@truedat/dd 8.12.2 → 8.12.5

package/src/selectors/messages.js

@@ -48,6 +48,32 @@ const uploadAccepted = () => {
   };
 };
 
+const uploadFailed = (data) => ({
+  error: true,
+  header: "structures.bulkUpdateStructures.failed.header",
+  icon: "attention",
+  color: "red",
+  text: "",
+  messages: _.has("errors")(data)
+    ? _.flow(
+        _.propOr([], "errors"),
+        _.map((error) => ({
+          id: `structures.bulkUpdateStructures.failed.note.${error.message}`,
+          fields: {
+            row: error.row,
+            id: error.id,
+            field: error.field,
+            externalId: error.external_id,
+            message: error.message,
+          },
+          defaultMessage: "structures.bulkUploadStructures.success.errors",
+        })),
+      )(data)
+    : [],
+  fields: data?.errors ? { count_errors: data.errors.length } : {},
+  initialMaxListItems: 5,
+});
+
 export const getUploadAlertMessage = ({ status, data }) => {
   if (status === 202) {
     return uploadAccepted();
@@ -55,4 +81,8 @@ export const getUploadAlertMessage = ({ status, data }) => {
   if (status === 200) {
     return uploadWithErrors(data);
   }
+  if (status >= 400) {
+    return uploadFailed(data || {});
+  }
+  return uploadAccepted();
 };

package/src/selectors/structureColumnsSelector.js

@@ -64,23 +64,20 @@ export const defaultStructureColumns = [
   },
 ];
 
-// If default filters include "system.name.raw", exclude the "system" column
-const filterExcludes = { "system.name.raw": "system" };
-
-const columnsToExclude = (defaultFilters) =>
-  _.flow(_.pick(_.keys(defaultFilters)), _.values)(filterExcludes);
+const filteredStructureColumns = createSelector(
+  (state) => state.structuresColumns ?? defaultStructureColumns,
+  _.reject(({ name }) => name === "system"),
+);
 
-export const structureColumnsSelector = (state, defaultFilters, ownColumns) =>
-  createSelector(_.prop("structuresColumns"), (columns) => {
-    const excludes = columnsToExclude(defaultFilters);
-    const res = ownColumns
-      ? ownColumns
-      : _.flow(
-          _.defaultTo(defaultStructureColumns),
-          _.reject(({ name }) => _.includes(name)(excludes)),
-        )(columns);
-    return res;
-  })(state);
+export const structureColumnsSelector = (state, defaultFilters, ownColumns) => {
+  if (ownColumns) return ownColumns;
+  return Object.prototype.hasOwnProperty.call(
+    defaultFilters || {},
+    "system.name.raw",
+  )
+    ? filteredStructureColumns(state)
+    : (state.structuresColumns ?? defaultStructureColumns);
+};
 
 const rawName = {
   name: "name",

package/src/utils/__tests__/structureNoteActions.spec.js

@@ -0,0 +1,196 @@
+import {
+  hasMandatoryErrors,
+  canPerformAction,
+  getMissingMandatoryFields,
+} from "../structureNoteActions";
+
+describe("hasMandatoryErrors", () => {
+  const template = {
+    content: [
+      {
+        name: "group",
+        fields: [
+          {
+            name: "required_field",
+            type: "string",
+            cardinality: "1",
+          },
+          {
+            name: "optional_field",
+            type: "string",
+            cardinality: "?",
+          },
+        ],
+      },
+    ],
+  };
+
+  it("returns false when content is null/undefined", () => {
+    expect(hasMandatoryErrors(null, template)).toBe(false);
+    expect(hasMandatoryErrors(undefined, template)).toBe(false);
+  });
+
+  it("returns false when template is null/undefined", () => {
+    expect(hasMandatoryErrors({}, null)).toBe(false);
+    expect(hasMandatoryErrors({}, undefined)).toBe(false);
+  });
+
+  it("returns true when a mandatory field is missing", () => {
+    const content = { optional_field: { value: "x", origin: "user" } };
+    expect(hasMandatoryErrors(content, template)).toBe(true);
+  });
+
+  it("returns false when all mandatory fields are populated", () => {
+    const content = {
+      required_field: { value: "ok", origin: "user" },
+      optional_field: { value: "x", origin: "user" },
+    };
+    expect(hasMandatoryErrors(content, template)).toBe(false);
+  });
+
+  it("returns true when a mandatory field is present but empty", () => {
+    const content = {
+      required_field: { value: "", origin: "user" },
+    };
+    expect(hasMandatoryErrors(content, template)).toBe(true);
+  });
+
+  it("returns true when a mandatory field is null", () => {
+    const content = {
+      required_field: { value: null, origin: "user" },
+    };
+    expect(hasMandatoryErrors(content, template)).toBe(true);
+  });
+});
+
+describe("getMissingMandatoryFields", () => {
+  const template = {
+    content: [
+      {
+        name: "group",
+        fields: [
+          {
+            name: "required_field",
+            type: "string",
+            cardinality: "1",
+          },
+          {
+            name: "another_required",
+            type: "string",
+            cardinality: "+",
+          },
+          {
+            name: "optional_field",
+            type: "string",
+            cardinality: "?",
+          },
+        ],
+      },
+    ],
+  };
+
+  it("returns empty array when content is null/undefined", () => {
+    expect(getMissingMandatoryFields(null, template)).toEqual([]);
+    expect(getMissingMandatoryFields(undefined, template)).toEqual([]);
+  });
+
+  it("returns empty array when template is null/undefined", () => {
+    expect(getMissingMandatoryFields({}, null)).toEqual([]);
+    expect(getMissingMandatoryFields({}, undefined)).toEqual([]);
+  });
+
+  it("returns list of missing field names", () => {
+    const content = { optional_field: { value: "x", origin: "user" } };
+    const missing = getMissingMandatoryFields(content, template);
+    expect(missing).toContain("required_field");
+    expect(missing).toContain("another_required");
+    expect(missing).toHaveLength(2);
+  });
+
+  it("returns empty array when all mandatory fields are populated", () => {
+    const content = {
+      required_field: { value: "ok", origin: "user" },
+      another_required: { value: ["a"], origin: "user" },
+      optional_field: { value: "x", origin: "user" },
+    };
+    expect(getMissingMandatoryFields(content, template)).toEqual([]);
+  });
+});
+
+describe("canPerformAction (TD-7093)", () => {
+  const template = {
+    content: [
+      {
+        name: "group",
+        fields: [
+          {
+            name: "required_field",
+            type: "string",
+            cardinality: "1",
+          },
+        ],
+      },
+    ],
+  };
+
+  const fullContent = { required_field: { value: "ok", origin: "user" } };
+  const partialContent = { optional_field: { value: "x", origin: "user" } };
+
+  describe("publishing actions", () => {
+    it("returns false for 'published' when mandatory fields are missing", () => {
+      expect(canPerformAction("published", partialContent, template)).toBe(
+        false,
+      );
+    });
+
+    it("returns true for 'published' when all mandatory fields are populated", () => {
+      expect(canPerformAction("published", fullContent, template)).toBe(true);
+    });
+
+    it("returns false for 'pending_approval' when mandatory fields are missing", () => {
+      expect(
+        canPerformAction("pending_approval", partialContent, template),
+      ).toBe(false);
+    });
+
+    it("returns true for 'pending_approval' when all mandatory fields are populated", () => {
+      expect(canPerformAction("pending_approval", fullContent, template)).toBe(
+        true,
+      );
+    });
+  });
+
+  describe("draft actions", () => {
+    it("always allows 'edited' even with partial content", () => {
+      expect(canPerformAction("edited", partialContent, template)).toBe(true);
+    });
+
+    it("always allows 'draft' even with partial content", () => {
+      expect(canPerformAction("draft", partialContent, template)).toBe(true);
+    });
+
+    it("always allows 'deleted' even with partial content", () => {
+      expect(canPerformAction("deleted", partialContent, template)).toBe(true);
+    });
+
+    it("always allows 'rejected' even with partial content", () => {
+      expect(canPerformAction("rejected", partialContent, template)).toBe(true);
+    });
+
+    it("always allows 'deprecated' even with partial content", () => {
+      expect(canPerformAction("deprecated", partialContent, template)).toBe(
+        true,
+      );
+    });
+  });
+
+  describe("edge cases", () => {
+    it("returns true for publishing actions when template is missing (no validation possible)", () => {
+      expect(canPerformAction("published", partialContent, null)).toBe(true);
+    });
+
+    it("returns true for publishing actions when content is missing (no validation possible)", () => {
+      expect(canPerformAction("published", null, template)).toBe(true);
+    });
+  });
+});

package/src/utils/structureNoteActions.js

@@ -0,0 +1,22 @@
+import { validateContent } from "@truedat/df/utils";
+
+export const getMissingMandatoryFields = (content, template) => {
+  if (!template || !content) return [];
+  const errors = validateContent(template)(content);
+  return Array.isArray(errors)
+    ? errors
+        .filter((err) => err && err.error === "missing required" && err.field)
+        .map((err) => err.field)
+    : [];
+};
+
+export const hasMandatoryErrors = (content, template) => {
+  return getMissingMandatoryFields(content, template).length > 0;
+};
+
+export const canPerformAction = (action, content, template) => {
+  if (action === "pending_approval" || action === "published") {
+    return !hasMandatoryErrors(content, template);
+  }
+  return true;
+};