@topconsultnpm/sdkui-react 6.20.0-dev1.7 → 6.20.0-dev1.70

package/lib/hooks/useCheckInOutOperations.js

@@ -0,0 +1,223 @@
+import { useCallback, useState } from 'react';
+import { cicoDownloadFilesCallback, dcmtsFileCachePreview, getCicoDownloadFileName, getExceptionMessage, removeDcmtsFileCache, renderCicoCheckInContent, SDKUI_Globals, SDKUI_Localizator, updateCicoCheckoutStorageItem, validateCicoFileName } from '../helper';
+import { ButtonNames, ShowAlert, TMMessageBoxManager, TMResultManager } from '../components';
+import { ResultTypes, SDK_Globals } from '@topconsultnpm/sdk-ts';
+let abortController = new AbortController();
+export const useCheckInOutOperations = () => {
+    const [showHistory, setShowHistory] = useState(false);
+    // State to manage show history selected file
+    const [showCheckoutInformationForm, setShowCheckoutInformationForm] = useState(false);
+    // Stato per triggerare il refresh della preview dall'esterno
+    const [refreshPreviewTrigger, setRefreshPreviewTrigger] = useState(0);
+    // State to manage comment form
+    const [commentFormState, setCommentFormState] = useState({
+        removeAndEditAttachment: true,
+        show: false,
+        isRequired: false
+    });
+    // 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);
+    const showHistoryCallback = useCallback(() => {
+        setShowHistory(true);
+    }, []);
+    const hideHistoryCallback = useCallback(() => {
+        setShowHistory(false);
+    }, []);
+    const showCheckoutInformationFormCallback = useCallback(() => {
+        setShowCheckoutInformationForm(true);
+    }, []);
+    const hideCheckoutInformationFormCallback = useCallback(() => {
+        setShowCheckoutInformationForm(false);
+    }, []);
+    const triggerPreviewRefresh = useCallback(() => {
+        setRefreshPreviewTrigger(prev => prev + 1);
+    }, []);
+    const hideCommentFormCallback = useCallback(() => {
+        setCommentFormState(prev => ({ ...prev, show: false }));
+    }, []);
+    const copyCheckoutPathToClipboardCallback = (dcmt, filename) => {
+        const defaultCheckInOutFolder = SDKUI_Globals.userSettings.defaultCheckInOutFolder ?? "Download";
+        const wGSDraftCheckoutItemCurrentItems = [...SDKUI_Globals.userSettings.dcmtCheckoutInfo];
+        const existingItem = wGSDraftCheckoutItemCurrentItems.find((item) => item.TID === dcmt.TID.toString() && item.DID === dcmt.DID.toString());
+        const folder = existingItem && existingItem.checkoutFolder && existingItem.checkoutFolder !== "" ? existingItem.checkoutFolder : defaultCheckInOutFolder;
+        const name = existingItem?.checkoutName ?? getCicoDownloadFileName({ type: 'dcmtInfo', dcmtInfo: dcmt, originalFileName: filename }, true, false);
+        const textToCopy = folder ? `${folder}\\${name}` : name;
+        navigator.clipboard.writeText(textToCopy)
+            .then(() => {
+            ShowAlert({ message: SDKUI_Localizator.OperationSuccess, mode: 'success', duration: 5000, title: SDKUI_Localizator.CopyToClipboard });
+        })
+            .catch(err => {
+            ShowAlert({ message: err, mode: 'error', duration: 5000, title: SDKUI_Localizator.OperationResult });
+        });
+    };
+    const handleCheckOutCallback = async (dcmt, checkout, filename, downloadDcmtsAsync, refreshMetadataAsync, refreshFocusedDataRowAsync) => {
+        if (!dcmt)
+            throw new Error("Document info is required");
+        const title = checkout ? 'Check out' : SDKUI_Localizator.CancelCheckOut;
+        const msg = checkout ? SDKUI_Localizator.ExecuteCheckOutQuestion : SDKUI_Localizator.ExecuteCancelCheckOutQuestion;
+        TMMessageBoxManager.show({
+            title: title,
+            message: msg,
+            buttons: [ButtonNames.YES, ButtonNames.NO],
+            onButtonClick: async (e) => {
+                if (e !== ButtonNames.YES)
+                    return;
+                let result = [];
+                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");
+                    ue.TID = dcmt.TID;
+                    ue.DID = dcmt.DID;
+                    if (checkout) {
+                        await ue.CheckOutAsync()
+                            .then(async () => {
+                            await cicoDownloadFilesCallback([{ type: 'dcmtInfo', dcmtInfo: dcmt, originalFileName: filename }], true, downloadDcmtsAsync);
+                            result.push({ rowIndex: 1, id1: dcmt.TID, id2: dcmt.DID, description: SDKUI_Localizator.UpdateCompletedSuccessfully, resultType: ResultTypes.SUCCESS });
+                            await refreshMetadataAsync?.();
+                            await refreshFocusedDataRowAsync?.(dcmt.TID, dcmt.DID, true);
+                        })
+                            .catch((error) => {
+                            result.push({ rowIndex: 1, id1: dcmt.TID, id2: dcmt.DID, resultType: ResultTypes.ERROR, description: getExceptionMessage(error) });
+                            throw error;
+                        });
+                    }
+                    else {
+                        await ue.UndoCheckOutAsync()
+                            .then(async () => {
+                            result.push({ rowIndex: 1, id1: dcmt.TID, id2: dcmt.DID, description: SDKUI_Localizator.UpdateCompletedSuccessfully, resultType: ResultTypes.SUCCESS });
+                            // Remove the corresponding draft checkout item
+                            updateCicoCheckoutStorageItem({ TID: dcmt.TID.toString(), DID: dcmt.DID.toString(), checkoutFolder: "", checkoutName: "" }, "dcmtInfo", "remove");
+                            await refreshMetadataAsync?.();
+                            await refreshFocusedDataRowAsync?.(dcmt.TID, dcmt.DID, true);
+                        })
+                            .catch((error) => {
+                            result.push({ rowIndex: 0, id1: dcmt.TID, id2: dcmt.DID, resultType: ResultTypes.ERROR, description: getExceptionMessage(error) });
+                            throw error;
+                        });
+                    }
+                }
+                catch (error) {
+                    result.push({ rowIndex: 1, id1: dcmt.TID, id2: dcmt.DID, resultType: ResultTypes.ERROR, description: getExceptionMessage(error) });
+                }
+                finally {
+                    setCicoPrimaryProgressText('');
+                    setCicoPrimaryProgressMax(0);
+                    setCicoPrimaryProgressValue(0);
+                    setShowCicoWaitPanel(false);
+                    TMResultManager.show(result, title, "ID", undefined);
+                }
+            }
+        });
+    };
+    const triggerCommentOnFileAdd = (addedFiles) => {
+        if (addedFiles.length > 0) {
+            setCommentFormState({
+                show: true,
+                isRequired: true,
+                removeAndEditAttachment: false
+            });
+        }
+    };
+    const handleCheckInCallback = async (dcmt, refreshMetadataAsync, refreshFocusedDataRowAsync) => {
+        if (!dcmt)
+            throw new Error("Document info is required");
+        // Create a new file input element
+        const input = document.createElement("input");
+        // Set the input type to "file" to allow file selection
+        input.type = "file";
+        // Set the accepted file types (e.g., images, PDFs, etc.)
+        input.accept = "*/*";
+        // Enable the input to accept one file at once
+        input.multiple = false;
+        // Add an event listener for when the file selection changes
+        input.addEventListener('change', async (event) => {
+            const fileInput = event.target;
+            if (!fileInput.files || fileInput.files.length === 0)
+                return;
+            const file = fileInput.files[0];
+            const validateFileName = validateCicoFileName({ type: 'dcmtInfo', dcmtInfo: dcmt, originalFileName: dcmt.fileName ?? SDKUI_Localizator.SearchResult }, file.name);
+            TMMessageBoxManager.show({
+                resizable: true,
+                buttons: [ButtonNames.YES, ButtonNames.NO],
+                message: renderCicoCheckInContent({ type: 'dcmtInfo', dcmtInfo: dcmt, originalFileName: dcmt.fileName ?? SDKUI_Localizator.SearchResult }, file, validateFileName.isValid, validateFileName.validationResults),
+                title: "Check in",
+                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) {
+                        try {
+                            const ue = SDK_Globals.tmSession?.NewUpdateEngineByID();
+                            if (ue) {
+                                ue.TID = dcmt.TID;
+                                ue.DID = dcmt.DID;
+                                await ue.CheckInAsync(file, "", abortController.signal);
+                                // Remove the corresponding draft checkout item
+                                updateCicoCheckoutStorageItem({ TID: dcmt.TID.toString(), DID: dcmt.DID.toString(), checkoutFolder: "", checkoutName: "" }, "dcmtInfo", "remove");
+                                result.push({ rowIndex: i, id1: dcmt.DID, id2: dcmt.DID, description: SDKUI_Localizator.UpdateCompletedSuccessfully, resultType: ResultTypes.SUCCESS });
+                                await refreshMetadataAsync?.();
+                                await refreshFocusedDataRowAsync?.(dcmt.TID, dcmt.DID, true);
+                                const cacheKey = `${dcmt.TID}-${dcmt.DID}`;
+                                if (dcmtsFileCachePreview.has(cacheKey))
+                                    removeDcmtsFileCache(cacheKey);
+                                triggerPreviewRefresh();
+                                triggerCommentOnFileAdd([dcmt.DID]);
+                            }
+                        }
+                        catch (err) {
+                            result.push({ rowIndex: i, id1: i, id2: i, resultType: ResultTypes.ERROR, description: getExceptionMessage(err) });
+                        }
+                        finally {
+                            setCicoPrimaryProgressText('');
+                            setCicoPrimaryProgressMax(0);
+                            setCicoPrimaryProgressValue(0);
+                            setShowCicoWaitPanel(false);
+                            TMResultManager.show(result, 'Check in', "ID", undefined, SDKUI_Localizator.CheckInSuccessMessage, 6000);
+                        }
+                    }
+                },
+            });
+        });
+        input.click();
+    };
+    return {
+        showHistory,
+        showHistoryCallback,
+        hideHistoryCallback,
+        showCheckoutInformationForm,
+        showCheckoutInformationFormCallback,
+        hideCheckoutInformationFormCallback,
+        commentFormState,
+        hideCommentFormCallback,
+        copyCheckoutPathToClipboardCallback,
+        handleCheckOutCallback,
+        handleCheckInCallback,
+        refreshPreviewTrigger,
+        showCicoWaitPanel,
+        cicoWaitPanelTitle,
+        showCicoPrimaryProgress,
+        cicoPrimaryProgressText,
+        cicoPrimaryProgressValue,
+        cicoPrimaryProgressMax,
+    };
+};

package/lib/hooks/useDataListItem.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { DataListItemDescriptor, DataListViewModes } from '@topconsultnpm/sdk-ts';
+export declare const useDataListItem: () => {
+    loadDataListsAsync: (dataListIDs: Set<number>) => Promise<void>;
+    getDataListItem: (dataListID: number, value: string | number | Date) => DataListItemDescriptor | undefined;
+    clearCache: () => void;
+    hasDataList: (dataListID: number) => boolean;
+    renderDataListCell: (value: string | Date | number | undefined, dataListID: number, dataListViewMode: DataListViewModes) => React.ReactElement;
+    dataListsCache: React.MutableRefObject<Map<number, DataListItemDescriptor[]>>;
+    convertToDataListValue: (value: string | Date | number | undefined) => string;
+    convertToDataListDisplayValue: (value: string | Date | number | undefined) => string;
+};

package/lib/hooks/useDataListItem.js

@@ -0,0 +1,131 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useCallback } from 'react';
+import { DataListCacheService, DataListViewModes } from '@topconsultnpm/sdk-ts';
+import { IconWarning, SDKUI_Localizator, TMImageLibrary } from '../helper';
+import { FormulaHelper, StyledDivHorizontal } from '../components';
+import { TMColors } from '../utils/theme';
+export const useDataListItem = () => {
+    const dataListsCacheRef = useRef(new Map());
+    /**
+     * Converte un valore in formato stringa per DataList
+     * @param value Valore da convertire
+     * @returns Stringa rappresentante il valore
+     */
+    const convertToDataListValue = useCallback((value) => {
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        else if (typeof value === 'number') {
+            return value.toString();
+        }
+        else {
+            return value ?? '';
+        }
+    }, []);
+    /**
+     * Converte un valore in formato stringa per visualizzazione in DataList
+     * @param value Valore da convertire
+     * @returns Stringa formattata per visualizzazione
+     */
+    const convertToDataListDisplayValue = useCallback((value) => {
+        if (value instanceof Date) {
+            return value.toLocaleDateString();
+        }
+        else if (typeof value === 'number') {
+            return value.toString();
+        }
+        else {
+            return value ?? '';
+        }
+    }, []);
+    /**
+     * Carica tutte le DataList necessarie in parallelo e popola la cache
+     * @param dataListIDs Set di ID delle DataList da caricare
+     * @returns Promise che si risolve quando tutte le DataList sono state caricate
+     */
+    const loadDataListsAsync = useCallback(async (dataListIDs) => {
+        if (dataListIDs.size === 0)
+            return;
+        try {
+            const results = await Promise.all(Array.from(dataListIDs).map(id => DataListCacheService.GetAsync(id).then(dl => ({
+                id,
+                items: dl?.items ?? []
+            }))));
+            const newCache = new Map();
+            results.forEach(({ id, items }) => newCache.set(id, items));
+            dataListsCacheRef.current = newCache;
+        }
+        catch (err) {
+            console.error('Error loading DataLists:', err);
+            dataListsCacheRef.current = new Map();
+        }
+    }, []);
+    /**
+     * Recupera un item dalla cache della DataList
+     * @param dataListID ID della DataList
+     * @param value Valore dell'item da cercare
+     * @returns DataListItemDescriptor se trovato, undefined altrimenti
+     */
+    const getDataListItem = useCallback((dataListID, value) => {
+        const stringValue = convertToDataListValue(value);
+        const dataListItems = dataListsCacheRef.current.get(dataListID);
+        return dataListItems?.find(o => o.value == stringValue);
+    }, []);
+    /**
+     * Svuota completamente la cache
+     */
+    const clearCache = useCallback(() => {
+        dataListsCacheRef.current = new Map();
+    }, []);
+    /**
+     * Verifica se una DataList è presente nella cache
+     * @param dataListID ID della DataList
+     * @returns true se la DataList è in cache, false altrimenti
+     */
+    const hasDataList = useCallback((dataListID) => {
+        return dataListsCacheRef.current.has(dataListID);
+    }, []);
+    /**
+     * Renderizza una cella DataList con icona e testo formattato
+     * @param value Valore della cella
+     * @param dataListID ID della DataList
+     * @param dataListViewMode Modalità di visualizzazione della DataList
+     * @returns Elemento React per la cella DataList
+     */
+    const renderDataListCell = useCallback((value, dataListID, dataListViewMode) => {
+        const stringValue = convertToDataListValue(value);
+        const showIcon = dataListViewMode !== DataListViewModes.Description;
+        const dataListItem = getDataListItem(dataListID, stringValue);
+        const getIcon = () => {
+            if (!showIcon)
+                return null;
+            if (value === undefined || value === null)
+                return null;
+            if (FormulaHelper.isFormula(stringValue))
+                return null;
+            return dataListItem
+                ? _jsx(TMImageLibrary, { imageID: dataListItem.imageID })
+                : _jsx(IconWarning, { color: TMColors.warning });
+        };
+        return (_jsxs(StyledDivHorizontal, { style: { width: '100%' }, title: dataListItem ? dataListItem.value : SDKUI_Localizator.ValueNotPresent, children: [getIcon(), _jsx("p", { style: {
+                        textAlign: 'left',
+                        marginLeft: showIcon ? '5px' : '',
+                        opacity: dataListItem ? 1 : 0.5,
+                        whiteSpace: 'nowrap',
+                        overflow: 'hidden',
+                        textOverflow: 'ellipsis',
+                        flexGrow: 1,
+                        minWidth: 0
+                    }, children: dataListItem ? dataListItem.name : convertToDataListDisplayValue(value) })] }));
+    }, [getDataListItem]);
+    return {
+        loadDataListsAsync,
+        getDataListItem,
+        clearCache,
+        hasDataList,
+        renderDataListCell,
+        dataListsCache: dataListsCacheRef,
+        convertToDataListValue,
+        convertToDataListDisplayValue
+    };
+};

package/lib/hooks/useDataUserIdItem.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { UserDescriptor } from '@topconsultnpm/sdk-ts';
+export declare const useDataUserIdItem: () => {
+    loadUsersAsync: (userIDs: Set<number>) => Promise<void>;
+    getUserItem: (userId: number) => UserDescriptor | undefined;
+    clearCache: () => void;
+    hasUser: (userId: number) => boolean;
+    usersCache: React.MutableRefObject<Map<number, UserDescriptor>>;
+    renderUserIdViewer: (userId: number | undefined, showIcon?: boolean, showTitile?: boolean) => React.ReactElement;
+};

package/lib/hooks/useDataUserIdItem.js

@@ -0,0 +1,96 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useCallback } from 'react';
+import { UserListCacheService } from '@topconsultnpm/sdk-ts';
+import { IconWarning, SDKUI_Localizator } from '../helper';
+import { TMColors } from '../utils/theme';
+import { TMUserIcon } from '../components';
+export const useDataUserIdItem = () => {
+    const usersCacheRef = useRef(new Map());
+    /**
+     * Carica tutti gli utenti necessari in parallelo e popola la cache
+     * @param userIDs Set di ID degli utenti da caricare
+     * @returns Promise che si risolve quando tutti gli utenti sono stati caricati
+     */
+    const loadUsersAsync = useCallback(async (userIDs) => {
+        if (userIDs.size === 0)
+            return;
+        try {
+            const results = await Promise.all(Array.from(userIDs).map(id => UserListCacheService.GetAsync(id).then(user => ({ id, user }))
+                .catch(() => ({ id, user: undefined }))));
+            const newCache = new Map();
+            results.forEach(({ id, user }) => {
+                if (user)
+                    newCache.set(id, user);
+            });
+            usersCacheRef.current = newCache;
+        }
+        catch (err) {
+            console.error('Error loading Users:', err);
+            usersCacheRef.current = new Map();
+        }
+    }, []);
+    /**
+     * Recupera un utente dalla cache
+     * @param userId ID dell'utente
+     * @returns UserDescriptor se trovato, undefined altrimenti
+     */
+    const getUserItem = useCallback((userId) => {
+        return usersCacheRef.current.get(userId);
+    }, []);
+    /**
+     * Svuota completamente la cache
+     */
+    const clearCache = useCallback(() => {
+        usersCacheRef.current = new Map();
+    }, []);
+    /**
+     * Verifica se un utente è presente nella cache
+     * @param userId ID dell'utente
+     * @returns true se l'utente è in cache, false altrimenti
+     */
+    const hasUser = useCallback((userId) => {
+        return usersCacheRef.current.has(userId);
+    }, []);
+    /**
+     * Helper per ottenere il nome completo dell'utente
+     */
+    const getCompleteUserName = useCallback((domain, name) => {
+        if (!name)
+            return undefined;
+        if (!domain)
+            return name;
+        return domain + "\\" + name;
+    }, []);
+    /**
+     * Renderizza un componente UserIdViewer
+     * @param userId ID dell'utente
+     * @param showIcon Se mostrare l'icona
+     * @param noneSelectionText Testo da mostrare quando non c'è selezione
+     * @param TMUserIcon Componente per l'icona utente
+     * @returns Elemento React per visualizzare l'utente
+     */
+    const renderUserIdViewer = useCallback((userId, showIcon = false, showTitile = true) => {
+        const ud = userId && userId > 0 ? getUserItem(userId) : undefined;
+        const getIcon = () => {
+            if (!showIcon)
+                return null;
+            if (!userId)
+                return null;
+            return ud ? _jsx(TMUserIcon, { ud: ud }) : _jsx("div", { title: showTitile ? SDKUI_Localizator.ValueNotPresent : undefined, children: _jsx(IconWarning, { color: TMColors.warning }) });
+        };
+        const getDescription = () => {
+            if (!userId)
+                return undefined;
+            return ud ? getCompleteUserName(ud.domain, ud.name) : userId.toString() ?? SDKUI_Localizator.NoneSelection;
+        };
+        return (_jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: '4px' }, children: [getIcon(), _jsx("span", { children: getDescription() })] }));
+    }, [getUserItem, getCompleteUserName]);
+    return {
+        loadUsersAsync,
+        getUserItem,
+        clearCache,
+        hasUser,
+        usersCache: usersCacheRef,
+        renderUserIdViewer
+    };
+};

package/lib/hooks/useSettingsFeedback.d.ts

@@ -0,0 +1,11 @@
+export interface SettingsFeedback {
+    showSavedBadge: boolean;
+    lastChanged: {
+        label: string;
+        value: string;
+    };
+    isWarning: boolean;
+    triggerUIUpdate: (label: string, value: any, warning?: boolean) => void;
+    closeBadge: () => void;
+}
+export declare const useSettingsFeedback: () => SettingsFeedback;

package/lib/hooks/useSettingsFeedback.js

@@ -0,0 +1,38 @@
+import { useState, useRef } from 'react';
+export const useSettingsFeedback = () => {
+    const [, setForceUpdate] = useState(0);
+    const [showSavedBadge, setShowSavedBadge] = useState(false);
+    const [lastChanged, setLastChanged] = useState({
+        label: '',
+        value: ''
+    });
+    const [isWarning, setIsWarning] = useState(false);
+    const timeoutRef = useRef(null);
+    const triggerUIUpdate = (label, value, warning = false) => {
+        setForceUpdate((prev) => prev + 1);
+        setShowSavedBadge(true);
+        setLastChanged({ label, value: String(value) });
+        setIsWarning(warning);
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(() => {
+            setShowSavedBadge(false);
+            timeoutRef.current = null;
+        }, 4000);
+    };
+    const closeBadge = () => {
+        setShowSavedBadge(false);
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+            timeoutRef.current = null;
+        }
+    };
+    return {
+        showSavedBadge,
+        lastChanged,
+        isWarning,
+        triggerUIUpdate,
+        closeBadge
+    };
+};

package/lib/hooks/useWorkflowApprove.d.ts

@@ -8,4 +8,8 @@ export declare const useWorkflowApprove: () => {
     isLoading: boolean;
     refreshWorkflowApprove: () => Promise<void>;
     totalDcmtsFound: number;
+    getWorkItemsByDID: (targetDID: number) => {
+        tid: number;
+        did: number;
+    }[];
 };

package/lib/hooks/useWorkflowApprove.js

@@ -14,6 +14,19 @@ export const useWorkflowApprove = () => {
     const calculateTotalDcmtsFound = useCallback((data) => {
         return data.reduce((sum, item) => sum + (item.dcmtsFound || 0), 0);
     }, []);
+    /**
+     * Ottiene tutti i work items che corrispondono a un determinato DID.
+     * Restituisce un array di oggetti { tid, did }.
+     */
+    const getWorkItemsByDID = useCallback((targetDID) => {
+        return workflowApproveData
+            .flatMap(workflow => workflow.dtdResult?.rows ?? [])
+            .filter(dataRow => Number(dataRow?.[1]) === targetDID)
+            .map(dataRow => ({
+            tid: Number(dataRow[0]),
+            did: targetDID
+        }));
+    }, [workflowApproveData]);
     /**
      * Esegue il fetch dei dati dal workflow, aggiorna lo stato globale
      * e notifica gli altri componenti tramite un evento.
@@ -53,5 +66,5 @@ export const useWorkflowApprove = () => {
             window.removeEventListener('onWorkflowApproveChange', handleUpdate);
         };
     }, [calculateTotalDcmtsFound]);
-    return { workflowApproveData, isLoading, refreshWorkflowApprove, totalDcmtsFound };
+    return { workflowApproveData, isLoading, refreshWorkflowApprove, totalDcmtsFound, getWorkItemsByDID };
 };

package/lib/index.d.ts

@@ -9,4 +9,5 @@ export * from './hooks/useDcmtOperations';
 export * from './hooks/useResizeObserver';
 export * from './hooks/useWorkflowApprove';
 export * from './hooks/useRelatedDocuments';
+export * from './hooks/useSettingsFeedback';
 export * from './services';

package/lib/index.js

@@ -9,6 +9,7 @@ export * from './hooks/useDcmtOperations';
 export * from './hooks/useResizeObserver';
 export * from './hooks/useWorkflowApprove';
 export * from './hooks/useRelatedDocuments';
+export * from './hooks/useSettingsFeedback';
 export * from './services';
 import config from 'devextreme/core/config';
 // DevExtreme License Key (valid for v25.1 and earlier versions)

package/lib/ts/types.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from "react";
-import { FileFormats, ITopMediaSession, MetadataDescriptor, MetadataValueDescriptor, UserDescriptor, ValidationItem } from "@topconsultnpm/sdk-ts";
+import { DataListItemDescriptor, FileFormats, ITopMediaSession, MetadataDescriptor, MetadataValueDescriptor, UserDescriptor, ValidationItem } from "@topconsultnpm/sdk-ts";
 import { ITMEditorBase } from "../components/base/TMEditorBase";
 import { IColumnProps } from "devextreme-react/data-grid";
 export declare enum FormModes {
@@ -310,3 +310,60 @@ export declare enum buildTypes {
     RTM = "RTM",
     PATCH = "PATCH"
 }
+/**
+ * Descrive un'istanza di workflow per il contesto WorkflowCtrl.
+ * Contiene tutte le informazioni necessarie per recuperare i work items associati.
+ */
+export interface WFInstanceDescriptor {
+    /** ID dell'istanza */
+    instanceId: string;
+    /** Indice della riga nel search result */
+    rowIndex: number;
+    /** Struttura metadati completa da searchResultToDataSource: { [key: string]: { md: MetadataDescriptor, value: any } } */
+    values: any;
+    /** TID del documento workflow */
+    tid?: number;
+    /** DID del documento workflow */
+    did?: number;
+    /** ID del workflow */
+    wfid?: number;
+    /** MID del metadato che contiene lo stato del workflow */
+    mStatusMID?: number;
+    /** DataList ID per visualizzare lo stato */
+    mStatusDLID?: number;
+}
+/**
+ * Dettaglio di un singolo work item
+ */
+export interface WorkItemDetail {
+    wid: string;
+    tid: number;
+    did: number;
+    wfid: number;
+    approvalVID: number;
+    status?: DataListItemDescriptor;
+    setID: string;
+    response?: string;
+    creationTime?: Date;
+    completionTime?: Date;
+    from?: number;
+    to?: number;
+    toUser?: UserDescriptor;
+    or?: number;
+}
+/**
+ * Raggruppamento di work items per setID (e creationTime se lo step si ripete)
+ */
+export interface IWorkItemData {
+    wid: string;
+    category?: any;
+    type?: any;
+    name?: string;
+    description?: string;
+    setID: string;
+    creationTime?: Date;
+    setStatus?: DataListItemDescriptor;
+    setRule?: number;
+    details: WorkItemDetail[];
+    groupIndex?: number;
+}

package/lib/utils/theme.d.ts

@@ -57,7 +57,7 @@ declare class FontSize {
     static defaultFontSizeInPixel: string;
 }
 declare class TMMargin {
-    static defultMargin: string;
+    static defaultMargin: string;
     static smallMargin: string;
     static largeMargin: string;
 }

package/lib/utils/theme.js

@@ -65,7 +65,7 @@ FontSize.defaultFontSize = '1rem';
 FontSize.defaultFontSizeInPixel = '13px';
 class TMMargin {
 }
-TMMargin.defultMargin = '5px';
+TMMargin.defaultMargin = '5px';
 TMMargin.smallMargin = '3px';
 TMMargin.largeMargin = '10px';
 class Gutters {