@uxland/primary-shell 3.5.2 → 3.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxland/primary-shell",
-  "version": "3.5.2",
+  "version": "3.5.4",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",
@@ -44,7 +44,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.0.5.tgz",
+    "@salut/design-system-salut": "../../design-system-salut-2.1.1.tgz",
     "jwt-decode": "^4.0.0",
     "lit": "^3.1.0",
     "mediatr-ts": "^1.2.1",

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

@@ -1,6 +1,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";
 
 export const template = (props: ShellHeader) => {
   const workCenterElements = [{ label: props.professional?.workCenter, value: "1" }];
@@ -17,8 +18,10 @@ export const template = (props: ShellHeader) => {
     </div>
     <div class="header__right">
       <div id="header-actions-region-container"></div>
-      <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}">
-        <dss-avatar size="xl" name="${props.professional?.firstName}" surname="${props.professional?.familyName}" slot="avatar"></dss-avatar>
+      ${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}">
+        <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">Centre treball</label>
             <input id="preferences1" slot="input" type="text" class="dss-input" readonly="">
@@ -31,7 +34,8 @@ export const template = (props: ShellHeader) => {
           <label slot="label" for="preferences3">Ambit treball</label>
           <input id="preferences3" slot="input" type="text" class="dss-input" readonly="">
         </dss-input-dropdown>
-      </dss-header-menu-professional>
+      </dss-header-menu-professional>`,
+      )}
     </div>
   </div>
 `;

package/src/UI/shared-components/primaria-text-editor/primaria-rich-text-editor.ts

@@ -20,6 +20,13 @@ export class PrimariaRichTextEditor extends LitElement {
   firstUpdated() {
     // const rte: PrimariaRichTextEditor = this;
     this.quill = new Quill(this.shadowRoot?.querySelector("#rte"), this._getOptions());
+
+    this.quill.on("text-change", () => this._emitTextChangeEvent());
+
+    this.quill.root.addEventListener("paste", () => {
+      this._emitTextChangeEvent();
+    });
+
     this.quill.on("text-change", (delta, oldDelta, source) => {
       const plainValue = this.quill.getText();
       const values = {
@@ -39,6 +46,22 @@ export class PrimariaRichTextEditor extends LitElement {
     });
   }
 
+  _emitTextChangeEvent() {
+    const plainValue = this.quill.getText();
+    const values = {
+      html: this.shadowRoot?.querySelector(".ql-editor")?.innerHTML,
+      plain: plainValue,
+    };
+
+    const textChanged = new CustomEvent("text-changed", {
+      composed: true,
+      detail: values,
+    });
+
+    this.dispatchEvent(textChanged);
+    this.range = this.getCursorPosition();
+  }
+
   @property()
   quill: Quill | null;
 

package/src/internal-plugins/activity-history/{features/inject-async-history-items → activity-history-item/add/add-async-history-items}/bootstrapper.ts

@@ -1,7 +1,7 @@
 import { BrokerExtensions } from "@primaria/plugins-core";
 import { injectAsyncHistoryItemsRequest } from "./request";
 import { InjectAsyncHistoryItemsHandler } from "./handler";
-import { BrokerDisposableHandler } from "../../../../api/broker/primaria-broker";
+import { BrokerDisposableHandler } from "../../../../../api/broker/primaria-broker";
 
 let request: BrokerDisposableHandler;
 
@@ -9,6 +9,6 @@ export const bootstrapInjectAsyncHistoryItems = (broker: BrokerExtensions) => {
   request = broker.registerRequest(injectAsyncHistoryItemsRequest, InjectAsyncHistoryItemsHandler);
 };
 
-export const teardownInjectAsyncHistoryItems = (broker: BrokerExtensions) => {
+export const teardownInjectAsyncHistoryItems = () => {
   request?.dispose();
 };

package/src/internal-plugins/activity-history/activity-history-item/add/add-async-history-items/handler.ts

@@ -0,0 +1,27 @@
+import { BaseHandler } from "../../../infrastructure/base-handlers";
+import { addBusyHistoryItem, removeBusyHistoryItem } from "../../list/handle-busy/actions";
+import { addErrorHistoryItem } from "../../list/handle-error/actions";
+import { addHistoryItemsRequest } from "../add-history-items/request";
+import { InjectAsyncHistoryItemsPayload } from "./request";
+
+export class InjectAsyncHistoryItemsHandler extends BaseHandler {
+  async handle(payload: InjectAsyncHistoryItemsPayload) {
+    this.store.dispatch(addBusyHistoryItem(payload.entityId));
+    try {
+      let items = await payload.asyncTask();
+      if (payload.mapFn) items = items.map(payload.mapFn);
+      this.api.broker.send(addHistoryItemsRequest, {
+        entityId: payload.entityId,
+        items,
+        componentFactory: payload.componentFactory,
+        searchPredicate: payload.searchPredicate,
+      });
+    } catch (e) {
+      this.store.dispatch(
+        addErrorHistoryItem({ id: payload.entityId, message: payload.errorMessage || e.message }),
+      );
+    } finally {
+      this.store.dispatch(removeBusyHistoryItem(payload.entityId));
+    }
+  }
+}

package/src/internal-plugins/activity-history/{features/inject-async-history-items → activity-history-item/add/add-async-history-items}/request.ts

@@ -1,8 +1,10 @@
+import { IActivityHistoryItem } from "../../domain/model";
+
 export interface InjectAsyncHistoryItemsPayload {
   entityId: string;
   asyncTask: () => Promise<any>;
   mapFn?: (item: any) => any;
-  componentFactory: () => HTMLElement;
+  componentFactory: (item: IActivityHistoryItem) => HTMLElement;
   searchPredicate?: (searchString: string, item: any) => boolean;
   errorMessage: string;
 }

package/src/internal-plugins/activity-history/activity-history-item/add/add-history-item/action.ts

@@ -0,0 +1,3 @@
+import { activityHistoryCollectionsSlice } from "../../slice";
+
+export const { addActivityHistoryItem } = activityHistoryCollectionsSlice.actions;

package/src/internal-plugins/activity-history/activity-history-item/add/add-history-item/add-item-to-collection.ts

@@ -0,0 +1,11 @@
+import { IActivityHistoryItem, IActivityHistoryItemCollection } from "../../domain/model";
+import { addItemsToCollection } from "../add-history-items/add-items-to-collection";
+
+export const addItemToCollection = (
+  collections: Record<string, IActivityHistoryItemCollection>,
+  id: string,
+  item: IActivityHistoryItem,
+  componentFactory?: (item: IActivityHistoryItem) => HTMLElement,
+) => {
+  return addItemsToCollection(collections, id, [item], componentFactory);
+};

package/src/internal-plugins/activity-history/{features → activity-history-item/add}/add-history-item/bootstrapper.ts

@@ -1,7 +1,7 @@
 import { BrokerExtensions } from "@primaria/plugins-core";
 import { AddHistoryItemHandler } from "./handler";
 import { addHistoryItemRequest } from "./request";
-import { BrokerDisposableHandler } from "../../../../api/broker/primaria-broker";
+import { BrokerDisposableHandler } from "../../../../../api/broker/primaria-broker";
 
 let request: BrokerDisposableHandler;
 
@@ -9,6 +9,6 @@ export const bootstrapAddHistoryItem = (broker: BrokerExtensions) => {
   request = broker.registerRequest(addHistoryItemRequest, AddHistoryItemHandler);
 };
 
-export const teardownAddHistoryItem = (broker: BrokerExtensions) => {
+export const teardownAddHistoryItem = () => {
   request?.dispose();
 };

package/src/internal-plugins/activity-history/{features → activity-history-item/add}/add-history-item/handler.ts

@@ -1,12 +1,9 @@
-import { Store } from "@reduxjs/toolkit";
-import { inject } from "inversify";
-import { TYPES } from "../../infrastructure/ioc/types";
-import { AddHistoryItemPayload } from "./request";
-import { addActivityHistoryItem } from "../../infrastructure/state/actions";
+import { StoreBaseHandler } from "../../../infrastructure/base-handlers";
 import { ensureAreValidActivityHistoryItems } from "../../domain/is-valid-history-item/is-valid-history-item";
+import { addActivityHistoryItem } from "./action";
+import { AddHistoryItemPayload } from "./request";
 
-export class AddHistoryItemHandler {
-  constructor(@inject(TYPES.store) private readonly store: Store) {}
+export class AddHistoryItemHandler extends StoreBaseHandler {
   async handle(payload: AddHistoryItemPayload) {
     try {
       ensureAreValidActivityHistoryItems([payload.item]);

package/src/internal-plugins/activity-history/activity-history-item/add/add-history-item/reducer.ts

@@ -0,0 +1,15 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { addItemToCollection } from "./add-item-to-collection";
+import { IActivityHistoryItem } from "../../domain/model";
+
+export function addActivityHistoryItemReducer(
+  state,
+  action: PayloadAction<{
+    id: string;
+    item: IActivityHistoryItem;
+    componentFactory?: (item: IActivityHistoryItem) => HTMLElement;
+  }>,
+) {
+  const { id, item, componentFactory } = action.payload;
+  state.collections = addItemToCollection(state.collections, id, item, componentFactory);
+}

package/src/internal-plugins/activity-history/activity-history-item/add/add-history-items/action.ts

@@ -0,0 +1,3 @@
+import { activityHistoryCollectionsSlice } from "../../slice";
+
+export const { addActivityHistoryItems } = activityHistoryCollectionsSlice.actions;

package/src/internal-plugins/activity-history/{domain/handle-collections/handle-collections.test.ts → activity-history-item/add/add-history-items/add-items-to-collection.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
-import { IActivityHistoryItem, IActivityHistoryItemCollection } from "../model";
-import { addItemsToCollection, updateItemInCollection } from "./handle-collections";
+import { IActivityHistoryItemCollection, IActivityHistoryItem } from "../../..";
+import { addItemsToCollection } from "./add-items-to-collection";
 
 describe("addItemsToCollection", () => {
   const mockComponentFactory = () => document.createElement("div"); // Mocks a component factory
@@ -68,65 +68,3 @@ describe("addItemsToCollection", () => {
     expect(result.collection1.items).toEqual(newItems);
   });
 });
-
-describe("updateItemInCollection", () => {
-  it("should return the same collections if the collection does not exist", () => {
-    const collections: Record<string, any> = {};
-    const updatedItem: IActivityHistoryItem = { id: "item1", name: "Updated Item 1" };
-
-    const result = updateItemInCollection(collections, "collection1", updatedItem);
-
-    expect(result).toEqual(collections); // Sin cambios
-  });
-
-  it("should return the same collections if the collection exists but has no items", () => {
-    const collections: Record<string, any> = {
-      collection1: {
-        id: "collection1",
-        items: [],
-      },
-    };
-    const updatedItem: IActivityHistoryItem = { id: "item1", name: "Updated Item 1" };
-
-    const result = updateItemInCollection(collections, "collection1", updatedItem);
-
-    expect(result).toEqual(collections); // Sin cambios
-  });
-
-  it("should update the item in the collection when the id matches", () => {
-    const collections: Record<string, any> = {
-      collection1: {
-        id: "collection1",
-        items: [
-          { id: "item1", name: "Item 1" },
-          { id: "item2", name: "Item 2" },
-        ],
-      },
-    };
-    const updatedItem: IActivityHistoryItem = { id: "item1", name: "Updated Item 1" };
-
-    const result = updateItemInCollection(collections, "collection1", updatedItem);
-
-    expect(result.collection1.items).toEqual([
-      { id: "item1", name: "Updated Item 1" },
-      { id: "item2", name: "Item 2" },
-    ]);
-  });
-
-  it("should return the same collections if the item with the id does not exist", () => {
-    const collections: Record<string, any> = {
-      collection1: {
-        id: "collection1",
-        items: [
-          { id: "item1", name: "Item 1" },
-          { id: "item2", name: "Item 2" },
-        ],
-      },
-    };
-    const updatedItem: IActivityHistoryItem = { id: "item3", name: "Updated Item 3" }; // No existe item3
-
-    const result = updateItemInCollection(collections, "collection1", updatedItem);
-
-    expect(result).toEqual(collections); // Sin cambios
-  });
-});

package/src/internal-plugins/activity-history/activity-history-item/add/add-history-items/add-items-to-collection.ts

@@ -0,0 +1,25 @@
+import {
+  IActivityHistoryItem,
+  IActivityHistoryItemCollection,
+  TSearchActivityHistoryItemPredicate,
+} from "../../domain/model";
+
+export const addItemsToCollection = (
+  collections: Record<string, IActivityHistoryItemCollection>,
+  id: string,
+  items: IActivityHistoryItem[],
+  componentFactory?: (item: IActivityHistoryItem) => HTMLElement,
+  searchPredicate?: TSearchActivityHistoryItemPredicate,
+) => {
+  // Crea la colección si no existe
+  if (!collections[id])
+    return { ...collections, [id]: { id, items, componentFactory, searchPredicate } };
+  // Si la colección ya existe, fusiona el array existente con el nuevo; si no, crea una nueva entrada
+  return {
+    ...collections,
+    [id]: {
+      ...collections[id],
+      items: [...(collections[id]?.items || []), ...items],
+    },
+  };
+};

package/src/internal-plugins/activity-history/{features → activity-history-item/add}/add-history-items/bootstrapper.ts

@@ -1,7 +1,7 @@
 import { BrokerExtensions } from "@primaria/plugins-core";
 import { AddHistoryItemsHandler } from "./handler";
 import { addHistoryItemsRequest } from "./request";
-import { BrokerDisposableHandler } from "../../../../api/broker/primaria-broker";
+import { BrokerDisposableHandler } from "../../../../../api/broker/primaria-broker";
 
 let request: BrokerDisposableHandler;
 
@@ -9,6 +9,6 @@ export const bootstrapAddHistoryItems = (broker: BrokerExtensions) => {
   request = broker.registerRequest(addHistoryItemsRequest, AddHistoryItemsHandler);
 };
 
-export const teardownAddHistoryItems = (broker: BrokerExtensions) => {
+export const teardownAddHistoryItems = () => {
   request?.dispose();
 };

package/src/internal-plugins/activity-history/activity-history-item/add/add-history-items/handler.ts

@@ -0,0 +1,22 @@
+import { StoreBaseHandler } from "../../../infrastructure/base-handlers";
+import { validateAndFilterItems } from "../../domain/is-valid-history-item/is-valid-history-item";
+import { addActivityHistoryItems } from "./action";
+import { AddHistoryItemsPayload } from "./request";
+
+export class AddHistoryItemsHandler extends StoreBaseHandler {
+  async handle(payload: AddHistoryItemsPayload) {
+    try {
+      const validItems = validateAndFilterItems(payload.items);
+      this.store.dispatch(
+        addActivityHistoryItems({
+          id: payload.entityId,
+          items: validItems,
+          componentFactory: payload.componentFactory,
+          searchPredicate: payload.searchPredicate,
+        }),
+      );
+    } catch (e) {
+      console.log(e.message);
+    }
+  }
+}

package/src/internal-plugins/activity-history/activity-history-item/add/add-history-items/reducer.ts

@@ -0,0 +1,22 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { addItemsToCollection } from "./add-items-to-collection";
+import { IActivityHistoryItem, TSearchActivityHistoryItemPredicate } from "../../domain/model";
+
+export function addActivityHistoryItemsReducer(
+  state,
+  action: PayloadAction<{
+    id: string;
+    items: IActivityHistoryItem[];
+    componentFactory?: (item: IActivityHistoryItem) => HTMLElement;
+    searchPredicate?: TSearchActivityHistoryItemPredicate;
+  }>,
+) {
+  const { id, items, componentFactory, searchPredicate } = action.payload;
+  state.collections = addItemsToCollection(
+    state.collections,
+    id,
+    items,
+    componentFactory,
+    searchPredicate,
+  );
+}

package/src/internal-plugins/activity-history/{features → activity-history-item/add}/add-history-items/request.ts

@@ -3,6 +3,8 @@ import { IActivityHistoryItem } from "../../domain/model";
 export interface AddHistoryItemsPayload {
   entityId: string;
   items: IActivityHistoryItem[];
+  componentFactory?: (item: IActivityHistoryItem) => HTMLElement;
+  searchPredicate?: (searchString: string, item: any) => boolean;
 }
 
 export const addHistoryItemsRequest = "add_history_items_request";

package/src/internal-plugins/activity-history/activity-history-item/bootstrapper.ts

@@ -0,0 +1,46 @@
+import { BrokerExtensions, brokerExtensions } from "@primaria/plugins-core";
+import { PrimariaApi } from "../../../api/api";
+import { container } from "../infrastructure/ioc/container";
+import {
+  bootstrapInjectAsyncHistoryItems,
+  teardownInjectAsyncHistoryItems,
+} from "./add/add-async-history-items/bootstrapper";
+import {
+  bootstrapAddHistoryItem,
+  teardownAddHistoryItem,
+} from "./add/add-history-item/bootstrapper";
+import { bootstrapExportPdf, teardownExportPdf } from "./export-to-pdf/bootstrapper";
+import {
+  bootstrapAddHistoryItems,
+  teardownAddHistoryItems,
+} from "./add/add-history-items/bootstrapper";
+import { bootstrapUpdateHistoryItem, teardownUpdateHistoryItem } from "./update/bootstrapper";
+import { bootstrapListActivityHistoryItems } from "./list/bootstrapper";
+import { bootstrapFilters, teardownFilters } from "./filter/bootstrapper";
+import { bootstrapSearchItems, teardownSearchItems } from "./search/bootstrapper";
+import { bootstrapActivityHistoryItemHandleBusy } from "./list/handle-busy/bootstrapper";
+
+let broker: BrokerExtensions;
+
+export const bootstrapActivityHistoryItem = (api: PrimariaApi) => {
+  broker = brokerExtensions(api, container);
+  bootstrapListActivityHistoryItems();
+  bootstrapActivityHistoryItemHandleBusy();
+  bootstrapInjectAsyncHistoryItems(broker);
+  bootstrapAddHistoryItem(broker);
+  bootstrapAddHistoryItems(broker);
+  bootstrapUpdateHistoryItem(broker);
+  bootstrapExportPdf(broker);
+  bootstrapFilters(broker);
+  bootstrapSearchItems(broker);
+};
+
+export const teardownActivityHistoryItem = () => {
+  teardownInjectAsyncHistoryItems();
+  teardownAddHistoryItem();
+  teardownAddHistoryItems();
+  teardownUpdateHistoryItem();
+  teardownExportPdf();
+  teardownFilters();
+  teardownSearchItems();
+};

package/src/internal-plugins/activity-history/{domain → activity-history-item/domain}/model.ts

@@ -9,6 +9,11 @@ export interface IErrorHistoryItem {
   message: string;
 }
 
+export type TSearchActivityHistoryItemPredicate = (
+  searchString: string,
+  item: IActivityHistoryItem,
+) => boolean;
+
 export interface IActivityHistoryItem {
   id: string;
   date: string;
@@ -19,15 +24,16 @@ export interface IActivityHistoryItem {
   up: IEntityDescription;
   ep: IEntityDescription;
   service: IEntityDescription;
-  componentFactory?: () => HTMLElement;
+  componentFactory: (item?: any) => HTMLElement;
+  searchPredicate: TSearchActivityHistoryItemPredicate;
   type?: string;
 }
 
 export interface IActivityHistoryItemCollection {
   id: string;
   items: IActivityHistoryItem[];
-  componentFactory: () => HTMLElement;
-  searchPredicate?: (searchString: string, item: IActivityHistoryItem) => boolean;
+  componentFactory: (item?: any) => HTMLElement;
+  searchPredicate: TSearchActivityHistoryItemPredicate;
 }
 
 export interface IActivityHistoryGroup {

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/own-spec.ts

@@ -0,0 +1,14 @@
+import { IUserInfo } from "../../../../../features/get-user-info/model";
+import { shellApi } from "../../../../../api/api";
+import { IActivityHistoryItem } from "../model";
+import { Spec } from "./spec";
+
+export class OwnSpec extends Spec<IActivityHistoryItem> {
+  constructor(public context: IActivityHistoryItem) {
+    super();
+  }
+  isSatisfiedBy(context: IActivityHistoryItem): boolean {
+    const userInfo = shellApi.globalStateManager.getData("userInfo") as IUserInfo;
+    return context?.professional?.id === userInfo?.userId;
+  }
+}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/relevant-spec.ts

@@ -0,0 +1,11 @@
+import { IActivityHistoryItem } from "../model";
+import { Spec } from "./spec";
+
+export class RelevantSpec extends Spec<IActivityHistoryItem> {
+  constructor(public context: IActivityHistoryItem) {
+    super();
+  }
+  isSatisfiedBy(context: IActivityHistoryItem): boolean {
+    return context?.relevant ?? false;
+  }
+}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/relevant.spec.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import { IActivityHistoryItem } from "../model";
+import { RelevantSpec } from "./relevant-spec";
+
+describe("RelevantSpec", () => {
+  it("should return true if the item is relevant", () => {
+    const activityItem: IActivityHistoryItem = {
+      id: "1",
+      date: "2025-02-25",
+      relevant: true,
+      professional: { id: "user123", name: "John Doe" },
+      diagnostics: [],
+      center: { id: "center1", name: "Center A" },
+      up: { id: "up1", name: "Up A" },
+      ep: { id: "ep1", name: "EP A" },
+      service: { id: "service1", name: "Service A" },
+      componentFactory: () => document.createElement("div"),
+    };
+
+    const spec = new RelevantSpec(activityItem);
+    expect(spec.isSatisfiedBy(activityItem)).toBe(true);
+  });
+
+  it("should return false if the item is not relevant", () => {
+    const activityItem: IActivityHistoryItem = {
+      id: "2",
+      date: "2025-02-25",
+      relevant: false,
+      professional: { id: "user123", name: "John Doe" },
+      diagnostics: [],
+      center: { id: "center1", name: "Center A" },
+      up: { id: "up1", name: "Up A" },
+      ep: { id: "ep1", name: "EP A" },
+      service: { id: "service1", name: "Service A" },
+      componentFactory: () => document.createElement("div"),
+    };
+
+    const spec = new RelevantSpec(activityItem);
+    expect(spec.isSatisfiedBy(activityItem)).toBe(false);
+  });
+
+  it("should return false if the relevant field is undefined", () => {
+    const activityItem: IActivityHistoryItem = {
+      id: "3",
+      date: "2025-02-25",
+      relevant: undefined,
+      professional: { id: "user123", name: "John Doe" },
+      diagnostics: [],
+      center: { id: "center1", name: "Center A" },
+      up: { id: "up1", name: "Up A" },
+      ep: { id: "ep1", name: "EP A" },
+      service: { id: "service1", name: "Service A" },
+      componentFactory: () => document.createElement("div"),
+    };
+
+    const spec = new RelevantSpec(activityItem);
+    expect(spec.isSatisfiedBy(activityItem)).toBe(false);
+  });
+});