@uxland/primary-shell 3.5.1 → 3.5.3

package/src/internal-plugins/activity-history/domain/filter-by-search-string/filter-by-search-string.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { propContainsString } from "../../utils/prop-contains-string";
-import { IActivityHistoryItem } from "../model";
-import { filterBySearchString } from "./filter-by-search-string";
-
-// Mock de la función `propContainsString`
-vi.mock("../../utils/prop-contains-string", () => ({
-  propContainsString: vi.fn(),
-}));
-
-describe("commonFieldsSearchPredicate and filterBySearchString", () => {
-  // Caso básico de un item
-  const mockItem = {
-    professional: {
-      name: "John Doe",
-      speciality: { description: "Cardiology" },
-      role: { description: "Doctor" },
-    },
-    center: { description: "Health Center" },
-    service: { description: "General Checkup" },
-  } as IActivityHistoryItem;
-
-  // Configurar el mock para propContainsString
-  beforeEach(() => {
-    vi.clearAllMocks();
-    propContainsString.mockImplementation((prop, searchString) =>
-      prop.toLowerCase().includes(searchString.toLowerCase()),
-    );
-  });
-
-  it("should return true if any field contains the search string", () => {
-    const result = filterBySearchString("John", [mockItem]);
-    expect(result).toHaveLength(1);
-  });
-
-  it("should return an empty array if searchString does not match any field", () => {
-    const result = filterBySearchString("NonExistent", [mockItem]);
-    expect(result).toHaveLength(0);
-  });
-
-  it("should use the custom searchPredicate if provided", () => {
-    const customPredicate = vi.fn(() => true);
-    const result = filterBySearchString("NonExistent", [mockItem], customPredicate);
-    expect(customPredicate).toHaveBeenCalled();
-    expect(result).toHaveLength(1);
-  });
-
-  it("should return all items if searchString is empty", () => {
-    const items = [mockItem, mockItem];
-    const result = filterBySearchString("", items);
-    expect(result).toHaveLength(2);
-  });
-
-  it("should call propContainsString with each relevant property", () => {
-    filterBySearchString("Health", [mockItem]);
-    expect(propContainsString).toHaveBeenCalledWith(mockItem.professional?.name, "Health");
-    expect(propContainsString).toHaveBeenCalledWith(mockItem.center.description, "Health");
-    expect(propContainsString).toHaveBeenCalledWith(
-      mockItem.professional?.speciality.description,
-      "Health",
-    );
-    expect(propContainsString).toHaveBeenCalledWith(
-      mockItem.professional?.role.description,
-      "Health",
-    );
-    expect(propContainsString).toHaveBeenCalledWith(mockItem.service.description, "Health");
-  });
-});

package/src/internal-plugins/activity-history/domain/filter-by-search-string/filter-by-search-string.ts

@@ -1,44 +0,0 @@
-import { propContainsString } from "../../utils/prop-contains-string";
-import { IActivityHistoryItem } from "../model";
-
-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 const filterBySearchString = (
-  searchString: string,
-  items: IActivityHistoryItem[],
-  searchPredicate?: (searchString: string, item: IActivityHistoryItem) => boolean,
-) => {
-  return searchString
-    ? items.filter((item: IActivityHistoryItem) => {
-        return (
-          commonFieldsSearchPredicate(item, searchString) ||
-          (searchPredicate ? searchPredicate(searchString.toLowerCase(), item) : false)
-        );
-      })
-    : items;
-};

package/src/internal-plugins/activity-history/domain/handle-collections/handle-collections.ts

@@ -1,47 +0,0 @@
-import { IActivityHistoryItem, IActivityHistoryItemCollection } from "../model";
-
-export const addItemToCollection = (
-  collections: Record<string, IActivityHistoryItemCollection>,
-  id: string,
-  item: IActivityHistoryItem,
-  componentFactory: () => HTMLElement,
-) => {
-  return addItemsToCollection(collections, id, [item], componentFactory);
-};
-
-export const addItemsToCollection = (
-  collections: Record<string, IActivityHistoryItemCollection>,
-  id: string,
-  items: IActivityHistoryItem[],
-  componentFactory: () => HTMLElement,
-  searchPredicate?: (searchString: string, item: IActivityHistoryItem) => boolean,
-) => {
-  // 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],
-    },
-  };
-};
-
-export const updateItemInCollection = (
-  collections: Record<string, any>,
-  id: string,
-  updatedItem: IActivityHistoryItem,
-) => {
-  if (!collections[id]?.items) return collections;
-  const items = collections[id]?.items ?? [];
-
-  return {
-    ...collections,
-    [id]: {
-      ...collections[id],
-      items: items.map((i: IActivityHistoryItem) => (i.id === updatedItem.id ? updatedItem : i)),
-    },
-  };
-};

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

@@ -1,23 +0,0 @@
-import { Store } from "@reduxjs/toolkit";
-import { inject } from "inversify";
-import { TYPES } from "../../infrastructure/ioc/types";
-import { AddHistoryItemsPayload } from "./request";
-import { addActivityHistoryItems } from "../../infrastructure/state/actions";
-import { ensureAreValidActivityHistoryItems } from "../../domain/is-valid-history-item/is-valid-history-item";
-
-export class AddHistoryItemsHandler {
-  constructor(@inject(TYPES.store) private readonly store: Store) {}
-  async handle(payload: AddHistoryItemsPayload) {
-    try {
-      ensureAreValidActivityHistoryItems(payload.items);
-      this.store.dispatch(
-        addActivityHistoryItems({
-          id: payload.entityId,
-          items: payload.items,
-        }),
-      );
-    } catch (e) {
-      console.log(e.message);
-    }
-  }
-}

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

@@ -1,39 +0,0 @@
-import { BrokerExtensions, brokerExtensions } from "@primaria/plugins-core";
-import { PrimariaApi } from "../../../api/api";
-import { container } from "../infrastructure/ioc/container";
-import {
-  bootstrapInjectAsyncHistoryItems,
-  teardownInjectAsyncHistoryItems,
-} from "./inject-async-history-items/bootstrapper";
-import { bootstrapAddHistoryItem, teardownAddHistoryItem } from "./add-history-item/bootstrapper";
-import {
-  bootstrapUpdateHistoryItem,
-  teardownUpdateHistoryItem,
-} from "./update-history-item/bootstrapper";
-import { bootstrapExportPdf, teardownExportPdf } from "./export-to-pdf/bootstrapper";
-import {
-  bootstrapAddHistoryItems,
-  teardownAddHistoryItems,
-} from "./add-history-items/bootstrapper";
-import { bootstrapSearchItems, teardownSearchItems } from "./search-items/bootstrapper";
-
-let broker: BrokerExtensions;
-
-export const bootstrapFeatures = (api: PrimariaApi) => {
-  broker = brokerExtensions(api, container);
-  bootstrapInjectAsyncHistoryItems(broker);
-  bootstrapAddHistoryItem(broker);
-  bootstrapAddHistoryItems(broker);
-  bootstrapUpdateHistoryItem(broker);
-  bootstrapExportPdf(broker);
-  bootstrapSearchItems(broker);
-};
-
-export const teardownFeatures = () => {
-  teardownInjectAsyncHistoryItems(broker);
-  teardownAddHistoryItem(broker);
-  teardownAddHistoryItems(broker);
-  teardownUpdateHistoryItem(broker);
-  teardownExportPdf(broker);
-  teardownSearchItems(broker);
-};

package/src/internal-plugins/activity-history/features/inject-async-history-items/handler.ts

@@ -1,37 +0,0 @@
-import { Store } from "@reduxjs/toolkit";
-import { inject } from "inversify";
-import { TYPES } from "../../infrastructure/ioc/types";
-import {
-  addActivityHistoryItems,
-  addBusyHistoryItem,
-  addErrorHistoryItem,
-  removeBusyHistoryItem,
-} from "../../infrastructure/state/actions";
-import { InjectAsyncHistoryItemsPayload } from "./request";
-import { validateAndFilterItems } from "../../domain/is-valid-history-item/is-valid-history-item";
-
-export class InjectAsyncHistoryItemsHandler {
-  constructor(@inject(TYPES.store) private readonly store: Store) {}
-  async handle(payload: InjectAsyncHistoryItemsPayload) {
-    this.store.dispatch(addBusyHistoryItem(payload.entityId));
-    try {
-      let items = await payload.asyncTask();
-      if (payload.mapFn) items = items.map(payload.mapFn);
-      const validItems = validateAndFilterItems(items);
-      this.store.dispatch(
-        addActivityHistoryItems({
-          id: payload.entityId,
-          items: validItems,
-          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/search-items/handler.ts

@@ -1,24 +0,0 @@
-import { Store } from "@reduxjs/toolkit";
-import { inject } from "inversify";
-import { TYPES } from "../../infrastructure/ioc/types";
-import { setSearchString } from "../../infrastructure/state/actions";
-import { SearchActivityHistoryItems } from "./request";
-import { PrimariaApi } from "@uxland/primary-shell";
-import { events } from "../../constants";
-
-export class SearchItemsHandler {
-  constructor(
-    @inject(TYPES.store) private readonly store: Store,
-    @inject(TYPES.primaryApi) private api: PrimariaApi,
-  ) {}
-  async handle(request: SearchActivityHistoryItems) {
-    try {
-      this.store.dispatch(setSearchString(request.searchString));
-      this.api.broker.publish(events.activityHistorySearched, {
-        searchQuery: request.searchString,
-      });
-    } catch (e) {
-      console.log(e.message);
-    }
-  }
-}

package/src/internal-plugins/activity-history/features/update-history-item/handler.ts

@@ -1,23 +0,0 @@
-import { Store } from "@reduxjs/toolkit";
-import { inject } from "inversify";
-import { TYPES } from "../../infrastructure/ioc/types";
-import { updateActivityHistoryItem } from "../../infrastructure/state/actions";
-import { UpdateHistoryItemPayload } from "./request";
-import { ensureAreValidActivityHistoryItems } from "../../domain/is-valid-history-item/is-valid-history-item";
-
-export class UpdateHistoryItemHandler {
-  constructor(@inject(TYPES.store) private readonly store: Store) {}
-  async handle(payload: UpdateHistoryItemPayload) {
-    try {
-      ensureAreValidActivityHistoryItems([payload.item]);
-      this.store.dispatch(
-        updateActivityHistoryItem({
-          id: payload.entityId,
-          item: payload.item,
-        }),
-      );
-    } catch (e) {
-      console.log(e.message);
-    }
-  }
-}

package/src/internal-plugins/activity-history/infrastructure/state/actions.ts

@@ -1,13 +0,0 @@
-import { activityHistorySlice } from "./slices";
-
-export const {
-  addBusyHistoryItem,
-  addErrorHistoryItem,
-  addActivityHistoryItem,
-  addActivityHistoryItems,
-  removeBusyHistoryItem,
-  removeErrorHistoryItem,
-  removeActivityHistoryItem,
-  updateActivityHistoryItem,
-  setSearchString,
-} = activityHistorySlice.actions;

package/src/internal-plugins/activity-history/infrastructure/state/selectors.ts

@@ -1,67 +0,0 @@
-import { createSelector } from "@reduxjs/toolkit";
-import { filterBySearchString } from "../../domain/filter-by-search-string/filter-by-search-string";
-import { IActivityHistoryItem, IActivityHistoryItemCollection } from "../../domain/model";
-import { RootState } from "./store";
-import { groupActivityHistoryItems } from "../../domain/group-history-items/group-history-items";
-import { sortGroupsByMostRecentDate } from "../../domain/sort-history-items-by-date/sort-history-items-by-date";
-
-const isAnyCollectionBusySelector = (state: RootState) => state.activityHistory.busy.length > 0;
-export const isAnyCollectionLoadingWithoutAnyLoaded = (state: RootState) => {
-  const collections = Object.values(state.activityHistory.collections);
-  return !collections?.length && isAnyCollectionBusySelector(state);
-};
-
-export const isSomeCollectionLoadedAndOtherLoading = (state: RootState) => {
-  const collections = Object.values(state.activityHistory.collections);
-  return collections && isAnyCollectionBusySelector(state);
-};
-
-export const activityHistoryCollectionsSelector = (state: RootState) =>
-  state.activityHistory.collections;
-
-export const activityHistorySearchStringSelector = (state: RootState) =>
-  state.activityHistory.searchString;
-
-const getFilteredItems = (
-  items: IActivityHistoryItem[],
-  searchString: string,
-  searchPredicate?: (searchString: string, item: IActivityHistoryItem) => boolean,
-) => {
-  return filterBySearchString(searchString, items, searchPredicate);
-};
-
-const mapItemsWithMetadata = (
-  items: IActivityHistoryItem[],
-  componentFactory: any,
-  type: string,
-) => {
-  return items.map((item) => ({
-    ...item,
-    componentFactory,
-    type,
-  }));
-};
-
-export const activityHistoryGroupableItems = createSelector(
-  activityHistoryCollectionsSelector,
-  activityHistorySearchStringSelector,
-  (collections, searchString) => {
-    return Object.values(collections).flatMap((collection: IActivityHistoryItemCollection) => {
-      const filteredItems = getFilteredItems(
-        collection.items,
-        searchString,
-        collection.searchPredicate,
-      );
-      return mapItemsWithMetadata(filteredItems, collection.componentFactory, collection.id);
-    });
-  },
-);
-
-export const activityHistoryGroupedItems = createSelector(
-  activityHistoryGroupableItems,
-  (items) => {
-    const groupedItems = groupActivityHistoryItems(items);
-    const sortedByMostRecentDate = sortGroupsByMostRecentDate(groupedItems);
-    return sortedByMostRecentDate;
-  },
-);

package/src/internal-plugins/activity-history/infrastructure/state/slices.ts

@@ -1,61 +0,0 @@
-import { createSlice } from "@reduxjs/toolkit";
-import {
-  IActivityHistoryItemCollection,
-  IBusyHistoryItem,
-  IErrorHistoryItem,
-} from "../../domain/model";
-import {
-  addItemsToCollection,
-  addItemToCollection,
-  updateItemInCollection,
-} from "../../domain/handle-collections/handle-collections";
-
-export const activityHistorySlice = createSlice({
-  name: "activity-history",
-  initialState: {
-    busy: [] as IBusyHistoryItem[],
-    error: [] as IErrorHistoryItem[],
-    collections: {} as Record<string, IActivityHistoryItemCollection>,
-    searchString: "",
-  },
-  reducers: {
-    addBusyHistoryItem(state, action) {
-      state.busy.push(action.payload);
-    },
-    addErrorHistoryItem(state, action) {
-      state.error.push(action.payload);
-    },
-    removeBusyHistoryItem(state, action) {
-      state.busy = state.busy.filter((i) => i !== action.payload);
-    },
-    addActivityHistoryItem(state, action) {
-      const { id, item, componentFactory } = action.payload;
-      state.collections = addItemToCollection(state.collections, id, item, componentFactory);
-    },
-    updateActivityHistoryItem(state, action) {
-      const { id, item } = action.payload;
-      state.collections = updateItemInCollection(state.collections, id, item);
-    },
-    addActivityHistoryItems(state, action) {
-      const { id, items, componentFactory, searchPredicate } = action.payload;
-      state.collections = addItemsToCollection(
-        state.collections,
-        id,
-        items,
-        componentFactory,
-        searchPredicate,
-      );
-    },
-    removeErrorHistoryItem(state, action) {
-      state.error = state.error.filter((i) => i !== action.payload);
-    },
-    removeActivityHistoryItem(state, action) {
-      /* state.collections[action.payload.id]?.items = state.collections[action.payload.id]?.items.filter(
-        (i) => i !== action.payload,
-      );   */
-    },
-    setSearchString(state, action) {
-      state.searchString = action.payload;
-    },
-  },
-});