@uxland/primary-shell 3.5.2 → 3.5.4

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/search-string-spec.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { IActivityHistoryItem, TSearchActivityHistoryItemPredicate } from "../model";
+import { SearchStringSpec } from "./search-string-spec";
+import { propContainsString } from "../../../utils/prop-contains-string";
+
+// Mocking the propContainsString function to simulate behavior
+vi.mock("../../../utils/prop-contains-string", () => ({
+  propContainsString: vi.fn(),
+}));
+
+describe("SearchStringSpec", () => {
+  let searchString: string;
+  let searchPredicate: TSearchActivityHistoryItemPredicate;
+  let item: IActivityHistoryItem;
+
+  beforeEach(() => {
+    // Default searchPredicate mock function
+    searchPredicate = vi.fn();
+
+    // Default mock item to test with
+    item = {
+      relevant: true,
+      professional: {
+        name: "John Doe",
+        speciality: { description: "Speciality1" },
+        role: { description: "Role1" },
+      },
+      center: { description: "Center1" },
+      service: { description: "Service1" },
+      diagnostics: [{ id: "123", description: "Diagnostic1" }],
+      up: { description: "Up1" },
+      ep: { description: "Ep1" },
+    } as IActivityHistoryItem;
+  });
+
+  it("should return true if searchString is empty or null", () => {
+    const spec = new SearchStringSpec("", searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(true); // should always return true
+  });
+
+  it("should return true if searchPredicate is satisfied", () => {
+    // Mock the searchPredicate to return true
+    searchPredicate.mockReturnValueOnce(true);
+    const spec = new SearchStringSpec("searchString", searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(true); // searchPredicate is true
+  });
+
+  it("should return false if searchPredicate is not satisfied", () => {
+    // Mock the searchPredicate to return false
+    searchPredicate.mockReturnValueOnce(false);
+    const spec = new SearchStringSpec("searchString", searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(false); // searchPredicate is false
+  });
+
+  it("should return true if any of the common fields match searchString", () => {
+    searchString = "Center1";
+
+    // Mocking propContainsString to return true if the center description matches
+    (propContainsString as vi.Mock).mockReturnValueOnce(true);
+    const spec = new SearchStringSpec(searchString, searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(true); // Center matches the searchString
+  });
+
+  it("should return false if no common fields or searchPredicate match", () => {
+    searchString = "nonexistent";
+
+    // Mocking propContainsString to return false for all fields
+    (propContainsString as vi.Mock).mockReturnValue(false);
+    const spec = new SearchStringSpec(searchString, searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(false); // No matches in common fields
+  });
+
+  it("should return true if searchString matches multiple fields", () => {
+    searchString = "John";
+
+    // Mocking propContainsString to return true for the professional name
+    (propContainsString as vi.Mock).mockReturnValueOnce(true);
+    const spec = new SearchStringSpec(searchString, searchPredicate);
+
+    expect(spec.isSatisfiedBy(item)).toBe(true); // Professional name matches
+  });
+
+  it("should call commonFieldsSearchPredicate and the searchPredicate with the correct arguments", () => {
+    searchString = "searchString";
+
+    // Mocking propContainsString
+    (propContainsString as vi.Mock).mockReturnValue(false); // simulating no matches in common fields
+    const spySearchPredicate = vi.fn();
+    const spec = new SearchStringSpec(searchString, spySearchPredicate);
+
+    // Simulate the searchPredicate call
+    spec.isSatisfiedBy(item);
+
+    // Verify the commonFieldsSearchPredicate is called
+    expect(propContainsString).toHaveBeenCalled();
+
+    // Verify the searchPredicate is called with the correct arguments
+    expect(spySearchPredicate).toHaveBeenCalledWith(searchString.toLowerCase(), item);
+  });
+});

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

@@ -0,0 +1,58 @@
+import { IActivityHistoryItem, TSearchActivityHistoryItemPredicate } from "../model";
+import { Spec } from "./spec";
+import { propContainsString } from "../../../utils/prop-contains-string";
+
+const commonFieldsSearchPredicate = (item: IActivityHistoryItem, searchString: string) => {
+  const professionalNameContainsSearchString =
+    item.professional?.name && propContainsString(item.professional?.name, searchString);
+  const centerNameContainsSearchString =
+    item.center.description && propContainsString(item.center.description, searchString);
+  const specialityNameContainsSearchString =
+    item.professional?.speciality.description &&
+    propContainsString(item.professional?.speciality.description, searchString);
+  const roleNameContainsSearchString =
+    item.professional?.role.description &&
+    propContainsString(item.professional?.role.description, searchString);
+  const serviceNameContainsSearchString =
+    item.service.description && propContainsString(item.service.description, searchString);
+  const diagnosticsMatch = item.diagnostics?.some(
+    (diagnostic) =>
+      propContainsString(diagnostic.id, searchString) ||
+      propContainsString(diagnostic.description, searchString),
+  );
+  return (
+    professionalNameContainsSearchString ||
+    centerNameContainsSearchString ||
+    specialityNameContainsSearchString ||
+    roleNameContainsSearchString ||
+    serviceNameContainsSearchString ||
+    diagnosticsMatch
+  );
+};
+
+export class SearchStringSpec extends Spec<IActivityHistoryItem> {
+  constructor(
+    public searchString: string,
+    public searchPredicate: TSearchActivityHistoryItemPredicate,
+  ) {
+    super();
+  }
+
+  isSatisfiedBy(context: IActivityHistoryItem): boolean {
+    // Si searchString está vacío o solo tiene espacios, no filtramos y devolvemos true
+    if (!this.searchString?.trim()) {
+      return true;
+    }
+
+    // Verificamos coincidencias en los campos comunes
+    const matchesCommonFields = commonFieldsSearchPredicate(context, this.searchString);
+
+    // Verificamos coincidencias con el searchPredicate
+    const matchesSearchPredicate = this.searchPredicate
+      ? this.searchPredicate(this.searchString.toLowerCase(), context)
+      : false;
+
+    // Aseguramos que siempre se retorne un valor booleano
+    return !!(matchesCommonFields || matchesSearchPredicate);
+  }
+}

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

@@ -0,0 +1,54 @@
+export interface ISpec<TContext> {
+  isSatisfiedBy(context: TContext): boolean;
+  and(spec: ISpec<TContext>): ISpec<TContext>;
+  or(spec: ISpec<TContext>): ISpec<TContext>;
+  not(): ISpec<TContext>;
+}
+
+
+export abstract class Spec<TContext> implements ISpec<TContext> {
+  abstract isSatisfiedBy(context: TContext): boolean;
+  and(spec: ISpec<TContext>): ISpec<TContext> {
+    return new AndSpec(this as unknown as ISpec<TContext>, spec);
+  }
+    or(spec: ISpec<TContext>): ISpec<TContext> {
+        return new OrSpec(this as unknown as ISpec<TContext>, spec);
+    }
+    not(): ISpec<TContext> {
+      return new NotSpec(this as unknown as ISpec<TContext>);
+    }
+}
+export class AndSpec<TContext> extends Spec<TContext> {
+  constructor(
+    private left: ISpec<TContext>,
+    private right: ISpec<TContext>,
+  ) {
+    super();
+  }
+  isSatisfiedBy(context: TContext): boolean {
+    return this.left.isSatisfiedBy(context) && this.right.isSatisfiedBy(context);
+  }
+}
+
+export class OrSpec<TContext> extends Spec<TContext> {
+  constructor(
+    private left: ISpec<TContext>,
+    private right: ISpec<TContext>,
+  ) {
+    super();
+  }
+
+  isSatisfiedBy(context: TContext): boolean {
+    return this.left.isSatisfiedBy(context) || this.right.isSatisfiedBy(context);
+  }
+}
+
+export class NotSpec<TContext> extends Spec<TContext> {
+  constructor(private spec: ISpec<TContext>) {
+    super();
+  }
+
+  isSatisfiedBy(context: TContext): boolean {
+    return !this.spec.isSatisfiedBy(context);
+  }
+}

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

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

package/src/internal-plugins/activity-history/{features → activity-history-item}/export-to-pdf/bootstrapper.ts

@@ -2,6 +2,7 @@ import { BrokerExtensions } from "plugins/core";
 import { ExportToPdfHandler } from "./handler";
 import { ExportPdf } from "./request";
 import { BrokerDisposableHandler } from "../../../../api/broker/primaria-broker";
+import "./export-pdf-modal/export-pdf-modal";
 
 let request: BrokerDisposableHandler;
 
@@ -9,6 +10,6 @@ export const bootstrapExportPdf = (broker: BrokerExtensions) => {
   request = broker.registerRequest(ExportPdf, ExportToPdfHandler);
 };
 
-export const teardownExportPdf = (broker: BrokerExtensions) => {
+export const teardownExportPdf = () => {
   request?.dispose();
 };

package/src/internal-plugins/activity-history/{components → activity-history-item/export-to-pdf}/export-pdf-modal/export-pdf-modal.ts

@@ -2,7 +2,7 @@ import { LitElement, css, html, unsafeCSS } from "lit";
 import { customElement, property } from "lit/decorators.js";
 import styles from "./export-pdf-modal.css?inline";
 import { template } from "./template";
-import { confirmMixin } from "../../../../index";
+import { confirmMixin } from "../../../../../UI/shared-components/primaria-interaction/confirm-mixin";
 
 @customElement("export-pdf-modal")
 export class ExportPdfModal extends confirmMixin(LitElement) {
@@ -49,7 +49,7 @@ export class ExportPdfModal extends confirmMixin(LitElement) {
   handleTest() {
     console.log(
       // this.selectedVisibilityLevelElement,
-      this.selectedPeriodDate
+      this.selectedPeriodDate,
     );
   }
 }

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

@@ -1,6 +1,6 @@
 import { html, nothing } from "lit";
 import { ExportPdfModal } from "./export-pdf-modal";
-import { translate } from "../../localization";
+import { translate } from "../../../localization";
 
 export const template = (props: ExportPdfModal) => {
   const { arrayElements, text } = props;
@@ -18,14 +18,14 @@ export const template = (props: ExportPdfModal) => {
               <div class="selector-options">
                 <dss-radio-button>
                   <input slot="input" id="radioButton1" type="radio" name="exportOption" @change=${() => {
-                  props.selectedRadioOption = "history";
+                    props.selectedRadioOption = "history";
                   }}>
                   <label slot="label" for="radioButton1">${translate("modal.allActivityHistory")}</label>
                 </dss-radio-button>
                 <dss-radio-button>
                   <input slot="input" id="radioButton2" type="radio" name="exportOption" @change=${() => {
-                  props.selectedRadioOption = "filters";
-                }}>
+                    props.selectedRadioOption = "filters";
+                  }}>
                   <label slot="label" for="radioButton2">${translate("modal.onlyAppliedFilters")}</label>
                 </dss-radio-button>
               </div>
@@ -37,7 +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. 
+                  }} helpText="Sense seleccionar data, s'aplicarà la de la primera entrada. 
                     Sense seleccionar data de fi, s'aplicarà la de l'última entrada.">
                     <label slot="label-range-start" for="myDatepickerRangeStart">${translate("modal.startDate")}</label>
                     <input slot="input-range-start" id="myDatepickerRangeStart" type="text" class="dss-input">

package/src/internal-plugins/activity-history/{features → activity-history-item}/export-to-pdf/handler.ts

@@ -1,10 +1,7 @@
-import { inject } from "inversify";
-import { TYPES } from "../../infrastructure/ioc/types";
-import { ExportPdfModal } from "../../components/export-pdf-modal/export-pdf-modal";
-import { PrimariaApi } from "../../../../api/api";
+import { ApiBaseHandler } from "../../infrastructure/base-handlers";
+import { ExportPdfModal } from "./export-pdf-modal/export-pdf-modal";
 
-export class ExportToPdfHandler {
-  constructor(@inject(TYPES.primaryApi) private api: PrimariaApi) {}
+export class ExportToPdfHandler extends ApiBaseHandler {
   async handle() {
     try {
       this.api.interactionManager.customConfirm({

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

@@ -0,0 +1,40 @@
+import { LitElement, css, html, unsafeCSS } from "lit";
+import { customElement, 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 styles from "./styles.css?inline";
+import { template } from "./template";
+import { activityHistoryCommonFiltersSelector } from "../../selectors";
+import { SetCommonFilter } from "../../set-common-filter/request";
+
+//@ts-ignore
+@customElement("activity-history-filters")
+export class ActivityHistoryFilters extends LitElement {
+  render() {
+    return html`${template(this)}`;
+  }
+
+  static styles = css`
+    ${unsafeCSS(styles)}
+  `;
+
+  @connectedProperty(activityHistoryCommonFiltersSelector)
+  filters: IActivityHistoryFilter[];
+
+  @lazyInject(TYPES.primaryApi)
+  api: PrimariaApi;
+
+  @state()
+  filtersExpanded = false;
+
+  _toggleFilters() {
+    this.filtersExpanded = !this.filtersExpanded;
+  }
+
+  _onChangeCommonFilterValue(filterId: string, value: boolean) {
+    this.api.broker.send(new SetCommonFilter({ id: filterId, enabled: value }));
+  }
+}

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

@@ -0,0 +1,39 @@
+.filters-sidebar {
+      padding: 8px 4px;
+      border-right: 1px solid rgb(189, 189, 189);
+      width: 56px;
+    height: 100%;
+    box-sizing: border-box;
+    display: flex;
+    flex-direction: column;
+    dss-icon-button{
+      align-self: center;
+    }
+      &[expanded] {
+        width: 296px;
+        .filters-sidebar-opened {
+          display: flex;
+          align-items: center;
+          justify-content: space-between;
+          padding-inline: 8px;
+          color: var(--color-neutral-900);
+          font-weight: 700;
+          font-size: 16px;
+          line-height: 24px;
+        }
+      }
+    }
+
+
+.filter-container{
+      display: flex;
+    flex-direction: column;
+    padding: 16px 8px 8px 8px;
+
+    
+}
+
+.filter-container .filter{
+  padding: 8px 0;
+      border-bottom: 1px solid var(--color-neutral-200);
+    }

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

@@ -0,0 +1,30 @@
+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 { 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>`;
+  }
+};
+
+export const template = (props: ActivityHistoryFilters) =>
+  html`
+  <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> `)}
+                </div> `
+          : html`<dss-icon-button @click=${() => props._toggleFilters()} size="md" variant="primary" icon="keyboard_double_arrow_right"></dss-icon-button>`
+      }
+  </div>
+  `;

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

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

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

@@ -0,0 +1,14 @@
+import { BrokerExtensions } from "@primaria/plugins-core";
+import "../../activity-history-item/filter/UI/activity-history-filters/activity-history-filters";
+import {
+  bootstrapSetCommonFilter,
+  teardownSetCommonFilter,
+} from "./set-common-filter/bootstrapper";
+
+export const bootstrapFilters = (broker: BrokerExtensions) => {
+  bootstrapSetCommonFilter(broker);
+};
+
+export const teardownFilters = () => {
+  teardownSetCommonFilter();
+};

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

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

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

@@ -0,0 +1,8 @@
+export enum ActivityHistoryFilterType {
+  Switch = "switch",
+}
+
+export enum ActivityHistoryFilterOperation {
+  And = "and",
+  Or = "or",
+}

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

@@ -0,0 +1,20 @@
+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 {
+  id: string;
+  title: string;
+  filters: IActivityHistoryFilter[];
+}
+
+export interface IActivityHistoryFilter {
+  id: string;
+  title: string;
+  spec: Constructor<Spec<IActivityHistoryItem>>;
+  enabled: boolean;
+  type: ActivityHistoryFilterType;
+  operation: ActivityHistoryFilterOperation;
+}

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

@@ -0,0 +1,28 @@
+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/set-common-filter/bootstrapper.ts

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

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

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

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

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

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

@@ -0,0 +1,27 @@
+import { createSlice } from "@reduxjs/toolkit";
+import { commonFilters } from "./common-filters";
+import { setSearchStringReducer } from "../search/reducer";
+
+export const activityHistoryFiltersSlice = createSlice({
+  name: "activity-history-filters",
+  initialState: {
+    searchString: "",
+    filters: [...commonFilters],
+  },
+  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;
+      });
+    },
+  },
+});