Начальная загрузка разрешений роли Strapi

Итак, приведенный ниже код взят из файла PROJECT/STRAPI/config/functions/bootstrap.js. Это автоматизирует создание типов контента и контента с информацией, которую мы храним в электронной таблице Excel. Но для того, чтобы использовать эти типы контента, необходимо активировать роли и разрешения, чтобы веб-интерфейс мог получить к ним доступ. По сути, мы не хотим вручную заходить в пользовательский интерфейс Strapi, чтобы создать пользователя, создать типы контента, создать контент или обновить разрешения. Мы хотим, чтобы сценарий делал все это.

'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)
    }
  }
}

Создание начального ПОЛЬЗОВАТЕЛЯ для страпи

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() — требуется для get_permissions(), и get_permissions() требуется для enable_permissions(). Здесь мы включаем эти типы контента, чтобы веб-интерфейс мог их видеть.

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. На изображениях ниже показаны 3 вкладки рабочей книги demo.xlsx, которая используется для заполнения всего.

Наконец, показ результатов. Меню (контент), набор разрешений и общедоступный веб-сайт с использованием Nuxt.

Я нахожу это проще.

// 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;
};

Основываясь на обоих предыдущих ответах, кажется, что вы можете обойтись одним циклом, в котором вы можете установить разрешения как для пользователей public, так и для пользователей authenticated.

Это было написано для страпи 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 })
  }

Для страпи 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 })
  }
}