mirror of
https://github.com/strapi/strapi.git
synced 2025-07-22 16:37:13 +00:00
731 lines
24 KiB
JavaScript
731 lines
24 KiB
JavaScript
'use strict';
|
|
|
|
const _ = require('lodash');
|
|
// const pluralize = require('pluralize');
|
|
// const {
|
|
// getApis,
|
|
// getApisKeys,
|
|
// getApisUploadRelations,
|
|
// getEditDisplayAvailableFieldsPath,
|
|
// getEditDisplayDisplayedField,
|
|
// getEditDisplayFieldsPath,
|
|
// } = require('./utils/getters');
|
|
// const splitted = str => str.split('.');
|
|
// const pickData = model =>
|
|
// _.pick(model, [
|
|
// 'info',
|
|
// 'connection',
|
|
// 'collectionName',
|
|
// 'attributes',
|
|
// 'identity',
|
|
// 'globalId',
|
|
// 'globalName',
|
|
// 'orm',
|
|
// 'options',
|
|
// 'loadedModel',
|
|
// 'primaryKey',
|
|
// 'associations',
|
|
// ]);
|
|
|
|
function getContentManagerKeys({ model }, key) {
|
|
if (model.orm === 'mongoose') {
|
|
return model
|
|
.find({
|
|
$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)));
|
|
}
|
|
|
|
async function updateGroups() {
|
|
const service = strapi.plugins['content-manager'].services.groups;
|
|
|
|
const configurations = await strapi
|
|
.query('core_store')
|
|
.custom(getContentManagerKeys)(
|
|
'plugin_content_manager_configuration_groups'
|
|
);
|
|
|
|
const realUIDs = Object.keys(strapi.groups);
|
|
const DBUIDs = configurations.map(({ uid }) => uid);
|
|
const groupsToUpdate = _.intersection(realUIDs, DBUIDs);
|
|
const groupsToAdd = _.difference(realUIDs, DBUIDs);
|
|
const groupsToDelete = _.difference(DBUIDs, realUIDs);
|
|
|
|
await Promise.all(
|
|
groupsToDelete.map(uid => service.deleteConfiguration(uid))
|
|
);
|
|
|
|
const generateNewConfiguration = async uid => {
|
|
return service.setConfiguration(
|
|
uid,
|
|
await buildDefaultConfiguration(strapi.groups[uid])
|
|
);
|
|
};
|
|
|
|
await Promise.all(groupsToAdd.map(uid => generateNewConfiguration(uid)));
|
|
|
|
const updateConfiguration = async uid => {
|
|
const conf = configurations.find(conf => conf.uid === uid);
|
|
const model = strapi.groups[uid];
|
|
return service.setConfiguration(uid, {
|
|
settings: await updateSettings(conf, model),
|
|
layouts: updateLayouts(conf, model),
|
|
metadatas: updateMetadatas(conf, model),
|
|
});
|
|
};
|
|
|
|
await Promise.all(groupsToUpdate.map(uid => updateConfiguration(uid)));
|
|
}
|
|
|
|
async function buildDefaultSettings() {
|
|
const generalSettings = await strapi.plugins[
|
|
'content-manager'
|
|
].services.generalsettings.getGeneralSettings();
|
|
|
|
return {
|
|
...generalSettings,
|
|
mainField: 'id',
|
|
defaultSortBy: 'id',
|
|
defaultSortOrder: 'ASC',
|
|
};
|
|
}
|
|
|
|
async function buildDefaultMetadata(name, attr) {
|
|
return {
|
|
edit: {
|
|
mainField: !_.has(attr, 'type') ? 'id' : undefined,
|
|
label: name,
|
|
description: '',
|
|
visible: true,
|
|
editable: true,
|
|
},
|
|
list: {
|
|
label: name,
|
|
searchable: true,
|
|
sortable: true,
|
|
},
|
|
};
|
|
}
|
|
|
|
async function buildDefaultMetadatas(model) {
|
|
return {
|
|
id: {
|
|
edit: {},
|
|
list: {
|
|
label: 'Id',
|
|
searchable: true,
|
|
sortable: true,
|
|
},
|
|
},
|
|
...Object.keys(model.allAttributes).reduce((acc, name) => {
|
|
acc[name] = buildDefaultMetadata(name, model.allAttributes[name]);
|
|
return acc;
|
|
}, {}),
|
|
};
|
|
}
|
|
|
|
function buildDefaultLayouts(model) {
|
|
return {
|
|
list: ['id'].concat(
|
|
Object.keys(model.allAttributes)
|
|
.filter(name => hasReadableAttribute(model, name))
|
|
.slice(0, 3)
|
|
),
|
|
editRelations: Object.keys(model.allAttributes).filter(name => {
|
|
const attr = model.allAttributes[name];
|
|
return !_.has(attr, 'type');
|
|
}),
|
|
edit: [],
|
|
};
|
|
}
|
|
|
|
async function buildDefaultConfiguration(model) {
|
|
return {
|
|
settings: await buildDefaultSettings(),
|
|
metadatas: buildDefaultMetadatas(model),
|
|
layouts: buildDefaultLayouts(model),
|
|
};
|
|
}
|
|
|
|
async function updateContentTypesScope(models, configurations, source) {
|
|
const service = strapi.plugins['content-manager'].services.contenttypes;
|
|
|
|
const realUIDs = Object.keys(models);
|
|
const DBUIDs = configurations.map(({ uid }) => uid);
|
|
const contentTypesToUpdate = _.intersection(realUIDs, DBUIDs);
|
|
const contentTypesToAdd = _.difference(realUIDs, DBUIDs);
|
|
const contentTypesToDelete = _.difference(DBUIDs, realUIDs);
|
|
|
|
await Promise.all(
|
|
contentTypesToDelete.map(uid =>
|
|
service.deleteContentTypeConfiguration({ uid, source })
|
|
)
|
|
);
|
|
|
|
const generateNewConfiguration = async uid => {
|
|
return service.setContentTypeConfiguration(
|
|
{ uid, source },
|
|
await buildDefaultConfiguration(models[uid])
|
|
);
|
|
};
|
|
|
|
await Promise.all(
|
|
contentTypesToAdd.map(uid => generateNewConfiguration(uid))
|
|
);
|
|
|
|
await Promise.all(contentTypesToUpdate.map(uid => {}));
|
|
}
|
|
|
|
async function updateContentTypes() {
|
|
const configurations = await strapi
|
|
.query('core_store')
|
|
.custom(getContentManagerKeys)(
|
|
'plugin_content_manager_configuration_content_types'
|
|
);
|
|
|
|
await updateContentTypesScope(
|
|
_.omit(strapi.models, ['core_store']),
|
|
configurations.filter(({ source }) => !source)
|
|
);
|
|
await updateContentTypesScope(
|
|
strapi.admin.models,
|
|
configurations.filter(({ source }) => source === 'admin'),
|
|
'admin'
|
|
);
|
|
|
|
await Promise.all(
|
|
Object.keys(strapi.plugins).map(pluginKey => {
|
|
const plugin = strapi.plugins[pluginKey];
|
|
return updateContentTypesScope(
|
|
plugin.models || {},
|
|
configurations.filter(({ source }) => source === pluginKey),
|
|
pluginKey
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
function updateMetadatas(configuration, model) {
|
|
// clear all keys that do not exist anymore
|
|
if (_.isEmpty(configuration.metadatas)) return buildDefaultMetadatas(model);
|
|
|
|
// remove old keys
|
|
const metasWithValidKeys = _.pick(
|
|
configuration.metadatas,
|
|
['id'].concat(Object.keys(model.allAttributes))
|
|
);
|
|
|
|
const metasWithDefaults = _.merge(
|
|
buildDefaultMetadatas(model),
|
|
metasWithValidKeys
|
|
);
|
|
|
|
// clear the invalid mainFields
|
|
const updatedMetas = Object.keys(metasWithDefaults).reduce((acc, key) => {
|
|
const meta = metasWithDefaults[key];
|
|
if (!_.has(meta, 'mainField')) return acc;
|
|
|
|
// remove mainField if the attribute is not a relation anymore
|
|
if (_.has(model.allAttributes[key], 'type')) {
|
|
acc[key] = _.omit(meta, 'mainField');
|
|
return acc;
|
|
}
|
|
|
|
// if the mainField is id you can keep it
|
|
if (meta.mainField === 'id') return acc;
|
|
|
|
// check the mainField in the targetModel
|
|
const attr = model.allAttributes[key];
|
|
const target = strapi.getModel(attr.model || attr.collection, attr.plugin);
|
|
|
|
if (!hasReadableAttribute(target, meta.mainField)) {
|
|
acc[key] = {
|
|
...meta,
|
|
mainField: 'id',
|
|
};
|
|
return acc;
|
|
}
|
|
return acc;
|
|
}, {});
|
|
|
|
return _.merge(metasWithDefaults, updatedMetas);
|
|
}
|
|
|
|
async function updateSettings(configuration, model) {
|
|
if (_.isEmpty(configuration.settings)) return buildDefaultSettings(model);
|
|
|
|
const { mainField = 'id', defaultSortBy = 'id' } = configuration.settings;
|
|
|
|
return {
|
|
...configuration.settings,
|
|
mainField: hasReadableAttribute(model, mainField) ? mainField : 'id',
|
|
defaultSortBy: hasReadableAttribute(model, defaultSortBy)
|
|
? defaultSortBy
|
|
: 'id',
|
|
};
|
|
}
|
|
|
|
function updateLayouts(configuration, model) {
|
|
if (_.isEmpty(configuration.layouts)) return buildDefaultLayouts(model);
|
|
return {
|
|
...configuration.layouts,
|
|
};
|
|
}
|
|
|
|
const hasReadableAttribute = (model, attr) => {
|
|
if (attr === 'id') return true;
|
|
|
|
if (!_.has(model.allAttributes, attr)) {
|
|
return false;
|
|
}
|
|
|
|
if (!_.has(model.allAttributes[attr], 'type')) {
|
|
return false;
|
|
}
|
|
|
|
if (['group', 'json', 'array'].includes(model.allAttributes[attr].type)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
async function bootstrap() {
|
|
await updateGroups();
|
|
await updateContentTypes();
|
|
}
|
|
|
|
module.exports = cb => {
|
|
bootstrap().then(() => cb(), err => cb(err));
|
|
};
|
|
|
|
/* eslint-disable indent */
|
|
// module.exports = async cb => {
|
|
// // Retrieve all layout files from the plugins config folder
|
|
// const pluginsLayout = Object.keys(strapi.plugins).reduce((acc, current) => {
|
|
// const models = _.get(strapi.plugins, [current, 'config', 'layout'], {});
|
|
// Object.keys(models).forEach(model => {
|
|
// const layout = _.get(strapi.plugins, [current, 'config', 'layout', model], {});
|
|
// acc[model] = layout;
|
|
// });
|
|
|
|
// return acc;
|
|
// }, {});
|
|
|
|
// // Retrieve the administrator layout
|
|
// const administratorLayout = _.get(strapi.admin, 'config.layout.administrator', {});
|
|
|
|
// // Remove the core_store layout since it is not needed
|
|
// // And create a temporay one
|
|
// const tempLayout = Object.keys(strapi.models)
|
|
// .filter(m => m !== 'core_store')
|
|
// .reduce((acc, current) => {
|
|
// acc[current] = { attributes: {} };
|
|
|
|
// return acc;
|
|
// }, _.merge(pluginsLayout, { administrator: administratorLayout }));
|
|
|
|
// const models = _.mapValues(strapi.models, pickData);
|
|
|
|
// delete models['core_store'];
|
|
|
|
// const adminModels = {
|
|
// admin: {
|
|
// models: _.mapValues(strapi.admin.models, pickData),
|
|
// },
|
|
// };
|
|
|
|
// const pluginsModel = Object.keys(strapi.plugins).reduce((acc, current) => {
|
|
// acc[current] = {
|
|
// models: _.mapValues(strapi.plugins[current].models, pickData),
|
|
// };
|
|
|
|
// return acc;
|
|
// }, adminModels);
|
|
|
|
// // Reference all current models
|
|
// const appModels = Object.keys(pluginsModel).reduce((acc, curr) => {
|
|
// const models = Object.keys(_.get(pluginsModel, [curr, 'models'], {}));
|
|
|
|
// return acc.concat(models);
|
|
// }, Object.keys(strapi.models).filter(m => m !== 'core_store'));
|
|
|
|
// // Init schema
|
|
// const schema = {
|
|
// generalSettings: {
|
|
// search: true,
|
|
// filters: true,
|
|
// bulkActions: true,
|
|
// pageEntries: 10,
|
|
// },
|
|
// models: {
|
|
// plugins: {},
|
|
// },
|
|
// layout: {},
|
|
// };
|
|
|
|
// // Populate the schema object
|
|
// const buildSchema = (model, name, plugin = false) => {
|
|
// // Model data
|
|
// const schemaModel = Object.assign(
|
|
// {
|
|
// label: _.upperFirst(name),
|
|
// labelPlural: _.upperFirst(pluralize(name)),
|
|
// orm: model.orm || 'mongoose',
|
|
// search: true,
|
|
// filters: true,
|
|
// bulkActions: true,
|
|
// pageEntries: 10,
|
|
// defaultSort: model.primaryKey,
|
|
// sort: 'ASC',
|
|
// options: model.options,
|
|
// editDisplay: {
|
|
// availableFields: {},
|
|
// displayedField: model.primaryKey,
|
|
// fields: [],
|
|
// relations: [],
|
|
// },
|
|
// },
|
|
// model,
|
|
// );
|
|
// const fieldsToRemove = [];
|
|
// // Fields (non relation)
|
|
// const fields = _.mapValues(
|
|
// _.pickBy(model.attributes, attribute => !attribute.model && !attribute.collection),
|
|
// (value, attribute) => {
|
|
// const fieldClassName = _.get(tempLayout, [name, 'attributes', attribute, 'className'], '');
|
|
|
|
// if (fieldClassName === 'd-none') {
|
|
// fieldsToRemove.push(attribute);
|
|
// }
|
|
|
|
// return {
|
|
// label: _.upperFirst(attribute),
|
|
// description: '',
|
|
// type: value.type || 'string',
|
|
// disabled: false,
|
|
// };
|
|
// },
|
|
// );
|
|
|
|
// // Don't display fields that are hidden by default like the resetPasswordToken for the model user
|
|
// fieldsToRemove.forEach(field => {
|
|
// _.unset(fields, field);
|
|
// });
|
|
// schemaModel.attributes = _.omit(schemaModel.attributes, fieldsToRemove);
|
|
|
|
// schemaModel.fields = fields;
|
|
// schemaModel.editDisplay.availableFields = fields;
|
|
|
|
// // Select fields displayed in list view
|
|
// schemaModel.listDisplay = Object.keys(schemaModel.fields)
|
|
// // Construct Array of attr ex { type: 'string', label: 'Foo', name: 'Foo', description: '' }
|
|
// .map(attr => {
|
|
// const attrType = schemaModel.fields[attr].type;
|
|
// const sortable = attrType !== 'json' && attrType !== 'array';
|
|
|
|
// return Object.assign(schemaModel.fields[attr], {
|
|
// name: attr,
|
|
// sortable,
|
|
// searchable: sortable,
|
|
// });
|
|
// })
|
|
// // Retrieve only the fourth first items
|
|
// .slice(0, 4);
|
|
|
|
// schemaModel.listDisplay.splice(0, 0, {
|
|
// name: model.primaryKey || 'id',
|
|
// label: 'Id',
|
|
// type: 'string',
|
|
// sortable: true,
|
|
// searchable: true,
|
|
// });
|
|
|
|
// // This object will be used to customise the label and description and so on of an input.
|
|
// // TODO: maybe add the customBootstrapClass in it;
|
|
// schemaModel.editDisplay.availableFields = Object.keys(schemaModel.fields).reduce((acc, current) => {
|
|
// acc[current] = Object.assign(
|
|
// _.pick(_.get(schemaModel, ['fields', current], {}), ['label', 'type', 'description', 'name']),
|
|
// {
|
|
// editable: ['updatedAt', 'createdAt', 'updated_at', 'created_at'].indexOf(current) === -1,
|
|
// placeholder: '',
|
|
// },
|
|
// );
|
|
|
|
// return acc;
|
|
// }, {});
|
|
|
|
// if (model.associations) {
|
|
// // Model relations
|
|
// schemaModel.relations = model.associations.reduce((acc, current) => {
|
|
// const label = _.upperFirst(current.alias);
|
|
// const displayedAttribute = current.plugin // Value to modified to custom what's displayed in the react-select
|
|
// ? _.get(pluginsModel, [current.plugin, 'models', current.model || current.collection, 'info', 'mainField']) ||
|
|
// _.findKey(
|
|
// _.get(pluginsModel, [current.plugin, 'models', current.model || current.collection, 'attributes']),
|
|
// { type: 'string' },
|
|
// ) ||
|
|
// 'id'
|
|
// : _.get(models, [current.model || current.collection, 'info', 'mainField']) ||
|
|
// _.findKey(_.get(models, [current.model || current.collection, 'attributes']), { type: 'string' }) ||
|
|
// 'id';
|
|
|
|
// acc[current.alias] = {
|
|
// ...current,
|
|
// description: '',
|
|
// label,
|
|
// displayedAttribute,
|
|
// };
|
|
|
|
// return acc;
|
|
// }, {});
|
|
// const relationsArray = Object.keys(schemaModel.relations).filter(relation => {
|
|
// const isUploadRelation = _.get(schemaModel, ['relations', relation, 'plugin'], '') === 'upload';
|
|
// const isMorphSide =
|
|
// _.get(schemaModel, ['relations', relation, 'nature'], '')
|
|
// .toLowerCase()
|
|
// .includes('morp') && _.get(schemaModel, ['relations', relation, relation]) !== undefined;
|
|
|
|
// return !isUploadRelation && !isMorphSide;
|
|
// });
|
|
|
|
// const uploadRelations = Object.keys(schemaModel.relations).reduce((acc, current) => {
|
|
// if (_.get(schemaModel, ['relations', current, 'plugin']) === 'upload') {
|
|
// const model = _.get(schemaModel, ['relations', current]);
|
|
|
|
// acc[current] = {
|
|
// description: '',
|
|
// editable: true,
|
|
// label: _.upperFirst(current),
|
|
// multiple: _.has(model, 'collection'),
|
|
// name: current,
|
|
// placeholder: '',
|
|
// type: 'file',
|
|
// disabled: false,
|
|
// };
|
|
// }
|
|
|
|
// return acc;
|
|
// }, {});
|
|
|
|
// schemaModel.editDisplay.availableFields = _.merge(schemaModel.editDisplay.availableFields, uploadRelations);
|
|
// schemaModel.editDisplay.relations = relationsArray;
|
|
// }
|
|
|
|
// schemaModel.editDisplay.fields = Object.keys(schemaModel.editDisplay.availableFields);
|
|
|
|
// if (plugin) {
|
|
// return _.set(schema.models.plugins, `${plugin}.${name}`, schemaModel);
|
|
// }
|
|
|
|
// // Set the formatted model to the schema
|
|
// schema.models[name] = schemaModel;
|
|
// };
|
|
|
|
// // For each plugin's apis populate the schema object with the needed infos
|
|
// _.forEach(pluginsModel, (plugin, pluginName) => {
|
|
// _.forEach(plugin.models, (model, name) => {
|
|
// buildSchema(model, name, pluginName);
|
|
// });
|
|
// });
|
|
|
|
// // Generate schema for models.
|
|
// _.forEach(models, (model, name) => {
|
|
// buildSchema(model, name);
|
|
// });
|
|
|
|
// const pluginStore = strapi.store({
|
|
// environment: '',
|
|
// type: 'plugin',
|
|
// name: 'content-manager',
|
|
// });
|
|
|
|
// try {
|
|
// // Retrieve the previous schema from the db
|
|
// const prevSchema = await pluginStore.get({ key: 'schema' });
|
|
|
|
// // If no schema stored
|
|
// if (!prevSchema) {
|
|
// _.set(schema, 'layout', tempLayout);
|
|
|
|
// pluginStore.set({ key: 'schema', value: schema });
|
|
|
|
// return cb();
|
|
// } else {
|
|
// const modelsLayout = Object.keys(_.get(prevSchema, 'layout', {}));
|
|
|
|
// // Remove previous model from the schema.layout
|
|
// // Usually needed when renaming a model
|
|
// modelsLayout.forEach(model => {
|
|
// if (!appModels.includes(model)) {
|
|
// _.unset(prevSchema, ['layout', model]);
|
|
// }
|
|
// });
|
|
// }
|
|
|
|
// // Here we do the difference between the previous schema from the database and the new one
|
|
|
|
// // Retrieve all the api path, it generates an array
|
|
// const prevSchemaApis = getApis(prevSchema.models);
|
|
// const schemaApis = getApis(schema.models);
|
|
|
|
// // Array of apis to add
|
|
// const apisToAdd = schemaApis.filter(api => prevSchemaApis.indexOf(api) === -1).map(splitted);
|
|
// // Array of apis to remove
|
|
// const apisToRemove = prevSchemaApis.filter(api => schemaApis.indexOf(api) === -1).map(splitted);
|
|
|
|
// // Retrieve the same apis by name
|
|
// const sameApis = schemaApis.filter(api => prevSchemaApis.indexOf(api) !== -1).map(splitted);
|
|
// // Retrieve all the field's path of the current unchanged api name
|
|
// const schemaSameApisKeys = _.flattenDeep(getApisKeys(schema, sameApis));
|
|
// // Retrieve all the field's path of the previous unchanged api name
|
|
// const prevSchemaSameApisKeys = _.flattenDeep(getApisKeys(prevSchema, sameApis));
|
|
// // Determine for the same api if we need to add some fields
|
|
// const sameApisAttrToAdd = schemaSameApisKeys
|
|
// .filter(attr => prevSchemaSameApisKeys.indexOf(attr) === -1)
|
|
// .map(splitted);
|
|
// // Special case for the relations
|
|
// const prevSchemaSameApisUploadRelations = _.flattenDeep(getApisUploadRelations(prevSchema, sameApis));
|
|
// const schemaSameApisUploadRelations = _.flattenDeep(getApisUploadRelations(schema, sameApis));
|
|
// const sameApisUploadRelationsToAdd = schemaSameApisUploadRelations
|
|
// .filter(attr => prevSchemaSameApisUploadRelations.indexOf(attr) === -1)
|
|
// .map(splitted);
|
|
// // Determine the fields to remove for the unchanged api name
|
|
// const sameApisAttrToRemove = prevSchemaSameApisKeys
|
|
// .filter(attr => schemaSameApisKeys.indexOf(attr) === -1)
|
|
// .map(splitted);
|
|
|
|
// // Remove api
|
|
// apisToRemove.map(apiPath => {
|
|
// _.unset(prevSchema.models, apiPath);
|
|
// });
|
|
|
|
// // Remove API attribute
|
|
// sameApisAttrToRemove.map(attrPath => {
|
|
// const editDisplayPath = getEditDisplayAvailableFieldsPath(attrPath);
|
|
// // Remove the field from the available fields in the editDisplayObject
|
|
// _.unset(prevSchema.models, editDisplayPath);
|
|
// // Check default sort and change it if needed
|
|
// _.unset(prevSchema.models, attrPath);
|
|
// // Retrieve the api path in the schema Object
|
|
// const apiPath = attrPath.length > 3 ? _.take(attrPath, 3) : _.take(attrPath, 1);
|
|
// // Retrieve the listDisplay path in the schema Object
|
|
// const listDisplayPath = apiPath.concat('listDisplay');
|
|
// const prevListDisplay = _.get(prevSchema.models, listDisplayPath);
|
|
// const defaultSortPath = apiPath.concat('defaultSort');
|
|
// const currentAttr = attrPath.slice(-1);
|
|
// const defaultSort = _.get(prevSchema.models, defaultSortPath);
|
|
// const displayedFieldPath = getEditDisplayDisplayedField(attrPath);
|
|
// const displayedField = _.get(prevSchema.models, displayedFieldPath, null);
|
|
// const primaryKey = _.get(prevSchema.models, [...apiPath, 'primaryKey'], null);
|
|
|
|
// // If the user has deleted the default sort attribute in the content type builder
|
|
// // Replace it by new generated one from the current schema
|
|
// if (_.includes(currentAttr, defaultSort)) {
|
|
// _.set(prevSchema.models, defaultSortPath, _.get(schema.models, defaultSortPath));
|
|
// }
|
|
|
|
// // If the user has deleted the edit view displayed field (name in the header)
|
|
// // Replace it by the model's primary key.
|
|
// if (_.includes(currentAttr, displayedField)) {
|
|
// _.set(prevSchema.models, displayedFieldPath, primaryKey);
|
|
// }
|
|
|
|
// // Update the displayed fields
|
|
// const updatedListDisplay = prevListDisplay.filter(obj => obj.name !== currentAttr.join());
|
|
|
|
// // Retrieve the model's displayed fields for the `EditPage`
|
|
// const fieldsPath = getEditDisplayFieldsPath(attrPath);
|
|
// // Retrieve the previous settings
|
|
// const prevEditDisplayFields = _.get(prevSchema.models, fieldsPath);
|
|
// // Update the fields
|
|
// const updatedEditDisplayFields = prevEditDisplayFields.filter(field => field !== currentAttr.join());
|
|
// // Set the new layout
|
|
// _.set(prevSchema.models, fieldsPath, updatedEditDisplayFields);
|
|
|
|
// if (updatedListDisplay.length === 0) {
|
|
// // Update it with the one from the generated schema
|
|
// _.set(prevSchema.models, listDisplayPath, _.get(schema.models, listDisplayPath, []));
|
|
// } else {
|
|
// _.set(prevSchema.models, listDisplayPath, updatedListDisplay);
|
|
// }
|
|
// });
|
|
|
|
// // Add API
|
|
// // Here we just need to add the data from the current schema Object
|
|
// apisToAdd.map(apiPath => {
|
|
// const api = _.get(schema.models, apiPath);
|
|
// const { search, filters, bulkActions, pageEntries, options } = _.get(prevSchema, 'generalSettings');
|
|
|
|
// _.set(api, 'options', options);
|
|
// _.set(api, 'filters', filters);
|
|
// _.set(api, 'search', search);
|
|
// _.set(api, 'bulkActions', bulkActions);
|
|
// _.set(api, 'pageEntries', pageEntries);
|
|
// _.set(prevSchema.models, apiPath, api);
|
|
// });
|
|
|
|
// // Add attribute to an existing API
|
|
// sameApisAttrToAdd.map(attrPath => {
|
|
// const attr = _.get(schema.models, attrPath);
|
|
// _.set(prevSchema.models, attrPath, attr);
|
|
|
|
// // Add the field in the editDisplay object
|
|
// const path = getEditDisplayAvailableFieldsPath(attrPath);
|
|
// const availableAttrToAdd = _.get(schema.models, path);
|
|
// _.set(prevSchema.models, path, availableAttrToAdd);
|
|
|
|
// // Push the attr into the list
|
|
// const fieldsPath = getEditDisplayFieldsPath(attrPath);
|
|
// const currentFields = _.get(prevSchema.models, fieldsPath, []);
|
|
// currentFields.push(availableAttrToAdd.name);
|
|
// _.set(prevSchema.models, fieldsPath, currentFields);
|
|
// });
|
|
|
|
// // Update other keys
|
|
// sameApis.forEach(apiPath => {
|
|
// // This doesn't keep the prevSettings for the relations, the user will have to reset it.
|
|
// // We might have to improve this if we want the order of the relations to be kept
|
|
// ['relations', 'loadedModel', 'associations', 'attributes', ['editDisplay', 'relations']]
|
|
// .map(key => apiPath.concat(key))
|
|
// .forEach(keyPath => {
|
|
// const newValue = _.get(schema.models, keyPath);
|
|
|
|
// _.set(prevSchema.models, keyPath, newValue);
|
|
// });
|
|
// });
|
|
|
|
// // Special handler for the upload relations
|
|
// sameApisUploadRelationsToAdd.forEach(attrPath => {
|
|
// const attr = _.get(schema.models, attrPath);
|
|
// _.set(prevSchema.models, attrPath, attr);
|
|
|
|
// const fieldsPath = [..._.take(attrPath, attrPath.length - 2), 'fields'];
|
|
// const currentFields = _.get(prevSchema.models, fieldsPath, []);
|
|
// currentFields.push(attr.name);
|
|
// _.set(prevSchema.models, fieldsPath, currentFields);
|
|
// });
|
|
|
|
// schemaApis.map(model => {
|
|
// const isPlugin = model.includes('plugins.');
|
|
// _.set(prevSchema.models[model], 'info', _.get(!isPlugin ? strapi.models[model] : strapi[model], 'info'));
|
|
// _.set(prevSchema.models[model], 'options', _.get(!isPlugin ? strapi.models[model] : strapi[model], 'options'));
|
|
// });
|
|
|
|
// await pluginStore.set({ key: 'schema', value: prevSchema });
|
|
// } catch (err) {
|
|
// console.log('error', err); // eslint-disable-line no-console
|
|
// }
|
|
|
|
// cb();
|
|
// };
|