@uxland/primary-shell 3.5.2 → 3.5.3

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