@uxland/primary-shell 5.4.6 → 5.5.0

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[]) {}
+}

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

@@ -1,11 +1,7 @@
 import { createSelector } from "@reduxjs/toolkit";
 import { RootState } from "../infrastructure/state/store";
 import { getUniqueObjects } from "../utils/get-unique-values-by-prop-path";
-import {
-  IActivityHistoryItem,
-  IActivityHistoryItemCollection,
-  TSearchActivityHistoryItemPredicate,
-} from "./domain/model";
+import { IActivityHistoryItem, IActivityHistoryItemCollection, TSearchActivityHistoryItemPredicate } from "./domain/model";
 import { CommonFilterSpec } from "./domain/specs/common-filter-spec";
 import { CustomFilterSpec } from "./domain/specs/custom-filter-spec";
 import { SearchStringSpec } from "./domain/specs/search-string-spec";
@@ -18,9 +14,10 @@ import { sortGroupsByMostRecentDate } from "./list/sort-history-items-by-date/so
 import { activityHistorySearchStringSelector } from "./search/selectors";
 import { diagnosticFilterEnabledValuesSelector } from "./filter/diagnostic-filters/selectors";
 import { DiagnosticCodeSpec } from "./domain/specs/diagnostics-filter-spec";
+import { upFilterEnabledValuesSelector } from "./filter/up-filters/selectors";
+import { UpFilterSpec } from "./domain/specs/up-filter-spec";
 
-export const activityHistoryCollectionsSelector = (state: RootState) =>
-  state.activityHistoryCollections.collections;
+export const activityHistoryCollectionsSelector = (state: RootState) => state.activityHistoryCollections.collections;
 
 const mapItemsWithMetadata = (
   items: IActivityHistoryItem[],
@@ -43,12 +40,7 @@ export const activityHistoryMappedItems = createSelector(
   activityHistoryCollectionsSelector,
   (collections: Record<string, IActivityHistoryItemCollection>) => {
     return Object.values(collections).flatMap((collection: IActivityHistoryItemCollection) => {
-      return mapItemsWithMetadata(
-        collection.items,
-        collection.componentFactory,
-        collection.id,
-        collection.searchPredicate,
-      );
+      return mapItemsWithMetadata(collection.items, collection.componentFactory, collection.id, collection.searchPredicate);
     });
   },
 );
@@ -56,10 +48,7 @@ export const activityHistoryMappedItems = createSelector(
 export const customFilterGroupsWithOptionsSelector = createSelector(
   activityHistoryCustomFilterGroupsSelector,
   activityHistoryCollectionsSelector,
-  (
-    filterGroups: IActivityHistoryCustomFilterGroup[],
-    collections: Record<string, IActivityHistoryItemCollection>,
-  ) => {
+  (filterGroups: IActivityHistoryCustomFilterGroup[], collections: Record<string, IActivityHistoryItemCollection>) => {
     const result = filterGroups.map((filterGroup: IActivityHistoryCustomFilterGroup) => {
       const collection = collections[filterGroup.id] as IActivityHistoryItemCollection;
       return {
@@ -69,12 +58,7 @@ export const customFilterGroupsWithOptionsSelector = createSelector(
             ...f,
             options:
               (!f.singleOption
-                ? getUniqueObjects<IActivityHistoryItem>(
-                    collection.items,
-                    f.propPathValue,
-                    f.propsPathDescription,
-                    f.title
-                  )
+                ? getUniqueObjects<IActivityHistoryItem>(collection.items, f.propPathValue, f.propsPathDescription, f.title)
                 : []) || [],
           };
         }),
@@ -90,12 +74,14 @@ export const activityHistoryGroupedItems = createSelector(
   activityHistoryCommonFiltersSelector,
   activityHistoryCustomFilterGroupsSelector,
   diagnosticFilterEnabledValuesSelector,
+  upFilterEnabledValuesSelector,
   (
     items: IActivityHistoryItem[],
     searchString: string,
     commonFilters: IActivityHistoryCommonFilter[],
     customFilters: IActivityHistoryCustomFilterGroup[],
     diagnosticFilterEnabledValues: string[],
+    upFilterEnabledValues: string[],
   ) => {
     const filteredItems = items.filter((item: IActivityHistoryItem) =>
       new SearchStringSpec(searchString, item.searchPredicate)
@@ -103,6 +89,7 @@ export const activityHistoryGroupedItems = createSelector(
         .and(new ComposedTypeSpec(customFilters))
         .and(new CustomFilterSpec(customFilters))
         .and(new DiagnosticCodeSpec(diagnosticFilterEnabledValues))
+        .and(new UpFilterSpec(upFilterEnabledValues))
         .isSatisfiedBy(item),
     );
 

package/src/internal-plugins/activity-history/utils/get-unique-values-by-prop-path.ts

@@ -13,7 +13,9 @@ export function getUniqueObjects<T>(
     const title = propPathDescription.reduce((acc, key) => acc?.[key], item);
 
     const isValidId = typeof id === "string" && id.trim() !== "";
-    const isValidTitle = typeof title === "string" && title.trim() !== "";
+
+    //Tret el trim del title pels casos de migració on arriben camps buits
+    const isValidTitle = typeof title === "string";
 
     if (isValidId && isValidTitle) {
       if (!map.has(id)) {

package/src/locales.ts

@@ -12,9 +12,7 @@ export const useLocalization = async (api: PrimariaApi) => {
 
 type LocaleKeys<T> = T extends object
   ? {
-      [K in keyof T]:
-        | `${K & string}`
-        | (T[K] extends object ? `${K & string}.${LocaleKeys<T[K]>}` : never);
+      [K in keyof T]: `${K & string}` | (T[K] extends object ? `${K & string}.${LocaleKeys<T[K]>}` : never);
     }[keyof T]
   : never;
 
@@ -43,12 +41,11 @@ export const locales = {
       },
       errors: {
         session: "Hi ha hagut un error amb la sessió. Siusplau, tanca i torna a obrir l'aplicació.",
-        invalidPatient:
-          "El pacient actual no és vàlid. Siusplau, tanca i torna a obrir l'aplicació.",
+        invalidPatient: "El pacient actual no és vàlid. Siusplau, tanca i torna a obrir l'aplicació.",
       },
       header: {
         workCenter: "Centre treball",
-        role: "Rol",
+        role: "Tipus de profesional",
         speciality: "Àmbit treball",
       },
       busyManager: {