@topconsultnpm/sdkui-react 6.20.0-dev1.15 → 6.20.0-dev1.17

package/lib/hooks/useDcmtOperations.d.ts

@@ -0,0 +1,24 @@
+import { RetrieveFileOptions, FileDescriptor } from '@topconsultnpm/sdk-ts';
+import { DcmtInfo, DcmtOperationTypes, DownloadModes, DownloadTypes } from '../ts';
+export declare function useDcmtOperations(): {
+    abortController: AbortController;
+    showWaitPanel: boolean;
+    showPrimary: boolean;
+    waitPanelTitle: string;
+    waitPanelTextPrimary: string;
+    waitPanelValuePrimary: number;
+    waitPanelMaxValuePrimary: number;
+    showSecondary: boolean;
+    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>;
+    getDcmtFileAsync: (inputDcmt: DcmtInfo | undefined, rfo: RetrieveFileOptions, operationTitle: string, keepWaitPanelPrimary: boolean, bypassCache?: boolean) => Promise<{
+        file: File | undefined;
+        isFromCache: boolean;
+    } | undefined>;
+    clearDcmtsFileCache: () => void;
+    removeDcmtsFileCache: (key: string) => void;
+    isDcmtFileInCache: (key: string) => boolean;
+    runOperationAsync: (inputDcmts: DcmtInfo[] | undefined, dcmtOperationType: DcmtOperationTypes, actionAfterOperationAsync?: () => Promise<void>) => Promise<void>;
+};

package/lib/hooks/useDcmtOperations.js

@@ -0,0 +1,486 @@
+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, skipConfirmation = false) => {
+        if (inputDcmts === undefined)
+            return;
+        if (inputDcmts.length <= 0)
+            return;
+        const fileExtLower = inputDcmts[0]?.FILEEXT?.toLowerCase();
+        const needsForceDownload = fileExtLower?.includes('p7m') || fileExtLower === 'msg';
+        const shouldShowConfirm = !skipConfirmation;
+        if (inputDcmts.length === 1 && shouldShowConfirm && (downloadMode === "openInNewWindow" || (downloadMode === "download" && needsForceDownload))) {
+            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;
+                    const downloadFileName = inputDcmts[i].fileName ?? (inputDcmts[i].FILEEXT ? `${inputDcmts[i].DID}.${inputDcmts[i].FILEEXT}` : file?.name);
+                    alink2.download = downloadFileName;
+                    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, skipConfirmation = false) => {
+        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);
+        }
+    };
+    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;
+};