@uxland/primary-shell 4.3.0 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxland/primary-shell",
-  "version": "4.3.0",
+  "version": "5.0.0",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",
@@ -40,8 +40,11 @@
     "@uxland/utilities": "^1.0.5",
     "axios-mock-adapter": "^2.0.0",
     "inversify": "^6.0.2",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "@types/react": "^19.0.12",
     "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/primaria-shell/primaria-shell.ts

@@ -9,6 +9,8 @@ import { shellViews } from "./constants";
 import { shellEvents } from "../../../events";
 import { activateDefaultView } from "../../../handle-views";
 import { BrokerDisposableHandler } from "harmonix/core/dist";
+import { translate } from "../../../locales";
+import { disposeShell } from "../../../disposer";
 
 //@ts-ignore
 @customElement("primaria-shell")
@@ -72,14 +74,29 @@ export class PrimariaShell extends PrimariaRegionHost(LitElement) {
   private subscriptions: BrokerDisposableHandler[] = [];
 
   _subscribeEvents() {
-    const subscription = shellApi.broker.subscribe(
-      shellEvents.appCrashed,
-      (error: { message: string }) => {
-        this.viewSelected = shellViews.error;
-        this.error = error;
-      },
+    this.subscriptions.push(
+      shellApi.broker.subscribe(shellEvents.appCrashed, (error: { message: string }) => {
+        this._handleError(error);
+      }),
     );
-    this.subscriptions.push(subscription);
+
+    this.subscriptions.push(
+      shellApi.broker.subscribe(shellEvents.refreshTokenFailed, (detail: any) => {
+        this._handleError({ message: translate("errors.session") });
+      }),
+    );
+
+    this.subscriptions.push(
+      shellApi.broker.subscribe(shellEvents.mpidHeaderInvalid, (detail: any) => {
+        this._handleError({ message: translate("errors.invalidPatient") });
+      }),
+    );
+  }
+
+  _handleError(error: { message: string }) {
+    this.viewSelected = shellViews.error;
+    this.error = error;
+    disposeShell();
   }
 
   _unsubscribeEvents() {

package/src/UI/components/quick-actions-menu/quick-actions-menu.ts

@@ -31,10 +31,14 @@ export class QuickActionsMenu extends LitElement {
 
   _handleOpenMenu(e) {
     // Obtener el otro slot (target-slot)
-    const targetSlot = this.shadowRoot?.querySelector('slot[name="content"]');
+    const contentSlot = this.shadowRoot?.querySelector('slot[name="content"]') as HTMLSlotElement;
+
+    const actionMenu = this.querySelector("dss-action-menu");
 
     // Obtener los elementos asignados al otro slot
-    const assignedElements = targetSlot?.assignedElements();
+    const assignedElements = contentSlot?.assignedElements();
+    if (assignedElements[0])
+      this._addMenuCustomStyle(contentSlot as HTMLElement, actionMenu as HTMLElement);
 
     // Hacer target al elemento que deseas (por ejemplo, un <p>)
     const targetElement = assignedElements.find((el) => el.id === "content");
@@ -43,4 +47,10 @@ export class QuickActionsMenu extends LitElement {
       targetElement.show();
     }
   }
-}
+
+  _addMenuCustomStyle(contentSlot: HTMLElement, actionMenu: HTMLElement) {
+    contentSlot.style.borderRadius = "var(--dss-radius-sm)";
+    const list = actionMenu.shadowRoot?.querySelector("ul");
+    if (list) list.style.overflow = "hidden";
+  }
+}

package/src/UI/shared-components/index.ts

@@ -1,5 +1,4 @@
 import "./primaria-content-switcher/primaria-content-switcher";
 import "./primaria-nav-item/primaria-nav-item";
 import "./primaria-text-editor/primaria-rich-text-editor";
-export * from "./primaria-interaction";
 export { PrimariaContentSwitcher } from "./primaria-content-switcher/primaria-content-switcher";

package/src/api/api.ts

@@ -7,14 +7,10 @@ import {
   createRegionManager,
 } from "@uxland/harmonix";
 import { PrimariaRegionManager, createRegionManagerProxy } from "./region-manager/region-manager";
-import { broker, 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";
-import {
-  PrimariaInteractionManager,
-  createInteractionManager,
-} from "./interaction-manager/interaction";
 import { createLocaleManager } from "./localization/localization";
 import { TokenManager, createTokenManager } from "./token-manager/token-manager";
 import { EcapEventManager, createEcapEventManager } from "./ecap-event-manager/ecap-event-manager";
@@ -22,12 +18,16 @@ import {
   PluginBusyManager,
   PluginBusyManagerImpl,
 } from "./plugin-busy-manager/plugin-busy-manager";
-
+import { PrimariaInteractionService } from "./interaction-service";
+import { ParimariaInteractionServiceImpl } from "./interaction-service/interaction-service-impl";
+import { PrimariaNotificationService } from "./notification-service/notification-service";
+import { PrimariaNotificationServiceImpl } from "./notification-service/notification.service-impl";
 
 const broker = createBroker();
 export interface PrimariaApi extends HarmonixApi {
   httpClient: HttpClient;
-  interactionManager: PrimariaInteractionManager;
+  interactionService: PrimariaInteractionService;
+  notificationService: PrimariaNotificationService;
   broker: PrimariaBroker;
   regionManager: PrimariaRegionManager;
   globalStateManager: PrimariaGlobalStateManager;
@@ -41,6 +41,8 @@ export const PrimariaRegionHost: any = createRegionHost(regionManager as any);
 const tokenManager = createTokenManager();
 const globalStateManager: PrimariaGlobalStateManager = createGlobalStateManager(broker);
 const pluginBusyManager = new PluginBusyManagerImpl();
+const interactionService = new ParimariaInteractionServiceImpl();
+const notificationService = new PrimariaNotificationServiceImpl();
 
 /**
  * Factory function that creates a Primaria API instance.
@@ -55,13 +57,14 @@ export const primariaApiFactory: ApiFactory<PrimariaApi> = (
     pluginInfo: pluginInfo,
     regionManager: createRegionManagerProxy(pluginInfo, regionManager, broker),
     httpClient: createHttpClient(tokenManager, broker),
-    interactionManager: { ...createInteractionManager() },
     broker: broker,
     createLocaleManager: createLocaleManager(pluginInfo.pluginId) as any,
     globalStateManager,
     tokenManager,
     ecapEventManager: createEcapEventManager(),
     pluginBusyManager,
+    interactionService,
+    notificationService,
   };
 };
 

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

@@ -1,17 +1,19 @@
 import axios, { AxiosInstance } from "axios";
 import AxiosMockAdapter from "axios-mock-adapter";
-import { Mock, beforeEach, describe, expect, it, vi } from "vitest";
+import { 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';
-
+const access_token =
+  "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJidFZxNnRMWGpmcXdzbm5MR2FXMXdhdU9McDNiTmY4bWZ3Rm1SZ0lBS2VJIn0.eyJleHAiOjE3NDI5MDkxNjMsImlhdCI6MTc0MjkwODI2MywianRpIjoiODRlMWEwYjYtOGNmYS00NzQ3LTk0MDItMjVkM2FlMzM3N2QxIiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsInN1YiI6Ijk1OGUyZWQ5LTJkNmUtNDZjOC1hOTE5LTU5MDQ0ZTYwMzVjMiIsInR5cCI6IkJlYXJlciIsImF6cCI6ImV0Yy1jY2YtcHJlIiwic2Vzc2lvbl9zdGF0ZSI6ImVhNzUwMDg4LWI1NjctNDU4ZC1iOWY5LWQ0OTdjMzlkN2ZkMyIsInJlYWxtX2FjY2VzcyI6eyJyb2xlcyI6WyJkZWZhdWx0LXJvbGVzLWhlcyIsIlJPTEVfSEVTX0VUQyIsIlJPTEVfSEVTX0xBTkRJTkciXX0sInNjb3BlIjoiIiwic2lkIjoiZWE3NTAwODgtYjU2Ny00NThkLWI5ZjktZDQ5N2MzOWQ3ZmQzIiwiY2xpZW50SG9zdCI6IjEwLjUzLjI1NC4xNTAiLCJhY2Nlc3NfcnVsZXMiOnt9LCJhY2Nlc3NfaW5mbyI6eyJtb2R1bGVfY29kZSI6IkEwMDEiLCJyb2xlX3R5cGUiOiJOT1JNIiwidHJhY2VfdXNlcl9pZCI6IlVzZXJfSUQiLCJjZW50ZXJfdHlwZSI6IkUiLCJtcGlfcGF0aWVudF9pZCI6IjVlYzc0YzdiLTVhYTUtNGE4NC1iM2I0LWYwMmVkZGZkZjZkYyIsInVwX2NvZGUiOiIwNzczMyIsInRyYWNlX3VzZXJfZ2l2ZW5fbmFtZSI6IkdpdmVuIE5hbWUiLCJ0cmFjZV91c2VyX2ZhbWlseV9uYW1lIjoiRmFtaWx5IE5hbWUiLCJ1c2VyX3R5cGUiOiJBRE0iLCJjZW50ZXJfY29kZSI6IkUwODU4Njk2MyIsInByb2Zlc3Npb25hbF9jYXRlZ29yeSI6IjMwOTM0MzAwNiIsInNlcnZpY2VfY29kZSI6IjVTMDg5IiwiZXBfY29kZSI6IjAyMDgiLCJpZGVudGlmaWVyIjpbeyJ0eXBlIjoiRE5JIiwidmFsdWUiOiI3MzI4ODIxOUEifSx7InR5cGUiOiJOVU1DT0wiLCJ2YWx1ZSI6IjIifV0sImFsdF9pZGVudGlmaWVyIjpbeyJ0eXBlIjoiTVBJIiwidmFsdWUiOiIwNjIxY2Y3ZC03ZDYzLTQ5ZWMtODAwNi04YzA1NjkyZWQzNzcifV19LCJjbGllbnRBZGRyZXNzIjoiMTAuNTMuMjU0LjE1MCIsImNsaWVudF9pZCI6ImV0Yy1jY2YtcHJlIn0.CgYL3zXbUHHiE7ZtrcxvlDHB3dbY_eI8TsL-0mBOy-JedSZZaGT_JS8Odm_eIo1drWZSnEaNblFZUPE56sCEPH6RYSqtyK0eYwy_aKoprKoRuDjEy2-VfmOJi5gY9wpYnAYpVtuTbncVirQIV9SIZ9st2d7LlfcM_88Yn8NJNTDcUk7ETw7Zy_728X2wjL_UeHT7yuzo3Y-Xm_389Og7UMyYGGrs104CHQNrzIMXiklkRZr4dqjqWU61Csrb8OBI6jCUAbBqgS8vPuUzPUghQXstr-aNn3zicy-Zw5e6RqCmSQXg56aTKx9QIOrQuX-az-urPnqvtWdloQrQJLQGSg";
+const refresh_token =
+  "eyJhbGciOiJIUzUxMiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICIwMjUzZGM1MC1hY2FmLTQ5ZDctYTYzNi0xN2NkMTlmOWEwOTAifQ.eyJleHAiOjE3NDI5MTE4NjMsImlhdCI6MTc0MjkwODI2MywianRpIjoiZjA4MzA1MDktMTA0My00ODI1LTk5YTItOTg1YmNjOGI4MmJmIiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsImF1ZCI6Imh0dHBzOi8vcHJlcHJvZHVjY2lvLnBkcy5oZXMuY2F0c2FsdXQuZ2VuY2F0LmNhdC9hdXRoL3JlYWxtcy9IRVMiLCJzdWIiOiI5NThlMmVkOS0yZDZlLTQ2YzgtYTkxOS01OTA0NGU2MDM1YzIiLCJ0eXAiOiJSZWZyZXNoIiwiYXpwIjoiZXRjLWNjZi1wcmUiLCJzZXNzaW9uX3N0YXRlIjoiZWE3NTAwODgtYjU2Ny00NThkLWI5ZjktZDQ5N2MzOWQ3ZmQzIiwic2NvcGUiOiIiLCJzaWQiOiJlYTc1MDA4OC1iNTY3LTQ1OGQtYjlmOS1kNDk3YzM5ZDdmZDMifQ.I8u83nfdxbjRrS7dC1k8_f9oBKmSD_Xu4iAxlFqcA3QdHi-L_yY63ENU1LTehh8-2d51f__nv58zPb799hNGhg";
+const newAccessToken =
+  "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJidFZxNnRMWGpmcXdzbm5MR2FXMXdhdU9McDNiTmY4bWZ3Rm1SZ0lBS2VJIn0.eyJleHAiOjE3NDI5MTAzNzgsImlhdCI6MTc0MjkwOTQ3OCwianRpIjoiMTg4OTE3ZDYtNmM0OS00YWY0LTlhYjItZjEzYTM4MGY5OTgyIiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsInN1YiI6Ijk1OGUyZWQ5LTJkNmUtNDZjOC1hOTE5LTU5MDQ0ZTYwMzVjMiIsInR5cCI6IkJlYXJlciIsImF6cCI6ImV0Yy1jY2YtcHJlIiwic2Vzc2lvbl9zdGF0ZSI6IjY5ODdhMzExLWM1NzQtNDc1Ni1hMzY0LWY1ZjQzZmViZjNhYiIsInJlYWxtX2FjY2VzcyI6eyJyb2xlcyI6WyJkZWZhdWx0LXJvbGVzLWhlcyIsIlJPTEVfSEVTX0VUQyIsIlJPTEVfSEVTX0xBTkRJTkciXX0sInNjb3BlIjoiIiwic2lkIjoiNjk4N2EzMTEtYzU3NC00NzU2LWEzNjQtZjVmNDNmZWJmM2FiIiwiY2xpZW50SG9zdCI6IjEwLjUzLjI1NC4xNTAiLCJhY2Nlc3NfcnVsZXMiOnt9LCJhY2Nlc3NfaW5mbyI6eyJtb2R1bGVfY29kZSI6IkEwMDEiLCJyb2xlX3R5cGUiOiJOT1JNIiwidHJhY2VfdXNlcl9pZCI6IlVzZXJfSUQiLCJjZW50ZXJfdHlwZSI6IkUiLCJtcGlfcGF0aWVudF9pZCI6IjVlYzc0YzdiLTVhYTUtNGE4NC1iM2I0LWYwMmVkZGZkZjZkYyIsInVwX2NvZGUiOiIwNzczMyIsInRyYWNlX3VzZXJfZ2l2ZW5fbmFtZSI6IkdpdmVuIE5hbWUiLCJ0cmFjZV91c2VyX2ZhbWlseV9uYW1lIjoiRmFtaWx5IE5hbWUiLCJ1c2VyX3R5cGUiOiJBRE0iLCJjZW50ZXJfY29kZSI6IkUwODU4Njk2MyIsInByb2Zlc3Npb25hbF9jYXRlZ29yeSI6IjMwOTM0MzAwNiIsInNlcnZpY2VfY29kZSI6IjVTMDg5IiwiZXBfY29kZSI6IjAyMDgiLCJpZGVudGlmaWVyIjpbeyJ0eXBlIjoiRE5JIiwidmFsdWUiOiI3MzI4ODIxOUEifSx7InR5cGUiOiJOVU1DT0wiLCJ2YWx1ZSI6IjIifV0sImFsdF9pZGVudGlmaWVyIjpbeyJ0eXBlIjoiTVBJIiwidmFsdWUiOiIwNjIxY2Y3ZC03ZDYzLTQ5ZWMtODAwNi04YzA1NjkyZWQzNzcifV19LCJjbGllbnRBZGRyZXNzIjoiMTAuNTMuMjU0LjE1MCIsImNsaWVudF9pZCI6ImV0Yy1jY2YtcHJlIn0.zPxoN5d8_uxdbxeH7ly9sQdlnDxNp8_eWDzNSzjzkUPsRVkLxgjQw_WcjZfns-LNgGr0FToS6uSDIC7uj2hPpKqD7HPWbI6UPa7g-43Jf9rh-KSOXEHJWhlASi2w0n3xQHFSxHDYBwhyXlvWQ_Tr1Vh37MroWmEL84fdwqhcfZHmD9Ek52EuRRrB-XkymCmN1ZvO2GPU04LbBvQxLVzdAaKRzr1cUqHTnsEdgRduyKShPcyth01L_X7m128SIwjJsa1lYxFE_DbSDKz8dPTsxoS1DgwRxeArrkMlIdTHyxmDRezZUGhamyLuWpXLDXJCFfrTUB8-j_JnVlILHeR6O";
 
 describe("HTTP Client", () => {
-
   let broker = createBroker();
   let tokenManager: TokenManager;
   let axiosInstance: AxiosInstance;
@@ -19,91 +21,201 @@ describe("HTTP Client", () => {
 
   beforeEach(() => {
     vi.restoreAllMocks(); // Reset all spies before each test
-    vi.spyOn(window, 'location', 'get').mockReturnValue({
-      search: `?access_token=${access_token}&refresh_token=${refresh_token}`
+    vi.spyOn(window, "location", "get").mockReturnValue({
+      search: `?access_token=${access_token}&refresh_token=${refresh_token}`,
     } as unknown as Location);
-
-    tokenManager = createTokenManager();
-    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
-    const response = await axiosInstance.get("/api/clinical-course");
-    // Assertions
-    expect(response.status).toBe(200);
-    expect(response.data).toBe("success");
-    expect(axiosMockInstance.history.get?.length).toBe(1);
-    // @ts-ignore
-    expect(axiosMockInstance.history.get?.[0]?.headers.Authorization).toBe(
-      `Bearer ${access_token}`,
-    );
-  });
+  describe("Without validateMpid", () => {
+    beforeEach(() => {
+      tokenManager = createTokenManager();
+      axiosInstance = createAxiosInstance(tokenManager, broker);
+      axiosMockInstance = new AxiosMockAdapter(axiosInstance);
+      axiosMockInstance.reset();
+    });
 
-  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"
-      }
+    it("should make a request with header", async () => {
+      axiosMockInstance.onGet("/api/clinical-course").reply(200, "success");
+      // Perform the request
+      const response = await axiosInstance.get("/api/clinical-course");
+      // Assertions
+      expect(response.status).toBe(200);
+      expect(response.data).toBe("success");
+      expect(axiosMockInstance.history.get?.length).toBe(1);
+      // @ts-ignore
+      expect(axiosMockInstance.history.get?.[0]?.headers.Authorization).toBe(
+        `Bearer ${access_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(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 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: newAccessToken,
+          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");
+      // Assertions
+      expect(response.status).toBe(200);
+      expect(response.data).toBe("success");
+      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 " + newAccessToken,
+      );
+      expect(axiosMockInstance.history.get?.[2]?.headers?.Authorization).toBe(
+        "Bearer " + newAccessToken,
+      );
+    });
+
+    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();
+    });
   });
 
-  it("should fail request if token refresh fails and publish an event", async () => {
-    vi.spyOn(axios, "post").mockRejectedValueOnce({
-      response: { status: 400, statusText: "Bad Request" },
+  describe.skip("With validateMpid", () => {
+    const validTokenHeaders = { "x-catsalut-mpid": "5ec74c7b-5aa5-4a84-b3b4-f02eddfdf6dc" };
+    beforeEach(() => {
+      tokenManager = createTokenManager();
+      axiosInstance = createAxiosInstance(tokenManager, broker, true);
+      axiosMockInstance = new AxiosMockAdapter(axiosInstance);
+      axiosMockInstance.reset();
     });
-    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");
+    it("should throw error if mpid header is missing without sending broker event", async () => {
+      axiosMockInstance.onGet("/api/clinical-course").reply(200, "success");
+      const brokerSpy = vi.spyOn(broker, "publish");
 
-    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" }),
+      // Perform the request
+      await expect(axiosInstance.get("/api/clinical-course")).rejects.toThrow(
+        "Mpid header is missing",
+      );
+      expect(brokerSpy).not.toHaveBeenCalled();
+    });
+
+    it("should throw error if mpid header value is invalid and send broker event ", async () => {
+      axiosMockInstance.onGet("/api/clinical-course").reply(200, "success", {
+        "x-catsalut-mpid": "invalid-mpid",
+      });
+      const brokerSpy = vi.spyOn(broker, "publish");
+      // Perform the request
+      await expect(axiosInstance.get("/api/clinical-course")).rejects.toThrow(
+        "Mpid header value is invalid",
+      );
+      expect(brokerSpy).toHaveBeenCalledWith(shellEvents.mpidHeaderInvalid, expect.any(Object));
+    });
+
+    it("should make a request with header and respond succesful if x-catsalut-mpid has valid value ", async () => {
+      axiosMockInstance.onGet("/api/clinical-course").reply(200, "success", validTokenHeaders);
+      // Perform the request
+      const response = await axiosInstance.get("/api/clinical-course");
+      // Assertions
+      expect(response.status).toBe(200);
+      expect(response.data).toBe("success");
+      expect(axiosMockInstance.history.get?.length).toBe(1);
+      // @ts-ignore
+      expect(axiosMockInstance.history.get?.[0]?.headers.Authorization).toBe(
+        `Bearer ${access_token}`,
+      );
+    });
+
+    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", validTokenHeaders)
+        .onGet("/api/clinical-course/2")
+        .replyOnce(200, "success", validTokenHeaders);
+
+      vi.spyOn(axios, "post").mockResolvedValueOnce({
+        data: {
+          access_token: newAccessToken,
+          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");
+
+      // Assertions
+      expect(response.status).toBe(200);
+      expect(response.data).toBe("success");
+      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 " + newAccessToken,
+      );
+      expect(axiosMockInstance.history.get?.[2]?.headers?.Authorization).toBe(
+        "Bearer " + newAccessToken,
+      );
+    });
+
+    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 },
+    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();
     });
-    expect(axiosMockInstance.history.get?.length).toBe(1);
-    expect(refreshTokenSpy).not.toHaveBeenCalled();
-    expect(brokerSpy).not.toHaveBeenCalled();
   });
-  
 });

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

@@ -2,28 +2,76 @@ import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
 import { TokenManager } from "../token-manager/token-manager";
 import { shellEvents } from "../../events";
 import { PrimariaBroker } from "../broker/primaria-broker";
+import { jwtDecode } from "jwt-decode";
 
-export const createAxiosInstance = (tokenManager: TokenManager, broker: PrimariaBroker) => {
+const mpidHeader = "x-catsalut-mpid";
+const obtainMpid = (token: string) => {
+  const mpid = (jwtDecode(token) as any).access_info?.mpi_patient_id;
+  return mpid;
+};
+
+export class MissingMpidHeaderError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "MissingMpidHeaderError";
+  }
+}
+
+export class InvalidMpidHeaderError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "InvalidMpidHeaderError";
+  }
+}
+const validateMpidHeader = (response: AxiosResponse, tokenManager: TokenManager): boolean => {
+  const mpidHeaderValue = response.headers[mpidHeader];
+  if (!mpidHeaderValue) {
+    throw new MissingMpidHeaderError("Mpid header is missing");
+  }
+  if (mpidHeaderValue !== obtainMpid(tokenManager.getToken())) {
+    throw new InvalidMpidHeaderError("Mpid header value is invalid");
+  }
+  return true;
+};
+
+export const createAxiosInstance = (
+  tokenManager: TokenManager,
+  broker: PrimariaBroker,
+  validateMpid: boolean = false,
+) => {
   const instance = axios.create();
   instance.interceptors.request.use((config) => {
     config.headers.Authorization = `Bearer ${tokenManager.getToken()}`;
     return config;
   });
-  
+
   instance.interceptors.response.use(
-    (response: AxiosResponse) => response,
+    (response: AxiosResponse) => {
+      try {
+        if (validateMpid) validateMpidHeader(response, tokenManager);
+        return response;
+      } catch (error) {
+        if (error instanceof InvalidMpidHeaderError) {
+          broker.publish(shellEvents.mpidHeaderInvalid, {
+            request: response.config,
+          });
+        }
+        return Promise.reject(error);
+      }
+    },
     async (error) => {
       const originalRequest = error.config;
-      if (error.response.status === 401 && !originalRequest._retry) {
+      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);
+          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});
+          broker.publish(shellEvents.refreshTokenFailed, {
+            request: originalRequest,
+          });
           return Promise.reject(error);
         }
       }
@@ -41,9 +89,12 @@ let instance;
 export interface HttpClient {
   request<T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
 }
-export const createHttpClient = (tokenManager: TokenManager, broker: PrimariaBroker): HttpClient => {
+export const createHttpClient = (
+  tokenManager: TokenManager,
+  broker: PrimariaBroker,
+): HttpClient => {
   if (!instance) {
     instance = createAxiosInstance(tokenManager, broker);
   }
   return { request: instance.request };
-};
+};

package/src/api/interaction-service/confirmation-message.tsx

@@ -0,0 +1,5 @@
+import { ConfirmationContentProps } from "./interaction-service.ts";
+
+export const ConfirmationMessage = ({ data }: ConfirmationContentProps<string>) => {
+    return (<div>{data}</div>)
+}

package/src/api/interaction-service/index.ts

@@ -0,0 +1 @@
+export * from "./interaction-service";