@uxland/primary-shell 5.1.1 → 5.2.0

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

@@ -0,0 +1,57 @@
+import { IRegion, region } from "@uxland/regions";
+import { LitElement, css, html, unsafeCSS } from "lit";
+import { PrimariaRegionHost } from "../../../api/api";
+import { clinicalMonitoringRegions } from "../../../api/region-manager/regions";
+import styles from "./styles.css?inline";
+import { template } from "./template";
+
+export class ClinicalMonitoring extends PrimariaRegionHost(LitElement) {
+  render() {
+    return html`${template(this)}`;
+  }
+
+  static styles = css`
+    ${unsafeCSS(styles)}
+  `;
+
+  firstUpdated() {
+    this._observeMaximizedState();
+  }
+
+  private _observeMaximizedState() {
+    const contentRegion = this.renderRoot.querySelector("#content-widgets-region");
+    if (!contentRegion) return;
+
+    const observer = new MutationObserver(() => {
+      const activity = contentRegion.querySelector("activity-history-main");
+      if (!activity) return;
+
+      const isMaximized = activity.hasAttribute("maximized") || activity.maximized;
+      this._toggleWidgetsVisibility(!isMaximized);
+    });
+
+    observer.observe(contentRegion, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["maximized"],
+    });
+  }
+
+  private _toggleWidgetsVisibility(show: boolean) {
+    const sidebar = this.renderRoot.querySelector("#widgets-sidebar-region");
+    const header = this.renderRoot.querySelector("#header-widgets-region");
+
+    if (sidebar) sidebar.style.display = show ? "" : "none";
+    if (header) header.style.display = show ? "" : "none";
+  }
+
+  @region({ targetId: "widgets-sidebar-region", name: clinicalMonitoringRegions.sidebar })
+  sidebarRegion: IRegion | undefined;
+
+  @region({ targetId: "header-widgets-region", name: clinicalMonitoringRegions.header })
+  headerRegion: IRegion | undefined;
+
+  @region({ targetId: "content-widgets-region", name: clinicalMonitoringRegions.content })
+  contentRegion: IRegion | undefined;
+}

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

@@ -24,7 +24,6 @@
       grid-template-columns: repeat(3, 1fr);
       gap: 24px;
       padding: 24px 40px;
-      z-index: 1;
     }
     #content-widgets-region {
       flex: 1;
@@ -32,7 +31,6 @@
       height: 100%;
       padding-inline: 40px;
       padding-bottom: 24px;
-      z-index: 2;
     }
   }
 }

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/exit/handler.ts

@@ -17,17 +17,17 @@ export class ExitShellHandler {
         const { confirmed } = await this.askForClose(busyTasks);
         if (!confirmed) return;
       }
-      disposeShell();
 
       // Per si un plugin tarda molt en fer dispose, màxim deixarem 5 segons, per no interrompre el tancar infinitament
       await Promise.race([
         disposePlugins(), // S'intenta executar un dispose normal
         this.timeout(5000), // Si passen 5s, es segueix amb l'execució
       ]);
-
+      disposeShell();
       raiseCloseEvent();
     } catch (error) {
       this.api.notificationService.error(error.message);
+      raiseCloseEvent();
     }
   }
 

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-plugins.ts

@@ -26,7 +26,7 @@ export const bootstrapPlugins = async (plugins: PluginDefinition[]) => {
 };
 
 export const disposePlugins = async () => {
-  return Promise.all(bootstrappedPlugins.map((plugin: BootstrappedPlugin) => plugin.dispose()));
+  return Promise.all(bootstrappedPlugins.map((plugin: BootstrappedPlugin) => plugin?.dispose()));
 };
 
 export type Plugin = PluginType<PrimariaApi>;