@topconsultnpm/sdkui-react 6.19.0-dev1.10

package/lib/hooks/useDcmtOperations.js

@@ -0,0 +1,482 @@
+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 { 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 { DcmtOperationTypes, DownloadTypes, FileExtensionHandler } from '../ts';
+import { useFileDialog } from './useInputDialog';
+import { isXMLFileExt } from '../helper/dcmtsHelper';
+import { ShowConfirm } from '../components/base/TMConfirm';
+let abortController = new AbortController();
+export function useDcmtOperations() {
+    const [showWaitPanel, setShowWaitPanel] = useState(false);
+    const [waitPanelTitle, setWaitPanelTitle] = useState('');
+    const [showPrimary, setShowPrimary] = useState(false);
+    const [waitPanelTextPrimary, setWaitPanelTextPrimary] = useState('');
+    const [waitPanelValuePrimary, setWaitPanelValuePrimary] = useState(0);
+    const [waitPanelMaxValuePrimary, setWaitPanelMaxValuePrimary] = useState(0);
+    const [showSecondary, setShowSecondary] = useState(false);
+    const [waitPanelTextSecondary, setWaitPanelTextSecondary] = useState('');
+    const [waitPanelValueSecondary, setWaitPanelValueSecondary] = useState(0);
+    const [waitPanelMaxValueSecondary, setWaitPanelMaxValueSecondary] = useState(0);
+    const { OpenFileDialog } = useFileDialog();
+    const _downloadDcmtsAsync = async (inputDcmts, downloadMode = "download", onFileDownloaded) => {
+        if (inputDcmts === undefined)
+            return;
+        if (inputDcmts.length <= 0)
+            return;
+        if (inputDcmts.length === 1 && downloadMode === "openInNewWindow") {
+            if (!inputDcmts[0].FILEEXT)
+                return;
+            let readyToShow = extensionHandler(inputDcmts[0].FILEEXT) === FileExtensionHandler.READY_TO_SHOW;
+            if (!readyToShow) {
+                const confirmDownload = await ShowConfirm({
+                    message: SDKUI_Localizator.FileExtensionNotViewable.replaceParams(inputDcmts[0].FILEEXT),
+                    title: SDKUI_Localizator.ConfirmDownload,
+                    okButtonText: 'Download',
+                    cancelButtonText: SDKUI_Localizator.Cancel
+                });
+                if (!confirmDownload)
+                    return;
+            }
+        }
+        let operationTitle = 'Download File';
+        setShowWaitPanel(true);
+        setShowPrimary(inputDcmts.length > 1);
+        setShowSecondary(true);
+        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;
+        let result = [];
+        setWaitPanelMaxValuePrimary(inputDcmts.length);
+        let firstBlock = true;
+        let maxFileSize = 0;
+        for (let i = 0; i < inputDcmts.length; i++) {
+            if (abortController.signal.aborted) {
+                result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.WARNING, description: `Operazione interrotta. Elaborati ${i + 1} documenti` });
+                break;
+            }
+            try {
+                setWaitPanelTextPrimary(`Download file ${i + 1} di ${inputDcmts.length}`);
+                let file;
+                const cacheKey = `${inputDcmts[i].TID}-${inputDcmts[i].DID}`;
+                if (dcmtsFileCacheDownload.has(cacheKey)) {
+                    file = dcmtsFileCacheDownload.get(cacheKey);
+                }
+                else {
+                    file = await SDK_Globals.tmSession?.NewSearchEngine().RetrieveFileAsync(inputDcmts[i].TID, inputDcmts[i].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;
+                        }
+                    });
+                }
+                setWaitPanelValuePrimary(i + 1);
+                const fileURL = window.URL.createObjectURL(file);
+                if (downloadMode === "openInNewWindow") {
+                    onFileDownloaded
+                        ? onFileDownloaded(file)
+                        : window.open(fileURL, '_blank', 'noopener');
+                }
+                else {
+                    const alink2 = document.createElement('a');
+                    alink2.href = fileURL;
+                    alink2.download = inputDcmts[i].fileName ?? file?.name;
+                    alink2.target = "_blank";
+                    alink2.rel = "noreferrer";
+                    alink2.click();
+                }
+                if (dcmtsFileCacheDownload.size >= CACHE_SIZE_LIMIT) {
+                    const oldestKey = dcmtsFileCacheDownload.keys().next().value;
+                    dcmtsFileCacheDownload.delete(oldestKey);
+                }
+                dcmtsFileCacheDownload.set(cacheKey, file);
+                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) });
+                const err = ex;
+                if (err.name === 'CanceledError') {
+                    ShowAlert({ message: err.message, mode: 'warning', duration: 3000, title: 'Abort' });
+                }
+            }
+        }
+        setWaitPanelTextPrimary('');
+        setWaitPanelMaxValuePrimary(0);
+        setWaitPanelValuePrimary(0);
+        setWaitPanelTextSecondary('');
+        setWaitPanelMaxValueSecondary(0);
+        setWaitPanelValueSecondary(0);
+        setShowWaitPanel(false);
+        TMResultManager.show(result, operationTitle, "TID", "DID");
+    };
+    const _downloadAttachmentsAsync = async (inputDcmts, confirmAttachments) => {
+        if (inputDcmts === undefined)
+            return;
+        if (inputDcmts.length !== 1)
+            return;
+        if (!isXMLFileExt(inputDcmts[0].FILEEXT)) {
+            ShowAlert({ message: 'Il file non è in formato XML', mode: 'warning', duration: 5000, title: 'Download Allegati' });
+            return;
+        }
+        let operationTitle = 'Download Allegati XML';
+        const rfo = new RetrieveFileOptions();
+        rfo.retrieveReason = DcmtOpers.ShowFile;
+        let result = [];
+        try {
+            TMSpinner.show({ description: 'Recupero allegati...' });
+            let files = await SDK_Globals.tmSession?.NewSearchEngine().RetrieveAttachmentsAsync(inputDcmts[0].TID, inputDcmts[0].DID, -1, 1);
+            TMSpinner.hide();
+            result.push({ rowIndex: 0, id1: inputDcmts[0].TID, id2: inputDcmts[0].DID, resultType: ResultTypes.SUCCESS });
+            if (!files || files.length === 0) {
+                ShowAlert({ message: 'Nessun allegato trovato', mode: 'warning', duration: 5000, title: 'Download Allegati' });
+                return;
+            }
+            if (files.length === 1) {
+                const file = files[0];
+                if (file?.base64Content)
+                    downloadBase64File(file.base64Content, file.name ?? '');
+            }
+            else {
+                // Open a dialog for the user to select files
+                const selectedFiles = await confirmAttachments?.(files);
+                if (!selectedFiles)
+                    return;
+                if (selectedFiles.length === 0) {
+                    ShowAlert({ message: 'Nessun file selezionato', mode: 'info', duration: 3000, title: 'Download Allegati' });
+                    return;
+                }
+                // Download the selected files
+                for (let i = 0; i < selectedFiles.length; i++) {
+                    if (abortController.signal.aborted) {
+                        result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.WARNING, description: `Operazione interrotta. Elaborati ${i + 1} documenti` });
+                        break;
+                    }
+                    let fd = files.find(f => f.name === selectedFiles[i]);
+                    if (fd?.base64Content) {
+                        downloadBase64File(fd.base64Content, fd.name ?? '');
+                    }
+                }
+            }
+            TMResultManager.show(result, operationTitle, "TID", "DID");
+        }
+        catch (ex) {
+            TMSpinner.hide();
+            const err = ex;
+            if (err.name === 'CanceledError') {
+                ShowAlert({ message: err.message, mode: 'warning', duration: 3000, title: 'Abort' });
+            }
+            else
+                TMExceptionBoxManager.show({ exception: err });
+        }
+    };
+    const downloadDcmtsAsync = async (inputDcmts, downloadType = DownloadTypes.Attachment, downloadMode = "download", onFileDownloaded, confirmAttachments) => {
+        switch (downloadType) {
+            case DownloadTypes.Dcmt: return await _downloadDcmtsAsync(inputDcmts, downloadMode, onFileDownloaded);
+            case DownloadTypes.Attachment: return await _downloadAttachmentsAsync(inputDcmts, confirmAttachments);
+            default: return await _downloadDcmtsAsync(inputDcmts);
+        }
+    };
+    const uploadDcmtsAsync = async (inputDcmts, operationTitle, operType, actionAfterOperationAsync) => {
+        if (inputDcmts === undefined)
+            return;
+        if (inputDcmts.length <= 0)
+            return;
+        let file = inputDcmts[0].FILE ?? await OpenFileDialog();
+        if (!file)
+            return;
+        setShowWaitPanel(true);
+        setShowPrimary(inputDcmts.length > 1);
+        setShowSecondary(true);
+        setWaitPanelTitle(operationTitle);
+        abortController = new AbortController();
+        let result = [];
+        setWaitPanelMaxValuePrimary(inputDcmts.length);
+        let firstBlock = true;
+        let maxFileSize = 0;
+        for (let i = 0; i < inputDcmts.length; i++) {
+            if (abortController.signal.aborted) {
+                result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.WARNING, description: `Operazione interrotta. Elaborati ${i + 1} documenti` });
+                break;
+            }
+            try {
+                setWaitPanelTextPrimary(`${SDKUI_Localizator.FileUpload} ${i + 1} di ${inputDcmts.length}`);
+                const cacheKey = `${inputDcmts[i].TID}-${inputDcmts[i].DID}`;
+                if (dcmtsFileCachePreview.has(cacheKey))
+                    removeDcmtsFileCache(cacheKey);
+                let ue = SDK_Globals.tmSession?.NewUpdateEngineByID();
+                if (ue) {
+                    ue.TID = inputDcmts[i].TID;
+                    ue.DID = inputDcmts[i].DID;
+                    await ue.SubstituteFileAsync(file, operType, undefined, abortController.signal, (pd) => {
+                        if (firstBlock) {
+                            maxFileSize = pd.ProgressBarMaximum ?? 0;
+                            setWaitPanelMaxValueSecondary(maxFileSize);
+                            firstBlock = false;
+                        }
+                        setWaitPanelValueSecondary(pd.ProgressBarValue);
+                        setWaitPanelTextSecondary(`Uploading... ${Globalization.getNumberDisplayValue(pd.ProgressBarValue, true)} / ${Globalization.getNumberDisplayValue(maxFileSize, true)}`);
+                        if (pd.ProgressBarValue === pd.ProgressBarMaximum) {
+                            setWaitPanelMaxValueSecondary(0);
+                            setWaitPanelValueSecondary(0);
+                            setWaitPanelTextSecondary('');
+                            firstBlock = true;
+                        }
+                    });
+                }
+                setWaitPanelValuePrimary(i + 1);
+                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) });
+                const err = ex;
+                if (err.name === 'CanceledError') {
+                    ShowAlert({ message: err.message, mode: 'warning', duration: 3000, title: 'Abort' });
+                }
+            }
+        }
+        setWaitPanelTextPrimary('');
+        setWaitPanelMaxValuePrimary(0);
+        setWaitPanelValuePrimary(0);
+        setWaitPanelTextSecondary('');
+        setWaitPanelMaxValueSecondary(0);
+        setWaitPanelValueSecondary(0);
+        actionAfterOperationAsync?.();
+        setShowWaitPanel(false);
+        TMResultManager.show(result, operationTitle, "TID", "DID");
+    };
+    const getDcmtFileAsync = async (inputDcmt, rfo, operationTitle, keepWaitPanelPrimary, bypassCache = false) => {
+        if (inputDcmt?.TID === undefined)
+            return;
+        if (inputDcmt?.DID === undefined)
+            return;
+        const cacheKey = `${inputDcmt.TID}-${inputDcmt.DID}`;
+        if (!bypassCache && dcmtsFileCachePreview.has(cacheKey))
+            return { file: dcmtsFileCachePreview.get(cacheKey), isFromCache: true };
+        setShowWaitPanel(true);
+        setShowPrimary(keepWaitPanelPrimary);
+        setShowSecondary(true);
+        setWaitPanelTitle(operationTitle);
+        abortController = new AbortController();
+        let firstBlock = true;
+        let maxFileSize = 0;
+        try {
+            setWaitPanelTextSecondary(extensionHandler(inputDcmt.FILEEXT ?? '') === FileExtensionHandler.CONVERTIBLE ? 'Conversione file in corso...' : 'Recupero file in corso...');
+            const 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 (dcmtsFileCachePreview.size >= CACHE_SIZE_LIMIT) {
+                const oldestKey = dcmtsFileCachePreview.keys().next().value;
+                dcmtsFileCachePreview.delete(oldestKey);
+            }
+            if (!bypassCache) {
+                dcmtsFileCachePreview.set(cacheKey, file);
+            }
+            return { file: file, isFromCache: false };
+        }
+        finally {
+            setWaitPanelTextSecondary('');
+            setWaitPanelMaxValueSecondary(0);
+            setWaitPanelValueSecondary(0);
+            setShowWaitPanel(false);
+        }
+    };
+    const getDisplayValueMetadataValueDescriptor = async (mvd) => {
+        if (!mvd)
+            return undefined;
+        if (FormulaHelper.isFormula(mvd.value))
+            return mvd.value;
+        if (mvd.isNull)
+            return "'NULL'";
+        if (!mvd.value)
+            return undefined;
+        if (mvd.md?.dataDomain === MetadataDataDomains.DataList) {
+            let dl = await DataListCacheService.GetAsync(mvd.md.dataListID);
+            let description = dl?.items?.find(o => o.value === mvd.value)?.name;
+            return (description && mvd.value !== description) ? `${description} (${mvd.value})` : mvd.value;
+        }
+        else {
+            switch (mvd.md?.dataType) {
+                case MetadataDataTypes.DateTime: return Globalization.getDateTimeDisplayValue(mvd.value, undefined, mvd.md.format?.format);
+                case MetadataDataTypes.Number: return mvd.value;
+                default: return mvd.value;
+            }
+        }
+    };
+    const runOperationAsync = async (inputDcmts, dcmtOperationType, actionAfterOperationAsync) => {
+        if (inputDcmts === undefined)
+            return;
+        if (inputDcmts.length <= 0)
+            return;
+        let operationTitle = LocalizeDcmtOperationTypes(dcmtOperationType);
+        let msg = "";
+        switch (dcmtOperationType) {
+            case DcmtOperationTypes.BatchUpdate:
+                msg = `I documenti selezionati (${inputDcmts.length}) verranno modificati con i seguenti valori: <br><br>`;
+                for (const mvd of inputDcmts[0]?.metadataValues?.filter(o => o.isSelected) ?? []) {
+                    let displayValue = await getDisplayValueMetadataValueDescriptor(mvd);
+                    msg += `${mvd.md?.nameLoc}: <b>${displayValue}</b><br>`;
+                }
+                msg += "<br>Le modifiche apportate non potranno essere più annullate.<br><br>Continuare?";
+                break;
+            default: {
+                switch (inputDcmts.length) {
+                    case 0: return;
+                    default:
+                        msg = `${inputDcmts.length} documento/i selezionato/i. Confermare l'operazione?`;
+                        break;
+                }
+                break;
+            }
+        }
+        const doOperationAsync = async () => {
+            if (dcmtOperationType == DcmtOperationTypes.SubstituteFile) {
+                await uploadDcmtsAsync(inputDcmts, operationTitle, undefined, actionAfterOperationAsync);
+                return;
+            }
+            setShowWaitPanel(true);
+            setShowPrimary(true);
+            setShowSecondary(false);
+            setWaitPanelTitle(operationTitle);
+            abortController = new AbortController();
+            let result = [];
+            setWaitPanelMaxValuePrimary(inputDcmts.length);
+            for (let i = 0; i < inputDcmts.length; i++) {
+                if (abortController.signal.aborted) {
+                    result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.WARNING, description: `Operazione interrotta. Elaborati ${i + 1} documenti` });
+                    break;
+                }
+                setWaitPanelTextPrimary(`Documento ${i + 1} di ${inputDcmts.length}`);
+                try {
+                    switch (dcmtOperationType) {
+                        case DcmtOperationTypes.AddToFavs:
+                            await SDK_Globals.tmSession?.NewFavoritesEngine().AddOrRemoveDcmtAsync(inputDcmts[i].TID, inputDcmts[i].DID, false);
+                            break;
+                        case DcmtOperationTypes.BatchUpdate: {
+                            let ue = SDK_Globals.tmSession?.NewUpdateEngineByID();
+                            if (ue) {
+                                ue.TID = inputDcmts[i].TID;
+                                ue.DID = inputDcmts[i].DID;
+                                ue.Metadata_ClearAll();
+                                for (let metadata of inputDcmts[i].metadataValues?.filter(o => o.isSelected) ?? []) {
+                                    if (metadata.isNull)
+                                        ue.Metadata_AddNull(metadata.mid);
+                                    else if (FormulaHelper.isFormula(metadata.value))
+                                        ue.Metadata_AddString(metadata.mid, metadata.value);
+                                    else {
+                                        switch (metadata.md?.dataType) {
+                                            case MetadataDataTypes.DateTime:
+                                                ue.Metadata_AddDateTime(metadata.mid, new Date(metadata.value));
+                                                break;
+                                            case MetadataDataTypes.Number:
+                                                ue.Metadata_AddNumber(metadata.mid, metadata.value);
+                                                break;
+                                            case MetadataDataTypes.Varchar:
+                                                ue.Metadata_AddString(metadata.mid, metadata.value);
+                                                break;
+                                            default: ue.Metadata_AddNull(metadata.mid);
+                                        }
+                                    }
+                                }
+                                await ue.UpdateAsync();
+                            }
+                            break;
+                        }
+                        case DcmtOperationTypes.CheckFile:
+                            await SDK_Globals.tmSession?.NewSearchEngine().CheckFileAsync(inputDcmts[i].TID, inputDcmts[i].DID);
+                            break;
+                        case DcmtOperationTypes.ConvertFile: {
+                            let ue = SDK_Globals.tmSession?.NewUpdateEngineByID();
+                            if (ue) {
+                                ue.TID = inputDcmts[i].TID;
+                                ue.DID = inputDcmts[i].DID;
+                                await ue.ConvertFileAsync(inputDcmts[i].fileFormat);
+                            }
+                            break;
+                        }
+                        case DcmtOperationTypes.FreeSearchReindex:
+                            await SDK_Globals.tmSession?.NewSearchEngine().FreeSearchReindexDcmtAsync(inputDcmts[i].TID, inputDcmts[i].DID);
+                            break;
+                        case DcmtOperationTypes.FreeSearchPurge:
+                            await SDK_Globals.tmSession?.NewSearchEngine().FreeSearchPurgeDcmtAsync(inputDcmts[i].TID, inputDcmts[i].DID);
+                            break;
+                        case DcmtOperationTypes.LogDelete:
+                            await SDK_Globals.tmSession?.NewDeleteEngine().LogDeleteByIDAsync(inputDcmts[i].TID, inputDcmts[i].DID);
+                            break;
+                        case DcmtOperationTypes.PhysDelete:
+                            await SDK_Globals.tmSession?.NewDeleteEngine().PhysDeleteByIDAsync(inputDcmts[i].TID, inputDcmts[i].DID, true);
+                            break;
+                        case DcmtOperationTypes.RemoveFromFavs:
+                            await SDK_Globals.tmSession?.NewFavoritesEngine().AddOrRemoveDcmtAsync(inputDcmts[i].TID, inputDcmts[i].DID, true);
+                            break;
+                        case DcmtOperationTypes.RemoveFromRecentsArk:
+                            await SDK_Globals.tmSession?.NewRecentEngine().AddOrRemoveDcmtAsync(inputDcmts[i].TID, inputDcmts[i].DID, RecentCategories.Archive, true);
+                            break;
+                        case DcmtOperationTypes.RemoveFromRecentsView:
+                            await SDK_Globals.tmSession?.NewRecentEngine().AddOrRemoveDcmtAsync(inputDcmts[i].TID, inputDcmts[i].DID, RecentCategories.View, true);
+                            break;
+                        case DcmtOperationTypes.RemoveFromWorkgroup:
+                            await SDK_Globals.tmSession?.NewWorkingGroupEngine().DcmtsAddOrRemoveAsync(inputDcmts[i]?.workingGroupId ?? 0, inputDcmts[i].TID, inputDcmts[i].DID, true);
+                            break;
+                        case DcmtOperationTypes.Undelete:
+                            await SDK_Globals.tmSession?.NewDeleteEngine().UndeleteByIDAsync(inputDcmts[i].TID, inputDcmts[i].DID);
+                            break;
+                        case DcmtOperationTypes.VerifySign: {
+                            let ue = SDK_Globals.tmSession?.NewUpdateEngineByID();
+                            if (ue) {
+                                ue.TID = inputDcmts[i].TID;
+                                ue.DID = inputDcmts[i].DID;
+                                await ue.VerifySignAsync();
+                            }
+                            break;
+                        }
+                    }
+                    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) });
+                    const err = ex;
+                    if (err.name === 'CanceledError') {
+                        ShowAlert({ message: err.message, mode: 'warning', duration: 3000, title: 'Abort' });
+                    }
+                }
+                setWaitPanelValuePrimary(i + 1);
+            }
+            setWaitPanelMaxValuePrimary(0);
+            setWaitPanelValuePrimary(0);
+            setWaitPanelTextPrimary('');
+            setShowWaitPanel(false);
+            actionAfterOperationAsync?.();
+            TMResultManager.show(result, operationTitle, "TID", "DID");
+        };
+        dialogConfirmOperation(operationTitle, msg, doOperationAsync);
+    };
+    return {
+        abortController, showWaitPanel, showPrimary, waitPanelTitle, waitPanelTextPrimary, waitPanelValuePrimary, waitPanelMaxValuePrimary, showSecondary, waitPanelTextSecondary, waitPanelValueSecondary, waitPanelMaxValueSecondary,
+        downloadDcmtsAsync, getDcmtFileAsync, clearDcmtsFileCache, removeDcmtsFileCache, isDcmtFileInCache, runOperationAsync
+    };
+}

package/lib/hooks/useForm.d.ts

@@ -0,0 +1,24 @@
+import { FormModes } from "../ts";
+import { JobTypes, ObjectClasses, ValidationItem } from "@topconsultnpm/sdk-ts";
+export declare class SaveFormOptions {
+    objClass: ObjectClasses;
+    objType: JobTypes;
+    loadDataAfterSave: boolean;
+}
+export declare function useSaveForm<T>(formMode: FormModes, id: number | undefined, sfo: SaveFormOptions, validator?: (d: T) => Promise<ValidationItem[] | undefined>, onSaved?: (newDescriptor: T) => void, onStatusChanged?: (isModified: boolean, isValid: boolean) => void, customizeFormData?: (d: T) => T, saveCustomAsync?: () => Promise<number>): {
+    formData: T | undefined;
+    setFormData: import("react").Dispatch<import("react").SetStateAction<T | undefined>>;
+    formDataOrig: T | undefined;
+    setFormDataOrig: import("react").Dispatch<import("react").SetStateAction<T | undefined>>;
+    validationItems: ValidationItem[];
+    exception: any;
+    saveDataAsync: (...args: any[]) => Promise<void>;
+};
+export declare function useApplyForm<T>(formMode: FormModes, inputData: T | undefined, newData: () => T, onApplied?: (newDescriptor: T) => void): {
+    formData: T;
+    setFormData: import("react").Dispatch<import("react").SetStateAction<T>>;
+    formDataOrig: T;
+    exception: any;
+    setException: import("react").Dispatch<any>;
+    applyData: () => void;
+};

package/lib/hooks/useForm.js

@@ -0,0 +1,157 @@
+import { useEffect, useState } from "react";
+import { FormModes } from "../ts";
+import { TMExceptionBoxManager, TMSpinner } from "../components";
+import { AreaEngine, BasketTypeEngine, DataListEngine, DcmtTypeEngine, DiskEngine, GroupEngine, JobEngine, JobTypes, LDAPDescriptor, LDAPProviders, NumeratorDescriptor, ObjectClasses, ProcessEngine, RelationEngine, ResultTypes, SAPEngine, SavedQueryEngine, SignCertDescriptor, TaskEngine, TreeDescriptor, TSADescriptor, UserEngine, WorkingGroupDescriptor } from "@topconsultnpm/sdk-ts";
+import { PlatformObjectService } from "../services";
+import { SDKUI_Localizator, calcIsModified } from "../helper";
+export class SaveFormOptions {
+    constructor() {
+        this.objType = JobTypes.None;
+        this.loadDataAfterSave = true;
+    }
+}
+export function useSaveForm(formMode, id, sfo, validator, onSaved, onStatusChanged, customizeFormData, saveCustomAsync) {
+    const [formData, setFormData] = useState();
+    const [formDataOrig, setFormDataOrig] = useState();
+    const [exception, setException] = useState();
+    const [validationItems, setValidationItems] = useState([]);
+    // #region Normalize object
+    function normalizeLDAP(d) {
+        d.provider = LDAPProviders.MSActiveDirectory;
+        return d;
+    }
+    function normalizeSignCert(d) {
+        d.isAuto = 1;
+        return d;
+    }
+    function normalizeView() {
+        let d = DcmtTypeEngine.NewDcmtTypeDescriptor();
+        if (d)
+            d.isView = true;
+        return d;
+    }
+    // #endregion
+    const getDataAsync = async (id, fm) => {
+        switch (fm) {
+            case FormModes.Create:
+                switch (sfo.objClass) {
+                    case ObjectClasses.Area: return AreaEngine.NewAreaDescriptor();
+                    case ObjectClasses.BasketType: return BasketTypeEngine.NewBasketTypeDescriptor();
+                    case ObjectClasses.DcmtType: return DcmtTypeEngine.NewDcmtTypeDescriptor();
+                    case ObjectClasses.DataList: return DataListEngine.NewDataListDescriptor();
+                    case ObjectClasses.Disk: return DiskEngine.NewDiskDescriptor();
+                    case ObjectClasses.Group: return GroupEngine.NewGroupDescriptor();
+                    case ObjectClasses.LDAP: return normalizeLDAP(new LDAPDescriptor());
+                    case ObjectClasses.Numerator: return new NumeratorDescriptor();
+                    case ObjectClasses.SignCert: return normalizeSignCert(new SignCertDescriptor());
+                    case ObjectClasses.Tree: return new TreeDescriptor();
+                    case ObjectClasses.TSA: return new TSADescriptor();
+                    case ObjectClasses.User: return UserEngine.NewUserDescriptor();
+                    case ObjectClasses.Process: return ProcessEngine.NewProcessDescriptor();
+                    case ObjectClasses.Job: return JobEngine.NewJobDescriptor(sfo.objType);
+                    case ObjectClasses.Relation: return RelationEngine.NewRelationDescriptor();
+                    case ObjectClasses.SAPLogin: return SAPEngine.NewSAPLoginDescriptor();
+                    case ObjectClasses.SavedQuery: return SavedQueryEngine.NewSavedQueryDescriptor();
+                    case ObjectClasses.Task: return TaskEngine.NewTaskDescriptor();
+                    case ObjectClasses.View: return normalizeView();
+                    case ObjectClasses.WorkingGroup: return new WorkingGroupDescriptor();
+                    default: return undefined;
+                }
+            default:
+                switch (sfo.objClass) {
+                    default: return await PlatformObjectService.retrieveAdminAsync(sfo.objClass, sfo.objType, id);
+                }
+        }
+    };
+    const loadDataAsync = async (id, fm) => {
+        try {
+            TMSpinner.show({ description: `${SDKUI_Localizator.Loading} (id: ${id}) ...`, backgroundColor: 'transparent' });
+            setException(undefined);
+            let d = await getDataAsync?.(id, fm);
+            if (customizeFormData)
+                d = customizeFormData(d);
+            setFormDataOrig({ ...d });
+            if (fm == FormModes.Duplicate)
+                d.name = d.name + ' (copy)';
+            setFormData({ ...d });
+            return d;
+        }
+        catch (e) {
+            setException(e);
+            TMExceptionBoxManager.show({ exception: e });
+            return undefined;
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    };
+    const setDataAsync = async (fm, d, ...args) => {
+        switch (fm) {
+            case FormModes.Update: return await PlatformObjectService.updateAsync(sfo.objClass, sfo.objType, d, ...args);
+            default: return await PlatformObjectService.createAsync(sfo.objClass, sfo.objType, d);
+        }
+    };
+    const saveDataAsync = async (...args) => {
+        if (!formData)
+            return;
+        let newId = -1;
+        if (saveCustomAsync)
+            newId = await saveCustomAsync();
+        else
+            newId = await setDataAsync?.(formMode, formData, ...args);
+        let newData;
+        if (sfo.loadDataAfterSave)
+            newData = await loadDataAsync(newId, FormModes.Update);
+        else {
+            newData = formData;
+            newData.id = newId;
+            setFormData(newData);
+            setFormDataOrig(newData);
+        }
+        onSaved?.(newData);
+    };
+    useEffect(() => { id && loadDataAsync(id, formMode); }, [id, formMode]);
+    useEffect(() => {
+        if (!formData)
+            return;
+        validator?.(formData).then(result => {
+            let vil = result ?? [];
+            setValidationItems(vil);
+            onStatusChanged?.(calcIsModified(formData, formDataOrig), vil.findIndex(o => o.ResultType != ResultTypes.SUCCESS) >= 0);
+        }).catch((err) => { TMExceptionBoxManager.show({ exception: err }); });
+    }, [JSON.stringify(formData)]);
+    return { formData, setFormData, formDataOrig, setFormDataOrig, validationItems, exception, saveDataAsync };
+}
+export function useApplyForm(formMode, inputData, newData, onApplied) {
+    const [formData, setFormData] = useState(inputData ?? newData());
+    const [formDataOrig, setFormDataOrig] = useState(inputData ?? newData());
+    const [exception, setException] = useState();
+    const loadData = (inputData, fm) => {
+        try {
+            setException(undefined);
+            let outputData;
+            switch (fm) {
+                case FormModes.Create:
+                    outputData = newData();
+                    break;
+                default:
+                    outputData = { ...inputData };
+                    break;
+            }
+            setFormDataOrig({ ...outputData });
+            // TODO: in DUPLICA deve partire già modificato?
+            // if (fm == FormModes.Duplicate) outputData.id = -1;
+            setFormData({ ...outputData });
+            return outputData;
+        }
+        catch (ex) {
+            setException(ex);
+            TMExceptionBoxManager.show({ exception: ex });
+            return undefined;
+        }
+        ;
+    };
+    const applyData = () => { onApplied?.(formData); loadData(formData, FormModes.Update); };
+    useEffect(() => { loadData(inputData, formMode); }, [inputData, formMode]);
+    return { formData, setFormData, formDataOrig, exception, setException, applyData };
+}

package/lib/hooks/useInputDialog.d.ts

@@ -0,0 +1,9 @@
+import { FileDescriptor, FileFormats } from '@topconsultnpm/sdk-ts';
+export declare const useInputCvtFormatDialog: () => [() => Promise<FileFormats>, () => JSX.Element];
+export declare const useFileDialog: () => {
+    OpenFileDialog: () => Promise<File | undefined>;
+};
+export declare const useInputAttachmentsDialog: () => {
+    openConfirmAttachmentsDialog: (list: FileDescriptor[]) => Promise<string[] | undefined>;
+    ConfirmAttachmentsDialog: () => import("react/jsx-runtime").JSX.Element | null;
+};