@uxland/primary-shell 7.36.5 → 7.37.0

package/dist/primary/shell/src/api/ecap-event-manager/ecap-event-manager.d.ts

@@ -1,16 +1,20 @@
+import { PrimariaGlobalStateManager } from '../global-state/global-state';
+export declare const LAST_WORKED_DIAGNOSTICS_KEY = "lastWorkedDiagnostics";
 export declare abstract class EcapEventManager {
     /**
      * Publish an Ecap event.
-     * @param event - Event name.
      * @param eventType - Event type.
-     * @param url - Asociated URL to event.
+     * @param accio - Action.
+     * @param payload - Additional payload properties.
      */
-    abstract publish(eventType: string, accio: string, payload?: Record<string, string>): void;
+    abstract publish(eventType: string, accio: string, payload?: Record<string, unknown>): void;
 }
 declare class EcapEventManagerImpl implements EcapEventManager {
-    publish(eventType: string, accio: string, payload?: Record<string, string>): void;
+    private globalStateManager;
+    constructor(globalStateManager: PrimariaGlobalStateManager);
+    publish(eventType: string, accio: string, payload?: Record<string, unknown>): void;
     private createEcapEvent;
     private raiseEcapEvent;
 }
-export declare const createEcapEventManager: () => EcapEventManagerImpl;
+export declare const createEcapEventManager: (globalStateManager: PrimariaGlobalStateManager) => EcapEventManagerImpl;
 export {};

package/dist/primary/shell/src/api/ecap-event-manager/typings.d.ts

@@ -1,5 +1,6 @@
 export interface IEcapEvent {
     TipusEvent: string;
     Accio: string;
-    [key: string]: string;
+    diagnostics?: unknown[];
+    [key: string]: unknown;
 }

package/package.json

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

package/src/api/api.ts

@@ -61,7 +61,7 @@ const pluginBusyManager = new PluginBusyManagerImpl();
 const quickActionBusyManager = new QuickActionBusyManagerImpl(broker);
 const interactionService = new ParimariaInteractionServiceImpl();
 const notificationService = new PrimariaNotificationServiceImpl();
-const ecapEventManager = createEcapEventManager();
+const ecapEventManager = createEcapEventManager(globalStateManager);
 const pdfViewerManager = createPdfViewerManager(broker, notificationService);
 const importDataManager = new ImportDataManagerImpl(interactionService);
 

package/src/api/ecap-event-manager/ecap-event-manager.test.ts

@@ -1,5 +1,12 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createEcapEventManager } from "./ecap-event-manager";
+import { createEcapEventManager, LAST_WORKED_DIAGNOSTICS_KEY } from "./ecap-event-manager";
+
+const createMockGlobalStateManager = (data: Record<string, unknown> = {}) =>
+  ({
+    getData: vi.fn((key: string) => data[key]),
+    setData: vi.fn(),
+    clearData: vi.fn(),
+  }) as any;
 
 describe("EcapEventManagerImpl", () => {
   const mockPostMessage = vi.fn();
@@ -16,29 +23,67 @@ describe("EcapEventManagerImpl", () => {
     };
   });
 
-  it("should publish and post the event correctly", () => {
-    const eventManager = createEcapEventManager();
+  it("should publish and post the event correctly without diagnostics for non-whitelisted events", () => {
+    const diagnostics = [{ codi: "J06" }];
+    const globalStateManager = createMockGlobalStateManager({ [LAST_WORKED_DIAGNOSTICS_KEY]: diagnostics });
+    const eventManager = createEcapEventManager(globalStateManager);
     const payload = { url: "https://example.com", user: "john" };
 
     eventManager.publish("click", "navigate", payload);
 
-    const expectedEvent = {
-      TipusEvent: "click",
-      Accio: "navigate",
-      ...payload,
-    };
+    const postedEvent = JSON.parse(mockPostMessage.mock.calls[0][0]);
+    expect(postedEvent.diagnostics).toBeUndefined();
+    expect(globalStateManager.getData).not.toHaveBeenCalled();
+  });
+
+  it("should include diagnostics for whitelisted events", () => {
+    const diagnostics = [{ codi: "J06", cataleg: "CIM-10", descripcio: "Test", idEcap: "1", idCipds: "2", idCdr: "3" }];
+    const globalStateManager = createMockGlobalStateManager({ [LAST_WORKED_DIAGNOSTICS_KEY]: diagnostics });
+    const eventManager = createEcapEventManager(globalStateManager);
+
+    eventManager.publish("PRESCRIPCIO_ACTIVA", "NO_TANCAR", {});
+
+    const postedEvent = JSON.parse(mockPostMessage.mock.calls[0][0]);
+    expect(postedEvent.diagnostics).toEqual(diagnostics);
+    expect(globalStateManager.getData).toHaveBeenCalledWith(LAST_WORKED_DIAGNOSTICS_KEY);
+  });
+
+  it.each([
+    "PROVES_ORDRES_CLINIQUES_CONSULTAR",
+    "RESULT_OC",
+    "LABORATORI_SEROTECA_PETICIO_CONSULTA",
+    "ORDRE_TRACTAMENT",
+    "PRESCRIPCIO_ACTIVA",
+    "REV_IT",
+    "OC_EXPRES",
+  ])("should include diagnostics for whitelisted event %s", (eventType) => {
+    const diagnostics = [{ codi: "J06" }];
+    const globalStateManager = createMockGlobalStateManager({ [LAST_WORKED_DIAGNOSTICS_KEY]: diagnostics });
+    const eventManager = createEcapEventManager(globalStateManager);
+
+    eventManager.publish(eventType, "NO_TANCAR", {});
+
+    const postedEvent = JSON.parse(mockPostMessage.mock.calls[0][0]);
+    expect(postedEvent.diagnostics).toEqual(diagnostics);
+  });
+
+  it("should include empty diagnostics array for whitelisted events when none set", () => {
+    const globalStateManager = createMockGlobalStateManager();
+    const eventManager = createEcapEventManager(globalStateManager);
+
+    eventManager.publish("ORDRE_TRACTAMENT", "NO_TANCAR", {});
 
-    expect(mockPostMessage).toHaveBeenCalledWith(JSON.stringify(expectedEvent), "*");
-    expect(mockConsoleLog).toHaveBeenCalledWith("method", JSON.stringify(expectedEvent));
+    const postedEvent = JSON.parse(mockPostMessage.mock.calls[0][0]);
+    expect(postedEvent.diagnostics).toEqual([]);
   });
 
   it("should not fail if window.parent is undefined", () => {
     (window as any).parent = undefined;
 
-    const eventManager = createEcapEventManager();
+    const globalStateManager = createMockGlobalStateManager();
+    const eventManager = createEcapEventManager(globalStateManager);
     const payload = { id: "123" };
 
-    // No error should be thrown
     expect(() => {
       eventManager.publish("custom", "action", payload);
     }).not.toThrow();

package/src/api/ecap-event-manager/ecap-event-manager.ts

@@ -1,22 +1,42 @@
+import type { PrimariaGlobalStateManager } from "../global-state/global-state";
 import { IEcapEvent } from "./typings";
 
+export const LAST_WORKED_DIAGNOSTICS_KEY = "lastWorkedDiagnostics";
+
+const EVENTS_WITH_DIAGNOSTICS = [
+  "PROVES_ORDRES_CLINIQUES_CONSULTAR",
+  "RESULT_OC",
+  "LABORATORI_SEROTECA_PETICIO_CONSULTA",
+  "ORDRE_TRACTAMENT",
+  "PRESCRIPCIO_ACTIVA",
+  "REV_IT",
+  "OC_EXPRES",
+] as const;
+
 export abstract class EcapEventManager {
   /**
    * Publish an Ecap event.
-   * @param event - Event name.
    * @param eventType - Event type.
-   * @param url - Asociated URL to event.
+   * @param accio - Action.
+   * @param payload - Additional payload properties.
    */
-  abstract publish(eventType: string, accio: string, payload?: Record<string, string>): void;
+  abstract publish(eventType: string, accio: string, payload?: Record<string, unknown>): void;
 }
 
 class EcapEventManagerImpl implements EcapEventManager {
-  publish(eventType: string, accio: string, payload?: Record<string, string>) {
+  constructor(private globalStateManager: PrimariaGlobalStateManager) {}
+
+  publish(eventType: string, accio: string, payload?: Record<string, unknown>) {
     const ecapEvent = this.createEcapEvent(eventType, accio, payload ?? {});
+
+    if (EVENTS_WITH_DIAGNOSTICS.includes(eventType as (typeof EVENTS_WITH_DIAGNOSTICS)[number])) {
+      ecapEvent.diagnostics = this.globalStateManager.getData<unknown[]>(LAST_WORKED_DIAGNOSTICS_KEY) ?? [];
+    }
+
     this.raiseEcapEvent(ecapEvent);
   }
 
-  private createEcapEvent(eventType: string, accio: string, payload: Record<string, string>) {
+  private createEcapEvent(eventType: string, accio: string, payload: Record<string, unknown>) {
     return {
       TipusEvent: eventType,
       Accio: accio,
@@ -29,6 +49,5 @@ class EcapEventManagerImpl implements EcapEventManager {
   }
 }
 
-const ecapEventManager = new EcapEventManagerImpl();
-
-export const createEcapEventManager = () => ecapEventManager;
+export const createEcapEventManager = (globalStateManager: PrimariaGlobalStateManager) =>
+  new EcapEventManagerImpl(globalStateManager);

package/src/api/ecap-event-manager/typings.ts

@@ -1,5 +1,6 @@
 export interface IEcapEvent {
   TipusEvent: string;
   Accio: string;
-  [key:string]: string;
+  diagnostics?: unknown[];
+  [key: string]: unknown;
 }