@truedat/df 7.4.5 → 7.5.0

package/src/templates/components/templateForm/__tests__/__snapshots__/TemplateFormActions.spec.js.snap

@@ -28,6 +28,34 @@ exports[`<TemplateFormActions /> matches the latest snapshot (deleting) 1`] = `
 </Container>
 `;
 
+exports[`<TemplateFormActions /> matches the latest snapshot (invalid) 1`] = `
+<Container
+  textAlign="right"
+>
+  <Button
+    as="button"
+    content={
+      <Memo(MemoizedFormattedMessage)
+        id="actions.save"
+      />
+    }
+    disabled={true}
+    loading={false}
+    onClick={[MockFunction]}
+    primary={true}
+  />
+  <Button
+    as="button"
+    content={
+      <Memo(MemoizedFormattedMessage)
+        id="actions.cancel"
+      />
+    }
+    onClick={[Function]}
+  />
+</Container>
+`;
+
 exports[`<TemplateFormActions /> matches the latest snapshot (saving) 1`] = `
 <Container
   textAlign="right"

package/src/templates/components/templateForm/__tests__/__snapshots__/ValuesListForm.spec.js.snap

@@ -71,6 +71,7 @@ exports[`<ValuesListForm /> fixed matches the latest snapshot for fixed 1`] = `
           onClick={[Function]}
         />
       }
+      label={null}
       name="fixed_value"
       onChange={[Function]}
       onKeyPress={[Function]}
@@ -152,6 +153,7 @@ exports[`<ValuesListForm /> fixed_tuple matches the latest snapshot for fixed_tu
         as={[Function]}
         control={[Function]}
         error={false}
+        label={null}
         name="tuple_value"
         onChange={[Function]}
         onKeyPress={[Function]}
@@ -169,6 +171,7 @@ exports[`<ValuesListForm /> fixed_tuple matches the latest snapshot for fixed_tu
             onClick={[Function]}
           />
         }
+        label={null}
         name="tuple_text"
         onChange={[Function]}
         onKeyPress={[Function]}
@@ -263,6 +266,7 @@ exports[`<ValuesListForm /> table_columns matches the latest snapshot for table_
             onClick={[Function]}
           />
         }
+        label={null}
         name="column_name"
         onChange={[Function]}
         onKeyPress={[Function]}

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

@@ -1,46 +1,131 @@
 import _ from "lodash/fp";
 
-const arrayAnd = list => _.indexOf(true)(list) >= 0;
+const arrayAnd = (list) => _.indexOf(true)(list) >= 0;
 
-export const parseContentValidation = content => {
+export const parseContentValidation = (content) => {
   const duplicatedGroupNames = _.flow([
     _.countBy("name"),
-    _.omitBy(v => v == 1),
-    _.keys
+    _.omitBy((v) => v == 1),
+    _.keys,
   ])(content);
   const duplicatedFieldNames = _.flow([
     _.map("fields"),
     _.reduce((acc, f) => [...acc, ...f], []),
     _.countBy("name"),
-    _.omitBy(v => v == 1),
-    _.keys
+    _.omitBy((v) => v == 1),
+    _.keys,
   ])(content);
 
-  const parseFieldsValidation = fields => {
-    return _.map(field => {
+  const parseFieldsValidation = (fields) => {
+    return _.map((field) => {
       const nameDuplicated = _.indexOf(field.name)(duplicatedFieldNames) >= 0;
+      const nameEmpty = _.isEmpty(field.name);
+      const labelEmpty = _.isEmpty(field.label);
+      const isDropdownWidget = _.includes(field.widget, [
+        "dropdown",
+        "radio",
+        "checkbox",
+      ]);
+      const checkFieldType = (field, type) => field.type === type;
+      const dropdownWidgetInvalid = _.cond([
+        [() => !isDropdownWidget, () => false],
+        [
+          () => checkFieldType(field, "user"),
+          () => _.isEmpty(field.values.role_users),
+        ],
+        [
+          () => checkFieldType(field, "user_group"),
+          () => _.isEmpty(field.values.role_groups),
+        ],
+        [
+          () => checkFieldType(field, "hierarchy"),
+          () => _.isEmpty(field.values.hierarchy),
+        ],
+        [
+          () => checkFieldType(field, "string"),
+          () =>
+            _.cond([
+              [
+                () => _.has("domain", field.values),
+                () =>
+                  _.isEmpty(field.values.domain) ||
+                  _.some((domain) => _.every(_.isEmpty)(_.values(domain)))(
+                    field.values.domain
+                  ),
+              ],
+              [
+                () => _.has("switch", field.values),
+                () =>
+                  _.isEmpty(field.values.switch) ||
+                  _.isEmpty(field.values.switch.values) ||
+                  _.some((switchKey) =>
+                    _.isEmpty(field.values.switch.values[switchKey])
+                  )(_.keys(field.values.switch.values)),
+              ],
+              [
+                () => _.has("fixed", field.values),
+                () => _.isEmpty(field.values.fixed),
+              ],
+              [
+                () => _.has("fixed_tuple", field.values),
+                () => _.isEmpty(field.values.fixed_tuple),
+              ],
+            ])(),
+        ],
+      ])();
 
-      const hasErrors = arrayAnd([nameDuplicated]);
+      const tableCoulmnEmpty =
+        checkFieldType(field, "table") &&
+        _.has("table_columns", field.values) &&
+        _.isEmpty(field.values.table_columns);
+
+      const conditionalVisibilityValueEmpty =
+        _.has("depends", field) &&
+        !_.isEmpty(field.depends.on) &&
+        _.isEmpty(field.depends.to_be);
+
+      const mandatoryDependingOnValueEmpty =
+        _.has("mandatory", field) &&
+        !_.isEmpty(field.mandatory.on) &&
+        _.isEmpty(field.mandatory.to_be);
+
+      const hasErrors = arrayAnd([
+        nameDuplicated,
+        nameEmpty,
+        labelEmpty,
+        dropdownWidgetInvalid,
+        tableCoulmnEmpty,
+        conditionalVisibilityValueEmpty,
+        mandatoryDependingOnValueEmpty,
+      ]);
       const errors = {
         hasErrors,
-        nameDuplicated
+        nameDuplicated,
       };
       return { ...field, errors };
     })(fields);
   };
 
-  return _.map(group => {
+  return _.map((group) => {
     const nameDuplicated = _.indexOf(group.name)(duplicatedGroupNames) >= 0;
-
+    const nameEmpty = _.isEmpty(group.name);
     const fields = parseFieldsValidation(group.fields);
-    const hasFieldErrors = _.flow([_.map(x => x.errors.hasErrors), arrayAnd])(
+    const hasNoFields = _.isEmpty(group.fields);
+    const hasFieldErrors = _.flow([_.map((x) => x.errors.hasErrors), arrayAnd])(
       fields
     );
 
-    const hasErrors = _.indexOf(true)([nameDuplicated, hasFieldErrors]) >= 0;
+    const hasErrors =
+      _.indexOf(true)([
+        nameDuplicated,
+        nameEmpty,
+        hasFieldErrors,
+        hasNoFields,
+      ]) >= 0;
+
     const errors = {
       hasErrors,
-      nameDuplicated
+      nameDuplicated,
     };
     return { ...group, fields, errors };
   })(content);