@uxland/primary-shell 5.4.7 → 5.5.0

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

@@ -38,13 +38,25 @@ const renderDiagnosticChip = (id, value, props) => html`
   ></dss-chip>
 `;
 
+const renderUpChip = (id, value, props) => html`
+  <dss-chip
+    label=${value}
+    size="sm"
+    hasdelete
+    selected
+    @click=${() => props._onDeleteUpFilterValue(id)}
+    @onDelete=${() => props._onDeleteUpFilterValue(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 &&
-    props.diagnosticFilterEnabled.enabledValues.length === 0
+    props.diagnosticFilterEnabled.enabledValues.length === 0 &&
+    props.upFilterEnabled.enabledValues.length === 0
   )
     return nothing;
 
@@ -85,6 +97,38 @@ export const template = (props: ActiveFiltersBadges) => {
     }
   }
 
+  const up = props.upFilterEnabled;  
+
+  if (up) {
+    const { title, values, enabledValues } = up;
+    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 = renderUpChip(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

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

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

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

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

@@ -8,6 +8,7 @@ import {
   IActivityHistoryCommonFilter,
   IActivityHistoryCustomFilterGroup,
   IActivityHistoryDiagnosticsFilter,
+  IActivityHistoryUpFilter,
 } from "../../model";
 import styles from "./styles.css?inline";
 import { template } from "./template";
@@ -16,11 +17,10 @@ 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 { diagnosticFilterEnabledValuesSelector, diagnosticFilterSelector } from "../../diagnostic-filters/selectors";
 import { SetDiagnosticFiltersCommand } from "../../diagnostic-filters/set/request";
+import { upFilterEnabledValuesSelector, upFilterSelector } from "../../up-filters/selectors";
+import { SetUpFiltersCommand } from "../../up-filters/set/request";
 
 //@ts-ignore
 @customElement("activity-history-filters")
@@ -45,6 +45,12 @@ export class ActivityHistoryFilters extends LitElement {
   @connectedProperty(diagnosticFilterEnabledValuesSelector)
   diagnosticFilterEnabledValues: string[];
 
+  @connectedProperty(upFilterSelector)
+  upFilter: IActivityHistoryUpFilter;
+
+  @connectedProperty(upFilterEnabledValuesSelector)
+  upFilterEnabledValues: string[];
+
   @lazyInject(TYPES.primaryApi)
   api: PrimariaApi;
 
@@ -72,12 +78,7 @@ export class ActivityHistoryFilters extends LitElement {
     this.api.broker.send(new SetCustomFilterGroup({ id: filterGroupId, enabled: value }));
   }
 
-  _onChangeCustomFilterValue(
-    filterGroupId: string,
-    filterId: string,
-    optionId: string,
-    value: boolean,
-  ) {
+  _onChangeCustomFilterValue(filterGroupId: string, filterId: string, optionId: string, value: boolean) {
     this.api.broker.send(
       new SetCustomFilterValue({
         filterGroupId,
@@ -92,4 +93,9 @@ export class ActivityHistoryFilters extends LitElement {
     const selectedValues = e.detail.selectedValue;
     this.api.broker.send(new SetDiagnosticFiltersCommand(selectedValues));
   }
+
+  _handleUpFilterChange(e: CustomEvent) {
+    const selectedValues = e.detail.selectedValue;
+    this.api.broker.send(new SetUpFiltersCommand(selectedValues));
+  }
 }

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

@@ -41,6 +41,7 @@
     display: flex;
     flex-direction: column;
     padding-top: 12px;
+    gap: var(--dss-spacing-xs);
 
     .custom-filter{
       display: flex;

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

@@ -22,6 +22,12 @@ const filterTemplates = {
       <input slot="input" id="checkboxStory-${id}" type="checkbox" ?disabled=${!isEnabled}>
       <label slot="label" for="checkboxStory-${id}">${title}</label>
     </dss-checkbox>`,
+
+  [ActivityHistoryFilterType.Dropdown]: (id, title, handleChange, isSelected, isEnabled) => html`
+    <dss-input-dropdown type="default" .checked=${isSelected} @onChange=${(e) => handleChange(e)}> 
+      <input slot="input" id="dropdownStory-${id}" type="text" ?disabled=${!isEnabled}>
+      <label slot="label" for="dropdownStory-${id}">${title}</label>
+    </dss-input-dropdown>`,
 };
 
 const getFilterTemplate = (
@@ -33,7 +39,7 @@ const getFilterTemplate = (
   const isCustom = !!filterGroup?.id && !!option;
   //const id = isCustom ? `${filterGroupId}-${filter.id}-${option.id}` : filter.id;
   const id = crypto.randomUUID();
-  const title = isCustom ? option.title : filter.title;
+  const title = isCustom ? option.title || option.id : filter.title;
 
   const handleChange = (e) => {
     if (filter.singleOption) onChangeValue(filterGroup?.id, filter.id, null, e.detail);
@@ -67,6 +73,15 @@ export const template = (props: ActivityHistoryFilters) =>
                           </dss-input-dropdown>
                         </div>`
                   }
+                  ${
+                    props.upFilter &&
+                    html`<div class="filter">
+                      <dss-input-dropdown icon="" multiple dropdownFixed type="default" .elements=${props.upFilter?.values} @onInputDropdownChange=${props._handleUpFilterChange} .selectedValue=${props.upFilterEnabledValues} selectorStyle=${"max-height: 450px"}>
+                        <label slot="label" for="up-filter">${props.upFilter.title}</label>
+                        <input id="up-filter" slot="input" type="text" class="dss-input" autocomplete="off"/>
+                      </dss-input-dropdown>
+                    </div>`
+                  }
                   ${repeat(
                     props.customFilterGroups,
                     (group: IActivityHistoryCustomFilterGroup) => html`
@@ -91,17 +106,38 @@ const customFilterTemplate = (
   filter: IActivityHistoryCustomFilter,
   props: ActivityHistoryFilters,
   group: IActivityHistoryCustomFilterGroup,
-) =>
-  html`
-    <div class="custom-filter">
-      ${
-        filter.singleOption
-          ? getFilterTemplate(filter, props._onChangeCustomFilterValue.bind(props), group)
-          : html`
-          <primaria-accordion isOpen=${true}>
-            <div class="custom-filter-title" slot="title">${filter.title}</div>
-            <div class="custom-filter-content" slot="content">${repeat(filter.options, (option) => html`${getFilterTemplate(filter, props._onChangeCustomFilterValue.bind(props), group, option)}`)}</div>
-          </primaria-accordion>`
-      }
-    </div>
-  `;
+) => {
+  if (filter.type === ActivityHistoryFilterType.Dropdown) {
+    const elements = filter?.options.map(option => ({ value: option.id, label: option.title }));
+    return html`
+      <dss-input-dropdown
+        icon=""
+        multiple
+        dropdownFixed
+        type="default"
+        .elements=${elements}
+        @onInputDropdownChange=${(e) =>
+          props._onChangeCustomFilterValue(group.id, filter.id, e.detail.selectedValue[e.detail.selectedValue.length-1], true)
+        }
+        .selectedValue=${filter.enabledValues}
+        selectorStyle="max-height: 450px"
+      >
+        <label slot="label">${filter.title}</label>
+        <input slot="input" type="text" class="dss-input" autocomplete="off" />
+      </dss-input-dropdown>
+    `;
+  }
+
+  return filter.singleOption
+    ? getFilterTemplate(filter, props._onChangeCustomFilterValue.bind(props), group)
+    : html`
+        <primaria-accordion isOpen>
+          <div class="custom-filter-title" slot="title">${filter.title}</div>
+          <div class="custom-filter-content" slot="content">
+            ${filter.options.map(option =>
+              getFilterTemplate(filter, props._onChangeCustomFilterValue.bind(props), group, option)
+            )}
+          </div>
+        </primaria-accordion>
+      `;
+};

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

@@ -14,6 +14,8 @@ import { bootstrapAddDiagnosticFilter, teardownAddDiagnosticFilter } from "./dia
 import { bootstrapSetDiagnosticFilter, teardownSetDiagnosticFilter } from "./diagnostic-filters/set/bootstrapper";
 import { bootstrapResetCommonFilter, teardownResetCommonFilter } from "./common-filters/reset-common-filter/bootstrapper";
 import { bootstrapResetCustomFilter, teardownResetCustomFilter } from "./custom-filters/reset-custom-filter/bootstrapper";
+import { bootstrapAddUpFilter, teardownAddUpFilter } from "./up-filters/add/bootstrapper";
+import { bootstrapSetUpFilter, teardownSetUpFilter } from "./up-filters/set/bootstrapper";
 
 export const bootstrapFilters = (broker: BrokerExtensions) => {
   bootstrapSetCommonFilter(broker);
@@ -24,6 +26,8 @@ export const bootstrapFilters = (broker: BrokerExtensions) => {
   bootstrapSetDiagnosticFilter(broker);
   bootstrapResetCommonFilter(broker);
   bootstrapResetCustomFilter(broker);
+  bootstrapAddUpFilter(broker);
+  bootstrapSetUpFilter(broker);
 };
 
 export const teardownFilters = () => {
@@ -35,4 +39,6 @@ export const teardownFilters = () => {
   teardownSetDiagnosticFilter();
   teardownResetCommonFilter();
   teardownResetCustomFilter();
+  teardownAddUpFilter();
+  teardownSetUpFilter();
 };

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

@@ -1,7 +1,6 @@
 export function resetCustomFilterValuesReducer(state) {
   state.filters = state.filters.map((f) => {
-    if (f.id !== "common" && f.id !== "history-diagnostics") {
-      console.log("filter", f);
+    if (f.id !== "common" && f.id !== "history-diagnostics" && f.id !== "history-up") {
       return {
         ...f,
         filters: f.filters.map((ff) => ({ ...ff, enabled: false, enabledValues: [] })),

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

@@ -6,6 +6,7 @@ type Constructor<T> = new (...args: any[]) => T;
 export enum ActivityHistoryFilterType {
   Switch = "switch",
   Checkbox = "checkbox",
+  Dropdown = "dropdown",
 }
 
 export enum ActivityHistoryFilterOperation {
@@ -56,14 +57,11 @@ export interface IActivityHistoryCustomFilter {
 }
 
 export const isCommonFilterGroup = (group: IActivityHistoryFilter) => group.id === "common";
-export const isNotCommonFilterGroup = (group: IActivityHistoryFilter) =>
-  !isCommonFilterGroup(group);
-export const isDiagnosticFilter = (filter: IActivityHistoryFilter) =>
-  filter.id === diagnosticsfilterId;
-export const isNotDiagnosticFilter = (filter: IActivityHistoryFilter) =>
-  !isDiagnosticFilter(filter);
-export const isCustomFilter = (filter: IActivityHistoryFilter) =>
-  !isCommonFilterGroup(filter) && !isDiagnosticFilter(filter);
+export const isNotCommonFilterGroup = (group: IActivityHistoryFilter) => !isCommonFilterGroup(group);
+export const isDiagnosticFilter = (filter: IActivityHistoryFilter) => filter.id === diagnosticsfilterId;
+export const isNotDiagnosticFilter = (filter: IActivityHistoryFilter) => !isDiagnosticFilter(filter);
+export const isCustomFilter = (filter: IActivityHistoryFilter) => !isCommonFilterGroup(filter) && !isDiagnosticFilter(filter) && !isUpFilter(filter);
+export const isUpFilter = (filter: IActivityHistoryFilter) => filter.id === upFilterId;
 export interface IActivityHistoryDiagnosticsFilter {
   id: string;
   title: string;
@@ -71,6 +69,14 @@ export interface IActivityHistoryDiagnosticsFilter {
   enabledValues: string[];
 }
 
+export interface IActivityHistoryUpFilter {
+  id: string;
+  title: string;
+  values: { label: string; value: string }[];
+  enabledValues: string[];
+}
+
 export const diagnosticsfilterId = "history-diagnostics";
 export const relevantFilterId = "history-relevant";
 export const ownFilterId = "history-own";
+export const upFilterId = "history-up";

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

@@ -10,6 +10,8 @@ import { addDiagnosticFiltersReducer } from "./diagnostic-filters/add/reducer";
 import { setDiagnosticFilterValuesReducer } from "./diagnostic-filters/set/reducer";
 import { resetCommonFilterValuesReducer } from "./common-filters/reset-common-filter/reducer";
 import { resetCustomFilterValuesReducer } from "./custom-filters/reset-custom-filter/reducer";
+import { addUpFiltersReducer } from "./up-filters/add/reducer";
+import { setUpFilterValuesReducer } from "./up-filters/set/reducer";
 
 export const activityHistoryFiltersSlice = createSlice({
   name: "activity-history-filters",
@@ -27,5 +29,7 @@ export const activityHistoryFiltersSlice = createSlice({
     resetCustomFilterValues: resetCustomFilterValuesReducer,
     addDiagnosticFilters: addDiagnosticFiltersReducer,
     setDiagnosticFilterValues: setDiagnosticFilterValuesReducer,
+    addUpFilters: addUpFiltersReducer,
+    setUpFilterValues: setUpFilterValuesReducer,
   },
 });

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

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

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

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

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

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

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

@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createSlice, PayloadAction } from "@reduxjs/toolkit";
+import { IActivityHistoryUpFilter,  isUpFilter } from "../../model";
+import {  addUpFiltersReducer } from "./reducer";
+
+vi.mock("../../model", () => ({
+  isUpFilter: vi.fn(),
+}));
+
+describe("addUpFiltersReducer", () => {
+  let initialState: { filters: IActivityHistoryUpFilter[] };
+
+  const baseFilter = (values: any[]): IActivityHistoryUpFilter => ({
+    id: "up",
+    title: "UP",
+    values,
+    enabledValues: [],
+  });
+
+  beforeEach(() => {
+    initialState = {
+      filters: [],
+    };
+    vi.clearAllMocks();
+  });
+
+  const slice = createSlice({
+    name: "activity",
+    initialState,
+    reducers: {
+      addUpFilters: addUpFiltersReducer,
+    },
+  });
+
+  const { addUpFilters } = slice.actions;
+  const reducer = slice.reducer;
+
+  it("should add a new up filter if none exists", () => {
+    (isUpFilter as any).mockReturnValue(false);
+
+    const newUp = baseFilter([{ label: "0773", value: "0773" }]);
+
+    const nextState = reducer(initialState, addUpFilters(newUp));
+
+    expect(nextState.filters).toHaveLength(1);
+    expect(nextState.filters[0]).toEqual(newUp);
+  });
+
+  it("should merge values if a up filter already exists", () => {
+    const existingFilter = baseFilter([{ label: "0773", value: "0773" }]);
+    initialState.filters = [existingFilter];
+
+    (isUpFilter as any).mockImplementation((f) => f.id === "up");
+
+    const incomingFilter = baseFilter([{ label: "0444", value: "0444" }]);
+
+    const nextState = reducer(initialState, addUpFilters(incomingFilter));
+
+    expect(nextState.filters).toHaveLength(1);
+    expect(nextState.filters[0].values).toContainEqual({ label: "0773", value: "0773" });
+    expect(nextState.filters[0].values).toContainEqual({ label: "0444", value: "0444" });
+  });
+
+  it("should avoid duplicate values when merging", () => {
+    const existingFilter = baseFilter([{ label: "0444", value: "0444" }]);
+    initialState.filters = [existingFilter];
+
+    (isUpFilter as any).mockImplementation((f) => f.id === "up");
+
+    const incomingFilter = baseFilter([{ label: "0444", value: "0444" }]);
+
+    const nextState = reducer(initialState, addUpFilters(incomingFilter));
+
+    expect(nextState.filters).toHaveLength(1);
+    expect(nextState.filters[0].values).toEqual([{ label: "0444", value: "0444" }]);
+  });
+
+  it("should preserve other properties of the existing filter", () => {
+    const existingFilter = {
+      ...baseFilter([{ label: "A", value: "1" }]),
+      enabledValues: ["1"],
+    };
+    initialState.filters = [existingFilter];
+
+    (isUpFilter as any).mockReturnValue(true);
+
+    const incomingFilter = baseFilter([{ label: "B", value: "2" }]);
+
+    const nextState = reducer(initialState, addUpFilters(incomingFilter));
+
+    expect(nextState.filters[0].enabledValues).toEqual(["1"]); // no se sobreescribe
+  });
+});

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

@@ -0,0 +1,22 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { IActivityHistoryUpFilter, isUpFilter } from "../../model";
+
+export function addUpFiltersReducer(state, action: PayloadAction<IActivityHistoryUpFilter>) {
+  const index = state.filters.findIndex(isUpFilter);
+
+  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/up-filters/add/request.ts

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

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

@@ -0,0 +1,20 @@
+import { mapArrayToLabelValue } from "@primaria/plugins-core";
+import { Store } from "@reduxjs/toolkit";
+import { IActivityHistoryItem } from "../../domain/model";
+import { upFilterId } from "../model";
+import { addUpFilters } from "./add/actions";
+
+export const handleAddUpFilter = (items: IActivityHistoryItem[], store: Store) => {
+  const allUps = items.flatMap((item) => item.up ?? []).filter((up, index, self) => index === self.findIndex((u) => u.id === up.id));
+
+  if (allUps.length > 0) {
+    const newUpFilter = {
+      id: upFilterId,
+      title: "UP",
+      values: mapArrayToLabelValue(allUps, "description", "id"),
+      enabledValues: [],
+    };
+
+    store.dispatch(addUpFilters(newUpFilter));
+  }
+};

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

@@ -0,0 +1,14 @@
+import { createSelector } from "@reduxjs/toolkit";
+import { IActivityHistoryFilter, IActivityHistoryUpFilter, isUpFilter } from "../model";
+import { activityHistoryFiltersSelector } from "../selectors";
+
+export const upFilterSelector = createSelector(activityHistoryFiltersSelector, (filters: IActivityHistoryFilter[]) =>
+  filters.find(isUpFilter),
+);
+
+export const upFilterEnabledValuesSelector = createSelector(
+  upFilterSelector,
+  (filter: IActivityHistoryUpFilter) => filter?.enabledValues || [],
+);
+
+export const areUpFiltersActive = createSelector(upFilterEnabledValuesSelector, (filters) => !!filters.length);

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { IActivityHistoryUpFilter, isUpFilter } from "../../model";
+
+export function setUpFilterValuesReducer(state, action: PayloadAction<string[]>) {
+  state.filters = [...state.filters].map((f) => {
+    if (isUpFilter(f)) {
+      return { ...f, enabledValues: action.payload } as IActivityHistoryUpFilter;
+    }
+    return f;
+  });
+}

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

@@ -0,0 +1,3 @@
+export class SetUpFiltersCommand {
+  constructor(public payload: string[]) {}
+}