@topconsultnpm/sdkui-react 6.20.0-dev1.6 → 6.20.0-dev1.60

package/lib/hooks/useCheckInOutOperations.js

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

package/lib/hooks/useWorkflowApprove.d.ts

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

package/lib/hooks/useWorkflowApprove.js

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

package/lib/ts/types.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@topconsultnpm/sdkui-react",
-  "version": "6.20.0-dev1.6",
+  "version": "6.20.0-dev1.60",
   "description": "",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -9,6 +9,7 @@
     "tm-build": "npm run clean && tsc && npm run copy-files",
     "tm-watch": "tsc -w",
     "tm-publish": "npm publish --tag latest",
+    "tm-publish_wl": "npm publish",
     "storybook": "storybook dev -p 6006",
     "build-storybook": "storybook build"
   },
@@ -39,12 +40,14 @@
     "lib"
   ],
   "dependencies": {
-    "@topconsultnpm/sdk-ts": "6.20.0-dev1.1",
+    "@topconsultnpm/sdk-ts": "6.20.0-dev1.4",
     "buffer": "^6.0.3",
     "devextreme": "25.1.7",
     "devextreme-react": "25.1.7",
     "exceljs": "^4.4.0",
     "htmlparser2": "^10.0.0",
+    "pdfjs-dist": "5.4.296",
+    "react-pdf": "^10.3.0",
     "react-router-dom": "^6.15.0",
     "styled-components": "^6.1.1"
   },

package/lib/components/features/search/TMSearchResultCheckoutInfoForm.d.ts

@@ -1,8 +0,0 @@
-import { DcmtInfo } from "../../../ts";
-interface TMSearchResultCheckoutInfoFormProps {
-    dtdName: string;
-    selectedDcmtOrFocused: DcmtInfo;
-    onClose: () => void;
-}
-declare const TMSearchResultCheckoutInfoForm: (props: TMSearchResultCheckoutInfoFormProps) => import("react/jsx-runtime").JSX.Element;
-export default TMSearchResultCheckoutInfoForm;