@uxland/primary-shell 5.3.6 → 5.3.8

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

@@ -14,6 +14,10 @@ import {
 import { translate } from "../../../../localization";
 import { virtualize } from "@lit-labs/virtualizer/virtualize.js";
 import { hasItemDivider, shouldShowRole } from "../../../domain/business-rules";
+import {
+  ActivityHistoryEntry,
+  mergeHistoryItemsAndSubgroups,
+} from "../../merge-history-items-and-subgroups/merge-history-items-and-subgroups";
 
 export const template = (props: ActivityHistoryTimeline) => {
   if (!props._hasUpdatedOnce) {
@@ -21,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,26 +38,41 @@ export const template = (props: ActivityHistoryTimeline) => {
                   ${visitHeaderTemplate(props, itemGroup.items[0] || itemGroup.subGroups[0]?.items[0])}
                   <div class="visit__items">
                     ${repeat(
-                      itemGroup.items,
-                      (item) => item.id,
-                      (item: IActivityHistoryItemWithComponent) =>
-                        html`<div class="item" ?has-divider=${hasItemDivider(item, itemGroup.items as IActivityHistoryItemWithComponent[])}>${item.component}</div> `,
-                    )}
-                    ${repeat(
-                      itemGroup.subGroups,
-                      (subGroup: IActivityHistorySubGroup) => html`
-                        <div class="diagnostics">
-                          ${diagnosticHeaderTemplate(subGroup.items[0])}
-                          <div class="diagnostics__items">
-                            ${repeat(
-                              subGroup.items,
-                              (item) => item.id,
-                              (item: IActivityHistoryItemWithComponent) =>
-                                html`<div class="item" ?has-divider=${hasItemDivider(item, subGroup.items as IActivityHistoryItemWithComponent[])}>${item?.component}</div>`,
-                            )}
-                          </div>
-                        </div>
-                      `,
+                      mergeHistoryItemsAndSubgroups(itemGroup),
+                      (entry) => (entry.type === "item" ? entry.item.id : entry.subGroup.id),
+                      (entry: ActivityHistoryEntry) => {
+                        if (entry.type === "item") {
+                          const item = entry.item;
+                          return html`
+                            <div
+                              class="item"
+                              ?has-divider=${hasItemDivider(item, itemGroup.items as IActivityHistoryItemWithComponent[])}
+                            >
+                              ${item.component}
+                            </div>
+                          `;
+                        }
+                        const subGroup = entry.subGroup;
+                        return html`
+                            <div class="diagnostics">
+                              ${diagnosticHeaderTemplate(subGroup.items[0])}
+                              <div class="diagnostics__items">
+                                ${repeat(
+                                  subGroup.items,
+                                  (item) => item.id,
+                                  (item: IActivityHistoryItemWithComponent) => html`
+                                    <div
+                                      class="item"
+                                      ?has-divider=${hasItemDivider(item, subGroup.items as IActivityHistoryItemWithComponent[])}
+                                    >
+                                      ${item.component}
+                                    </div>
+                                  `,
+                                )}
+                              </div>
+                            </div>
+                          `;
+                      },
                     )}
                   </div>
                 </div>
@@ -96,7 +117,7 @@ const renderProfessionalValues = (props: ActivityHistoryTimeline, item: IActivit
   const professionalItems = [
     props.highlighted(item.professional.name),
     showRole ? props.highlighted(item.professional.role.description) : null,
-    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;
-};
+}

package/src/internal-plugins/activity-history/activity-history-item/list/merge-history-items-and-subgroups/merge-history-items-and-subgroups.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from "vitest";
+import { mergeHistoryItemsAndSubgroups } from "./merge-history-items-and-subgroups";
+import {
+  IActivityHistoryGroup,
+  IActivityHistoryItemWithComponent,
+  IActivityHistorySubGroup,
+} from "../../domain/model";
+
+type RenderEntry =
+  | { type: "item"; date: Date; item: IActivityHistoryItemWithComponent }
+  | { type: "subGroup"; date: Date; subGroup: IActivityHistorySubGroup };
+
+describe("mergeHistoryItemsAndSubgroups", () => {
+  it("should sort only items by date descending", () => {
+    const group: IActivityHistoryGroup = {
+      id: "g1",
+      items: [
+        { id: "i1", date: "2025-05-05T10:00:00Z", component: "<div/>" },
+        { id: "i2", date: "2025-05-05T12:00:00Z", component: "<div/>" },
+        { id: "i3", date: "2025-05-05T08:00:00Z", component: "<div/>" },
+      ],
+      subGroups: [],
+    };
+
+    const result = mergeHistoryItemsAndSubgroups(group) as RenderEntry[];
+    const ids = result.map((e) => (e.type === "item" ? e.item.id : e.subGroup.id));
+
+    expect(ids).toEqual(["i2", "i1", "i3"]);
+  });
+
+  it("should sort only subGroups by their most recent item", () => {
+    const subGroupA: IActivityHistorySubGroup = {
+      id: "sgA",
+      items: [{ id: "a1", date: "2025-05-05T09:00:00Z", component: "<div/>" }],
+    };
+    const subGroupB: IActivityHistorySubGroup = {
+      id: "sgB",
+      items: [
+        { id: "b1", date: "2025-05-05T15:00:00Z", component: "<div/>" },
+        { id: "b2", date: "2025-05-05T14:00:00Z", component: "<div/>" },
+      ],
+    };
+    const group: IActivityHistoryGroup = {
+      id: "g2",
+      items: [],
+      subGroups: [subGroupA, subGroupB],
+    };
+
+    const result = mergeHistoryItemsAndSubgroups(group) as RenderEntry[];
+    const ids = result.map((e) => (e.type === "item" ? e.item.id : e.subGroup.id));
+
+    expect(ids).toEqual(["sgB", "sgA"]);
+  });
+
+  it("should interleave items and subGroups by date", () => {
+    const group: IActivityHistoryGroup = {
+      id: "g3",
+      items: [
+        { id: "i1", date: "2025-05-05T10:00:00Z", component: "<div/>" },
+        { id: "i2", date: "2025-05-05T14:00:00Z", component: "<div/>" },
+      ],
+      subGroups: [
+        {
+          id: "sg1",
+          items: [{ id: "s1", date: "2025-05-05T12:00:00Z", component: "<div/>" }],
+        },
+      ],
+    };
+
+    const result = mergeHistoryItemsAndSubgroups(group) as RenderEntry[];
+    const ids = result.map((e) => (e.type === "item" ? e.item.id : e.subGroup.id));
+
+    // Expected order: i2 (14:00), sg1 (12:00), i1 (10:00)
+    expect(ids).toEqual(["i2", "sg1", "i1"]);
+  });
+
+  it("should place subGroups without items at the end", () => {
+    const emptySubGroup: IActivityHistorySubGroup = {
+      id: "sgEmpty",
+      items: [],
+    };
+    const group: IActivityHistoryGroup = {
+      id: "g4",
+      items: [{ id: "i1", date: "2025-05-05T11:00:00Z", component: "<div/>" }],
+      subGroups: [emptySubGroup],
+    };
+
+    const result = mergeHistoryItemsAndSubgroups(group) as RenderEntry[];
+    const ids = result.map((e) => (e.type === "item" ? e.item.id : e.subGroup.id));
+
+    expect(ids).toEqual(["i1", "sgEmpty"]);
+  });
+});

package/src/internal-plugins/activity-history/activity-history-item/list/merge-history-items-and-subgroups/merge-history-items-and-subgroups.ts

@@ -0,0 +1,34 @@
+import {
+  IActivityHistoryGroup,
+  IActivityHistoryItemWithComponent,
+  IActivityHistorySubGroup,
+} from "../../domain/model";
+
+export type ActivityHistoryEntry =
+  | { type: "item"; date: Date; item: IActivityHistoryItemWithComponent }
+  | { type: "subGroup"; date: Date; subGroup: IActivityHistorySubGroup };
+
+export const mergeHistoryItemsAndSubgroups = (
+  group: IActivityHistoryGroup,
+): ActivityHistoryEntry[] => {
+  // 1. Prepara los items sueltos
+  const itemEntries: ActivityHistoryEntry[] = group.items.map((item) => ({
+    type: "item",
+    date: new Date(item.date),
+    item,
+  }));
+
+  // 2. Prepara los subGroups, usando la fecha del ítem más reciente de cada subgrupo
+  const subGroupEntries: ActivityHistoryEntry[] = group.subGroups.map((subGroup) => {
+    // Asumimos que subGroup.items ya está ordenado de más reciente a más antiguo
+    const mostRecent = subGroup.items.length ? new Date(subGroup.items[0].date) : new Date(0);
+    return {
+      type: "subGroup",
+      date: mostRecent,
+      subGroup,
+    };
+  });
+
+  // 3. Fusiona y ordena
+  return [...itemEntries, ...subGroupEntries].sort((a, b) => b.date.getTime() - a.date.getTime());
+};

package/src/internal-plugins/activity-history/activity-history-item/list/sort-history-items-by-date/sort-history-items-by-date.ts

@@ -1,47 +1,52 @@
 import { IActivityHistoryGroup } from "../../domain/model";
 
 export const sortGroupsByMostRecentDate = (arr: IActivityHistoryGroup[]) => {
-  // Helper function to get the most recent date from a list of items
-  const getMostRecentDate = (items) => {
+  // Helper: obtener la fecha más reciente de una lista de items
+  const getMostRecentDate = (items: { date: string }[]): Date => {
     return items.reduce((latest, item) => {
       const itemDate = new Date(item.date);
       return itemDate > latest ? itemDate : latest;
-    }, new Date(0)); // Default to an old date
+    }, new Date(0));
   };
 
-  // Helper function to sort items within each group or subgroup
-  const sortItemsByDate = (items) => {
-    return items.sort((a, b) => new Date(b.date) - new Date(a.date));
+  // Ordenar items de más reciente a más antiguo
+  const sortItemsByDate = (items: { date: string }[]) => {
+    return items.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
   };
 
-  // Function to get the most recent date from a group (considering its items and subgroups)
-  const getGroupMostRecentDate = (group) => {
-    let allDates = [];
-
-    // Collect dates from group items
-    if (group.items.length > 0) {
-      allDates.push(getMostRecentDate(group.items));
-    }
-
-    // Collect dates from subgroups items
-    group.subGroups.forEach((subGroup) => {
-      if (subGroup.items.length > 0) {
-        allDates.push(getMostRecentDate(subGroup.items));
-      }
-    });
+  // Obtener la fecha más reciente de un subgrupo
+  const getSubGroupMostRecentDate = (subGroup: { items: { date: string }[] }): Date => {
+    return getMostRecentDate(subGroup.items);
+  };
 
-    // Return the most recent date found in the group and subgroups
-    return allDates.length > 0 ? new Date(Math.max(...allDates)) : new Date(0);
+  // Obtener la fecha más reciente de un grupo (considerando sus items y subgroups)
+  const getGroupMostRecentDate = (group: IActivityHistoryGroup): Date => {
+    const itemDates = group.items.length > 0 ? [getMostRecentDate(group.items)] : [];
+    const subGroupDates = group.subGroups.map(getSubGroupMostRecentDate);
+    const allDates = [...itemDates, ...subGroupDates];
+    return allDates.length > 0
+      ? new Date(Math.max(...allDates.map((d) => d.getTime())))
+      : new Date(0);
   };
 
-  // Sort each group's items and subgroups' items by date
+  // Procesar cada grupo
   arr.forEach((group) => {
+    // Ordenar items del grupo
     group.items = sortItemsByDate(group.items);
+
+    // Ordenar items de cada subgrupo
     group.subGroups.forEach((subGroup) => {
       subGroup.items = sortItemsByDate(subGroup.items);
     });
+
+    // Ordenar subgrupos según el item más reciente en cada uno
+    group.subGroups.sort(
+      (a, b) => getSubGroupMostRecentDate(b).getTime() - getSubGroupMostRecentDate(a).getTime(),
+    );
   });
 
-  // Sort groups by the most recent date of their items and subgroups
-  return arr.sort((a, b) => getGroupMostRecentDate(b) - getGroupMostRecentDate(a));
+  // Finalmente, ordenar los grupos por su fecha más reciente
+  return arr.sort(
+    (a, b) => getGroupMostRecentDate(b).getTime() - getGroupMostRecentDate(a).getTime(),
+  );
 };

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

@@ -16,6 +16,8 @@ import { activityHistoryCustomFilterGroupsSelector } from "./filter/custom-filte
 import { groupActivityHistoryItems } from "./list/group-history-items/group-history-items";
 import { sortGroupsByMostRecentDate } from "./list/sort-history-items-by-date/sort-history-items-by-date";
 import { activityHistorySearchStringSelector } from "./search/selectors";
+import { diagnosticFilterEnabledValuesSelector } from "./filter/diagnostic-filters/selectors";
+import { DiagnosticCodeSpec } from "./domain/specs/diagnostics-filter-spec";
 
 export const activityHistoryCollectionsSelector = (state: RootState) =>
   state.activityHistoryCollections.collections;
@@ -86,17 +88,20 @@ export const activityHistoryGroupedItems = createSelector(
   activityHistorySearchStringSelector,
   activityHistoryCommonFiltersSelector,
   activityHistoryCustomFilterGroupsSelector,
+  diagnosticFilterEnabledValuesSelector,
   (
     items: IActivityHistoryItem[],
     searchString: string,
     commonFilters: IActivityHistoryCommonFilter[],
     customFilters: IActivityHistoryCustomFilterGroup[],
+    diagnosticFilterEnabledValues: string[],
   ) => {
     const filteredItems = items.filter((item: IActivityHistoryItem) =>
       new SearchStringSpec(searchString, item.searchPredicate)
         .and(new CommonFilterSpec(commonFilters))
         .and(new ComposedTypeSpec(customFilters))
         .and(new CustomFilterSpec(customFilters))
+        .and(new DiagnosticCodeSpec(diagnosticFilterEnabledValues))
         .isSatisfiedBy(item),
     );
 

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

@@ -6,16 +6,10 @@ import {
   IBusyHistoryItem,
   IErrorHistoryItem,
 } from "./domain/model";
-import {
-  addBusyHistoryItemReducer,
-  removeBusyHistoryItemReducer,
-} from "./list/handle-busy/reducers";
-import {
-  addErrorHistoryItemReducer,
-  removeErrorHistoryItemReducer,
-} from "./list/handle-error/reducers";
 import { removeActivityHistoryItemReducer } from "./remove/reducer";
 import { updateActivityHistoryItemReducer } from "./update/reducer";
+import { addBusyHistoryItemReducer, removeBusyHistoryItemReducer } from "./add/handle-busy/reducers";
+import { addErrorHistoryItemReducer, removeErrorHistoryItemReducer } from "./add/handle-error/reducers";
 
 export const activityHistoryCollectionsSlice = createSlice({
   name: "activity-history-collections",

package/src/internal-plugins/activity-history/localization.ts

@@ -86,6 +86,22 @@ export const locales = {
       chipHeader: {
         selection: "Selecció:",
       },
+      error: {
+        general: {
+          title: "Hi ha hagut un problema durant la càrrega de contingut. Actualitza la pàgina o torna-ho a provar més tard.",
+          refresh: "Actualitzar pàgina",
+          noInfo: "No hi ha informació disponible.", 
+        },
+        partial: {
+          title: "Hi ha hagut un problema i no s'ha pogut carregar les notes de tipus",
+          refresh: "Actualitzar",
+          limit: "Límit de clicks superat",
+        },
+        title: "Error en la càrrega",
+        viewDetails: "Veure detalls",
+        imageAlt: "Imatge d'error",
+        errorToRefresh: "Error en l'acció d'actualitzar la pàgina",
+      },
     },
   },
 };

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/list/handle-error/actions.d.ts

@@ -1,4 +0,0 @@
-export declare const addErrorHistoryItem: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
-    id: string;
-    message: string;
-}, "activity-history-collections/addErrorHistoryItem">, removeErrorHistoryItem: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "activity-history-collections/removeErrorHistoryItem">;