@uxland/primary-shell 7.3.0 → 7.5.0

package/dist/primary/shell/src/UI/bootstrapper.d.ts

@@ -1 +1 @@
-export declare const useUI: (userRole?: string) => void;
+export declare const useUI: () => void;

package/dist/primary/shell/src/UI/internal-views/handle-views.d.ts

@@ -1 +1 @@
-export declare const useInternalViews: (userRole?: string) => void;
+export declare const useInternalViews: () => void;

package/dist/primary/shell/src/api/api.d.ts

@@ -9,6 +9,8 @@ import { PdfViewerManager } from './pdf-viewer-manager/pdf-viewer-manager';
 import { PluginBusyManager } from './plugin-busy-manager/plugin-busy-manager';
 import { PrimariaRegionManager } from './region-manager/region-manager';
 import { TokenManager } from './token-manager/token-manager';
+import { UserManager } from './user-manager/user-manager';
+import { PrimariaImportDataManager } from './import-data-manager';
 export interface PrimariaApi extends HarmonixApi {
     httpClient: HttpClient;
     interactionService: PrimariaInteractionService;
@@ -17,9 +19,11 @@ export interface PrimariaApi extends HarmonixApi {
     regionManager: PrimariaRegionManager;
     globalStateManager: PrimariaGlobalStateManager;
     tokenManager: TokenManager;
+    userManager: UserManager;
     ecapEventManager: EcapEventManager;
     pluginBusyManager: PluginBusyManager;
     pdfViewerManager: PdfViewerManager;
+    importDataManager: PrimariaImportDataManager;
 }
 export declare const PrimariaRegionHost: any;
 /**

package/dist/primary/shell/src/api/import-data-manager/component/component.d.ts

@@ -0,0 +1,15 @@
+import { IRegion } from '@uxland/regions';
+import { ConfirmationContentProps } from '../../interaction-service';
+declare const ImportDataManagerModal_base: any;
+export declare class ImportDataManagerModal extends ImportDataManagerModal_base implements ConfirmationContentProps<undefined, undefined> {
+    data: undefined;
+    setResult: (result: undefined) => void;
+    setIsValid: (isValid: boolean) => void;
+    confirm: () => void;
+    cancel: () => void;
+    importDataRegion: IRegion | undefined;
+    render(): import('lit').TemplateResult<1>;
+    static styles: import('lit').CSSResult;
+    _accept: () => void;
+}
+export {};

package/dist/primary/shell/src/api/import-data-manager/component/template.d.ts

@@ -0,0 +1,2 @@
+import { ImportDataManagerModal } from './component';
+export declare const template: (props: ImportDataManagerModal) => import('lit').TemplateResult<1>;

package/dist/primary/shell/src/api/import-data-manager/import-data-manager-impl.d.ts

@@ -0,0 +1,27 @@
+import { PrimariaImportDataManager } from './import-data-manager';
+import { PrimariaInteractionService } from '../interaction-service/interaction-service';
+export declare class ImportDataManagerImpl implements PrimariaImportDataManager {
+    private interactionService;
+    private selectedItems;
+    private currentImporterId;
+    private pluginTexts;
+    constructor(interactionService: PrimariaInteractionService);
+    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;
+    private getConcatenatedText;
+}

package/dist/primary/shell/src/api/import-data-manager/import-data-manager-impl.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primary/shell/src/api/import-data-manager/import-data-manager.d.ts

@@ -0,0 +1,19 @@
+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/dist/primary/shell/src/api/import-data-manager/index.d.ts

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

package/dist/primary/shell/src/api/region-manager/regions.d.ts

@@ -7,6 +7,7 @@ export declare const shellRegions: {
     quickActions: string;
     floating: string;
     communicationSidenav: string;
+    importData: string;
 };
 export declare const clinicalMonitoringRegions: {
     sidebar: string;

package/dist/primary/shell/src/api/user-manager/user-manager.d.ts

@@ -0,0 +1,12 @@
+import { TokenManager } from '../token-manager/token-manager';
+export interface UserManager {
+    getRole: () => string | undefined;
+    isUserRoleAdministrative: () => boolean;
+}
+export declare class UserManagerImpl implements UserManager {
+    private tokenManager;
+    constructor(tokenManager: TokenManager);
+    getRole: () => string | undefined;
+    isUserRoleAdministrative: () => boolean;
+}
+export declare const createUserManager: (tokenManager: TokenManager) => UserManager;

package/dist/primary/shell/src/bootstrapper.d.ts

@@ -1 +1 @@
-export declare const initializeShell: (hostAppElement: HTMLElement, userRole?: string) => void;
+export declare const initializeShell: (hostAppElement: HTMLElement) => void;

package/dist/primary/shell/src/handle-plugins.d.ts

@@ -1,6 +1,6 @@
 import { PluginDefinition, Plugin as PluginType } from '@uxland/harmonix';
 import { PrimariaApi } from './api/api';
 export type { PluginDefinition, PluginInfo } from '@uxland/harmonix';
-export declare const bootstrapPlugins: (plugins: PluginDefinition[], userRole?: string) => Promise<void>;
+export declare const bootstrapPlugins: (plugins: PluginDefinition[]) => Promise<void>;
 export declare const disposePlugins: () => Promise<void[]>;
 export type Plugin = PluginType<PrimariaApi>;

package/dist/primary/shell/src/locales.d.ts

@@ -8,6 +8,7 @@ type LocaleKeys<T> = T extends object ? {
 export type ShellLocales = LocaleKeys<(typeof locales)[typeof defaultLang][typeof primariaShellId]>;
 export declare const translate: (path: ShellLocales) => any;
 export { shellLocaleManager };
+declare const defaultLang = "ca";
 export declare const locales: {
     ca: {
         "primaria-shell": {
@@ -44,6 +45,13 @@ export declare const locales: {
             pdfVisor: {
                 noPdfSelected: string;
             };
+            importDataManager: {
+                title: string;
+                actions: {
+                    cancel: string;
+                    import: string;
+                };
+            };
         };
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxland/primary-shell",
-  "version": "7.3.0",
+  "version": "7.5.0",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",

package/src/UI/bootstrapper.ts

@@ -3,12 +3,12 @@ import { useComponents } from "./components/bootstrapper";
 import { useSharedUI } from "./shared-components/bootstrapper";
 import { useInternalViews } from "./internal-views/handle-views";
 
-export const useUI = (userRole?: string) => {
+export const useUI = () => {
   regionAdapterRegistry.registerAdapterFactory(
     "primaria-content-switcher",
     selectableAdapterFactory,
   );
   useSharedUI();
   useComponents();
-  useInternalViews(userRole);
+  useInternalViews();
 };

package/src/UI/internal-views/handle-views.ts

@@ -1,14 +1,15 @@
+import { shellApi } from "../../api/api";
 import { registerPDFVisorMainView } from "../../api/pdf-viewer-manager/handle-views";
-import { isUserRoleAdministrative } from "../../domain/is-user-role-administrative";
 import { registerAdministrativeNavMenuViews, registerDoctorNavMenuViews } from "./upper-nav-views";
 
 const registerMainViews = () => {
   registerPDFVisorMainView();
 };
 
-export const useInternalViews = (userRole?: string) => {
+export const useInternalViews = () => {
   registerMainViews();
-  if(isUserRoleAdministrative(userRole))
+  const isUserRoleAdministrative = shellApi.userManager.isUserRoleAdministrative();
+  if((isUserRoleAdministrative))
     registerAdministrativeNavMenuViews();
   else
     registerDoctorNavMenuViews();

package/src/api/api.ts

@@ -24,6 +24,8 @@ import {
 } from "./plugin-busy-manager/plugin-busy-manager";
 import { PrimariaRegionManager, createRegionManagerProxy } from "./region-manager/region-manager";
 import { TokenManager, createTokenManager } from "./token-manager/token-manager";
+import { UserManager, createUserManager } from "./user-manager/user-manager";
+import { PrimariaImportDataManager, ImportDataManagerImpl } from "./import-data-manager";
 
 const broker = createBroker();
 
@@ -35,20 +37,24 @@ export interface PrimariaApi extends HarmonixApi {
   regionManager: PrimariaRegionManager;
   globalStateManager: PrimariaGlobalStateManager;
   tokenManager: TokenManager;
+  userManager: UserManager;
   ecapEventManager: EcapEventManager;
   pluginBusyManager: PluginBusyManager;
   pdfViewerManager: PdfViewerManager;
+  importDataManager: PrimariaImportDataManager;
 }
 
 const regionManager: RegionManager = createRegionManager("primaria");
 export const PrimariaRegionHost: any = createRegionHost(regionManager as any);
 const tokenManager = createTokenManager();
+const userManager = createUserManager(tokenManager);
 const globalStateManager: PrimariaGlobalStateManager = createGlobalStateManager(broker);
 const pluginBusyManager = new PluginBusyManagerImpl(broker);
 const interactionService = new ParimariaInteractionServiceImpl();
 const notificationService = new PrimariaNotificationServiceImpl();
 const ecapEventManager = createEcapEventManager();
 const pdfViewerManager = createPdfViewerManager(broker, notificationService);
+const importDataManager = new ImportDataManagerImpl(interactionService);
 
 /**
  * Factory function that creates a Primaria API instance.
@@ -69,11 +75,13 @@ export const primariaApiFactory: ApiFactory<PrimariaApi> = (
     createLocaleManager: createLocaleManager(pluginInfo.pluginId) as any,
     globalStateManager,
     tokenManager,
+    userManager,
     ecapEventManager,
     pluginBusyManager,
     interactionService,
     notificationService,
     pdfViewerManager,
+    importDataManager,
   };
 };
 

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

@@ -0,0 +1,34 @@
+
+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 { ConfirmationContentProps } from "../../interaction-service";
+import { PrimariaRegionHost } from "../../api";
+
+@customElement("import-data-manager-modal")
+export class ImportDataManagerModal
+  extends PrimariaRegionHost(LitElement) implements ConfirmationContentProps<undefined, undefined>
+{
+  data: undefined;
+  setResult: (result: undefined) => void;
+  setIsValid: (isValid: boolean) => void;
+  confirm: () => void;
+  cancel: () => void;
+
+  @region({ targetId: "import-data-region", name: "import-data-region" })
+  importDataRegion: IRegion | undefined;
+
+  render() {
+    return html`${template(this)}`;
+  }
+
+  static styles = css`
+    ${unsafeCSS(styles)}
+  `;
+
+  _accept = () => {
+    this.confirm();
+  };
+}

package/src/api/import-data-manager/component/styles.css

@@ -0,0 +1,58 @@
+.container {
+  background-color: white;
+  display: flex;
+  flex-direction: column;
+  min-width: 500px;
+  width: 90vw;
+  height: 90vh;
+  border-radius: var(--dss-radius-sm);
+  overflow: hidden;
+}
+
+/* .header {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  justify-content: space-between;
+  text-align: center;
+  color: black;
+  padding: var(--dss-spacing-sm);
+
+  .title {
+    display: flex;
+    flex-direction: row;
+    gap: 8px;
+  }
+} */
+
+.content{
+  display: grid;
+  height: 100%;
+  min-height: 1px;
+  grid-template-columns: 1fr 1fr;
+  grid-auto-rows: 1fr;
+  gap: 16px;
+  padding: 16px;
+  overflow-y: auto;
+  max-height: calc(90vh - 120px);
+}
+
+.content > * {
+  border: 1px solid var(--color-neutral-200);
+  border-radius: 8px;
+  padding: 16px;
+  background-color: var(--color-neutral-50);
+  min-height: 200px;
+} 
+
+.footer {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  background: white;
+  justify-content: end;
+  gap: 12px;
+  height: 56px;
+  border-top: 1px solid var(--color-neutral-100);
+  padding: var(--dss-spacing-sm);
+}

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

@@ -0,0 +1,24 @@
+import { html } from "lit";
+import { translate } from "../../../locales";
+import { ImportDataManagerModal } from "./component";
+
+export const template = (props: ImportDataManagerModal) => {
+  return html`
+    <div class="container">
+      <!-- <div class="header">
+        <div class="title">
+          <div>${translate("importDataManager.title")}</div>
+        </div>  
+      </div> -->
+        <div class="content" id="import-data-region"></div>
+        <div class="footer">
+    <dss-button label="${translate("importDataManager.actions.cancel")}" @click="${() => {
+        props.cancel();
+      }}" size="md" variant="secondary"></dss-button>
+      <dss-button label="${translate("importDataManager.actions.import")}" @click="${() => {
+        props._accept();
+      }}" size="md" variant="primary"></dss-button>
+  </div>
+    </div>
+  `;
+};

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

@@ -0,0 +1,282 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ImportDataManagerImpl } from './import-data-manager-impl';
+import { PrimariaInteractionService, ConfirmationOptions, ConfirmComponentUI, ConfirmationResult } from '../interaction-service/interaction-service';
+
+// Mock del PrimariaInteractionService
+class MockInteractionService extends PrimariaInteractionService {
+  private mockConfirmResult: { confirmed: boolean; result?: unknown } = { confirmed: true };
+
+  // Mètode per configurar el resultat del mock
+  setMockConfirmResult(result: { confirmed: boolean; result?: unknown }) {
+    this.mockConfirmResult = result;
+  }
+
+  async confirm<TData = undefined, TResult = undefined>(
+    _data: TData | undefined,
+    _componentUI: ConfirmComponentUI<TData, TResult>,
+    _options?: ConfirmationOptions | undefined,
+  ): Promise<ConfirmationResult<TResult | undefined>> {
+    return Promise.resolve(this.mockConfirmResult as ConfirmationResult<TResult | undefined>);
+  }
+
+  async confirmMessage(
+    _message: string,
+    _options?: ConfirmationOptions | undefined,
+  ): Promise<ConfirmationResult> {
+    return Promise.resolve({ confirmed: this.mockConfirmResult.confirmed, result: undefined });
+  }
+}
+
+describe('ImportDataManagerImpl implements PrimariaImportDataManager', () => {
+  let importDataManager: ImportDataManagerImpl;
+  let mockInteractionService: MockInteractionService;
+
+  beforeEach(() => {
+    mockInteractionService = new MockInteractionService();
+    importDataManager = new ImportDataManagerImpl(mockInteractionService);
+  });
+
+  describe('getCurrentImporterId', () => {
+    it('should return empty string initially', () => {
+      expect(importDataManager.getCurrentImporterId()).toBe('');
+    });
+
+    it('should return the current importer ID after calling import', async () => {
+      mockInteractionService.setMockConfirmResult({ confirmed: true });
+
+      const promise = importDataManager.import('test-importer-123');
+      expect(importDataManager.getCurrentImporterId()).toBe('test-importer-123');
+
+      await promise;
+      expect(importDataManager.getCurrentImporterId()).toBe('');
+    });
+  });
+
+  describe('selectItems', () => {
+    it('should store selected items correctly', () => {
+      const payload = {
+        pluginId: 'test-plugin',
+        data: [{ id: '1', name: 'Test Item' }],
+        text: { raw: 'Test Item', html: '<p>Test Item</p>' }
+      };
+
+      importDataManager.selectItems(payload);
+
+      // Test via getCurrentImporterId and import method to verify internal state
+      expect(() => importDataManager.selectItems(payload)).not.toThrow();
+    });
+
+    it('should handle multiple plugin selections', () => {
+      const payload1 = {
+        pluginId: 'plugin-1',
+        data: [{ id: '1', name: 'Item 1' }],
+        text: { raw: 'Item 1', html: '<p>Item 1</p>' }
+      };
+
+      const payload2 = {
+        pluginId: 'plugin-2',
+        data: [{ id: '2', name: 'Item 2' }],
+        text: { raw: 'Item 2', html: '<p>Item 2</p>' }
+      };
+
+      expect(() => {
+        importDataManager.selectItems(payload1);
+        importDataManager.selectItems(payload2);
+      }).not.toThrow();
+    });
+
+    it('should overwrite previous selections from same plugin', () => {
+      const payload1 = {
+        pluginId: 'test-plugin',
+        data: [{ id: '1', name: 'First Item' }],
+        text: { raw: 'First Item', html: '<p>First Item</p>' }
+      };
+
+      const payload2 = {
+        pluginId: 'test-plugin',
+        data: [{ id: '2', name: 'Second Item' }],
+        text: { raw: 'Second Item', html: '<p>Second Item</p>' }
+      };
+
+      expect(() => {
+        importDataManager.selectItems(payload1);
+        importDataManager.selectItems(payload2);
+      }).not.toThrow();
+    });
+  });
+
+  describe('import', () => {
+    it('should return accepted result with concatenated text when confirmed', async () => {
+      mockInteractionService.setMockConfirmResult({ confirmed: true });
+
+      // Mock the import to allow setting up items during the import process
+      const originalConfirm = mockInteractionService.confirm.bind(mockInteractionService);
+      vi.spyOn(mockInteractionService, 'confirm').mockImplementation(async (...args) => {
+        // Setup some selected items during the import process (simulating user interaction)
+        importDataManager.selectItems({
+          pluginId: 'plugin-1',
+          data: [{ id: '1', name: 'Item 1' }],
+          text: { raw: 'Item 1', html: '<p>Item 1</p>' }
+        });
+
+        importDataManager.selectItems({
+          pluginId: 'plugin-2',
+          data: [{ id: '2', name: 'Item 2' }],
+          text: { raw: 'Item 2', html: '<p>Item 2</p>' }
+        });
+
+        return originalConfirm(...args);
+      });
+
+      const result = await importDataManager.import('test-importer');
+
+      expect(result.accepted).toBe(true);
+      expect(result.data).toEqual({
+        'plugin-1': [{ id: '1', name: 'Item 1' }],
+        'plugin-2': [{ id: '2', name: 'Item 2' }]
+      });
+      expect(result.text.raw).toBe('Item 1\n\nItem 2');
+      expect(result.text.html).toBe('<p>Item 1</p><br><br><p>Item 2</p>');
+    });
+
+    it('should return cancelled result with empty data when not confirmed', async () => {
+      mockInteractionService.setMockConfirmResult({ confirmed: false });
+
+      // Setup some selected items
+      importDataManager.selectItems({
+        pluginId: 'plugin-1',
+        data: [{ id: '1', name: 'Item 1' }],
+        text: { raw: 'Item 1', html: '<p>Item 1</p>' }
+      });
+
+      const result = await importDataManager.import('test-importer');
+
+      expect(result.accepted).toBe(false);
+      expect(result.data).toEqual({});
+      expect(result.text.raw).toBe('');
+      expect(result.text.html).toBe('');
+    });
+
+    it('should clear state after successful import', async () => {
+      mockInteractionService.setMockConfirmResult({ confirmed: true });
+
+      // Setup selected items
+      importDataManager.selectItems({
+        pluginId: 'test-plugin',
+        data: [{ id: '1', name: 'Test Item' }],
+        text: { raw: 'Test Item', html: '<p>Test Item</p>' }
+      });
+
+      await importDataManager.import('test-importer');
+
+      // Verify state is cleared
+      expect(importDataManager.getCurrentImporterId()).toBe('');
+
+      // Verify that subsequent import returns empty data
+      const result = await importDataManager.import('another-importer');
+      expect(result.data).toEqual({});
+      expect(result.text.raw).toBe('');
+      expect(result.text.html).toBe('');
+    });
+
+    it('should clear state after cancelled import', async () => {
+      mockInteractionService.setMockConfirmResult({ confirmed: false });
+
+      // Setup selected items
+      importDataManager.selectItems({
+        pluginId: 'test-plugin',
+        data: [{ id: '1', name: 'Test Item' }],
+        text: { raw: 'Test Item', html: '<p>Test Item</p>' }
+      });
+
+      await importDataManager.import('test-importer');
+
+      // Verify state is cleared
+      expect(importDataManager.getCurrentImporterId()).toBe('');
+    });
+
+    it('should handle empty selections', async () => {
+      mockInteractionService.setMockConfirmResult({ confirmed: true });
+
+      const result = await importDataManager.import('test-importer');
+
+      expect(result.accepted).toBe(true);
+      expect(result.data).toEqual({});
+      expect(result.text.raw).toBe('');
+      expect(result.text.html).toBe('');
+    });
+
+    it('should handle error and clear state', async () => {
+      mockInteractionService.setMockConfirmResult({ confirmed: true });
+
+      // Mock the interaction service to throw an error
+      vi.spyOn(mockInteractionService, 'confirm').mockRejectedValueOnce(new Error('Test error'));
+
+      // Setup selected items
+      importDataManager.selectItems({
+        pluginId: 'test-plugin',
+        data: [{ id: '1', name: 'Test Item' }],
+        text: { raw: 'Test Item', html: '<p>Test Item</p>' }
+      });
+
+      await expect(importDataManager.import('test-importer')).rejects.toThrow('Test error');
+
+      // Verify state is cleared even after error
+      expect(importDataManager.getCurrentImporterId()).toBe('');
+    });
+
+    it('should handle text concatenation correctly with multiple plugins', async () => {
+      mockInteractionService.setMockConfirmResult({ confirmed: true });
+
+      // Mock the import to allow setting up items during the import process
+      const originalConfirm = mockInteractionService.confirm.bind(mockInteractionService);
+      vi.spyOn(mockInteractionService, 'confirm').mockImplementation(async (...args) => {
+        importDataManager.selectItems({
+          pluginId: 'diagnostics',
+          data: [{ code: 'E11.9', name: 'Diabetes' }],
+          text: { raw: 'E11.9 - Diabetes', html: '<p><strong>E11.9</strong> - Diabetes</p>' }
+        });
+
+        importDataManager.selectItems({
+          pluginId: 'allergies',
+          data: [{ name: 'Penicillin', severity: 'High' }],
+          text: { raw: 'Penicillin - High severity', html: '<p><strong>Penicillin</strong> - High severity</p>' }
+        });
+
+        return originalConfirm(...args);
+      });
+
+      const result = await importDataManager.import('test-importer');
+
+      expect(result.text.raw).toBe('E11.9 - Diabetes\n\nPenicillin - High severity');
+      expect(result.text.html).toBe('<p><strong>E11.9</strong> - Diabetes</p><br><br><p><strong>Penicillin</strong> - High severity</p>');
+    });
+
+    it('should handle empty text values in concatenation', async () => {
+      mockInteractionService.setMockConfirmResult({ confirmed: true });
+
+      // Mock the import to allow setting up items during the import process
+      const originalConfirm = mockInteractionService.confirm.bind(mockInteractionService);
+      vi.spyOn(mockInteractionService, 'confirm').mockImplementation(async (...args) => {
+        importDataManager.selectItems({
+          pluginId: 'plugin-1',
+          data: [{ id: '1' }],
+          text: { raw: '', html: '' }
+        });
+
+        importDataManager.selectItems({
+          pluginId: 'plugin-2',
+          data: [{ id: '2' }],
+          text: { raw: 'Item 2', html: '<p>Item 2</p>' }
+        });
+
+        return originalConfirm(...args);
+      });
+
+      const result = await importDataManager.import('test-importer');
+
+      expect(result.text.raw).toBe('Item 2');
+      expect(result.text.html).toBe('<p>Item 2</p>');
+    });
+  });
+});