@uxland/primary-shell 3.5.4 → 4.0.0

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/index.d.ts

@@ -0,0 +1,5 @@
+export * from './filter';
+export { addAsyncHistoryItemsCommand } from './add/add-async-history-items/request';
+export { addHistoryItemsCommand } from './add/add-history-items/request';
+export { addHistoryItemCommand } from './add/add-history-item/request';
+export { updateHistoryItemCommand } from './update/request';

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/list/handle-error/actions.d.ts

@@ -1 +1,4 @@
-export declare const addErrorHistoryItem: import('@reduxjs/toolkit').ActionCreatorWithNonInferrablePayload<"activity-history-collections/addErrorHistoryItem"> | import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"activity-history-collections/addErrorHistoryItem">, removeErrorHistoryItem: import('@reduxjs/toolkit').ActionCreatorWithNonInferrablePayload<"activity-history-collections/removeErrorHistoryItem"> | import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"activity-history-collections/removeErrorHistoryItem">;
+export declare const addErrorHistoryItem: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+    id: string;
+    message: string;
+}, "activity-history-collections/addErrorHistoryItem">, removeErrorHistoryItem: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "activity-history-collections/removeErrorHistoryItem">;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/list/handle-error/reducers.d.ts

@@ -1,2 +1,7 @@
-export declare function addErrorHistoryItemReducer(state: any, action: any): void;
-export declare function removeErrorHistoryItemReducer(state: any, action: any): void;
+import { PayloadAction } from '@reduxjs/toolkit';
+
+export declare function addErrorHistoryItemReducer(state: any, action: PayloadAction<{
+    id: string;
+    message: string;
+}>): void;
+export declare function removeErrorHistoryItemReducer(state: any, action: PayloadAction<string>): void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/selectors.d.ts

@@ -0,0 +1,294 @@
+import { RootState } from '../infrastructure/state/store';
+import { IActivityHistoryItem, IActivityHistoryItemCollection } from './domain/model';
+import { IActivityHistoryCommonFilter } from './filter';
+
+export declare const activityHistoryCollectionsSelector: (state: RootState) => Record<string, IActivityHistoryItemCollection>;
+export declare const activityHistoryMappedItems: ((state: {
+    activityHistoryCollections: {
+        busy: import('..').IBusyHistoryItem[];
+        error: import('..').IErrorHistoryItem[];
+        collections: Record<string, IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: import('./filter').IActivityHistoryFilterGroup[];
+    };
+}) => IActivityHistoryItem[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => IActivityHistoryItem[];
+    dependencies: [(state: RootState) => Record<string, IActivityHistoryItemCollection>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export declare const customFilterGroupsWithOptionsSelector: ((state: {
+    activityHistoryCollections: {
+        busy: import('..').IBusyHistoryItem[];
+        error: import('..').IErrorHistoryItem[];
+        collections: Record<string, IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: import('./filter').IActivityHistoryFilterGroup[];
+    };
+}) => {
+    filters: {
+        options: {
+            id: string;
+            description: string;
+        }[];
+        id: string;
+        title: string;
+        propPathValue: string[];
+        propsPathDescription: string[];
+        enabled: boolean;
+        type: import('./filter').ActivityHistoryFilterType;
+        singleOption?: boolean;
+        enabledValues?: string[];
+    }[];
+    id: string;
+    title: string;
+    enabled: boolean;
+    sort: string;
+}[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import('./filter').IActivityHistoryFilterGroup[], resultFuncArgs_1: Record<string, IActivityHistoryItemCollection>) => {
+        filters: {
+            options: {
+                id: string;
+                description: string;
+            }[];
+            id: string;
+            title: string;
+            propPathValue: string[];
+            propsPathDescription: string[];
+            enabled: boolean;
+            type: import('./filter').ActivityHistoryFilterType;
+            singleOption?: boolean;
+            enabledValues?: string[];
+        }[];
+        id: string;
+        title: string;
+        enabled: boolean;
+        sort: string;
+    }[];
+    memoizedResultFunc: ((resultFuncArgs_0: import('./filter').IActivityHistoryFilterGroup[], resultFuncArgs_1: Record<string, IActivityHistoryItemCollection>) => {
+        filters: {
+            options: {
+                id: string;
+                description: string;
+            }[];
+            id: string;
+            title: string;
+            propPathValue: string[];
+            propsPathDescription: string[];
+            enabled: boolean;
+            type: import('./filter').ActivityHistoryFilterType;
+            singleOption?: boolean;
+            enabledValues?: string[];
+        }[];
+        id: string;
+        title: string;
+        enabled: boolean;
+        sort: string;
+    }[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        filters: {
+            options: {
+                id: string;
+                description: string;
+            }[];
+            id: string;
+            title: string;
+            propPathValue: string[];
+            propsPathDescription: string[];
+            enabled: boolean;
+            type: import('./filter').ActivityHistoryFilterType;
+            singleOption?: boolean;
+            enabledValues?: string[];
+        }[];
+        id: string;
+        title: string;
+        enabled: boolean;
+        sort: string;
+    }[];
+    dependencies: [((state: {
+        activityHistoryCollections: {
+            busy: import('..').IBusyHistoryItem[];
+            error: import('..').IErrorHistoryItem[];
+            collections: Record<string, IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: import('./filter').IActivityHistoryFilterGroup[];
+        };
+    }) => import('./filter').IActivityHistoryFilterGroup[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import('./filter').IActivityHistoryFilterGroup[]) => import('./filter').IActivityHistoryFilterGroup[];
+        memoizedResultFunc: ((resultFuncArgs_0: import('./filter').IActivityHistoryFilterGroup[]) => import('./filter').IActivityHistoryFilterGroup[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import('./filter').IActivityHistoryFilterGroup[];
+        dependencies: [(state: RootState) => import('./filter').IActivityHistoryFilterGroup[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }, (state: RootState) => Record<string, IActivityHistoryItemCollection>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export declare const activityHistoryGroupedItems: ((state: {
+    activityHistoryCollections: {
+        busy: import('..').IBusyHistoryItem[];
+        error: import('..').IErrorHistoryItem[];
+        collections: Record<string, IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: import('./filter').IActivityHistoryFilterGroup[];
+    };
+}) => import('..').IActivityHistoryGroup[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IActivityHistoryItem[], resultFuncArgs_1: string, resultFuncArgs_2: IActivityHistoryCommonFilter[] | import('./filter').IActivityHistoryCustomFilter[], resultFuncArgs_3: import('./filter').IActivityHistoryFilterGroup[]) => import('..').IActivityHistoryGroup[];
+    memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryItem[], resultFuncArgs_1: string, resultFuncArgs_2: IActivityHistoryCommonFilter[] | import('./filter').IActivityHistoryCustomFilter[], resultFuncArgs_3: import('./filter').IActivityHistoryFilterGroup[]) => import('..').IActivityHistoryGroup[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import('..').IActivityHistoryGroup[];
+    dependencies: [((state: {
+        activityHistoryCollections: {
+            busy: import('..').IBusyHistoryItem[];
+            error: import('..').IErrorHistoryItem[];
+            collections: Record<string, IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: import('./filter').IActivityHistoryFilterGroup[];
+        };
+    }) => IActivityHistoryItem[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[];
+        memoizedResultFunc: ((resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IActivityHistoryItem[];
+        dependencies: [(state: RootState) => Record<string, IActivityHistoryItemCollection>];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }, (state: RootState) => string, ((state: {
+        activityHistoryCollections: {
+            busy: import('..').IBusyHistoryItem[];
+            error: import('..').IErrorHistoryItem[];
+            collections: Record<string, IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: import('./filter').IActivityHistoryFilterGroup[];
+        };
+    }) => IActivityHistoryCommonFilter[] | import('./filter').IActivityHistoryCustomFilter[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import('./filter').IActivityHistoryFilterGroup[]) => IActivityHistoryCommonFilter[] | import('./filter').IActivityHistoryCustomFilter[];
+        memoizedResultFunc: ((resultFuncArgs_0: import('./filter').IActivityHistoryFilterGroup[]) => IActivityHistoryCommonFilter[] | import('./filter').IActivityHistoryCustomFilter[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IActivityHistoryCommonFilter[] | import('./filter').IActivityHistoryCustomFilter[];
+        dependencies: [(state: RootState) => import('./filter').IActivityHistoryFilterGroup[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }, ((state: {
+        activityHistoryCollections: {
+            busy: import('..').IBusyHistoryItem[];
+            error: import('..').IErrorHistoryItem[];
+            collections: Record<string, IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: import('./filter').IActivityHistoryFilterGroup[];
+        };
+    }) => import('./filter').IActivityHistoryFilterGroup[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import('./filter').IActivityHistoryFilterGroup[]) => import('./filter').IActivityHistoryFilterGroup[];
+        memoizedResultFunc: ((resultFuncArgs_0: import('./filter').IActivityHistoryFilterGroup[]) => import('./filter').IActivityHistoryFilterGroup[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import('./filter').IActivityHistoryFilterGroup[];
+        dependencies: [(state: RootState) => import('./filter').IActivityHistoryFilterGroup[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/update/request.d.ts

@@ -4,4 +4,4 @@ export interface UpdateHistoryItemPayload {
     entityId: string;
     item: IActivityHistoryItem;
 }
-export declare const updateHistoryItemRequest = "update_history_item_request";
+export declare const updateHistoryItemCommand = "update_history_item_request";

package/dist/primary/shell/src/internal-plugins/activity-history/index.d.ts

@@ -1 +1,2 @@
 export * from './activity-history-item/domain/model';
+export * from './activity-history-item';

package/dist/primary/shell/src/internal-plugins/activity-history/infrastructure/state/store.d.ts

@@ -8,7 +8,7 @@ export declare const store: import('@reduxjs/toolkit').EnhancedStore<{
     };
     activityHistoryFilters: {
         searchString: string;
-        filters: import('../../activity-history-item/filter/model').IActivityHistoryFilterGroup[];
+        filters: import('../..').IActivityHistoryFilterGroup[];
     };
 }, import('@reduxjs/toolkit').UnknownAction, import('@reduxjs/toolkit').Tuple<[import('@reduxjs/toolkit').StoreEnhancer<{
     dispatch: import('@reduxjs/toolkit').ThunkDispatch<{
@@ -19,7 +19,7 @@ export declare const store: import('@reduxjs/toolkit').EnhancedStore<{
         };
         activityHistoryFilters: {
             searchString: string;
-            filters: import('../../activity-history-item/filter/model').IActivityHistoryFilterGroup[];
+            filters: import('../..').IActivityHistoryFilterGroup[];
         };
     }, undefined, import('@reduxjs/toolkit').UnknownAction>;
 }>, import('@reduxjs/toolkit').StoreEnhancer]>>;
@@ -31,7 +31,7 @@ export declare const dispatch: import('@reduxjs/toolkit').ThunkDispatch<{
     };
     activityHistoryFilters: {
         searchString: string;
-        filters: import('../../activity-history-item/filter/model').IActivityHistoryFilterGroup[];
+        filters: import('../..').IActivityHistoryFilterGroup[];
     };
 }, undefined, import('@reduxjs/toolkit').UnknownAction> & import('@reduxjs/toolkit').Dispatch<import('@reduxjs/toolkit').UnknownAction>;
 export declare const getState: () => {
@@ -42,6 +42,6 @@ export declare const getState: () => {
     };
     activityHistoryFilters: {
         searchString: string;
-        filters: import('../../activity-history-item/filter/model').IActivityHistoryFilterGroup[];
+        filters: import('../..').IActivityHistoryFilterGroup[];
     };
 };

package/dist/primary/shell/src/internal-plugins/activity-history/localization.d.ts

@@ -25,12 +25,15 @@ export declare const locales: {
                 noteLegend: string;
                 moreOptions: string;
                 entryLegend: string;
+                maximizeButton: string;
+                menuButton: string;
             };
             modal: {
                 selectExportOption: string;
                 allActivityHistory: string;
                 onlyAppliedFilters: string;
                 selectDateRange: string;
+                helpText: string;
                 startDate: string;
                 endDate: string;
                 cancel: string;

package/dist/primary/shell/src/internal-plugins/activity-history/utils/get-unique-values-by-prop-path.d.ts

@@ -0,0 +1,4 @@
+export declare function getUniqueObjects<T>(items: T[], propPathId: string[], propPathDescription: string[]): {
+    id: string;
+    description: string;
+}[];

package/dist/primary/shell/src/locales.d.ts

@@ -21,6 +21,11 @@ export declare const locales: {
             clinicalMonitoring: {
                 title: string;
             };
+            header: {
+                workCenter: string;
+                role: string;
+                speciality: string;
+            };
         };
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxland/primary-shell",
-  "version": "3.5.4",
+  "version": "4.0.0",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",
@@ -26,8 +26,8 @@
   },
   "dependencies": {
     "@reduxjs/toolkit": "^2.2.5",
-    "@uxland/harmonix": "^1.0.0",
-    "@uxland/harmonix-adapters": "^1.0.1",
+    "@uxland/harmonix": "^1.1.0",
+    "@uxland/harmonix-adapters": "^2.0.0",
     "axios": "^1.7.2",
     "date-fns": "^3.6.0",
     "inversify": "^6.0.2",

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

@@ -2,6 +2,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";
+import {translate} from '../../../locales';
 
 export const template = (props: ShellHeader) => {
   const workCenterElements = [{ label: props.professional?.workCenter, value: "1" }];
@@ -23,15 +24,15 @@ export const template = (props: ShellHeader) => {
         () => 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>
+            <label slot="label" for="preferences1">${translate("header.workCenter")}</label>
             <input id="preferences1" slot="input" type="text" class="dss-input" readonly="">
         </dss-input-dropdown>
         <dss-input-dropdown icon="business_center" type="default" .elements=${roleElements} selectedvalue="[&quot;1&quot;]">
-          <label slot="label" for="preferences2">Rol</label>
+          <label slot="label" for="preferences2">${translate("header.role")}</label>
           <input id="preferences2" slot="input" type="text" class="dss-input" readonly="">
         </dss-input-dropdown>
         <dss-input-dropdown icon="people_alt" type="default" .elements=${specialityElements} selectedvalue="[&quot;1&quot;]">
-          <label slot="label" for="preferences3">Ambit treball</label>
+          <label slot="label" for="preferences3">${translate("header.speciality")}</label>
           <input id="preferences3" slot="input" type="text" class="dss-input" readonly="">
         </dss-input-dropdown>
       </dss-header-menu-professional>`,

package/src/UI/shared-components/index.ts

@@ -2,3 +2,4 @@ import "./primaria-content-switcher/primaria-content-switcher";
 import "./primaria-nav-item/primaria-nav-item";
 import "./primaria-text-editor/primaria-rich-text-editor";
 export * from "./primaria-interaction";
+export { PrimariaContentSwitcher } from "./primaria-content-switcher/primaria-content-switcher";

package/src/index.ts

@@ -5,7 +5,7 @@ export * from "./api/region-manager/regions";
 export * from "./handle-plugins";
 export * from "./api/api";
 export * from "./api/broker/primaria-broker";
-import "./UI/index";
+export * from "./UI/index";
 export { PrimariaNavItem } from "./UI/shared-components/primaria-nav-item/primaria-nav-item";
 export { confirmMixin } from "./UI/shared-components/primaria-interaction";
 export type { CustomConfirmOptions } from "./UI/shared-components/primaria-interaction";

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

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

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

@@ -1,21 +1,22 @@
 import { BaseHandler } from "../../../infrastructure/base-handlers";
+import { AddCustomFiltersCommand } from "../../filter/custom-filters/add-custom-filters/request";
 import { addBusyHistoryItem, removeBusyHistoryItem } from "../../list/handle-busy/actions";
 import { addErrorHistoryItem } from "../../list/handle-error/actions";
-import { addHistoryItemsRequest } from "../add-history-items/request";
+import { addHistoryItemsCommand } 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, {
+      const items = await payload.asyncDataProvider();
+      this.api.broker.send(addHistoryItemsCommand, {
         entityId: payload.entityId,
         items,
         componentFactory: payload.componentFactory,
         searchPredicate: payload.searchPredicate,
       });
+      payload.filters ? this.api.broker.send(new AddCustomFiltersCommand(payload.filters)) : null;
     } catch (e) {
       this.store.dispatch(
         addErrorHistoryItem({ id: payload.entityId, message: payload.errorMessage || e.message }),

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

@@ -1,12 +1,13 @@
 import { IActivityHistoryItem } from "../../domain/model";
+import { IActivityHistoryCommonFilterGroup } from "../../filter";
 
 export interface InjectAsyncHistoryItemsPayload {
   entityId: string;
-  asyncTask: () => Promise<any>;
-  mapFn?: (item: any) => any;
+  asyncDataProvider: () => Promise<IActivityHistoryItem[]>;
   componentFactory: (item: IActivityHistoryItem) => HTMLElement;
-  searchPredicate?: (searchString: string, item: any) => boolean;
+  searchPredicate?: (searchString: string, item: IActivityHistoryItem) => boolean;
   errorMessage: string;
+  filters?: IActivityHistoryCommonFilterGroup;
 }
 
-export const injectAsyncHistoryItemsRequest = "inject_async_history_items_request";
+export const addAsyncHistoryItemsCommand = "inject_async_history_items_request";

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

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

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

@@ -5,4 +5,4 @@ export interface AddHistoryItemPayload {
   item: IActivityHistoryItem;
 }
 
-export const addHistoryItemRequest = "add_history_item_request";
+export const addHistoryItemCommand = "add_history_item_request";

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

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

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

@@ -7,4 +7,4 @@ export interface AddHistoryItemsPayload {
   searchPredicate?: (searchString: string, item: any) => boolean;
 }
 
-export const addHistoryItemsRequest = "add_history_items_request";
+export const addHistoryItemsCommand = "add_history_items_request";

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

@@ -0,0 +1,18 @@
+import { IActivityHistoryCommonFilter } from "../../filter";
+import { IActivityHistoryItem } from "../model";
+import { Spec } from "./spec";
+import { TrueSpec } from "./true-spec";
+
+export class CommonFilterSpec extends Spec<IActivityHistoryItem> {
+  constructor(private commonFilters: IActivityHistoryCommonFilter[]) {
+    super();
+  }
+
+  isSatisfiedBy(item: IActivityHistoryItem): boolean {
+    const enabledCommonFilters = this.commonFilters.filter((f) => f.enabled);
+    const finalCommonSpec = enabledCommonFilters.reduce((acc, filter) => {
+      return acc.and(new filter.spec());
+    }, new TrueSpec());
+    return finalCommonSpec.isSatisfiedBy(item);
+  }
+}