@uxland/primary-shell 5.3.10 → 5.3.11

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/validation/diagnostics/are-same-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import { IActivityHistoryDiagnostic } from '../../model';
+
+export declare const areSameDiagnostics: (diag1: IActivityHistoryDiagnostic[], diag2: IActivityHistoryDiagnostic[]) => boolean;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/validation/diagnostics/are-same-diagnostics.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/validation/diagnostics/has-valid-diagnostics.d.ts

@@ -0,0 +1,4 @@
+import { IActivityHistoryDiagnostic } from '../../model';
+
+export declare const hasValidDiagnostic: (diagnostic: IActivityHistoryDiagnostic) => boolean;
+export declare const hasValidDiagnostics: (diagnostics: IActivityHistoryDiagnostic[]) => boolean;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/validation/diagnostics/has-valid-diagnostics.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/validation/is-valid-professional.d.ts

@@ -0,0 +1 @@
+export declare const hasValidProfessional: (professional: any) => any;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/validation/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const isString: (value: any) => boolean;
+export declare const isBoolean: (value: any) => value is boolean;
+export declare const isArray: (value: any) => value is any[];
+export declare const isValidDateString: (value: any) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxland/primary-shell",
-  "version": "5.3.10",
+  "version": "5.3.11",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",

package/src/internal-plugins/activity-history/activity-history-item/domain/validation/diagnostics/are-same-diagnostics.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from "vitest";
+import { areSameDiagnostics } from "./are-same-diagnostics";
+
+describe("areSameDiagnostics", () => {
+  it("returns true for identical diagnostics in same order", () => {
+    const d1 = [{ codi: "A" }, { codi: "B" }];
+    const d2 = [{ codi: "A" }, { codi: "B" }];
+    expect(areSameDiagnostics(d1, d2)).toBe(true);
+  });
+
+  it("returns true for identical diagnostics in different order", () => {
+    const d1 = [{ codi: "B" }, { codi: "A" }];
+    const d2 = [{ codi: "A" }, { codi: "B" }];
+    expect(areSameDiagnostics(d1, d2)).toBe(true);
+  });
+
+  it("returns false if one diagnostic has extra item", () => {
+    const d1 = [{ codi: "A" }, { codi: "B" }];
+    const d2 = [{ codi: "A" }];
+    expect(areSameDiagnostics(d1, d2)).toBe(false);
+  });
+
+  it("returns false if codes are different", () => {
+    const d1 = [{ codi: "A" }, { codi: "B" }];
+    const d2 = [{ codi: "A" }, { codi: "C" }];
+    expect(areSameDiagnostics(d1, d2)).toBe(false);
+  });
+
+  it("returns true for both empty arrays", () => {
+    expect(areSameDiagnostics([], [])).toBe(true);
+  });
+
+  it("returns false if one is empty and the other is not", () => {
+    expect(areSameDiagnostics([], [{ codi: "X" }])).toBe(false);
+  });
+
+  it("returns true for duplicated codes in both arrays", () => {
+    const d1 = [{ codi: "A" }, { codi: "A" }];
+    const d2 = [{ codi: "A" }, { codi: "A" }];
+    expect(areSameDiagnostics(d1, d2)).toBe(true);
+  });
+
+  it("returns false if duplicated codes differ in count", () => {
+    const d1 = [{ codi: "A" }, { codi: "A" }];
+    const d2 = [{ codi: "A" }];
+    expect(areSameDiagnostics(d1, d2)).toBe(false);
+  });
+});

package/src/internal-plugins/activity-history/activity-history-item/domain/validation/diagnostics/are-same-diagnostics.ts

@@ -0,0 +1,15 @@
+import { IActivityHistoryDiagnostic } from "../../model";
+
+export const areSameDiagnostics = (
+  diag1: IActivityHistoryDiagnostic[],
+  diag2: IActivityHistoryDiagnostic[],
+): boolean => {
+  if (diag1.length !== diag2.length) {
+    return false;
+  }
+
+  const sortedDiag1 = diag1.map((d) => d.codi).sort();
+  const sortedDiag2 = diag2.map((d) => d.codi).sort();
+
+  return sortedDiag1.every((id, index) => id === sortedDiag2[index]);
+};

package/src/internal-plugins/activity-history/activity-history-item/domain/validation/diagnostics/has-valid-diagnostics.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import { hasValidDiagnostic, hasValidDiagnostics } from "./has-valid-diagnostics";
+
+interface IActivityHistoryDiagnostic {
+  codi?: any;
+  cataleg?: any;
+  descripcio?: any;
+}
+
+describe("hasValidDiagnostic", () => {
+  it("returns true for a valid diagnostic", () => {
+    const diag: IActivityHistoryDiagnostic = {
+      codi: "A123",
+      cataleg: "ICD-10",
+      descripcio: "Dolor lumbar",
+    };
+    expect(hasValidDiagnostic(diag)).toBe(true);
+  });
+
+  it("returns false for null", () => {
+    expect(hasValidDiagnostic(null as any)).toBe(false);
+  });
+
+  it("returns false for undefined", () => {
+    expect(hasValidDiagnostic(undefined as any)).toBe(false);
+  });
+
+  it("returns false if one property is missing", () => {
+    const diag: IActivityHistoryDiagnostic = {
+      codi: "B123",
+      cataleg: "CIM10",
+      // descripcio missing
+    };
+    expect(hasValidDiagnostic(diag)).toBe(false);
+  });
+
+  it("returns false if any property is not a string", () => {
+    const diag: IActivityHistoryDiagnostic = {
+      codi: 123,
+      cataleg: "ICD",
+      descripcio: "Texto",
+    };
+    expect(hasValidDiagnostic(diag)).toBe(false);
+  });
+});
+
+describe("hasValidDiagnostics", () => {
+  it("returns true for a valid array of diagnostics", () => {
+    const diagnostics = [
+      { codi: "A", cataleg: "X", descripcio: "D1" },
+      { codi: "B", cataleg: "Y", descripcio: "D2" },
+    ];
+    expect(hasValidDiagnostics(diagnostics)).toBe(true);
+  });
+
+  it("returns true for null input", () => {
+    expect(hasValidDiagnostics(null as any)).toBe(true);
+  });
+
+  it("returns true for undefined input", () => {
+    expect(hasValidDiagnostics(undefined as any)).toBe(true);
+  });
+
+  it("returns false if not all diagnostics are valid", () => {
+    const diagnostics = [
+      { codi: "A", cataleg: "X", descripcio: "D1" },
+      { codi: "", cataleg: 42, descripcio: null },
+    ];
+    expect(hasValidDiagnostics(diagnostics)).toBe(false);
+  });
+
+  it("returns false if diagnostics is not an array", () => {
+    expect(hasValidDiagnostics({} as any)).toBe(false);
+  });
+
+  it("returns true for empty array", () => {
+    expect(hasValidDiagnostics([])).toBe(true);
+  });
+});

package/src/internal-plugins/activity-history/activity-history-item/domain/validation/diagnostics/has-valid-diagnostics.ts

@@ -0,0 +1,20 @@
+import { IActivityHistoryDiagnostic } from "../../model";
+
+export const hasValidDiagnostic = (diagnostic: IActivityHistoryDiagnostic) => {
+  return (
+    diagnostic !== null &&
+    diagnostic !== undefined &&
+    typeof diagnostic.codi === "string" &&
+    typeof diagnostic.cataleg === "string" &&
+    typeof diagnostic.descripcio === "string"
+  );
+};
+
+// Comprueba las propiedades de un diagnóstico
+export const hasValidDiagnostics = (diagnostics: IActivityHistoryDiagnostic[]) => {
+  if (diagnostics === null || diagnostics === undefined) {
+    return true;
+  }
+
+  return Array.isArray(diagnostics) && diagnostics.every(hasValidDiagnostic);
+};

package/src/internal-plugins/activity-history/activity-history-item/domain/validation/is-valid-basic-history-item.ts

@@ -1,17 +1,7 @@
 import { IActivityHistoryItem } from "../model";
+import { isString, isValidDateString } from "./utils";
 
 export const isValidBasicActivityHistoryItem = (obj: IActivityHistoryItem) => {
-  // Función auxiliar para comprobar si una propiedad existe y es del tipo string válido
-  const isString = (value: any) => typeof value === "string" && value.trim() !== "";
-
-  // Función para comprobar si un string representa una fecha válida
- const isValidDateString = (value: any) => {
-  if (typeof value !== "string" || value.trim() === "") return false;
-
-  const date = new Date(value);
-  return date instanceof Date && !Number.isNaN(date.getTime());
-};
-
   // Comprobación del objeto principal
   return (
     obj &&

package/src/internal-plugins/activity-history/activity-history-item/domain/validation/is-valid-full-history-item.ts

@@ -1,46 +1,10 @@
 import { IActivityHistoryItem } from "../model";
+import { hasValidDiagnostics } from "./diagnostics/has-valid-diagnostics";
 import { isValidBasicActivityHistoryItem } from "./is-valid-basic-history-item";
+import { hasValidProfessional } from "./is-valid-professional";
+import { isBoolean, isString } from "./utils";
 
 export const isValidFullActivityHistoryItem = (obj: IActivityHistoryItem) => {
-  // Función auxiliar para comprobar si una propiedad existe y es del tipo esperado
-  const isString = (value) => typeof value === "string" && value.trim() !== "";
-  const isBoolean = (value) => typeof value === "boolean";
-  const isArray = (value) => Array.isArray(value);
-
-  // Comprueba las propiedades del profesional
-  const hasValidProfessional = (professional) => {
-    return (
-      professional &&
-      isString(professional.id) &&
-      isString(professional.name) &&
-      professional.speciality &&
-      isString(professional.speciality.id) &&
-      isString(professional.speciality.description) &&
-      professional.role &&
-      isString(professional.role.id) &&
-      isString(professional.role.description)
-    );
-  };
-
-  // Comprueba las propiedades de un diagnóstico
-  const hasValidDiagnostics = (diagnostics) => {
-    if (diagnostics === null || diagnostics === undefined) {
-      return true;
-    }
-
-    return (
-      Array.isArray(diagnostics) &&
-      diagnostics.every(
-        (diagnostic) =>
-          diagnostic !== null &&
-          diagnostic !== undefined &&
-          typeof diagnostic.codi === "string" &&
-          typeof diagnostic.cataleg === "string" &&
-          typeof diagnostic.descripcio === "string",
-      )
-    );
-  };
-
   // Comprueba las propiedades del centro, up, ep y servicio
   const hasValidCenter = (center) => center && isString(center.id) && isString(center.description);
   const hasValidUp = (up) => up && isString(up.id) && isString(up.description);

package/src/internal-plugins/activity-history/activity-history-item/domain/validation/is-valid-professional.ts

@@ -0,0 +1,16 @@
+import { isString } from "./utils";
+
+// Comprueba las propiedades del profesional
+export const hasValidProfessional = (professional) => {
+  return (
+    professional &&
+    isString(professional.id) &&
+    isString(professional.name) &&
+    professional.speciality &&
+    isString(professional.speciality.id) &&
+    isString(professional.speciality.description) &&
+    professional.role &&
+    isString(professional.role.id) &&
+    isString(professional.role.description)
+  );
+};

package/src/internal-plugins/activity-history/activity-history-item/domain/validation/utils.ts

@@ -0,0 +1,11 @@
+export const isString = (value) => typeof value === "string" && value.trim() !== "";
+export const isBoolean = (value) => typeof value === "boolean";
+export const isArray = (value) => Array.isArray(value);
+
+// Función para comprobar si un string representa una fecha válida
+export const isValidDateString = (value: any) => {
+  if (typeof value !== "string" || value.trim() === "") return false;
+
+  const date = new Date(value);
+  return date instanceof Date && !Number.isNaN(date.getTime());
+};

package/src/internal-plugins/activity-history/activity-history-item/filter/UI/activity-history-filters/template.ts

@@ -65,7 +65,7 @@ export const template = (props: ActivityHistoryFilters) =>
                   ${
                     props.diagnosticFilter &&
                     html`<div class="filter">
-                          <dss-input-dropdown icon="" multiple dropdownFixed type="default" .elements=${props.diagnosticFilter?.values} @onInputDropdownChange=${props._handleDiagnosticFilterChange} .selectedValue=${props.diagnosticFilterEnabledValues}>
+                          <dss-input-dropdown icon="" multiple dropdownFixed type="default" .elements=${props.diagnosticFilter?.values} @onInputDropdownChange=${props._handleDiagnosticFilterChange} .selectedValue=${props.diagnosticFilterEnabledValues} selectorStyle=${"max-height: 450px"}>
                             <label slot="label" for="diagnostic-filter">${props.diagnosticFilter.title}</label>
                             <input id="diagnostic-filter" slot="input" type="text" class="dss-input" autocomplete="off"/>
                           </dss-input-dropdown>

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/add-custom-filters/reducer.ts

@@ -5,5 +5,9 @@ export function addCustomFiltersReducer(
   state,
   action: PayloadAction<IActivityHistoryCustomFilterGroup>,
 ) {
-  state.filters = [...state.filters, action.payload];
+  const exists = state.filters.some((filter) => filter.id === action.payload.id);
+
+  if (!exists) {
+    state.filters = [...state.filters, action.payload];
+  }
 }

package/src/internal-plugins/activity-history/activity-history-item/list/group-history-items/group-history-items.test.ts

@@ -65,7 +65,13 @@ describe("groupActivityHistoryItems", () => {
 
   it("crea subgrupos con mismos diagnósticos", () => {
     const now = new Date();
-    const diagnostics = [{ codi: "D1" }];
+    const diagnostics = [
+      {
+        codi: "A123",
+        cataleg: "ICD-10",
+        descripcio: "Dolor lumbar",
+      },
+    ];
     const items = [
       baseItem({ id: "1", date: now.toISOString(), diagnostics }),
       baseItem({ id: "2", date: new Date(now.getTime() + 1000).toISOString(), diagnostics }),
@@ -78,10 +84,45 @@ describe("groupActivityHistoryItems", () => {
     expect(result[0].items).toHaveLength(0);
   });
 
+  it("no crea subgrupos si alguno de los diagnosticos es invalido", () => {
+    const now = new Date();
+    const diagnostics1 = [
+      {
+        codi: "A123",
+        cataleg: "ICD-10",
+        descripcio: "Dolor lumbar",
+      },
+    ];
+    const diagnostics2 = [
+      {
+        codi: "A123",
+      },
+    ];
+    const items = [
+      baseItem({ id: "1", date: now.toISOString(), diagnostics1 }),
+      baseItem({ id: "2", date: new Date(now.getTime() + 1000).toISOString(), diagnostics2 }),
+    ];
+
+    const result = groupActivityHistoryItems(items);
+
+    expect(result[0].subGroups).toHaveLength(0);
+    expect(result[0].items).toHaveLength(2);
+  });
+
   it("deja fuera de subgrupos ítems sin diagnóstico", () => {
     const now = new Date();
     const items = [
-      baseItem({ id: "1", date: now.toISOString(), diagnostics: [{ codi: "D1" }] }),
+      baseItem({
+        id: "1",
+        date: now.toISOString(),
+        diagnostics: [
+          {
+            codi: "A123",
+            cataleg: "ICD-10",
+            descripcio: "Dolor lumbar",
+          },
+        ],
+      }),
       baseItem({ id: "2", date: new Date(now.getTime() + 1000).toISOString() }),
     ];
 

package/src/internal-plugins/activity-history/activity-history-item/list/group-history-items/group-history-items.ts

@@ -2,8 +2,9 @@ import {
   IActivityHistoryItem,
   IActivityHistoryGroup,
   IActivityHistorySubGroup,
-  IActivityHistoryDiagnostic,
 } from "../../domain/model";
+import { areSameDiagnostics } from "../../domain/validation/diagnostics/are-same-diagnostics";
+import { hasValidDiagnostics } from "../../domain/validation/diagnostics/has-valid-diagnostics";
 
 const isSameVisit = (item1: IActivityHistoryItem, item2: IActivityHistoryItem): boolean => {
   const sameProfessional =
@@ -26,19 +27,44 @@ const withinEightHours = (date1: string, date2: string): boolean => {
   return timeDifference <= 8 * 60 * 60 * 1000; // 8 hours in milliseconds
 };
 
-const areSameDiagnostics = (
-  diag1: IActivityHistoryDiagnostic[],
-  diag2: IActivityHistoryDiagnostic[],
-): boolean => {
-  if (diag1.length !== diag2.length) {
-    return false;
-  }
+function groupByValidDiagnostics(groups: IActivityHistoryGroup[]) {
+  groups.forEach((group) => {
+    const subGroups: IActivityHistorySubGroup[] = [];
+    const remainingItems: IActivityHistoryItem[] = [];
+
+    group.items.forEach((item) => {
+      const diagnostics = item.diagnostics;
 
-  const sortedDiag1 = diag1.map((d) => d.codi).sort();
-  const sortedDiag2 = diag2.map((d) => d.codi).sort();
+      const allDiagnosticsValid = diagnostics?.length > 0 && hasValidDiagnostics(diagnostics);
 
-  return sortedDiag1.every((id, index) => id === sortedDiag2[index]);
-};
+      if (allDiagnosticsValid) {
+        let addedToSubGroup = false;
+
+        for (const subGroup of subGroups) {
+          const firstSubGroupItem = subGroup.items[0];
+
+          if (areSameDiagnostics(firstSubGroupItem.diagnostics, diagnostics)) {
+            subGroup.items.push(item);
+            addedToSubGroup = true;
+            break;
+          }
+        }
+
+        if (!addedToSubGroup) {
+          subGroups.push({
+            idSubGroup: crypto.randomUUID(),
+            items: [item],
+          });
+        }
+      } else {
+        remainingItems.push(item);
+      }
+    });
+
+    group.items = remainingItems;
+    group.subGroups = subGroups;
+  });
+}
 
 const groupActivityHistoryItems = (items: IActivityHistoryItem[]): IActivityHistoryGroup[] => {
   const groups: IActivityHistoryGroup[] = [];
@@ -85,7 +111,7 @@ const groupActivityHistoryItems = (items: IActivityHistoryItem[]): IActivityHist
     // Si no se pudo agrupar, crear un nuevo grupo
     if (!added) {
       groups.push({
-        idGroup: Math.random().toString(36).substr(2, 9),
+        idGroup: crypto.randomUUID(),
         items: [item],
         sameVisit: false,
       });
@@ -93,38 +119,8 @@ const groupActivityHistoryItems = (items: IActivityHistoryItem[]): IActivityHist
   });
 
   // Crear subgrupos por diagnósticos iguales. Los items que no tienen diagnostico, se quedan fuera de subgrupos (remaining items)
-  groups.forEach((group) => {
-    const subGroups: IActivityHistorySubGroup[] = [];
-    const remainingItems: IActivityHistoryItem[] = [];
 
-    group.items.forEach((item) => {
-      if (item.diagnostics?.length > 0) {
-        let addedToSubGroup = false;
-
-        for (const subGroup of subGroups) {
-          const firstSubGroupItem = subGroup.items[0];
-
-          if (areSameDiagnostics(firstSubGroupItem.diagnostics, item.diagnostics)) {
-            subGroup.items.push(item);
-            addedToSubGroup = true;
-            break;
-          }
-        }
-
-        if (!addedToSubGroup) {
-          subGroups.push({
-            idSubGroup: Math.random().toString(36).substr(2, 9),
-            items: [item],
-          });
-        }
-      } else {
-        remainingItems.push(item);
-      }
-    });
-
-    group.items = remainingItems;
-    group.subGroups = subGroups;
-  });
+  groupByValidDiagnostics(groups);
 
   return groups;
 };