@uxland/primary-shell 5.3.6 → 5.3.8

package/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-badges/active-filters-badges.ts

@@ -8,9 +8,15 @@ import { template } from "./template";
 import styles from "./styles.css?inline";
 import { activeGroupsWithEnabledFilters } from "../../custom-filters/selectors";
 import { SetCustomFilterValue } from "../../custom-filters/set-custom-filter-value/request";
-import { IActivityHistoryCustomFilterGroup, IActivityHistoryFilterGroup } from "../../model";
+import {
+  IActivityHistoryCustomFilterGroup,
+  IActivityHistoryDiagnosticsFilter,
+  IActivityHistoryFilter,
+} from "../../model";
 import { activityHistoryEnabledCommonFiltersSelector } from "../../common-filters/selectors";
 import { SetCommonFilter } from "../../common-filters/set-common-filter/request";
+import { diagnosticFilterSelector } from "../../diagnostic-filters/selectors";
+import { SetDiagnosticFiltersCommand } from "../../diagnostic-filters/set/request";
 
 //@ts-ignore
 @customElement("active-filters-badges")
@@ -29,11 +35,14 @@ export class ActiveFiltersBadges extends LitElement {
   activityHistoryCommonFiltersSelector;
 
   @connectedProperty(activityHistoryEnabledCommonFiltersSelector)
-  enabledCommonFilters: IActivityHistoryFilterGroup[];
+  enabledCommonFilters: IActivityHistoryFilter[];
 
   @connectedProperty(activeGroupsWithEnabledFilters)
   enabledFilters: IActivityHistoryCustomFilterGroup[];
 
+  @connectedProperty(diagnosticFilterSelector)
+  diagnosticFilterEnabled: IActivityHistoryDiagnosticsFilter;
+
   _onDeleteFilterValue(filterGroupId: string, filterId: string, optionId: string, value: boolean) {
     this.api.broker.send(
       new SetCustomFilterValue({
@@ -48,4 +57,12 @@ export class ActiveFiltersBadges extends LitElement {
   _onDeleteCommonFilterValue(filterId: string) {
     this.api.broker.send(new SetCommonFilter({ id: filterId, enabled: false }));
   }
+
+  _onDeleteDiagnosticFilterValue(diagnosticValue: string) {
+    this.api.broker.send(
+      new SetDiagnosticFiltersCommand([
+        ...this.diagnosticFilterEnabled.enabledValues.filter((v) => v !== diagnosticValue),
+      ]),
+    );
+  }
 }

package/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-badges/template.ts

@@ -27,16 +27,64 @@ const renderCommonChip = (filter, props) => html`
   ></dss-chip>
 `;
 
+const renderDiagnosticChip = (id, value, props) => html`
+  <dss-chip
+    label=${value}
+    size="sm"
+    hasdelete
+    selected
+    @click=${() => props._onDeleteDiagnosticFilterValue(id)}
+    @onDelete=${() => props._onDeleteDiagnosticFilterValue(id)}
+  ></dss-chip>
+`;
+
 const renderFilterTitle = (title) => html`<div class="filter-title">${`${title}:`}</div>`;
 
 export const template = (props: ActiveFiltersBadges) => {
-  if (props.enabledFilters.length === 0 && props.enabledCommonFilters.length === 0) return nothing;
+  if (
+    props.enabledFilters.length === 0 &&
+    props.enabledCommonFilters.length === 0 &&
+    props.diagnosticFilterEnabled.enabledValues.length === 0
+  )
+    return nothing;
 
   let visibleCount = 0;
   const visibleChips: any[] = [];
   const hiddenElements: any[] = [];
   const hiddenChips: any[] = [];
 
+  const diagnostic = props.diagnosticFilterEnabled;
+
+  if (diagnostic) {
+    const { title, values, enabledValues } = diagnostic;
+    const selectedOptions = values.filter((opt) => enabledValues.includes(opt.value));
+
+    if (selectedOptions.length > 0) {
+      let titleAddedToVisible = false;
+      let titleAddedToHidden = false;
+
+      for (const option of selectedOptions) {
+        const chip = renderDiagnosticChip(option.value, option.label, props);
+
+        if (visibleCount < MAX_VISIBLE_CHIPS) {
+          if (!titleAddedToVisible) {
+            visibleChips.push(renderFilterTitle(title));
+            titleAddedToVisible = true;
+          }
+          visibleChips.push(chip);
+          visibleCount++;
+        } else {
+          if (!titleAddedToHidden) {
+            hiddenElements.push(renderFilterTitle(title));
+            titleAddedToHidden = true;
+          }
+          hiddenElements.push(chip);
+          hiddenChips.push(chip);
+        }
+      }
+    }
+  }
+
   for (const filter of props.enabledCommonFilters) {
     const chip = renderCommonChip(filter, props);
 

package/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-header/active-filters-header.ts

@@ -6,6 +6,7 @@ import { connectedProperty } from "../../../../infrastructure/state/connected-pr
 import { activityHistorySearchStringSelector } from "../../../search/selectors";
 import { areCustomFiltersActive } from "../../custom-filters/selectors";
 import { areCommonFiltersActive } from "../../common-filters/selectors";
+import { areDiagnosticFiltersActive } from "../../diagnostic-filters/selectors";
 
 //@ts-ignore
 @customElement("active-filters-header")
@@ -26,4 +27,7 @@ export class ActiveFiltersHeader extends LitElement {
 
   @connectedProperty(areCommonFiltersActive)
   areCommonFiltersActive: boolean;
+
+  @connectedProperty(areDiagnosticFiltersActive)
+  areDiagnosticFiltersActive: boolean;
 }

package/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-header/template.ts

@@ -6,6 +6,7 @@ export const template = (props: ActiveFiltersHeader) => {
   if (
     !props.areCustomFiltersActive &&
     !props.areCommonFiltersActive &&
+    !props.areDiagnosticFiltersActive &&
     props.searchString.length < 1
   )
     return nothing;

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

@@ -4,7 +4,11 @@ import { PrimariaApi } from "../../../../../../api/api";
 import { lazyInject } from "../../../../infrastructure/ioc/container";
 import { TYPES } from "../../../../infrastructure/ioc/types";
 import { connectedProperty } from "../../../../infrastructure/state/connected-property";
-import { IActivityHistoryCommonFilter, IActivityHistoryCustomFilterGroup } from "../../model";
+import {
+  IActivityHistoryCommonFilter,
+  IActivityHistoryCustomFilterGroup,
+  IActivityHistoryDiagnosticsFilter,
+} from "../../model";
 import styles from "./styles.css?inline";
 import { template } from "./template";
 import { SetCustomFilterGroup } from "../../custom-filters/set-custom-filter-group/request";
@@ -12,6 +16,11 @@ import { SetCommonFilter } from "../../common-filters/set-common-filter/request"
 import { activityHistoryCommonFiltersSelector } from "../../common-filters/selectors";
 import { SetCustomFilterValue } from "../../custom-filters/set-custom-filter-value/request";
 import { customFilterGroupsWithOptionsSelector } from "../../../selectors";
+import {
+  diagnosticFilterEnabledValuesSelector,
+  diagnosticFilterSelector,
+} from "../../diagnostic-filters/selectors";
+import { SetDiagnosticFiltersCommand } from "../../diagnostic-filters/set/request";
 
 //@ts-ignore
 @customElement("activity-history-filters")
@@ -30,6 +39,12 @@ export class ActivityHistoryFilters extends LitElement {
   @connectedProperty(customFilterGroupsWithOptionsSelector)
   customFilterGroups: IActivityHistoryCustomFilterGroup[];
 
+  @connectedProperty(diagnosticFilterSelector)
+  diagnosticFilter: IActivityHistoryDiagnosticsFilter;
+
+  @connectedProperty(diagnosticFilterEnabledValuesSelector)
+  diagnosticFilterEnabledValues: string[];
+
   @lazyInject(TYPES.primaryApi)
   api: PrimariaApi;
 
@@ -72,4 +87,9 @@ export class ActivityHistoryFilters extends LitElement {
       }),
     );
   }
+
+  _handleDiagnosticFilterChange(e: CustomEvent) {
+    const selectedValues = e.detail.selectedValue;
+    this.api.broker.send(new SetDiagnosticFiltersCommand(selectedValues));
+  }
 }

package/src/internal-plugins/activity-history/activity-history-item/filter/UI/activity-history-filters/template.ts

@@ -6,7 +6,7 @@ import {
   IActivityHistoryCommonFilter,
   IActivityHistoryCustomFilter,
   IActivityHistoryCustomFilterGroup,
-  IActivityHistoryFilterGroup,
+  IActivityHistoryFilter,
 } from "../../model";
 import { translate } from "../../../../localization";
 
@@ -27,7 +27,7 @@ const filterTemplates = {
 const getFilterTemplate = (
   filter: IActivityHistoryCommonFilter | IActivityHistoryCustomFilter,
   onChangeValue: (...args: any[]) => void,
-  filterGroup?: IActivityHistoryFilterGroup,
+  filterGroup?: IActivityHistoryFilter,
   option?: { id: string; title: string },
 ) => {
   const isCustom = !!filterGroup?.id && !!option;
@@ -62,6 +62,15 @@ export const template = (props: ActivityHistoryFilters) =>
           ? html`<div class="filters-sidebar-opened">${translate("filters.filters")}<dss-icon-button ?hidden=${props.wrapperMaximized} @click=${() => props._toggleFilters()} size="md" variant="primary" icon="keyboard_double_arrow_left"></dss-icon-button></div>
           <div class="filter-container">
                   ${repeat(props.commonFilters, (filter: IActivityHistoryCommonFilter) => html`<div class="filter">${getFilterTemplate(filter, props._onChangeCommonFilterValue.bind(props))}</div> `)}
+                  ${
+                    props.diagnosticFilter &&
+                    html`<div class="filter">
+                          <dss-input-dropdown icon="" multiple dropdownFixed type="default" .elements=${props.diagnosticFilter?.values} @onInputDropdownChange=${props._handleDiagnosticFilterChange} .selectedValue=${props.diagnosticFilterEnabledValues}>
+                            <label slot="label" for="diagnostic-filter">${props.diagnosticFilter.title}</label>
+                            <input id="diagnostic-filter" slot="input" type="text" class="dss-input" autocomplete="off"/>
+                          </dss-input-dropdown>
+                        </div>`
+                  }
                   ${repeat(
                     props.customFilterGroups,
                     (group: IActivityHistoryCustomFilterGroup) => html`

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

@@ -16,12 +16,22 @@ import {
   bootstrapSetCustomFilterValue,
   teardownSetCustomFilterValue,
 } from "./custom-filters/set-custom-filter-value/bootstrapper";
+import {
+  bootstrapAddDiagnosticFilter,
+  teardownAddDiagnosticFilter,
+} from "./diagnostic-filters/add/bootstrapper";
+import {
+  bootstrapSetDiagnosticFilter,
+  teardownSetDiagnosticFilter,
+} from "./diagnostic-filters/set/bootstrapper";
 
 export const bootstrapFilters = (broker: BrokerExtensions) => {
   bootstrapSetCommonFilter(broker);
   bootstrapAddCustomFilter(broker);
   bootstrapSetCustomFilterGroup(broker);
   bootstrapSetCustomFilterValue(broker);
+  bootstrapAddDiagnosticFilter(broker);
+  bootstrapSetDiagnosticFilter(broker);
 };
 
 export const teardownFilters = () => {
@@ -29,4 +39,6 @@ export const teardownFilters = () => {
   teardownAddCustomFilter();
   teardownSetCustomFilterGroup();
   teardownSetCustomFilterValue();
+  teardownAddDiagnosticFilter();
+  teardownSetDiagnosticFilter();
 };

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

@@ -1,6 +1,11 @@
 import { OwnSpec } from "../../domain/specs/own-spec";
 import { RelevantSpec } from "../../domain/specs/relevant-spec";
-import { IActivityHistoryCommonFilterGroup, ActivityHistoryFilterType } from "../model";
+import {
+  IActivityHistoryCommonFilterGroup,
+  ActivityHistoryFilterType,
+  relevantFilterId,
+  ownFilterId,
+} from "../model";
 
 export const commonFilters: IActivityHistoryCommonFilterGroup[] = [
   {
@@ -8,14 +13,14 @@ export const commonFilters: IActivityHistoryCommonFilterGroup[] = [
     title: "Comuns",
     filters: [
       {
-        id: "relevant",
+        id: relevantFilterId,
         title: "Veure rellevants",
         spec: RelevantSpec,
         enabled: false,
         type: ActivityHistoryFilterType.Switch,
       },
       {
-        id: "own",
+        id: ownFilterId,
         title: "Veure meus",
         spec: OwnSpec,
         enabled: false,

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

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

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

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

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

@@ -1,16 +1,15 @@
 import { createSelector } from "@reduxjs/toolkit";
 import {
-  IActivityHistoryCustomFilter,
   IActivityHistoryCustomFilterGroup,
-  IActivityHistoryFilterGroup,
-  isNotCommonFilterGroup,
+  IActivityHistoryFilter,
+  isCustomFilter,
 } from "../model";
 import { activityHistoryFiltersSelector } from "../selectors";
 
 export const activityHistoryCustomFilterGroupsSelector = createSelector(
   activityHistoryFiltersSelector,
-  (filters: IActivityHistoryFilterGroup[]) => {
-    const customFilters = filters.filter(isNotCommonFilterGroup);
+  (filters: IActivityHistoryFilter[]) => {
+    const customFilters = filters.filter(isCustomFilter);
     return customFilters.sort(sortBySortProperty);
   },
 );

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

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

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

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

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

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

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

@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createSlice, PayloadAction } from "@reduxjs/toolkit";
+import { IActivityHistoryDiagnosticsFilter, isDiagnosticFilter } from "../../model";
+import { addDiagnosticFiltersReducer } from "./reducer";
+
+vi.mock("../../model", () => ({
+  isDiagnosticFilter: vi.fn(),
+}));
+
+describe("addDiagnosticFiltersReducer", () => {
+  let initialState: { filters: IActivityHistoryDiagnosticsFilter[] };
+
+  const baseFilter = (values: any[]): IActivityHistoryDiagnosticsFilter => ({
+    id: "diagnostics",
+    title: "Diagnòstics",
+    values,
+    enabledValues: [],
+  });
+
+  beforeEach(() => {
+    initialState = {
+      filters: [],
+    };
+    vi.clearAllMocks();
+  });
+
+  const slice = createSlice({
+    name: "activity",
+    initialState,
+    reducers: {
+      addDiagnosticFilters: addDiagnosticFiltersReducer,
+    },
+  });
+
+  const { addDiagnosticFilters } = slice.actions;
+  const reducer = slice.reducer;
+
+  it("should add a new diagnostic filter if none exists", () => {
+    (isDiagnosticFilter as any).mockReturnValue(false);
+
+    const newFilter = baseFilter([{ label: "Hipertensió", value: "I10" }]);
+
+    const nextState = reducer(initialState, addDiagnosticFilters(newFilter));
+
+    expect(nextState.filters).toHaveLength(1);
+    expect(nextState.filters[0]).toEqual(newFilter);
+  });
+
+  it("should merge values if a diagnostic filter already exists", () => {
+    const existingFilter = baseFilter([{ label: "Diabetes", value: "E11" }]);
+    initialState.filters = [existingFilter];
+
+    (isDiagnosticFilter as any).mockImplementation((f) => f.id === "diagnostics");
+
+    const incomingFilter = baseFilter([{ label: "Hipertensió", value: "I10" }]);
+
+    const nextState = reducer(initialState, addDiagnosticFilters(incomingFilter));
+
+    expect(nextState.filters).toHaveLength(1);
+    expect(nextState.filters[0].values).toContainEqual({ label: "Diabetes", value: "E11" });
+    expect(nextState.filters[0].values).toContainEqual({ label: "Hipertensió", value: "I10" });
+  });
+
+  it("should avoid duplicate values when merging", () => {
+    const existingFilter = baseFilter([{ label: "Diabetes", value: "E11" }]);
+    initialState.filters = [existingFilter];
+
+    (isDiagnosticFilter as any).mockImplementation((f) => f.id === "diagnostics");
+
+    const incomingFilter = baseFilter([{ label: "Diabetes", value: "E11" }]);
+
+    const nextState = reducer(initialState, addDiagnosticFilters(incomingFilter));
+
+    expect(nextState.filters).toHaveLength(1);
+    expect(nextState.filters[0].values).toEqual([{ label: "Diabetes", value: "E11" }]);
+  });
+
+  it("should preserve other properties of the existing filter", () => {
+    const existingFilter = {
+      ...baseFilter([{ label: "A", value: "1" }]),
+      enabledValues: ["1"],
+    };
+    initialState.filters = [existingFilter];
+
+    (isDiagnosticFilter as any).mockReturnValue(true);
+
+    const incomingFilter = baseFilter([{ label: "B", value: "2" }]);
+
+    const nextState = reducer(initialState, addDiagnosticFilters(incomingFilter));
+
+    expect(nextState.filters[0].enabledValues).toEqual(["1"]); // no se sobreescribe
+  });
+});

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

@@ -0,0 +1,25 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { IActivityHistoryDiagnosticsFilter, isDiagnosticFilter } from "../../model";
+
+export function addDiagnosticFiltersReducer(
+  state,
+  action: PayloadAction<IActivityHistoryDiagnosticsFilter>,
+) {
+  const index = state.filters.findIndex(isDiagnosticFilter);
+
+  if (index === -1) {
+    state.filters.push(action.payload);
+  } else {
+    const existing = state.filters[index];
+
+    const mergedValues = [
+      ...existing.values,
+      ...action.payload.values.filter((v) => !existing.values.some((ev) => ev.value === v.value)),
+    ];
+
+    state.filters[index] = {
+      ...existing,
+      values: mergedValues,
+    };
+  }
+}

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

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

package/src/internal-plugins/activity-history/activity-history-item/filter/diagnostic-filters/handle-add-diagnostics-options-from-item.test.ts

@@ -0,0 +1,80 @@
+import { mapArrayToLabelValue } from "@primaria/plugins-core";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { handleAddDiagnosticsFilter } from "./handle-add-diagnostics-options-from-item";
+import { diagnosticsfilterId } from "../model";
+
+vi.mock("@primaria/plugins-core", () => ({
+  mapArrayToLabelValue: vi.fn(),
+}));
+
+describe("handleAddDiagnosticsFilter", () => {
+  const mockDispatch = vi.fn();
+  const mockStore = { dispatch: mockDispatch };
+
+  const diagnosticsSample = [
+    { descripcio: "Diabetes", codi: "E11" },
+    { descripcio: "Hipertensió", codi: "I10" },
+  ];
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should dispatch a filter when items have diagnostics", () => {
+    (mapArrayToLabelValue as any).mockReturnValue([
+      { label: "Diabetes", value: "E11" },
+      { label: "Hipertensió", value: "I10" },
+    ]);
+
+    const items = [{ diagnostics: diagnosticsSample }];
+
+    handleAddDiagnosticsFilter(items, mockStore as any);
+
+    expect(mapArrayToLabelValue).toHaveBeenCalledWith(diagnosticsSample, "descripcio", "codi");
+    expect(mockDispatch).toHaveBeenCalledWith({
+      type: expect.any(String), // puedes ajustar esto si usas createAction
+      payload: {
+        id: diagnosticsfilterId,
+        title: "Diagnòstics",
+        values: [
+          { label: "Diabetes", value: "E11" },
+          { label: "Hipertensió", value: "I10" },
+        ],
+        enabledValues: [],
+      },
+    });
+  });
+
+  it("should not dispatch if no diagnostics are present", () => {
+    const items = [{ diagnostics: [] }, { diagnostics: undefined }];
+    handleAddDiagnosticsFilter(items, mockStore as any);
+    expect(mockDispatch).not.toHaveBeenCalled();
+  });
+
+  it("should deduplicate diagnostics by codi", () => {
+    const duplicatedDiagnostics = [
+      { descripcio: "Diabetes", codi: "E11" },
+      { descripcio: "Diabetis", codi: "E11" }, // mismo código
+      { descripcio: "Hipertensió", codi: "I10" },
+    ];
+
+    (mapArrayToLabelValue as any).mockReturnValue([
+      { label: "Diabetes", value: "E11" },
+      { label: "Hipertensió", value: "I10" },
+    ]);
+
+    const items = [{ diagnostics: duplicatedDiagnostics }];
+
+    handleAddDiagnosticsFilter(items, mockStore as any);
+
+    expect(mapArrayToLabelValue).toHaveBeenCalledWith(
+      [
+        { descripcio: "Diabetes", codi: "E11" },
+        { descripcio: "Hipertensió", codi: "I10" },
+      ],
+      "descripcio",
+      "codi",
+    );
+    expect(mockDispatch).toHaveBeenCalled();
+  });
+});

package/src/internal-plugins/activity-history/activity-history-item/filter/diagnostic-filters/handle-add-diagnostics-options-from-item.ts

@@ -0,0 +1,30 @@
+import { mapArrayToLabelValue } from "@primaria/plugins-core";
+import { Store } from "@reduxjs/toolkit";
+import { IActivityHistoryItem } from "../../domain/model";
+import { diagnosticsfilterId } from "../model";
+import { addDiagnosticFilters } from "./add/actions";
+
+export const handleAddDiagnosticsFilter = (items: IActivityHistoryItem[], store: Store) => {
+  const allDiagnostics = items
+    .flatMap((item) => item.diagnostics ?? [])
+    .filter((diag, index, self) => index === self.findIndex((d) => d.codi === diag.codi));
+
+  if (allDiagnostics.length > 0) {
+    const newDiagnosticFilter = {
+      id: diagnosticsfilterId,
+      title: "Diagnòstics",
+      values: mapArrayToLabelValue(allDiagnostics, "descripcio", "codi"),
+      enabledValues: [],
+    };
+
+    store.dispatch(addDiagnosticFilters(newDiagnosticFilter));
+  }
+};
+
+export function mergeDiagnosticOptionsByCodi(array1, array2) {
+  const existingCodis = new Set(array1.map((obj) => obj.codi));
+
+  const newObjects = array2.filter((obj) => !existingCodis.has(obj.codi));
+
+  return [...array1, ...newObjects];
+}

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

@@ -0,0 +1,22 @@
+import { createSelector } from "@reduxjs/toolkit";
+import {
+  IActivityHistoryDiagnosticsFilter,
+  IActivityHistoryFilter,
+  isDiagnosticFilter,
+} from "../model";
+import { activityHistoryFiltersSelector } from "../selectors";
+
+export const diagnosticFilterSelector = createSelector(
+  activityHistoryFiltersSelector,
+  (filters: IActivityHistoryFilter[]) => filters.find(isDiagnosticFilter),
+);
+
+export const diagnosticFilterEnabledValuesSelector = createSelector(
+  diagnosticFilterSelector,
+  (filter: IActivityHistoryDiagnosticsFilter) => filter?.enabledValues || [],
+);
+
+export const areDiagnosticFiltersActive = createSelector(
+  diagnosticFilterEnabledValuesSelector,
+  (filters) => !!filters.length,
+);

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

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

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

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

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

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