@uxland/primary-shell 5.3.7 → 5.3.9

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,31 @@
+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) => typeof diag.codi === "string" && diag.codi.trim() !== "")
+    .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);
+    }
+  }
+}

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

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

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

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

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

@@ -35,9 +35,10 @@ export interface IActivityHistoryCustomFilterGroup {
   filters: IActivityHistoryCustomFilter[];
 }
 
-export type IActivityHistoryFilterGroup =
+export type IActivityHistoryFilter =
   | IActivityHistoryCommonFilterGroup
-  | IActivityHistoryCustomFilterGroup;
+  | IActivityHistoryCustomFilterGroup
+  | IActivityHistoryDiagnosticsFilter;
 
 export interface IActivityHistoryCustomFilter {
   id: string;
@@ -54,6 +55,22 @@ export interface IActivityHistoryCustomFilter {
   enabledValues?: string[];
 }
 
-export const isCommonFilterGroup = (group: IActivityHistoryFilterGroup) => group.id === "common";
-export const isNotCommonFilterGroup = (group: IActivityHistoryFilterGroup) =>
+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 interface IActivityHistoryDiagnosticsFilter {
+  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";

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

@@ -5,13 +5,15 @@ import { setCommonFilterValueReducer } from "./common-filters/set-common-filter/
 import { addCustomFiltersReducer } from "./custom-filters/add-custom-filters/reducer";
 import { setCustomFilterGroupValueReducer } from "./custom-filters/set-custom-filter-group/reducer";
 import { setCustomFilterValueReducer } from "./custom-filters/set-custom-filter-value/reducer";
-import { IActivityHistoryFilterGroup } from "./model";
+import { IActivityHistoryFilter } from "./model";
+import { addDiagnosticFiltersReducer } from "./diagnostic-filters/add/reducer";
+import { setDiagnosticFilterValuesReducer } from "./diagnostic-filters/set/reducer";
 
 export const activityHistoryFiltersSlice = createSlice({
   name: "activity-history-filters",
   initialState: {
     searchString: "",
-    filters: [...commonFilters] as IActivityHistoryFilterGroup[],
+    filters: [...commonFilters] as IActivityHistoryFilter[],
   },
   reducers: {
     setSearchString: setSearchStringReducer,
@@ -19,5 +21,7 @@ export const activityHistoryFiltersSlice = createSlice({
     addCustomFilters: addCustomFiltersReducer,
     setCustomFilterGroupValue: setCustomFilterGroupValueReducer,
     setCustomFilterValue: setCustomFilterValueReducer,
+    addDiagnosticFilters: addDiagnosticFiltersReducer,
+    setDiagnosticFilterValues: setDiagnosticFilterValuesReducer,
   },
 });

package/src/internal-plugins/activity-history/activity-history-item/list/UI/timeline/activity-history-timeline.ts

@@ -3,14 +3,11 @@ import { customElement } from "lit/decorators.js";
 import { connectedProperty } from "../../../../infrastructure/state/connected-property";
 import { IActivityHistoryGroup } from "../../../domain/model";
 import { activityHistorySearchStringSelector } from "../../../search/selectors";
-import {
-  isAnyCollectionLoadingWithoutAnyLoaded,
-  isSomeCollectionLoadedAndOtherLoading,
-} from "../../handle-busy/selectors";
 import { activityHistoryGroupedItems } from "../../../selectors";
 import styles from "./styles.css?inline";
 import { template } from "./template";
 import { unsafeHTML } from "lit/directives/unsafe-html.js";
+import { isAnyCollectionLoadingWithoutAnyLoaded, isSomeCollectionLoadedAndOtherLoading } from "../../../add/handle-busy/selectors";
 
 const createZIndexStyles = (max: number) => {
   let styles = "";

package/src/internal-plugins/activity-history/activity-history-item/list/UI/timeline/template.ts

@@ -25,6 +25,8 @@ export const template = (props: ActivityHistoryTimeline) => {
   }
   return html`
   <div class="container">
+    <activity-history-full-data-error></activity-history-full-data-error>
+    <activity-history-partial-data-error></activity-history-partial-data-error>
     ${
       props.historyGroups?.length > 0
         ? html`
@@ -32,7 +34,7 @@ export const template = (props: ActivityHistoryTimeline) => {
             ${virtualize({
               items: props.historyGroups,
               renderItem: (itemGroup: IActivityHistoryGroup, index: number) => html`
-                <div class="visit zIndex${props.historyGroups.length - index}" data-date=${ifDefined(itemGroup.items[0]?.date || itemGroup.subGroups[0]?.items[0]?.date)}>
+                <div class="visit zIndex${props.historyGroups.length - index}" data-date=${ifDefined(itemGroup?.items[0]?.date || itemGroup.subGroups[0]?.items[0]?.date)}>
                   ${visitHeaderTemplate(props, itemGroup.items[0] || itemGroup.subGroups[0]?.items[0])}
                   <div class="visit__items">
                     ${repeat(
@@ -111,11 +113,12 @@ const visitHeaderTemplate = (
 };
 
 const renderProfessionalValues = (props: ActivityHistoryTimeline, item: IActivityHistoryItem) => {
+  if(!item.professional) return nothing;
   const showRole = shouldShowRole(item);
   const professionalItems = [
     props.highlighted(item.professional.name),
     showRole ? props.highlighted(item.professional.role.description) : null,
-    props.highlighted(item.up.description) ?? props.highlighted(item.center.description),
+    props.highlighted(item.up.description),
     props.highlighted(item.professional.speciality.description),
     props.highlighted(item.service.description),
   ].filter(Boolean);

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

@@ -1,6 +1,9 @@
 import "./UI/timeline/activity-history-timeline";
 import "../filter/UI/active-filters-header/active-filters-header";
+import "../add/handle-error/history-full-data-error/component";
+import "../add/handle-error/history-partial-data-error/component";
+
 
 export const bootstrapListActivityHistoryItems = () => {
   () => null;
-};
+}