@uxland/primary-shell 3.5.2 → 3.5.3

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);
+  });
+});

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/search-string-spec.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { IActivityHistoryItem, TSearchActivityHistoryItemPredicate } from "../model";
+import { SearchStringSpec } from "./search-string-spec";
+import { propContainsString } from "../../../utils/prop-contains-string";
+
+// Mocking the propContainsString function to simulate behavior
+vi.mock("../../../utils/prop-contains-string", () => ({
+  propContainsString: vi.fn(),
+}));
+
+describe("SearchStringSpec", () => {
+  let searchString: string;
+  let searchPredicate: TSearchActivityHistoryItemPredicate;
+  let item: IActivityHistoryItem;
+
+  beforeEach(() => {
+    // Default searchPredicate mock function
+    searchPredicate = vi.fn();
+
+    // Default mock item to test with
+    item = {
+      relevant: true,
+      professional: {
+        name: "John Doe",
+        speciality: { description: "Speciality1" },
+        role: { description: "Role1" },
+      },
+      center: { description: "Center1" },
+      service: { description: "Service1" },
+      diagnostics: [{ id: "123", description: "Diagnostic1" }],
+      up: { description: "Up1" },
+      ep: { description: "Ep1" },
+    } as IActivityHistoryItem;
+  });
+
+  it("should return true if searchString is empty or null", () => {
+    const spec = new SearchStringSpec("", searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(true); // should always return true
+  });
+
+  it("should return true if searchPredicate is satisfied", () => {
+    // Mock the searchPredicate to return true
+    searchPredicate.mockReturnValueOnce(true);
+    const spec = new SearchStringSpec("searchString", searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(true); // searchPredicate is true
+  });
+
+  it("should return false if searchPredicate is not satisfied", () => {
+    // Mock the searchPredicate to return false
+    searchPredicate.mockReturnValueOnce(false);
+    const spec = new SearchStringSpec("searchString", searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(false); // searchPredicate is false
+  });
+
+  it("should return true if any of the common fields match searchString", () => {
+    searchString = "Center1";
+
+    // Mocking propContainsString to return true if the center description matches
+    (propContainsString as vi.Mock).mockReturnValueOnce(true);
+    const spec = new SearchStringSpec(searchString, searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(true); // Center matches the searchString
+  });
+
+  it("should return false if no common fields or searchPredicate match", () => {
+    searchString = "nonexistent";
+
+    // Mocking propContainsString to return false for all fields
+    (propContainsString as vi.Mock).mockReturnValue(false);
+    const spec = new SearchStringSpec(searchString, searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(false); // No matches in common fields
+  });
+
+  it("should return true if searchString matches multiple fields", () => {
+    searchString = "John";
+
+    // Mocking propContainsString to return true for the professional name
+    (propContainsString as vi.Mock).mockReturnValueOnce(true);
+    const spec = new SearchStringSpec(searchString, searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(true); // Professional name matches
+  });
+
+  it("should call commonFieldsSearchPredicate and the searchPredicate with the correct arguments", () => {
+    searchString = "searchString";
+
+    // Mocking propContainsString
+    (propContainsString as vi.Mock).mockReturnValue(false); // simulating no matches in common fields
+    const spySearchPredicate = vi.fn();
+    const spec = new SearchStringSpec(searchString, spySearchPredicate);
+
+    // Simulate the searchPredicate call
+    spec.isSatisfiedBy(item);
+
+    // Verify the commonFieldsSearchPredicate is called
+    expect(propContainsString).toHaveBeenCalled();
+
+    // Verify the searchPredicate is called with the correct arguments
+    expect(spySearchPredicate).toHaveBeenCalledWith(searchString.toLowerCase(), item);
+  });
+});

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

@@ -0,0 +1,58 @@
+import { IActivityHistoryItem, TSearchActivityHistoryItemPredicate } from "../model";
+import { Spec } from "./spec";
+import { propContainsString } from "../../../utils/prop-contains-string";
+
+const commonFieldsSearchPredicate = (item: IActivityHistoryItem, searchString: string) => {
+  const professionalNameContainsSearchString =
+    item.professional?.name && propContainsString(item.professional?.name, searchString);
+  const centerNameContainsSearchString =
+    item.center.description && propContainsString(item.center.description, searchString);
+  const specialityNameContainsSearchString =
+    item.professional?.speciality.description &&
+    propContainsString(item.professional?.speciality.description, searchString);
+  const roleNameContainsSearchString =
+    item.professional?.role.description &&
+    propContainsString(item.professional?.role.description, searchString);
+  const serviceNameContainsSearchString =
+    item.service.description && propContainsString(item.service.description, searchString);
+  const diagnosticsMatch = item.diagnostics?.some(
+    (diagnostic) =>
+      propContainsString(diagnostic.id, searchString) ||
+      propContainsString(diagnostic.description, searchString),
+  );
+  return (
+    professionalNameContainsSearchString ||
+    centerNameContainsSearchString ||
+    specialityNameContainsSearchString ||
+    roleNameContainsSearchString ||
+    serviceNameContainsSearchString ||
+    diagnosticsMatch
+  );
+};
+
+export class SearchStringSpec extends Spec<IActivityHistoryItem> {
+  constructor(
+    public searchString: string,
+    public searchPredicate: TSearchActivityHistoryItemPredicate,
+  ) {
+    super();
+  }
+
+  isSatisfiedBy(context: IActivityHistoryItem): boolean {
+    // Si searchString está vacío o solo tiene espacios, no filtramos y devolvemos true
+    if (!this.searchString?.trim()) {
+      return true;
+    }
+
+    // Verificamos coincidencias en los campos comunes
+    const matchesCommonFields = commonFieldsSearchPredicate(context, this.searchString);
+
+    // Verificamos coincidencias con el searchPredicate
+    const matchesSearchPredicate = this.searchPredicate
+      ? this.searchPredicate(this.searchString.toLowerCase(), context)
+      : false;
+
+    // Aseguramos que siempre se retorne un valor booleano
+    return !!(matchesCommonFields || matchesSearchPredicate);
+  }
+}

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

@@ -0,0 +1,54 @@
+export interface ISpec<TContext> {
+  isSatisfiedBy(context: TContext): boolean;
+  and(spec: ISpec<TContext>): ISpec<TContext>;
+  or(spec: ISpec<TContext>): ISpec<TContext>;
+  not(): ISpec<TContext>;
+}
+
+
+export abstract class Spec<TContext> implements ISpec<TContext> {
+  abstract isSatisfiedBy(context: TContext): boolean;
+  and(spec: ISpec<TContext>): ISpec<TContext> {
+    return new AndSpec(this as unknown as ISpec<TContext>, spec);
+  }
+    or(spec: ISpec<TContext>): ISpec<TContext> {
+        return new OrSpec(this as unknown as ISpec<TContext>, spec);
+    }
+    not(): ISpec<TContext> {
+      return new NotSpec(this as unknown as ISpec<TContext>);
+    }
+}
+export class AndSpec<TContext> extends Spec<TContext> {
+  constructor(
+    private left: ISpec<TContext>,
+    private right: ISpec<TContext>,
+  ) {
+    super();
+  }
+  isSatisfiedBy(context: TContext): boolean {
+    return this.left.isSatisfiedBy(context) && this.right.isSatisfiedBy(context);
+  }
+}
+
+export class OrSpec<TContext> extends Spec<TContext> {
+  constructor(
+    private left: ISpec<TContext>,
+    private right: ISpec<TContext>,
+  ) {
+    super();
+  }
+
+  isSatisfiedBy(context: TContext): boolean {
+    return this.left.isSatisfiedBy(context) || this.right.isSatisfiedBy(context);
+  }
+}
+
+export class NotSpec<TContext> extends Spec<TContext> {
+  constructor(private spec: ISpec<TContext>) {
+    super();
+  }
+
+  isSatisfiedBy(context: TContext): boolean {
+    return !this.spec.isSatisfiedBy(context);
+  }
+}

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

@@ -0,0 +1,8 @@
+import { IActivityHistoryItem } from "../model";
+import { Spec } from "./spec";
+
+export class TrueSpec extends Spec<IActivityHistoryItem> {
+  isSatisfiedBy(): boolean {
+    return true;
+  }
+}

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

@@ -2,6 +2,7 @@ import { BrokerExtensions } from "plugins/core";
 import { ExportToPdfHandler } from "./handler";
 import { ExportPdf } from "./request";
 import { BrokerDisposableHandler } from "../../../../api/broker/primaria-broker";
+import "./export-pdf-modal/export-pdf-modal";
 
 let request: BrokerDisposableHandler;
 
@@ -9,6 +10,6 @@ export const bootstrapExportPdf = (broker: BrokerExtensions) => {
   request = broker.registerRequest(ExportPdf, ExportToPdfHandler);
 };
 
-export const teardownExportPdf = (broker: BrokerExtensions) => {
+export const teardownExportPdf = () => {
   request?.dispose();
 };

package/src/internal-plugins/activity-history/{components → activity-history-item/export-to-pdf}/export-pdf-modal/export-pdf-modal.ts

@@ -2,7 +2,7 @@ import { LitElement, css, html, unsafeCSS } from "lit";
 import { customElement, property } from "lit/decorators.js";
 import styles from "./export-pdf-modal.css?inline";
 import { template } from "./template";
-import { confirmMixin } from "../../../../index";
+import { confirmMixin } from "../../../../../UI/shared-components/primaria-interaction/confirm-mixin";
 
 @customElement("export-pdf-modal")
 export class ExportPdfModal extends confirmMixin(LitElement) {
@@ -49,7 +49,7 @@ export class ExportPdfModal extends confirmMixin(LitElement) {
   handleTest() {
     console.log(
       // this.selectedVisibilityLevelElement,
-      this.selectedPeriodDate
+      this.selectedPeriodDate,
     );
   }
 }

package/src/internal-plugins/activity-history/{components → activity-history-item/export-to-pdf}/export-pdf-modal/template.ts

@@ -1,6 +1,6 @@
 import { html, nothing } from "lit";
 import { ExportPdfModal } from "./export-pdf-modal";
-import { translate } from "../../localization";
+import { translate } from "../../../localization";
 
 export const template = (props: ExportPdfModal) => {
   const { arrayElements, text } = props;
@@ -18,14 +18,14 @@ export const template = (props: ExportPdfModal) => {
               <div class="selector-options">
                 <dss-radio-button>
                   <input slot="input" id="radioButton1" type="radio" name="exportOption" @change=${() => {
-                  props.selectedRadioOption = "history";
+                    props.selectedRadioOption = "history";
                   }}>
                   <label slot="label" for="radioButton1">${translate("modal.allActivityHistory")}</label>
                 </dss-radio-button>
                 <dss-radio-button>
                   <input slot="input" id="radioButton2" type="radio" name="exportOption" @change=${() => {
-                  props.selectedRadioOption = "filters";
-                }}>
+                    props.selectedRadioOption = "filters";
+                  }}>
                   <label slot="label" for="radioButton2">${translate("modal.onlyAppliedFilters")}</label>
                 </dss-radio-button>
               </div>
@@ -37,7 +37,7 @@ export const template = (props: ExportPdfModal) => {
                 <div class="datepicker-canvas">
                   <dss-datepicker-range inputsize="md" @onRangeChange=${(e) => {
                     props.selectedPeriodDate = e.detail;
-                    }} helpText="Sense seleccionar data, s'aplicarà la de la primera entrada. 
+                  }} helpText="Sense seleccionar data, s'aplicarà la de la primera entrada. 
                     Sense seleccionar data de fi, s'aplicarà la de l'última entrada.">
                     <label slot="label-range-start" for="myDatepickerRangeStart">${translate("modal.startDate")}</label>
                     <input slot="input-range-start" id="myDatepickerRangeStart" type="text" class="dss-input">

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

@@ -1,10 +1,7 @@
-import { inject } from "inversify";
-import { TYPES } from "../../infrastructure/ioc/types";
-import { ExportPdfModal } from "../../components/export-pdf-modal/export-pdf-modal";
-import { PrimariaApi } from "../../../../api/api";
+import { ApiBaseHandler } from "../../infrastructure/base-handlers";
+import { ExportPdfModal } from "./export-pdf-modal/export-pdf-modal";
 
-export class ExportToPdfHandler {
-  constructor(@inject(TYPES.primaryApi) private api: PrimariaApi) {}
+export class ExportToPdfHandler extends ApiBaseHandler {
   async handle() {
     try {
       this.api.interactionManager.customConfirm({