@uxland/primary-shell 5.1.2 → 5.2.0

package/src/features/exit/bootstrapper.ts

@@ -1,4 +1,4 @@
-import { shellApi } from "../../api/api";
+import { PrimariaApi } from "../../api/api";
 import { BrokerDisposableHandler } from "../../api/broker/primaria-broker";
 import { container } from "../../infrastructure/ioc/container";
 import { registerRequest } from "../utils";
@@ -7,11 +7,11 @@ import { ExitShell } from "./request";
 
 let request: BrokerDisposableHandler;
 
-export const bootstrapExitShell = () => {
-  teardownExitShell();
-  request = registerRequest(shellApi, container)(ExitShell, ExitShellHandler);
+export const useExitShell = (api: PrimariaApi) => {
+  disposeExitShell();
+  request = registerRequest(api, container)(ExitShell, ExitShellHandler);
 };
 
-export const teardownExitShell = () => {
+export const disposeExitShell = () => {
   request?.dispose();
 };

package/src/features/exit/handler.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExitShellHandler } from "./handler";
+import { ExitShell } from "./request";
+import { disposePlugins } from "../../handle-plugins";
+import { disposeShell, raiseCloseEvent } from "../../disposer";
+import { PluginBusyTask } from "../../api/plugin-busy-manager/plugin-busy-manager";
+import { PrimariaApi } from "@uxland/primary-shell";
+
+vi.mock("../../handle-plugins", () => ({
+  disposePlugins: vi.fn(),
+}));
+
+vi.mock("../../disposer", () => ({
+  disposeShell: vi.fn(),
+  raiseCloseEvent: vi.fn(),
+}));
+
+const createMockApi = (): PrimariaApi =>
+  ({
+    pluginBusyManager: {
+      getBusyPluginTasks: vi.fn(),
+    },
+    interactionService: {
+      confirm: vi.fn(),
+    },
+    notificationService: {
+      error: vi.fn(),
+    },
+  }) as any;
+
+describe("ExitShellHandler", () => {
+  let handler: ExitShellHandler;
+  let mockApi: PrimariaApi;
+  const message = {} as ExitShell;
+
+  beforeEach(() => {
+    mockApi = createMockApi();
+    handler = new ExitShellHandler(mockApi);
+    vi.clearAllMocks();
+  });
+
+  it("should dispose and raise close event if no busy tasks", async () => {
+    mockApi.pluginBusyManager.getBusyPluginTasks = vi.fn().mockReturnValue([]);
+    (disposePlugins as any).mockResolvedValue(undefined);
+
+    await handler.handle(message);
+
+    expect(disposePlugins).toHaveBeenCalled();
+    expect(disposeShell).toHaveBeenCalled();
+    expect(raiseCloseEvent).toHaveBeenCalled();
+  });
+
+  it("should ask for confirmation if there are busy tasks", async () => {
+    const busyTasks: PluginBusyTask[] = [{ pluginId: "x" }] as any;
+    mockApi.pluginBusyManager.getBusyPluginTasks = vi.fn().mockReturnValue(busyTasks);
+    mockApi.interactionService.confirm = vi.fn().mockResolvedValue({ confirmed: true });
+    (disposePlugins as any).mockResolvedValue(undefined);
+
+    await handler.handle(message);
+
+    expect(mockApi.interactionService.confirm).toHaveBeenCalled();
+    expect(disposePlugins).toHaveBeenCalled();
+    expect(disposeShell).toHaveBeenCalled();
+    expect(raiseCloseEvent).toHaveBeenCalled();
+  });
+
+  it("should not continue if confirmation is declined", async () => {
+    const busyTasks: PluginBusyTask[] = [{ pluginId: "x" }] as any;
+    mockApi.pluginBusyManager.getBusyPluginTasks = vi.fn().mockReturnValue(busyTasks);
+    mockApi.interactionService.confirm = vi.fn().mockResolvedValue({ confirmed: false });
+
+    await handler.handle(message);
+
+    expect(mockApi.interactionService.confirm).toHaveBeenCalled();
+    expect(disposePlugins).not.toHaveBeenCalled();
+    expect(disposeShell).not.toHaveBeenCalled();
+    expect(raiseCloseEvent).not.toHaveBeenCalled();
+  });
+
+  it("should handle errors and raise close event", async () => {
+    const error = new Error("Something went wrong");
+    mockApi.pluginBusyManager.getBusyPluginTasks = vi.fn().mockReturnValue([]);
+    (disposePlugins as any).mockRejectedValue(error);
+
+    await handler.handle(message);
+
+    expect(mockApi.notificationService.error).toHaveBeenCalledWith("Something went wrong");
+    expect(raiseCloseEvent).toHaveBeenCalled();
+  });
+
+  it("should proceed if disposePlugins takes longer than 5 seconds", async () => {
+    mockApi.pluginBusyManager.getBusyPluginTasks = vi.fn().mockReturnValue([]);
+    (disposePlugins as any).mockImplementation(
+      () => new Promise((resolve) => setTimeout(resolve, 6000)),
+    );
+
+    await handler.handle(message);
+
+    expect(disposePlugins).toHaveBeenCalled();
+    expect(disposeShell).toHaveBeenCalled();
+    expect(raiseCloseEvent).toHaveBeenCalled();
+  });
+});

package/src/features/get-patient-cip/action.ts

@@ -0,0 +1,5 @@
+import { PrimariaApi } from "@uxland/primary-shell";
+
+export const getPatientCip = async (api: PrimariaApi): Promise<string> => {
+  return (await api.broker.send("get_patient_cip")) as string;
+};

package/src/features/get-user-info/bootstrapper.ts

@@ -1,4 +1,4 @@
-import { shellApi } from "../../api/api";
+import { PrimariaApi, shellApi } from "../../api/api";
 import { BrokerDisposableHandler } from "../../api/broker/primaria-broker";
 import { container, registerDep, unregisterDep } from "../../infrastructure/ioc/container";
 import { registerRequest } from "../utils";
@@ -8,13 +8,13 @@ import { GetUserInfo } from "./request";
 
 let request: BrokerDisposableHandler;
 
-export const bootstrapGetUserInfo = () => {
-  teardownGetUserInfo();
-  request = registerRequest(shellApi, container)(GetUserInfo, GetUserInfoHandler);
+export const useGetUserInfo = (api: PrimariaApi) => {
+  disposeGetUserInfo();
+  request = registerRequest(api, container)(GetUserInfo, GetUserInfoHandler);
   registerDep(GetUserInfoBackendAdapter);
 };
 
-export const teardownGetUserInfo = () => {
+export const disposeGetUserInfo = () => {
   request?.dispose();
   unregisterDep(GetUserInfoBackendAdapter);
 };

package/src/features/get-user-info/handler.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { GetUserInfoHandler } from "./handler";
+import { GetUserInfo } from "./request";
+import { IUserInfo } from "./model";
+import { UserInfoBackendAdapter } from "./backend-adapter";
+import { PrimariaApi } from "../../api/api";
+
+const createMockApi = (): PrimariaApi =>
+  ({
+    globalStateManager: {
+      setData: vi.fn(),
+    },
+    notificationService: {
+      error: vi.fn(),
+    },
+  }) as any;
+
+const createMockBackendAdapter = (): UserInfoBackendAdapter =>
+  ({
+    getUserInfo: vi.fn(),
+  }) as any;
+
+describe("GetUserInfoHandler", () => {
+  let handler: GetUserInfoHandler;
+  let api: PrimariaApi;
+  let backendAdapter: UserInfoBackendAdapter;
+
+  const message = {} as GetUserInfo;
+  const mockUserInfo: IUserInfo = {
+    name: "John Doe",
+    email: "john@example.com",
+  };
+
+  beforeEach(() => {
+    api = createMockApi();
+    backendAdapter = createMockBackendAdapter();
+    handler = new GetUserInfoHandler(api, backendAdapter);
+    vi.clearAllMocks();
+  });
+
+  it("should fetch user info and store it in global state", async () => {
+    (backendAdapter.getUserInfo as any).mockResolvedValue(mockUserInfo);
+
+    const result = await handler.handle(message);
+
+    expect(backendAdapter.getUserInfo).toHaveBeenCalled();
+    expect(api.globalStateManager.setData).toHaveBeenCalledWith("userInfo", mockUserInfo);
+    expect(result).toEqual(mockUserInfo);
+  });
+
+  it("should handle error and call notificationService", async () => {
+    const error = new Error("Failed to fetch user info");
+    (backendAdapter.getUserInfo as any).mockRejectedValue(error);
+
+    const result = await handler.handle(message);
+
+    expect(api.notificationService.error).toHaveBeenCalledWith("Failed to fetch user info");
+    expect(result).toBeUndefined();
+  });
+});

package/src/features/get-user-info/handler.ts

@@ -1,10 +1,10 @@
-import { PrimariaApi } from "@uxland/primary-shell";
 import { TYPES } from "../../infrastructure/ioc/types";
 import { inject } from "inversify";
 import { GetUserInfo } from "./request";
 import { IUserInfo } from "./model";
 import { UserInfoBackendAdapter } from "./backend-adapter";
 import { GetUserInfoBackendAdapter } from "./backend-adapter";
+import { PrimariaApi } from "../../api/api";
 
 export class GetUserInfoHandler {
   constructor(
@@ -17,9 +17,7 @@ export class GetUserInfoHandler {
       this.api.globalStateManager.setData("userInfo", userInfo);
       return userInfo;
     } catch (error) {
-      this.api.notificationService.error(
-        error.message,
-      );
+      this.api.notificationService.error(error.message);
     }
   }
 }

package/src/features/navigate-to-ecap/navigate-without-closing-and-with-cip.ts

@@ -0,0 +1,7 @@
+import { shellApi } from "../../api/api";
+import { getPatientCip } from "../get-patient-cip/action";
+
+export const navigateToEcapWithoutClosingWithCip = async (eventName: string) => {
+  const CIP = await getPatientCip(shellApi);
+  shellApi.ecapEventManager.publish(eventName, "NO_TANCAR", { CIP });
+};

package/src/handle-views.ts

@@ -1,158 +1,123 @@
 import { shellApi } from "./api/api";
+import { registerPDFVisorMainView } from "./api/pdf-viewer-manager/handle-views";
 import { shellRegions } from "./api/region-manager/regions";
-import { clinicalMonitoringId, pdfViewerId, pocTestEventsId } from "./constants";
-import { shellEvents } from "./events";
+import { pocTestEventsId } from "./constants";
 import { ExitShell } from "./features/exit/request";
-import { ClinicalMonitoring } from "./UI/components/clinical-monitoring/clinical-monitoring";
-import { PdfVisor } from "./UI/components/pdf-visor/pdf-visor";
+import { getPatientCip } from "./features/get-patient-cip/action";
+import { navigateToEcapWithoutClosingWithCip } from "./features/navigate-to-ecap/navigate-without-closing-and-with-cip";
 import { PocEventsEcap } from "./UI/components/poc-events-ecap/poc-events-ecap";
 import { PrimariaNavItem } from "./UI/shared-components/primaria-nav-item/primaria-nav-item";
 import { PrimariaNavTreeMenu } from "./UI/shared-components/primaria-nav-tree-menu/primaria-nav-tree-menu";
 
-const getPatientCip = async (): Promise<string> => {
-  return (await shellApi.broker.send("get_patient_cip")) as string;
-};
-
-const publishEcapNoCloseWithCip = async (eventName: string) => {
-  const CIP = await getPatientCip();
-  shellApi.ecapEventManager.publish(eventName, "NO_TANCAR", { CIP });
-};
-
 const registerUpperNavMenuViews = () => {
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: pocTestEventsId,
+    id: "landing",
     factory: () => {
       const menuItem = new PrimariaNavItem({
-        icon: "bolt",
-        label: "Prova Events ECAP",
+        icon: "home",
+        label: "Pàgina inici",
         callbackFn: () => {
-          shellApi.regionManager.activateMainView(pocTestEventsId);
+          shellApi.broker.send(new ExitShell());
         },
       });
       return Promise.resolve(menuItem);
     },
     sortHint: "000100",
   });
+
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "communication",
+    id: "processes",
     factory: () => {
       const menuItem = new PrimariaNavTreeMenu({
-        icon: "add_box",
-        label: "Comunicació",
+        icon: "account_tree",
+        label: "Vies clíniques",
         actionMenuItems: [
           {
             icon: "open_in_new",
-            label: "SMS",
-            callbackFn: async (): Promise<void> => {
-              const CIP = await getPatientCip();
-              shellApi.ecapEventManager.publish("MISSATGES_DEV", "NO_TANCAR", {
-                CIP: CIP || "",
-                TipusMissatge: "SMS",
-              });
+            label: "ARES",
+            callbackFn: async () => {
+              navigateToEcapWithoutClosingWithCip("PROCES_ATENCIO");
             },
           },
           {
             icon: "open_in_new",
-            label: "Econsulta",
+            label: "Procés Obstètric",
             callbackFn: (): void => {},
           },
           {
             icon: "open_in_new",
-            label: "Mail",
-            callbackFn: (): void => {},
+            label: "Nen sa",
+            callbackFn: async () => {
+              navigateToEcapWithoutClosingWithCip("NEN_SA");
+            },
           },
           {
             icon: "open_in_new",
-            label: "Veu IP",
-            callbackFn: async (): Promise<void> => {
-              publishEcapNoCloseWithCip("VOIP");
+            label: "Odontologia",
+            callbackFn: async () => {
+              navigateToEcapWithoutClosingWithCip("ODONTOLOGO");
             },
           },
           {
             icon: "open_in_new",
-            label: "Videoconsulta",
-            callbackFn: (): void => {},
+            label: "Situació d'especial cura",
+            callbackFn: async () => {
+              navigateToEcapWithoutClosingWithCip("SIT_ESPEC_CURA_DEV");
+            },
           },
         ],
       });
       return Promise.resolve(menuItem);
     },
-  });
-  shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "visits",
-    factory: () => {
-      const menuItem = new PrimariaNavItem({
-        icon: "add_box",
-        label: "Visites",
-        callbackFn: async (): Promise<void> => {
-          publishEcapNoCloseWithCip("CONSULTA_VISITES");
-        },
-      });
-      return Promise.resolve(menuItem);
-    },
-  });
-  shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "it",
-    factory: () => {
-      const menuItem = new PrimariaNavItem({
-        icon: "add_box",
-        label: "IT",
-        callbackFn: async (): Promise<void> => {
-          publishEcapNoCloseWithCip("REV_IT");
-        },
-      });
-      return Promise.resolve(menuItem);
-    },
+    sortHint: "000400",
   });
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
     id: "unique-petition",
     factory: () => {
       const menuItem = new PrimariaNavTreeMenu({
-        icon: "add_box",
-        label: "Petitori únic",
+        icon: "playlist_add",
+        label: "Petitori",
         actionMenuItems: [
           {
             icon: "open_in_new",
             label: "Analítiques",
             callbackFn: async (): Promise<void> => {
-              publishEcapNoCloseWithCip("LABORATORI");
+              navigateToEcapWithoutClosingWithCip("LABORATORI");
             },
           },
           {
             icon: "open_in_new",
-            label: "OC",
+            label: "Ordres Clíniques",
             callbackFn: async (): Promise<void> => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("RESULT_OC");
+              navigateToEcapWithoutClosingWithCip("RESULT_OC");
             },
           },
           {
             icon: "open_in_new",
             label: "OC Exprés",
             callbackFn: async (): Promise<void> => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("OC_EXPRES");
+              navigateToEcapWithoutClosingWithCip("OC_EXPRES");
             },
           },
           {
             icon: "open_in_new",
             label: "Sol·licitud de trasllat",
             callbackFn: async (): Promise<void> => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("TRANSPORT");
+              navigateToEcapWithoutClosingWithCip("TRANSPORT");
             },
           },
         ],
       });
       return Promise.resolve(menuItem);
     },
+    sortHint: "000500",
   });
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
     id: "results-reports",
     factory: () => {
       const menuItem = new PrimariaNavTreeMenu({
-        icon: "add_box",
-        label: "Resultats i informes",
+        icon: "folder",
+        label: "Documents",
         actionMenuItems: [
           {
             icon: "open_in_new",
@@ -163,9 +128,8 @@ const registerUpperNavMenuViews = () => {
             icon: "open_in_new",
             label: "Documents usuari",
             callbackFn: async (): Promise<void> => {
-              const CIP = await getPatientCip();
               setTimeout(() => {
-                publishEcapNoCloseWithCip("CRIDA_DOCS_USU");
+                navigateToEcapWithoutClosingWithCip("CRIDA_DOCS_USU");
               }, 0);
             },
           },
@@ -173,92 +137,104 @@ const registerUpperNavMenuViews = () => {
       });
       return Promise.resolve(menuItem);
     },
+    sortHint: "000700",
   });
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "processes",
+    id: "communication",
     factory: () => {
       const menuItem = new PrimariaNavTreeMenu({
-        icon: "add_box",
-        label: "Processos",
+        icon: "3p",
+        label: "Comunicació",
         actionMenuItems: [
           {
             icon: "open_in_new",
-            label: "ARES",
-            callbackFn: async () => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("PROCES_ATENCIO");
+            label: "SMS",
+            callbackFn: async (): Promise<void> => {
+              const CIP = await getPatientCip(shellApi);
+              shellApi.ecapEventManager.publish("MISSATGES_DEV", "NO_TANCAR", {
+                CIP: CIP || "",
+                TipusMissatge: "SMS",
+              });
             },
           },
           {
             icon: "open_in_new",
-            label: "Nen sa",
-            callbackFn: async () => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("NEN_SA");
-            },
+            label: "Econsulta",
+            callbackFn: (): void => {},
           },
           {
             icon: "open_in_new",
-            label: "Procés Obstètric",
+            label: "Mail",
             callbackFn: (): void => {},
           },
           {
             icon: "open_in_new",
-            label: "Odontologia",
-            callbackFn: async () => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("ODONTOLOGO");
+            label: "Veu IP",
+            callbackFn: async (): Promise<void> => {
+              navigateToEcapWithoutClosingWithCip("VOIP");
             },
           },
           {
             icon: "open_in_new",
-            label: "Situació d'especial cura",
-            callbackFn: async () => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("SIT_ESPEC_CURA_DEV");
-            },
+            label: "Videoconsulta",
+            callbackFn: (): void => {},
           },
         ],
       });
       return Promise.resolve(menuItem);
     },
+    sortHint: "001200",
   });
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "variable activities",
+    id: "visits",
     factory: () => {
       const menuItem = new PrimariaNavItem({
-        icon: "add_box",
-        label: "Activitats variables",
-        callbackFn: async () => {
-          const CIP = await getPatientCip();
-          publishEcapNoCloseWithCip("SIA_DEV");
+        icon: "today",
+        label: "Visites",
+        callbackFn: async (): Promise<void> => {
+          navigateToEcapWithoutClosingWithCip("CONSULTA_VISITES");
         },
       });
       return Promise.resolve(menuItem);
     },
+    sortHint: "001300",
   });
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: clinicalMonitoringId,
+    id: pocTestEventsId,
     factory: () => {
       const menuItem = new PrimariaNavItem({
-        icon: "add_box",
-        label: "Seguiment clínic",
+        icon: "bolt",
+        label: "Prova Events ECAP",
         callbackFn: () => {
-          shellApi.regionManager.activateMainView(clinicalMonitoringId);
-          shellApi.broker.publish(shellEvents.openClinicalMonitoringRequested);
+          shellApi.regionManager.activateMainView(pocTestEventsId);
         },
       });
       return Promise.resolve(menuItem);
     },
   });
+
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "landing",
+    id: "it",
     factory: () => {
       const menuItem = new PrimariaNavItem({
         icon: "add_box",
-        label: "Pàgina inici",
-        callbackFn: () => {
-          shellApi.broker.send(new ExitShell());
+        label: "IT",
+        callbackFn: async (): Promise<void> => {
+          navigateToEcapWithoutClosingWithCip("REV_IT");
+        },
+      });
+      return Promise.resolve(menuItem);
+    },
+  });
+
+  shellApi.regionManager.registerView(shellRegions.navigationMenu, {
+    id: "variable activities",
+    factory: () => {
+      const menuItem = new PrimariaNavItem({
+        icon: "add_box",
+        label: "Activitats variables",
+        callbackFn: async () => {
+          navigateToEcapWithoutClosingWithCip("SIA_DEV");
         },
       });
       return Promise.resolve(menuItem);
@@ -271,7 +247,7 @@ const registerLowerNavMenuViews = () => {
     id: "configuration-center",
     factory: () => {
       const menuItem = new PrimariaNavItem({
-        icon: "add_box",
+        icon: "settings",
         label: "Centre de configuració",
         callbackFn: () => {
           // shellApi.regionManager.activateView(shellRegions.main, "");
@@ -283,14 +259,6 @@ const registerLowerNavMenuViews = () => {
 };
 
 const registerMainViews = () => {
-  shellApi.regionManager.registerMainView({
-    id: clinicalMonitoringId,
-    factory: () => {
-      const mainItem = new ClinicalMonitoring();
-      return Promise.resolve(mainItem as unknown as HTMLElement);
-    },
-    isDefault: true,
-  });
   shellApi.regionManager.registerMainView({
     id: pocTestEventsId,
     factory: () => {
@@ -299,21 +267,11 @@ const registerMainViews = () => {
     },
   });
 
-  shellApi.regionManager.registerMainView({
-    id: pdfViewerId,
-    factory: () => {
-      const mainItem = new PdfVisor();
-      return Promise.resolve(mainItem as unknown as HTMLElement);
-    },
-  });
+  registerPDFVisorMainView();
 };
 
-export const registerInternalViews = () => {
+export const useInternalViews = () => {
   registerMainViews();
   registerUpperNavMenuViews();
   registerLowerNavMenuViews();
 };
-
-export const activateDefaultView = () => {
-  shellApi.regionManager.activateMainView(clinicalMonitoringId);
-};