@uxland/primary-shell 3.5.4 → 4.0.0

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

@@ -0,0 +1,59 @@
+import { IActivityHistoryCommonFilterGroup, IActivityHistoryCustomFilterGroup } from "../../filter";
+import { IActivityHistoryItem } from "../model";
+import { FalseSpec } from "./false-spec";
+import { PropPathSpec } from "./prop-path-spec";
+import { Spec } from "./spec";
+
+export class CustomFilterSpec extends Spec<IActivityHistoryItem> {
+  constructor(private filters: IActivityHistoryCustomFilterGroup[]) {
+    super();
+  }
+
+  isSatisfiedBy(item: IActivityHistoryItem): boolean {
+    const enabledGroups = this.filters.filter((group) => group.enabled);
+
+    if (enabledGroups.length === 0) {
+      return true; // No hay filtros activados, se aceptan todos los items
+    }
+
+    return enabledGroups.every((group) => {
+      if (!this.belongsToGroup(item, group)) {
+        return true;
+      }
+
+      const enabledFilters = group.filters.filter(
+        (filter) => filter.enabled || filter.singleOption,
+      );
+
+      if (enabledFilters.length === 0) {
+        return true;
+      }
+
+      return enabledFilters.every((filter) => {
+        if (filter.singleOption) {
+          // Si el filtro booleano está DESACTIVADO, debe filtrar los elementos con ese valor
+          return !filter.enabled
+            ? new PropPathSpec(filter.propPathValue, false).isSatisfiedBy(item)
+            : true; // Si está activado, no filtra nada
+        }
+
+        if (!filter.enabledValues || filter.enabledValues.length === 0) {
+          return true;
+        }
+
+        const propSpec = filter.enabledValues.reduce((acc, value) => {
+          return acc.or(new PropPathSpec(filter.propPathValue, value));
+        }, new FalseSpec());
+
+        return propSpec.isSatisfiedBy(item);
+      });
+    });
+  }
+
+  private belongsToGroup(
+    item: IActivityHistoryItem,
+    group: IActivityHistoryCustomFilterGroup,
+  ): boolean {
+    return item.type === group.id;
+  }
+}

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

@@ -0,0 +1,8 @@
+import { IActivityHistoryItem } from "../model";
+import { Spec } from "./spec";
+
+export class FalseSpec extends Spec<IActivityHistoryItem> {
+  isSatisfiedBy(): boolean {
+    return false;
+  }
+}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/prop-path-spec.ts

@@ -0,0 +1,19 @@
+import { IActivityHistoryItem } from "../model";
+import { Spec } from "./spec";
+
+export class PropPathSpec extends Spec<IActivityHistoryItem> {
+  constructor(
+    public propPath: string[],
+    private value: any,
+  ) {
+    super();
+  }
+
+  isSatisfiedBy(context: IActivityHistoryItem): boolean {
+    // Reducir el context siguiendo el path hasta llegar al valor final
+    const propValue = this.propPath.reduce((acc, key) => acc?.[key], context);
+
+    // Comparar con el valor esperado
+    return propValue === this.value;
+  }
+}

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

@@ -0,0 +1,26 @@
+import { IActivityHistoryCustomFilterGroup } from "../../filter";
+import { IActivityHistoryItem } from "../model";
+import { FalseSpec } from "./false-spec";
+import { Spec } from "./spec";
+
+export class TypeSpec extends Spec<IActivityHistoryItem> {
+  constructor(public itemType: string) {
+    super();
+  }
+  isSatisfiedBy(context: IActivityHistoryItem): boolean {
+    return context?.type === this.itemType;
+  }
+}
+
+export class ComposedTypeSpec extends Spec<IActivityHistoryItem> {
+  constructor(public filters: IActivityHistoryCustomFilterGroup[]) {
+    super();
+  }
+  isSatisfiedBy(item: IActivityHistoryItem): boolean {
+    const enabledGroupTypes = this.filters.filter((f) => f.enabled).map((f) => f.id);
+    const finalSpec = enabledGroupTypes.reduce((acc, groupId) => {
+      return acc.or(new TypeSpec(groupId));
+    }, new FalseSpec());
+    return finalSpec.isSatisfiedBy(item);
+  }
+}

package/src/internal-plugins/activity-history/activity-history-item/export-to-pdf/export-pdf-modal/export-pdf-modal.css

@@ -43,8 +43,8 @@ dss-datepicker {
     width: 234px;
     height: 48px;
     border-radius: var(--dss-radius-sm);
-    border: var(--dds-border-width-sm);
-    padding: var(--dds-spacing-sm);
-    gap: var(--dds-spacing-xs);
+    border: var(--dss-border-width-sm);
+    padding: var(--dss-spacing-sm);
+    gap: var(--dss-spacing-xs);
     color: var(--color-neutral-100);
 }

package/src/internal-plugins/activity-history/activity-history-item/export-to-pdf/export-pdf-modal/template.ts

@@ -37,8 +37,7 @@ export const template = (props: ExportPdfModal) => {
                 <div class="datepicker-canvas">
                   <dss-datepicker-range inputsize="md" @onRangeChange=${(e) => {
                     props.selectedPeriodDate = e.detail;
-                  }} helpText="Sense seleccionar data, s'aplicarà la de la primera entrada. 
-                    Sense seleccionar data de fi, s'aplicarà la de l'última entrada.">
+                  }} helpText=${translate("modal.helpText")}>
                     <label slot="label-range-start" for="myDatepickerRangeStart">${translate("modal.startDate")}</label>
                     <input slot="input-range-start" id="myDatepickerRangeStart" type="text" class="dss-input">
                     <label slot="label-range-end" for="myDatepickerRangeEnd">${translate("modal.endDate")}</label>

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

@@ -1,14 +1,17 @@
 import { LitElement, css, html, unsafeCSS } from "lit";
-import { customElement, state } from "lit/decorators.js";
+import { customElement, property, state } from "lit/decorators.js";
 import { PrimariaApi } from "../../../../../../api/api";
-import { IActivityHistoryFilter } from "../../model";
 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 styles from "./styles.css?inline";
 import { template } from "./template";
-import { activityHistoryCommonFiltersSelector } from "../../selectors";
-import { SetCommonFilter } from "../../set-common-filter/request";
+import { SetCustomFilterGroup } from "../../custom-filters/set-custom-filter-group/request";
+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";
 
 //@ts-ignore
 @customElement("activity-history-filters")
@@ -22,7 +25,10 @@ export class ActivityHistoryFilters extends LitElement {
   `;
 
   @connectedProperty(activityHistoryCommonFiltersSelector)
-  filters: IActivityHistoryFilter[];
+  commonFilters: IActivityHistoryCommonFilter[];
+
+  @connectedProperty(customFilterGroupsWithOptionsSelector)
+  customFilterGroups: IActivityHistoryCustomFilterGroup[];
 
   @lazyInject(TYPES.primaryApi)
   api: PrimariaApi;
@@ -30,6 +36,15 @@ export class ActivityHistoryFilters extends LitElement {
   @state()
   filtersExpanded = false;
 
+  @property({ type: Boolean })
+  wrapperMaximized: boolean;
+
+  updated(changedProperties) {
+    if (changedProperties.has("wrapperMaximized")) {
+      this.filtersExpanded = this.wrapperMaximized;
+    }
+  }
+
   _toggleFilters() {
     this.filtersExpanded = !this.filtersExpanded;
   }
@@ -37,4 +52,24 @@ export class ActivityHistoryFilters extends LitElement {
   _onChangeCommonFilterValue(filterId: string, value: boolean) {
     this.api.broker.send(new SetCommonFilter({ id: filterId, enabled: value }));
   }
+
+  _onChangeCustomFilterGroupValue(filterGroupId: string, value: boolean) {
+    this.api.broker.send(new SetCustomFilterGroup({ id: filterGroupId, enabled: value }));
+  }
+
+  _onChangeCustomFilterValue(
+    filterGroupId: string,
+    filterId: string,
+    optionId: string,
+    value: boolean,
+  ) {
+    this.api.broker.send(
+      new SetCustomFilterValue({
+        filterGroupId,
+        filterId,
+        optionId,
+        enabled: value,
+      }),
+    );
+  }
 }

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

@@ -26,14 +26,30 @@
 
 
 .filter-container{
-      display: flex;
+    display: flex;
     flex-direction: column;
     padding: 16px 8px 8px 8px;
-
-    
+    overflow:auto;
 }
 
 .filter-container .filter{
   padding: 8px 0;
       border-bottom: 1px solid var(--color-neutral-200);
-    }
+}
+
+.filter-group{
+    display: flex;
+    flex-direction: column;
+    padding-top: 12px;
+
+    .custom-filter{
+      display: flex;
+      flex-direction: column;
+      padding: 6px 8px 6px var(--dss-spacing-xl);
+
+      .custom-filter-content{
+        display: flex;
+        flex-direction: column;
+      }
+    }
+}

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

@@ -1,19 +1,57 @@
 import { html } from "lit";
 import { ActivityHistoryFilters } from "./activity-history-filters";
 import { repeat } from "lit/directives/repeat.js";
-import { IActivityHistoryFilter } from "../../model";
-import { ActivityHistoryFilterType } from "../../constants";
+import {
+  ActivityHistoryFilterType,
+  IActivityHistoryCommonFilter,
+  IActivityHistoryCustomFilter,
+  IActivityHistoryCustomFilterGroup,
+  IActivityHistoryFilterGroup,
+} from "../../model";
 import { translate } from "../../../../localization";
 
-const getFilterTemplate = (props: ActivityHistoryFilters, filter: IActivityHistoryFilter) => {
-  switch (filter.type) {
-    case ActivityHistoryFilterType.Switch:
-      return html`
-      <dss-input-switch size="sm" @onChangeValue=${(e) => props._onChangeCommonFilterValue(filter.id, e.detail)}>
-        <input slot="input" id="switch-${filter.id}" aria-label=${filter.title} type="checkbox">
-         <label slot="label" for="switch-${filter.id}">${filter.title}</label>
-      </dss-input-switch>`;
-  }
+const filterTemplates = {
+  [ActivityHistoryFilterType.Switch]: (id, title, handleChange, isSelected, isEnabled) => html`
+    <dss-input-switch size="sm" .checked=${isSelected} @onChangeValue=${handleChange} >
+      <input slot="input" id="switch-${id}" aria-label=${title} type="checkbox" ?disabled=${!isEnabled}>
+      <label slot="label" for="switch-${id}">${title}</label>
+    </dss-input-switch>`,
+
+  [ActivityHistoryFilterType.Checkbox]: (id, title, handleChange, isSelected, isEnabled) => html`
+    <dss-checkbox variant="default" .checked=${isSelected} @onChange=${(e) => handleChange(e)}> 
+      <input slot="input" id="checkboxStory-${id}" type="checkbox" ?disabled=${!isEnabled}>
+      <label slot="label" for="checkboxStory-${id}">${title}</label>
+    </dss-checkbox>`,
+};
+
+const getFilterTemplate = (
+  filter: IActivityHistoryCommonFilter | IActivityHistoryCustomFilter,
+  onChangeValue: (...args: any[]) => void,
+  filterGroup?: IActivityHistoryFilterGroup,
+  option?: { id: string; title: string },
+) => {
+  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 handleChange = (e) => {
+    if (filter.singleOption) onChangeValue(filterGroup?.id, filter.id, null, e.detail);
+    else if (isCustom && option) onChangeValue(filterGroup?.id, filter.id, option.id, e.detail);
+    else onChangeValue(filter.id, e.detail);
+  };
+
+  const isSelected =
+    isCustom && option
+      ? (filter as IActivityHistoryCustomFilter).enabledValues?.includes(option.id)
+      : filter.enabled;
+
+  const isEnabled =
+    (isCustom && option) || filter.singleOption
+      ? (filterGroup as IActivityHistoryCustomFilterGroup).enabled
+      : true;
+
+  return filterTemplates[filter.type]?.(id, title, handleChange, isSelected, isEnabled) || html``;
 };
 
 export const template = (props: ActivityHistoryFilters) =>
@@ -21,10 +59,44 @@ export const template = (props: ActivityHistoryFilters) =>
   <div class="filters-sidebar" ?expanded=${props.filtersExpanded} >
       ${
         props.filtersExpanded
-          ? html`<div class="filters-sidebar-opened">${translate("filters.filters")}<dss-icon-button @click=${() => props._toggleFilters()} size="md" variant="primary" icon="keyboard_double_arrow_left"></dss-icon-button></div><div class="filter-container">
-                  ${repeat(props.filters, (filter: IActivityHistoryFilter) => html`<div class="filter">${getFilterTemplate(props, filter)}</div> `)}
+          ? 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> `)}
+                  ${repeat(
+                    props.customFilterGroups,
+                    (group: IActivityHistoryCustomFilterGroup) => html`
+                  <div class="filter-group">
+                    <dss-input-switch size="sm" .checked=${group.enabled} @onChangeValue=${(e) => props._onChangeCustomFilterGroupValue(group.id, e.detail)}>
+                      <input slot="input" id="switch-${group.id}" aria-label=${group.title} type="checkbox">
+                      <label slot="label" for="switch-${group.id}">${group.title}</label>
+                    </dss-input-switch>
+                    ${
+                      group?.filters &&
+                      repeat(group.filters, (filter: IActivityHistoryCustomFilter) =>
+                        customFilterTemplate(filter, props, group),
+                      )
+                    }
+                  </div> `,
+                  )}
                 </div> `
           : html`<dss-icon-button @click=${() => props._toggleFilters()} size="md" variant="primary" icon="keyboard_double_arrow_right"></dss-icon-button>`
       }
   </div>
   `;
+
+const customFilterTemplate = (
+  filter: IActivityHistoryCustomFilter,
+  props: ActivityHistoryFilters,
+  group: IActivityHistoryCustomFilterGroup,
+) =>
+  html`
+    <div class="custom-filter">
+      ${
+        filter.singleOption
+          ? getFilterTemplate(filter, props._onChangeCustomFilterValue.bind(props), group)
+          : html`<div class="custom-filter-title">${filter.title}</div>
+                <div class="custom-filter-content">${repeat(filter.options, (option) => html`${getFilterTemplate(filter, props._onChangeCustomFilterValue.bind(props), group, option)}`)}</div>`
+      }
+      
+    </div>
+  `;

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

@@ -3,12 +3,30 @@ import "../../activity-history-item/filter/UI/activity-history-filters/activity-
 import {
   bootstrapSetCommonFilter,
   teardownSetCommonFilter,
-} from "./set-common-filter/bootstrapper";
+} from "./common-filters/set-common-filter/bootstrapper";
+import {
+  bootstrapAddCustomFilter,
+  teardownAddCustomFilter,
+} from "./custom-filters/add-custom-filters/bootstrapper";
+import {
+  bootstrapSetCustomFilterGroup,
+  teardownSetCustomFilterGroup,
+} from "./custom-filters/set-custom-filter-group/bootstrapper";
+import {
+  bootstrapSetCustomFilterValue,
+  teardownSetCustomFilterValue,
+} from "./custom-filters/set-custom-filter-value/bootstrapper";
 
 export const bootstrapFilters = (broker: BrokerExtensions) => {
   bootstrapSetCommonFilter(broker);
+  bootstrapAddCustomFilter(broker);
+  bootstrapSetCustomFilterGroup(broker);
+  bootstrapSetCustomFilterValue(broker);
 };
 
 export const teardownFilters = () => {
   teardownSetCommonFilter();
+  teardownAddCustomFilter();
+  teardownSetCustomFilterGroup();
+  teardownSetCustomFilterValue();
 };

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

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

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