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

package/lib/helper/index.d.ts

@@ -0,0 +1,14 @@
+export * from './SDKUI_Localizator';
+export * from './SDKUI_Globals';
+export * from './Enum_Localizator';
+export * from './Globalization';
+export * from './TMIcons';
+export * from './TMImageLibrary';
+export * from './helpers';
+export * from './queryHelper';
+export * from './TMUtils';
+export * from './TMCommandsContextMenu';
+export * from './TMConditionalWrapper';
+export * from './TMToppyMessage';
+export * from './GlobalStyles';
+export * from './checkinCheckoutManager';

package/lib/helper/index.js

@@ -0,0 +1,14 @@
+export * from './SDKUI_Localizator';
+export * from './SDKUI_Globals';
+export * from './Enum_Localizator';
+export * from './Globalization';
+export * from './TMIcons';
+export * from './TMImageLibrary';
+export * from './helpers';
+export * from './queryHelper';
+export * from './TMUtils';
+export * from './TMCommandsContextMenu';
+export * from './TMConditionalWrapper';
+export * from './TMToppyMessage';
+export * from './GlobalStyles';
+export * from './checkinCheckoutManager';

package/lib/helper/queryHelper.d.ts

@@ -0,0 +1,19 @@
+import { MetadataDescriptor, MetadataDataDomains, SystemMIDsAsNumber, MetadataDataTypes, QueryDescriptor, SelectItem, DataTableDescriptor, LayoutModes, QueryOperators, SavedQueryDescriptor } from '@topconsultnpm/sdk-ts';
+import { MetadataValueDescriptorEx } from '../ts';
+export type TID_Alias = {
+    tid: number;
+    alias: string | undefined;
+};
+export declare const getTIDsByQd: (qd: QueryDescriptor | undefined) => TID_Alias[];
+export declare const getDcmtTypesByQdAsync: (qd: QueryDescriptor) => Promise<import("@topconsultnpm/sdk-ts").DcmtTypeDescriptor[]>;
+export declare const displayMetadataValue: (md: MetadataDescriptor | undefined, value: string | undefined, valueEmptyDescription?: string) => string;
+export declare const IsParametricQuery: (qd: QueryDescriptor | undefined) => boolean;
+export declare const addHiddenSelectItem: (select: SelectItem[], tid: number | undefined, mid: SystemMIDsAsNumber) => void;
+export declare const prepareQdForSearchAsync: (qdInput?: QueryDescriptor, removeWhereItemNoValue?: boolean) => Promise<QueryDescriptor>;
+export declare function addWhereClausesForConnect(qd: QueryDescriptor): void;
+export declare function getDefaultOperator(dataDomain: MetadataDataDomains | undefined, dataType: MetadataDataTypes | undefined): QueryOperators.Equal | QueryOperators.Contain | QueryOperators.In;
+export declare const getQD: (tid: number | undefined, easyOr: boolean) => Promise<QueryDescriptor | undefined>;
+export declare const getWorkItemSetIDAsync: (vid: number, did: number) => Promise<string | undefined>;
+export declare const getSysAllDcmtsSQD: (tid: number | undefined, easyOr: boolean) => Promise<SavedQueryDescriptor>;
+export declare const searchResultToMetadataValues: (tid: number | undefined, dtd: DataTableDescriptor | undefined, rows: string[], mids: number[], metadata: MetadataDescriptor[], layoutMode: LayoutModes) => MetadataValueDescriptorEx[];
+export declare const handleArchiveVisibility: (md: MetadataDescriptor) => boolean;

package/lib/helper/queryHelper.js

@@ -0,0 +1,365 @@
+import { AccessLevels, MetadataDataDomains, DcmtTypeListCacheService, SystemMIDsAsNumber, MetadataDataTypes, QueryDescriptor, QueryFunctions, SelectItem, SelectItemVisibilities, FromItem, LayoutModes, QueryOperators, SavedQueryDescriptor, SearchEngine, WhereItem, OrderByItem, SDK_Globals, AppModules, SystemTIDs, WorkItemMetadataNames, PlatformObjectValidator } from '@topconsultnpm/sdk-ts';
+import { DateDisplayTypes, Globalization } from './Globalization';
+import { ChronologyMIDs, DraftsMIDs, MetadataValueDescriptorEx } from '../ts';
+import { SDKUI_Localizator } from './SDKUI_Localizator';
+import { getDcmtCicoInfo } from './checkinCheckoutManager';
+export const getTIDsByQd = (qd) => {
+    let tids = [];
+    qd?.from?.tid && tids.push({ tid: qd.from?.tid, alias: undefined });
+    if (qd?.join && qd.join.length > 0) {
+        for (const ji of qd.join) {
+            if (ji.tid)
+                tids.push({ tid: ji.tid, alias: ji.alias });
+        }
+    }
+    return tids;
+};
+export const getDcmtTypesByQdAsync = async (qd) => {
+    return await DcmtTypeListCacheService.GetFromQdAsync(qd);
+};
+export const displayMetadataValue = (md, value, valueEmptyDescription = "") => {
+    if (!value)
+        return valueEmptyDescription;
+    if (value?.startsWith("{@QueryParam") || value == "{@UserName}" || value == "{@UserID}")
+        return value;
+    switch (md?.dataDomain) {
+        case MetadataDataDomains.DataList: return value;
+        case MetadataDataDomains.UserID: return value;
+        default:
+            switch (md?.dataType) {
+                case MetadataDataTypes.DateTime: return Globalization.getDateTimeDisplayValue(value, DateDisplayTypes.DateTime);
+                case MetadataDataTypes.Number: return Globalization.getNumberDisplayValue(Number(value));
+                default: return value;
+            }
+    }
+};
+export const IsParametricQuery = (qd) => {
+    if (qd == undefined)
+        return false;
+    if (qd.where == undefined)
+        return false;
+    let qp = "{@QueryParam";
+    for (const wi of qd.where) {
+        if (wi.value1?.includes(qp))
+            return true;
+        if (wi.value2?.includes(qp))
+            return true;
+    }
+    return false;
+};
+export const addHiddenSelectItem = (select, tid, mid) => {
+    if (select.findIndex(o => o.mid == mid) >= 0)
+        return;
+    let si = new SelectItem();
+    si.tid = tid;
+    si.mid = mid;
+    si.visibility = SelectItemVisibilities.Hidden;
+    select.push(si);
+};
+export const prepareQdForSearchAsync = async (qdInput, removeWhereItemNoValue) => {
+    let qd = new QueryDescriptor();
+    qd.init({ ...qdInput });
+    let fromTID = qd?.from?.tid;
+    qd.select ??= [];
+    qd.orderBy ??= [];
+    // In modalità easy rimuovi filtri non valorizzati
+    if (removeWhereItemNoValue) {
+        qd.where = qd?.where?.filter(o => PlatformObjectValidator.WhereItemHasValues(o));
+        qd.where?.forEach(o => o.or = false); // props.easyOr
+    }
+    let qdWithAggrFunctions = qd.select?.some(o => o.function != QueryFunctions.None && o.function != undefined);
+    if (!qd.isDistinct && !qdWithAggrFunctions) {
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.TID);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.DID);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.OwnerID);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.UpdaterID);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.CreationTime);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.LastUpdateTime);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.FileCount);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.FileExt);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.FileSize);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.IsLex);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.IsLogDel);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.IsMail);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.IsSigned);
+        addHiddenSelectItem(qd.select, fromTID, SystemMIDsAsNumber.IsShared);
+        const dtd = await DcmtTypeListCacheService.GetAsync(fromTID);
+        if (dtd) {
+            const cicoInfo = getDcmtCicoInfo(dtd);
+            const canCICO = cicoInfo.CICO === 1 && cicoInfo.CanCICO === AccessLevels.Yes;
+            if (canCICO) {
+                if (!qd.select.find(o => o.mid == cicoInfo.UserID_MID) && cicoInfo.UserID_CanViewOrUpdate == AccessLevels.Yes) {
+                    addHiddenSelectItem(qd.select, fromTID, cicoInfo.UserID_MID);
+                }
+                if (!qd.select.find(o => o.mid == cicoInfo.Date_MID) && cicoInfo.Date_CanViewOrUpdate == AccessLevels.Yes) {
+                    addHiddenSelectItem(qd.select, fromTID, cicoInfo.Date_MID);
+                }
+                if (!qd.select.find(o => o.mid == cicoInfo.Ver_MID) && cicoInfo.Ver_CanViewOrUpdate == AccessLevels.Yes) {
+                    addHiddenSelectItem(qd.select, fromTID, cicoInfo.Ver_MID);
+                }
+            }
+        }
+        if (qd.orderBy && qd.orderBy.length <= 0) {
+            let obi = new OrderByItem();
+            obi.tid = fromTID;
+            obi.mid = SystemMIDsAsNumber.DID;
+            obi.asc = false;
+            qd.orderBy.push(obi);
+        }
+    }
+    // Alcuni lavori di ORCHESTRATOR non definiscono i SelectItem (per esempio, CheckSequence, DcmtPrinter, ...).
+    // In tal caso il risultato della ricerca risultava senza colonne (metadati).
+    // In questa condizione si è deciso di visualizzare, di default, i primi 10 metadati.
+    if (!qdWithAggrFunctions && qd.select.filter(o => o.mid > 100).length <= 0) {
+        let dtd = await DcmtTypeListCacheService.GetAsync(fromTID, true);
+        if (dtd?.metadata) {
+            for (const md of dtd.metadata.filter(o => o.isSystem != 1 && o.perm?.canView != AccessLevels.No).slice(0, 10)) {
+                let si = new SelectItem();
+                si.visibility = SelectItemVisibilities.Visible;
+                si.tid = dtd.id;
+                si.mid = md.id;
+                qd.select.push(si);
+            }
+        }
+    }
+    qd.isLexProt = 1;
+    // Apply Filters for Connectors
+    addWhereClausesForConnect(qd);
+    return qd;
+};
+export function addWhereClausesForConnect(qd) {
+    switch (SDK_Globals.tmSession?.SessionDescr?.appModuleID) {
+        case AppModules.EXCEL_CONNECTOR:
+        case AppModules.OUTLOOK_CONNECTOR:
+        case AppModules.POWERPOINT_CONNECTOR:
+        case AppModules.WORD_CONNECTOR:
+            break; // Continua l'esecuzione per questi moduli
+        default:
+            return; // Esci dalla funzione per tutti gli altri moduli
+    }
+    let connectForWEPExts = '';
+    switch (SDK_Globals.tmSession?.SessionDescr?.appModuleID) {
+        case AppModules.EXCEL_CONNECTOR:
+            connectForWEPExts = "'XLS', 'XLT', 'XLM', 'XLSX', 'XLSM', 'XLSB', 'XLAM', 'XLTX', 'XLTM'";
+            break;
+        case AppModules.POWERPOINT_CONNECTOR:
+            connectForWEPExts = "'PPT', 'PPTX', 'PPTM', 'PPSX', 'PPS', 'PPSM'";
+            break;
+        case AppModules.WORD_CONNECTOR:
+            connectForWEPExts = "'DOCX', 'DOCM', 'DOTX', 'DOTM', 'DOC', 'DOT', 'HTM', 'HTML', 'RTF', 'MHT', 'MHTML', 'XML', 'ODT', 'TXT'";
+            break;
+    }
+    qd.where ??= [];
+    // ( <filtri utente> ) AND FileCount > 0 [AND FileExt IN (....)]
+    if (qd.where.length >= 2) {
+        qd.where[0].leftBrackets = '(' + qd.where[0].leftBrackets;
+        qd.where[qd.where.length - 1].rightBrackets += ')';
+    }
+    let wiFileCount = new WhereItem();
+    wiFileCount.tid = qd.from?.tid;
+    wiFileCount.mid = SystemMIDsAsNumber.FileCount;
+    wiFileCount.operator = QueryOperators.Greater;
+    wiFileCount.value1 = '0';
+    wiFileCount.or = false;
+    wiFileCount.leftBrackets = '(';
+    wiFileCount.rightBrackets = ')';
+    qd.where.push(wiFileCount);
+    if (connectForWEPExts !== '') {
+        let wiFileExt = new WhereItem();
+        wiFileExt.tid = qd.from?.tid;
+        wiFileExt.mid = SystemMIDsAsNumber.FileExt;
+        wiFileExt.operator = QueryOperators.In;
+        wiFileExt.value1 = connectForWEPExts;
+        wiFileExt.or = false;
+        wiFileExt.leftBrackets = '(';
+        wiFileExt.rightBrackets = ')';
+        qd.where.push(wiFileExt);
+    }
+}
+export function getDefaultOperator(dataDomain, dataType) {
+    if (dataDomain == MetadataDataDomains.DataList)
+        return QueryOperators.In;
+    return dataType == MetadataDataTypes.Varchar ? QueryOperators.Contain : QueryOperators.Equal;
+}
+export const getQD = async (tid, easyOr) => {
+    let dtd = await DcmtTypeListCacheService.GetAsync(tid);
+    if (!dtd?.metadata)
+        return;
+    let qd = SearchEngine.NewQueryDescriptor();
+    qd.isDistinct = false;
+    qd.id = 1;
+    qd.maxDcmtsToBeReturned = 1000;
+    qd.from = new FromItem();
+    qd.from.tid = tid;
+    qd.select = [];
+    for (const md of dtd.metadata) {
+        if ((md?.perm?.canView == AccessLevels.No) && (md?.perm?.canUpdate == AccessLevels.No))
+            continue;
+        if (md.isSystem == 1)
+            continue;
+        let si = new SelectItem();
+        si.visibility = SelectItemVisibilities.Visible;
+        si.tid = dtd.id;
+        si.mid = md.id;
+        qd.select.push(si);
+    }
+    qd.where = [];
+    for (const md of dtd.metadata) {
+        if (md?.perm?.canSearch == AccessLevels.No)
+            continue;
+        if (md.isSystem == 1)
+            continue;
+        let wi = new WhereItem();
+        wi.or = easyOr;
+        wi.leftBrackets = "(";
+        wi.tid = dtd.id;
+        wi.mid = md.id;
+        wi.operator = getDefaultOperator(md.dataDomain, md.dataType);
+        wi.rightBrackets = ")";
+        qd.where.push(wi);
+    }
+    return qd;
+};
+export const getWorkItemSetIDAsync = async (vid, did) => {
+    let dtd = await DcmtTypeListCacheService.GetAsync(vid);
+    if (!dtd?.metadata)
+        return undefined;
+    let mdSetID = dtd.metadata.find(o => o.name === WorkItemMetadataNames.WI_SetID);
+    if (!mdSetID)
+        return undefined;
+    let qd = SearchEngine.NewQueryDescriptor();
+    if (!qd.from)
+        return undefined;
+    qd.from.tid = vid;
+    qd.select = [];
+    let si = new SelectItem();
+    si.tid = vid;
+    si.mid = mdSetID.id;
+    si.visibility = SelectItemVisibilities.Visible;
+    qd.select.push(si);
+    qd.where = [];
+    let wiDID = new WhereItem();
+    wiDID.tid = vid;
+    wiDID.mid = SystemMIDsAsNumber.DID;
+    wiDID.operator = QueryOperators.Equal;
+    wiDID.value1 = did.toString();
+    wiDID.or = false;
+    wiDID.leftBrackets = '(';
+    wiDID.rightBrackets = ')';
+    qd.where.push(wiDID);
+    let result = await SDK_Globals.tmSession?.NewSearchEngine().SearchByIDAsync(qd);
+    return result?.dtdResult?.rows?.[0]?.[0];
+};
+export const getSysAllDcmtsSQD = async (tid, easyOr) => {
+    let sqd = new SavedQueryDescriptor();
+    sqd.id = 1;
+    sqd.masterTID = tid;
+    sqd.isEasyWhere = 1;
+    sqd.name = SDKUI_Localizator.AllDcmts;
+    sqd.qd = await getQD(tid, easyOr);
+    return sqd;
+};
+export const searchResultToMetadataValues = (tid, dtd, rows, mids, metadata, layoutMode) => {
+    if (!metadata || metadata.length === 0) {
+        return [];
+    }
+    const outputMetadataList = [];
+    const isLexProtIndex = dtd?.columns?.findIndex(col => col.caption === 'IsLexProt') !== -1 ? dtd?.columns?.findIndex(col => col.caption === 'IsLexProt') : 0;
+    const createMetadataProps = (tid, md, value, isLexProt) => {
+        const isNumeratorInArk = md.dataDomain === MetadataDataDomains.Numerator && layoutMode === LayoutModes.Ark;
+        const hasDefaultValue = md.defaultValue !== undefined;
+        let mvd = new MetadataValueDescriptorEx();
+        mvd.tid = tid;
+        mvd.mid = md.id;
+        mvd.md = md;
+        mvd.value = (md.dataDomain === MetadataDataDomains.Numerator && layoutMode === LayoutModes.Ark) ? undefined : value;
+        mvd.isRequired = isNumeratorInArk || hasDefaultValue ? '0' : md.isRequired?.toString();
+        mvd.isLexProt = isLexProt;
+        // Tipo documento SYSTEM - Bozze, imposta sola lettura + localizzazione
+        if (tid === SystemTIDs.Drafts) {
+            switch (mvd.mid) {
+                case DraftsMIDs.Name:
+                    mvd.customName = SDKUI_Localizator.Name;
+                    break;
+                case DraftsMIDs.Description:
+                    mvd.customName = SDKUI_Localizator.Description;
+                    break;
+                case DraftsMIDs.Ver:
+                    mvd.customName = SDKUI_Localizator.Version;
+                    mvd.isReadOnly = true;
+                    break;
+                case DraftsMIDs.LastVer:
+                    mvd.customName = SDKUI_Localizator.LastVersion;
+                    mvd.isReadOnly = true;
+                    break;
+                case DraftsMIDs.CheckOutDate:
+                    mvd.customName = SDKUI_Localizator.ExtractedOn;
+                    mvd.isReadOnly = true;
+                    break;
+                case DraftsMIDs.CheckOutUserID:
+                    mvd.customName = SDKUI_Localizator.ExtractedBy;
+                    mvd.isReadOnly = true;
+                    break;
+                case SystemMIDsAsNumber.FileExt:
+                    mvd.customName = SDKUI_Localizator.Extension;
+                    mvd.isReadOnly = true;
+                    break;
+                case SystemMIDsAsNumber.FileSize:
+                    mvd.customName = SDKUI_Localizator.File_Size;
+                    mvd.isReadOnly = true;
+                    break;
+                case SystemMIDsAsNumber.LastUpdateTime:
+                    mvd.customName = SDKUI_Localizator.LastUpdateTime;
+                    mvd.isReadOnly = true;
+                    break;
+                case SystemMIDsAsNumber.CreationTime:
+                    mvd.customName = SDKUI_Localizator.CreationTime;
+                    mvd.isReadOnly = true;
+                    break;
+            }
+        }
+        if (tid === SystemTIDs.Chronology) {
+            switch (mvd.mid) {
+                case ChronologyMIDs.Ver:
+                    mvd.customName = SDKUI_Localizator.Version;
+                    mvd.isReadOnly = true;
+                    break;
+                case ChronologyMIDs.AuthorID:
+                    mvd.customName = SDKUI_Localizator.Author;
+                    mvd.isReadOnly = true;
+                    break;
+            }
+        }
+        return mvd;
+    };
+    metadata.forEach(md => {
+        if (!md.id)
+            return;
+        if (layoutMode === LayoutModes.Ark && !handleArchiveVisibility(md))
+            return;
+        if (!rows)
+            return;
+        if (mids.length > 0) {
+            const index = mids.indexOf(md.id);
+            if (index >= 0) {
+                const isLexProt = (isLexProtIndex !== undefined && rows[isLexProtIndex]) ? (parseInt(rows[isLexProtIndex]) || undefined) : undefined;
+                outputMetadataList.push(createMetadataProps(tid, md, rows[index], isLexProt));
+            }
+        }
+        else {
+            let defaultValue;
+            if (layoutMode === LayoutModes.Ark && (md.dataDomain === MetadataDataDomains.DataList || md.dataDomain === MetadataDataDomains.DynamicDataList || md.dataDomain === MetadataDataDomains.UserID))
+                defaultValue = md.defaultValue;
+            outputMetadataList.push(createMetadataProps(tid, md, defaultValue, undefined));
+        }
+    });
+    return outputMetadataList;
+};
+export const handleArchiveVisibility = (md) => {
+    if (md.dataDomain === MetadataDataDomains.Computed ||
+        md.perm?.canArchive !== AccessLevels.Yes ||
+        md.isSystem === 1 ||
+        md.isRootMID !== 1)
+        return false;
+    return true;
+};

package/lib/hooks/useCheckInOutOperations.d.ts

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

package/lib/hooks/useCheckInOutOperations.js

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