@topconsultnpm/sdkui-react 6.22.0-t1 → 6.22.0-t3

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/useCheckInOutOperations.d.ts

@@ -20,11 +20,5 @@ export interface UseCheckInOutOperationsReturn {
     copyCheckoutPathToClipboardCallback: (dcmt: DcmtInfo, filename: string) => void;
     handleCheckOutCallback: (dcmt: DcmtInfo, checkout: boolean, filename: string, downloadDcmtsAsync: (params: DownloadDcmtsAsyncParams) => Promise<void>, onRefreshAsync?: (tid: number | undefined, did: number | undefined, refreshUI?: boolean, metadataResult?: SearchResultDescriptor | null) => Promise<void>) => Promise<void>;
     handleCheckInCallback: (dcmt: DcmtInfo, checkoutDate?: string | null, onRefreshAsync?: (tid: number | undefined, did: number | undefined, refreshUI?: boolean, metadataResult?: SearchResultDescriptor | null) => Promise<void>) => Promise<void>;
-    showCicoWaitPanel: boolean;
-    cicoWaitPanelTitle: string;
-    showCicoPrimaryProgress: boolean;
-    cicoPrimaryProgressText: string;
-    cicoPrimaryProgressValue: number;
-    cicoPrimaryProgressMax: number;
 }
 export declare const useCheckInOutOperations: (props: UseCheckInOutOperationsProps) => UseCheckInOutOperationsReturn;

package/lib/hooks/useCheckInOutOperations.js

@@ -1,6 +1,6 @@
 import { useCallback, useMemo, useState } from 'react';
 import { cicoDownloadFilesCallback, dcmtsFileCachePreview, getCicoDownloadFileName, getExceptionMessage, removeDcmtsFileCache, renderCicoCheckInContent, SDKUI_Globals, SDKUI_Localizator, updateCicoCheckoutStorageItem, validateCicoFileName } from '../helper';
-import { ButtonNames, DeviceType, ShowAlert, TMMessageBoxManager, TMResultManager, useDeviceType } from '../components';
+import { ButtonNames, DeviceType, ShowAlert, TMMessageBoxManager, TMResultManager, TMWaitPanelManager, useDeviceType } from '../components';
 import { ResultTypes, SDK_Globals } from '@topconsultnpm/sdk-ts';
 let abortController = new AbortController();
 export const useCheckInOutOperations = (props) => {
@@ -18,18 +18,13 @@ export const useCheckInOutOperations = (props) => {
     const deviceType = useDeviceType();
     // This avoids unnecessary re-renders by only recalculating when deviceType changes.
     let isMobile = useMemo(() => { return deviceType === DeviceType.MOBILE; }, [deviceType]);
-    // State variable to control the visibility of the wait panel
-    const [showCicoWaitPanel, setShowCicoWaitPanel] = useState(false);
-    // State variable to store the title of the wait panel
-    const [cicoWaitPanelTitle, setCicoWaitPanelTitle] = useState('');
-    // State variable to control the visibility of the primary section of the wait panel
-    const [showCicoPrimaryProgress, setShowCicoPrimaryProgress] = useState(false);
-    // State variable to store the primary text of the wait panel
-    const [cicoPrimaryProgressText, setCicoPrimaryProgressText] = useState('');
-    // State variable to track the current value of the primary progress indicator in the wait panel
-    const [cicoPrimaryProgressValue, setCicoPrimaryProgressValue] = useState(0);
-    // State variable to define the maximum value for the primary progress indicator in the wait panel
-    const [cicoPrimaryProgressMax, setCicoPrimaryProgressMax] = useState(0);
+    // Check in e check out non riportano avanzamento: il pannello e' solo il "sto lavorando".
+    const showCicoWaitPanel = (title) => TMWaitPanelManager.show({
+        title,
+        showCounters: false,
+        cancelable: true,
+        onAbort: () => abortController.abort(),
+    });
     const showHistoryCallback = useCallback(() => {
         setShowHistory(true);
     }, []);
@@ -73,11 +68,9 @@ export const useCheckInOutOperations = (props) => {
                 if (e !== ButtonNames.YES)
                     return;
                 let result = [];
+                abortController = new AbortController();
+                const panel = showCicoWaitPanel(title);
                 try {
-                    setCicoWaitPanelTitle(title);
-                    setShowCicoWaitPanel(true);
-                    setShowCicoPrimaryProgress(true);
-                    abortController = new AbortController();
                     const ue = SDK_Globals.tmSession?.NewUpdateEngineByID();
                     if (!ue)
                         throw new Error("Update Engine not available");
@@ -113,10 +106,7 @@ export const useCheckInOutOperations = (props) => {
                     result.push({ rowIndex: 1, id1: dcmt.TID, id2: dcmt.DID, resultType: ResultTypes.ERROR, description: getExceptionMessage(error) });
                 }
                 finally {
-                    setCicoPrimaryProgressText('');
-                    setCicoPrimaryProgressMax(0);
-                    setCicoPrimaryProgressValue(0);
-                    setShowCicoWaitPanel(false);
+                    panel.close();
                     TMResultManager.show(result, title, "ID", undefined);
                 }
             }
@@ -158,13 +148,12 @@ export const useCheckInOutOperations = (props) => {
                 onButtonClick: async (e) => {
                     if (e !== ButtonNames.YES)
                         return;
-                    setCicoWaitPanelTitle('Check in');
-                    setShowCicoWaitPanel(true);
-                    setShowCicoPrimaryProgress(true);
                     abortController = new AbortController();
                     let result = [];
                     let i = 0;
                     if (dcmt.TID && dcmt.DID) {
+                        // Aperto qui e non prima: fuori da questo ramo nessuno lo chiuderebbe.
+                        const panel = showCicoWaitPanel('Check in');
                         try {
                             const ue = SDK_Globals.tmSession?.NewUpdateEngineByID();
                             if (ue) {
@@ -187,10 +176,7 @@ export const useCheckInOutOperations = (props) => {
                             result.push({ rowIndex: i, id1: i, id2: i, resultType: ResultTypes.ERROR, description: getExceptionMessage(err) });
                         }
                         finally {
-                            setCicoPrimaryProgressText('');
-                            setCicoPrimaryProgressMax(0);
-                            setCicoPrimaryProgressValue(0);
-                            setShowCicoWaitPanel(false);
+                            panel.close();
                             TMResultManager.show(result, 'Check in', "ID", undefined, SDKUI_Localizator.CheckInSuccessMessage, 6000);
                         }
                     }
@@ -211,11 +197,5 @@ export const useCheckInOutOperations = (props) => {
         copyCheckoutPathToClipboardCallback,
         handleCheckOutCallback,
         handleCheckInCallback,
-        showCicoWaitPanel,
-        cicoWaitPanelTitle,
-        showCicoPrimaryProgress,
-        cicoPrimaryProgressText,
-        cicoPrimaryProgressValue,
-        cicoPrimaryProgressMax,
     };
 };

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/useDcmtOperations.d.ts

@@ -26,19 +26,10 @@ export interface DownloadDcmtsAsyncParams {
     useInputFileName?: boolean;
 }
 export interface UseDcmtOperationsReturn {
-    abortController: AbortController;
-    showWaitPanel: boolean;
-    showPrimary: boolean;
-    waitPanelTitle: string;
-    waitPanelTextPrimary: string;
-    waitPanelValuePrimary: number;
-    waitPanelMaxValuePrimary: number;
-    showSecondary: boolean;
-    waitPanelTextSecondary: string;
-    waitPanelValueSecondary: number;
-    waitPanelMaxValueSecondary: number;
     downloadDcmtsAsync: (params: DownloadDcmtsAsyncParams) => Promise<void>;
-    getDcmtFileAsync: (inputDcmt: DcmtInfo | undefined, rfo: RetrieveFileOptions, operationTitle: string, keepWaitPanelPrimary: boolean, bypassCache?: boolean) => Promise<{
+    getDcmtFileAsync: (inputDcmt: DcmtInfo | undefined, rfo: RetrieveFileOptions, operationTitle: string, 
+    /** Ignorato: con un file solo il pannello ha una barra sola, quella dei byte. */
+    keepWaitPanelPrimary: boolean, bypassCache?: boolean) => Promise<{
         file: File | undefined;
         isFromCache: boolean;
     } | undefined>;