@uxland/primary-shell 7.4.0 → 7.5.0

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

@@ -10,6 +10,7 @@ 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;
@@ -22,6 +23,7 @@ export interface PrimariaApi extends HarmonixApi {
     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/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.4.0",
+  "version": "7.5.0",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",

package/src/api/api.ts

@@ -25,6 +25,7 @@ import {
 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();
 
@@ -40,6 +41,7 @@ export interface PrimariaApi extends HarmonixApi {
   ecapEventManager: EcapEventManager;
   pluginBusyManager: PluginBusyManager;
   pdfViewerManager: PdfViewerManager;
+  importDataManager: PrimariaImportDataManager;
 }
 
 const regionManager: RegionManager = createRegionManager("primaria");
@@ -52,6 +54,7 @@ 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.
@@ -78,6 +81,7 @@ export const primariaApiFactory: ApiFactory<PrimariaApi> = (
     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>');
+    });
+  });
+});

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 = {