引导 Strapi 角色权限

Question

我是一名开发人员，第一次从事前端工作，strapi 和 javascript。我希望有人能可怜我，并提供一个如何通过 bootstrap.js 脚本设置 Public 角色权限的示例。 node.js v10.16.0
Strapi v3.0.0-next.11
Graphql 14.3.1
MongoDB: 3.6
全部在 Windows 10

在 Strapi UI 中，它是 Public 角色的角色和权限
_{（来源：strapi.io）}

我想将这些框设置为选中
_{（来源：strapi.io）}

另一位开发人员使用 bootstrap.js 文件将项目添加到我们创建的服务（菜单）中。我不知道如何 return 甚至是有关角色权限的最基本信息。我的函数称为 test() 我搜索了示例，我发现最好的是在 Whosebug 上： Strapi Plugin Route Default Permission :

strapi.plugins['users-permissions'].models.role.find

但我不知道如何使用它:

WORKING
function add_widgets_from_sheet(sheet_name, model_object){
  console.log(`adding ${sheet_name}`)
  let xlsxSheet = Sheets[sheet_name]
  const widgets = XLSX.utils.sheet_to_json(xlsxSheet)

  widgets.forEach(function (widget) {
    //See if the object is already in the db before adding it
    model_object.count(widget)
      .then(result => {
        if (result == 0) {
          console.log('Adding '+sheet_name+': ' + JSON.stringify(widget))
          return model_object.add(widget)
        }
      })
  })
}

NOT WORKING
function test(){
  console.log(`Testing ${strapi.plugins['users-permissions'].models.role.find}`)
}

module.exports = next => {

  console.log('Starting Strapi bootstrap')
  add_widgets_from_sheet('Menus', strapi.services.menu) //adding menus
  test() // Returning nothing
  console.log('Ending Strapi bootstrap')
  next()
}

我想将这些复选框切换为 TRUE、CHECKED 或任何名称。这样我们就不必在每次转储数据库时都通过 UI 手动完成。

我从例子中学习得最好...我希望你能有所帮助。谢谢！

Answer 1

所以下面的代码来自一个名为 PROJECT/STRAPI/config/functions/bootstrap.js 的文件这会使用我们保存在 excel 电子表格中的信息自动创建内容类型和内容。但是为了使用这些内容类型，必须激活一些角色和权限，以便网络 ui 可以访问它们。基本上，我们不想手动进入 Strapi UI 来创建您的用户、创建内容类型、创建内容或更新权限。我们想要一个脚本来完成所有这些。

'use strict'

我们的环境变量

require('dotenv').config({ path:'../.env' })

Excel保存我们数据的电子表格（附上）

const XLSX = require('xlsx')
const BOOTSTRAP_DATA = XLSX.readFile(process.env.BOOTSTRAP_DATA).Sheets

从 .env 中提取的变量

const ADMIN_USERNAME = process.env.ADMIN_USERNAME
const ADMIN_PASSWORD = process.env.ADMIN_PASSWORD
const ADMIN_EMAIL    = process.env.ADMIN_EMAIL

正在阅读 XLSX

async function bootstrap_resource(resource_type, resource_service) {
  strapi.log.info(`Bootstrapping ${resource_type}`)

  const resources = XLSX.utils.sheet_to_json(BOOTSTRAP_DATA[resource_type])

  for (let resource of resources) {

    if (await resource_service.count(resource) === 0) {
      strapi.log.warn(`Bootstrapping ${resource_type}: ${JSON.stringify(resource)}`)

      await resource_service.create(resource)
    }
  }
}

正在为 strapi 创建初始用户

async function bootstrap_admin() {
  strapi.log.info(`Bootstrapping Admin`)

  const admin_orm = strapi.admin.queries('administrator', 'admin')

  const admins = await admin_orm.find({username: ADMIN_USERNAME})

  if ( admins.length === 0) {
    const blocked  = false
    const username = ADMIN_USERNAME
    const password = await strapi.admin.services.auth.hashPassword(ADMIN_PASSWORD)
    const email    = ADMIN_EMAIL
    const user     = { blocked, username, password, email }

    const data = await admin_orm.create(user)

    strapi.log.warn(`Bootstrapped Admin User: ${JSON.stringify(user)}`)
  }
}

以下是get_roles() - required for get_permissions(), get_permissions()是required for enable_permissions() 这是我们打开这些内容类型的地方，以便网络 ui 可以看到它。

async function get_roles() {
  const role_orm = strapi.plugins['users-permissions'].queries('role', 'users-permissions')

  const role_list = await role_orm.find({}, [])

  const roles = {}

  for (let role of role_list) {
    roles[ role._id ] = role
    roles[ role.name ] = role
  }

  return roles
}

async function get_permissions( selected_role, selected_type, selected_controller ) {
  const roles          = await get_roles()
  const permission_orm = strapi.plugins['users-permissions'].queries('permission', 'users-permissions')

  let permission_list  = await permission_orm.find({_limit: 999}, [])

  if ( selected_role       ) permission_list = permission_list.filter( ({ role       }) => `${role}`       === `${roles[selected_role]._id}` )
  if ( selected_type       ) permission_list = permission_list.filter( ({ type       }) => `${type}`       === `${selected_type}`            )
  if ( selected_controller ) permission_list = permission_list.filter( ({ controller }) => `${controller}` === `${selected_controller}`      )

  return permission_list
}

async function enable_permissions(role, type, controller) {
  strapi.log.info(`Setting '${controller}' permissions for '${role}'`)

  const permission_orm = strapi.plugins['users-permissions'].queries('permission', 'users-permissions')

  const permissions = await get_permissions(role, type, controller)

  for (let { _id } of permissions) {
    permission_orm.update({ _id }, { enabled: true })
  }
}

最后，我们运行程序

module.exports = async next => {

  await bootstrap_admin()

  await bootstrap_resource( 'Clients', strapi.services.client )
  await bootstrap_resource( 'Menus',   strapi.services.menu   )

  enable_permissions('Public', 'application', 'client'     )
  enable_permissions('Public', 'application', 'github'     )
  enable_permissions('Public', 'application', 'menu'       )
  enable_permissions('Public', 'application', 'confluence' )

  next()
}

去掉我的评论，你就有了整个bootstrap.js文件。下图显示了用于填充所有内容的 demo.xlsx 工作簿的 3 个选项卡。

最后，展示结果。使用 Nuxt 的菜单（内容）、权限集和 public 网站。

Answer 2

我觉得这个更简单。

// In your bootstrap.js file
'use strict';
module.exports = async () => {

    const authenticated = await strapi.query('role', 'users-permissions').findOne({ type: 'authenticated' });
    authenticated.permissions.forEach(permission => {

        if (permission.type === 'application'){ // Whatever permissions you want to change
            let newPermission = permission;
            newPermission.enabled = true; // Editing permission as needed

            strapi.query('permission', 'users-permissions').update( { id: newPermission.id }, newPermission ); // Updating Strapi with the permission
        }
    });
    return;
};

Answer 3

在前面两个答案的基础上，您似乎可以通过一个循环摆脱困境，因为您可以为 public 和 authenticated 用户设置权限。

这是针对 strapi 3.2.4 编写的，我使用的是 NodeJS 12，因此可以使用展开运算符 ... 之类的东西。

  const permOrm = strapi.query('permission', 'users-permissions')
  const perms = await permOrm.find({ type: 'application' })
  for (const curr of perms) {
    if (curr.role.type === 'authenticated') {
      strapi.log.info(
        `Allowing authenticated to call ${curr.controller}.${curr.action}`,
      )
      permOrm.update({ id: curr.id }, { ...curr, enabled: true })
      continue
    }
    // permission is for public
    const isReadEndpoint = ['find', 'findone', 'count'].includes(curr.action)
    if (isReadEndpoint) {
      strapi.log.info(
        `Allowing public to call ${curr.controller}.${curr.action}`,
      )
      permOrm.update({ id: curr.id }, { ...curr, enabled: true })
      continue
    }
    // TODO add custom logic for any non-standard actions here
    strapi.log.info(
      `Disallowing public from calling ${curr.controller}.${curr.action}`,
    )
    permOrm.update({ id: curr.id }, { ...curr, enabled: false })
  }

Answer 4

对于 strapi 3.3.x 和可能的未来版本
稍微高效的方式（一次查询角色，使用查询过滤权限）

'use strict';

module.exports = async () => {
  const publicRole = await getRoleByName('Public')
  await grantPermissions(publicRole, 'application', 'images', ['upload', 'remove'])  // upload, remove in 'images' controller
  await grantPermissions(publicRole, 'application', 'project') // any action in 'project' controller                      
};

async function getRoleByName(name) {
  return strapi.query('role', 'users-permissions').findOne({ name }, [])
}

async function getPermissions(role, permissionType, controller, actions = null) {
  const permissionQuery = strapi.query('permission', 'users-permissions')
  const permissionRequest = {
    _limit: 1000,
    role: role.id,
    type: permissionType,
    controller: controller
  }

  if (actions) {
    permissionRequest.action_in = Array.isArray(actions) ? actions : [actions]
  }

  return permissionQuery.find(permissionRequest, [])
}

async function grantPermissions(role, permissionType, controller, actions) {
  if (actions && !Array.isArray(actions)) {
    actions = [ actions ]
  }
  strapi.log.info(`Setting '${controller}' [${actions ? actions.join(', ') : '*'}] permissions for '${role.name}'`)

  const permissionQuery = strapi.query('permission', 'users-permissions')
  const permissions = await getPermissions(role, permissionType, controller, actions)
  if (permissions.length === 0) {
    throw new Error(`Error enabling permissions: ${role.name}, ${permissionType}, ${controller}, ${actions}`)
  }

  for (const { id } of permissions) {
    await permissionQuery.update({ id }, { enabled: true })
  }
}

引导 Strapi 角色权限

Bootstraping Strapi Role Permissions

javascript

node.js

graphql

strapi