@uxland/primary-shell 3.5.1 → 3.5.3

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

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