@uxland/primary-shell 3.5.3 → 4.0.0

package/src/internal-plugins/activity-history/activity-history-item/filter/common-filters/selectors.ts

@@ -0,0 +1,14 @@
+import { createSelector } from "@reduxjs/toolkit";
+import { isCommonFilterGroup } from "../model";
+import { activityHistoryFiltersSelector } from "../selectors";
+
+export const activityHistoryCommonFiltersSelector = createSelector(
+  activityHistoryFiltersSelector,
+  (filters) => filters.find(isCommonFilterGroup)?.filters || [],
+);
+
+export const isEnabledCommonFilterSelector = (filterId: string) =>
+  createSelector(
+    activityHistoryCommonFiltersSelector,
+    (filterSpecs) => filterSpecs?.find((s) => s.id === filterId)?.enabled,
+  );

package/src/internal-plugins/activity-history/activity-history-item/filter/{actions.ts → common-filters/set-common-filter/actions.ts}

@@ -1,3 +1,3 @@
-import { activityHistoryFiltersSlice } from "./slice";
+import { activityHistoryFiltersSlice } from "../../slice";
 
 export const { setCommonFilterValue } = activityHistoryFiltersSlice.actions;

package/src/internal-plugins/activity-history/activity-history-item/filter/{set-common-filter → common-filters/set-common-filter}/handler.ts

@@ -1,5 +1,5 @@
-import { StoreBaseHandler } from "../../../infrastructure/base-handlers";
-import { setCommonFilterValue } from "../actions";
+import { StoreBaseHandler } from "../../../../infrastructure/base-handlers";
+import { setCommonFilterValue } from "./actions";
 import { SetCommonFilter } from "./request";
 
 export class SetCommonFilterHandler extends StoreBaseHandler {

package/src/internal-plugins/activity-history/activity-history-item/filter/common-filters/set-common-filter/reducer.ts

@@ -0,0 +1,18 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+
+export function setCommonFilterValueReducer(
+  state,
+  action: PayloadAction<{ id: string; enabled: boolean }>,
+) {
+  state.filters = state.filters.map((f) => {
+    if (f.id === "common") {
+      return {
+        ...f,
+        filters: f.filters.map((ff) =>
+          ff.id === action.payload.id ? { ...ff, enabled: action.payload.enabled } : ff,
+        ),
+      };
+    }
+    return f;
+  });
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/add-custom-filters/actions.ts

@@ -0,0 +1,3 @@
+import { activityHistoryFiltersSlice } from "../../slice";
+
+export const { addCustomFilters } = activityHistoryFiltersSlice.actions;

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

@@ -0,0 +1,14 @@
+import { BrokerExtensions } from "@primaria/plugins-core";
+import { BrokerDisposableHandler } from "../../../../../../api/broker/primaria-broker";
+import { AddCustomFiltersHandler } from "./handler";
+import { AddCustomFiltersCommand } from "./request";
+
+let request: BrokerDisposableHandler;
+
+export const bootstrapAddCustomFilter = (broker: BrokerExtensions) => {
+  request = broker.registerRequest(AddCustomFiltersCommand, AddCustomFiltersHandler);
+};
+
+export const teardownAddCustomFilter = () => {
+  request?.dispose();
+};

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/add-custom-filters/handler.ts

@@ -0,0 +1,14 @@
+import { StoreBaseHandler } from "../../../../infrastructure/base-handlers";
+import { addCustomFilters } from "./actions";
+import { AddCustomFiltersCommand } from "./request";
+
+export class AddCustomFiltersHandler extends StoreBaseHandler {
+  async handle(request: AddCustomFiltersCommand) {
+    try {
+      //TODO ensure are valid filters
+      this.store.dispatch(addCustomFilters(request.payload));
+    } catch (e) {
+      console.log(e.message);
+    }
+  }
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/add-custom-filters/reducer.ts

@@ -0,0 +1,9 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { IActivityHistoryCommonFilterGroup } from "../model";
+
+export function addCustomFiltersReducer(
+  state,
+  action: PayloadAction<IActivityHistoryCommonFilterGroup>,
+) {
+  state.filters = [...state.filters, action.payload];
+}

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

@@ -0,0 +1,5 @@
+import { IActivityHistoryCommonFilterGroup } from "../model";
+
+export class AddCustomFiltersCommand {
+  constructor(public payload: IActivityHistoryCommonFilterGroup) {}
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/selectors.ts

@@ -0,0 +1,20 @@
+import { createSelector } from "@reduxjs/toolkit";
+import {
+  IActivityHistoryCustomFilterGroup,
+  IActivityHistoryFilterGroup,
+  isNotCommonFilterGroup,
+} from "../model";
+import { activityHistoryFiltersSelector } from "../selectors";
+
+export const activityHistoryCustomFilterGroupsSelector = createSelector(
+  activityHistoryFiltersSelector,
+  (filters: IActivityHistoryFilterGroup[]) => {
+    const customFilters = filters.filter(isNotCommonFilterGroup);
+    return customFilters.sort(sortBySortProperty);
+  },
+);
+
+const sortBySortProperty = (
+  a: IActivityHistoryCustomFilterGroup,
+  b: IActivityHistoryCustomFilterGroup,
+) => Number(a.sort) - Number(b.sort);

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-group/actions.ts

@@ -0,0 +1,3 @@
+import { activityHistoryFiltersSlice } from "../../slice";
+
+export const { setCustomFilterGroupValue } = activityHistoryFiltersSlice.actions;

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-group/bootstrapper.ts

@@ -0,0 +1,14 @@
+import { BrokerExtensions } from "@primaria/plugins-core";
+import { BrokerDisposableHandler } from "../../../../../../api/broker/primaria-broker";
+import { SetCustomFilterGroup } from "./request";
+import { SetCustomFilterGroupHandler } from "./handler";
+
+let request: BrokerDisposableHandler;
+
+export const bootstrapSetCustomFilterGroup = (broker: BrokerExtensions) => {
+  request = broker.registerRequest(SetCustomFilterGroup, SetCustomFilterGroupHandler);
+};
+
+export const teardownSetCustomFilterGroup = () => {
+  request?.dispose();
+};

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-group/handler.ts

@@ -0,0 +1,13 @@
+import { StoreBaseHandler } from "../../../../infrastructure/base-handlers";
+import { setCustomFilterGroupValue } from "./actions";
+import { SetCustomFilterGroup } from "./request";
+
+export class SetCustomFilterGroupHandler extends StoreBaseHandler {
+  async handle(request: SetCustomFilterGroup) {
+    try {
+      this.store.dispatch(setCustomFilterGroupValue(request.payload));
+    } catch (e) {
+      console.log(e.message);
+    }
+  }
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-group/reducer.ts

@@ -0,0 +1,17 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+
+export function setCustomFilterGroupValueReducer(
+  state,
+  action: PayloadAction<{ id: string; enabled: boolean }>,
+) {
+  //seteamos el valor de enabled en el filterGroup, y ademas vamos a todos los hijos y deshabilitamos todas sus opciones si estamos deshabilitando el grupo.
+  state.filters = state.filters.map((f) => {
+    if (f.id === action.payload.id) {
+      return {
+        ...f,
+        enabled: action.payload.enabled,
+      };
+    }
+    return f;
+  });
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-group/request.ts

@@ -0,0 +1,3 @@
+export class SetCustomFilterGroup {
+  constructor(public payload: { id: string; enabled: boolean }) {}
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-value/actions.ts

@@ -0,0 +1,3 @@
+import { activityHistoryFiltersSlice } from "../../slice";
+
+export const { setCustomFilterValue } = activityHistoryFiltersSlice.actions;

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-value/bootstrapper.ts

@@ -0,0 +1,14 @@
+import { BrokerExtensions } from "@primaria/plugins-core";
+import { BrokerDisposableHandler } from "../../../../../../api/broker/primaria-broker";
+import { SetCustomFilterValue } from "./request";
+import { SetCustomFilterValueHandler } from "./handler";
+
+let request: BrokerDisposableHandler;
+
+export const bootstrapSetCustomFilterValue = (broker: BrokerExtensions) => {
+  request = broker.registerRequest(SetCustomFilterValue, SetCustomFilterValueHandler);
+};
+
+export const teardownSetCustomFilterValue = () => {
+  request?.dispose();
+};

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-value/handler.ts

@@ -0,0 +1,13 @@
+import { StoreBaseHandler } from "../../../../infrastructure/base-handlers";
+import { setCustomFilterValue } from "./actions";
+import { SetCustomFilterValue } from "./request";
+
+export class SetCustomFilterValueHandler extends StoreBaseHandler {
+  async handle(request: SetCustomFilterValue) {
+    try {
+      this.store.dispatch(setCustomFilterValue(request.payload));
+    } catch (e) {
+      console.log(e.message);
+    }
+  }
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-value/reducer.ts

@@ -0,0 +1,41 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { SetCustomFilterValuePayload } from "./request";
+
+export function setCustomFilterValueReducer(
+  state,
+  action: PayloadAction<SetCustomFilterValuePayload>,
+) {
+  state.filters = state.filters.map((f) => {
+    if (f.id === action.payload.filterGroupId) {
+      return {
+        ...f,
+        filters: f.filters.map((ff) =>
+          ff.id === action.payload.filterId
+            ? ff.singleOption
+              ? setSingleOptionFilterValue(ff, action.payload.enabled)
+              : setMultipleOptionsFilterValue(ff, action.payload)
+            : ff,
+        ),
+      };
+    }
+    return f;
+  });
+}
+
+const setMultipleOptionsFilterValue = (filter, payload: SetCustomFilterValuePayload) => {
+  const { optionId, enabled } = payload;
+  return {
+    ...filter,
+    enabledValues: enabled
+      ? [...(filter.enabledValues || []), optionId]
+      : filter.enabledValues.filter((id) => id !== optionId),
+  };
+};
+
+const setSingleOptionFilterValue = (filter, value: boolean) => {
+  return {
+    ...filter,
+    enabled: value,
+    enabledValues: value ? [true] : [],
+  };
+};

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-value/request.ts

@@ -0,0 +1,10 @@
+export interface SetCustomFilterValuePayload {
+  filterGroupId: string;
+  filterId: string;
+  optionId: string;
+  enabled: boolean;
+}
+
+export class SetCustomFilterValue {
+  constructor(public payload: SetCustomFilterValuePayload) {}
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/index.ts

@@ -0,0 +1 @@
+export * from "./model";

package/src/internal-plugins/activity-history/activity-history-item/filter/model.ts

@@ -1,20 +1,59 @@
 import { IActivityHistoryItem } from "../domain/model";
 import { Spec } from "../domain/specs/spec";
-import { ActivityHistoryFilterOperation, ActivityHistoryFilterType } from "./constants";
 
 type Constructor<T> = new (...args: any[]) => T;
 
-export interface IActivityHistoryFilterGroup {
+export enum ActivityHistoryFilterType {
+  Switch = "switch",
+  Checkbox = "checkbox",
+}
+
+export enum ActivityHistoryFilterOperation {
+  And = "and",
+  Or = "or",
+}
+
+export interface IActivityHistoryCommonFilterGroup {
   id: string;
   title: string;
-  filters: IActivityHistoryFilter[];
+  filters: IActivityHistoryCommonFilter[];
 }
 
-export interface IActivityHistoryFilter {
+export interface IActivityHistoryCommonFilter {
   id: string;
   title: string;
   spec: Constructor<Spec<IActivityHistoryItem>>;
   enabled: boolean;
   type: ActivityHistoryFilterType;
-  operation: ActivityHistoryFilterOperation;
 }
+
+export interface IActivityHistoryCustomFilterGroup {
+  id: string;
+  title: string;
+  enabled: boolean;
+  sort: string;
+  filters: IActivityHistoryCustomFilter[];
+}
+
+export type IActivityHistoryFilterGroup =
+  | IActivityHistoryCommonFilterGroup
+  | IActivityHistoryCustomFilterGroup;
+
+export interface IActivityHistoryCustomFilter {
+  id: string;
+  title: string;
+  propPathValue: string[];
+  propsPathDescription: string[];
+  enabled: boolean;
+  type: ActivityHistoryFilterType;
+  singleOption?: boolean;
+  options?: {
+    id: string;
+    title: string;
+  }[];
+  enabledValues?: string[];
+}
+
+export const isCommonFilterGroup = (group: IActivityHistoryFilterGroup) => group.id === "common";
+export const isNotCommonFilterGroup = (group: IActivityHistoryFilterGroup) =>
+  !isCommonFilterGroup(group);

package/src/internal-plugins/activity-history/activity-history-item/filter/selectors.ts

@@ -1,28 +1,4 @@
-import { createSelector } from "@reduxjs/toolkit";
 import { RootState } from "../../infrastructure/state/store";
-import { TrueSpec } from "../domain/specs/true-spec";
-import { IActivityHistoryFilter } from "./model";
 
 export const activityHistoryFiltersSelector = (state: RootState) =>
   state.activityHistoryFilters.filters;
-
-export const activityHistoryCommonFiltersSelector = createSelector(
-  activityHistoryFiltersSelector,
-  (filters) => filters.find((f) => f.id === "common")?.filters,
-);
-export const isEnabledCommonFilterSelector = (filterId: string) =>
-  createSelector(
-    activityHistoryCommonFiltersSelector,
-    (filterSpecs) => filterSpecs?.find((s) => s.id === filterId)?.enabled,
-  );
-
-export const commonSpecSelector = createSelector(
-  activityHistoryCommonFiltersSelector,
-  (commonFilters: IActivityHistoryFilter[]) => {
-    const enabledCommonFilters = commonFilters.filter((f) => f.enabled);
-    const finalCommonSpec = enabledCommonFilters.reduce((acc, filter) => {
-      return acc.and(new filter.spec());
-    }, new TrueSpec());
-    return finalCommonSpec;
-  },
-);

package/src/internal-plugins/activity-history/activity-history-item/filter/slice.ts

@@ -1,27 +1,23 @@
 import { createSlice } from "@reduxjs/toolkit";
-import { commonFilters } from "./common-filters";
 import { setSearchStringReducer } from "../search/reducer";
+import { commonFilters } from "./common-filters/common-filters";
+import { setCommonFilterValueReducer } from "./common-filters/set-common-filter/reducer";
+import { addCustomFiltersReducer } from "./custom-filters/add-custom-filters/reducer";
+import { setCustomFilterGroupValueReducer } from "./custom-filters/set-custom-filter-group/reducer";
+import { setCustomFilterValueReducer } from "./custom-filters/set-custom-filter-value/reducer";
+import { IActivityHistoryFilterGroup } from "./model";
 
 export const activityHistoryFiltersSlice = createSlice({
   name: "activity-history-filters",
   initialState: {
     searchString: "",
-    filters: [...commonFilters],
+    filters: [...commonFilters] as IActivityHistoryFilterGroup[],
   },
   reducers: {
     setSearchString: setSearchStringReducer,
-    setCommonFilterValue(state, action) {
-      state.filters = state.filters.map((f) => {
-        if (f.id === "common") {
-          return {
-            ...f,
-            filters: f.filters.map((ff) =>
-              ff.id === action.payload.id ? { ...ff, enabled: action.payload.enabled } : ff,
-            ),
-          };
-        }
-        return f;
-      });
-    },
+    setCommonFilterValue: setCommonFilterValueReducer,
+    addCustomFilters: addCustomFiltersReducer,
+    setCustomFilterGroupValue: setCustomFilterGroupValueReducer,
+    setCustomFilterValue: setCustomFilterValueReducer,
   },
 });

package/src/internal-plugins/activity-history/activity-history-item/index.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/src/internal-plugins/activity-history/activity-history-item/list/UI/main-view/activity-history-main.ts

@@ -8,7 +8,7 @@ import { lazyInject } from "../../../../infrastructure/ioc/container";
 import { TYPES } from "../../../../infrastructure/ioc/types";
 import { connectedProperty } from "../../../../infrastructure/state/connected-property";
 import { SearchActivityHistoryItems } from "../../../search/request";
-import { activityHistoryCollectionsSelector } from "../../selectors";
+import { activityHistoryCollectionsSelector } from "../../../selectors";
 import { ActivityHistoryTimeline } from "../timeline/activity-history-timeline";
 import styles from "./styles.css?inline";
 import { template } from "./template";

package/src/internal-plugins/activity-history/activity-history-item/list/UI/main-view/template.ts

@@ -19,9 +19,9 @@ export const template = (props: ActivityHistoryMain) =>
             </div>
             
             <div class="header__right">
-                <dss-icon-button @click=${() => props._maximize()} size="md" variant="primary" icon="arrow_forward" label="Botó maximitzar"></dss-icon-button>
+                <dss-icon-button @click=${() => props._maximize()} size="md" variant="primary" icon="arrow_forward" label=${translate("actions.maximizeButton")}></dss-icon-button>
                 <div>|</div>
-                <dss-icon-button size="md" variant="primary" icon="more_vert" label="Botó menu"></dss-icon-button>
+                <dss-icon-button size="md" variant="primary" icon="more_vert" label=${translate("actions.menuButton")}></dss-icon-button>
                 <dss-action-menu position="bottom-start">
                     <dss-action-menu-item lefticon="view_timeline" label=${translate("actions.cronogram")}></dss-action-menu-item>
                     <dss-action-menu-item lefticon="file_download" label=${translate("actions.exportPdf")} @click=${() => props.api.broker.send(new ExportPdf())}></dss-action-menu-item>
@@ -31,7 +31,7 @@ export const template = (props: ActivityHistoryMain) =>
         </div>`
   } 
         <div class="wrapper" ?maximized=${props.maximized}>
-          <activity-history-filters></activity-history-filters>
+          <activity-history-filters .wrapperMaximized=${props.maximized}></activity-history-filters>
           <div class="content">
             ${when(props.searchQuery.length > 1, () => html`<activity-history-search-header searchQuery="${props.searchQuery}"></activity-history-search-header>`)}
             <activity-history-busy></activity-history-busy>

package/src/internal-plugins/activity-history/activity-history-item/list/UI/timeline/activity-history-timeline.ts

@@ -7,7 +7,7 @@ import {
   isAnyCollectionLoadingWithoutAnyLoaded,
   isSomeCollectionLoadedAndOtherLoading,
 } from "../../handle-busy/selectors";
-import { activityHistoryGroupedItems } from "../../selectors";
+import { activityHistoryGroupedItems } from "../../../selectors";
 import styles from "./styles.css?inline";
 import { template } from "./template";
 

package/src/internal-plugins/activity-history/activity-history-item/list/handle-error/reducers.ts

@@ -1,6 +1,11 @@
-export function addErrorHistoryItemReducer(state, action) {
+import { PayloadAction } from "@reduxjs/toolkit";
+
+export function addErrorHistoryItemReducer(
+  state,
+  action: PayloadAction<{ id: string; message: string }>,
+) {
   state.error.push(action.payload);
 }
-export function removeErrorHistoryItemReducer(state, action) {
+export function removeErrorHistoryItemReducer(state, action: PayloadAction<string>) {
   state.error = state.error.filter((i) => i !== action.payload);
 }

package/src/internal-plugins/activity-history/activity-history-item/search/activity-history-search-bar/styles.css

@@ -2,7 +2,7 @@
   padding-inline: 16px;
   padding-top: 12px;
   padding-bottom: 12px;
-  gap: var(--dds-spacing-xs);
+  gap: var(--dss-spacing-xs);
   border-width: 0px 0px 1px 0px;
   border-style: solid;
   border-color: #D8D8D8;

package/src/internal-plugins/activity-history/activity-history-item/search/activity-history-search-results/styles.css

@@ -2,7 +2,7 @@
   padding-inline: 16px;
   padding-top: 12px;
   padding-bottom: 12px;
-  gap: var(--dds-spacing-xs);
+  gap: var(--dss-spacing-xs);
   border-width: 0px 0px 1px 0px;
   border-style: solid;
   border-color: #D8D8D8;

package/src/internal-plugins/activity-history/activity-history-item/selectors.ts

@@ -0,0 +1,107 @@
+import { createSelector } from "@reduxjs/toolkit";
+import { RootState } from "../infrastructure/state/store";
+import { getUniqueObjects } from "../utils/get-unique-values-by-prop-path";
+import {
+  IActivityHistoryItem,
+  IActivityHistoryItemCollection,
+  TSearchActivityHistoryItemPredicate,
+} from "./domain/model";
+import { CommonFilterSpec } from "./domain/specs/common-filter-spec";
+import { CustomFilterSpec } from "./domain/specs/custom-filter-spec";
+import { SearchStringSpec } from "./domain/specs/search-string-spec";
+import { ComposedTypeSpec } from "./domain/specs/type-spec";
+import { IActivityHistoryCommonFilter, IActivityHistoryCustomFilterGroup } from "./filter";
+import { activityHistoryCommonFiltersSelector } from "./filter/common-filters/selectors";
+import { activityHistoryCustomFilterGroupsSelector } from "./filter/custom-filters/selectors";
+import { groupActivityHistoryItems } from "./list/group-history-items/group-history-items";
+import { sortGroupsByMostRecentDate } from "./list/sort-history-items-by-date/sort-history-items-by-date";
+import { activityHistorySearchStringSelector } from "./search/selectors";
+
+export const activityHistoryCollectionsSelector = (state: RootState) =>
+  state.activityHistoryCollections.collections;
+
+const mapItemsWithMetadata = (
+  items: IActivityHistoryItem[],
+  componentFactory: any,
+  type: string,
+  searchPredicate: TSearchActivityHistoryItemPredicate,
+) => {
+  return items.map(
+    (item) =>
+      ({
+        ...item,
+        searchPredicate,
+        componentFactory,
+        type,
+      }) as IActivityHistoryItem,
+  );
+};
+
+export const activityHistoryMappedItems = createSelector(
+  activityHistoryCollectionsSelector,
+  (collections: Record<string, IActivityHistoryItemCollection>) => {
+    return Object.values(collections).flatMap((collection: IActivityHistoryItemCollection) => {
+      return mapItemsWithMetadata(
+        collection.items,
+        collection.componentFactory,
+        collection.id,
+        collection.searchPredicate,
+      );
+    });
+  },
+);
+
+export const customFilterGroupsWithOptionsSelector = createSelector(
+  activityHistoryCustomFilterGroupsSelector,
+  activityHistoryCollectionsSelector,
+  (
+    filterGroups: IActivityHistoryCustomFilterGroup[],
+    collections: Record<string, IActivityHistoryItemCollection>,
+  ) => {
+    const result = filterGroups.map((filterGroup: IActivityHistoryCustomFilterGroup) => {
+      const collection = collections[filterGroup.id] as IActivityHistoryItemCollection;
+      return {
+        ...filterGroup,
+        filters: filterGroup.filters.map((f) => {
+          return {
+            ...f,
+            options:
+              (!f.singleOption
+                ? getUniqueObjects<IActivityHistoryItem>(
+                    collection.items,
+                    f.propPathValue,
+                    f.propsPathDescription,
+                  )
+                : []) || [],
+          };
+        }),
+      };
+    });
+    return result;
+  },
+);
+
+export const activityHistoryGroupedItems = createSelector(
+  activityHistoryMappedItems,
+  activityHistorySearchStringSelector,
+  activityHistoryCommonFiltersSelector,
+  activityHistoryCustomFilterGroupsSelector,
+  (
+    items: IActivityHistoryItem[],
+    searchString: string,
+    commonFilters: IActivityHistoryCommonFilter[],
+    customFilters: IActivityHistoryCustomFilterGroup[],
+  ) => {
+    const filteredItems = items.filter((item: IActivityHistoryItem) =>
+      new SearchStringSpec(searchString, item.searchPredicate)
+        .and(new CommonFilterSpec(commonFilters))
+        .and(new ComposedTypeSpec(customFilters))
+        .and(new CustomFilterSpec(customFilters))
+        .isSatisfiedBy(item),
+    );
+
+    const groupedItems = groupActivityHistoryItems(filteredItems);
+    const sortedByMostRecentDate = sortGroupsByMostRecentDate(groupedItems);
+    return sortedByMostRecentDate;
+  },
+);

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

@@ -1,12 +1,12 @@
 import { BrokerExtensions } from "@primaria/plugins-core";
 import { UpdateHistoryItemHandler } from "./handler";
-import { updateHistoryItemRequest } from "./request";
+import { updateHistoryItemCommand } from "./request";
 import { BrokerDisposableHandler } from "../../../../api/broker/primaria-broker";
 
 let request: BrokerDisposableHandler;
 
 export const bootstrapUpdateHistoryItem = (broker: BrokerExtensions) => {
-  request = broker.registerRequest(updateHistoryItemRequest, UpdateHistoryItemHandler);
+  request = broker.registerRequest(updateHistoryItemCommand, UpdateHistoryItemHandler);
 };
 
 export const teardownUpdateHistoryItem = () => {

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

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

package/src/internal-plugins/activity-history/index.ts

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

package/src/internal-plugins/activity-history/localization.ts

@@ -46,12 +46,15 @@ export const locales = {
         noteLegend: "Llegenda notes",
         moreOptions: "Més opcions",
         entryLegend: "Llegenda entrades",
+        maximizeButton: "Botó maximitzar",
+        menuButton: "Botó menu",
       },
       modal: {
         selectExportOption: "Tria una opció d'exportació",
         allActivityHistory: "Tot l’històric d’activitat",
         onlyAppliedFilters: "Només amb filtres aplicats",
         selectDateRange: "En el cas que sigui necessari, selecciona un rang de dates",
+        helpText: "Sense seleccionar data, s'aplicarà la de la primera entrada. Sense seleccionar data de fi, s'aplicarà la de l'última entrada.",
         startDate: "Data Inici",
         endDate: "Data Fi",
         cancel: "Cancel·lar",