@topconsultnpm/sdkui-react 6.22.0-dev2.2 → 6.22.0-dev2.21

package/lib/helper/dcmtsHelper.js

@@ -1,4 +1,21 @@
-import { RelationCacheService, RelationTypes, SDK_Globals } from "@topconsultnpm/sdk-ts";
+import { MetadataDataTypes, RelationCacheService, RelationTypes, SDK_Globals } from "@topconsultnpm/sdk-ts";
+import { formatDateTimeByMetadataFormat, formatNumberByMetadataFormat } from "./TMUtils";
+/** Metadati utente (esclusi quelli di sistema) del tipo documento, in ordine di visualizzazione */
+export const getUserMetadataSorted = (dtd) => {
+    return (dtd?.metadata ?? [])
+        .filter(md => md.id !== undefined && md.id > 100 && md.isSystem !== 1)
+        .sort((a, b) => (a.ordinalPosition ?? 0) - (b.ordinalPosition ?? 0));
+};
+/** Formatta un valore scalare (non lista dati): date e numeri rispettano Format e FormatCulture del metadato */
+export const formatScalarValue = (value, dataType, format, formatCulture) => {
+    if (value === undefined || value === null || value === '')
+        return '';
+    switch (dataType) {
+        case MetadataDataTypes.DateTime: return formatDateTimeByMetadataFormat(value instanceof Date ? value : new Date(value), format, formatCulture);
+        case MetadataDataTypes.Number: return formatNumberByMetadataFormat(value, format, formatCulture ?? window.navigator.language);
+        default: return String(value);
+    }
+};
 /** Check if dcmtType (mTID) has configured Detail or Many-to-Many relations */
 export const hasDetailRelations = async (mTID) => {
     let allRelations = await RelationCacheService.GetAllAsync();
@@ -13,6 +30,46 @@ export const hasMasterRelations = async (mTID) => {
     let rdlManyToMany = allRelations?.filter(o => o.relationType == RelationTypes.ManyToMany && (o.masterTID == mTID || o.detailTID == mTID)) ?? [];
     return rdlManyToMany.length > 0 || rdlOneToMany.length > 0;
 };
+// Legge i metadati di un documento
+export const getDcmtMetadataByMid = async (dcmt) => {
+    const metadataMap = new Map();
+    if (!dcmt?.TID || !dcmt?.DID)
+        return metadataMap; // Documento non identificabile: mappa vuota
+    const searchEngine = SDK_Globals.tmSession?.NewSearchEngine();
+    if (!searchEngine)
+        return metadataMap; // Nessuna sessione attiva: mappa vuota
+    const allMetadata = await searchEngine.GetMetadataAsync(dcmt.TID, dcmt.DID, false);
+    const row = allMetadata?.dtdResult?.rows?.[0]; // Prima (e unica) riga = il documento richiesto
+    const mids = allMetadata?.selectMIDs; // MID nello stesso ordine dei valori di riga
+    if (row && mids)
+        mids.forEach((mid, index) => metadataMap.set(mid, row[index])); // Accoppia mid -> valore per posizione
+    return metadataMap;
+};
+// Mappa le associazioni della relazione nei MID di destinazione, usando i metadati sorgente già letti.
+// 'detail' = archivio dettagli dal master (sorgente item1 -> destinazione item2); 'master' = archivio master dal dettaglio (item2 -> item1).
+// Emette una voce per ogni associazione, anche vuota, per coprire tutti i collegamenti.
+export const mapAssociationsFromMetadata = (relation, type, metadataByMid) => {
+    if (!relation.associations || relation.associations.length === 0)
+        return []; // Relazione senza collegamenti
+    return relation.associations.map(assoc => {
+        const sourceMid = type === 'detail' ? (assoc.item1 ?? 0) : (assoc.item2 ?? 0); // MID da cui leggere il valore
+        const targetMid = type === 'detail' ? (assoc.item2 ?? 0) : (assoc.item1 ?? 0); // MID da valorizzare
+        const value = metadataByMid.get(sourceMid); // Valore sorgente (può mancare)
+        return { mid: targetMid, value: value !== undefined && value !== null ? value.toString() : '' }; // Assente/null -> stringa vuota
+    });
+};
+// Legge il documento sorgente (master per 'detail', dettaglio per 'master') e mappa le associazioni nei MID di destinazione.
+// Per letture ripetute dello stesso documento, riusare la mappa e chiamare direttamente `mapAssociationsFromMetadata`.
+export const mapRelationAssociationsToMids = async (relation, type, dcmt) => {
+    if (!relation.associations || relation.associations.length === 0)
+        return []; // Relazione senza collegamenti
+    if (!dcmt?.TID || !dcmt?.DID)
+        return []; // Documento sorgente non identificabile
+    const metadataByMid = await getDcmtMetadataByMid(dcmt);
+    if (metadataByMid.size === 0)
+        return []; // Nessun metadato leggibile: [] come nel flusso originale (niente collegamenti a vuoto)
+    return mapAssociationsFromMetadata(relation, type, metadataByMid);
+};
 export const isXMLFileExt = (fileExt) => {
     const fileExtension = fileExt?.toLowerCase() ?? '';
     switch (fileExtension) {

package/lib/helper/helpers.d.ts

@@ -2,6 +2,15 @@ import { Colors as ColorsType } from "../components/base/TMEditorBase";
 import { DeviceType } from "../components";
 import { AppModules, DataColumnDescriptor, DcmtTypeDescriptor, ITopMediaSession, MetadataDescriptor, QueryDescriptor, SearchResultDescriptor, TaskDescriptor } from "@topconsultnpm/sdk-ts";
 import { FileExtensionHandler, FormModes, moduleTypes } from "../ts";
+import React from "react";
+/**
+ * Handler di hover per elementi con stili inline: applica `over` all'ingresso del mouse e `out` all'uscita.
+ * Da spandere sull'elemento: `{...hoverStyle({ background: 'red' }, { background: 'transparent' })}`
+ */
+export declare const hoverStyle: (over: React.CSSProperties, out: React.CSSProperties) => {
+    onMouseEnter: (e: React.MouseEvent<HTMLElement>) => CSSStyleDeclaration & React.CSSProperties;
+    onMouseLeave: (e: React.MouseEvent<HTMLElement>) => CSSStyleDeclaration & React.CSSProperties;
+};
 declare const calcResponsiveSizes: (deviceType: DeviceType | undefined, desktopSize: string, tabletSize: string, mobileSize: string) => string;
 declare const taskModalSizes: (deviceType: DeviceType | undefined, formMode: FormModes) => {
     width: string;
@@ -35,6 +44,17 @@ export declare const getDataColumnName: (fromTID: number | undefined, dtColumn:
  */
 export declare const generateUniqueColumnKeys: (columns: DataColumnDescriptor[] | undefined, fromTID: number | undefined) => string[];
 export declare const searchResultDescriptorToSimpleArray: (searchResult: SearchResultDescriptor | undefined) => any[] | undefined;
+/**
+ * Unisce ("accoda") il risultato di una nuova ricerca a quello precedente, sullo stesso tipo documento.
+ * - Le righe della nuova ricerca vengono messe in cima (più recenti in alto)
+ * - Le righe duplicate sono accettate: lo stesso documento può comparire più volte
+ * - Aggiorna i contatori globali (dcmtsFound / dcmtsReturned) sul totale unito
+ *
+ * @param previous Risultato attualmente in memoria (può essere undefined al primo giro)
+ * @param next Nuovo risultato appena ottenuto
+ * @returns Un nuovo SearchResultDescriptor con le righe unite, oppure il singolo risultato disponibile
+ */
+export declare const mergeSearchResultsAppend: (previous: SearchResultDescriptor | undefined, next: SearchResultDescriptor | undefined) => SearchResultDescriptor | undefined;
 export declare const getCompleteMetadataName: (dcmtTypeName: string | undefined, metadataName: string | undefined) => string;
 export declare const getQueryCountAsync: (qd: QueryDescriptor, showSpinner: boolean) => Promise<void>;
 export declare function getTIDByMID(mid: number | undefined, defaultTid?: number): number;

package/lib/helper/helpers.js

@@ -7,6 +7,14 @@ import { buildTypes, FileExtensionHandler, FormModes, moduleTypes } from "../ts"
 import { SDKUI_Localizator } from "./SDKUI_Localizator";
 import ReactDOMServer from "react-dom/server";
 import { DeepCompareHelper } from "./DeepCompareHelper";
+/**
+ * Handler di hover per elementi con stili inline: applica `over` all'ingresso del mouse e `out` all'uscita.
+ * Da spandere sull'elemento: `{...hoverStyle({ background: 'red' }, { background: 'transparent' })}`
+ */
+export const hoverStyle = (over, out) => ({
+    onMouseEnter: (e) => Object.assign(e.currentTarget.style, over),
+    onMouseLeave: (e) => Object.assign(e.currentTarget.style, out),
+});
 const calcResponsiveSizes = (deviceType, desktopSize, tabletSize, mobileSize) => {
     if (deviceType === DeviceType.DESKTOP)
         return desktopSize;
@@ -239,6 +247,38 @@ export const searchResultDescriptorToSimpleArray = (searchResult) => {
     });
     return result;
 };
+/**
+ * Unisce ("accoda") il risultato di una nuova ricerca a quello precedente, sullo stesso tipo documento.
+ * - Le righe della nuova ricerca vengono messe in cima (più recenti in alto)
+ * - Le righe duplicate sono accettate: lo stesso documento può comparire più volte
+ * - Aggiorna i contatori globali (dcmtsFound / dcmtsReturned) sul totale unito
+ *
+ * @param previous Risultato attualmente in memoria (può essere undefined al primo giro)
+ * @param next Nuovo risultato appena ottenuto
+ * @returns Un nuovo SearchResultDescriptor con le righe unite, oppure il singolo risultato disponibile
+ */
+export const mergeSearchResultsAppend = (previous, next) => {
+    // Se manca uno dei due, non c'è nulla da unire
+    if (!next?.dtdResult?.rows?.length)
+        return previous;
+    if (!previous?.dtdResult?.rows?.length)
+        return next;
+    // L'accodamento ha senso solo sullo stesso tipo documento (colonne compatibili)
+    if (previous.fromTID !== next.fromTID)
+        return next;
+    const prevRows = previous.dtdResult.rows ?? [];
+    const nextRows = next.dtdResult.rows ?? [];
+    // Nessuna deduplica: le nuove righe in cima, poi le precedenti (i duplicati sono ammessi)
+    const mergedRows = [...nextRows, ...prevRows];
+    // Costruisce il nuovo descrittore basandosi sull'ultimo risultato (colonne/qd più recenti), con le righe unite
+    const merged = structuredClone(next);
+    const mergedDtd = structuredClone(next.dtdResult);
+    mergedDtd.rows = mergedRows;
+    merged.dtdResult = mergedDtd;
+    merged.dcmtsReturned = mergedRows.length;
+    merged.dcmtsFound = mergedRows.length;
+    return merged;
+};
 export const getCompleteMetadataName = (dcmtTypeName, metadataName) => `${dcmtTypeName}...${metadataName}`;
 export const getQueryCountAsync = async (qd, showSpinner) => {
     try {

package/lib/helper/index.d.ts

@@ -5,6 +5,7 @@ export * from './Globalization';
 export * from './TMIcons';
 export * from './TMImageLibrary';
 export * from './helpers';
+export * from './dataGridSearchHelper';
 export * from './queryHelper';
 export * from './TMUtils';
 export * from './TMCommandsContextMenu';

package/lib/helper/index.js

@@ -5,6 +5,7 @@ export * from './Globalization';
 export * from './TMIcons';
 export * from './TMImageLibrary';
 export * from './helpers';
+export * from './dataGridSearchHelper';
 export * from './queryHelper';
 export * from './TMUtils';
 export * from './TMCommandsContextMenu';

package/lib/helper/queryHelper.d.ts

@@ -14,6 +14,8 @@ export declare function addWhereClausesForConnect(qd: QueryDescriptor): void;
 export declare function getDefaultOperator(dataDomain: MetadataDataDomains | undefined, dataType: MetadataDataTypes | undefined): QueryOperators.Equal | QueryOperators.Contain | QueryOperators.In;
 export declare const getQD: (tid: number | undefined, easyOr: boolean, newMaxDcmtsToBeReturned: number) => Promise<QueryDescriptor | undefined>;
 export declare const getWorkItemSetIDAsync: (vid: number, did: number) => Promise<string | undefined>;
+/** Id assegnato alla ricerca di sistema con tutti i documenti: non è in cache, va ricostruita a runtime con getSysAllDcmtsSQD */
+export declare const SYS_ALL_DCMTS_SQD_ID = 1;
 export declare const getSysAllDcmtsSQD: (tid: number | undefined, easyOr: boolean) => Promise<SavedQueryDescriptor>;
 export declare const searchResultToMetadataValues: (tid: number | undefined, dtd: DataTableDescriptor | undefined, rows: string[], mids: number[], metadata: MetadataDescriptor[], layoutMode: LayoutModes, isReadOnlyOrigin?: boolean) => MetadataValueDescriptorEx[];
 export declare const handleArchiveVisibility: (md: MetadataDescriptor) => boolean;

package/lib/helper/queryHelper.js

@@ -251,9 +251,11 @@ export const getWorkItemSetIDAsync = async (vid, did) => {
     let result = await SDK_Globals.tmSession?.NewSearchEngine().SearchByIDAsync(qd);
     return result?.dtdResult?.rows?.[0]?.[0];
 };
+/** Id assegnato alla ricerca di sistema con tutti i documenti: non è in cache, va ricostruita a runtime con getSysAllDcmtsSQD */
+export const SYS_ALL_DCMTS_SQD_ID = 1;
 export const getSysAllDcmtsSQD = async (tid, easyOr) => {
     let sqd = new SavedQueryDescriptor();
-    sqd.id = 1;
+    sqd.id = SYS_ALL_DCMTS_SQD_ID;
     sqd.masterTID = tid;
     sqd.isEasyWhere = 1;
     sqd.name = SDKUI_Localizator.AllDcmts;

package/lib/hooks/tmDistinctValuesGridHelper.d.ts

@@ -0,0 +1,16 @@
+import { DataColumnDescriptor, DataColumnTypes, MetadataDescriptor, MetadataFormats } from '@topconsultnpm/sdk-ts';
+/**
+ * Funzioni condivise dalle due sorgenti di TMDistinctValues (valori distinti e ricerca rapida):
+ * stanno fuori dagli hook perché non dipendono da alcuno stato.
+ */
+export declare const withRowIndex: <T>(rows: Array<T>) => T[];
+export declare const toGridDataType: (dataType: DataColumnTypes | undefined) => "string" | "number" | "datetime" | "boolean";
+export declare const getMetadataName: (columnMd: MetadataDescriptor | undefined) => string | undefined;
+export declare const getDateDisplayFormat: (format: MetadataFormats | undefined, formatCulture: string | undefined | null) => {
+    formatter: (value: string | number | Date) => string;
+};
+/**
+ * Risolve il MID della colonna di un risultato di ricerca: la proprietà estesa è la fonte principale,
+ * in mancanza resta l'allineamento posizionale tra selectMIDs e colonne del risultato.
+ */
+export declare const getColumnMid: (column: DataColumnDescriptor | undefined, selectMIDs: number[] | undefined, columnIndex: number) => number;

package/lib/hooks/tmDistinctValuesGridHelper.js

@@ -0,0 +1,31 @@
+import { DataColumnTypes, SDK_Globals } from '@topconsultnpm/sdk-ts';
+import { formatDateTimeByMetadataFormat } from '../helper';
+/**
+ * Funzioni condivise dalle due sorgenti di TMDistinctValues (valori distinti e ricerca rapida):
+ * stanno fuori dagli hook perché non dipendono da alcuno stato.
+ */
+// rowIndex è la chiave delle griglie di TMDistinctValues: va riallineato all'ordine finale delle righe
+export const withRowIndex = (rows) => {
+    rows.forEach((row, index) => { row.rowIndex = index; });
+    return rows;
+};
+export const toGridDataType = (dataType) => {
+    switch (dataType) {
+        case DataColumnTypes.DateTime: return 'datetime';
+        case DataColumnTypes.Bool: return 'boolean';
+        case DataColumnTypes.Number: return 'number';
+        default: return 'string';
+    }
+};
+// Nome del metadato con cui viene intestata la colonna, nella lingua scelta dall'utente
+export const getMetadataName = (columnMd) => (SDK_Globals.useLocalizedName ? columnMd?.nameLoc : columnMd?.name) ?? columnMd?.name ?? columnMd?.nameLoc ?? undefined;
+// Le date vanno mostrate con il formato definito sul metadato, come nel risultato di ricerca
+export const getDateDisplayFormat = (format, formatCulture) => ({
+    // La griglia passa al formatter un oggetto Date già istanziato, ma il valore può arrivare anche come stringa
+    formatter: (value) => formatDateTimeByMetadataFormat(value instanceof Date ? value : new Date(value), format, formatCulture)
+});
+/**
+ * Risolve il MID della colonna di un risultato di ricerca: la proprietà estesa è la fonte principale,
+ * in mancanza resta l'allineamento posizionale tra selectMIDs e colonne del risultato.
+ */
+export const getColumnMid = (column, selectMIDs, columnIndex) => Number(column?.extendedProperties?.['MID'] ?? 0) || (selectMIDs?.[columnIndex] ?? 0);

package/lib/hooks/useArchiveListForm.d.ts

@@ -0,0 +1,39 @@
+import { MutableRefObject } from 'react';
+import { MetadataValueDescriptorEx } from '../ts';
+/** Modalità "aggiungi a elenco": il form non archivia a sistema, restituisce i metadati al chiamante (TMMultiMasterDetailDcmts). */
+export interface ArchiveListMode {
+    /** true quando si modifica una riga già presente nell'elenco ("Modifica" al posto di "Aggiungi"). */
+    isEditingRow: boolean;
+    /** Restituisce metadati e file al chiamante, che aggiunge o aggiorna la riga nell'elenco (senza archiviare). */
+    onUpsertRow: (metadataValues: Array<MetadataValueDescriptorEx>, file: File | undefined, tid?: number) => void;
+}
+interface UseArchiveListFormParams {
+    /** Assente = modalità "aggiungi a elenco" spenta. */
+    mode?: ArchiveListMode;
+    /** Valori della riga in modifica, con cui pre-compilare il form. */
+    editingRowValues?: Array<{
+        mid: number;
+        value: string;
+    }>;
+    /** Template vuoto del form. */
+    formDataOrig: Array<MetadataValueDescriptorEx>;
+    /** Ref ai valori correnti del form (per leggerli al submit senza stale closure). */
+    formDataRef: MutableRefObject<Array<MetadataValueDescriptorEx>>;
+    /** Ref al file caricato. */
+    dcmtFileRef: MutableRefObject<File | null>;
+    tid?: number;
+    isModal?: boolean;
+    /** Id del form, usato come parentId del message box quando è in modale. */
+    id?: string;
+    /** Svuota il form dopo aver restituito i valori. */
+    clearForm: () => void;
+}
+/** Isola la logica della modalità "aggiungi a elenco": valori di riferimento, submit e chiusura del form. */
+export declare const useArchiveListForm: ({ mode, editingRowValues, formDataOrig, formDataRef, dcmtFileRef, tid, isModal, id, clearForm, }: UseArchiveListFormParams) => {
+    enabled: boolean;
+    isEditingRow: boolean;
+    referenceValues: MetadataValueDescriptorEx[];
+    submit: () => void;
+    requestClose: (isModified: boolean, onClose?: () => void) => boolean;
+};
+export {};

package/lib/hooks/useArchiveListForm.js

@@ -0,0 +1,46 @@
+import { useCallback, useMemo } from 'react';
+import { ButtonNames, TMMessageBoxManager } from '../components';
+/** Isola la logica della modalità "aggiungi a elenco": valori di riferimento, submit e chiusura del form. */
+export const useArchiveListForm = ({ mode, editingRowValues, formDataOrig, formDataRef, dcmtFileRef, tid, isModal, id, clearForm, }) => {
+    const enabled = !!mode;
+    const isEditingRow = !!mode?.isEditingRow;
+    // Valori con cui si confronta il form per capire cosa è cambiato (flag "modificato" ed evidenza gialla).
+    // Modificando una riga si parte dai suoi valori, così i campi pre-compilati non risultano subito modificati.
+    const referenceValues = useMemo(() => {
+        if (!isEditingRow || !editingRowValues || editingRowValues.length === 0)
+            return formDataOrig;
+        return formDataOrig.map(md => {
+            const rowValue = editingRowValues.find(rv => rv.mid === md.mid);
+            return rowValue ? { ...md, value: rowValue.value } : md;
+        });
+    }, [isEditingRow, editingRowValues, formDataOrig]);
+    // Restituisce metadati e file al chiamante, poi svuota il form.
+    const submit = useCallback(() => {
+        if (!mode)
+            return;
+        const values = formDataRef.current.filter(md => md.mid !== undefined && md.mid > 99);
+        mode.onUpsertRow(values, dcmtFileRef.current ?? undefined, tid);
+        clearForm();
+    }, [mode, formDataRef, dcmtFileRef, tid, clearForm]);
+    // Gestisce la chiusura del form
+    const requestClose = useCallback((isModified, onClose) => {
+        if (!mode)
+            return false;
+        if (!isModified) {
+            onClose?.();
+            return true;
+        }
+        TMMessageBoxManager.show({
+            parentId: isModal ? "TMDcmtFormShowConfirmForClose-" + id : undefined,
+            message: "Chiudendo, le modifiche andranno perse. Proseguire?",
+            buttons: [ButtonNames.YES, ButtonNames.NO],
+            onButtonClick: (e) => {
+                // Sì: scarta le modifiche e chiude senza aggiungere all'elenco. No: resta sul form.
+                if (e == ButtonNames.YES)
+                    onClose?.();
+            }
+        });
+        return true;
+    }, [mode, isModal, id]);
+    return { enabled, isEditingRow, referenceValues, submit, requestClose };
+};

package/lib/hooks/useCaseFlowApprove.d.ts

@@ -0,0 +1,56 @@
+import { CaseFlowInstanceDescriptor, CaseFlowWorkItem } from '@topconsultnpm/sdk-ts';
+/**
+ * Attività (workitem) delle PRATICHE assegnate all'utente, con il documento su
+ * cui lavorano già risolto.
+ *
+ * Gemello di `useWorkflowApprove` per il modulo CaseFlow: i dati stanno in una
+ * cache di modulo e le istanze del hook si sincronizzano con un evento, così il
+ * form del documento — da qualunque punto venga aperto — sa che su quel TID/DID
+ * c'è una firma da fare o un'approvazione da dare, senza che il chiamante debba
+ * passargli nulla.
+ */
+/** Workitem di pratica già risolto sul documento cui si riferisce. */
+export interface CaseFlowDcmtWorkItem {
+    caseflow: CaseFlowInstanceDescriptor;
+    workItem: CaseFlowWorkItem;
+    tid: number;
+    did: number;
+}
+/**
+ * Ricarica i workitem di pratica dell'utente. Con `force` ignora la finestra
+ * anti-raffica (da usare dopo un'operazione che li ha modificati).
+ */
+export declare const refreshCaseFlowApproveData: (force?: boolean) => Promise<void>;
+/**
+ * Workitem di pratica pendenti su quel documento (lettura sincrona dalla cache).
+ *
+ * TID/DID vanno NORMALIZZATI: pur essendo tipati `number`, arrivano come stringhe
+ * quando il documento è aperto da una griglia (righe di datagrid) — per lo stesso
+ * motivo il resto della libreria fa `Number(TID)`/`Number(DID)` in ogni confronto.
+ * Senza normalizzazione il confronto stretto falliva, e l'attività risultava
+ * assente aprendo il documento dalla ricerca mentre compariva dal widget "Per te".
+ */
+export declare const getCaseFlowWorkItemsByDcmt: (tid?: number | string, did?: number | string) => CaseFlowDcmtWorkItem[];
+/** Svuota la cache (logout / cambio archivio). */
+export declare const clearCaseFlowApproveData: () => void;
+/** Completa il workitem di pratica e ricarica la cache. */
+export declare const completeCaseFlowWorkItem: (item: CaseFlowDcmtWorkItem, comment?: string) => Promise<void>;
+/** Rifiuta il workitem di pratica (motivo obbligatorio) e ricarica la cache. */
+export declare const rejectCaseFlowWorkItem: (item: CaseFlowDcmtWorkItem, reason: string) => Promise<void>;
+/**
+ * Completa l'attività di FIRMA di una pratica sul documento indicato, se esiste.
+ * La chiama il viewer di firma quando la firma è riuscita: è il gemello di quanto
+ * già avviene per i workitem del workflow legacy.
+ * @returns true se un'attività è stata completata.
+ */
+export declare const completeCaseFlowSignatureForDcmt: (tid: number | string, did: number | string, comment?: string) => Promise<boolean>;
+/**
+ * Attività di pratica sul documento indicato. Senza sessione o senza attività
+ * l'elenco è vuoto e nulla cambia nella UI.
+ */
+export declare const useCaseFlowApprove: (tid?: number | string, did?: number | string) => {
+    caseFlowWorkItems: CaseFlowDcmtWorkItem[];
+    refreshCaseFlowApprove: (force?: boolean) => Promise<void>;
+    completeCaseFlowWorkItem: (item: CaseFlowDcmtWorkItem, comment?: string) => Promise<void>;
+    rejectCaseFlowWorkItem: (item: CaseFlowDcmtWorkItem, reason: string) => Promise<void>;
+};

package/lib/hooks/useCaseFlowApprove.js

@@ -0,0 +1,157 @@
+import { useCallback, useEffect, useState } from 'react';
+import { SDK_Globals } from '@topconsultnpm/sdk-ts';
+import { CaseFlowService } from '../services/caseflow/CaseFlowService';
+import { getWorkItemTargetDoc, isMoreInfoWorkItem, isSignatureWorkItem } from '../services/caseflow/caseFlowWorkItemUtils';
+const CASEFLOW_APPROVE_CHANGED_EVENT = 'onCaseFlowApproveChange';
+let cache = [];
+let inFlight;
+let lastLoadedAt = 0;
+/**
+ * Finestra minima fra due ricariche: il form del documento chiede un refresh a
+ * ogni apertura e la lista è una scansione delle istanze, non una query puntuale.
+ */
+const MIN_RELOAD_INTERVAL_MS = 15000;
+const notifyChanged = () => {
+    if (typeof window === 'undefined')
+        return;
+    window.dispatchEvent(new CustomEvent(CASEFLOW_APPROVE_CHANGED_EVENT));
+};
+/**
+ * Ricarica la cache: i workitem pendenti dell'utente, risolti sul documento su
+ * cui lavorano. Le richieste di informazioni sono escluse (si rispondono nella
+ * pratica, non sul documento) come i workitem senza documento.
+ */
+const reload = async () => {
+    const userId = SDK_Globals.tmSession?.SessionDescr?.userID;
+    if (userId == null) {
+        cache = [];
+        return;
+    }
+    const groups = await CaseFlowService.getMyPendingWorkItems(userId);
+    const resolved = [];
+    for (const { caseflow, workItems } of groups) {
+        // Le richieste di informazioni si rispondono nella pratica, non sul documento.
+        const relevant = workItems.filter(wi => !isMoreInfoWorkItem(wi));
+        if (relevant.length === 0)
+            continue;
+        // Il TID dell'azione è autorato sul TEMPLATE e non materializzato
+        // sull'istanza: senza template risolto il documento non è calcolabile.
+        if (caseflow.cftid != null) {
+            await CaseFlowService.getTemplate(caseflow.cftid);
+        }
+        // I DOCUMENTI AGGANCIATI non arrivano dalla RetrieveAll (che porta solo i
+        // dati delle card): serve la Retrieve completa, altrimenti `dcmts` è vuoto
+        // e nessun workitem risulterebbe associato a un documento.
+        let instance = caseflow;
+        if ((instance.dcmts?.length ?? 0) === 0 && instance.id != null) {
+            instance = (await CaseFlowService.getCaseflow(instance.id, instance.cftid)) ?? instance;
+        }
+        for (const wi of relevant) {
+            const target = getWorkItemTargetDoc(instance, wi);
+            if (!target)
+                continue;
+            resolved.push({ caseflow: instance, workItem: wi, tid: target.tid, did: target.did });
+        }
+    }
+    cache = resolved;
+    lastLoadedAt = Date.now();
+    // Diagnostica del bring-up: se il Toppy non compare, qui si vede a che punto
+    // la catena si interrompe (nessun workitem / nessun documento risolto).
+    // Rimuovibile una volta stabilizzato il flusso.
+    console.debug('[CaseFlow] attività su documenti:', {
+        istanzeConPendenti: groups.length,
+        workItemPendenti: groups.reduce((n, g) => n + g.workItems.length, 0),
+        risolteSuDocumento: resolved.length,
+        documenti: resolved.map(r => `${r.tid}/${r.did}`),
+    });
+};
+/**
+ * Ricarica i workitem di pratica dell'utente. Con `force` ignora la finestra
+ * anti-raffica (da usare dopo un'operazione che li ha modificati).
+ */
+export const refreshCaseFlowApproveData = async (force = false) => {
+    if (inFlight)
+        return inFlight;
+    if (!force && lastLoadedAt > 0 && Date.now() - lastLoadedAt < MIN_RELOAD_INTERVAL_MS)
+        return;
+    inFlight = reload()
+        .catch(error => { console.error('Errore nel caricare le attività di pratica sui documenti', error); })
+        .finally(() => { inFlight = undefined; notifyChanged(); });
+    return inFlight;
+};
+/**
+ * Workitem di pratica pendenti su quel documento (lettura sincrona dalla cache).
+ *
+ * TID/DID vanno NORMALIZZATI: pur essendo tipati `number`, arrivano come stringhe
+ * quando il documento è aperto da una griglia (righe di datagrid) — per lo stesso
+ * motivo il resto della libreria fa `Number(TID)`/`Number(DID)` in ogni confronto.
+ * Senza normalizzazione il confronto stretto falliva, e l'attività risultava
+ * assente aprendo il documento dalla ricerca mentre compariva dal widget "Per te".
+ */
+export const getCaseFlowWorkItemsByDcmt = (tid, did) => {
+    const t = Number(tid);
+    const d = Number(did);
+    if (!Number.isFinite(t) || !Number.isFinite(d))
+        return [];
+    return cache.filter(r => Number(r.tid) === t && Number(r.did) === d);
+};
+/** Svuota la cache (logout / cambio archivio). */
+export const clearCaseFlowApproveData = () => {
+    cache = [];
+    lastLoadedAt = 0;
+    notifyChanged();
+};
+/** Completa il workitem di pratica e ricarica la cache. */
+export const completeCaseFlowWorkItem = async (item, comment) => {
+    if (item.caseflow.id == null || item.workItem.id == null)
+        return;
+    await CaseFlowService.completeWorkItem(item.caseflow.id, item.workItem.id, comment?.trim() || undefined);
+    await refreshCaseFlowApproveData(true);
+};
+/** Rifiuta il workitem di pratica (motivo obbligatorio) e ricarica la cache. */
+export const rejectCaseFlowWorkItem = async (item, reason) => {
+    if (item.caseflow.id == null || item.workItem.id == null)
+        return;
+    await CaseFlowService.rejectWorkItem(item.caseflow.id, item.workItem.id, reason);
+    await refreshCaseFlowApproveData(true);
+};
+/**
+ * Completa l'attività di FIRMA di una pratica sul documento indicato, se esiste.
+ * La chiama il viewer di firma quando la firma è riuscita: è il gemello di quanto
+ * già avviene per i workitem del workflow legacy.
+ * @returns true se un'attività è stata completata.
+ */
+export const completeCaseFlowSignatureForDcmt = async (tid, did, comment) => {
+    const target = getCaseFlowWorkItemsByDcmt(tid, did).find(r => isSignatureWorkItem(r.workItem));
+    if (!target)
+        return false;
+    await completeCaseFlowWorkItem(target, comment);
+    return true;
+};
+/**
+ * Attività di pratica sul documento indicato. Senza sessione o senza attività
+ * l'elenco è vuoto e nulla cambia nella UI.
+ */
+export const useCaseFlowApprove = (tid, did) => {
+    const readItems = useCallback(() => getCaseFlowWorkItemsByDcmt(tid, did), [tid, did]);
+    const [caseFlowWorkItems, setCaseFlowWorkItems] = useState(readItems);
+    useEffect(() => { setCaseFlowWorkItems(readItems()); }, [readItems]);
+    useEffect(() => {
+        const handleChange = () => setCaseFlowWorkItems(readItems());
+        window.addEventListener(CASEFLOW_APPROVE_CHANGED_EVENT, handleChange);
+        return () => window.removeEventListener(CASEFLOW_APPROVE_CHANGED_EVENT, handleChange);
+    }, [readItems]);
+    // All'apertura di un documento la cache può essere vecchia (attività assegnate
+    // dopo l'ultimo caricamento) o non ancora popolata.
+    useEffect(() => {
+        if (tid == null || did == null)
+            return;
+        void refreshCaseFlowApproveData();
+    }, [tid, did]);
+    return {
+        caseFlowWorkItems,
+        refreshCaseFlowApprove: refreshCaseFlowApproveData,
+        completeCaseFlowWorkItem,
+        rejectCaseFlowWorkItem,
+    };
+};

package/lib/hooks/useDataUserIdItem.d.ts

@@ -3,6 +3,7 @@ import { UserDescriptor } from '@topconsultnpm/sdk-ts';
 export declare const useDataUserIdItem: () => {
     loadUsersAsync: (userIDs: Set<number>) => Promise<void>;
     getUserItem: (userId: number) => UserDescriptor | undefined;
+    getCompleteUserName: (domain: string | undefined, name: string | undefined) => string | undefined;
     clearCache: () => void;
     hasUser: (userId: number) => boolean;
     usersCache: React.MutableRefObject<Map<number, UserDescriptor>>;

package/lib/hooks/useDataUserIdItem.js

@@ -90,6 +90,7 @@ export const useDataUserIdItem = () => {
     return {
         loadUsersAsync,
         getUserItem,
+        getCompleteUserName,
         clearCache,
         hasUser,
         usersCache: usersCacheRef,

package/lib/hooks/useDocumentOperations.d.ts

@@ -105,6 +105,7 @@ interface UseDocumentOperationsProps {
 }
 export interface UseDocumentOperationsResult {
     operationItems: Array<TMContextMenuItemProps>;
+    selectedDcmtInfos: Array<DcmtInfo>;
     renderFloatingBar: React.ReactNode;
     renderDcmtOperations: React.ReactNode;
     features: {
@@ -118,6 +119,7 @@ export interface UseDocumentOperationsResult {
         closeDcmtFormHandler: () => void;
         handleSignApprove: () => void;
         showSearchTMDatagrid: boolean;
+        showDcmtTypesSelection: boolean;
         showExportForm: boolean;
         checkoutInfo: UseCheckInOutOperationsReturn;
         relatedDocumentsInfo: UseRelatedDocumentsReturn;