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

package/services/permission.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const { prop } = require('lodash/fp');
+const { contentTypes: contentTypesUtils } = require('@akemona-org/strapi-utils');
+const { getService } = require('../utils');
+
+module.exports = {
+  canConfigureContentType({ userAbility, contentType }) {
+    const action = contentTypesUtils.isSingleType(contentType)
+      ? 'plugins::content-manager.single-types.configure-view'
+      : 'plugins::content-manager.collection-types.configure-view';
+
+    return userAbility.can(action);
+  },
+
+  async registerPermissions() {
+    const displayedContentTypes = getService('content-types').findDisplayedContentTypes();
+
+    const contentTypesUids = displayedContentTypes.map(prop('uid'));
+
+    const draftAndPublishContentTypesUids = displayedContentTypes
+      .filter(contentTypesUtils.hasDraftAndPublish)
+      .map(prop('uid'));
+
+    const actions = [
+      {
+        section: 'contentTypes',
+        displayName: 'Create',
+        uid: 'explorer.create',
+        pluginName: 'content-manager',
+        subjects: contentTypesUids,
+        options: {
+          applyToProperties: ['fields'],
+        },
+      },
+      {
+        section: 'contentTypes',
+        displayName: 'Read',
+        uid: 'explorer.read',
+        pluginName: 'content-manager',
+        subjects: contentTypesUids,
+        options: {
+          applyToProperties: ['fields'],
+        },
+      },
+      {
+        section: 'contentTypes',
+        displayName: 'Update',
+        uid: 'explorer.update',
+        pluginName: 'content-manager',
+        subjects: contentTypesUids,
+        options: {
+          applyToProperties: ['fields'],
+        },
+      },
+      {
+        section: 'contentTypes',
+        displayName: 'Delete',
+        uid: 'explorer.delete',
+        pluginName: 'content-manager',
+        subjects: contentTypesUids,
+      },
+      {
+        section: 'contentTypes',
+        displayName: 'Publish',
+        uid: 'explorer.publish',
+        pluginName: 'content-manager',
+        subjects: draftAndPublishContentTypesUids,
+      },
+      {
+        section: 'plugins',
+        displayName: 'Configure view',
+        uid: 'single-types.configure-view',
+        subCategory: 'single types',
+        pluginName: 'content-manager',
+      },
+      {
+        section: 'plugins',
+        displayName: 'Configure view',
+        uid: 'collection-types.configure-view',
+        subCategory: 'collection types',
+        pluginName: 'content-manager',
+      },
+      {
+        section: 'plugins',
+        displayName: 'Configure Layout',
+        uid: 'components.configure-layout',
+        subCategory: 'components',
+        pluginName: 'content-manager',
+      },
+    ];
+
+    await strapi.admin.services.permission.actionProvider.registerMany(actions);
+  },
+};

package/services/uid.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const _ = require('lodash');
+const slugify = require('@sindresorhus/slugify');
+
+module.exports = {
+  async generateUIDField({ contentTypeUID, field, data }) {
+    const contentType = strapi.contentTypes[contentTypeUID];
+    const { attributes } = contentType;
+
+    const { targetField, default: defaultValue, options } = attributes[field];
+    const targetValue = _.get(data, targetField);
+
+    if (!_.isEmpty(targetValue)) {
+      return this.findUniqueUID({
+        contentTypeUID,
+        field,
+        value: slugify(targetValue, options),
+      });
+    }
+
+    return this.findUniqueUID({
+      contentTypeUID,
+      field,
+      value: slugify(defaultValue || contentType.modelName, options),
+    });
+  },
+
+  async findUniqueUID({ contentTypeUID, field, value }) {
+    const query = strapi.db.query(contentTypeUID);
+
+    const possibleColisions = await query
+      .find({
+        [`${field}_contains`]: value,
+        _limit: -1,
+      })
+      .then(results => results.map(result => result[field]));
+
+    if (possibleColisions.length === 0) {
+      return value;
+    }
+
+    let i = 1;
+    let tmpUId = `${value}-${i}`;
+    while (possibleColisions.includes(tmpUId)) {
+      i += 1;
+      tmpUId = `${value}-${i}`;
+    }
+
+    return tmpUId;
+  },
+
+  async checkUIDAvailability({ contentTypeUID, field, value }) {
+    const query = strapi.db.query(contentTypeUID);
+
+    const count = await query.count({
+      [field]: value,
+    });
+
+    if (count > 0) return false;
+    return true;
+  },
+};

package/services/utils/configuration/attributes.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const _ = require('lodash');
+const { contentTypes: contentTypesUtils } = require('@akemona-org/strapi-utils');
+
+const { PUBLISHED_AT_ATTRIBUTE } = contentTypesUtils.constants;
+
+const NON_SORTABLES = ['component', 'json', 'media', 'richtext', 'dynamiczone'];
+const SORTABLE_RELATIONS = ['oneWay', 'oneToOne', 'manyToOne'];
+
+const NON_LISTABLES = ['component', 'json', 'password', 'richtext', 'dynamiczone'];
+const LISTABLE_RELATIONS = [
+  'oneWay',
+  'oneToOne',
+  'oneToMany',
+  'manyToOne',
+  'manyToMany',
+  'manyWay',
+];
+
+// hidden fields are fields that are configured to be hidden from list, and edit views
+const isHidden = (schema, name) => {
+  if (!_.has(schema.attributes, name)) {
+    return false;
+  }
+
+  const isHidden = _.get(schema, ['config', 'attributes', name, 'hidden'], false);
+  if (isHidden === true) {
+    return true;
+  }
+
+  return false;
+};
+
+const isListable = (schema, name) => {
+  if (!_.has(schema.attributes, name)) {
+    return false;
+  }
+
+  if (isHidden(schema, name)) {
+    return false;
+  }
+
+  const attribute = schema.attributes[name];
+  if (NON_LISTABLES.includes(attribute.type)) {
+    return false;
+  }
+
+  if (isRelation(attribute) && !LISTABLE_RELATIONS.includes(attribute.relationType)) {
+    return false;
+  }
+
+  return true;
+};
+
+const isSortable = (schema, name) => {
+  if (!_.has(schema.attributes, name)) {
+    return false;
+  }
+
+  if (schema.modelType === 'component' && name === 'id') return false;
+
+  const attribute = schema.attributes[name];
+  if (NON_SORTABLES.includes(attribute.type)) {
+    return false;
+  }
+
+  if (isRelation(attribute) && !SORTABLE_RELATIONS.includes(attribute.relationType)) {
+    return false;
+  }
+
+  return true;
+};
+
+const isSearchable = (schema, name) => {
+  return isSortable(schema, name);
+};
+
+const isVisible = (schema, name) => {
+  if (!_.has(schema.attributes, name)) {
+    return false;
+  }
+
+  if (isHidden(schema, name)) {
+    return false;
+  }
+
+  if (isTimestamp(schema, name) || name === 'id') {
+    return false;
+  }
+
+  if (isPublicationField(name)) {
+    return false;
+  }
+
+  return true;
+};
+
+const isPublicationField = (name) => {
+  return PUBLISHED_AT_ATTRIBUTE === name;
+};
+
+const isTimestamp = (schema, name) => {
+  if (!_.has(schema.attributes, name)) {
+    return false;
+  }
+
+  const timestampsOpt = _.get(schema, ['options', 'timestamps']);
+  if (!timestampsOpt || !Array.isArray(timestampsOpt)) {
+    return false;
+  }
+
+  if (timestampsOpt.includes(name)) {
+    return true;
+  }
+};
+
+const isRelation = (attribute) => attribute.type === 'relation';
+
+const hasRelationAttribute = (schema, name) => {
+  if (!_.has(schema.attributes, name)) {
+    return false;
+  }
+
+  if (isHidden(schema, name)) {
+    return false;
+  }
+
+  if (!isVisible(schema, name)) {
+    return false;
+  }
+
+  return isRelation(schema.attributes[name]);
+};
+
+const hasEditableAttribute = (schema, name) => {
+  if (!_.has(schema.attributes, name)) {
+    return false;
+  }
+
+  if (isHidden(schema, name)) {
+    return false;
+  }
+
+  if (!isVisible(schema, name)) {
+    return false;
+  }
+
+  if (isRelation(schema.attributes[name])) {
+    if (schema.modelType === 'component') return true;
+    return false;
+  }
+
+  return true;
+};
+
+const findFirstStringAttribute = (schema) => {
+  return Object.keys(schema.attributes || {}).find((key) => {
+    const { type } = schema.attributes[key];
+    return type === 'string' && key !== 'id';
+  });
+};
+
+const getDefaultMainField = (schema) => findFirstStringAttribute(schema) || 'id';
+
+module.exports = {
+  isSortable,
+  isVisible,
+  isSearchable,
+  isRelation,
+  isListable,
+  hasEditableAttribute,
+  hasRelationAttribute,
+  getDefaultMainField,
+};

package/services/utils/configuration/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { createModelConfigurationSchema } = require('../../../controllers/validation');
+const { createDefaultSettings, syncSettings } = require('./settings');
+const { createDefaultMetadatas, syncMetadatas } = require('./metadatas');
+const { createDefaultLayouts, syncLayouts } = require('./layouts');
+
+async function validateCustomConfig(schema) {
+  try {
+    await createModelConfigurationSchema(schema, {
+      allowUndefined: true,
+    }).validate(schema.config);
+  } catch (error) {
+    throw new Error(
+      `Invalid Model configuration for model ${schema.uid}. Verify your {{modelName}}.config.js(on) file:\n  - ${error.message}\n`
+    );
+  }
+}
+
+async function createDefaultConfiguration(schema) {
+  await validateCustomConfig(schema);
+
+  return {
+    settings: await createDefaultSettings(schema),
+    metadatas: await createDefaultMetadatas(schema),
+    layouts: await createDefaultLayouts(schema),
+  };
+}
+
+async function syncConfiguration(conf, schema) {
+  await validateCustomConfig(schema);
+
+  return {
+    settings: await syncSettings(conf, schema),
+    layouts: await syncLayouts(conf, schema),
+    metadatas: await syncMetadatas(conf, schema),
+  };
+}
+
+module.exports = {
+  createDefaultConfiguration,
+  syncConfiguration,
+};

package/services/utils/configuration/layouts.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const _ = require('lodash');
+const {
+  isListable,
+  hasEditableAttribute,
+  hasRelationAttribute,
+} = require('./attributes');
+
+const DEFAULT_LIST_LENGTH = 4;
+const MAX_ROW_SIZE = 12;
+
+const typeToSize = type => {
+  switch (type) {
+    case 'checkbox':
+    case 'boolean':
+    case 'date':
+    case 'time':
+    case 'biginteger':
+    case 'decimal':
+    case 'float':
+    case 'integer':
+    case 'number':
+      return MAX_ROW_SIZE / 3;
+    case 'json':
+    case 'component':
+    case 'richtext':
+    case 'dynamiczone':
+      return MAX_ROW_SIZE;
+
+    default:
+      return MAX_ROW_SIZE / 2;
+  }
+};
+
+async function createDefaultLayouts(schema) {
+  return {
+    list: createDefaultListLayout(schema),
+    editRelations: createDefaultEditRelationsLayout(schema),
+    edit: createDefaultEditLayout(schema),
+    ..._.pick(_.get(schema, ['config', 'layouts'], {}), [
+      'list',
+      'edit',
+      'editRelations',
+    ]),
+  };
+}
+
+function createDefaultListLayout(schema) {
+  return Object.keys(schema.attributes)
+    .filter(name => isListable(schema, name))
+    .slice(0, DEFAULT_LIST_LENGTH);
+}
+
+function createDefaultEditRelationsLayout(schema) {
+  if (schema.modelType === 'component') return [];
+
+  return Object.keys(schema.attributes).filter(name =>
+    hasRelationAttribute(schema, name)
+  );
+}
+
+const rowSize = els => els.reduce((sum, el) => sum + el.size, 0);
+
+function createDefaultEditLayout(schema) {
+  const keys = Object.keys(schema.attributes).filter(name =>
+    hasEditableAttribute(schema, name)
+  );
+
+  return appendToEditLayout([], keys, schema);
+}
+
+/** Synchronisation functions */
+
+function syncLayouts(configuration, schema) {
+  if (_.isEmpty(configuration.layouts)) return createDefaultLayouts(schema);
+
+  const { list = [], editRelations = [], edit = [] } =
+    configuration.layouts || {};
+
+  let cleanList = list.filter(attr => isListable(schema, attr));
+
+  let cleanEditRelations = editRelations.filter(attr =>
+    hasRelationAttribute(schema, attr)
+  );
+
+  let elementsToReAppend = [];
+  let cleanEdit = [];
+  for (let row of edit) {
+    let newRow = [];
+
+    for (let el of row) {
+      if (!hasEditableAttribute(schema, el.name)) continue;
+
+      // if size of the element has changed (type changes)
+      if (typeToSize(schema.attributes[el.name].type) !== el.size) {
+        elementsToReAppend.push(el.name);
+        continue;
+      }
+
+      newRow.push(el);
+    }
+
+    if (newRow.length > 0) {
+      cleanEdit.push(newRow);
+    }
+  }
+
+  cleanEdit = appendToEditLayout(cleanEdit, elementsToReAppend, schema);
+
+  const newAttributes = _.difference(
+    Object.keys(schema.attributes),
+    Object.keys(configuration.metadatas)
+  );
+
+  /** Add new attributes where they belong */
+
+  if (cleanList.length < DEFAULT_LIST_LENGTH) {
+    // add newAttributes
+    // only add valid listable attributes
+    cleanList = _.uniq(
+      cleanList
+        .concat(newAttributes.filter(key => isListable(schema, key)))
+        .slice(0, DEFAULT_LIST_LENGTH)
+    );
+  }
+
+  // add new relations to layout
+  if (schema.modelType !== 'component') {
+    const newRelations = newAttributes.filter(key =>
+      hasRelationAttribute(schema, key)
+    );
+
+    cleanEditRelations = _.uniq(cleanEditRelations.concat(newRelations));
+  }
+
+  // add new attributes to edit view
+  const newEditAttributes = newAttributes.filter(key =>
+    hasEditableAttribute(schema, key)
+  );
+
+  cleanEdit = appendToEditLayout(cleanEdit, newEditAttributes, schema);
+
+  return {
+    list: cleanList.length > 0 ? cleanList : createDefaultListLayout(schema),
+    edit: cleanEdit.length > 0 ? cleanEdit : createDefaultEditLayout(schema),
+    editRelations:
+      cleanEditRelations.length > 0
+        ? cleanEditRelations
+        : createDefaultEditRelationsLayout(schema),
+  };
+}
+
+const appendToEditLayout = (layout = [], keysToAppend, schema) => {
+  if (keysToAppend.length === 0) return layout;
+  let currentRowIndex = Math.max(layout.length - 1, 0);
+
+  // init currentRow if necessary
+  if (!layout[currentRowIndex]) {
+    layout[currentRowIndex] = [];
+  }
+
+  for (let key of keysToAppend) {
+    const attribute = schema.attributes[key];
+    const attributeSize = typeToSize(attribute.type);
+    let currenRowSize = rowSize(layout[currentRowIndex]);
+
+    if (currenRowSize + attributeSize > MAX_ROW_SIZE) {
+      currentRowIndex += 1;
+      layout[currentRowIndex] = [];
+    }
+
+    layout[currentRowIndex].push({
+      name: key,
+      size: attributeSize,
+    });
+  }
+
+  return layout;
+};
+
+module.exports = {
+  createDefaultLayouts,
+  syncLayouts,
+};

package/services/utils/configuration/metadatas.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const _ = require('lodash');
+const { getService } = require('../../../utils');
+const {
+  isSortable,
+  isSearchable,
+  isVisible,
+  isRelation,
+  getDefaultMainField,
+} = require('./attributes');
+
+function createDefaultMetadatas(schema) {
+  return {
+    ...Object.keys(schema.attributes).reduce((acc, name) => {
+      acc[name] = createDefaultMetadata(schema, name);
+      return acc;
+    }, {}),
+    id: {
+      edit: {},
+      list: {
+        label: 'Id',
+        searchable: true,
+        sortable: true,
+      },
+    },
+  };
+}
+
+function createDefaultMetadata(schema, name) {
+  const edit = {
+    label: _.upperFirst(name),
+    description: '',
+    placeholder: '',
+    visible: isVisible(schema, name),
+    editable: true,
+  };
+
+  if (isRelation(schema.attributes[name])) {
+    const { targetModel } = schema.attributes[name];
+
+    const targetSchema = getTargetSchema(targetModel);
+
+    if (targetSchema) {
+      edit.mainField = getDefaultMainField(targetSchema);
+    }
+  }
+
+  _.assign(
+    edit,
+    _.pick(_.get(schema, ['config', 'metadatas', name, 'edit'], {}), [
+      'label',
+      'description',
+      'placeholder',
+      'visible',
+      'editable',
+      'mainField',
+    ])
+  );
+
+  const list = {
+    label: _.upperFirst(name),
+    searchable: isSearchable(schema, name),
+    sortable: isSortable(schema, name),
+    ..._.pick(_.get(schema, ['config', 'metadatas', name, 'list'], {}), [
+      'label',
+      'searchable',
+      'sortable',
+    ]),
+  };
+
+  return { edit, list };
+}
+
+/** Synchronisation functions */
+
+async function syncMetadatas(configuration, schema) {
+  // clear all keys that do not exist anymore
+  if (_.isEmpty(configuration.metadatas)) {
+    return createDefaultMetadatas(schema);
+  }
+
+  // remove old keys
+  const metasWithValidKeys = _.pick(configuration.metadatas, Object.keys(schema.attributes));
+
+  // add new keys and missing fields
+  const metasWithDefaults = _.merge({}, createDefaultMetadatas(schema), metasWithValidKeys);
+
+  // clear the invalid mainFields
+  const updatedMetas = Object.keys(metasWithDefaults).reduce((acc, key) => {
+    const { edit, list } = metasWithDefaults[key];
+    const attr = schema.attributes[key];
+
+    let updatedMeta = { edit, list };
+    // update sortable attr
+    if (list.sortable && !isSortable(schema, key)) {
+      _.set(updatedMeta, ['list', 'sortable'], false);
+      _.set(acc, [key], updatedMeta);
+    }
+
+    if (list.searchable && !isSearchable(schema, key)) {
+      _.set(updatedMeta, ['list', 'searchable'], false);
+      _.set(acc, [key], updatedMeta);
+    }
+
+    if (!_.has(edit, 'mainField')) return acc;
+
+    // remove mainField if the attribute is not a relation anymore
+    if (!isRelation(attr)) {
+      _.set(updatedMeta, 'edit', _.omit(edit, ['mainField']));
+      _.set(acc, [key], updatedMeta);
+      return acc;
+    }
+
+    // if the mainField is id you can keep it
+    if (edit.mainField === 'id') return acc;
+
+    // check the mainField in the targetModel
+    const targetSchema = getTargetSchema(attr.targetModel);
+
+    if (!targetSchema) return acc;
+
+    if (!isSortable(targetSchema, edit.mainField)) {
+      _.set(updatedMeta, ['edit', 'mainField'], getDefaultMainField(targetSchema));
+      _.set(acc, [key], updatedMeta);
+      return acc;
+    }
+
+    return acc;
+  }, {});
+
+  return _.assign(metasWithDefaults, updatedMetas);
+}
+
+const getTargetSchema = targetModel => {
+  return getService('content-types').findContentType(targetModel);
+};
+
+module.exports = {
+  createDefaultMetadatas,
+  syncMetadatas,
+};