@akemona-org/strapi-plugin-content-manager 3.7.0

package/admin/src/utils/index.js

@@ -0,0 +1,17 @@
+export { default as checkIfAttributeIsDisplayable } from './checkIfAttributeIsDisplayable';
+export { default as createDefaultForm } from './createDefaultForm';
+export { default as dateFormats } from './dateFormats';
+export { default as formatFiltersFromQuery } from './formatFiltersFromQuery';
+export { default as formatFiltersToQuery } from './formatFiltersToQuery';
+export { default as formatLayoutToApi } from './formatLayoutToApi';
+export { default as generatePermissionsObject } from './generatePermissionsObject';
+export { default as getDisplayedValue } from './getDisplayedValue';
+export { default as getFieldName } from './getFieldName';
+export { default as getInjectedComponents } from './getComponents';
+export { default as getMaxTempKey } from './getMaxTempKey';
+export { default as getRequestUrl } from './getRequestUrl';
+export { default as getTrad } from './getTrad';
+export { default as ItemTypes } from './ItemTypes';
+export { default as mergeMetasWithSchema } from './mergeMetasWithSchema';
+export { default as removeKeyInObject } from './removeKeyInObject';
+export { default as removePasswordFieldsFromData } from './removePasswordFieldsFromData';

package/admin/src/utils/mergeMetasWithSchema.js

@@ -0,0 +1,20 @@
+import { set } from 'lodash';
+
+const mergeMetasWithSchema = (data, schemas, mainSchemaKey) => {
+  const findSchema = refUid => schemas.find(obj => obj.uid === refUid);
+  const merged = Object.assign({}, data);
+  const mainUID = data[mainSchemaKey].uid;
+  const mainSchema = findSchema(mainUID);
+
+  set(merged, [mainSchemaKey], { ...data[mainSchemaKey], ...mainSchema });
+
+  Object.keys(data.components).forEach(compoUID => {
+    const compoSchema = findSchema(compoUID);
+
+    set(merged, ['components', compoUID], { ...data.components[compoUID], ...compoSchema });
+  });
+
+  return merged;
+};
+
+export default mergeMetasWithSchema;

package/admin/src/utils/removeKeyInObject.js

@@ -0,0 +1,45 @@
+const removeKeyInObject = (obj, keyToRemove) => {
+  if (!obj) {
+    return obj;
+  }
+
+  return Object.keys(obj).reduce((acc, current) => {
+    const value = acc[current];
+
+    if (value === null) {
+      return acc;
+    }
+
+    if (Array.isArray(value)) {
+      if (Array.isArray(acc)) {
+        acc[current] = removeKeyInObject(value, keyToRemove);
+
+        return acc;
+      }
+
+      return { ...acc, [current]: value.map(obj => removeKeyInObject(obj, keyToRemove)) };
+    }
+
+    if (typeof value === 'object') {
+      if (value._isAMomentObject === true) {
+        return { ...acc, [current]: value };
+      }
+
+      if (Array.isArray(acc)) {
+        acc[current] = removeKeyInObject(value, keyToRemove);
+
+        return acc;
+      }
+
+      return { ...acc, [current]: removeKeyInObject(value, keyToRemove) };
+    }
+
+    if (current === keyToRemove) {
+      delete acc[current];
+    }
+
+    return acc;
+  }, obj);
+};
+
+export default removeKeyInObject;

package/admin/src/utils/removePasswordFieldsFromData.js

@@ -0,0 +1,54 @@
+import { get } from 'lodash';
+import { getType, getOtherInfos } from 'strapi-helper-plugin';
+
+const removePasswordFieldsFromData = (data, contentTypeSchema, componentSchema) => {
+  const recursiveCleanData = (data, schema) => {
+    return Object.keys(data).reduce((acc, current) => {
+      const attrType = getType(schema, current);
+      const value = get(data, current);
+      const component = getOtherInfos(schema, [current, 'component']);
+      const isRepeatable = getOtherInfos(schema, [current, 'repeatable']);
+
+      if (attrType === 'dynamiczone') {
+        acc[current] = value.map(componentValue => {
+          const subCleanedData = recursiveCleanData(
+            componentValue,
+            componentSchema[componentValue.__component]
+          );
+
+          return subCleanedData;
+        });
+
+        return acc;
+      }
+
+      if (attrType === 'component') {
+        if (isRepeatable) {
+          /* eslint-disable indent */
+          acc[current] = value
+            ? value.map(compoData => {
+                const subCleanedData = recursiveCleanData(compoData, componentSchema[component]);
+
+                return subCleanedData;
+              })
+            : value;
+          /* eslint-enable indent */
+        } else {
+          acc[current] = value ? recursiveCleanData(value, componentSchema[component]) : value;
+        }
+
+        return acc;
+      }
+
+      if (attrType !== 'password') {
+        acc[current] = value;
+      }
+
+      return acc;
+    }, {});
+  };
+
+  return recursiveCleanData(data, contentTypeSchema);
+};
+
+export default removePasswordFieldsFromData;

package/config/admin.json

@@ -0,0 +1,5 @@
+{
+  "admin": {
+    "schema": {}
+  }
+}

package/config/functions/bootstrap.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { getService } = require('../../utils');
+
+module.exports = async () => {
+  await getService('components').syncConfigurations();
+  await getService('content-types').syncConfigurations();
+  await getService('permission').registerPermissions();
+};

package/config/policies/has-draft-and-publish.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const {
+  contentTypes: { hasDraftAndPublish },
+} = require('@akemona-org/strapi-utils');
+
+module.exports = (ctx, next) => {
+  const {
+    params: { model: modelUid },
+  } = ctx;
+
+  const model = strapi.contentTypes[modelUid];
+
+  if (!hasDraftAndPublish(model)) {
+    throw strapi.errors.forbidden();
+  }
+
+  return next();
+};

package/config/policies/hasPermissions.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const {
+  policy: { createPolicyFactory },
+} = require('@akemona-org/strapi-utils');
+const { validateHasPermissionsInput } = require('../../validation/policies/hasPermissions');
+
+module.exports = createPolicyFactory(
+  (actions, { hasAtLeastOne = false } = {}) =>
+    (ctx, next) => {
+      const {
+        state: { userAbility, isAuthenticatedAdmin },
+        params: { model },
+      } = ctx;
+
+      if (!isAuthenticatedAdmin || !userAbility) {
+        return next();
+      }
+
+      const isAuthorized = hasAtLeastOne
+        ? actions.some((action) => userAbility.can(action, model))
+        : actions.every((action) => userAbility.can(action, model));
+
+      if (!isAuthorized) {
+        throw strapi.errors.forbidden();
+      }
+
+      return next();
+    },
+  {
+    validator: validateHasPermissionsInput,
+    name: 'plugins::content-manager.hasPermissions',
+  }
+);

package/config/policies/routing.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const _ = require('lodash');
+
+module.exports = async (ctx, next) => {
+  const { model } = ctx.params;
+
+  const ct = strapi.contentTypes[model];
+
+  if (!ct) {
+    return ctx.send({ error: 'contentType.notFound' }, 404);
+  }
+
+  const target = ct.plugin === 'admin' ? strapi.admin : strapi.plugins[ct.plugin];
+
+  const actionPath = ['config', 'layout', ct.modelName, 'actions', ctx.request.route.action];
+
+  if (_.has(target, actionPath)) {
+    const [controller, action] = _.get(target, actionPath, []).split('.');
+
+    if (controller && action) {
+      return await target.controllers[controller.toLowerCase()][action](ctx);
+    }
+  }
+
+  await next();
+};

package/config/routes.json

@@ -0,0 +1,275 @@
+{
+  "routes": [
+    {
+      "method": "GET",
+      "path": "/content-types",
+      "handler": "content-types.findContentTypes",
+      "config": {
+        "policies": []
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/content-types-settings",
+      "handler": "content-types.findContentTypesSettings",
+      "config": {
+        "policies": []
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/content-types/:uid/configuration",
+      "handler": "content-types.findContentTypeConfiguration",
+      "config": {
+        "policies": []
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/content-types/:uid/configuration",
+      "handler": "content-types.updateContentTypeConfiguration",
+      "config": {
+        "policies": ["admin::isAuthenticatedAdmin"]
+      }
+    },
+
+    {
+      "method": "GET",
+      "path": "/components",
+      "handler": "components.findComponents",
+      "config": {
+        "policies": []
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/components/:uid/configuration",
+      "handler": "components.findComponentConfiguration",
+      "config": {
+        "policies": []
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/components/:uid/configuration",
+      "handler": "components.updateComponentConfiguration",
+      "config": {
+        "policies": []
+      }
+    },
+
+    {
+      "method": "POST",
+      "path": "/uid/generate",
+      "handler": "uid.generateUID",
+      "config": {
+        "policies": []
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/uid/check-availability",
+      "handler": "uid.checkUIDAvailability",
+      "config": {
+        "policies": []
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/relations/:model/:targetField",
+      "handler": "relations.find",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          [
+            "plugins::content-manager.hasPermissions",
+            [
+              "plugins::content-manager.explorer.create",
+              "plugins::content-manager.explorer.update"
+            ],
+            { "hasAtLeastOne": true }
+          ]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/single-types/:model",
+      "handler": "single-types.find",
+      "config": {
+        "policies": [
+          "routing",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.read"]]
+        ]
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/single-types/:model",
+      "handler": "single-types.createOrUpdate",
+      "config": {
+        "policies": [
+          "routing",
+          "admin::isAuthenticatedAdmin",
+          [
+            "plugins::content-manager.hasPermissions",
+            [
+              "plugins::content-manager.explorer.create",
+              "plugins::content-manager.explorer.update"
+            ],
+            { "hasAtLeastOne": true }
+          ]
+        ]
+      }
+    },
+    {
+      "method": "DELETE",
+      "path": "/single-types/:model",
+      "handler": "single-types.delete",
+      "config": {
+        "policies": [
+          "routing",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.delete"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/single-types/:model/actions/publish",
+      "handler": "single-types.publish",
+      "config": {
+        "policies": [
+          "routing",
+          "plugins::content-manager.has-draft-and-publish",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.publish"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/single-types/:model/actions/unpublish",
+      "handler": "single-types.unpublish",
+      "config": {
+        "policies": [
+          "routing",
+          "plugins::content-manager.has-draft-and-publish",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.publish"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/collection-types/:model/:id/:targetField",
+      "handler": "collection-types.previewManyRelations",
+      "config": {
+        "policies": [
+          "routing",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.read"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/collection-types/:model",
+      "handler": "collection-types.find",
+      "config": {
+        "policies": [
+          "routing",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.read"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/collection-types/:model",
+      "handler": "collection-types.create",
+      "config": {
+        "policies": [
+          "routing",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.create"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/collection-types/:model/:id",
+      "handler": "collection-types.findOne",
+      "config": {
+        "policies": [
+          "routing",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.read"]]
+        ]
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/collection-types/:model/:id",
+      "handler": "collection-types.update",
+      "config": {
+        "policies": [
+          "routing",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.update"]]
+        ]
+      }
+    },
+    {
+      "method": "DELETE",
+      "path": "/collection-types/:model/:id",
+      "handler": "collection-types.delete",
+      "config": {
+        "policies": [
+          "routing",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.delete"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/collection-types/:model/:id/actions/publish",
+      "handler": "collection-types.publish",
+      "config": {
+        "policies": [
+          "routing",
+          "plugins::content-manager.has-draft-and-publish",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.publish"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/collection-types/:model/:id/actions/unpublish",
+      "handler": "collection-types.unpublish",
+      "config": {
+        "policies": [
+          "routing",
+          "plugins::content-manager.has-draft-and-publish",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.publish"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/collection-types/:model/actions/bulkDelete",
+      "handler": "collection-types.bulkDelete",
+      "config": {
+        "policies": [
+          "routing",
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::content-manager.explorer.delete"]]
+        ]
+      }
+    }
+  ]
+}