@truedat/df 7.12.5 → 7.12.7

package/src/templates/components/templateForm/widgetDefinitions.js

@@ -1,6 +1,9 @@
 import _ from "lodash/fp";
+import { useIntl } from "react-intl";
+
+export const getCardinalityOptions = (widget) => {
+  const { formatMessage } = useIntl();
 
-export const getCardinalityOptions = (formatMessage) => (widget) => {
   const cardinalities = _.flow([
     _.find({ value: widget }),
     _.prop("cardinalities"),
@@ -12,7 +15,9 @@ export const getCardinalityOptions = (formatMessage) => (widget) => {
   }))(cardinalities);
 };
 
-export const getTypeOptions = (formatMessage) => (widget) => {
+export const getTypeOptions = (widget) => {
+  const { formatMessage } = useIntl();
+
   const types = _.flow([_.find({ value: widget }), _.prop("types")])(WIDGETS);
   return _.map((type) => ({
     key: type,
@@ -111,6 +116,14 @@ export const WIDGETS = [
     cardinalities: ["*"],
     types: ["table"],
   },
+  {
+    key: "dynamic_table",
+    value: "dynamic_table",
+    text: "Dynamic Table",
+    icon: "table",
+    cardinalities: ["*"],
+    types: ["dynamic_table"],
+  },
   {
     key: "password",
     value: "password",
@@ -152,3 +165,16 @@ export const WIDGETS = [
     types: ["datetime"],
   },
 ];
+
+export const defaultFieldDefinition = {
+  name: "new_field",
+  label: "New Field",
+  widget: "string",
+  cardinality: "?",
+  type: "string",
+  default: {
+    value: "",
+    origin: "default",
+  },
+  values: null,
+};

package/src/templates/utils/__tests__/validateContent.spec.js

@@ -62,7 +62,7 @@ const templateMultCondVisibility = {
 describe("utils: validateContent", () => {
   describe("validateRequired", () => {
     it("should return an empty array on valid content", () => {
-      const content = { req: "foo" };
+      const content = { req: { value: "foo" } };
       const result = validateContent(template)(content);
       expect(result).toEqual([]);
     });
@@ -77,12 +77,12 @@ describe("utils: validateContent", () => {
       ]);
     });
     it("should return empty array on valid multiple field", () => {
-      const content = { req: ["value"] };
+      const content = { req: { value: ["value"] } };
       const result = validateContent(templateMultiple)(content);
       expect(result).toEqual([]);
     });
     it("should return error on empty required multiple field", () => {
-      const content = { req: [] };
+      const content = { req: { value: [] } };
       const result = validateContent(templateMultiple)(content);
       expect(result).toEqual([
         {
@@ -92,12 +92,12 @@ describe("utils: validateContent", () => {
       ]);
     });
     it("should return empty array on hidden required field", () => {
-      const content = { depend: "no" };
+      const content = { depend: { value: "no" } };
       const result = validateContent(templateCondVisibility)(content);
       expect(result).toEqual([]);
     });
     it("should return error on conditionaly shown required field", () => {
-      const content = { depend: "yes" };
+      const content = { depend: { value: "yes" } };
       const result = validateContent(templateCondVisibility)(content);
       expect(result).toEqual([
         {
@@ -107,7 +107,7 @@ describe("utils: validateContent", () => {
       ]);
     });
     it("should return error on multiple conditionaly shown required field", () => {
-      const content = { depend: "maybe" };
+      const content = { depend: { value: "maybe" } };
       const result = validateContent(templateMultCondVisibility)(content);
       expect(result).toEqual([
         {

package/src/templates/utils/applyTemplate.js

@@ -17,33 +17,82 @@ const isInformed = _.flow(
   (value) => !value
 );
 
+const applyTableFields = (templateContent, content, domainId) => {
+  const tableFields = _.filter((field) => field.type === "dynamic_table")(templateContent);
+  return _.reduce((content, field) => {
+    const fieldName = field.name;
+    const contentValues = _.pathOr([], `${fieldName}.value`)(content)
+
+    if (!_.isEmpty(contentValues)) {
+      const tableColumns = field.values.table_columns;
+      const updatedContentValues = _.map((contentValue) => _.flow(
+        filterFields(tableColumns),
+        filterValues(tableColumns),
+        filterDepends(tableColumns),
+        filterSwitches(tableColumns),
+        (content) => filterDomains(tableColumns)(content, domainId),
+        (content) => applyDefaults(tableColumns)(content, domainId),
+      )(contentValue))(contentValues);
+
+      return _.set(`${fieldName}.value`, updatedContentValues)(content);
+    } else {
+      return content
+    }
+  }, content)(tableFields)
+}
+
+const applyTableFieldsWithoutDefaults = (templateContent, content, domainId) => {
+  const tableFields = _.filter((field) => field.type === "dynamic_table")(templateContent);
+  return _.reduce((content, field) => {
+    const fieldName = field.name;
+    const contentValues = _.pathOr([], `${fieldName}.value`)(content)
+
+    if (!_.isEmpty(contentValues)) {
+      const tableColumns = field.values.table_columns;
+      const updatedContentValues = _.map((contentValue) => _.flow(
+        filterFields(tableColumns),
+        filterValues(tableColumns),
+        filterDepends(tableColumns),
+        filterSwitches(tableColumns),
+        (content) => filterDomains(tableColumns)(content, domainId),
+        (content) => applyDefaults(tableColumns)(content, domainId),
+      )(contentValue))(contentValues);
+
+      return _.set(`${fieldName}.value`, updatedContentValues)(content);
+    } else {
+      return content
+    }
+  }, content)(tableFields)
+}
 export const applyTemplate =
   (template) =>
-  (content, domainId = null) => {
-    const templateContent = flattenFields(template);
-    return _.flow(
-      filterFields(templateContent),
-      filterValues(templateContent),
-      filterDepends(templateContent),
-      filterSwitches(templateContent),
-      (content) => filterDomains(templateContent)(content, domainId),
-      (content) => applyDefaults(templateContent)(content, domainId),
-      _.pickBy((value) => isInformed(value.value))
-    )(content);
-  };
+    (content, domainId = null) => {
+      const templateContent = flattenFields(template);
+      return _.flow(
+        filterFields(templateContent),
+        filterValues(templateContent),
+        filterDepends(templateContent),
+        filterSwitches(templateContent),
+        (content) => filterDomains(templateContent)(content, domainId),
+        (content) => applyDefaults(templateContent)(content, domainId),
+        _.pickBy((value) => isInformed(value.value)),
+        (content) => applyTableFields(templateContent, content, domainId)
+      )(content);
+    };
 
 export const applyTemplateWithoutDefaults =
   (template) =>
-  (content, domainId = null) => {
-    const templateContent = flattenFields(template);
-    return _.flow(
-      filterFields(templateContent),
-      filterValues(templateContent),
-      filterDepends(templateContent),
-      filterSwitches(templateContent),
-      (content) => filterDomains(templateContent)(content, domainId),
-      _.pickBy((value) => isInformed(value.value))
-    )(content);
-  };
+    (content, domainId = null) => {
+      const templateContent = flattenFields(template);
+      return _.flow(
+        filterFields(templateContent),
+        filterValues(templateContent),
+        filterDepends(templateContent),
+        filterSwitches(templateContent),
+        (content) => filterDomains(templateContent)(content, domainId),
+        _.pickBy((value) => isInformed(value.value)),
+        (content) => applyTableFieldsWithoutDefaults(templateContent, content, domainId)
+      )(content);
+    };
 
 export default applyTemplate;

package/src/templates/utils/filterValues.js

@@ -34,9 +34,9 @@ export const filterValues = (templateContent) => {
     _.has(key)(vv)
       ? _.isArray(value.value)
         ? _.set(
-            "value",
-            _.filter((v) => _.includes(v)(_.prop(key)(vv)))(value.value)
-          )(value)
+          "value",
+          _.filter((v) => _.includes(v)(_.prop(key)(vv)))(value.value)
+        )(value)
         : _.includes(value.value)(_.prop(key)(vv))
           ? value
           : { ...value, value: null }

package/src/templates/utils/parseFieldOptions.js

@@ -7,66 +7,81 @@ const makeOptions = (formatMessage, label) =>
     text: formatMessage({ id: `fields.${label}.${v}`, defaultMessage: v }),
   }));
 
-export const parseFieldOptions =
-  (formatMessage) => (content, selectedDomain) => (field) => {
-    const value = _.prop(field?.name)(content);
-    if (!field?.values) return { ...field, value };
+const doParseFieldOptions = (formatMessage, content, selectedDomain, field) => {
+  const value = _.prop(field?.name)(content);
 
-    const translateValues = _.flow(
-      makeOptions(formatMessage, field?.label),
-      _.sortBy(accentInsensitivePathOrder("text"))
-    );
-    const parseSwitch = (values) => {
-      const switchOn = _.prop("switch.on")(values);
-      const switchedValues = _.prop(`switch.values.${content[switchOn].value}`)(
-        values
-      );
-      return translateValues(switchedValues);
+  if (!field?.values) return { ...field, value };
+  if (field?.type == "dynamic_table" && _.has("values.table_columns")(field)) {
+    const tableColumns = _.flow(
+      _.propOr([], "values.table_columns"),
+      _.map((field) =>
+        doParseFieldOptions(formatMessage, content, selectedDomain, field),
+      ),
+    )(field);
+    return {
+      ...field,
+      value,
+      values: { ...field?.values, table_columns: tableColumns },
     };
-    const parseFixed = _.flow(_.get("fixed"), translateValues);
-    const parseRoleUsers = _.flow(
-      _.get("processed_users"),
-      _.cond([
-        [_.isArray, _.identity],
-        [_.stubTrue, _.constant([])],
-      ]),
-      translateValues
+  }
+  const translateValues = _.flow(
+    makeOptions(formatMessage, field?.label),
+    _.sortBy(accentInsensitivePathOrder("text")),
+  );
+  const parseSwitch = (values) => {
+    const switchOn = _.prop("switch.on")(values);
+    const switchedValues = _.prop(`switch.values.${content[switchOn].value}`)(
+      values,
     );
-    const parseRoleGroups = (values) =>
-      _.concat(
-        _.flow(
-          _.get("processed_users"),
-          _.map((name) => ({
-            value: `user:${name}`,
-            text: name,
-            icon: "user",
-          }))
-        )(values),
-        _.flow(
-          _.get("processed_groups"),
-          _.map((name) => ({
-            value: `group:${name}`,
-            text: name,
-            icon: "group",
-          }))
-        )(values)
-      );
-    const parseDomain = _.flow(
-      _.get("domain"),
-      _.propOr([], _.toString(selectedDomain?.id)),
-      translateValues
+    return translateValues(switchedValues);
+  };
+  const parseFixed = _.flow(_.get("fixed"), translateValues);
+  const parseRoleUsers = _.flow(
+    _.get("processed_users"),
+    _.cond([
+      [_.isArray, _.identity],
+      [_.stubTrue, _.constant([])],
+    ]),
+    translateValues,
+  );
+  const parseRoleGroups = (values) =>
+    _.concat(
+      _.flow(
+        _.get("processed_users"),
+        _.map((name) => ({
+          value: `user:${name}`,
+          text: name,
+          icon: "user",
+        })),
+      )(values),
+      _.flow(
+        _.get("processed_groups"),
+        _.map((name) => ({
+          value: `group:${name}`,
+          text: name,
+          icon: "group",
+        })),
+      )(values),
     );
+  const parseDomain = _.flow(
+    _.get("domain"),
+    _.propOr([], _.toString(selectedDomain?.id)),
+    translateValues,
+  );
 
-    const parsedValues = _.flow(
-      _.get("values"),
-      _.cond([
-        [_.has("switch"), parseSwitch],
-        [_.has("fixed"), parseFixed],
-        [_.has("fixed_tuple"), _.get("fixed_tuple")],
-        [_.has("role_users"), parseRoleUsers],
-        [_.has("role_groups"), parseRoleGroups],
-        [_.has("domain"), parseDomain],
-      ])
-    )(field);
-    return { ...field, value, parsedValues };
-  };
+  const parsedValues = _.flow(
+    _.get("values"),
+    _.cond([
+      [_.has("switch"), parseSwitch],
+      [_.has("fixed"), parseFixed],
+      [_.has("fixed_tuple"), _.get("fixed_tuple")],
+      [_.has("role_users"), parseRoleUsers],
+      [_.has("role_groups"), parseRoleGroups],
+      [_.has("domain"), parseDomain],
+    ]),
+  )(field);
+  return { ...field, value, parsedValues };
+};
+export const parseFieldOptions =
+  (formatMessage) => (content, selectedDomain) => (field) =>
+    doParseFieldOptions(formatMessage, content, selectedDomain, field);

package/src/templates/utils/parseGroups.js

@@ -31,61 +31,60 @@ export const parseGroups =
                 (hasDependentKeys(field) && checkDependency(field, content))) &&
               (!(field.values && "switch" in field.values) ||
                 _.prop(`${_.prop("values.switch.on")(field)}.value`)(content) in
-                  _.prop("values.switch.values")(field))
+                _.prop("values.switch.values")(field)),
           ),
           _.map(parseFieldOptions(formatMessage)(content, selectedDomain)),
           _.map(enrichRequired(content)),
-          _.map(enrichIsSecret(_.get("is_secret")(group)))
+          _.map(enrichIsSecret(_.get("is_secret")(group))),
         )(group);
         return { ...group, fields };
       }),
-      _.filter(({ fields }) => _.negate(_.isEmpty)(fields))
+      _.filter(({ fields }) => _.negate(_.isEmpty)(fields)),
     )(template);
 
 export const parseGroupsWithLangs =
   (formatMessage) =>
-  (template, i18nContent, fieldsToOmit, selectedDomain, requiredLangs = []) => {
-    return _.flow(
-      _.getOr([], "content"),
-      _.map((group) => {
-        const langs = _.flow(
-          _.toPairs,
-          _.map(([lang, langContent]) => {
-            const fields = _.flow(
-              _.get("fields"),
-              _.reject((field) => _.includes(fieldsToOmit)(field?.name)),
-              _.filter((field) => {
-                return (
-                  (!("depends" in field) ||
-                    (hasDependentKeys(field) &&
-                      checkDependency(field, langContent))) &&
-                  (!(field.values && "switch" in field.values) ||
-                    _.prop(`${_.prop("values.switch.on")(field)}.value`)(
-                      langContent
-                    ) in _.prop("values.switch.values")(field))
-                );
-              }),
-              _.map((field) => ({
-                ...field,
-                ...parseFieldOptions(formatMessage)(
-                  langContent,
-                  selectedDomain
-                )(field),
-                ...(requiredLangs.includes(lang)
-                  ? enrichRequired(langContent)(field)
-                  : { required: false }),
-                ...enrichIsSecret(_.get("is_secret")(group))(field),
-              }))
-            )(group);
-            return [lang, fields];
-          }),
-          _.fromPairs
-        )(i18nContent);
-        return {
-          name: group.name,
-          langs,
-        };
-      }),
-      _.filter(({ langs }) => _.some((fields) => !_.isEmpty(fields))(langs))
-    )(template);
-  };
+    (template, i18nContent, fieldsToOmit, selectedDomain, requiredLangs = []) => {
+      return _.flow(
+        _.getOr([], "content"),
+        _.map((group) => {
+          const langs = _.flow(
+            _.toPairs,
+            _.map(([lang, langContent]) => {
+              const fields = _.flow(
+                _.get("fields"),
+                _.reject((field) => _.includes(fieldsToOmit)(field?.name)),
+                _.filter((field) => {
+                  return (
+                    (!("depends" in field) ||
+                      (hasDependentKeys(field) &&
+                        checkDependency(field, langContent))) &&
+                    (!(field.values && "switch" in field.values) ||
+                      _.prop(`${_.prop("values.switch.on")(field)}.value`)(
+                        langContent,
+                      ) in _.prop("values.switch.values")(field))
+                  );
+                }),
+                _.map(
+                  _.flow(
+                    parseFieldOptions(formatMessage)(langContent, selectedDomain),
+                    (field) => requiredLangs.includes(lang)
+                      ? enrichRequired(langContent)(field)
+                      : { ...field, required: false }
+                    ,
+                    enrichIsSecret(_.get("is_secret")(group)),
+                  ),
+                ),
+              )(group);
+              return [lang, fields];
+            }),
+            _.fromPairs,
+          )(i18nContent);
+          return {
+            name: group.name,
+            langs,
+          };
+        }),
+        _.filter(({ langs }) => _.some((fields) => !_.isEmpty(fields))(langs)),
+      )(template);
+    };

package/src/templates/utils/validateContent.js

@@ -3,42 +3,75 @@ import { flattenFields } from "./flattenFields";
 
 const fieldIsHiddenVerifier =
   (content) =>
-  ({ depends }) => {
-    if (!depends) return false;
-    const { on, to_be } = depends;
-    const dependentValue = content[on];
-    return _.isArray(dependentValue)
-      ? !_.some((d) => to_be.includes(d))(dependentValue)
-      : !to_be.includes(dependentValue);
-  };
+    ({ depends }) => {
+      if (!depends) return false;
+      const { on, to_be } = depends;
+      const dependentValue = content[on]?.value;
+      return _.isArray(dependentValue)
+        ? !_.some((d) => to_be.includes(d))(dependentValue)
+        : !to_be.includes(dependentValue);
+    };
 
-export const validateContent = (template) => (content) => {
+const isTableRequired = (field, content) => {
+  if (field?.type === "dynamic_table" && _.has("values.table_columns")(field)) {
+    const rowValues = _.pathOr([], `${field?.name}.value`)(content);
+
+    if (_.isEmpty(rowValues)) return false;
+
+    return _.flow(
+      _.pathOr([], "values.table_columns"),
+      _.any((nestedField) => _.includes(nestedField?.cardinality)(["1", "+"])))
+      (field);
+  }
+
+  return false;
+}
+
+const validateTemplateContent = (schema, content) => {
   const fieldIsHidden = fieldIsHiddenVerifier(content);
-  const templateContent = _.flow(
-    flattenFields,
-    _.reject(fieldIsHidden)
-  )(template);
+  const templateContent = _.reject(fieldIsHidden)(schema);
   return _.flow(validateRequired(templateContent), _.head)([[], content]);
+}
+
+export const validateContent = (template) => (content) => {
+  const schema = flattenFields(template);
+  return validateTemplateContent(schema, content);
 };
 
-const isEmptyValue = (value) => !_.isNumber(value) && _.isEmpty(value);
+const isEmptyValue = (value) => _.isNil(value) || (!_.isNumber(value) && _.isEmpty(value));
+
+const isEmptyField = (field, content) => {
+  if (field?.type === "dynamic_table" && _.has("values.table_columns")(field)) {
+    const tableColumns = _.pathOr([], "values.table_columns")(field);
+    const rowValues = _.pathOr([], `${field?.name}.value`)(content);
+
+    if (_.isEmpty(rowValues)) return true;
+
+    const requiredErrors = _.flow(
+      _.map((row) => _.flow(validateRequired(tableColumns), _.head)([[], row])),
+      _.flatten,
+    )(rowValues);
+
+    return !_.isEmpty(requiredErrors);
+  }
+  return isEmptyValue(content?.[field?.name]?.value);
+}
 
 export const validateRequired =
   (templateContent) =>
-  ([validations, content]) => {
-    const newValidations = _.flow([
-      _.filter((field) => isRequired(field, content)),
-      _.map("name"),
-      _.filter((r) => isEmptyValue(_.prop(r)(content))),
-      _.map((field) => ({ error: "missing required", field })),
-    ])(templateContent);
-    return [[...validations, ...newValidations], content];
-  };
+    ([validations, content]) => {
+      const newValidations = _.flow([
+        _.filter((field) => isRequired(field, content)),
+        _.filter((field) => isEmptyField(field, content)),
+        _.map((field) => ({ error: "missing required", field: field?.name })),
+      ])(templateContent);
+      return [[...validations, ...newValidations], content];
+    };
 
 export const dependentRequired = (field, content) => {
   if (_.has("mandatory")(field)) {
     const on = field?.mandatory?.on;
-    const dependent = content[on];
+    const dependent = content[on]?.value;
     const target = field?.mandatory?.to_be || [];
     if (_.isArray(dependent)) {
       return !_.isEmpty(_.intersection(dependent)(target));
@@ -50,11 +83,23 @@ export const dependentRequired = (field, content) => {
 };
 
 export const isRequired = (field, content) =>
-  _.includes(field?.cardinality)(["1", "+"]) ||
+  _.includes(field?.cardinality)(["1", "+"]) || isTableRequired(field, content) ||
   dependentRequired(field, content);
 
 export const enrichRequired = (content) => (field) => {
   const required = isRequired(field, content);
+  if (field?.type === "dynamic_table" && _.has("values.table_columns")(field)) {
+    const tableColumns = _.flow(
+      _.propOr([], "values.table_columns"),
+      _.map((field) => enrichRequired({})(field)))
+      (field);
+
+    return _.flow(
+      _.set("values.table_columns", tableColumns),
+      _.set("required", required))
+      (field);
+  }
+
   return { ...field, required };
 };