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

package/lib/hooks/useDataUserIdItem.js

@@ -15,7 +15,7 @@ export const useDataUserIdItem = () => {
         if (userIDs.size === 0)
             return;
         try {
-            const results = await Promise.all(Array.from(userIDs).map(id => UserListCacheService.GetAsync(id).then(user => ({ id, user }))
+            const results = await Promise.all(Array.from(userIDs).filter(id => id > 0).map(id => UserListCacheService.GetAsync(id).then(user => ({ id, user }))
                 .catch(() => ({ id, user: undefined }))));
             const newCache = new Map();
             results.forEach(({ id, user }) => {
@@ -70,17 +70,19 @@ export const useDataUserIdItem = () => {
      * @returns Elemento React per visualizzare l'utente
      */
     const renderUserIdViewer = useCallback((userId, showIcon = false, showTitile = true) => {
-        const ud = userId && userId > 0 ? getUserItem(userId) : undefined;
+        const ud = userId !== undefined && userId > 0 ? getUserItem(userId) : undefined;
         const getIcon = () => {
             if (!showIcon)
                 return null;
-            if (!userId)
+            if (userId === undefined || userId === null)
                 return null;
             return ud ? _jsx(TMUserIcon, { ud: ud }) : _jsx("span", { title: showTitile ? SDKUI_Localizator.ValueNotPresent : undefined, style: { display: 'inline-flex', alignItems: 'center' }, children: _jsx(IconWarning, { color: TMColors.warning }) });
         };
         const getDescription = () => {
-            if (!userId)
+            if (userId == null)
                 return undefined;
+            if (userId === 0)
+                return SDKUI_Localizator.SystemUser;
             return ud ? getCompleteUserName(ud.domain, ud.name) : userId.toString() ?? SDKUI_Localizator.NoneSelection;
         };
         return (_jsxs("span", { style: { display: 'inline-flex', alignItems: 'center', gap: '4px', lineHeight: 1 }, children: [getIcon(), _jsx("span", { style: { lineHeight: 'normal' }, children: getDescription() })] }));

package/lib/hooks/useDcmtOperations.d.ts

@@ -1,5 +1,29 @@
-import { RetrieveFileOptions, FileDescriptor } from '@topconsultnpm/sdk-ts';
+import { RetrieveFileOptions, DcmtOpers, FileDescriptor, GeneralRetrieveFormats, InvoiceRetrieveFormats, OrderRetrieveFormats, FileFormats } from '@topconsultnpm/sdk-ts';
 import { DcmtInfo, DcmtOperationTypes, DownloadModes, DownloadTypes } from '../ts';
+export interface RetrieveFormatOptions {
+    retrieveReason?: DcmtOpers;
+    cvtFormat?: FileFormats;
+    generalRetrieveFormat?: GeneralRetrieveFormats;
+    invoiceRetrieveFormat?: InvoiceRetrieveFormats;
+    orderRetrieveFormat?: OrderRetrieveFormats;
+}
+export interface DownloadDcmtsAsyncParams {
+    inputDcmts: DcmtInfo[] | undefined;
+    downloadType?: DownloadTypes;
+    downloadMode?: DownloadModes;
+    onFileDownloaded?: (dcmtFile: File, dcmtInfo: DcmtInfo) => void | Promise<void>;
+    confirmAttachments?: (list: FileDescriptor[]) => Promise<string[] | undefined>;
+    skipConfirmation?: boolean;
+    retrieveOptions?: RetrieveFormatOptions;
+    useCache?: boolean;
+    showSuccessAlert?: boolean;
+    /**
+     * Controlla la priorità del nome file per il download:
+     * - true: usa il fileName da inputDcmts (dcmtInfo.fileName) come priorità
+     * - false (default): usa il nome file recuperato dal backend (file.name) come priorità
+     */
+    useInputFileName?: boolean;
+}
 export interface UseDcmtOperationsReturn {
     abortController: AbortController;
     showWaitPanel: boolean;
@@ -12,7 +36,7 @@ export interface UseDcmtOperationsReturn {
     waitPanelTextSecondary: string;
     waitPanelValueSecondary: number;
     waitPanelMaxValueSecondary: number;
-    downloadDcmtsAsync: (inputDcmts: DcmtInfo[] | undefined, downloadType?: DownloadTypes, downloadMode?: DownloadModes, onFileDownloaded?: (dcmtFile: File) => void, confirmAttachments?: (list: FileDescriptor[]) => Promise<string[] | undefined>, skipConfirmation?: boolean) => Promise<void>;
+    downloadDcmtsAsync: (params: DownloadDcmtsAsyncParams) => Promise<void>;
     getDcmtFileAsync: (inputDcmt: DcmtInfo | undefined, rfo: RetrieveFileOptions, operationTitle: string, keepWaitPanelPrimary: boolean, bypassCache?: boolean) => Promise<{
         file: File | undefined;
         isFromCache: boolean;

package/lib/hooks/useDcmtOperations.js

@@ -1,12 +1,13 @@
 import { useState } from 'react';
 import { LocalizeDcmtOperationTypes } from '../helper/Enum_Localizator';
-import { SDK_Globals, RetrieveFileOptions, DcmtOpers, ResultTypes, RecentCategories, MetadataDataTypes, MetadataDataDomains, DataListCacheService } from '@topconsultnpm/sdk-ts';
+import { SDK_Globals, RetrieveFileOptions, DcmtOpers, ResultTypes, RecentCategories, MetadataDataTypes, MetadataDataDomains, DataListCacheService, DcmtTypeListCacheService, TemplateTIDs } from '@topconsultnpm/sdk-ts';
 import { ShowAlert, TMResultManager, FormulaHelper, TMExceptionBoxManager, TMSpinner } from '../components';
-import { Globalization, getExceptionMessage, dialogConfirmOperation, extensionHandler, downloadBase64File, SDKUI_Globals, dcmtsFileCacheDownload, CACHE_SIZE_LIMIT, clearDcmtsFileCache, dcmtsFileCachePreview, isDcmtFileInCache, removeDcmtsFileCache, SDKUI_Localizator } from '../helper';
+import { Globalization, getExceptionMessage, dialogConfirmOperation, extensionHandler, downloadBase64File, SDKUI_Globals, dcmtsFileCacheDownload, CACHE_SIZE_LIMIT, clearDcmtsFileCache, dcmtsFileCachePreview, isDcmtFileInCache, removeDcmtsFileCache, SDKUI_Localizator, ZipManager } from '../helper';
 import { DcmtOperationTypes, DownloadTypes, FileExtensionHandler } from '../ts';
 import { useFileDialog, useFileSourceDialog } from './useInputDialog';
 import { isXMLFileExt } from '../helper/dcmtsHelper';
 import { ShowConfirm } from '../components/base/TMConfirm';
+import { generateTargetFileName } from '../components/features/documents/copyAndMergeDcmtsShared';
 const isScannerLicenseConfigured = () => {
     try {
         const scannerLicense = SDKUI_Globals.userSettings.advancedSettings.scannerLicense;
@@ -18,16 +19,91 @@ const isScannerLicenseConfigured = () => {
 };
 let abortController = new AbortController();
 const downloadCountMap = new Map();
-const getDownloadFileName = (fileName) => {
-    const firstDot = fileName.indexOf('.');
-    const lastDot = fileName.lastIndexOf('.');
-    if (firstDot === -1 || firstDot === lastDot)
-        return fileName;
-    const count = downloadCountMap.get(fileName) ?? 0;
-    downloadCountMap.set(fileName, count + 1);
-    if (count === 0)
-        return fileName;
-    return `${fileName.slice(0, firstDot)}(${count})${fileName.slice(firstDot)}`;
+/**
+ * Genera il nome file per il download con logica di priorità configurabile.
+ *
+ * @param file - File recuperato dal backend (può contenere il nome originale)
+ * @param dcmtInfo - Informazioni del documento (fileName, DID, FILEEXT)
+ * @param useInputFileName - Controlla la priorità del nome:
+ *   - true: priorità a dcmtInfo.fileName → file.name → DID
+ *   - false (default): priorità a file.name → dcmtInfo.fileName → DID
+ *
+ * Gestisce anche:
+ * - Aggiunta automatica dell'estensione se mancante
+ * - Duplicati per file con estensioni multiple (es: file.pdf.p7m)
+ */
+const getDownloadFileName = (file, dcmtInfo, useInputFileName = false) => {
+    // === FASE 1: Costruzione nome base con fallback ===
+    // Determina l'estensione con fallback: prima dal backend, poi dal documento
+    const fileExtFromBackend = file?.name?.split('.').pop()?.toLowerCase();
+    const fileExtFromDcmt = dcmtInfo.FILEEXT?.toLowerCase();
+    const fileExtension = fileExtFromBackend ?? fileExtFromDcmt ?? '';
+    let baseFileName;
+    /**
+     * Logica di priorità per il nome file:
+     *
+     * Se useInputFileName = true:
+     *   1. Usa dcmtInfo.fileName (nome passato nell'input)
+     *   2. Fallback a file.name (nome dal backend)
+     *   3. Fallback finale a DID
+     *
+     * Se useInputFileName = false (default):
+     *   1. Usa file.name (nome recuperato dal backend)
+     *   2. Fallback a dcmtInfo.fileName (nome salvato nel documento)
+     *   3. Fallback finale a DID
+     */
+    if (useInputFileName) {
+        // Priorità al nome da inputDcmts (dcmtInfo.fileName)
+        if (dcmtInfo.fileName) {
+            const hasExtension = dcmtInfo.fileName.includes('.');
+            baseFileName = hasExtension
+                ? dcmtInfo.fileName
+                : (fileExtension ? `${dcmtInfo.fileName}.${fileExtension}` : dcmtInfo.fileName);
+        }
+        // Seconda priorità: nome dal backend
+        else if (file?.name) {
+            baseFileName = file.name;
+        }
+        // Fallback finale: ID documento con estensione
+        else {
+            baseFileName = fileExtension ? `${dcmtInfo.DID}.${fileExtension}` : `${dcmtInfo.DID}`;
+        }
+    }
+    else {
+        // Comportamento default: priorità al nome dal backend
+        // 1. Priorità massima: nome dal backend
+        if (file?.name) {
+            baseFileName = file.name;
+        }
+        // 2. Seconda priorità: nome salvato nel documento
+        else if (dcmtInfo.fileName) {
+            const hasExtension = dcmtInfo.fileName.includes('.');
+            baseFileName = hasExtension
+                ? dcmtInfo.fileName
+                : (fileExtension ? `${dcmtInfo.fileName}.${fileExtension}` : dcmtInfo.fileName);
+        }
+        // 3. Fallback finale: ID documento con estensione
+        else {
+            baseFileName = fileExtension ? `${dcmtInfo.DID}.${fileExtension}` : `${dcmtInfo.DID}`;
+        }
+    }
+    // === FASE 2: Gestione duplicati per file con estensioni multiple ===
+    const firstDot = baseFileName.indexOf('.');
+    const lastDot = baseFileName.lastIndexOf('.');
+    // Se non ci sono punti o c'è una sola estensione, ritorna il nome così com'è
+    if (firstDot === -1 || firstDot === lastDot) {
+        return baseFileName;
+    }
+    // Gestisce il contatore per evitare sovrascritture
+    const count = downloadCountMap.get(baseFileName) ?? 0;
+    downloadCountMap.set(baseFileName, count + 1);
+    // Prima occorrenza: nome originale
+    if (count === 0) {
+        return baseFileName;
+    }
+    // Download successivi: inserisce contatore dopo il nome base
+    // Es: "file.pdf.p7m" -> "file(1).pdf.p7m"
+    return `${baseFileName.slice(0, firstDot)}(${count})${baseFileName.slice(firstDot)}`;
 };
 export const useDcmtOperations = () => {
     const [showWaitPanel, setShowWaitPanel] = useState(false);
@@ -42,7 +118,145 @@ export const useDcmtOperations = () => {
     const [waitPanelMaxValueSecondary, setWaitPanelMaxValueSecondary] = useState(0);
     const { OpenFileDialog } = useFileDialog();
     const [selectFileSource, FileSourceDialog] = useFileSourceDialog();
-    const _downloadDcmtsAsync = async (inputDcmts, downloadMode = "download", onFileDownloaded, skipConfirmation = false) => {
+    const copyCompliantDcmtsAsync = async (inputDcmt, onFileDownloaded) => {
+        return await _copyCompliantDcmtsAsync(inputDcmt, onFileDownloaded);
+    };
+    const _copyCompliantDcmtsAsync = async (inputDcmt, onFileDownloaded) => {
+        if (inputDcmt === undefined)
+            return;
+        let returnDcmtFiles = [];
+        let returnDcmtInfos = [];
+        const rfo = new RetrieveFileOptions();
+        rfo.retrieveReason = DcmtOpers.ShowFile;
+        let firstBlock = true;
+        let maxFileSize = 0;
+        let signerInfoDescriptor = undefined;
+        if (inputDcmt?.FILEEXT == undefined || inputDcmt.FILEEXT == '') {
+            throw new Error('WARNING#Documento di soli metadati');
+        }
+        let ue = SDK_Globals.tmSession?.NewUpdateEngineByID();
+        if (ue) {
+            ue.TID = inputDcmt?.TID;
+            ue.DID = inputDcmt?.DID;
+            //Verifichiamo la nostra firma che nel Lex è sempre CadES
+            if (inputDcmt?.FILEEXT && inputDcmt.FILEEXT?.toLowerCase().includes('p7m')) {
+                //Verifica firma e recupero informazioni firmatari 
+                await ue.VerifySignAsync();
+                //Recuperiamo le impronte
+                signerInfoDescriptor = await ue.GetSignersAsync();
+            }
+        }
+        //Documenti master
+        let dsRes = await SDK_Globals.tmSession?.NewSearchEngine().GetAllMasterDcmtsAsync(inputDcmt?.TID, inputDcmt?.DID);
+        if (dsRes == undefined || dsRes.length === 0) {
+            throw new Error('Nessun documento master trovato');
+        }
+        //Cerchiamo quello con modello IdC
+        let serachResultIdC = null;
+        for (const dtRes of dsRes) {
+            let dtdCur = await DcmtTypeListCacheService.GetAsync(dtRes.fromTID);
+            if (dtdCur?.templateTID === TemplateTIDs.IDC_DcmtType && dtRes.dcmtsFound && dtRes.dcmtsFound > 0) {
+                serachResultIdC = { ...dtRes };
+            }
+        }
+        if (serachResultIdC == null || serachResultIdC.dcmtsFound !== 1) {
+            throw new Error('Nessun IdC correlato al documento');
+        }
+        if (ue) {
+            ue.Metadata_ClearAll();
+            ue.TID = serachResultIdC.dtdResult.rows[0][0];
+            ue.DID = serachResultIdC.dtdResult.rows[0][1];
+            //Verifica dell'IdC
+            await ue.VerifySignAsync();
+            const signerInfoDescriptorIdC = await ue.GetSignersAsync();
+            //Controllo se marcato temporalmente
+            if (signerInfoDescriptorIdC) {
+                if (signerInfoDescriptorIdC.signers?.filter(s => s.isTimeStamp === true).length === 0) {
+                    throw new Error('IdC non marcato temporalmente!');
+                }
+            }
+            else
+                throw new Error('IdC non firmato e non marcato temporalmente!');
+            //Ricerca dell'impronta SHA256 nel contenuto dell'IdC
+            let fileIdC = await SDK_Globals.tmSession?.NewSearchEngine().RetrieveFileAsync(serachResultIdC.dtdResult.rows[0][0], serachResultIdC.dtdResult.rows[0][1], rfo, abortController.signal, (pd) => {
+                if (firstBlock) {
+                    maxFileSize = pd.ProgressBarMaximum ?? 0;
+                    setWaitPanelMaxValueSecondary(maxFileSize);
+                    firstBlock = false;
+                }
+                setWaitPanelValueSecondary(pd.ProgressBarValue);
+                setWaitPanelTextSecondary(`Downloading IdC... ${Globalization.getNumberDisplayValue(pd.ProgressBarValue, true)} / ${Globalization.getNumberDisplayValue(maxFileSize, true)}`);
+                if (pd.ProgressBarValue === pd.ProgressBarMaximum) {
+                    setWaitPanelMaxValueSecondary(0);
+                    setWaitPanelValueSecondary(0);
+                    setWaitPanelTextSecondary('');
+                    firstBlock = true;
+                }
+            });
+            let hashOk = false;
+            if (fileIdC) {
+                try {
+                    const contenuto = await fileIdC.text();
+                    if (contenuto && signerInfoDescriptor?.shA256) {
+                        hashOk = contenuto.toLocaleUpperCase().includes(signerInfoDescriptor.shA256.toLocaleUpperCase());
+                    }
+                }
+                catch (errDebug) {
+                    throw new Error(`Errore nella lettura del file IdC: ${errDebug}`);
+                }
+            }
+            if (!hashOk) {
+                throw new Error('Impronta non trovata nel file IdC o non corrispondente a quella del documento');
+            }
+            let file;
+            file = await SDK_Globals.tmSession?.NewSearchEngine().RetrieveFileAsync(inputDcmt.TID, inputDcmt.DID, rfo, abortController.signal, (pd) => {
+                if (firstBlock) {
+                    maxFileSize = pd.ProgressBarMaximum ?? 0;
+                    setWaitPanelMaxValueSecondary(maxFileSize);
+                    firstBlock = false;
+                }
+                setWaitPanelValueSecondary(pd.ProgressBarValue);
+                setWaitPanelTextSecondary(`Downloading... ${Globalization.getNumberDisplayValue(pd.ProgressBarValue, true)} / ${Globalization.getNumberDisplayValue(maxFileSize, true)}`);
+                if (pd.ProgressBarValue === pd.ProgressBarMaximum) {
+                    setWaitPanelMaxValueSecondary(0);
+                    setWaitPanelValueSecondary(0);
+                    setWaitPanelTextSecondary('');
+                    firstBlock = true;
+                }
+            });
+            if (file && fileIdC) {
+                returnDcmtFiles.push(file);
+                returnDcmtInfos.push(inputDcmt);
+                returnDcmtFiles.push(fileIdC);
+                returnDcmtInfos.push({ ...inputDcmt, fileName: inputDcmt.fileName + "_IdC", FILEEXT: 'TXT.P7M.TSD' });
+            }
+            onFileDownloaded && await onFileDownloaded(returnDcmtFiles, returnDcmtInfos);
+        }
+    };
+    const zipGetName = async (operation, tid) => {
+        let nameZip = tid ? tid.toString() + ".zip" : operation.toString() + ".zip";
+        switch (operation) {
+            case DcmtOperationTypes.CopyCompliant:
+                nameZip = `Duplicato_Informatico_${tid ?? '1'}`;
+                break;
+        }
+        return nameZip.trim().toLowerCase().endsWith('.zip')
+            ? nameZip.trim() : nameZip.trim() + '.zip';
+    };
+    const zipDocuments = async (zipEntries, typeOperation, tid, passwordZip) => {
+        if (zipEntries.length > 0) {
+            const zipFileName = await zipGetName(typeOperation, tid);
+            // Crea il blob ZIP
+            const zipBlob = await ZipManager.createZip(zipEntries, {
+                compressionLevel: 6,
+                password: passwordZip || undefined,
+            });
+            // Download zip nella cartella Downloads del browser
+            ZipManager.downloadBlob(zipBlob, zipFileName);
+            ShowAlert({ message: SDKUI_Localizator.ZipCreatedSavedInFolder.replaceParams(zipFileName, "Zip creato con successo"), mode: 'success', duration: 5000, title: SDKUI_Localizator.CompressToZipFile });
+        }
+    };
+    const _downloadDcmtsAsync = async (inputDcmts, downloadMode = "download", onFileDownloaded, skipConfirmation = false, retrieveOptions, useCache = true, showSuccessAlert = true, useInputFileName = false) => {
         if (inputDcmts === undefined)
             return;
         if (inputDcmts.length <= 0)
@@ -72,9 +286,13 @@ export const useDcmtOperations = () => {
         setWaitPanelTitle(operationTitle);
         abortController = new AbortController();
         const rfo = new RetrieveFileOptions();
-        rfo.retrieveReason = DcmtOpers.ShowFile;
-        rfo.invoiceRetrieveFormat = SDKUI_Globals.userSettings.searchSettings.invoiceRetrieveFormat;
-        rfo.orderRetrieveFormat = SDKUI_Globals.userSettings.searchSettings.orderRetrieveFormat;
+        rfo.retrieveReason = retrieveOptions?.retrieveReason ?? DcmtOpers.ShowFile;
+        if (retrieveOptions?.cvtFormat !== undefined)
+            rfo.cvtFormat = retrieveOptions.cvtFormat;
+        if (retrieveOptions?.generalRetrieveFormat !== undefined)
+            rfo.generalRetrieveFormat = retrieveOptions.generalRetrieveFormat;
+        rfo.invoiceRetrieveFormat = retrieveOptions?.invoiceRetrieveFormat ?? SDKUI_Globals.userSettings.searchSettings.invoiceRetrieveFormat;
+        rfo.orderRetrieveFormat = retrieveOptions?.orderRetrieveFormat ?? SDKUI_Globals.userSettings.searchSettings.orderRetrieveFormat;
         let result = [];
         setWaitPanelMaxValuePrimary(inputDcmts.length);
         let firstBlock = true;
@@ -88,7 +306,7 @@ export const useDcmtOperations = () => {
                 setWaitPanelTextPrimary(`Download file ${i + 1} di ${inputDcmts.length}`);
                 let file;
                 const cacheKey = `${inputDcmts[i].TID}-${inputDcmts[i].DID}`;
-                if (dcmtsFileCacheDownload.has(cacheKey)) {
+                if (useCache && dcmtsFileCacheDownload.has(cacheKey)) {
                     file = dcmtsFileCacheDownload.get(cacheKey);
                 }
                 else {
@@ -111,24 +329,31 @@ export const useDcmtOperations = () => {
                 setWaitPanelValuePrimary(i + 1);
                 const fileURL = window.URL.createObjectURL(file);
                 if (downloadMode === "openInNewWindow") {
-                    onFileDownloaded
-                        ? onFileDownloaded(file)
+                    (onFileDownloaded && file)
+                        ? onFileDownloaded(file, inputDcmts[i])
                         : window.open(fileURL, '_blank', 'noopener');
                 }
                 else {
-                    const alink2 = document.createElement('a');
-                    alink2.href = fileURL;
-                    const baseFileName = inputDcmts[i].fileName ?? (inputDcmts[i].FILEEXT ? `${inputDcmts[i].DID}.${inputDcmts[i].FILEEXT}` : file?.name);
-                    alink2.download = getDownloadFileName(baseFileName);
-                    alink2.target = "_blank";
-                    alink2.rel = "noreferrer";
-                    alink2.click();
+                    if (onFileDownloaded && file) {
+                        await onFileDownloaded(file, inputDcmts[i]);
+                    }
+                    else {
+                        const alink2 = document.createElement('a');
+                        alink2.href = fileURL;
+                        // Usa useInputFileName per determinare la priorità del nome file
+                        alink2.download = getDownloadFileName(file, inputDcmts[i], useInputFileName);
+                        alink2.target = "_blank";
+                        alink2.rel = "noreferrer";
+                        alink2.click();
+                    }
                 }
-                if (dcmtsFileCacheDownload.size >= CACHE_SIZE_LIMIT) {
-                    const oldestKey = dcmtsFileCacheDownload.keys().next().value;
-                    dcmtsFileCacheDownload.delete(oldestKey);
+                if (useCache) {
+                    if (dcmtsFileCacheDownload.size >= CACHE_SIZE_LIMIT) {
+                        const oldestKey = dcmtsFileCacheDownload.keys().next().value;
+                        dcmtsFileCacheDownload.delete(oldestKey);
+                    }
+                    dcmtsFileCacheDownload.set(cacheKey, file);
                 }
-                dcmtsFileCacheDownload.set(cacheKey, file);
                 result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.SUCCESS });
             }
             catch (ex) {
@@ -146,9 +371,9 @@ export const useDcmtOperations = () => {
         setWaitPanelMaxValueSecondary(0);
         setWaitPanelValueSecondary(0);
         setShowWaitPanel(false);
-        TMResultManager.show(result, operationTitle, "TID", "DID");
+        TMResultManager.show(result, operationTitle, "TID", "DID", undefined, undefined, showSuccessAlert);
     };
-    const _downloadAttachmentsAsync = async (inputDcmts, confirmAttachments) => {
+    const _downloadAttachmentsAsync = async (inputDcmts, confirmAttachments, showSuccessAlert = true) => {
         if (inputDcmts === undefined)
             return;
         if (inputDcmts.length !== 1)
@@ -196,7 +421,7 @@ export const useDcmtOperations = () => {
                     }
                 }
             }
-            TMResultManager.show(result, operationTitle, "TID", "DID");
+            TMResultManager.show(result, operationTitle, "TID", "DID", undefined, undefined, showSuccessAlert);
         }
         catch (ex) {
             TMSpinner.hide();
@@ -208,11 +433,14 @@ export const useDcmtOperations = () => {
                 TMExceptionBoxManager.show({ exception: err });
         }
     };
-    const downloadDcmtsAsync = async (inputDcmts, downloadType = DownloadTypes.Attachment, downloadMode = "download", onFileDownloaded, confirmAttachments, skipConfirmation = false) => {
+    const downloadDcmtsAsync = async (params) => {
+        const { inputDcmts, downloadType = DownloadTypes.Attachment, downloadMode = "download", onFileDownloaded, confirmAttachments, skipConfirmation = false, retrieveOptions, useCache = true, showSuccessAlert = true, useInputFileName = false, // Default: usa il nome dal backend
+         } = params;
         switch (downloadType) {
-            case DownloadTypes.Dcmt: return await _downloadDcmtsAsync(inputDcmts, downloadMode, onFileDownloaded, skipConfirmation);
-            case DownloadTypes.Attachment: return await _downloadAttachmentsAsync(inputDcmts, confirmAttachments);
-            default: return await _downloadDcmtsAsync(inputDcmts, undefined, undefined, skipConfirmation);
+            // Per il download di documenti, passa useInputFileName per controllare la priorità del nome
+            case DownloadTypes.Dcmt: return await _downloadDcmtsAsync(inputDcmts, downloadMode, onFileDownloaded, skipConfirmation, retrieveOptions, useCache, showSuccessAlert, useInputFileName);
+            case DownloadTypes.Attachment: return await _downloadAttachmentsAsync(inputDcmts, confirmAttachments, showSuccessAlert);
+            default: return await _downloadDcmtsAsync(inputDcmts, undefined, undefined, skipConfirmation, retrieveOptions, useCache, showSuccessAlert, useInputFileName);
         }
     };
     const uploadDcmtsAsync = async (inputDcmts, operationTitle, operType, actionAfterOperationAsync) => {
@@ -438,6 +666,7 @@ export const useDcmtOperations = () => {
                 await uploadDcmtsAsync(inputDcmts, operationTitle, undefined, actionAfterOperationAsync);
                 return;
             }
+            let zipEntries = [];
             setShowWaitPanel(true);
             setShowPrimary(true);
             setShowSecondary(false);
@@ -486,6 +715,23 @@ export const useDcmtOperations = () => {
                             }
                             break;
                         }
+                        case DcmtOperationTypes.CopyCompliant:
+                            const collectFileForZip = async (file, dcmtInfo) => {
+                                if (file.length !== dcmtInfo.length) {
+                                    console.warn(`Numero di file (${file.length}) e documenti (${dcmtInfo.length}) non corrispondono. Impossibile associare correttamente i file ai documenti per la creazione dello zip.`);
+                                    return;
+                                }
+                                for (let j = 0; j < file.length; j++) {
+                                    let targetFileName = await generateTargetFileName(file[j], dcmtInfo[j], {
+                                        fileNamingMode: 'documentTypeAndDid',
+                                        separatorChar: '_',
+                                    });
+                                    targetFileName = targetFileName.replace(/\.xml\.p7m\.tsd$/i, '_IdC.XML.P7M.TSD');
+                                    zipEntries.push({ filename: targetFileName, data: file[j] });
+                                }
+                            };
+                            await copyCompliantDcmtsAsync(inputDcmts[i], collectFileForZip);
+                            break;
                         case DcmtOperationTypes.CheckFile:
                             await SDK_Globals.tmSession?.NewSearchEngine().CheckFileAsync(inputDcmts[i].TID, inputDcmts[i].DID);
                             break;
@@ -538,7 +784,12 @@ export const useDcmtOperations = () => {
                     result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.SUCCESS });
                 }
                 catch (ex) {
-                    result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.ERROR, description: getExceptionMessage(ex) });
+                    let msg = getExceptionMessage(ex);
+                    if (msg.startsWith('WARNING#')) {
+                        result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.WARNING, description: msg.replace('WARNING#', '') });
+                    }
+                    else
+                        result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.ERROR, description: msg });
                     const err = ex;
                     if (err.name === 'CanceledError') {
                         ShowAlert({ message: err.message, mode: 'warning', duration: 3000, title: 'Abort' });
@@ -546,6 +797,9 @@ export const useDcmtOperations = () => {
                 }
                 setWaitPanelValuePrimary(i + 1);
             }
+            if (zipEntries.length > 0) {
+                await zipDocuments(zipEntries, dcmtOperationType, inputDcmts[0].TID);
+            }
             setWaitPanelMaxValuePrimary(0);
             setWaitPanelValuePrimary(0);
             setWaitPanelTextPrimary('');

package/lib/hooks/useDocumentOperations.d.ts

@@ -38,6 +38,8 @@ export interface DocumentDataProps {
         s4TViewerDialogComponent?: React.ReactNode;
     };
 }
+export type TMCopyToFolderMode = 'onlySelected' | 'customized';
+export type TMCopyToFolderOperationType = 'copyToFolder' | 'mergeToPdf';
 export interface ExportDataProps {
     dataColumns?: Array<IColumnProps>;
     dataSource?: Array<any>;
@@ -110,6 +112,7 @@ export interface UseDocumentOperationsResult {
         isOpenBatchUpdate: boolean;
         isModifiedBatchUpdate: boolean;
         updateBatchUpdateForm: (value: boolean) => void;
+        closeDcmtFormHandler: () => void;
         handleSignApprove: () => void;
         showSearchTMDatagrid: boolean;
         showExportForm: boolean;