@topconsultnpm/sdkui-react 6.20.0-dev1.12 → 6.20.0-dev1.120

package/lib/helper/devextremeCustomMessages.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Custom DevExtreme localization messages
+ * Contains missing translations for DevExtreme components
+ */
+export declare const devextremeCustomMessages: {
+    de: {
+        "dxDataGrid-moveColumnToTheRight": string;
+        "dxDataGrid-moveColumnToTheLeft": string;
+    };
+    en: {
+        "dxDataGrid-moveColumnToTheRight": string;
+        "dxDataGrid-moveColumnToTheLeft": string;
+    };
+    es: {
+        "dxDataGrid-moveColumnToTheRight": string;
+        "dxDataGrid-moveColumnToTheLeft": string;
+    };
+    fr: {
+        "dxDataGrid-moveColumnToTheRight": string;
+        "dxDataGrid-moveColumnToTheLeft": string;
+    };
+    it: {
+        "dxDataGrid-moveColumnToTheRight": string;
+        "dxDataGrid-moveColumnToTheLeft": string;
+    };
+    pt: {
+        "dxDataGrid-moveColumnToTheRight": string;
+        "dxDataGrid-moveColumnToTheLeft": string;
+    };
+};

package/lib/helper/devextremeCustomMessages.js

@@ -0,0 +1,30 @@
+/**
+ * Custom DevExtreme localization messages
+ * Contains missing translations for DevExtreme components
+ */
+export const devextremeCustomMessages = {
+    "de": {
+        "dxDataGrid-moveColumnToTheRight": "Nach rechts verschieben",
+        "dxDataGrid-moveColumnToTheLeft": "Nach links verschieben"
+    },
+    "en": {
+        "dxDataGrid-moveColumnToTheRight": "Move to the right",
+        "dxDataGrid-moveColumnToTheLeft": "Move to the left"
+    },
+    "es": {
+        "dxDataGrid-moveColumnToTheRight": "Mover a la derecha",
+        "dxDataGrid-moveColumnToTheLeft": "Mover a la izquierda"
+    },
+    "fr": {
+        "dxDataGrid-moveColumnToTheRight": "Déplacer vers la droite",
+        "dxDataGrid-moveColumnToTheLeft": "Déplacer vers la gauche"
+    },
+    "it": {
+        "dxDataGrid-moveColumnToTheRight": "Sposta a destra",
+        "dxDataGrid-moveColumnToTheLeft": "Sposta a sinistra"
+    },
+    "pt": {
+        "dxDataGrid-moveColumnToTheRight": "Mover para a direita",
+        "dxDataGrid-moveColumnToTheLeft": "Mover para a esquerda"
+    }
+};

package/lib/helper/helpers.d.ts

@@ -1,6 +1,6 @@
 import { Colors as ColorsType } from "../components/base/TMEditorBase";
 import { DeviceType } from "../components";
-import { AppModules, DataColumnDescriptor, ITopMediaSession, MetadataDescriptor, QueryDescriptor, SearchResultDescriptor } from "@topconsultnpm/sdk-ts";
+import { AppModules, DataColumnDescriptor, DcmtTypeDescriptor, ITopMediaSession, MetadataDescriptor, QueryDescriptor, SearchResultDescriptor, TaskDescriptor } from "@topconsultnpm/sdk-ts";
 import { FileExtensionHandler, FormModes, moduleTypes } from "../ts";
 declare const TABLET_WIDTH = 1024;
 declare const MOBILE_WIDTH = 640;
@@ -37,6 +37,7 @@ export declare const extensionHandler: (fileExt: string | undefined) => FileExte
 export declare const downloadBase64File: (base64Data: string, fileName: string) => void;
 export declare const TASK_MORE_INFO_PREFIX_NAME: string;
 export declare const isTaskMoreInfo: (taskName: string | undefined) => boolean | undefined;
+export declare const getMoreInfoTasksForDocument: (allTasks: TaskDescriptor[], TID: number | null | undefined, DID: number | null | undefined) => TaskDescriptor[];
 export declare const canNext: (visibleItems: any[], selectedItems: any[]) => boolean;
 export declare const getNext: (visibleItems: any[], selectedItems: any[]) => any;
 export declare const canPrev: (visibleItems: any[], selectedItems: any[]) => boolean;
@@ -66,7 +67,8 @@ export declare enum LandingPages {
     RECENT = "recent",
     AREA_MANAGER = "areaManager",
     NOTIFICATIONS = "notifications",
-    ACTIVITIES = "activities"
+    ACTIVITIES = "activities",
+    WORKFLOW_CTRL = "workflowCtrl"
 }
 export declare function getExceptionMessage(ex: any): string;
 export declare function getContrastColor(inputColor: string): {
@@ -89,3 +91,29 @@ export declare class AreaHelper {
     static ExtractAreaInfo_1(areaPath: string): AreaValues;
     static ExtractAreaInfo_2(areaPath: string, extractFileName: boolean): AreaValues;
 }
+export declare const isApprovalWorkflowView: (dtd: DcmtTypeDescriptor) => boolean;
+export interface SessionIpInfo {
+    publicIp: string;
+    localIp: string;
+    forwardedFor: string;
+}
+export declare const getSessionIpInfo: () => SessionIpInfo;
+interface BrowserAuditInfo {
+    name: string;
+    version: string;
+    os: string;
+    language: string;
+    screenWidth: number;
+    screenHeight: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    colorDepth: number;
+    pixelRatio: number;
+    timezone: string;
+    cookiesEnabled: boolean;
+    onlineStatus: boolean;
+    touchSupport: boolean;
+    userAgent: string;
+    toString(): string;
+}
+export declare const getBrowserAuditInfo: () => BrowserAuditInfo;

package/lib/helper/helpers.js

@@ -1,7 +1,7 @@
 import { Fragment as _Fragment, jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Colors } from "../utils/theme";
 import { ButtonNames, DeviceType, TMExceptionBoxManager, TMMessageBoxManager, TMSpinner } from "../components";
-import { AccessLevels, MetadataDataDomains, MetadataDataTypes, MetadataDescriptor, MetadataFormatDescriptor, MetadataFormats, MetadataPermission, SDK_Globals, SetGlobalsInfoAsync, SystemMIDs, SystemMIDsAsNumber, TopMediaServer } from "@topconsultnpm/sdk-ts";
+import { AccessLevels, MetadataDataDomains, MetadataDataTypes, MetadataDescriptor, MetadataFormatDescriptor, MetadataFormats, MetadataPermission, SDK_Globals, SetGlobalsInfoAsync, SystemMIDs, SystemMIDsAsNumber, Task_States, TopMediaServer, WorkItemMetadataNames } from "@topconsultnpm/sdk-ts";
 import { Buffer } from 'buffer';
 import { buildTypes, FileExtensionHandler, FormModes, moduleTypes } from "../ts";
 import { SDKUI_Localizator } from "./SDKUI_Localizator";
@@ -505,7 +505,8 @@ export const extensionHandler = (fileExt) => {
         case 'txt': return FileExtensionHandler.READY_TO_SHOW;
         case 'config':
         case 'cfg':
-        case 'json': return FileExtensionHandler.READY_TO_SHOW;
+        case 'json':
+        case 'sql': return FileExtensionHandler.READY_TO_SHOW;
         default: return FileExtensionHandler.NONE;
     }
 };
@@ -531,6 +532,17 @@ export const downloadBase64File = (base64Data, fileName) => {
 };
 export const TASK_MORE_INFO_PREFIX_NAME = `${SDKUI_Localizator.MoreInformation} - `;
 export const isTaskMoreInfo = (taskName) => taskName?.startsWith(TASK_MORE_INFO_PREFIX_NAME);
+// Filtra i task di tipo "More Info" non completati associati a un documento specifico.
+export const getMoreInfoTasksForDocument = (allTasks, TID, DID) => {
+    if (TID === null || DID === null)
+        return [];
+    if (TID === undefined || DID === undefined)
+        return [];
+    return allTasks.filter(task => isTaskMoreInfo(task.name) &&
+        task.state !== Task_States.Completed &&
+        task.iD1?.toString() === TID.toString() &&
+        task.iD2?.toString() === DID.toString());
+};
 //#region Form, Page Helpers
 export const canNext = (visibleItems, selectedItems) => {
     if (!visibleItems)
@@ -664,7 +676,13 @@ export const renderHighlightedText = (text, searchText, isSelected) => {
     return text.split(regex).map((part, index) => regex.test(part) ? (_jsx("span", { style: { backgroundColor: isSelected ? '#6c9023' : 'yellow' }, children: part }, index)) : (part));
 };
 export function versionAndBuildtypeInfo(module) {
-    return moduleVersion(module);
+    switch (module) {
+        case moduleTypes.SDK:
+        case moduleTypes.SDKUI:
+            return moduleVersion(module).replace("-hotfix.", "+hotfix").replace("-hotfix", "+hotfix");
+        default:
+            return moduleVersion(module);
+    }
 }
 export const getListMaxItems = (deviceType) => { return deviceType === DeviceType.MOBILE ? 8 : 12; };
 export const svgToString = (icon) => {
@@ -710,6 +728,7 @@ export var LandingPages;
     LandingPages["AREA_MANAGER"] = "areaManager";
     LandingPages["NOTIFICATIONS"] = "notifications";
     LandingPages["ACTIVITIES"] = "activities";
+    LandingPages["WORKFLOW_CTRL"] = "workflowCtrl";
 })(LandingPages || (LandingPages = {}));
 // #endregion
 // #region Exception
@@ -850,3 +869,112 @@ export class AreaHelper {
 }
 AreaHelper.AreaPathPrefix = "tmarea:\\\\";
 AreaHelper.AreaFolderNamePrefix = "AID_";
+export const isApprovalWorkflowView = (dtd) => {
+    return Boolean(dtd?.isView &&
+        dtd.metadata?.some(data => data.name === WorkItemMetadataNames.WI_DID));
+};
+// Recupera e normalizza le informazioni IP dalla sessione corrente
+export const getSessionIpInfo = () => {
+    // Lettura sicura del valore globale
+    const raw = SDK_Globals.tmSession?.SessionDescr?.customData2;
+    // Se non esiste, ritorna struttura vuota
+    if (!raw) {
+        return {
+            publicIp: "",
+            localIp: "",
+            forwardedFor: ""
+        };
+    }
+    try {
+        // Se è stringa, effettua il parse JSON
+        const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+        // Normalizza i campi garantendo sempre stringhe
+        return {
+            publicIp: parsed?.publicIp ?? "",
+            localIp: parsed?.localIp ?? "",
+            forwardedFor: parsed?.forwardedFor ?? ""
+        };
+    }
+    catch {
+        // In caso di errore JSON, ritorna valori vuoti
+        return {
+            publicIp: "",
+            localIp: "",
+            forwardedFor: ""
+        };
+    }
+};
+export const getBrowserAuditInfo = () => {
+    // Funzione per rilevare browser e versione
+    const detectBrowser = () => {
+        const ua = navigator.userAgent;
+        if (ua.includes("Chrome") && !ua.includes("Edg")) {
+            const match = ua.match(/Chrome\/([\d.]+)/);
+            return { name: "Chrome", version: match?.[1] ?? "unknown" };
+        }
+        if (ua.includes("Edg")) {
+            const match = ua.match(/Edg\/([\d.]+)/);
+            return { name: "Edge", version: match?.[1] ?? "unknown" };
+        }
+        if (ua.includes("Firefox")) {
+            const match = ua.match(/Firefox\/([\d.]+)/);
+            return { name: "Firefox", version: match?.[1] ?? "unknown" };
+        }
+        if (ua.includes("Safari") && !ua.includes("Chrome")) {
+            const match = ua.match(/Version\/([\d.]+)/);
+            return { name: "Safari", version: match?.[1] ?? "unknown" };
+        }
+        return { name: "Unknown", version: "unknown" };
+    };
+    // Funzione per rilevare il sistema operativo (sostituisce navigator.platform deprecato)
+    const detectOS = () => {
+        const ua = navigator.userAgent;
+        if (ua.includes("Win"))
+            return "Windows";
+        if (ua.includes("Mac"))
+            return "macOS";
+        if (ua.includes("Linux"))
+            return "Linux";
+        if (ua.includes("Android"))
+            return "Android";
+        if (ua.includes("iOS") || ua.includes("iPhone") || ua.includes("iPad"))
+            return "iOS";
+        return "Unknown";
+    };
+    // Rileva supporto touch
+    const hasTouchSupport = () => {
+        return 'ontouchstart' in window || navigator.maxTouchPoints > 0;
+    };
+    const browser = detectBrowser();
+    const os = detectOS();
+    const info = {
+        name: browser.name,
+        version: browser.version,
+        os: os,
+        language: navigator.language,
+        screenWidth: screen.width,
+        screenHeight: screen.height,
+        viewportWidth: window.innerWidth,
+        viewportHeight: window.innerHeight,
+        colorDepth: screen.colorDepth,
+        pixelRatio: window.devicePixelRatio || 1,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        cookiesEnabled: navigator.cookieEnabled,
+        onlineStatus: navigator.onLine,
+        touchSupport: hasTouchSupport(),
+        userAgent: navigator.userAgent,
+        toString() {
+            return [
+                `Browser: ${this.name} ${this.version}`,
+                `OS: ${this.os}`,
+                `Language: ${this.language}`,
+                `Timezone: ${this.timezone}`,
+                `Screen: ${this.screenWidth}x${this.screenHeight} (${this.colorDepth}bit, ${this.pixelRatio}x)`,
+                `Viewport: ${this.viewportWidth}x${this.viewportHeight}`,
+                // `Features: Cookies=${this.cookiesEnabled}, Online=${this.onlineStatus}, Touch=${this.touchSupport}`,
+                `UserAgent: ${this.userAgent}`
+            ].join(' | ');
+        },
+    };
+    return info;
+};

package/lib/helper/index.d.ts

@@ -9,6 +9,8 @@ export * from './queryHelper';
 export * from './TMUtils';
 export * from './TMCommandsContextMenu';
 export * from './TMConditionalWrapper';
+export * from './TMPdfViewer';
 export * from './TMToppyMessage';
 export * from './GlobalStyles';
 export * from './checkinCheckoutManager';
+export * from './workItemsHelper';

package/lib/helper/index.js

@@ -9,6 +9,8 @@ export * from './queryHelper';
 export * from './TMUtils';
 export * from './TMCommandsContextMenu';
 export * from './TMConditionalWrapper';
+export * from './TMPdfViewer';
 export * from './TMToppyMessage';
 export * from './GlobalStyles';
 export * from './checkinCheckoutManager';
+export * from './workItemsHelper';

package/lib/helper/queryHelper.d.ts

@@ -12,7 +12,7 @@ export declare const addHiddenSelectItem: (select: SelectItem[], tid: number | u
 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 getQD: (tid: number | undefined, easyOr: boolean, newMaxDcmtsToBeReturned: number) => 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[];

package/lib/helper/queryHelper.js

@@ -2,6 +2,8 @@ import { AccessLevels, MetadataDataDomains, DcmtTypeListCacheService, SystemMIDs
 import { DateDisplayTypes, Globalization } from './Globalization';
 import { ChronologyMIDs, DraftsMIDs, MetadataValueDescriptorEx } from '../ts';
 import { SDKUI_Localizator } from './SDKUI_Localizator';
+import { getDcmtCicoInfo } from './checkinCheckoutManager';
+import { SDKUI_Globals } from './SDKUI_Globals';
 export const getTIDsByQd = (qd) => {
     let tids = [];
     qd?.from?.tid && tids.push({ tid: qd.from?.tid, alias: undefined });
@@ -82,6 +84,22 @@ export const prepareQdForSearchAsync = async (qdInput, removeWhereItemNoValue) =
         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;
@@ -164,14 +182,14 @@ export function getDefaultOperator(dataDomain, dataType) {
         return QueryOperators.In;
     return dataType == MetadataDataTypes.Varchar ? QueryOperators.Contain : QueryOperators.Equal;
 }
-export const getQD = async (tid, easyOr) => {
+export const getQD = async (tid, easyOr, newMaxDcmtsToBeReturned) => {
     let dtd = await DcmtTypeListCacheService.GetAsync(tid);
     if (!dtd?.metadata)
         return;
     let qd = SearchEngine.NewQueryDescriptor();
     qd.isDistinct = false;
     qd.id = 1;
-    qd.maxDcmtsToBeReturned = 1000;
+    qd.maxDcmtsToBeReturned = newMaxDcmtsToBeReturned;
     qd.from = new FromItem();
     qd.from.tid = tid;
     qd.select = [];
@@ -239,7 +257,7 @@ export const getSysAllDcmtsSQD = async (tid, easyOr) => {
     sqd.masterTID = tid;
     sqd.isEasyWhere = 1;
     sqd.name = SDKUI_Localizator.AllDcmts;
-    sqd.qd = await getQD(tid, easyOr);
+    sqd.qd = await getQD(tid, easyOr, SDKUI_Globals.userSettings.searchSettings?.maxDcmtsToBeReturned ?? 1000);
     return sqd;
 };
 export const searchResultToMetadataValues = (tid, dtd, rows, mids, metadata, layoutMode) => {
@@ -311,6 +329,18 @@ export const searchResultToMetadataValues = (tid, dtd, rows, mids, metadata, lay
                     mvd.customName = SDKUI_Localizator.Author;
                     mvd.isReadOnly = true;
                     break;
+                case ChronologyMIDs.CheckInTime:
+                    mvd.customName = SDKUI_Localizator.LastUpdateTime;
+                    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;
             }
         }
         return mvd;

package/lib/helper/workItemsHelper.d.ts

@@ -0,0 +1,6 @@
+import { IWorkItemData, WFInstanceDescriptor } from '../ts';
+/**
+ * Helper function per costruire IWorkItemData da un WFInstanceDescriptor
+ * Effettua le chiamate API necessarie e popola tutti i campi disponibili
+ */
+export declare const buildWorkItemsFromWFCtrl: (wfInstance: WFInstanceDescriptor) => Promise<IWorkItemData[]>;

package/lib/helper/workItemsHelper.js

@@ -0,0 +1,230 @@
+import { SDK_Globals, WorkItemMetadataNames, SystemDataListIDs } from '@topconsultnpm/sdk-ts';
+import { WorkflowCacheService, DataListCacheService, UserListCacheService, DcmtTypeListCacheService } from '@topconsultnpm/sdk-ts';
+import { parseWfDiagramXml } from '../components/features/workflow/diagram/xmlParser';
+/**
+ * Helper function per costruire IWorkItemData da un WFInstanceDescriptor
+ * Effettua le chiamate API necessarie e popola tutti i campi disponibili
+ */
+export const buildWorkItemsFromWFCtrl = async (wfInstance) => {
+    const { wfid, tid: mtid, did: mdid, instanceId } = wfInstance;
+    if (!wfid || !mtid || !mdid) {
+        return [];
+    }
+    // Recupera il workflow descriptor
+    const workflow = await WorkflowCacheService.GetWFCtrlInfoAsync(wfid);
+    // Recupera tutti i work items per questo workflow usando WFCtrl_RetrieveAllWIsAsync
+    const workItemsResult = await SDK_Globals.tmSession?.NewWorkflowEngine().WFCtrl_RetrieveAllWIsAsync(wfid, mtid, mdid, instanceId);
+    // Se non ci sono work items, restituisci array vuoto
+    if (!workItemsResult || workItemsResult.dcmtsFound === 0 || !workItemsResult.dtdResult?.rows) {
+        return [];
+    }
+    // Recupera la DataList degli stati del workflow
+    const dldStatus = await DataListCacheService.GetAsync(SystemDataListIDs.WIStates);
+    // Parse del diagramma del workflow per ottenere type e name dai diagramItems
+    let wfDiagram;
+    if (workflow?.diagram) {
+        try {
+            wfDiagram = parseWfDiagramXml(workflow.diagram);
+        }
+        catch (error) {
+            console.warn('Errore nel parsing del diagramma workflow:', error);
+        }
+    }
+    // Recupera il DTD per ottenere i MID dai nomi dei metadati
+    const dtd = await DcmtTypeListCacheService.GetAsync(workItemsResult.fromTID);
+    if (!dtd?.metadata) {
+        return [];
+    }
+    // Crea una mappa nome metadato -> MID
+    const metadataNameToMID = {};
+    for (const meta of dtd.metadata) {
+        if (meta.name) {
+            metadataNameToMID[meta.name] = meta.id;
+        }
+    }
+    const columns = workItemsResult.dtdResult.columns || [];
+    // Funzione helper per trovare l'indice di una colonna tramite MID
+    const findColumnIndexByMID = (mid) => {
+        if (mid === -1)
+            return -1;
+        return columns.findIndex(col => col.extendedProperties?.MID === mid.toString());
+    };
+    // Mappa degli indici delle colonne usando MID
+    const columnIndices = {
+        tid: 0, // TID è sempre il primo
+        did: 1, // DID è sempre il secondo
+        setID: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_SetID] ?? -1),
+        creationTime: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_CreationTime] ?? -1),
+        response: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_Response] ?? -1),
+        completionTime: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_CompletionTime] ?? -1),
+        from: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_From] ?? -1),
+        to: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_To] ?? -1),
+        or: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_Or] ?? -1),
+        status: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_Status] ?? -1),
+        category: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_Category] ?? -1),
+        description: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_Description] ?? -1),
+        setStatus: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_SetStatus] ?? -1),
+        setRule: findColumnIndexByMID(metadataNameToMID[WorkItemMetadataNames.WI_SetRule] ?? -1),
+    };
+    // Crea i WorkItemDetail
+    const details = [];
+    for (let i = 0; i < workItemsResult.dtdResult.rows.length; i++) {
+        const row = workItemsResult.dtdResult.rows[i];
+        const tid = Number(row[columnIndices.tid]);
+        const did = Number(row[columnIndices.did]);
+        const setID = columnIndices.setID !== -1 ? row[columnIndices.setID] : '';
+        const toUserID = columnIndices.to !== -1 ? Number(row[columnIndices.to]) : undefined;
+        // Risolvi l'utente usando la cache
+        let toUser = undefined;
+        if (toUserID !== undefined) {
+            try {
+                toUser = await UserListCacheService.GetAsync(toUserID);
+            }
+            catch (error) {
+                console.warn(`Impossibile recuperare l'utente con ID ${toUserID}:`, error);
+            }
+        }
+        // Calcola lo status come DataListItemDescriptor
+        let statusItem = undefined;
+        if (columnIndices.status !== -1) {
+            const rawStatusValue = row[columnIndices.status];
+            if (rawStatusValue !== undefined && rawStatusValue !== null && dldStatus?.items) {
+                statusItem = dldStatus.items.find(item => item.value === rawStatusValue);
+            }
+        }
+        details.push({
+            wid: `${tid}_${did}`,
+            tid,
+            did,
+            wfid: workflow?.id ?? 0,
+            approvalVID: workflow?.approvalVID ?? 0,
+            setID,
+            creationTime: columnIndices.creationTime !== -1 && row[columnIndices.creationTime]
+                ? new Date(row[columnIndices.creationTime])
+                : undefined,
+            response: columnIndices.response !== -1 ? row[columnIndices.response] : undefined,
+            completionTime: columnIndices.completionTime !== -1 && row[columnIndices.completionTime]
+                ? new Date(row[columnIndices.completionTime])
+                : undefined,
+            from: columnIndices.from !== -1 ? Number(row[columnIndices.from]) : undefined,
+            to: toUserID,
+            toUser: toUser,
+            or: columnIndices.or !== -1 ? Number(row[columnIndices.or]) : undefined,
+            status: statusItem,
+        });
+    }
+    // Raggruppa per setID considerando il creationTime e setStatus
+    // Ordiniamo tutti i details per creationTime (ordine cronologico)
+    const sortedAllDetails = [...details].sort((a, b) => {
+        if (!a.creationTime || !b.creationTime)
+            return 0;
+        return a.creationTime.getTime() - b.creationTime.getTime();
+    });
+    // Crea una mappa detail -> setStatus per avere accesso al setStatus di ogni detail
+    const detailSetStatusMap = new Map();
+    for (const detail of details) {
+        const row = workItemsResult.dtdResult?.rows?.find(r => Number(r[columnIndices.tid]) === detail.tid &&
+            Number(r[columnIndices.did]) === detail.did);
+        if (row && columnIndices.setStatus !== -1) {
+            const setStatusValue = row[columnIndices.setStatus];
+            detailSetStatusMap.set(detail, setStatusValue?.toString() ?? '');
+        }
+    }
+    /**
+     * Logica di raggruppamento sequenziale dei workitems:
+     *
+     * Regole:
+     * 1. Primo workitem o SetID diverso => Nuovo step
+     *    - Se SetStatus = "0" (Nuovo): attiva modalità aggregazione per tutti i successivi
+     *
+     * 2. Stesso SetID del precedente:
+     *    - In modalità aggregazione (SetStatus = "0"): aggrega sempre nello stesso step
+     *    - SetStatus != "0": raggruppa per stesso SetStatus
+     *      - Stesso SetStatus => aggrega
+     *      - SetStatus diverso => nuovo step
+     *    - SetStatus = "0": nuovo step e attiva modalità aggregazione
+     */
+    const groups = [];
+    let previousSetID = undefined;
+    let previousSetStatus = undefined;
+    let isInNewStatusMode = false;
+    for (const detail of sortedAllDetails) {
+        const currentSetStatus = detailSetStatusMap.get(detail) ?? '';
+        const currentSetID = detail.setID;
+        if (previousSetID === undefined || currentSetID !== previousSetID) {
+            // Nuovo SetID: crea nuovo step
+            groups.push([detail]);
+            previousSetID = currentSetID;
+            previousSetStatus = currentSetStatus;
+            isInNewStatusMode = currentSetStatus === '0';
+        }
+        else {
+            // Stesso SetID
+            if (isInNewStatusMode) {
+                // Modalità aggregazione attiva: aggrega sempre
+                groups[groups.length - 1].push(detail);
+            }
+            else {
+                if (currentSetStatus === '0') {
+                    // SetStatus "Nuovo": nuovo step e attiva modalità aggregazione
+                    groups.push([detail]);
+                    isInNewStatusMode = true;
+                    previousSetStatus = currentSetStatus;
+                }
+                else {
+                    // SetStatus diverso da "Nuovo": raggruppa per stesso SetStatus
+                    if (currentSetStatus !== previousSetStatus) {
+                        groups.push([detail]);
+                        previousSetStatus = currentSetStatus;
+                    }
+                    else {
+                        groups[groups.length - 1].push(detail);
+                    }
+                }
+            }
+        }
+    }
+    // Crea IWorkItemData per ogni gruppo con tutti i campi disponibili
+    const finalWorkItems = groups.map((groupDetails, groupIndex) => {
+        const setID = groupDetails[0].setID;
+        // Ordina per creationTime (più recente prima)
+        const sortedDetails = [...groupDetails].sort((a, b) => {
+            if (!a.creationTime || !b.creationTime)
+                return 0;
+            return b.creationTime.getTime() - a.creationTime.getTime();
+        });
+        const latest = sortedDetails[0];
+        const latestRow = workItemsResult.dtdResult?.rows?.find(row => Number(row[columnIndices.tid]) === latest.tid &&
+            Number(row[columnIndices.did]) === latest.did);
+        // Calcola il setStatus come DataListItemDescriptor
+        let setStatusItem = undefined;
+        if (latestRow && columnIndices.setStatus !== -1) {
+            const rawStatusValue = latestRow[columnIndices.setStatus];
+            if (rawStatusValue !== undefined && rawStatusValue !== null && dldStatus?.items) {
+                setStatusItem = dldStatus.items.find(item => item.value === rawStatusValue);
+            }
+        }
+        // Cerca il diagramItem corrispondente al setID nel workflow
+        const diagramItem = wfDiagram?.DiagramItems?.find(item => item.ID === setID);
+        return {
+            wid: `group_${setID}_${groupIndex}`,
+            setID,
+            creationTime: latest.creationTime,
+            groupIndex,
+            category: latestRow && columnIndices.category !== -1 ? latestRow[columnIndices.category] : undefined,
+            type: diagramItem?.Type,
+            name: diagramItem?.ItemName,
+            description: latestRow && columnIndices.description !== -1 ? latestRow[columnIndices.description] : undefined,
+            setStatus: setStatusItem,
+            setRule: latestRow && columnIndices.setRule !== -1 ? Number(latestRow[columnIndices.setRule]) : undefined,
+            details: sortedDetails,
+            wf: workflow,
+        };
+    });
+    // Ordina i gruppi per creationTime (più recente prima)
+    return finalWorkItems.sort((a, b) => {
+        if (!a.creationTime || !b.creationTime)
+            return 0;
+        return b.creationTime.getTime() - a.creationTime.getTime();
+    });
+};

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 {};