@uxland/primary-shell 7.3.0 → 7.5.0

package/src/api/import-data-manager/import-data-manager-impl.ts

@@ -0,0 +1,80 @@
+import { PrimariaImportDataManager } from './import-data-manager';
+import { PrimariaInteractionService } from '../interaction-service/interaction-service';
+
+export class ImportDataManagerImpl implements PrimariaImportDataManager {
+  private selectedItems: Record<string, any[]> = {};
+  private currentImporterId = '';
+  private pluginTexts: Record<string, {raw: string, html: string}> = {};
+
+  constructor(private interactionService: PrimariaInteractionService) {}
+
+  async import(importerId: string): Promise<{
+    accepted: boolean;
+    data: Record<string, any[]>;
+    text: {raw: string, html: string};
+  }> {
+    this.currentImporterId = importerId;
+    this.selectedItems = {};
+    this.pluginTexts = {};
+
+    try {
+      // Import component dynamically to avoid circular dependency
+      const { ImportDataManagerModal } = await import("./component/component");
+
+      const { confirmed } = await this.interactionService.confirm(
+        undefined,
+        { component: ImportDataManagerModal as any },
+        {
+          fullCustomization: true,
+        },
+      );
+
+      const concatenatedText = this.getConcatenatedText();
+
+      const finalResult = {
+        accepted: confirmed,
+        data: confirmed ? this.selectedItems : {},
+        text: confirmed ? concatenatedText : {raw: '', html: ''}
+      };
+
+      this.selectedItems = {};
+      this.currentImporterId = '';
+      this.pluginTexts = {};
+
+      return finalResult;
+    } catch (error) {
+      this.selectedItems = {};
+      this.currentImporterId = '';
+      this.pluginTexts = {};
+      throw error;
+    }
+  }
+
+  selectItems(payload: {
+    pluginId: string,
+    data: any[],
+    text: {raw: string, html: string}
+  }): void {
+    this.selectedItems[payload.pluginId] = payload.data;
+    this.pluginTexts[payload.pluginId] = payload.text;
+  }
+
+  getCurrentImporterId(): string {
+    return this.currentImporterId;
+  }
+
+  private getConcatenatedText(): {raw: string, html: string} {
+    const rawTexts: string[] = [];
+    const htmlTexts: string[] = [];
+
+    for (const text of Object.values(this.pluginTexts)) {
+      if (text.raw) rawTexts.push(text.raw);
+      if (text.html) htmlTexts.push(text.html);
+    }
+
+    return {
+      raw: rawTexts.join('\n\n'),
+      html: htmlTexts.join('<br><br>')
+    };
+  }
+}

package/src/api/import-data-manager/import-data-manager.ts

@@ -0,0 +1,15 @@
+export interface PrimariaImportDataManager {
+  import(importerId: string): Promise<{
+    accepted: boolean;
+    data: Record<string, any[]>;
+    text: {raw: string, html: string};
+  }>;
+
+  selectItems(payload: {
+    pluginId: string,
+    data: any[],
+    text: {raw: string, html: string}
+  }): void;
+
+  getCurrentImporterId(): string;
+}

package/src/api/import-data-manager/index.ts

@@ -0,0 +1,2 @@
+export * from './import-data-manager';
+export * from './import-data-manager-impl';

package/src/api/region-manager/regions.ts

@@ -7,6 +7,7 @@ export const shellRegions = {
   quickActions: "quick-actions-region",
   floating: "floating-region",
   communicationSidenav: "communication-sidenav-region",
+  importData: "import-data-region",
 };
 
 export const clinicalMonitoringRegions = {

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

@@ -0,0 +1,45 @@
+import { jwtDecode } from "jwt-decode";
+import { TokenManager } from "../token-manager/token-manager";
+
+interface JWTPayload {
+  access_info?: {
+    role_type?: string;
+  };
+}
+
+export interface UserManager {
+  getRole: () => string | undefined;
+  isUserRoleAdministrative: () => boolean;
+}
+
+export class UserManagerImpl implements UserManager {
+  constructor(private tokenManager: TokenManager) {}
+
+  getRole = (): string | undefined => {
+    const token = this.tokenManager.getToken();
+    if (!token) {
+      return undefined;
+    }
+    
+    try {
+      const payload = jwtDecode<JWTPayload>(token);
+      const role = payload.access_info?.role_type;
+      return role;
+    } catch (error) {
+      console.error("Error decoding JWT token:", error);
+      return undefined;
+    }
+  };
+
+  isUserRoleAdministrative = (): boolean => {
+    const userRole = this.getRole();
+    return userRole === "ADM";
+  };
+}
+
+let userManager: UserManager;
+export const createUserManager = (tokenManager: TokenManager): UserManager => {
+  if (userManager) return userManager;
+  userManager = new UserManagerImpl(tokenManager);
+  return userManager;
+};

package/src/bootstrapper.ts

@@ -4,9 +4,9 @@ import { useFeatures } from "./features/bootstrapper";
 import { useLocalization } from "./locales";
 import { useUI } from "./UI/bootstrapper";
 
-export const initializeShell = (hostAppElement: HTMLElement, userRole?: string) => {
+export const initializeShell = (hostAppElement: HTMLElement) => {
   useLocalization(shellApi);
-  useUI(userRole);
+  useUI();
   useFeatures(shellApi);
   const shell = new PrimariaShell();
   hostAppElement.appendChild(shell as any);

package/src/handle-plugins.ts

@@ -13,8 +13,7 @@ import {
   initialize as adminClinicalMonitoringInitialize,
   dispose as adminClinicalMonitoringDispose,
 } from "../../../plugins/admin-clinical-monitoring/src/plugin";
-import { PrimariaApi, primariaApiFactory } from "./api/api";
-import { isUserRoleAdministrative } from "./domain/is-user-role-administrative";
+import { PrimariaApi, primariaApiFactory, shellApi } from "./api/api";
 
 let bootstrappedPlugins = [] as BootstrappedPlugin[];
 
@@ -51,15 +50,16 @@ const administrativeInternalPlugins: PluginDefinition[] = [
   },
 ];
 
-const getPluginsByUserRole = (userRole?: string) => {
-  if (isUserRoleAdministrative(userRole)) {
+const getPluginsByUserRole = (isUserRoleAdministrative: boolean) => {
+  if (isUserRoleAdministrative) {
     return commonPlugins.concat(administrativeInternalPlugins);
   }
   return commonPlugins.concat(doctorInternalPlugins);
 };
 
-export const bootstrapPlugins = async (plugins: PluginDefinition[], userRole?: string) => {
-  const internalPlugins = getPluginsByUserRole(userRole);
+export const bootstrapPlugins = async (plugins: PluginDefinition[]) => {
+  const isUserRoleAdministrative = shellApi.userManager.isUserRoleAdministrative();
+  const internalPlugins = getPluginsByUserRole(isUserRoleAdministrative);
   const finalPlugins = internalPlugins.concat(plugins || []);
   bootstrappedPlugins = await pluginBootstrapper(finalPlugins, primariaApiFactory);
 };

package/src/locales.ts

@@ -25,6 +25,8 @@ export const translate = (path: ShellLocales) => {
 
 export { shellLocaleManager };
 
+const defaultLang = "ca";
+
 export const locales = {
   ca: {
     [primariaShellId]: {
@@ -61,6 +63,13 @@ export const locales = {
       pdfVisor: {
         noPdfSelected: "No hi ha cap PDF seleccionat",
       },
+      importDataManager:{
+        title: "Importar dades",
+        actions: {
+          cancel: "Cancel·lar",
+          import: "Importar dades",
+        }
+      }
     },
   },
 };

package/dist/primary/shell/src/domain/is-user-role-administrative.d.ts

@@ -1 +0,0 @@
-export declare const isUserRoleAdministrative: (userRole?: string) => userRole is "ADM";

package/src/domain/is-user-role-administrative.ts

@@ -1 +0,0 @@
-export const isUserRoleAdministrative = (userRole?: string) => userRole === "ADM";