@akemona-org/strapi-plugin-content-type-builder 3.7.0

package/admin/src/containers/DataManagerProvider/utils/createModifiedDataSchema.js

@@ -0,0 +1,91 @@
+import { fromJS, OrderedMap } from 'immutable';
+import { get } from 'lodash';
+
+const createModifiedDataSchema = (
+  contentTypeSchema,
+  retrievedComponents,
+  allComponentsSchema,
+  isInContentTypeView
+) => {
+  const componentsAssociatedToContentType = retrievedComponents.reduce(
+    (acc, current) => {
+      const componentSchema = get(allComponentsSchema, current, {});
+
+      acc[current] = componentSchema;
+
+      return acc;
+    },
+    {}
+  );
+  const keyName = isInContentTypeView ? 'contentType' : 'component';
+  const schema = {
+    [keyName]: contentTypeSchema,
+    components: componentsAssociatedToContentType,
+  };
+
+  return schema;
+};
+
+const orderAllDataAttributesWithImmutable = (
+  allDataSchema,
+  isInContentTypeView
+) => {
+  const attributesPath = ['schema', 'attributes'];
+  const componentsSchema = allDataSchema.components;
+  const componentsWithImmutableSchema = Object.keys(componentsSchema).reduce(
+    (acc, current) => {
+      const currentSchema = get(componentsSchema, [current], {});
+
+      const currentAttributes = get(currentSchema, attributesPath, {});
+
+      const fromJSAttributes = Object.keys(currentAttributes).reduce(
+        (acc, current) => {
+          acc[current] = fromJS(currentAttributes[current]);
+
+          return acc;
+        },
+        {}
+      );
+
+      // TODO refacto
+      const currentImmutableSchemas = fromJS(currentSchema).setIn(
+        ['schema', 'attributes'],
+        fromJS(OrderedMap(fromJSAttributes))
+      );
+
+      acc[current] = fromJS(currentImmutableSchemas);
+
+      return acc;
+    },
+    {}
+  );
+  const keyName = isInContentTypeView ? 'contentType' : 'component';
+  const mainSchema = get(allDataSchema, [keyName], {});
+  const mainImmutableSchema = fromJS(mainSchema).setIn(
+    attributesPath,
+    fromJS(
+      OrderedMap(
+        Object.keys(get(mainSchema, attributesPath, {})).reduce(
+          (acc, current) => {
+            acc[current] = fromJS(
+              get(mainSchema, [...attributesPath, current], {})
+            );
+
+            return acc;
+          },
+          {}
+        )
+      )
+    )
+  );
+
+  const immutableData = fromJS({
+    components: componentsWithImmutableSchema,
+    [keyName]: mainImmutableSchema,
+  });
+
+  return immutableData;
+};
+
+export default createModifiedDataSchema;
+export { orderAllDataAttributesWithImmutable };

package/admin/src/containers/DataManagerProvider/utils/retrieveComponentsFromSchema.js

@@ -0,0 +1,55 @@
+import { get } from 'lodash';
+import makeUnique from '../../../utils/makeUnique';
+
+const retrieveComponentsFromSchema = (attributes, allComponentsData) => {
+  const allComponents = Object.keys(attributes).reduce((acc, current) => {
+    const type = get(attributes, [current, 'type'], '');
+
+    if (type === 'component') {
+      const currentComponentName = attributes[current].component;
+      // Push the existing compo
+      acc.push(currentComponentName);
+
+      const currentComponentAttributes = get(
+        allComponentsData,
+        [currentComponentName, 'schema', 'attributes'],
+        {}
+      );
+
+      // Retrieve the nested ones
+      acc.push(
+        ...retrieveComponentsFromSchema(
+          currentComponentAttributes,
+          allComponentsData
+        )
+      );
+    }
+
+    if (type === 'dynamiczone') {
+      const dynamicZoneComponents = attributes[current].components;
+      const componentsFromDZComponents = dynamicZoneComponents.reduce(
+        (acc2, currentUid) => {
+          const compoAttrs = get(
+            allComponentsData,
+            [currentUid, 'schema', 'attributes'],
+            {}
+          );
+
+          return [
+            ...acc2,
+            ...retrieveComponentsFromSchema(compoAttrs, allComponentsData),
+          ];
+        },
+        []
+      );
+
+      return [...acc, ...dynamicZoneComponents, ...componentsFromDZComponents];
+    }
+
+    return acc;
+  }, []);
+
+  return makeUnique(allComponents);
+};
+
+export default retrieveComponentsFromSchema;

package/admin/src/containers/DataManagerProvider/utils/retrieveComponentsThatHaveComponents.js

@@ -0,0 +1,35 @@
+import { get } from 'lodash';
+import makeUnique from '../../../utils/makeUnique';
+
+const retrieveComponentsThatHaveComponents = allComponents => {
+  const componentsThatHaveNestedComponents = Object.keys(allComponents).reduce(
+    (acc, current) => {
+      const currentComponent = get(allComponents, [current], {});
+      const uid = currentComponent.uid;
+
+      if (doesComponentHaveAComponentField(currentComponent)) {
+        acc.push(uid);
+      }
+
+      return acc;
+    },
+    []
+  );
+
+  return makeUnique(componentsThatHaveNestedComponents);
+};
+
+const doesComponentHaveAComponentField = component => {
+  const attributes = get(component, ['schema', 'attributes'], {});
+
+  return Object.keys(attributes).some(attributeName => {
+    const type = get(attributes, [attributeName, 'type'], '');
+
+    return type === 'component';
+  });
+};
+
+export {
+  doesComponentHaveAComponentField,
+  retrieveComponentsThatHaveComponents,
+};

package/admin/src/containers/DataManagerProvider/utils/retrieveNestedComponents.js

@@ -0,0 +1,34 @@
+import { get } from 'lodash';
+import makeUnique from '../../../utils/makeUnique';
+
+const retrieveNestedComponents = appComponents => {
+  const nestedComponents = Object.keys(appComponents).reduce((acc, current) => {
+    const componentAttributes = get(
+      appComponents,
+      [current, 'schema', 'attributes'],
+      {}
+    );
+    const currentComponentNestedCompos = getComponentsFromComponent(
+      componentAttributes
+    );
+
+    return [...acc, ...currentComponentNestedCompos];
+  }, []);
+
+  return makeUnique(nestedComponents);
+};
+
+const getComponentsFromComponent = componentAttributes => {
+  return Object.keys(componentAttributes).reduce((acc, current) => {
+    const attribute = get(componentAttributes, current, {});
+    const { type, component } = attribute;
+
+    if (type === 'component') {
+      acc.push(component);
+    }
+
+    return acc;
+  }, []);
+};
+
+export default retrieveNestedComponents;

package/admin/src/containers/DataManagerProvider/utils/retrieveSpecificInfoFromComponents.js

@@ -0,0 +1,12 @@
+import { get } from 'lodash';
+import makeUnique from '../../../utils/makeUnique';
+
+const retrieveSpecificInfoFromComponents = (allComponents, keysToRetrieve) => {
+  const allData = Object.keys(allComponents).map(compo => {
+    return get(allComponents, [compo, ...keysToRetrieve], '');
+  });
+
+  return makeUnique(allData);
+};
+
+export default retrieveSpecificInfoFromComponents;

package/admin/src/containers/FormModal/CustomButton.js

@@ -0,0 +1,12 @@
+import styled from 'styled-components';
+import { Button } from '@buffetjs/core';
+
+const CustomButton = styled(Button)`
+  svg {
+    height: 11px;
+    width: 11px;
+    vertical-align: initial;
+  }
+`;
+
+export default CustomButton;

package/admin/src/containers/FormModal/attributes/advancedForm.js

@@ -0,0 +1,269 @@
+import React from 'react';
+import { FormattedMessage } from 'react-intl';
+import { get, isEmpty } from 'lodash';
+import getTrad from '../../../utils/getTrad';
+import { componentForm } from '../component';
+import options from './attributeOptions';
+import uiHelpers from './uiHelpers';
+
+const advancedForm = {
+  boolean: () => {
+    return {
+      items: [
+        [
+          {
+            autoFocus: true,
+            type: 'enum',
+            label: {
+              id: getTrad('form.attribute.settings.default'),
+            },
+            name: 'default',
+            options: [
+              { value: 'true', label: 'TRUE' },
+              { value: '', label: 'NULL' },
+              { value: 'false', label: 'FALSE' },
+            ],
+            validations: {},
+          },
+        ],
+        [uiHelpers.divider],
+        [options.required, options.unique],
+        [options.private],
+      ],
+    };
+  },
+  component: ({ repeatable }, step) => {
+    if (step === '1') {
+      return { items: componentForm.advanced('componentToCreate') };
+    }
+
+    if (repeatable) {
+      return { items: [[options.required], [uiHelpers.divider], [options.max, options.min]] };
+    }
+
+    return {
+      items: [[options.required]],
+    };
+  },
+  date: ({ type }) => {
+    return {
+      items: [
+        [
+          {
+            ...options.default,
+            type: type || 'date',
+            value: null,
+            withDefaultValue: false,
+            disabled: !type,
+            autoFocus: false,
+          },
+        ],
+        [uiHelpers.divider],
+        [options.required, options.unique],
+        [options.private],
+      ],
+    };
+  },
+  dynamiczone: () => {
+    return {
+      items: [[options.required], [uiHelpers.divider], [options.max, options.min]],
+    };
+  },
+  email: () => {
+    return {
+      items: [
+        [
+          {
+            ...options.default,
+            type: 'email',
+          },
+        ],
+        [uiHelpers.divider],
+        [options.required, options.unique],
+        [options.maxLength, options.minLength],
+        [options.private],
+      ],
+    };
+  },
+  enumeration: data => {
+    return {
+      items: [
+        [
+          {
+            autoFocus: false,
+            name: 'default',
+            type: 'select',
+            label: {
+              id: getTrad('form.attribute.settings.default'),
+            },
+            validations: {},
+            options: [
+              <FormattedMessage
+                key="hidden___value__placeholder"
+                id="components.InputSelect.option.placeholder"
+              >
+                {msg => <option value="">{msg}</option>}
+              </FormattedMessage>,
+            ].concat(
+              data.enum
+                ? data.enum
+                    .filter((val, index) => data.enum.indexOf(val) === index && !isEmpty(val))
+                    .map(val => (
+                      <option key={val} value={val}>
+                        {val}
+                      </option>
+                    ))
+                : []
+            ),
+          },
+          {
+            label: {
+              id: getTrad('form.attribute.item.enumeration.graphql'),
+            },
+            name: 'enumName',
+            type: 'text',
+            validations: {},
+            description: {
+              id: getTrad('form.attribute.item.enumeration.graphql.description'),
+            },
+          },
+        ],
+        [uiHelpers.divider],
+        [options.required, options.unique],
+        [options.private],
+      ],
+    };
+  },
+  json: () => {
+    return {
+      items: [[uiHelpers.divider], [options.required, options.unique], [options.private]],
+    };
+  },
+  media: () => {
+    return {
+      items: [
+        [uiHelpers.divider],
+        [options.required, options.unique],
+        [
+          {
+            label: {
+              id: getTrad('form.attribute.media.allowed-types'),
+            },
+            name: 'allowedTypes',
+            type: 'allowedTypesSelect',
+            value: '',
+            validations: {},
+          },
+        ],
+        [options.private],
+      ],
+    };
+  },
+  number: data => {
+    const inputStep = data.type === 'decimal' || data.type === 'float' ? 'any' : '1';
+
+    return {
+      items: [
+        [
+          {
+            autoFocus: true,
+            name: 'default',
+            type: data.type === 'biginteger' ? 'text' : 'number',
+            step: inputStep,
+            label: {
+              id: getTrad('form.attribute.settings.default'),
+            },
+            validations: {},
+          },
+        ],
+        [uiHelpers.divider],
+        [options.required, options.unique],
+        [options.max, options.min],
+        [options.private],
+      ],
+    };
+  },
+  password: () => {
+    return {
+      items: [
+        [options.default],
+        [uiHelpers.divider],
+        [options.required, options.unique],
+        [options.maxLength, options.minLength],
+        [options.private],
+      ],
+    };
+  },
+  relation: data => {
+    const targetAttributeValue = get(data, 'targetAttribute', null);
+    const nameValue = get(data, 'name', null);
+
+    return {
+      items: [
+        [uiHelpers.divider],
+        [options.private],
+        [options.unique],
+        [
+          {
+            autoFocus: false,
+            disabled: nameValue === null,
+            name: 'columnName',
+            type: 'addon',
+            addon: nameValue,
+            label: {
+              id: getTrad('form.attribute.item.customColumnName'),
+            },
+            inputDescription: {
+              id: getTrad('form.attribute.item.customColumnName.description'),
+            },
+            validations: {},
+          },
+          {
+            autoFocus: false,
+            disabled: targetAttributeValue === null || targetAttributeValue === '-',
+            name: 'targetColumnName',
+            label: '',
+            type: 'addon',
+            addon: targetAttributeValue,
+            validations: {},
+          },
+        ],
+      ],
+    };
+  },
+  richtext: () => {
+    return {
+      items: [
+        [options.default],
+        [uiHelpers.divider],
+        [options.required, options.unique],
+        [options.maxLength, options.minLength],
+        [options.private],
+      ],
+    };
+  },
+  text: () => {
+    return {
+      items: [
+        [options.default, options.regex],
+        [uiHelpers.divider],
+        [options.required, options.unique],
+        [options.maxLength, options.minLength],
+        [options.private],
+      ],
+    };
+  },
+  uid: data => {
+    return {
+      items: [
+        [{ ...options.default, disabled: Boolean(data.targetField), type: 'text' }],
+        [uiHelpers.divider],
+        [options.required],
+        [options.maxLength, options.minLength],
+        [options.private],
+      ],
+    };
+  },
+};
+
+export default advancedForm;

package/admin/src/containers/FormModal/attributes/attributeOptions.js

@@ -0,0 +1,99 @@
+import getTrad from '../../../utils/getTrad';
+
+const attributeOptions = {
+  default: {
+    autoFocus: true,
+    name: 'default',
+    type: 'text',
+    label: {
+      id: getTrad('form.attribute.settings.default'),
+    },
+    validations: {},
+  },
+  max: {
+    autoFocus: false,
+    name: 'max',
+    type: 'customCheckboxWithChildren',
+    label: {
+      id: getTrad('form.attribute.item.maximum'),
+    },
+    validations: {},
+  },
+  maxLength: {
+    autoFocus: false,
+    name: 'maxLength',
+    type: 'customCheckboxWithChildren',
+    label: {
+      id: getTrad('form.attribute.item.maximumLength'),
+    },
+    validations: {},
+  },
+  min: {
+    autoFocus: false,
+    name: 'min',
+    type: 'customCheckboxWithChildren',
+    label: {
+      id: getTrad('form.attribute.item.minimum'),
+    },
+    validations: {},
+  },
+  minLength: {
+    autoFocus: false,
+    name: 'minLength',
+    type: 'customCheckboxWithChildren',
+    label: {
+      id: getTrad('form.attribute.item.minimumLength'),
+    },
+    validations: {},
+  },
+  private: {
+    autoFocus: false,
+    name: 'private',
+    type: 'checkbox',
+    label: {
+      id: getTrad('form.attribute.item.privateField'),
+    },
+    description: {
+      id: getTrad('form.attribute.item.privateField.description'),
+    },
+    validations: {},
+  },
+  regex: {
+    autoFocus: false,
+    label: {
+      id: getTrad('form.attribute.item.text.regex'),
+    },
+    name: 'regex',
+    type: 'text',
+    validations: {},
+    description: {
+      id: getTrad('form.attribute.item.text.regex.description'),
+    },
+  },
+  required: {
+    autoFocus: false,
+    name: 'required',
+    type: 'checkbox',
+    label: {
+      id: getTrad('form.attribute.item.requiredField'),
+    },
+    description: {
+      id: getTrad('form.attribute.item.requiredField.description'),
+    },
+    validations: {},
+  },
+  unique: {
+    autoFocus: false,
+    name: 'unique',
+    type: 'checkbox',
+    label: {
+      id: getTrad('form.attribute.item.uniqueField'),
+    },
+    description: {
+      id: getTrad('form.attribute.item.uniqueField.description'),
+    },
+    validations: {},
+  },
+};
+
+export default attributeOptions;