@truedat/df 8.5.9 → 8.6.0

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

@@ -44,6 +44,58 @@ describe("utils: validValues", () => {
       });
     });
 
+    it("should validate processed_groups values", () => {
+      const template = [
+        {
+          name: "role",
+          type: "user_group",
+          values: {
+            role_groups: "some_role",
+            processed_users: ["u1"],
+            processed_groups: ["alias1", "group2"],
+          },
+        },
+      ];
+
+      const result = filterValues(template)({
+        role: { value: "group:alias1", origin: "default" },
+      });
+
+      expect(result).toEqual({
+        role: { value: "group:alias1", origin: "default" },
+      });
+    });
+
+    it("should validate group values without allowing users", () => {
+      const template = [
+        {
+          name: "role",
+          type: "group",
+          values: {
+            role_groups: "some_role",
+            processed_users: ["u1"],
+            processed_groups: ["alias1", "group2"],
+          },
+        },
+      ];
+
+      expect(
+        filterValues(template)({
+          role: { value: "group:alias1", origin: "default" },
+        }),
+      ).toEqual({
+        role: { value: "group:alias1", origin: "default" },
+      });
+
+      expect(
+        filterValues(template)({
+          role: { value: "user:u1", origin: "default" },
+        }),
+      ).toEqual({
+        role: { value: null, origin: "default" },
+      });
+    });
+
     it("should nullify unlisted fixed values", () => {
       const result = filterValues(templateContent)({
         fixed: { value: "ho", origin: "default" },

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

@@ -105,6 +105,51 @@ describe("utils: parseFieldOptions", () => {
     });
   });
 
+  it("handles values role_groups with processed_groups", () => {
+    const field = {
+      name: "field",
+      type: "user_group",
+      values: {
+        role_groups: "Some Role",
+        processed_users: ["x"],
+        processed_groups: ["alias1", "group2"],
+      },
+    };
+    const content = { field: { value: "group:alias1", origin: "default" } };
+    const result = parseFormatFieldOptions(content)(field);
+    expect(result).toEqual({
+      ...field,
+      value: { value: "group:alias1", origin: "default" },
+      parsedValues: [
+        { value: "user:x", text: "x", icon: "user" },
+        { value: "group:alias1", text: "alias1", icon: "group" },
+        { value: "group:group2", text: "group2", icon: "group" },
+      ],
+    });
+  });
+
+  it("handles group values with processed_groups only", () => {
+    const field = {
+      name: "field",
+      type: "group",
+      values: {
+        role_groups: "Some Role",
+        processed_users: ["x"],
+        processed_groups: ["alias1", "group2"],
+      },
+    };
+    const content = { field: { value: "group:alias1", origin: "default" } };
+    const result = parseFormatFieldOptions(content)(field);
+    expect(result).toEqual({
+      ...field,
+      value: { value: "group:alias1", origin: "default" },
+      parsedValues: [
+        { value: "group:alias1", text: "alias1", icon: "group" },
+        { value: "group:group2", text: "group2", icon: "group" },
+      ],
+    });
+  });
+
   it("handles values domain", () => {
     const selectedDomain = { id: 1 };
     const field = {

package/src/templates/utils/filterValues.js

@@ -1,31 +1,53 @@
 import _ from "lodash/fp";
 
+const groupNameOrAlias = (group) =>
+  _.isString(group) ? group : group?.alias || group?.name;
+
 const userGroupValues = (field) =>
   _.concat(
     _.flow(
       _.get("processed_users"),
-      _.map((name) => `user:${name}`)
+      _.map((name) => `user:${name}`),
     )(field),
     _.flow(
       _.get("processed_groups"),
-      _.map((name) => `group:${name}`)
-    )(field)
+      _.map((group) => {
+        const name = groupNameOrAlias(group);
+        return `group:${name}`;
+      }),
+    )(field),
   );
 
+const groupValues = _.flow(
+  _.get("processed_groups"),
+  _.map((group) => {
+    const name = groupNameOrAlias(group);
+    return `group:${name}`;
+  }),
+);
+
 export const validValues = _.flow(
   _.filter(
-    _.overSome([_.has("values.fixed"), _.has("values.processed_users")])
+    _.overSome([
+      _.has("values.fixed"),
+      _.has("values.processed_users"),
+      _.has("values.processed_groups"),
+    ]),
   ),
-  _.map(_.pick(["name", "values"])),
-  _.map(({ name, values }) => [
+  _.map(_.pick(["name", "type", "values"])),
+  _.map(({ name, type, values }) => [
     name,
     _.cond([
       [_.has("fixed"), _.pathOr([], "fixed")],
+      [
+        () => type === "group" && _.has("processed_groups")(values),
+        groupValues,
+      ],
       [_.has("processed_groups"), userGroupValues],
       [_.has("processed_users"), _.pathOr([], "processed_users")],
     ])(values),
   ]),
-  _.fromPairs
+  _.fromPairs,
 );
 
 export const filterValues = (templateContent) => {
@@ -34,12 +56,12 @@ 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 }
-      : value
+      : value,
   );
 };

package/src/templates/utils/parseFieldOptions.js

@@ -44,38 +44,47 @@ const doParseFieldOptions = (formatMessage, content, selectedDomain, field) => {
     ]),
     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) => ({
+  const groupNameOrAlias = (group) =>
+    typeof group === "string" ? group : group.alias || group.name;
+  const parseRoleGroups = (values) => {
+    const groups = _.flow(
+      _.get("processed_groups"),
+      _.map((group) => {
+        const name = groupNameOrAlias(group);
+        return {
           value: `group:${name}`,
           text: name,
           icon: "group",
-        })),
-      )(values),
-    );
+        };
+      }),
+    )(values);
+
+    if (field?.type === "group") return groups;
+
+    const users = _.flow(
+      _.get("processed_users"),
+      _.map((name) => ({
+        value: `user:${name}`,
+        text: name,
+        icon: "user",
+      })),
+    )(values);
+
+    return _.concat(users, groups);
+  };
   const parseDomain = _.flow(
     _.get("domain"),
     (domainValues) => {
       if (!domainValues) return [];
       const domainIds = selectedDomain?.ids || [selectedDomain?.id];
-      const allValues = domainIds
-        ?.filter((id) => id != null)
-        .flatMap((id) => {
-          const strId = String(id);
-          const val = domainValues[strId];
-          return Array.isArray(val) ? val : [];
-        })
-        || [];
+      const allValues =
+        domainIds
+          ?.filter((id) => id != null)
+          .flatMap((id) => {
+            const strId = String(id);
+            const val = domainValues[strId];
+            return Array.isArray(val) ? val : [];
+          }) || [];
       return _.uniq(allValues);
     },
     translateValues,