@uxland/primary-shell 4.2.0 → 4.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxland/primary-shell",
-  "version": "4.2.0",
+  "version": "4.3.1",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",
@@ -41,7 +41,7 @@
     "axios-mock-adapter": "^2.0.0",
     "inversify": "^6.0.2",
     "inversify-inject-decorators": "^3.1.0",
-    "@salut/design-system-salut": "../../design-system-salut-2.2.0.tgz",
+    "@salut/design-system-salut": "../../design-system-salut-2.2.1.tgz",
     "jwt-decode": "^4.0.0",
     "lit": "^3.1.0",
     "mediatr-ts": "^1.2.1",

package/src/UI/components/index.ts

@@ -1,5 +1,6 @@
 import "./primaria-shell/primaria-shell";
 import "./clinical-monitoring/clinical-monitoring";
 import "../shared-components";
-import "../components/shell-header/shell-header";
-import "../components/quick-actions-menu/quick-actions-menu";
+import "./shell-header/shell-header";
+import "./quick-actions-menu/quick-actions-menu";
+import "../../api/plugin-busy-manager/plugin-busy-list/component";

package/src/UI/components/shell-header/shell-header.ts

@@ -7,6 +7,7 @@ import { GetUserInfo } from "../../../features/get-user-info/request";
 import styles from "./styles.css?inline";
 import { shellRegions } from "../../../api/region-manager/regions";
 import { IRegion, region } from "@uxland/regions";
+import { ExitShell } from "../../../features/exit/request";
 
 @customElement("shell-header")
 export class ShellHeader extends PrimariaRegionHost(LitElement) {
@@ -34,6 +35,10 @@ export class ShellHeader extends PrimariaRegionHost(LitElement) {
     this.menuOpened = !this.menuOpened;
   }
 
+  logout() {
+    shellApi.broker.send(new ExitShell());
+  }
+
   connectedCallback() {
     super.connectedCallback();
     shellApi.broker.send(new GetUserInfo()).then((response: IUserInfo) => {

package/src/UI/components/shell-header/template.ts

@@ -2,7 +2,7 @@ import { html } from "lit";
 import salutLogo from "../../../UI/images/Salut_Logotip.svg";
 import { ShellHeader } from "./shell-header";
 import { when } from "lit/directives/when.js";
-import {translate} from '../../../locales';
+import { translate } from "../../../locales";
 
 export const template = (props: ShellHeader) => {
   const workCenterElements = [{ label: props.professional?.workCenter, value: "1" }];
@@ -21,7 +21,7 @@ export const template = (props: ShellHeader) => {
       <div id="header-actions-region-container"></div>
       ${when(
         props.professional,
-        () => html`<dss-header-menu-professional slot="professional-menu" name="${props.professional.firstName} ${props.professional?.familyName} ${props.professional?.lastName}" center="${props.professional.workCenter}" collegiate="${props.professional.registrationNumber}">
+        () => html`<dss-header-menu-professional @onLogout=${props.logout} slot="professional-menu" name="${props.professional.firstName} ${props.professional?.familyName} ${props.professional?.lastName}" center="${props.professional.workCenter}" collegiate="${props.professional.registrationNumber}">
         <dss-avatar size="xl" name="${props.professional.firstName}" surname="${props.professional?.familyName}" slot="avatar"></dss-avatar>
         <dss-input-dropdown icon="maps_home_work" type="default" .elements=${workCenterElements} selectedvalue="[&quot;1&quot;]">
             <label slot="label" for="preferences1">${translate("header.workCenter")}</label>

package/src/api/api.ts

@@ -7,7 +7,7 @@ import {
   createRegionManager,
 } from "@uxland/harmonix";
 import { PrimariaRegionManager, createRegionManagerProxy } from "./region-manager/region-manager";
-import { createBroker } from "./broker/factory";
+import {  createBroker } from "./broker/factory";
 import { PrimariaBroker } from "./broker/primaria-broker";
 import { PrimariaGlobalStateManager, createGlobalStateManager } from "./global-state/global-state";
 import { HttpClient, createHttpClient } from "./http-client/http-client";
@@ -18,9 +18,13 @@ import {
 import { createLocaleManager } from "./localization/localization";
 import { TokenManager, createTokenManager } from "./token-manager/token-manager";
 import { EcapEventManager, createEcapEventManager } from "./ecap-event-manager/ecap-event-manager";
+import {
+  PluginBusyManager,
+  PluginBusyManagerImpl,
+} from "./plugin-busy-manager/plugin-busy-manager";
 
-const broker = createBroker();
 
+const broker = createBroker();
 export interface PrimariaApi extends HarmonixApi {
   httpClient: HttpClient;
   interactionManager: PrimariaInteractionManager;
@@ -29,12 +33,14 @@ export interface PrimariaApi extends HarmonixApi {
   globalStateManager: PrimariaGlobalStateManager;
   tokenManager: TokenManager;
   ecapEventManager: EcapEventManager;
+  pluginBusyManager: PluginBusyManager;
 }
 
 const regionManager: IRegionManager = createRegionManager("primaria");
 export const PrimariaRegionHost: any = createRegionHost(regionManager as any);
 const tokenManager = createTokenManager();
 const globalStateManager: PrimariaGlobalStateManager = createGlobalStateManager(broker);
+const pluginBusyManager = new PluginBusyManagerImpl();
 
 /**
  * Factory function that creates a Primaria API instance.
@@ -48,13 +54,14 @@ export const primariaApiFactory: ApiFactory<PrimariaApi> = (
   return {
     pluginInfo: pluginInfo,
     regionManager: createRegionManagerProxy(pluginInfo, regionManager, broker),
-    httpClient: createHttpClient(tokenManager),
+    httpClient: createHttpClient(tokenManager, broker),
     interactionManager: { ...createInteractionManager() },
     broker: broker,
     createLocaleManager: createLocaleManager(pluginInfo.pluginId) as any,
     globalStateManager,
     tokenManager,
     ecapEventManager: createEcapEventManager(),
+    pluginBusyManager,
   };
 };
 

package/src/api/broker/factory.ts

@@ -154,4 +154,4 @@ const createDynamicMessageHandler = (handler: messageHandler, classPrefix: strin
   )(handler);
 };
 
-export const createBroker = (): PrimariaBroker => new Broker();
+export const createBroker = (): PrimariaBroker => new Broker(); 

package/src/api/http-client/http-client.test.ts

@@ -3,24 +3,32 @@ import AxiosMockAdapter from "axios-mock-adapter";
 import { Mock, beforeEach, describe, expect, it, vi } from "vitest";
 import { TokenManager, createTokenManager } from "../token-manager/token-manager";
 import { createAxiosInstance } from "./http-client";
+import { shellEvents } from "../../events";
+import { createBroker } from "../broker/factory";
 
 const access_token = 'eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJidFZxNnRMWGpmcXdzbm5MR2FXMXdhdU9McDNiTmY4bWZ3Rm1SZ0lBS2VJIn0.eyJleHAiOjE3Mzg2NjcxODIsImlhdCI6MTczODY2NjI4MiwianRpIjoiY2I0M2M2ZmItY2MyMS00M2Y2LTk5M2UtNDM3ZTJjNDU3YWMzIiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsInN1YiI6Ijk1OGUyZWQ5LTJkNmUtNDZjOC1hOTE5LTU5MDQ0ZTYwMzVjMiIsInR5cCI6IkJlYXJlciIsImF6cCI6ImV0Yy1jY2YtcHJlIiwic2Vzc2lvbl9zdGF0ZSI6ImU3MzIzYWIyLTU3MDktNGY1ZS05ZGU4LWU1MzM3ZTBhOTMxNiIsInJlYWxtX2FjY2VzcyI6eyJyb2xlcyI6WyJkZWZhdWx0LXJvbGVzLWhlcyIsIlJPTEVfSEVTX0VUQyIsIlJPTEVfSEVTX0xBTkRJTkciXX0sInNjb3BlIjoiIiwic2lkIjoiZTczMjNhYjItNTcwOS00ZjVlLTlkZTgtZTUzMzdlMGE5MzE2IiwiY2xpZW50SG9zdCI6IjEwLjUzLjI1NC4xNTAiLCJhY2Nlc3NfcnVsZXMiOnt9LCJhY2Nlc3NfaW5mbyI6eyJtb2R1bGVfY29kZSI6IkEwMDEiLCJyb2xlX3R5cGUiOiJOT1JNIiwidHJhY2VfdXNlcl9pZCI6IlVzZXJfSUQiLCJjZW50ZXJfdHlwZSI6IkUiLCJ1cF9jb2RlIjoiMDc3MzMiLCJ0cmFjZV91c2VyX2dpdmVuX25hbWUiOiJHaXZlbiBOYW1lIiwidHJhY2VfdXNlcl9mYW1pbHlfbmFtZSI6IkZhbWlseSBOYW1lIiwidXNlcl90eXBlIjoiQURNIiwiY2VudGVyX2NvZGUiOiJFMDg1ODY5NjMiLCJwcm9mZXNzaW9uYWxfY2F0ZWdvcnkiOiIzMDkzNDMwMDYiLCJzZXJ2aWNlX2NvZGUiOiI1UzA4OSIsImVwX2NvZGUiOiIwMjA4IiwiaWRlbnRpZmllciI6W3sidHlwZSI6IkROSSIsInZhbHVlIjoiNzMyODgyMTlBIn0seyJ0eXBlIjoiTlVNQ09MIiwidmFsdWUiOiIyIn1dLCJhbHRfaWRlbnRpZmllciI6W3sidHlwZSI6Ik1QSSIsInZhbHVlIjoiMDYyMWNmN2QtN2Q2My00OWVjLTgwMDYtOGMwNTY5MmVkMzc3In1dfSwiY2xpZW50QWRkcmVzcyI6IjEwLjUzLjI1NC4xNTAiLCJjbGllbnRfaWQiOiJldGMtY2NmLXByZSJ9.WYF6VvIVqzW71MdOcvRJnKNBEe8BoD43Ql_hyGyqBC1wbNDNcbqucX-2wPbSOpHaHv5iogYNTVp1eEkHvrnryQ4koHXf4U3inTxoZR94qAzIt8XGgBVxpYlArc-XrFX1FAwkdfsNmYE_L6G7q5wfzaP0y1YrFH6u9TPTBl1w2us8O8xKPB6B652NUphNHFWmPWv6t6Zq97sjHPIHMZsDeBdolK5RlG5J3u8K-quJeKLByZhA2kYAJMGyCzR6jLLrup5w-WdYNJRyGopeFSDVp-lECmaiYIXmhQOJzzJQqhARrwYN8ZxqTOyD5u24HOB7Q1ZCMnAp4vAL6OphWyRZuw';
 const refresh_token = 'eyJhbGciOiJIUzUxMiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICIwMjUzZGM1MC1hY2FmLTQ5ZDctYTYzNi0xN2NkMTlmOWEwOTAifQ.eyJleHAiOjE3Mzg2NjgwODIsImlhdCI6MTczODY2NjI4MiwianRpIjoiZWM5OGE2OWMtMDJkNS00Yjc0LWIwZWYtNzcwMGU4OTc3YWY1IiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsImF1ZCI6Imh0dHBzOi8vcHJlcHJvZHVjY2lvLnBkcy5oZXMuY2F0c2FsdXQuZ2VuY2F0LmNhdC9hdXRoL3JlYWxtcy9IRVMiLCJzdWIiOiI5NThlMmVkOS0yZDZlLTQ2YzgtYTkxOS01OTA0NGU2MDM1YzIiLCJ0eXAiOiJSZWZyZXNoIiwiYXpwIjoiZXRjLWNjZi1wcmUiLCJzZXNzaW9uX3N0YXRlIjoiZTczMjNhYjItNTcwOS00ZjVlLTlkZTgtZTUzMzdlMGE5MzE2Iiwic2NvcGUiOiIiLCJzaWQiOiJlNzMyM2FiMi01NzA5LTRmNWUtOWRlOC1lNTMzN2UwYTkzMTYifQ.KOO0Ulbed4640-obEr3Xg8qavGeXhU25o6ZUfsq0SoQpzMjhcx8GTgOH-PiIR88ksrjtTnpbmzw2D29xuugv4A';
 
 
 describe("HTTP Client", () => {
-  vi.spyOn(window, 'location', 'get').mockReturnValue({
-    search: `?access_token=${access_token}&refresh_token=${refresh_token}`
-  } as unknown as Location);
+
+  let broker = createBroker();
   let tokenManager: TokenManager;
   let axiosInstance: AxiosInstance;
   let axiosMockInstance: AxiosMockAdapter;
+
   beforeEach(() => {
+    vi.restoreAllMocks(); // Reset all spies before each test
+    vi.spyOn(window, 'location', 'get').mockReturnValue({
+      search: `?access_token=${access_token}&refresh_token=${refresh_token}`
+    } as unknown as Location);
+
     tokenManager = createTokenManager();
-    axiosInstance = createAxiosInstance(tokenManager);
+    axiosInstance = createAxiosInstance(tokenManager, broker);
     axiosMockInstance = new AxiosMockAdapter(axiosInstance);
     axiosMockInstance.reset();
   });
+
   it("should make a request with header", async () => {
     axiosMockInstance.onGet("/api/clinical-course").reply(200, "success");
     // Perform the request
@@ -34,22 +42,68 @@ describe("HTTP Client", () => {
       `Bearer ${access_token}`,
     );
   });
-  it("should retry request after token refresh", async () => {
+
+  it("should retry request with  new token if failed with 401 after token refresh, and requests after that have new token", async () => {
+    
     axiosMockInstance
       .onGet("/api/clinical-course")
       .replyOnce(401, "Unauthorized")
       .onGet("/api/clinical-course")
+      .replyOnce(200, "success")
+      .onGet("/api/clinical-course/2")
       .replyOnce(200, "success");
+
+    vi.spyOn(axios, "post").mockResolvedValueOnce({
+      data: {
+        access_token: "new-auth-token",
+        refresh_token: "new-refresh-token"
+      }
+    });
+
     // Perform the request
     const response = await axiosInstance.get("/api/clinical-course");
+    const secondResponse = await axiosInstance.get("/api/clinical-course/2");
 
     console.log("response", response.status);
     // Assertions
     expect(response.status).toBe(200);
     expect(response.data).toBe("success");
-    expect(axiosMockInstance.history.get?.length).toBe(2);
+    expect(axiosMockInstance.history.get?.length).toBe(3); // 3 Calls 2 for the first request (request and retry), 1 for the second request
     expect(axiosMockInstance.history.get?.[1]?.headers?.Authorization).toBe(
       "Bearer new-auth-token",
     );
+    expect(axiosMockInstance.history.get?.[2]?.headers?.Authorization).toBe(
+      "Bearer new-auth-token",
+    );
+
+  });
+
+  it("should fail request if token refresh fails and publish an event", async () => {
+    vi.spyOn(axios, "post").mockRejectedValueOnce({
+      response: { status: 400, statusText: "Bad Request" },
+    });
+    const brokerSpy = vi.spyOn(broker, "publish") 
+    axiosMockInstance.onGet("/api/clinical-course").replyOnce(401, "Unauthorized");
+
+    await expect(axiosInstance.get("/api/clinical-course")).rejects.toThrow("Request failed with status code 401");
+
+    expect(axiosMockInstance.history.get?.length).toBe(1); // No retry happened
+    expect(brokerSpy).toHaveBeenCalledWith(shellEvents.refreshTokenFailed, expect.any(Object));
+    expect(brokerSpy).toHaveBeenCalledWith(shellEvents.refreshTokenFailed, {
+      request: expect.objectContaining({ url: "/api/clinical-course" }),
+    });
+  });
+
+  it("should fail request with error != 401 and should not retry", async () => {
+    const refreshTokenSpy = vi.spyOn(tokenManager, "refreshToken");
+    const brokerSpy = vi.spyOn(broker, "publish");
+    axiosMockInstance.onGet("/api/clinical-course").replyOnce(500, "Internal Server Error");
+    await expect(axiosInstance.get("/api/clinical-course")).rejects.toMatchObject({
+      response: { status: 500 },
+    });
+    expect(axiosMockInstance.history.get?.length).toBe(1);
+    expect(refreshTokenSpy).not.toHaveBeenCalled();
+    expect(brokerSpy).not.toHaveBeenCalled();
   });
+  
 });

package/src/api/http-client/http-client.ts

@@ -1,12 +1,15 @@
 import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
 import { TokenManager } from "../token-manager/token-manager";
+import { shellEvents } from "../../events";
+import { PrimariaBroker } from "../broker/primaria-broker";
 
-export const createAxiosInstance = (tokenManager: TokenManager) => {
-  const instance = axios.create({
-    headers: {
-      Authorization: `Bearer ${tokenManager.getToken()}`,
-    },
+export const createAxiosInstance = (tokenManager: TokenManager, broker: PrimariaBroker) => {
+  const instance = axios.create();
+  instance.interceptors.request.use((config) => {
+    config.headers.Authorization = `Bearer ${tokenManager.getToken()}`;
+    return config;
   });
+  
   instance.interceptors.response.use(
     (response: AxiosResponse) => response,
     async (error) => {
@@ -14,9 +17,15 @@ export const createAxiosInstance = (tokenManager: TokenManager) => {
       if (error.response.status === 401 && !originalRequest._retry) {
         originalRequest._retry = true;
         // Implement token refresh logic here and update the token in headers
+        try {
         const newToken = await tokenManager.refreshToken();
         originalRequest.headers.Authorization = `Bearer ${newToken}`;
         return instance(originalRequest);
+        } catch (refreshError) {
+          console.error("Error refreshing token:", refreshError);
+          broker.publish(shellEvents.refreshTokenFailed, {request: originalRequest});
+          return Promise.reject(error);
+        }
       }
       return Promise.reject(error);
     },
@@ -29,14 +38,12 @@ let instance;
 
 //TODO: Test concurrent request that get intercepted by expired token and
 // An option is to use subscribers to enque unauth requests and only refresh one token and retry the others with the new token
-
-
 export interface HttpClient {
   request<T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
 }
-export const createHttpClient = (tokenManager: TokenManager): HttpClient => {
+export const createHttpClient = (tokenManager: TokenManager, broker: PrimariaBroker): HttpClient => {
   if (!instance) {
-    instance = createAxiosInstance(tokenManager);
+    instance = createAxiosInstance(tokenManager, broker);
   }
   return { request: instance.request };
-};
+};

package/src/api/plugin-busy-manager/plugin-busy-list/component.ts

@@ -0,0 +1,19 @@
+import { LitElement, css, html, unsafeCSS } from "lit";
+import { customElement } from "lit/decorators.js";
+import styles from "./styles.css?inline";
+import { template } from "./template";
+import { confirmMixin } from "../../../UI/shared-components/primaria-interaction/confirm-mixin";
+import { PluginBusyTask } from "../plugin-busy-manager";
+
+@customElement("plugin-busy-list")
+export class PluginBusyList extends confirmMixin(LitElement) {
+  static styles = css`
+    ${unsafeCSS(styles)}
+  `;
+
+  render() {
+    return html`${template(this)}`;
+  }
+
+  model: { busyTasks: PluginBusyTask[] };
+}

package/src/api/plugin-busy-manager/plugin-busy-list/styles.css

@@ -0,0 +1,20 @@
+.container{
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    align-items: center;
+}
+
+.title{
+    font-size: 15px;
+    line-height: 24px;
+    font-weight: 600;
+    color: var(--color-red-600);
+}
+
+
+.list{
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}

package/src/api/plugin-busy-manager/plugin-busy-list/template.ts

@@ -0,0 +1,13 @@
+import { html } from "lit";
+import { PluginBusyList } from "./component";
+import { PluginBusyTask } from "../plugin-busy-manager";
+import { translate } from "../../../locales";
+
+export const template = (props: PluginBusyList) => html`
+    <div class="container">
+        <div class="title">${translate("busyManager.title")}</div>
+        <div class="list">
+            ${props.model?.busyTasks?.map((item: PluginBusyTask) => html`<div class="plugin-busy-item">${item.taskDescription}</div>`)}
+        </div>
+    </div>
+`;

package/src/api/plugin-busy-manager/plugin-busy-manager.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { PluginBusyManagerImpl } from "./plugin-busy-manager";
+
+describe("PluginBusyManagerImpl", () => {
+  let manager: PluginBusyManagerImpl;
+
+  beforeEach(() => {
+    manager = new PluginBusyManagerImpl();
+  });
+
+  it("should start with no busy plugins", () => {
+    expect(manager.getBusyPluginTasks()).toEqual([]);
+    expect(manager.isAnyPluginBusy()).toBe(false);
+  });
+
+  it("should add a busy plugin", () => {
+    const task = { taskId: "plugin1", taskDescription: "Description for plugin1" };
+    manager.addBusyPluginTask(task);
+    expect(manager.getBusyPluginTasks()).toContainEqual(task);
+    expect(manager.isAnyPluginBusy()).toBe(true);
+  });
+
+  it("should remove a busy plugin", () => {
+    const task1 = { taskId: "plugin1", taskDescription: "Description for plugin1" };
+    const task2 = { taskId: "plugin2", taskDescription: "Description for plugin2" };
+    manager.addBusyPluginTask(task1);
+    manager.addBusyPluginTask(task2);
+    manager.removeBusyPluginTask("plugin1");
+    expect(manager.getBusyPluginTasks()).not.toContainEqual(task1);
+    expect(manager.getBusyPluginTasks()).toContainEqual(task2);
+  });
+
+  it("should do nothing if removing a non-existent plugin", () => {
+    const task = { taskId: "plugin1", taskDescription: "Description for plugin1" };
+    manager.addBusyPluginTask(task);
+    manager.removeBusyPluginTask("nonexistent");
+    expect(manager.getBusyPluginTasks()).toEqual([task]);
+  });
+
+  it("should clear all busy plugins", () => {
+    const task1 = { taskId: "plugin1", taskDescription: "Description for plugin1" };
+    const task2 = { taskId: "plugin2", taskDescription: "Description for plugin2" };
+    manager.addBusyPluginTask(task1);
+    manager.addBusyPluginTask(task2);
+    manager.clearAllBusyPlugins();
+    expect(manager.getBusyPluginTasks()).toEqual([]);
+    expect(manager.isAnyPluginBusy()).toBe(false);
+  });
+});

package/src/api/plugin-busy-manager/plugin-busy-manager.ts

@@ -0,0 +1,38 @@
+export interface PluginBusyTask {
+  taskId: string;
+  taskDescription: string;
+}
+
+export abstract class PluginBusyManager {
+  abstract addBusyPluginTask(busyTask: PluginBusyTask): void;
+  abstract removeBusyPluginTask(taskId: string): any;
+  abstract clearAllBusyPlugins(): void;
+  abstract isAnyPluginBusy(): boolean;
+  abstract getBusyPluginTasks(): PluginBusyTask[];
+}
+export class PluginBusyManagerImpl implements PluginBusyManager {
+  private busyPluginTasks: PluginBusyTask[] = [];
+
+  public addBusyPluginTask(busyTask: PluginBusyTask): void {
+    this.busyPluginTasks.push(busyTask);
+  }
+
+  public removeBusyPluginTask(taskId: string): any {
+    const index = this.busyPluginTasks.findIndex((item) => item.taskId === taskId);
+    if (index > -1) {
+      this.busyPluginTasks.splice(index, 1);
+    }
+  }
+
+  public isAnyPluginBusy(): boolean {
+    return this.busyPluginTasks.length > 0;
+  }
+
+  public clearAllBusyPlugins(): void {
+    this.busyPluginTasks = [];
+  }
+
+  public getBusyPluginTasks(): PluginBusyTask[] {
+    return this.busyPluginTasks;
+  }
+}

package/src/api/token-manager/token-manager.test.ts

@@ -13,17 +13,5 @@ describe("Token Manager test", () => {
   it("should return initial token", () => {
     const tokenManager = createTokenManager();
     expect(tokenManager.getToken()).toBe(access_token);
-  });  
-
-  it("should refresh token", async () => {
-    const tokenManager = createTokenManager();
-    const refreshPromise = tokenManager.refreshToken();
-    const oldToken = tokenManager.getToken();
-    const newToken = await refreshPromise;
-    const newToken2 = tokenManager.getToken();
-    expect(newToken).toBe("new-auth-token");
-    expect(newToken).toBe(newToken2);
-    expect(newToken).not.toBe(oldToken);
-    expect(oldToken).toBe(access_token);
   });
 });

package/src/api/token-manager/token-manager.ts

@@ -1,3 +1,5 @@
+import axios from "axios";
+
 export interface TokenManager {
   getToken: () => string;
   refreshToken: () => Promise<string>;
@@ -5,7 +7,7 @@ export interface TokenManager {
 
 let token: string;
 let refreshToken: string;
-export class TokenManagerSimulator implements TokenManager {
+export class TokenManagerImpl implements TokenManager {
   getUrlParams = (): URLSearchParams => {
     return new URLSearchParams(window.location.search);
   };
@@ -14,7 +16,6 @@ export class TokenManagerSimulator implements TokenManager {
     const searchString = this.getUrlParams();
     token = searchString.get("access_token") || "";
     refreshToken = searchString.get("refresh_token") || "";
-
     return token;
   };
 
@@ -23,16 +24,20 @@ export class TokenManagerSimulator implements TokenManager {
   };
 
   refreshToken = async () => {
-    //sleep for 1 second change token and return token
-    await new Promise((resolve) => setTimeout(resolve, 200));
-    token = "new-auth-token";
-    return token;
+      const response = await axios.post('/api/token/refresh', {token: refreshToken});
+      const {access_token, refresh_token} = response.data;
+      if(!access_token){
+        throw new Error("Invalid refresh token response");
+      }
+      token = access_token;
+      refreshToken = refresh_token;
+      return token;
   };
 }
 let tokenManager;
 export const createTokenManager = () =>  {
   if(tokenManager) return tokenManager;
-  tokenManager = new TokenManagerSimulator();
+  tokenManager = new TokenManagerImpl();
   tokenManager.initToken();
   return tokenManager;
 }

package/src/disposer.ts

@@ -1,7 +1,6 @@
 import { shellApi } from "./api/api";
 import { teardownFeatures } from "./features/bootstrapper";
 export const disposeShell = () => {
-  shellApi.ecapEventManager.publish("CLOSE_REQUESTED_RECEIVED", "", {});
   teardownFeatures();
 };
 

package/src/events.ts

@@ -2,4 +2,5 @@ export const shellEvents = {
   openClinicalMonitoringRequested: "openClinicalMonitoringRequested",
   appCrashed: "appCrashed",
   mainViewChanged: "mainViewChanged",
+  refreshTokenFailed: "refreshTokenFailed",
 };

package/src/features/bootstrapper.ts

@@ -1,16 +1,19 @@
 import { PrimariaApi, shellApi } from "../api/api";
 import { container } from "../infrastructure/ioc/container";
 import { TYPES } from "../infrastructure/ioc/types";
+import { bootstrapExitShell, teardownExitShell } from "./exit/bootstrapper";
 import { bootstrapGetUserInfo, teardownGetUserInfo } from "./get-user-info/bootstrapper";
 import { GetUserInfo } from "./get-user-info/request";
 
 export const bootstrapFeatures = (api: PrimariaApi) => {
   container.bind(TYPES.primaryApi).toConstantValue(api);
   bootstrapGetUserInfo();
+  bootstrapExitShell();
   shellApi.broker.send(new GetUserInfo());
 };
 
 export const teardownFeatures = () => {
   teardownGetUserInfo();
+  teardownExitShell();
   container.unbindAll();
 };

package/src/features/exit/bootstrapper.ts

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

package/src/features/exit/handler.ts

@@ -0,0 +1,51 @@
+import { CustomConfirmOptions, PrimariaApi } from "@uxland/primary-shell";
+import { TYPES } from "../../infrastructure/ioc/types";
+import { inject } from "inversify";
+import { ExitShell } from "./request";
+import { disposeShell, raiseCloseEvent } from "../../disposer";
+import { disposePlugins } from "../../handle-plugins";
+import { PluginBusyTask } from "../../api/plugin-busy-manager/plugin-busy-manager";
+import { PluginBusyList } from "../../api/plugin-busy-manager/plugin-busy-list/component";
+import { translate } from "../../locales";
+
+export class ExitShellHandler {
+  constructor(@inject(TYPES.primaryApi) private api: PrimariaApi) {}
+  async handle(message: ExitShell): Promise<void> {
+    try {
+      const busyTasks = this.api.pluginBusyManager.getBusyPluginTasks();
+      if (busyTasks.length > 0) {
+        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ó
+      ]);
+
+      raiseCloseEvent();
+    } catch (error) {
+      this.api.interactionManager.notify({
+        type: "error",
+        message: error.message,
+      });
+    }
+  }
+
+  private askForClose(busyTasks: PluginBusyTask[]) {
+    return this.api.interactionManager.customConfirm({
+      title: translate("actions.askExit"),
+      componentConstructor: PluginBusyList,
+      type: "danger",
+      model: { busyTasks },
+      acceptLabel: "Si",
+      cancelLabel: "No",
+    } as CustomConfirmOptions<{ busyTasks: PluginBusyTask[] }>);
+  }
+
+  private timeout(ms: number) {
+    return new Promise<void>((resolve) => setTimeout(resolve, ms));
+  }
+}

package/src/features/exit/request.ts

@@ -0,0 +1,3 @@
+import { IRequest } from "@uxland/primary-shell";
+
+export class ExitShell implements IRequest<void> {}

package/src/handle-plugins.ts

@@ -1,11 +1,13 @@
 import { bootstrapPlugins as pluginBootstrapper } from "@uxland/harmonix";
-import type { PluginDefinition, Plugin as PluginType } from "@uxland/harmonix";
+import type { PluginDefinition, Plugin as PluginType, BootstrappedPlugin } from "@uxland/harmonix";
 export type { PluginDefinition, PluginInfo } from "@uxland/harmonix";
 import {
   initialize as activityHistoryInitialize,
   dispose as activityHistoryDispose,
 } from "./internal-plugins/activity-history/main";
-import { PrimariaApi, primariaApiFactory, shellApi } from "./api/api";
+import { PrimariaApi, primariaApiFactory } from "./api/api";
+
+let bootstrappedPlugins = [] as BootstrappedPlugin[];
 
 const internalPlugins: PluginDefinition[] = [
   {
@@ -20,12 +22,11 @@ const internalPlugins: PluginDefinition[] = [
 
 export const bootstrapPlugins = async (plugins: PluginDefinition[]) => {
   const finalPlugins = internalPlugins.concat(plugins || []);
-  const bootstrappedPlugins = await pluginBootstrapper(finalPlugins, primariaApiFactory);
-  return bootstrappedPlugins as Plugin[];
+  bootstrappedPlugins = await pluginBootstrapper(finalPlugins, primariaApiFactory);
 };
 
-export const disposePlugins = async (plugins: Plugin[]) => {
-  return Promise.all(plugins.map((plugin) => plugin.dispose(shellApi)));
+export const disposePlugins = async () => {
+  return Promise.all(bootstrappedPlugins.map((plugin: BootstrappedPlugin) => plugin.dispose()));
 };
 
 export type Plugin = PluginType<PrimariaApi>;