@akemona-org/strapi-admin 3.7.0

package/admin/src/components/Roles/Permissions/init.js

@@ -0,0 +1,41 @@
+import createDefaultCTFormFromLayout from './utils/createDefaultCTFormFromLayout';
+import createDefaultPluginsFormFromLayout from './utils/createDefaultPluginsFormFromLayout';
+import formatLayoutForSettingsAndPlugins from './utils/formatLayoutForSettingsAndPlugins';
+
+const init = (layout, permissions) => {
+  const {
+    conditions,
+    sections: { collectionTypes, singleTypes, plugins, settings },
+  } = layout;
+
+  const layouts = {
+    collectionTypes,
+    singleTypes,
+    plugins: formatLayoutForSettingsAndPlugins(plugins, 'plugin'),
+    settings: formatLayoutForSettingsAndPlugins(settings, 'category'),
+  };
+  const defaultForm = {
+    collectionTypes: createDefaultCTFormFromLayout(
+      collectionTypes,
+      collectionTypes.actions || [],
+      conditions,
+      permissions
+    ),
+    singleTypes: createDefaultCTFormFromLayout(
+      singleTypes,
+      singleTypes.actions || [],
+      conditions,
+      permissions
+    ),
+    plugins: createDefaultPluginsFormFromLayout(layouts.plugins, conditions, permissions),
+    settings: createDefaultPluginsFormFromLayout(layouts.settings, conditions, permissions),
+  };
+
+  return {
+    initialData: defaultForm,
+    modifiedData: defaultForm,
+    layouts,
+  };
+};
+
+export default init;

package/admin/src/components/Roles/Permissions/reducer.js

@@ -0,0 +1,177 @@
+import produce from 'immer';
+import { cloneDeep, has, isObject, get, set } from 'lodash';
+import updateConditionsToFalse from './utils/updateConditionsToFalse';
+import updateValues from './utils/updateValues';
+
+const initialState = {
+  initialData: {},
+  modifiedData: {},
+  layouts: {},
+};
+
+/* eslint-disable consistent-return */
+const reducer = (state, action) =>
+  produce(state, draftState => {
+    switch (action.type) {
+      // This action is called when a checkbox in the <GlobalActions />
+      // changes
+      case 'ON_CHANGE_COLLECTION_TYPE_GLOBAL_ACTION_CHECKBOX': {
+        const { collectionTypeKind, actionId, value } = action;
+        const pathToData = ['modifiedData', collectionTypeKind];
+
+        Object.keys(get(state, pathToData)).forEach(collectionType => {
+          const collectionTypeActionData = get(
+            state,
+            [...pathToData, collectionType, actionId],
+            undefined
+          );
+
+          if (collectionTypeActionData) {
+            let updatedValues = updateValues(collectionTypeActionData, value);
+
+            // We need to remove the applied conditions
+            if (!value && updatedValues.conditions) {
+              const updatedConditions = updateValues(updatedValues.conditions, false);
+
+              updatedValues = { ...updatedValues, conditions: updatedConditions };
+            }
+
+            set(draftState, [...pathToData, collectionType, actionId], updatedValues);
+          }
+        });
+
+        break;
+      }
+      case 'ON_CHANGE_COLLECTION_TYPE_ROW_LEFT_CHECKBOX': {
+        const { pathToCollectionType, propertyName, rowName, value } = action;
+        let nextModifiedDataState = cloneDeep(state.modifiedData);
+        const pathToModifiedDataCollectionType = pathToCollectionType.split('..');
+
+        const objToUpdate = get(nextModifiedDataState, pathToModifiedDataCollectionType, {});
+
+        Object.keys(objToUpdate).forEach(actionId => {
+          // When a ct has multiple properties (ex: locales, field)
+          // We need to make sure that we add any new property to the modifiedData
+          // object.
+          if (has(objToUpdate[actionId], `properties.${propertyName}`)) {
+            const objValue = get(objToUpdate, [actionId, 'properties', propertyName, rowName]);
+            const pathToDataToSet = [
+              ...pathToModifiedDataCollectionType,
+              actionId,
+              'properties',
+              propertyName,
+              rowName,
+            ];
+
+            if (!isObject(objValue)) {
+              set(nextModifiedDataState, pathToDataToSet, value);
+            } else {
+              const updatedValue = updateValues(objValue, value);
+
+              set(nextModifiedDataState, pathToDataToSet, updatedValue);
+            }
+          }
+        });
+
+        // When we uncheck a row, we need to check if we also need to disable the conditions
+        if (!value) {
+          nextModifiedDataState = updateConditionsToFalse(nextModifiedDataState);
+        }
+
+        set(draftState, 'modifiedData', nextModifiedDataState);
+
+        break;
+      }
+      case 'ON_CHANGE_CONDITIONS': {
+        Object.entries(action.conditions).forEach(array => {
+          const [stringPathToData, conditionsToUpdate] = array;
+
+          set(
+            draftState,
+            ['modifiedData', ...stringPathToData.split('..'), 'conditions'],
+            conditionsToUpdate
+          );
+        });
+
+        break;
+      }
+      case 'ON_CHANGE_SIMPLE_CHECKBOX': {
+        let nextModifiedDataState = cloneDeep(state.modifiedData);
+
+        set(nextModifiedDataState, [...action.keys.split('..')], action.value);
+
+        // When we uncheck a single checkbox we need to remove the conditions from the parent
+        if (!action.value) {
+          nextModifiedDataState = updateConditionsToFalse(nextModifiedDataState);
+        }
+
+        set(draftState, 'modifiedData', nextModifiedDataState);
+
+        break;
+      }
+      /*
+       * Here the idea is to retrieve a specific value of the modifiedObject
+       * then update all the boolean values of the retrieved one
+       * and update the drafState.
+       *
+       * For instance in order to enable create action for all the fields and locales
+       * of the restaurant content type we need to :
+       * 1. Retrieve the modifiedData.collectionTypes.restaurant.create object
+       * 2. Toggle all the end boolean values to the desired one
+       * 3. Update the draftState
+       *
+       * Since the case works well in order to update what we called "parent" checkbox. We can
+       * reuse the action when we need to toggle change all the values that depends on this one.
+       * A parent checkbox is a checkbox which value is not a boolean but depends on its children ones, therefore,
+       * a parent checkbox does not have a represented value in the draftState, they are just helpers.
+       *
+       * Given the following data:
+       *
+       * const data = {
+       *  restaurant: {
+       *   create: {
+       *     fields: { name: true },
+       *     locales: { en: false }
+       *   }
+       *  }
+       * }
+       *
+       * The value of the create checkbox for the restaurant will be ƒalse since not all its children have
+       * truthy values and in order to set its value to true when need to have all the values of its children set to true.
+       *
+       * Similarly, we can reuse the logic for the components attributes
+       *
+       */
+      case 'ON_CHANGE_TOGGLE_PARENT_CHECKBOX': {
+        const { keys, value } = action;
+        const pathToValue = [...keys.split('..')];
+        let nextModifiedDataState = cloneDeep(state.modifiedData);
+        const oldValues = get(nextModifiedDataState, pathToValue, {});
+
+        const updatedValues = updateValues(oldValues, value);
+        set(nextModifiedDataState, pathToValue, updatedValues);
+
+        // When we uncheck a parent checkbox we need to remove the associated conditions
+        if (!value) {
+          nextModifiedDataState = updateConditionsToFalse(nextModifiedDataState);
+        }
+
+        set(draftState, ['modifiedData'], nextModifiedDataState);
+
+        break;
+      }
+      case 'RESET_FORM': {
+        draftState.modifiedData = state.initialData;
+        break;
+      }
+      case 'SET_FORM_AFTER_SUBMIT': {
+        draftState.initialData = state.modifiedData;
+        break;
+      }
+      default:
+        return draftState;
+    }
+  });
+
+export default reducer;
+export { initialState };

package/admin/src/components/Roles/Permissions/utils/createDefaultCTFormFromLayout.js

@@ -0,0 +1,178 @@
+import { merge, get, isEmpty, set } from 'lodash';
+import findMatchingPermission from './findMatchingPermissions';
+/**
+ * Creates the default condition form: { [conditionId]: false }
+ * @param {object} conditions.id Id of the condition
+ * @returns {object}
+ */
+const createDefaultConditionsForm = (conditions, initialConditions = []) =>
+  conditions.reduce((acc, current) => {
+    acc[current.id] = initialConditions.indexOf(current.id) !== -1;
+
+    return acc;
+  }, {});
+
+/**
+ * Create the default form a property (fields, locales) with all the values
+ * set to false
+ * @param {object} property.children ex: {children: [{value: 'foo',}]}
+ * @param {array<string>} The found property values retrieved from the role associated permissions
+ * @returns {object} ex: { foo: false }
+ *
+ */
+const createDefaultPropertyForms = ({ children }, propertyValues, prefix = '') => {
+  return children.reduce((acc, current) => {
+    if (current.children) {
+      return {
+        ...acc,
+        [current.value]: createDefaultPropertyForms(
+          current,
+          propertyValues,
+          `${prefix}${current.value}.`
+        ),
+      };
+    }
+
+    const hasProperty = propertyValues.indexOf(`${prefix}${current.value}`) !== -1;
+
+    acc[current.value] = hasProperty;
+
+    return acc;
+  }, {});
+};
+
+/**
+ * Creates the default form for all the properties found in a content type's layout
+ * @param {array<string>} propertiesArray ex; ['fields', 'locales']
+ * @param {object} ctLayout layout of the content type ex:
+ * ctLayout = {
+ *  properties: [{
+ *    value: 'fields',
+ *    children: [{value: 'name'}]
+ *  }
+ * }
+ * @returns {object} In this case it will return { fields: { name: false } }
+ */
+const createDefaultPropertiesForm = (propertiesArray, ctLayout, matchingPermission) => {
+  return propertiesArray.reduce(
+    (acc, currentPropertyName) => {
+      const foundProperty = ctLayout.properties.find(({ value }) => value === currentPropertyName);
+
+      if (foundProperty) {
+        const matchingPermissionPropertyValues = get(
+          matchingPermission,
+          ['properties', foundProperty.value],
+          []
+        );
+        const propertyForm = createDefaultPropertyForms(
+          foundProperty,
+          matchingPermissionPropertyValues
+        );
+
+        acc.properties[currentPropertyName] = propertyForm;
+      }
+
+      return acc;
+    },
+    { properties: {} }
+  );
+};
+
+/**
+ * Return an object of content types layout of an action's subject ex: { adress: {uid, label, properties } }
+ * @param {array<object>} allLayouts All the content types' layout
+ * @param {object} subjects
+ */
+const findLayouts = (allLayouts, subjects) => {
+  return subjects.reduce((acc, current) => {
+    const foundLayout = allLayouts.find(({ uid }) => uid === current) || null;
+
+    if (foundLayout) {
+      acc[current] = foundLayout;
+    }
+
+    return acc;
+  }, {});
+};
+
+/**
+ * Creates the default for for a content type
+ * @param {object} layout.subjects All the content types to display
+ * @param {array<object>} actionArray An action has the following shape:
+ * action = {label: 'string', actionId: 'string', subjects: [object], applyToProperties: ['string]}
+ * @param {array<object>} conditionArray Ex: { id: 'string', category: 'string' }
+ * @returns {object} Ex:
+ * {
+ *  ctUId: {
+ *    [actionId]: {
+ *      [propertyName]: { enabled: false, conditions: { [id]: false } }
+ *    }
+ *  }
+ * }
+ */
+const createDefaultCTFormFromLayout = (
+  { subjects },
+  actionArray,
+  conditionArray,
+  initialPermissions = []
+) => {
+  return actionArray.reduce((defaultForm, current) => {
+    const actionSubjects = current.subjects;
+
+    const subjectLayouts = findLayouts(subjects, actionSubjects);
+
+    // This can happen when an action is not related to a content type
+    // for instance the D&P permission is applied only with the cts that
+    // have the D&P features enabled
+    if (isEmpty(subjectLayouts)) {
+      return defaultForm;
+    }
+
+    // The object has the following shape: { [ctUID]: { [actionId]: { [property]: { enabled: false } } } }
+    const contentTypesActions = Object.keys(subjectLayouts).reduce((acc, currentCTUID) => {
+      const { actionId, applyToProperties } = current;
+      const currentSubjectLayout = subjectLayouts[currentCTUID];
+      const properties = currentSubjectLayout.properties.map(({ value }) => value);
+      const doesNothaveProperty = properties.every(
+        property => (applyToProperties || []).indexOf(property) === -1
+      );
+
+      const matchingPermission = findMatchingPermission(initialPermissions, actionId, currentCTUID);
+      const conditionsForm = createDefaultConditionsForm(
+        conditionArray,
+        get(matchingPermission, 'conditions', [])
+      );
+
+      if (isEmpty(applyToProperties) || doesNothaveProperty) {
+        set(acc, [currentCTUID, actionId], {
+          properties: {
+            enabled: matchingPermission !== undefined,
+          },
+          conditions: conditionsForm,
+        });
+
+        return acc;
+      }
+
+      const propertiesForm = createDefaultPropertiesForm(
+        applyToProperties,
+        subjectLayouts[currentCTUID],
+        matchingPermission
+      );
+
+      set(acc, [currentCTUID, actionId], { ...propertiesForm, conditions: conditionsForm });
+
+      return acc;
+    }, {});
+
+    return merge(defaultForm, contentTypesActions);
+  }, {});
+};
+
+export default createDefaultCTFormFromLayout;
+export {
+  createDefaultConditionsForm,
+  createDefaultPropertyForms,
+  createDefaultPropertiesForm,
+  findLayouts,
+};

package/admin/src/components/Roles/Permissions/utils/createDefaultPluginsFormFromLayout.js

@@ -0,0 +1,49 @@
+import { get } from 'lodash';
+import { createDefaultConditionsForm } from './createDefaultCTFormFromLayout';
+import findMatchingPermission from './findMatchingPermissions';
+
+const createSubCategoryForm = (actions, conditions, permissions) => {
+  return actions.reduce((acc, current) => {
+    const foundMatchingPermission = findMatchingPermission(permissions, current.action, null);
+
+    acc[current.action] = {
+      properties: {
+        enabled: foundMatchingPermission !== undefined,
+      },
+      conditions: createDefaultConditionsForm(
+        conditions,
+        get(foundMatchingPermission, 'conditions', [])
+      ),
+    };
+
+    return acc;
+  }, {});
+};
+
+const createChildrenDefaultForm = (childrenForm, conditions, initialPermissions) => {
+  return childrenForm.reduce((acc, current) => {
+    acc[current.subCategoryId] = createSubCategoryForm(
+      current.actions,
+      conditions,
+      initialPermissions
+    );
+
+    return acc;
+  }, {});
+};
+
+const createDefaultPluginsFormFromLayout = (pluginsLayout, conditions, initialPermissions = []) => {
+  return pluginsLayout.reduce((acc, { categoryId, childrenForm }) => {
+    const childrenDefaultForm = createChildrenDefaultForm(
+      childrenForm,
+      conditions,
+      initialPermissions
+    );
+    acc[categoryId] = childrenDefaultForm;
+
+    return acc;
+  }, {});
+};
+
+export default createDefaultPluginsFormFromLayout;
+export { createSubCategoryForm, createChildrenDefaultForm };

package/admin/src/components/Roles/Permissions/utils/findMatchingPermissions.js

@@ -0,0 +1,4 @@
+const findMatchingPermission = (permissions, action, subject) =>
+  permissions.find(perm => perm.action === action && perm.subject === subject);
+
+export default findMatchingPermission;

package/admin/src/components/Roles/Permissions/utils/formatContentTypesPermissionToAPI.js

@@ -0,0 +1,122 @@
+import { has, isObject } from 'lodash';
+import { createArrayOfValues } from '../../utils';
+import { createConditionsArray } from './formatSettingsPermissionsToAPI';
+
+/**
+ * Returns an array of property values
+ * @param {object} propertyValue
+ * @param {string} prefix
+ * @returns {array<string>}
+ */
+const createPropertyArray = (propertyValue, prefix = '') => {
+  return Object.entries(propertyValue).reduce((acc, current) => {
+    const [name, value] = current;
+
+    if (isObject(value)) {
+      return [...acc, ...createPropertyArray(value, `${prefix}${name}.`)];
+    }
+
+    if (value && !isObject(value)) {
+      acc.push(`${prefix}${name}`);
+    }
+
+    return acc;
+  }, []);
+};
+
+/**
+ *
+ * @param {string} action
+ * @param {string} subject
+ * @param {object} param2
+ * @config {object} conditions
+ * @config {object} the name of the properties array we need to fill
+ * @returns {object}
+ */
+const createPermissionWithProperties = (action, subject, { conditions, properties }) => {
+  return Object.entries(properties).reduce(
+    (acc, current) => {
+      const [propertyName, propertyValue] = current;
+
+      acc.properties[propertyName] = createPropertyArray(propertyValue);
+
+      return acc;
+    },
+    { action, subject, conditions: createConditionsArray(conditions), properties: {} }
+  );
+};
+
+/**
+ *
+ * @param {string} action The name of the action
+ * @param {string} subject The name of the subject
+ * @param {object} param2
+ * @returns {object}
+ */
+const createPermissionWithoutProperties = (action, subject, { conditions }) => {
+  return {
+    action,
+    subject,
+    properties: {},
+    conditions: createConditionsArray(conditions),
+  };
+};
+
+/**
+ *
+ * @param {string} subject  The name of the subject
+ * @param {object} actions The subject's actions
+ * @returns {array<object>}
+ */
+const createSubjectPermissions = (subject, actions) => {
+  const permissions = Object.entries(actions).reduce((acc, current) => {
+    const [actionName, permissions] = current;
+    const shouldCreatePermission = createArrayOfValues(permissions).some(val => val);
+
+    if (!shouldCreatePermission) {
+      return acc;
+    }
+
+    if (!has(permissions, 'properties.enabled')) {
+      const createdPermissionsArray = createPermissionWithProperties(
+        actionName,
+        subject,
+        permissions
+      );
+
+      return [...acc, createdPermissionsArray];
+    }
+
+    if (!permissions.properties.enabled) {
+      return acc;
+    }
+
+    const permission = createPermissionWithoutProperties(actionName, subject, permissions);
+
+    acc.push(permission);
+
+    return acc;
+  }, []);
+
+  return permissions;
+};
+
+/**
+ *
+ * @param {object} contentTypesPermissions
+ * @returns {array<object>}
+ */
+const formatContentTypesPermissionToAPI = contentTypesPermissions => {
+  const permissions = Object.entries(contentTypesPermissions).reduce((allPermissions, current) => {
+    const [subject, currentSubjectActions] = current;
+
+    const permissions = createSubjectPermissions(subject, currentSubjectActions);
+
+    return [...allPermissions, ...permissions];
+  }, []);
+
+  return permissions;
+};
+
+export default formatContentTypesPermissionToAPI;
+export { createPropertyArray, createPermissionWithProperties };

package/admin/src/components/Roles/Permissions/utils/formatLayoutForSettingsAndPlugins.js

@@ -0,0 +1,23 @@
+import { chain } from 'lodash';
+
+const replaceName = name => name.split(' ').join('-');
+
+const formatLayout = (layout, groupByKey) => {
+  return chain(layout)
+    .groupBy(groupByKey)
+    .map((item, itemName) => ({
+      category: itemName,
+      categoryId: replaceName(itemName),
+      childrenForm: chain(item)
+        .groupBy('subCategory')
+        .map((actions, subCategoryName) => ({
+          subCategoryName,
+          subCategoryId: replaceName(subCategoryName),
+          actions,
+        }))
+        .value(),
+    }))
+    .value();
+};
+
+export default formatLayout;

package/admin/src/components/Roles/Permissions/utils/formatPermissionsToAPI.js

@@ -0,0 +1,21 @@
+import formatContentTypesPermissionToAPI from './formatContentTypesPermissionToAPI';
+import formatSettingsPermissionsToAPI from './formatSettingsPermissionsToAPI';
+
+const formatPermissionsToAPI = modifiedData => {
+  const pluginsPermissions = formatSettingsPermissionsToAPI(modifiedData.plugins);
+  const settingsPermissions = formatSettingsPermissionsToAPI(modifiedData.settings);
+  const collectionTypesPermissions = formatContentTypesPermissionToAPI(
+    modifiedData.collectionTypes
+  );
+
+  const singleTypesPermissions = formatContentTypesPermissionToAPI(modifiedData.singleTypes);
+
+  return [
+    ...pluginsPermissions,
+    ...settingsPermissions,
+    ...collectionTypesPermissions,
+    ...singleTypesPermissions,
+  ];
+};
+
+export default formatPermissionsToAPI;

package/admin/src/components/Roles/Permissions/utils/formatSettingsPermissionsToAPI.js

@@ -0,0 +1,59 @@
+/**
+ * Returns an array of condition names when a condition is enabled
+ * @param {object} conditions
+ * @config {boolean}
+ */
+const createConditionsArray = conditions => {
+  return Object.entries(conditions)
+    .filter(([, conditionValue]) => {
+      return conditionValue;
+    })
+    .map(([conditionName]) => conditionName);
+};
+
+const createPermission = array => {
+  const [actionName, { conditions }] = array;
+
+  return {
+    action: actionName,
+    subject: null,
+    conditions: createConditionsArray(conditions),
+    properties: {},
+  };
+};
+
+const createPermissionsArrayFromCategory = categoryPermissions => {
+  return Object.values(categoryPermissions).reduce((acc, current) => {
+    const permissions = Object.entries(current).reduce((acc1, current1) => {
+      const [
+        ,
+        {
+          properties: { enabled },
+        },
+      ] = current1;
+
+      if (!enabled) {
+        return acc1;
+      }
+
+      const permission = createPermission(current1);
+
+      acc1.push(permission);
+
+      return acc1;
+    }, []);
+
+    return [...acc, ...permissions];
+  }, []);
+};
+
+const formatSettingsPermissionsToAPI = settingsPermissionsObject => {
+  return Object.values(settingsPermissionsObject).reduce((acc, current) => {
+    const currentCategoryPermissions = createPermissionsArrayFromCategory(current);
+
+    return [...acc, ...currentCategoryPermissions];
+  }, []);
+};
+
+export default formatSettingsPermissionsToAPI;
+export { createConditionsArray, createPermission, createPermissionsArrayFromCategory };