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

package/services/utils/configuration/settings.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { isEmpty, pick, pipe, propOr } = require('lodash/fp');
+const { isSortable, getDefaultMainField } = require('./attributes');
+
+/** General settings */
+const DEFAULT_SETTINGS = {
+  bulkable: true,
+  filterable: true,
+  searchable: true,
+  pageSize: 10,
+};
+
+const settingsFields = [
+  'searchable',
+  'filterable',
+  'bulkable',
+  'pageSize',
+  'mainField',
+  'defaultSortBy',
+  'defaultSortOrder',
+];
+
+const getModelSettings = pipe([propOr({}, 'config.settings'), pick(settingsFields)]);
+
+module.exports = {
+  async createDefaultSettings(schema) {
+    const defaultField = getDefaultMainField(schema);
+
+    return {
+      ...DEFAULT_SETTINGS,
+      mainField: defaultField,
+      defaultSortBy: defaultField,
+      defaultSortOrder: 'ASC',
+      ...getModelSettings(schema),
+    };
+  },
+
+  async syncSettings(configuration, schema) {
+    if (isEmpty(configuration.settings)) return this.createDefaultSettings(schema);
+
+    const defaultField = getDefaultMainField(schema);
+
+    const { mainField = defaultField, defaultSortBy = defaultField } = configuration.settings || {};
+
+    return {
+      ...configuration.settings,
+      mainField: isSortable(schema, mainField) ? mainField : defaultField,
+      defaultSortBy: isSortable(schema, defaultSortBy) ? defaultSortBy : defaultField,
+    };
+  },
+};

package/services/utils/store.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const _ = require('lodash');
+
+const keys = {
+  CONFIGURATION: 'configuration',
+};
+
+const getStore = () => {
+  return strapi.store({
+    environment: '',
+    type: 'plugin',
+    name: 'content_manager',
+  });
+};
+
+/** Model configuration */
+const EMPTY_CONFIG = {
+  settings: {},
+  metadatas: {},
+  layouts: {},
+};
+
+const configurationKey = key => `${keys.CONFIGURATION}_${key}`;
+
+const getModelConfiguration = async key => {
+  const config = await getStore().get({ key: configurationKey(key) });
+  return _.merge({}, EMPTY_CONFIG, config);
+};
+
+const setModelConfiguration = async (key, value) => {
+  const storedConfig = (await getStore().get({ key: configurationKey(key) })) || {};
+  const currentConfig = { ...storedConfig };
+  Object.keys(value).forEach(key => {
+    if (value[key] !== null && value[key] !== undefined) {
+      _.set(currentConfig, key, value[key]);
+    }
+  });
+
+  if (!_.isEqual(currentConfig, storedConfig)) {
+    return getStore().set({
+      key: configurationKey(key),
+      value: currentConfig,
+    });
+  }
+};
+
+const deleteKey = key => {
+  return strapi.query('core_store').delete({ key: `plugin_content_manager_configuration_${key}` });
+};
+
+function findByKeyQuery({ model }, key) {
+  if (model.orm === 'mongoose') {
+    return model
+      .find({
+        key: { $regex: `${key}.*` },
+      })
+      .then(results => results.map(({ value }) => JSON.parse(value)));
+  }
+
+  return model
+    .query(qb => {
+      qb.where('key', 'like', `${key}%`);
+    })
+    .fetchAll()
+    .then(config => config && config.toJSON())
+    .then(results => results.map(({ value }) => JSON.parse(value)));
+}
+
+const findByKey = key => strapi.query('core_store').custom(findByKeyQuery)(key);
+const moveKey = (oldKey, newKey) => {
+  return strapi.query('core_store').update(
+    {
+      key: `plugin_content_manager_configuration_${oldKey}`,
+    },
+    {
+      key: `plugin_content_manager_configuration_${newKey}`,
+    }
+  );
+};
+
+const getAllConfigurations = () => findByKey('plugin_content_manager_configuration');
+
+module.exports = {
+  getAllConfigurations,
+  findByKey,
+  getModelConfiguration,
+  setModelConfiguration,
+
+  deleteKey,
+  moveKey,
+  keys,
+};

package/utils/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { prop } = require('lodash/fp');
+const wrapBadRequest = require('./wrap-bad-request');
+const pickWritableAttributes = require('./pick-writable-attributes');
+
+// retrieve a local service
+const getService = name => {
+  return prop(`content-manager.services.${name}`, strapi.plugins);
+};
+
+module.exports = {
+  getService,
+  wrapBadRequest,
+  pickWritableAttributes,
+};

package/utils/pick-writable-attributes.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const { omit } = require('lodash/fp');
+const { getNonWritableAttributes } = require('@akemona-org/strapi-utils').contentTypes;
+
+module.exports = (model) => omit(getNonWritableAttributes(strapi.getModel(model)));

package/utils/wrap-bad-request.js

@@ -0,0 +1,15 @@
+'use strict';
+
+module.exports = fn => async (...args) => {
+  try {
+    await fn(...args);
+  } catch (error) {
+    if (strapi.errors.isBoom(error)) {
+      throw error;
+    }
+
+    // these are errors like unique constraints
+    strapi.log.error(error);
+    throw strapi.errors.badRequest('Invalid input data. Please verify unique constraints');
+  }
+};

package/validation/policies/hasPermissions.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { yup, formatYupErrors } = require('@akemona-org/strapi-utils');
+
+const hasPermissionsSchema = yup.array().of(yup.string());
+
+const validateHasPermissionsInput = (actions) => {
+  try {
+    return hasPermissionsSchema.validateSync(actions, { strict: true, abortEarly: true });
+  } catch (e) {
+    throw new Error(formatYupErrors(e));
+  }
+};
+
+module.exports = {
+  validateHasPermissionsInput,
+};