@topconsultnpm/sdkui-react 6.20.0-dev1.13 → 6.20.0-dev1.130

package/lib/helper/workItemsHelper.js

@@ -0,0 +1,230 @@
+import { SDK_Globals, WorkItemMetadataNames, SystemDataListIDs } from '@topconsultnpm/sdk-ts';
+import { WorkflowCacheService, DataListCacheService, UserListCacheService, DcmtTypeListCacheService } from '@topconsultnpm/sdk-ts';
+import { parseWfDiagramXml } from '../components/features/workflow/diagram/xmlParser';
+/**
+ * Helper function per costruire IWorkItemData da un WFInstanceDescriptor
+ * Effettua le chiamate API necessarie e popola tutti i campi disponibili
+ */
+export const buildWorkItemsFromWFCtrl = async (wfInstance) => {
+    const { wfid, tid: mtid, did: mdid, instanceId } = wfInstance;
+    if (!wfid || !mtid || !mdid) {
+        return [];
+    }
+    // Recupera il workflow descriptor
+    const workflow = await WorkflowCacheService.GetWFCtrlInfoAsync(wfid);
+    // Recupera tutti i work items per questo workflow usando WFCtrl_RetrieveAllWIsAsync
+    const workItemsResult = await SDK_Globals.tmSession?.NewWorkflowEngine().WFCtrl_RetrieveAllWIsAsync(wfid, mtid, mdid, instanceId);
+    // Se non ci sono work items, restituisci array vuoto
+    if (!workItemsResult || workItemsResult.dcmtsFound === 0 || !workItemsResult.dtdResult?.rows) {
+        return [];
+    }
+    // Recupera la DataList degli stati del workflow
+    const dldStatus = await DataListCacheService.GetAsync(SystemDataListIDs.WIStates);
+    // Parse del diagramma del workflow per ottenere type e name dai diagramItems
+    let wfDiagram;
+    if (workflow?.diagram) {
+        try {
+            wfDiagram = parseWfDiagramXml(workflow.diagram);
+        }
+        catch (error) {
+            console.warn('Errore nel parsing del diagramma workflow:', error);
+        }
+    }
+    // Recupera il DTD per ottenere i MID dai nomi dei metadati
+    const dtd = await DcmtTypeListCacheService.GetAsync(workItemsResult.fromTID);
+    if (!dtd?.metadata) {
+        return [];
+    }
+    // Crea una mappa nome metadato -> MID
+    const metadataNameToMID = {};
+    for (const meta of dtd.metadata) {
+        if (meta.name) {
+            metadataNameToMID[meta.name] = meta.id;
+        }
+    }
+    const columns = workItemsResult.dtdResult.columns || [];
+    // Funzione helper per trovare l'indice di una colonna tramite MID
+    const findColumnIndexByMID = (mid) => {
+        if (mid === -1)
+            return -1;
+        return columns.findIndex(col => col.extendedProperties?.MID === mid.toString());
+    };
+    // Mappa degli indici delle colonne usando MID
+    const columnIndices = {
+        tid: 0, // TID è sempre il primo
+        did: 1, // DID è sempre il secondo
+        setID: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_SetID] ?? -1),
+        creationTime: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_CreationTime] ?? -1),
+        response: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_Response] ?? -1),
+        completionTime: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_CompletionTime] ?? -1),
+        from: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_From] ?? -1),
+        to: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_To] ?? -1),
+        or: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_Or] ?? -1),
+        status: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_Status] ?? -1),
+        category: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_Category] ?? -1),
+        description: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_Description] ?? -1),
+        setStatus: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_SetStatus] ?? -1),
+        setRule: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_SetRule] ?? -1),
+    };
+    // Crea i WorkItemDetail
+    const details = [];
+    for (let i = 0; i < workItemsResult.dtdResult.rows.length; i++) {
+        const row = workItemsResult.dtdResult.rows[i];
+        const tid = Number(row[columnIndices.tid]);
+        const did = Number(row[columnIndices.did]);
+        const setID = columnIndices.setID !== -1 ? row[columnIndices.setID] : '';
+        const toUserID = columnIndices.to !== -1 ? Number(row[columnIndices.to]) : undefined;
+        // Risolvi l'utente usando la cache
+        let toUser = undefined;
+        if (toUserID !== undefined) {
+            try {
+                toUser = await UserListCacheService.GetAsync(toUserID);
+            }
+            catch (error) {
+                console.warn(`Impossibile recuperare l'utente con ID ${toUserID}:`, error);
+            }
+        }
+        // Calcola lo status come DataListItemDescriptor
+        let statusItem = undefined;
+        if (columnIndices.status !== -1) {
+            const rawStatusValue = row[columnIndices.status];
+            if (rawStatusValue !== undefined && rawStatusValue !== null && dldStatus?.items) {
+                statusItem = dldStatus.items.find(item => item.value === rawStatusValue);
+            }
+        }
+        details.push({
+            wid: `${tid}_${did}`,
+            tid,
+            did,
+            wfid: workflow?.id ?? 0,
+            approvalVID: workflow?.approvalVID ?? 0,
+            setID,
+            creationTime: columnIndices.creationTime !== -1 && row[columnIndices.creationTime]
+                ? new Date(row[columnIndices.creationTime])
+                : undefined,
+            response: columnIndices.response !== -1 ? row[columnIndices.response] : undefined,
+            completionTime: columnIndices.completionTime !== -1 && row[columnIndices.completionTime]
+                ? new Date(row[columnIndices.completionTime])
+                : undefined,
+            from: columnIndices.from !== -1 ? Number(row[columnIndices.from]) : undefined,
+            to: toUserID,
+            toUser: toUser,
+            or: columnIndices.or !== -1 ? Number(row[columnIndices.or]) : undefined,
+            status: statusItem,
+        });
+    }
+    // Raggruppa per setID considerando il creationTime e setStatus
+    // Ordiniamo tutti i details per creationTime (ordine cronologico)
+    const sortedAllDetails = [...details].sort((a, b) => {
+        if (!a.creationTime || !b.creationTime)
+            return 0;
+        return a.creationTime.getTime() - b.creationTime.getTime();
+    });
+    // Crea una mappa detail -> setStatus per avere accesso al setStatus di ogni detail
+    const detailSetStatusMap = new Map();
+    for (const detail of details) {
+        const row = workItemsResult.dtdResult?.rows?.find(r => Number(r[columnIndices.tid]) === detail.tid &&
+            Number(r[columnIndices.did]) === detail.did);
+        if (row && columnIndices.setStatus !== -1) {
+            const setStatusValue = row[columnIndices.setStatus];
+            detailSetStatusMap.set(detail, setStatusValue?.toString() ?? '');
+        }
+    }
+    /**
+     * Logica di raggruppamento sequenziale dei workitems:
+     *
+     * Regole:
+     * 1. Primo workitem o SetID diverso => Nuovo step
+     *    - Se SetStatus = "0" (Nuovo): attiva modalità aggregazione per tutti i successivi
+     *
+     * 2. Stesso SetID del precedente:
+     *    - In modalità aggregazione (SetStatus = "0"): aggrega sempre nello stesso step
+     *    - SetStatus != "0": raggruppa per stesso SetStatus
+     *      - Stesso SetStatus => aggrega
+     *      - SetStatus diverso => nuovo step
+     *    - SetStatus = "0": nuovo step e attiva modalità aggregazione
+     */
+    const groups = [];
+    let previousSetID = undefined;
+    let previousSetStatus = undefined;
+    let isInNewStatusMode = false;
+    for (const detail of sortedAllDetails) {
+        const currentSetStatus = detailSetStatusMap.get(detail) ?? '';
+        const currentSetID = detail.setID;
+        if (previousSetID === undefined || currentSetID !== previousSetID) {
+            // Nuovo SetID: crea nuovo step
+            groups.push([detail]);
+            previousSetID = currentSetID;
+            previousSetStatus = currentSetStatus;
+            isInNewStatusMode = currentSetStatus === '0';
+        }
+        else {
+            // Stesso SetID
+            if (isInNewStatusMode) {
+                // Modalità aggregazione attiva: aggrega sempre
+                groups[groups.length - 1].push(detail);
+            }
+            else {
+                if (currentSetStatus === '0') {
+                    // SetStatus "Nuovo": nuovo step e attiva modalità aggregazione
+                    groups.push([detail]);
+                    isInNewStatusMode = true;
+                    previousSetStatus = currentSetStatus;
+                }
+                else {
+                    // SetStatus diverso da "Nuovo": raggruppa per stesso SetStatus
+                    if (currentSetStatus !== previousSetStatus) {
+                        groups.push([detail]);
+                        previousSetStatus = currentSetStatus;
+                    }
+                    else {
+                        groups[groups.length - 1].push(detail);
+                    }
+                }
+            }
+        }
+    }
+    // Crea IWorkItemData per ogni gruppo con tutti i campi disponibili
+    const finalWorkItems = groups.map((groupDetails, groupIndex) => {
+        const setID = groupDetails[0].setID;
+        // Ordina per creationTime (più recente prima)
+        const sortedDetails = [...groupDetails].sort((a, b) => {
+            if (!a.creationTime || !b.creationTime)
+                return 0;
+            return b.creationTime.getTime() - a.creationTime.getTime();
+        });
+        const latest = sortedDetails[0];
+        const latestRow = workItemsResult.dtdResult?.rows?.find(row => Number(row[columnIndices.tid]) === latest.tid &&
+            Number(row[columnIndices.did]) === latest.did);
+        // Calcola il setStatus come DataListItemDescriptor
+        let setStatusItem = undefined;
+        if (latestRow && columnIndices.setStatus !== -1) {
+            const rawStatusValue = latestRow[columnIndices.setStatus];
+            if (rawStatusValue !== undefined && rawStatusValue !== null && dldStatus?.items) {
+                setStatusItem = dldStatus.items.find(item => item.value === rawStatusValue);
+            }
+        }
+        // Cerca il diagramItem corrispondente al setID nel workflow
+        const diagramItem = wfDiagram?.DiagramItems?.find(item => item.ID === setID);
+        return {
+            wid: `group_${setID}_${groupIndex}`,
+            setID,
+            creationTime: latest.creationTime,
+            groupIndex,
+            category: latestRow && columnIndices.category !== -1 ? latestRow[columnIndices.category] : undefined,
+            type: diagramItem?.Type,
+            name: diagramItem?.ItemName,
+            description: latestRow && columnIndices.description !== -1 ? latestRow[columnIndices.description] : undefined,
+            setStatus: setStatusItem,
+            setRule: latestRow && columnIndices.setRule !== -1 ? Number(latestRow[columnIndices.setRule]) : undefined,
+            details: sortedDetails,
+            wf: workflow,
+        };
+    });
+    // Ordina i gruppi per creationTime (più recente prima)
+    return finalWorkItems.sort((a, b) => {
+        if (!a.creationTime || !b.creationTime)
+            return 0;
+        return b.creationTime.getTime() - a.creationTime.getTime();
+    });
+};

package/lib/hooks/useCheckInOutOperations.d.ts

@@ -0,0 +1,28 @@
+import { DcmtInfo, DownloadModes, DownloadTypes } from '../ts';
+import { FileDescriptor, SearchResultDescriptor } from '@topconsultnpm/sdk-ts';
+interface UseCheckInOutOperationsReturn {
+    showHistory: boolean;
+    showHistoryCallback: () => void;
+    hideHistoryCallback: () => void;
+    showCheckoutInformationForm: boolean;
+    showCheckoutInformationFormCallback: () => void;
+    hideCheckoutInformationFormCallback: () => void;
+    commentFormState: {
+        removeAndEditAttachment: boolean;
+        show: boolean;
+        isRequired: boolean;
+    };
+    hideCommentFormCallback: () => void;
+    copyCheckoutPathToClipboardCallback: (dcmt: DcmtInfo, filename: string) => void;
+    handleCheckOutCallback: (dcmt: DcmtInfo, checkout: boolean, filename: string, downloadDcmtsAsync: (inputDcmts: Array<DcmtInfo> | undefined, downloadType?: DownloadTypes, downloadMode?: DownloadModes, onFileDownloaded?: (dcmtFile: File) => void, confirmAttachments?: (list: FileDescriptor[]) => Promise<string[] | undefined>, skipConfirmation?: boolean) => Promise<void>, refreshCurrentDcmt?: () => Promise<void>, refreshFocusedDataRowAsync?: (tid: number | undefined, did: number | undefined, refreshUI?: boolean, metadataResult?: SearchResultDescriptor | null) => Promise<void>) => Promise<void>;
+    handleCheckInCallback: (dcmt: DcmtInfo, refreshCurrentDcmt?: () => Promise<void>, refreshFocusedDataRowAsync?: (tid: number | undefined, did: number | undefined, refreshUI?: boolean, metadataResult?: SearchResultDescriptor | null) => Promise<void>) => Promise<void>;
+    refreshPreviewTrigger: number;
+    showCicoWaitPanel: boolean;
+    cicoWaitPanelTitle: string;
+    showCicoPrimaryProgress: boolean;
+    cicoPrimaryProgressText: string;
+    cicoPrimaryProgressValue: number;
+    cicoPrimaryProgressMax: number;
+}
+export declare const useCheckInOutOperations: () => UseCheckInOutOperationsReturn;
+export {};

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,132 @@
+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 showText = dataListViewMode !== DataListViewModes.Image;
+        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(), showText && (_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;
+};