@truedat/df 4.37.4 → 4.38.2

package/src/messages/en.js

@@ -8,6 +8,8 @@ export default {
   "template.actions.delete.confirmation.content":
     "Template {name} will be deleted. Are you sure?",
   "template.actions.delete.confirmation.header": "Delete Template",
+  "template.field.action.cancel": "Cancel",
+  "template.field.action.save": "Save",
   "template.field.autogenerated": "Generated automatically",
   "template.field.cardinality": "Cardinality",
   "template.field.cardinality.0": "None (autogenerated)",
@@ -19,6 +21,7 @@ export default {
   "template.field.depends.on": "Source Field",
   "template.field.depends.to_be": "Source Value",
   "template.field.description": "Description",
+  "template.field.hidden_secret": "<Hidden secret value>",
   "template.field.label": "Label",
   "template.field.mandatory.depends": "Mandatory depending on",
   "template.field.mandatory.depends.on": "Depending on",

package/src/messages/es.js

@@ -8,6 +8,8 @@ export default {
   "template.actions.delete.confirmation.content":
     "Se va a eliminar la plantilla {name}. ¿Estás seguro?",
   "template.actions.delete.confirmation.header": "Eliminar plantilla",
+  "template.field.action.cancel": "Cancelar",
+  "template.field.action.save": "Guardar",
   "template.field.autogenerated": "Generado automáticamente",
   "template.field.cardinality": "Cardinalidad",
   "template.field.cardinality.0": "Ninguno (autogenerado)",
@@ -19,6 +21,7 @@ export default {
   "template.field.depends.on": "Campo origen",
   "template.field.depends.to_be": "Valor origen",
   "template.field.description": "Descripción",
+  "template.field.hidden_secret": "<Campo secreto oculto>",
   "template.field.mandatory.depends": "Obligatorio dependiente de",
   "template.field.mandatory.depends.on": "Depende de",
   "template.field.mandatory.depends.to_be": "Valor dependiente",

package/src/styles/fieldGroupDetail.less

@@ -1,6 +1,56 @@
 .list > .item > .header.dynamic-field-header {
   margin-bottom: 10px;
 }
+.list > .item > .header.dynamic-field-header i{
+  visibility: hidden;
+}
+
+.list > .item > .header.editable-dynamic-field-header{
+  cursor: pointer;
+}
+
+.list > .item > .header.editable-dynamic-field-header i{
+  color: rgba(0, 0, 0, 0.8);
+  font-size: 14px;
+  margin-left: 5px;
+  visibility: hidden;
+}
+
+.list > .item > .header.editable-dynamic-field-header:hover i{
+  visibility: visible;
+}
+
+.editable-dynamic-field-buttons{
+  padding: 8px;
+}
+
+.editable-dynamic-field-button-shake {
+  animation: shake 1s;
+}
+
+@keyframes shake {
+  10%, 90% {
+    transform: translate3d(-1px, 0, 0);
+  }
+  
+  20%, 80% {
+    transform: translate3d(2px, 0, 0);
+  }
+
+  30%, 50%, 70% {
+    transform: translate3d(-4px, 0, 0);
+  }
+
+  40%, 60% {
+    transform: translate3d(4px, 0, 0);
+  }
+}
+
+.hidden-secret-value {
+  font-family: 'Courier New', Courier, monospace;
+  color: #888;
+}
+
 
 .identifier-value {
   font-family: 'Courier New', Courier, monospace;

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

@@ -0,0 +1,120 @@
+import { parseFieldOptions } from "..";
+
+describe("utils: parseFieldOptions", () => {
+  it("adds value to field", () => {
+    const field = { name: "field" };
+    const content = { field: "1" };
+    const result = parseFieldOptions(content)(field);
+    expect(result).toEqual({ ...field, value: "1" });
+  });
+
+  it("handles values switch", () => {
+    const field = {
+      name: "field",
+      values: {
+        switch: {
+          on: "switcher",
+          values: {
+            odd: ["1", "3"],
+            even: ["2", "4"],
+          },
+        },
+      },
+    };
+    const content = { field: "1", switcher: "odd" };
+    const result = parseFieldOptions(content)(field);
+    expect(result).toEqual({
+      ...field,
+      value: "1",
+      parsed_values: [
+        { text: "1", value: "1" },
+        { text: "3", value: "3" },
+      ],
+    });
+  });
+
+  it("handles values fixed", () => {
+    const field = {
+      name: "field",
+      values: {
+        fixed: ["a", "b", "c"],
+      },
+    };
+    const content = { field: "b" };
+    const result = parseFieldOptions(content)(field);
+    expect(result).toEqual({
+      ...field,
+      value: "b",
+      parsed_values: [
+        { text: "a", value: "a" },
+        { text: "b", value: "b" },
+        { text: "c", value: "c" },
+      ],
+    });
+  });
+
+  it("handles values fixed_tuple", () => {
+    const field = {
+      name: "field",
+      values: {
+        fixed_tuple: [
+          { text: "a", value: "a" },
+          { text: "b", value: "b" },
+        ],
+      },
+    };
+    const content = { field: "a" };
+    const result = parseFieldOptions(content)(field);
+    expect(result).toEqual({
+      ...field,
+      value: "a",
+      parsed_values: [
+        { text: "a", value: "a" },
+        { text: "b", value: "b" },
+      ],
+    });
+  });
+
+  it("handles values role_users", () => {
+    const field = {
+      name: "field",
+      values: {
+        role_users: {},
+        processed_users: ["x", "y", "z"],
+      },
+    };
+    const content = { field: "y" };
+    const result = parseFieldOptions(content)(field);
+    expect(result).toEqual({
+      ...field,
+      value: "y",
+      parsed_values: [
+        { text: "x", value: "x" },
+        { text: "y", value: "y" },
+        { text: "z", value: "z" },
+      ],
+    });
+  });
+
+  it("handles values domain", () => {
+    const selectedDomain = { id: 1 };
+    const field = {
+      name: "field",
+      values: {
+        domain: {
+          1: ["foo", "bar"],
+        },
+      },
+    };
+    const content = { field: "bar" };
+    const result = parseFieldOptions(content, selectedDomain)(field);
+    expect(result).toEqual({
+      ...field,
+      value: "bar",
+      parsed_values: [
+        { text: "foo", value: "foo" },
+        { text: "bar", value: "bar" },
+      ],
+    });
+  });
+});

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

@@ -0,0 +1,228 @@
+import { parseGroups } from "..";
+
+describe("utils: parseGroups", () => {
+  it("adds required and value to field", () => {
+    const template = {
+      content: [
+        {
+          name: "group1",
+          fields: [
+            { name: "field" },
+            { name: "field_mandatory", cardinality: "1" },
+          ],
+        },
+      ],
+    };
+    const content = { field: "1", field_mandatory: "2" };
+    const result = parseGroups(template, content);
+    expect(result).toEqual([
+      {
+        fields: [
+          { name: "field", required: false, value: "1" },
+          {
+            name: "field_mandatory",
+            required: true,
+            value: "2",
+            cardinality: "1",
+          },
+        ],
+        name: "group1",
+      },
+    ]);
+  });
+  it("omits fields", () => {
+    const template = {
+      content: [
+        {
+          name: "group1",
+          fields: [{ name: "field" }, { name: "ommitedField" }],
+        },
+      ],
+    };
+    const content = { field: "1" };
+    const fieldsToOmit = ["ommitedField"];
+    const result = parseGroups(template, content, fieldsToOmit);
+    expect(result).toEqual([
+      {
+        fields: [{ name: "field", required: false, value: "1" }],
+        name: "group1",
+      },
+    ]);
+  });
+  it("hides dependant fields and parses values", () => {
+    const template = {
+      content: [
+        {
+          name: "group1",
+          fields: [
+            { name: "parent", values: { fixed: ["a", "b"] } },
+            { name: "dependant_hidden", depends: { on: "parent", to_be: "a" } },
+            { name: "dependant", depends: { on: "parent", to_be: "b" } },
+          ],
+        },
+      ],
+    };
+    const content = { parent: "b", dependant: "value" };
+    const fieldsToOmit = ["ommitedField"];
+    const result = parseGroups(template, content, fieldsToOmit);
+    expect(result).toEqual([
+      {
+        fields: [
+          {
+            name: "parent",
+            parsed_values: [
+              { text: "a", value: "a" },
+              { text: "b", value: "b" },
+            ],
+            values: { fixed: ["a", "b"] },
+            required: false,
+            value: "b",
+          },
+          {
+            name: "dependant",
+            depends: { on: "parent", to_be: "b" },
+            value: "value",
+            required: false,
+          },
+        ],
+        name: "group1",
+      },
+    ]);
+  });
+  it("hides dependant fields of multiple values", () => {
+    const template = {
+      content: [
+        {
+          name: "group1",
+          fields: [
+            { name: "parent", values: { fixed: ["a", "b", "c"] } },
+            { name: "dependant_hidden", depends: { on: "parent", to_be: "a" } },
+          ],
+        },
+      ],
+    };
+    const content = { parent: ["b", "c"] };
+    const fieldsToOmit = ["ommitedField"];
+    const result = parseGroups(template, content, fieldsToOmit);
+    expect(result).toEqual([
+      {
+        fields: [
+          {
+            name: "parent",
+            parsed_values: [
+              { text: "a", value: "a" },
+              { text: "b", value: "b" },
+              { text: "c", value: "c" },
+            ],
+            values: { fixed: ["a", "b", "c"] },
+            required: false,
+            value: ["b", "c"],
+          },
+        ],
+        name: "group1",
+      },
+    ]);
+  });
+  it("hides fields of switch type", () => {
+    const template = {
+      content: [
+        {
+          name: "group1",
+          fields: [
+            { name: "parent", values: { fixed: ["a", "b"] } },
+            {
+              name: "dependant_hidden",
+              values: {
+                switch: { on: "parent", values: { a: "1" } },
+              },
+            },
+            {
+              name: "dependant",
+              values: {
+                switch: { on: "parent", values: { b: "1" } },
+              },
+            },
+          ],
+        },
+      ],
+    };
+    const content = { parent: "b", dependant: "1" };
+    const fieldsToOmit = ["ommitedField"];
+    const result = parseGroups(template, content, fieldsToOmit);
+    expect(result).toEqual([
+      {
+        fields: [
+          {
+            name: "parent",
+            parsed_values: [
+              { text: "a", value: "a" },
+              { text: "b", value: "b" },
+            ],
+            values: { fixed: ["a", "b"] },
+            required: false,
+            value: "b",
+          },
+          {
+            name: "dependant",
+            values: {
+              switch: { on: "parent", values: { b: "1" } },
+            },
+            parsed_values: [{ text: "1", value: "1" }],
+            value: "1",
+            required: false,
+          },
+        ],
+        name: "group1",
+      },
+    ]);
+  });
+  it("filters groups without fields", () => {
+    const template = {
+      content: [
+        {
+          name: "group1",
+          fields: [{ name: "field" }],
+        },
+        { name: "empty_group" },
+      ],
+    };
+    const content = { field: "1" };
+    const result = parseGroups(template, content);
+    expect(result).toEqual([
+      {
+        fields: [{ name: "field", required: false, value: "1" }],
+        name: "group1",
+      },
+    ]);
+  });
+  it("enriches isSecret", () => {
+    const template = {
+      content: [
+        {
+          name: "group1",
+          fields: [{ name: "not_secret" }],
+        },
+        {
+          name: "group2",
+          fields: [{ name: "secret" }],
+          is_secret: true,
+        },
+      ],
+    };
+    const content = { secret: "1", not_secret: "2" };
+    const result = parseGroups(template, content);
+    expect(result).toEqual([
+      {
+        fields: [{ name: "not_secret", required: false, value: "2" }],
+        name: "group1",
+      },
+      {
+        fields: [
+          { name: "secret", required: false, value: "1", isSecret: true },
+        ],
+        is_secret: true,
+        name: "group2",
+      },
+    ]);
+  });
+});

package/src/templates/utils/index.js

@@ -12,3 +12,5 @@ export {
   validateContent,
   validateRequired,
 } from "./validateContent";
+export { parseFieldOptions } from "./parseFieldOptions";
+export { parseGroups } from "./parseGroups";

package/src/templates/utils/parseFieldOptions.js

@@ -0,0 +1,41 @@
+import _ from "lodash/fp";
+const stringToValueTextList = _.map((v) => ({ value: v, text: v }));
+
+const parseFieldOptions = (content, selectedDomain) => (field) => {
+  const value = _.prop(field?.name)(content);
+  if (!field?.values) return { ...field, value };
+
+  const parseSwitch = (values) => {
+    const switchOn = _.prop("switch.on")(values);
+    const switchedValues = _.prop(`switch.values.${content[switchOn]}`)(values);
+    return stringToValueTextList(switchedValues);
+  };
+  const parseFixed = _.flow(_.get("fixed"), stringToValueTextList);
+  const parseRoleUsers = _.flow(
+    _.get("processed_users"),
+    _.cond([
+      [_.isArray, _.identity],
+      [_.stubTrue, _.constant([])],
+    ]),
+    stringToValueTextList
+  );
+  const parseDomain = _.flow(
+    _.get("domain"),
+    _.propOr([], _.toString(selectedDomain?.id)),
+    stringToValueTextList
+  );
+
+  const parsed_values = _.flow(
+    _.get("values"),
+    _.cond([
+      [_.has("switch"), parseSwitch],
+      [_.has("fixed"), parseFixed],
+      [_.has("fixed_tuple"), _.get("fixed_tuple")],
+      [_.has("role_users"), parseRoleUsers],
+      [_.has("domain"), parseDomain],
+    ])
+  )(field);
+  return { ...field, value, parsed_values };
+};
+
+export { parseFieldOptions };

package/src/templates/utils/parseGroups.js

@@ -0,0 +1,44 @@
+import _ from "lodash/fp";
+import { enrichRequired } from "./validateContent";
+import { parseFieldOptions } from "./parseFieldOptions";
+
+const hasDependentKeys = (field) =>
+  !_.isNil(_.path("depends.to_be")(field)) &&
+  !_.isNil(_.path("depends.on")(field));
+
+const checkDependency = (field, content) => {
+  const on = _.prop(_.path("depends.on")(field))(content);
+  const to_be = _.path("depends.to_be")(field);
+  return _.isArray(on)
+    ? _.some((d) => to_be.includes(d))(on)
+    : to_be.includes(on);
+};
+
+const enrichIsSecret = (isSecret) => (field) =>
+  isSecret ? { ...field, isSecret } : field;
+
+const parseGroups = (template, content, fieldsToOmit, selectedDomain) =>
+  _.flow(
+    _.getOr([], "content"),
+    _.map((group) => {
+      const fields = _.flow(
+        _.get("fields"),
+        _.filter((field) => !_.includes(fieldsToOmit)(field?.name)),
+        _.filter(
+          (field) =>
+            (!("depends" in field) ||
+              (hasDependentKeys(field) && checkDependency(field, content))) &&
+            (!(field.values && "switch" in field.values) ||
+              _.prop(_.prop("values.switch.on")(field))(content) in
+                _.prop("values.switch.values")(field))
+        ),
+        _.map(parseFieldOptions(content, selectedDomain)),
+        _.map(enrichRequired(content)),
+        _.map(enrichIsSecret(_.get("is_secret")(group)))
+      )(group);
+      return { ...group, fields };
+    }),
+    _.filter(({ fields }) => _.negate(_.isEmpty)(fields))
+  )(template);
+
+export { parseGroups };

package/src/templates/utils/validateContent.js

@@ -53,7 +53,7 @@ export const isRequired = (field, content) =>
   _.includes(field?.cardinality)(["1", "+"]) ||
   dependentRequired(field, content);
 
-export const enrichRequired = (field, content) => {
+export const enrichRequired = (content) => (field) => {
   const required = isRequired(field, content);
   return { ...field, required };
 };