@uxland/primary-shell 5.1.2 → 5.2.1

package/src/features/clinical-monitoring/bootstrapper.ts

@@ -0,0 +1,39 @@
+import { customElement } from "lit/decorators.js";
+import { PrimariaApi } from "../../api/api";
+import { shellRegions } from "../../api/region-manager/regions";
+import { clinicalMonitoringId } from "./constants";
+import { ClinicalMonitoring } from "./component/clinical-monitoring";
+import { shellEvents } from "../../events";
+import { PrimariaNavItem } from "../../UI/shared-components/primaria-nav-item/primaria-nav-item";
+
+export const useClinicalMonitoring = (api: PrimariaApi) => {
+  //@ts-ignore
+  customElement("clinical-monitoring")(ClinicalMonitoring);
+  api.regionManager.registerMainView({
+    id: clinicalMonitoringId,
+    factory: () => {
+      const mainItem = new ClinicalMonitoring();
+      return Promise.resolve(mainItem as unknown as HTMLElement);
+    },
+    isDefault: true,
+  });
+  api.regionManager.registerView(shellRegions.navigationMenu, {
+    id: clinicalMonitoringId,
+    factory: () => {
+      const menuItem = new PrimariaNavItem({
+        icon: "account_box",
+        label: "Seguiment clínic",
+        callbackFn: () => {
+          api.regionManager.activateMainView(clinicalMonitoringId);
+          api.broker.publish(shellEvents.openClinicalMonitoringRequested);
+        },
+      });
+      return Promise.resolve(menuItem);
+    },
+    sortHint: "000200",
+  });
+};
+
+export const disposeClinicalMonitoring = (api: PrimariaApi) => {
+  api.regionManager.removeView(shellRegions.main, clinicalMonitoringId);
+};

package/src/{UI/components/clinical-monitoring → features/clinical-monitoring/component}/clinical-monitoring.ts

@@ -1,13 +1,10 @@
+import { IRegion, region } from "@uxland/regions";
 import { LitElement, css, html, unsafeCSS } from "lit";
-import { customElement } from "lit/decorators.js";
-import styles from "./styles.css?inline";
-import { template } from "./template";
 import { PrimariaRegionHost } from "../../../api/api";
-import { IRegion, region } from "@uxland/regions";
 import { clinicalMonitoringRegions } from "../../../api/region-manager/regions";
+import styles from "./styles.css?inline";
+import { template } from "./template";
 
-//@ts-ignore
-@customElement("clinical-monitoring")
 export class ClinicalMonitoring extends PrimariaRegionHost(LitElement) {
   render() {
     return html`${template(this)}`;

package/src/features/clinical-monitoring/constants.ts

@@ -0,0 +1 @@
+export const clinicalMonitoringId = "clinical-monitoring";

package/src/features/clinical-monitoring/handle-views.ts

@@ -0,0 +1,6 @@
+import { shellApi } from "../../api/api";
+import { clinicalMonitoringId } from "./constants";
+
+export const activateClinicalMonitoringView = () => {
+  shellApi.regionManager.activateMainView(clinicalMonitoringId);
+};

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 });
+};