@topconsultnpm/sdkui-react-beta 6.16.59 → 6.16.60

package/lib/components/features/workflow/diagram/DiagramItemForm.js

@@ -161,7 +161,6 @@ const DiagramItemForm = ({ itemToEdit, wf, onClose, onApply }) => {
                 PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
                 PlatformObjectValidator.RequiredStringValidator(d.Tos, DiagramItemProps.Tos, vil, SDKUI_Localizator.Recipients);
                 PlatformObjectValidator.RequiredStringValidator(d.Severity, DiagramItemProps.Severity, vil, SDKUI_Localizator.Severity);
-                PlatformObjectValidator.RequiredStringValidator(d.AppType, DiagramItemProps.AppType, vil, SDKUI_Localizator.WorkflowAppType);
                 break;
             case DiagramItemTypes.RunApp:
                 PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);

package/lib/components/features/workflow/diagram/WFDiagram.js

@@ -1,14 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
 import { DiagramItemTypes, ArrowSymbol } from './interfaces';
-import { parseWfDiagramXml } from './xmlParser';
+import { parseWfDiagramXml, serializeWfDiagramToXml } from './xmlParser';
 import styled from 'styled-components';
 import { CultureIDs, SearchEngine, WFAppTypes, WorkItemStatus } from "@topconsultnpm/sdk-ts-beta";
 import ConnectionComponent from './ConnectionComponent';
 import DiagramItemComponent from './DiagramItemComponent';
 import DiagramItemSvgContent from './DiagramItemSvgContent';
-import { calculateArrowAngle, getConnectionPoint, isConnectionNonLinear, validateDiagram } from './workflowHelpers';
-import { IconFlowChart, IconUndo, IconRestore, IconAdjust, IconCopy, IconCut, IconPaste, IconPin, IconUnpin, IconChevronRight, IconCloseOutline, IconNew, SDKUI_Localizator, generateUUID } from '../../../../helper';
+import { calculateArrowAngle, downloadFile, getConnectionPoint, isConnectionNonLinear, validateDiagram } from './workflowHelpers';
+import { IconFlowChart, IconUndo, IconRestore, IconAdjust, IconCopy, IconCut, IconPaste, IconPin, IconUnpin, IconChevronRight, IconCloseOutline, IconNew, SDKUI_Localizator, generateUUID, IconExport } from '../../../../helper';
 import { TMExceptionBoxManager } from '../../../base/TMPopUp';
 import { StyledLoadingContainer, StyledSpinner } from '../../../base/Styled';
 import DiagramItemForm from './DiagramItemForm';
@@ -589,6 +589,24 @@ const WFDiagram = ({ xmlDiagramString, currentSetID, readOnly = false, zoomLevel
             return;
         }
     }, [wfDiagram, selectedItems, selectedConnections, handleUndo, handleRedo, handleDelete, updateDiagram, handleCopy, handleCut, handlePaste, readOnly]);
+    const handleExportDiagram = useCallback(() => {
+        if (!wfDiagram) {
+            // Visualizza un errore se il diagramma non è stato caricato o è vuoto
+            TMExceptionBoxManager.show({ exception: new Error('Diagram not loaded.') });
+            return;
+        }
+        try {
+            // 1. Serializza il diagramma in XML
+            const xmlString = serializeWfDiagramToXml(wfDiagram);
+            // 2. Determina il nome del file (usa l'ID o un UUID se non disponibile)
+            const filename = `WorkflowDiagram_${wfDiagram.Info?.ID || generateUUID()}.xml`;
+            // 3. Avvia il download (la cartella è scelta dal browser)
+            downloadFile(xmlString, filename, 'application/xml');
+        }
+        catch (e) {
+            TMExceptionBoxManager.show({ exception: e });
+        }
+    }, [wfDiagram]); // Dipende dallo stato attuale del diagramma
     const calculateConnectionPath = useCallback((connection, sourceItem, sinkItem) => {
         const sourcePoint = getConnectionPoint(sourceItem, connection.Source.ConnectorName);
         const sinkPoint = getConnectionPoint(sinkItem, connection.Sink.ConnectorName);
@@ -1392,7 +1410,7 @@ const WFDiagram = ({ xmlDiagramString, currentSetID, readOnly = false, zoomLevel
             isUndoingRedoing.current = false;
         }
     }, [wfDiagram]);
-    return (_jsxs(CanvasContainer, { children: [!readOnly && (_jsxs(ToolbarContainer, { "$isCollapsed": isToolbarCollapsed, "$isFloating": isToolbarFloating, "$isToolboxVisible": isToolboxVisible, children: [_jsx(ButtonGroup, { "$isFloating": isToolbarFloating, children: _jsxs("button", { onClick: handleToggleToolboxVisibility, title: "Show toolbox", children: [_jsx(IconFlowChart, {}), !isToolbarCollapsed && _jsx("span", { children: "Mostra/nascondi toolbox" })] }) }), _jsxs(ButtonGroup, { "$isFloating": isToolbarFloating, children: [_jsxs("button", { onClick: handleUndo, disabled: historyIndex === 0, title: "Undo", children: [_jsx(IconUndo, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Undo" })] }), _jsxs("button", { onClick: handleRedo, disabled: historyIndex === wfDiagramHistory.length - 1, title: "Redo", children: [_jsx(IconUndo, { style: { transform: 'scaleX(-1)' } }), " ", !isToolbarCollapsed && _jsx("span", { children: "Redo" })] }), _jsxs("button", { onClick: handleRestore, title: "Restore", children: [_jsx(IconRestore, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Restore" })] }), _jsxs("button", { onClick: handleNew, title: "New diagram", disabled: readOnly, children: [_jsx(IconNew, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "New" })] })] }), _jsx(ButtonGroup, { "$isFloating": isToolbarFloating, children: _jsxs("button", { onClick: handleAutoAdjust, title: "Auto adjust", children: [_jsx(IconAdjust, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Auto Adjust" })] }) }), _jsxs(ButtonGroup, { "$isFloating": isToolbarFloating, children: [_jsxs("button", { onClick: handleCopy, disabled: selectedItems.size === 0, title: "Copy", children: [_jsx(IconCopy, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Copy" })] }), _jsxs("button", { onClick: handleCut, disabled: selectedItems.size === 0, title: "Cut", children: [_jsx(IconCut, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Cut" })] }), _jsxs("button", { onClick: handlePaste, disabled: copiedItems.length === 0 && copiedConnections.length === 0, title: "Paste", children: [_jsx(IconPaste, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Paste" })] })] }), _jsxs("button", { onClick: handleToggleToolbarMode, title: isToolbarFloating ? "Dock Toolbar" : "Float Toolbar", children: [isToolbarFloating ? _jsx(IconPin, {}) : _jsx(IconUnpin, {}), !isToolbarCollapsed && !isToolbarFloating && _jsx("span", { children: "Toggle Mode" })] }), !isToolbarFloating && _jsx(ToolbarToggle, { onClick: () => setIsToolbarCollapsed(!isToolbarCollapsed), title: isToolbarCollapsed ? "Expand Toolbar" : "Collapse Toolbar", children: isToolbarCollapsed ? _jsx(IconChevronRight, {}) : _jsx(IconCloseOutline, {}) })] })), !readOnly && (_jsx(ToolboxContainer, { "$isVisible": isToolboxVisible, children: isToolboxVisible && availableItemTypes.map(type => (_jsxs(ToolboxItem, { draggable: true, onDragStart: (e) => handleToolboxDragStart(e, type), onDragEnd: handleToolboxDragEnd, children: [_jsx(DiagramItemSvgContent, { itemType: type, width: 40, height: 40, isToolboxPreview: true }), _jsx("span", { children: DiagramItemTypes[type] })] }, type))) })), _jsx(SvgScrollContainer, { children: isLoading ?
+    return (_jsxs(CanvasContainer, { children: [!readOnly && (_jsxs(ToolbarContainer, { "$isCollapsed": isToolbarCollapsed, "$isFloating": isToolbarFloating, "$isToolboxVisible": isToolboxVisible, children: [_jsx(ButtonGroup, { "$isFloating": isToolbarFloating, children: _jsxs("button", { onClick: handleToggleToolboxVisibility, title: "Show toolbox", children: [_jsx(IconFlowChart, {}), !isToolbarCollapsed && _jsx("span", { children: "Mostra/nascondi toolbox" })] }) }), _jsxs(ButtonGroup, { "$isFloating": isToolbarFloating, children: [_jsxs("button", { onClick: handleUndo, disabled: historyIndex === 0, title: "Undo", children: [_jsx(IconUndo, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Undo" })] }), _jsxs("button", { onClick: handleRedo, disabled: historyIndex === wfDiagramHistory.length - 1, title: "Redo", children: [_jsx(IconUndo, { style: { transform: 'scaleX(-1)' } }), " ", !isToolbarCollapsed && _jsx("span", { children: "Redo" })] }), _jsxs("button", { onClick: handleRestore, title: "Restore", children: [_jsx(IconRestore, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Restore" })] }), _jsxs("button", { onClick: handleNew, title: "New diagram", disabled: readOnly, children: [_jsx(IconNew, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "New" })] }), _jsxs("button", { onClick: handleExportDiagram, disabled: readOnly || !wfDiagram, title: SDKUI_Localizator.Export || 'Export Diagram', children: [_jsx(IconExport, {}), _jsx("span", { children: SDKUI_Localizator.Export || 'Export' })] })] }), _jsx(ButtonGroup, { "$isFloating": isToolbarFloating, children: _jsxs("button", { onClick: handleAutoAdjust, title: "Auto adjust", children: [_jsx(IconAdjust, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Auto Adjust" })] }) }), _jsxs(ButtonGroup, { "$isFloating": isToolbarFloating, children: [_jsxs("button", { onClick: handleCopy, disabled: selectedItems.size === 0, title: "Copy", children: [_jsx(IconCopy, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Copy" })] }), _jsxs("button", { onClick: handleCut, disabled: selectedItems.size === 0, title: "Cut", children: [_jsx(IconCut, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Cut" })] }), _jsxs("button", { onClick: handlePaste, disabled: copiedItems.length === 0 && copiedConnections.length === 0, title: "Paste", children: [_jsx(IconPaste, {}), " ", !isToolbarCollapsed && _jsx("span", { children: "Paste" })] })] }), _jsxs("button", { onClick: handleToggleToolbarMode, title: isToolbarFloating ? "Dock Toolbar" : "Float Toolbar", children: [isToolbarFloating ? _jsx(IconPin, {}) : _jsx(IconUnpin, {}), !isToolbarCollapsed && !isToolbarFloating && _jsx("span", { children: "Toggle Mode" })] }), !isToolbarFloating && _jsx(ToolbarToggle, { onClick: () => setIsToolbarCollapsed(!isToolbarCollapsed), title: isToolbarCollapsed ? "Expand Toolbar" : "Collapse Toolbar", children: isToolbarCollapsed ? _jsx(IconChevronRight, {}) : _jsx(IconCloseOutline, {}) })] })), !readOnly && (_jsx(ToolboxContainer, { "$isVisible": isToolboxVisible, children: isToolboxVisible && availableItemTypes.map(type => (_jsxs(ToolboxItem, { draggable: true, onDragStart: (e) => handleToolboxDragStart(e, type), onDragEnd: handleToolboxDragEnd, children: [_jsx(DiagramItemSvgContent, { itemType: type, width: 40, height: 40, isToolboxPreview: true }), _jsx("span", { children: DiagramItemTypes[type] })] }, type))) })), _jsx(SvgScrollContainer, { children: isLoading ?
                     (_jsxs(StyledLoadingContainer, { children: [_jsx(StyledSpinner, {}), _jsx("span", { children: `${'Caricamento diagramma'}...` })] })) : wfDiagram ? (_jsx(StyledSvg, { ref: svgRef, tabIndex: 0, onKeyDownCapture: handleKeyDown, onMouseMove: handleMouseMove, onMouseUp: handleMouseUp, onMouseDown: handleMouseDown, onDrop: handleDropOnCanvas, onDragOver: handleDragOver, width: svgWidth, height: svgHeight, children: _jsxs(ScalableGroup, { "$scale": zoomLevel, "$translateX": translateX, "$translateY": translateY, children: [wfDiagram?.DiagramItems.map(item => (_jsx(DiagramItemComponent, { wf: wfDiagram?.Info, readOnly: readOnly, item: item, isSelected: selectedItems.has(item.ID), isCurrent: item.ID === currentSetID, onClick: handleDiagramItemClick, onDrag: handleDrag, onDragEnd: handleDragEnd, onConnectorMouseDown: handleConnectorMouseDown, onConnectorMouseUp: handleConnectorMouseUp, onDimensionsChange: handleItemDimensionsChange, onDoubleClick: handleDoubleClickItem }, item.ID))), calculatedConnections.map(connection => {
                                 const sourceItem = wfDiagram?.DiagramItems.find(item => item.ID === connection.Source.ParentDiagramItem.ID);
                                 const sinkItem = wfDiagram?.DiagramItems.find(item => item.ID === connection.Sink.ParentDiagramItem.ID);

package/lib/components/features/workflow/diagram/workflowHelpers.d.ts

@@ -65,3 +65,4 @@ export declare const calculateDiagramItemFullDimensions: (item: DiagramItem, tex
 /** Helper function to get the color based on connection status */
 export declare const getConnectionColor: (status: WorkItemStatus) => string;
 export declare const validateDiagram: (diagram: WfDiagram, newConnection?: Connection) => void;
+export declare const downloadFile: (data: string, filename: string, type: string) => void;

package/lib/components/features/workflow/diagram/workflowHelpers.js

@@ -242,3 +242,14 @@ export const validateDiagram = (diagram, newConnection) => {
     // In futuro, puoi aggiungere qui la validazione per gli item del diagramma
     // ...
 };
+export const downloadFile = (data, filename, type) => {
+    const blob = new Blob([data], { type });
+    const url = window.URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    window.URL.revokeObjectURL(url);
+};

package/lib/components/features/workflow/diagram/xmlParser.d.ts

@@ -1,3 +1,10 @@
 import { WfDiagram } from './interfaces';
+import { CultureIDs, Severities, WFAppTypes, WorkItemSetRules, WorkItemStatus } from '@topconsultnpm/sdk-ts-beta';
+export declare const getCultureIDsNumber: (cultureID: CultureIDs | undefined) => number;
+export declare const getWorkItemStatusNumber: (status: WorkItemStatus | undefined) => number;
+export declare const getSeveritiesNumber: (severity: Severities | undefined) => number;
+export declare const getWorkItemSetRulesNumber: (setRule: WorkItemSetRules | undefined) => number;
+export declare const getWFAppTypesNumber: (appType: WFAppTypes | undefined) => number;
+export declare const mapCultureIDs: (cultureIDValue: number) => CultureIDs;
 export declare const parseWfDiagramXml: (xmlString: string) => WfDiagram;
-export declare function serializeWfDiagramToXml(diagram: WfDiagram): string;
+export declare const serializeWfDiagramToXml: (wfDiagram: WfDiagram | null) => string;

package/lib/components/features/workflow/diagram/xmlParser.js

@@ -1,7 +1,116 @@
 import { ArrowSymbol } from './interfaces';
-import { WorkItemStatus } from '@topconsultnpm/sdk-ts-beta';
+import { CultureIDs, Severities, WFAppTypes, WorkItemSetRules, WorkItemStatus } from '@topconsultnpm/sdk-ts-beta';
 import { parseQueryDescriptorXml } from './queryDescriptorParser'; // Import the new parser
 import { parseMetadataValuesXml } from './metadataParser';
+// Funzione helper per escapare i caratteri XML speciali (necessaria per i campi stringa)
+const escapeXml = (unsafe) => {
+    if (unsafe === undefined || unsafe === null)
+        return '';
+    const str = String(unsafe);
+    return str.replace(/[<>&'"]/g, function (c) {
+        switch (c) {
+            case '<': return '&lt;';
+            case '>': return '&gt;';
+            case '&': return '&amp;';
+            case "'": return '&apos;';
+            case '"': return '&quot;';
+            default: return c;
+        }
+    });
+};
+export const getCultureIDsNumber = (cultureID) => {
+    switch (cultureID) {
+        case CultureIDs.It_IT:
+            return 1;
+        case CultureIDs.Fr_FR:
+            return 2;
+        case CultureIDs.En_US:
+            return 3;
+        case CultureIDs.Pt_PT:
+            return 4;
+        case CultureIDs.Es_ES:
+            return 5;
+        case CultureIDs.De_DE:
+            return 6;
+        case CultureIDs.None: // 0 è il default
+        default:
+            return 0;
+    }
+};
+export const getWorkItemStatusNumber = (status) => {
+    switch (status) {
+        case WorkItemStatus.New:
+            return 0;
+        case WorkItemStatus.Completed:
+            return 1;
+        case WorkItemStatus.Rejected:
+            return -1;
+        default:
+            return 0;
+    }
+};
+export const getSeveritiesNumber = (severity) => {
+    switch (severity) {
+        case Severities.None:
+            return 0;
+        case Severities.Critical:
+            return 1;
+        case Severities.Error:
+            return 2;
+        case Severities.Warning:
+            return 3;
+        case Severities.Information:
+            return 10;
+        default:
+            return 0;
+    }
+};
+export const getWorkItemSetRulesNumber = (setRule) => {
+    switch (setRule) {
+        case WorkItemSetRules.Ands_AND_Ors:
+            return 0;
+        case WorkItemSetRules.Ands_OR_Ors:
+            return 1;
+        case WorkItemSetRules.Custom:
+            return 2;
+        default:
+            return 0;
+    }
+};
+export const getWFAppTypesNumber = (appType) => {
+    switch (appType) {
+        case WFAppTypes.None:
+            return 0;
+        case WFAppTypes.EXE:
+            return 1;
+        case WFAppTypes.SP:
+            return 2;
+        case WFAppTypes.REST:
+            return 3;
+        default:
+            return 0;
+    }
+};
+export const mapCultureIDs = (cultureIDValue) => {
+    switch (cultureIDValue) {
+        case 1:
+            return CultureIDs.It_IT;
+        case 2:
+            return CultureIDs.Fr_FR;
+        case 3:
+            return CultureIDs.En_US;
+        case 4:
+            return CultureIDs.Pt_PT;
+        case 5:
+            return CultureIDs.Es_ES;
+        case 6:
+            return CultureIDs.De_DE;
+        case 0: // 0 è None
+        default:
+            console.warn(`Valore CultureID sconosciuto: ${cultureIDValue}. Ritorno CultureIDs.None.`);
+            return CultureIDs.None;
+    }
+};
 // Funzione helper per mappare i valori numerici di OutputStatus
 const mapOutputStatus = (statusValue) => {
     switch (statusValue) {
@@ -12,11 +121,75 @@ const mapOutputStatus = (statusValue) => {
         case -1:
             return WorkItemStatus.Rejected;
         default:
-            // Gestisci il caso di un valore sconosciuto, potresti voler lanciare un errore o ritornare un default
             console.warn(`Valore OutputStatus sconosciuto: ${statusValue}. Ritorno WorkItemStatus.New.`);
             return WorkItemStatus.New;
     }
 };
+// Funzione helper per mappare i valori numerici di Severity (dal precedente problema)
+const mapSeverity = (severityValue) => {
+    switch (severityValue) {
+        case 0:
+            return Severities.None;
+        case 1:
+            return Severities.Critical;
+        case 2:
+            return Severities.Error;
+        case 3:
+            return Severities.Warning;
+        case 10: // Mappatura da 10 a Information come nell'enum C#
+            return Severities.Information;
+        default:
+            console.warn(`Valore Severity sconosciuto: ${severityValue}. Ritorno Severities.None.`);
+            return Severities.None;
+    }
+};
+// Funzione helper per mappare i valori numerici di WorkItemSetRules
+const mapWorkItemSetRules = (ruleValue) => {
+    switch (ruleValue) {
+        case 0:
+            return WorkItemSetRules.Ands_AND_Ors;
+        case 1:
+            return WorkItemSetRules.Ands_OR_Ors;
+        case 2:
+            return WorkItemSetRules.Custom;
+        default:
+            console.warn(`Valore WorkItemSetRules sconosciuto: ${ruleValue}. Ritorno WorkItemSetRules.Ands_AND_Ors.`);
+            return WorkItemSetRules.Ands_AND_Ors;
+    }
+};
+// Funzione helper per mappare i valori numerici di WFAppTypes
+const mapWFAppTypes = (appTypeValue) => {
+    switch (appTypeValue) {
+        case 0:
+            return WFAppTypes.None;
+        case 1:
+            return WFAppTypes.EXE;
+        case 2:
+            return WFAppTypes.SP;
+        case 3:
+            return WFAppTypes.REST;
+        default:
+            console.warn(`Valore WFAppTypes sconosciuto: ${appTypeValue}. Ritorno WFAppTypes.None.`);
+            return WFAppTypes.None;
+    }
+};
+// Placeholder per la serializzazione di QueryDescriptor in XML (DA MODIFICARE CON LA LOGICA REALE)
+const serializeQueryDescriptorXml = (qd) => {
+    if (qd) {
+        // Logica di serializzazione reale qui, ad esempio:
+        // return `<ID>${qd.ID}</ID><Query>${escapeXml(qd.Query)}</Query>...`
+        return '[QUERY_DESCRIPTOR_XML_PLACEHOLDER]';
+    }
+    return '';
+};
+// Placeholder per la serializzazione di MetadataValues in XML (DA MODIFICARE CON LA LOGICA REALE)
+const serializeMetadataValuesXml = (values) => {
+    if (!values || values.length === 0)
+        return '';
+    // Logica di serializzazione reale qui, ad esempio per ogni elemento in values:
+    // return values.map(v => `<Value Name="${v.Name}">${v.Value}</Value>`).join('');
+    return '[METADATA_VALUES_XML_PLACEHOLDER]';
+};
 export const parseWfDiagramXml = (xmlString) => {
     const parser = new DOMParser();
     const xmlDoc = parser.parseFromString(xmlString, "application/xml");
@@ -78,6 +251,9 @@ export const parseWfDiagramXml = (xmlString) => {
         const startAfterUpdateMIDsArray = (startAfterUpdateMIDsContent && startAfterUpdateMIDsContent !== '')
             ? startAfterUpdateMIDsContent.split(';').map(Number)
             : undefined;
+        const xmlSeverity = parseInt(itemXML.querySelector("Severity")?.textContent || "0", 10);
+        const xmlSetRule = parseInt(itemXML.querySelector("SetRule")?.textContent || "0", 10);
+        const xmlAppType = parseInt(itemXML.querySelector("AppType")?.textContent || "0", 10);
         const item = {
             ID: itemXML.querySelector("ID")?.textContent || "",
             Left: left,
@@ -103,7 +279,7 @@ export const parseWfDiagramXml = (xmlString) => {
             RegisterPost: itemXML.querySelector("RegisterPost")?.textContent === "true",
             AllowZeroTos: itemXML.querySelector("AllowZeroTos")?.textContent === "true",
             Tos: itemXML.querySelector("Tos")?.textContent || undefined,
-            SetRule: parseInt(itemXML.querySelector("SetRule")?.textContent || "0", 10),
+            SetRule: mapWorkItemSetRules(xmlSetRule),
             StartAfterArchive: parseInt(itemXML.querySelector("StartAfterArchive")?.textContent || "0", 10),
             StartAfterUpdate: parseInt(itemXML.querySelector("StartAfterUpdate")?.textContent || "0", 10),
             StartAfterUpdateMIDs: startAfterUpdateMIDsArray,
@@ -113,9 +289,9 @@ export const parseWfDiagramXml = (xmlString) => {
             QD: parsedQD,
             SOD: itemXML.querySelector("SOD")?.textContent || undefined,
             MetadataValues: parsedMetadataValues,
-            Severity: parseInt(itemXML.querySelector("Severity")?.textContent || "0", 10),
+            Severity: mapSeverity(xmlSeverity),
             RegAsWfInstPart: parseInt(itemXML.querySelector("RegAsWfInstPart")?.textContent || "0", 10),
-            FormatCultureID: parseInt(itemXML.querySelector("FormatCultureID")?.textContent || "0", 10),
+            FormatCultureID: mapCultureIDs(parseInt(itemXML.querySelector("FormatCultureID")?.textContent || "0", 10)),
             Tos2: itemXML.querySelector("Tos2")?.textContent || undefined,
             QD2: itemXML.querySelector("QD2")?.textContent || undefined,
             PlatformObjName: itemXML.querySelector("PlatformObjName")?.textContent || undefined,
@@ -124,7 +300,7 @@ export const parseWfDiagramXml = (xmlString) => {
             Value2asInt: parseInt(itemXML.querySelector("Value2asInt")?.textContent || "0", 10),
             Value3asInt: parseInt(itemXML.querySelector("Value3asInt")?.textContent || "0", 10),
             Value1asString: itemXML.querySelector("Value1asString")?.textContent || undefined,
-            AppType: parseInt(itemXML.querySelector("AppType")?.textContent || "0", 10),
+            AppType: mapWFAppTypes(xmlAppType),
             AppName: itemXML.querySelector("AppName")?.textContent || undefined,
             AppArgs: itemXML.querySelector("AppArgs")?.textContent || undefined,
             Trunc: parseInt(itemXML.querySelector("Trunc")?.textContent || "0", 10),
@@ -161,105 +337,146 @@ export const parseWfDiagramXml = (xmlString) => {
     return wfDiagram;
 };
 // Funzione di serializzazione (inclusa per completezza, se l'avevi)
-export function serializeWfDiagramToXml(diagram) {
-    let xml = `<Root>`;
-    if (diagram.Info) {
-        xml += `<Workflow>`;
-        xml += `<WFID>${diagram.Info.ID}</WFID>`;
-        xml += `<WFMTID>${diagram.Info.MTID}</WFMTID>`;
-        xml += `<WFMStatusMID>${diagram.Info.MStatusMID}</WFMStatusMID>`;
-        xml += `<WFMStatusDLID>${diagram.Info.MStatusDLID}</WFMStatusDLID>`;
-        // Aggiungi <Type> se esiste in Info
-        xml += `</Workflow>`;
+export const serializeWfDiagramToXml = (wfDiagram) => {
+    if (!wfDiagram) {
+        return '<?xml version="1.0" encoding="utf-8"?>\n<Root></Root>';
     }
-    xml += `<DiagramItems>`;
-    diagram.DiagramItems.forEach(item => {
-        xml += `<DiagramItem>`;
-        xml += `<ID>${item.ID}</ID>`;
-        xml += `<L>${item.Left}</L>`;
-        xml += `<T>${item.Top}</T>`;
-        xml += `<W>${item.Width}</W>`;
-        xml += `<H>${item.Height}</H>`;
-        xml += `<Type>${item.Type}</Type>`;
-        xml += `<Name>${item.ItemName}</Name>`;
-        xml += `<Description>${item.Description}</Description>`;
-        xml += `<StatusValue>${item.StatusValue || ''}</StatusValue>`;
-        xml += `<RegisterPost>${item.RegisterPost || false}</RegisterPost>`;
-        xml += `<AllowZeroTos>${item.AllowZeroTos || false}</AllowZeroTos>`;
-        xml += `<Tos>${item.Tos || ''}</Tos>`;
-        xml += `<SetRule>${item.SetRule || 0}</SetRule>`;
-        xml += `<StartAfterArchive>${item.StartAfterArchive || 0}</StartAfterArchive>`;
-        xml += `<StartAfterUpdate>${item.StartAfterUpdate || 0}</StartAfterUpdate>`;
-        xml += `<StartAfterUpdateMIDs>${item.StartAfterUpdateMIDs || ''}</StartAfterUpdateMIDs>`;
-        xml += `<StartManual>${item.StartManual || 0}</StartManual>`;
-        xml += `<Hist>${item.Hist || 0}</Hist>`;
-        xml += `<EndWFInstance>${item.EndWFInstance || 0}</EndWFInstance>`;
-        // Handling serialization of QueryDescriptor:
-        // This is tricky because DataContractSerializer produces specific XML.
-        // If you need to serialize it back to the exact DataContract XML format,
-        // you would ideally have a `serializeQueryDescriptorToXml` function.
-        // For now, if QD is an object, you cannot simply do `${item.QD || ''}`.
-        // You would need to re-serialize it. Since the original XML already contained the string,
-        // and we parsed it, re-serializing it perfectly matches the C# DataContractSerializer
-        // output can be complex.
-        // For simple cases, you might stringify it as JSON if the C# side can read it,
-        // or re-generate the XML structure manually.
-        // For now, if you are *only* parsing, this is fine. If you also need to serialize,
-        // you will need a corresponding serialization function for QueryDescriptor that
-        // matches the C# DataContractSerializer's output precisely.
-        xml += `<QD>${JSON.stringify(item.QD) || ''}</QD>`; // Placeholder - this won't match C# XML
-        xml += `<SOD>${item.SOD || ''}</SOD>`;
-        xml += `<MetadataValues>${item.MetadataValues || ''}</MetadataValues>`;
-        xml += `<Severity>${item.Severity || 0}</Severity>`;
-        xml += `<RegAsWfInstPart>${item.RegAsWfInstPart || 0}</RegAsWfInstPart>`;
-        xml += `<FormatCultureID>${item.FormatCultureID || 0}</FormatCultureID>`;
-        xml += `<Tos2>${item.Tos2 || ''}</Tos2>`;
-        xml += `<QD2>${item.QD2 || ''}</QD2>`;
-        xml += `<PlatformObjName>${item.PlatformObjName || ''}</PlatformObjName>`;
-        xml += `<PlatformObjDescr>${item.PlatformObjDescr || ''}</PlatformObjDescr>`;
-        xml += `<Value1asInt>${item.Value1asInt || 0}</Value1asInt>`;
-        xml += `<Value2asInt>${item.Value2asInt || 0}</Value2asInt>`;
-        xml += `<Value3asInt>${item.Value3asInt || 0}</Value3asInt>`;
-        xml += `<Value1asString>${item.Value1asString || ''}</Value1asString>`;
-        xml += `<AppType>${item.AppType || 0}</AppType>`;
-        xml += `<AppName>${item.AppName || ''}</AppName>`;
-        xml += `<AppArgs>${item.AppArgs || ''}</AppArgs>`;
-        xml += `<Trunc>${item.Trunc || 0}</Trunc>`;
-        xml += `</DiagramItem>`;
-    });
-    xml += `</DiagramItems>`;
-    xml += `<Connections>`;
-    diagram.Connections.forEach(conn => {
-        xml += `<Connection>`;
-        xml += `<ID>${conn.ID}</ID>`;
-        xml += `<SourceID>${conn.Source.ParentDiagramItem.ID}</SourceID>`;
-        // Assicurati che conn.Source.ConnectorName esista e contenga il valore corretto
-        xml += `<SourceConnectorName>${conn.Source.ConnectorName || ''}</SourceConnectorName>`;
-        xml += `<SinkID>${conn.Sink.ParentDiagramItem.ID}</SinkID>`;
-        // Assicurati che conn.Sink.ConnectorName esista e contenga il valore corretto
-        xml += `<SinkConnectorName>${conn.Sink.ConnectorName || ''}</SinkConnectorName>`;
-        // Mappa il valore dell'enum WorkItemStatus a un numero per la serializzazione
-        let outputStatusNumber;
-        switch (conn.OutputStatus) {
-            case WorkItemStatus.New:
-                outputStatusNumber = 0;
-                break;
-            case WorkItemStatus.Completed:
-                outputStatusNumber = 1;
-                break;
-            case WorkItemStatus.Rejected:
-                outputStatusNumber = -1;
-                break;
-            default:
-                outputStatusNumber = 0; // Default per sicurezza
+    let xml = '<?xml version="1.0" encoding="utf-8"?>\n';
+    xml += '<Root>\n';
+    // 1. Serializzazione WfInfo
+    if (wfDiagram.Info) {
+        xml += '  <Workflow>\n';
+        xml += `    <WFID>${escapeXml(wfDiagram.Info.ID)}</WFID>\n`;
+        xml += `    <WFMTID>${wfDiagram.Info.MTID}</WFMTID>\n`;
+        xml += `    <WFMStatusMID>${wfDiagram.Info.MStatusMID}</WFMStatusMID>\n`;
+        xml += `    <WFMStatusDLID>${wfDiagram.Info.MStatusDLID}</WFMStatusDLID>\n`;
+        xml += '  </Workflow>\n';
+    }
+    // 2. Serializzazione DiagramItems
+    xml += '  <DiagramItems>\n';
+    wfDiagram.DiagramItems.forEach(item => {
+        xml += '    <DiagramItem>\n';
+        xml += `      <ID>${escapeXml(item.ID)}</ID>\n`;
+        xml += `      <L>${item.Left}</L>\n`;
+        xml += `      <T>${item.Top}</T>\n`;
+        xml += `      <W>${item.Width}</W>\n`;
+        xml += `      <H>${item.Height}</H>\n`;
+        xml += `      <Type>${item.Type}</Type>\n`;
+        xml += `      <Name>${escapeXml(item.ItemName)}</Name>\n`;
+        // Nomi localizzati
+        if (item.ItemName_IT)
+            xml += `      <Name_IT>${escapeXml(item.ItemName_IT)}</Name_IT>\n`;
+        if (item.ItemName_EN)
+            xml += `      <Name_EN>${escapeXml(item.ItemName_EN)}</Name_EN>\n`;
+        if (item.ItemName_FR)
+            xml += `      <Name_FR>${escapeXml(item.ItemName_FR)}</Name_FR>\n`;
+        if (item.ItemName_PT)
+            xml += `      <Name_PT>${escapeXml(item.ItemName_PT)}</Name_PT>\n`;
+        if (item.ItemName_ES)
+            xml += `      <Name_ES>${escapeXml(item.ItemName_ES)}</Name_ES>\n`;
+        if (item.ItemName_DE)
+            xml += `      <Name_DE>${escapeXml(item.ItemName_DE)}</Name_DE>\n`;
+        xml += `      <Description>${escapeXml(item.Description)}</Description>\n`;
+        // Descrizioni localizzate
+        if (item.Description_IT)
+            xml += `      <Description_IT>${escapeXml(item.Description_IT)}</Description_IT>\n`;
+        if (item.Description_EN)
+            xml += `      <Description_EN>${escapeXml(item.Description_EN)}</Description_EN>\n`;
+        if (item.Description_FR)
+            xml += `      <Description_FR>${escapeXml(item.Description_FR)}</Description_FR>\n`;
+        if (item.Description_PT)
+            xml += `      <Description_PT>${escapeXml(item.Description_PT)}</Description_PT>\n`;
+        if (item.Description_ES)
+            xml += `      <Description_ES>${escapeXml(item.Description_ES)}</Description_ES>\n`;
+        if (item.Description_DE)
+            xml += `      <Description_DE>${escapeXml(item.Description_DE)}</Description_DE>\n`;
+        if (item.StatusValue)
+            xml += `      <StatusValue>${escapeXml(item.StatusValue)}</StatusValue>\n`;
+        if (item.RegisterPost !== undefined)
+            xml += `      <RegisterPost>${item.RegisterPost ? 'true' : 'false'}</RegisterPost>\n`;
+        if (item.AllowZeroTos !== undefined)
+            xml += `      <AllowZeroTos>${item.AllowZeroTos ? 'true' : 'false'}</AllowZeroTos>\n`;
+        if (item.Tos)
+            xml += `      <Tos>${escapeXml(item.Tos)}</Tos>\n`;
+        if (item.SetRule !== undefined)
+            xml += `      <SetRule>${getWorkItemSetRulesNumber(item.SetRule)}</SetRule>\n`;
+        if (item.StartAfterArchive !== undefined)
+            xml += `      <StartAfterArchive>${item.StartAfterArchive}</StartAfterArchive>\n`;
+        if (item.StartAfterUpdate !== undefined)
+            xml += `      <StartAfterUpdate>${item.StartAfterUpdate}</StartAfterUpdate>\n`;
+        if (item.StartAfterUpdateMIDs && item.StartAfterUpdateMIDs.length > 0) {
+            xml += `      <StartAfterUpdateMIDs>${item.StartAfterUpdateMIDs.join(';')}</StartAfterUpdateMIDs>\n`;
+        }
+        if (item.StartManual !== undefined)
+            xml += `      <StartManual>${item.StartManual}</StartManual>\n`;
+        if (item.Hist !== undefined)
+            xml += `      <Hist>${item.Hist}</Hist>\n`;
+        if (item.EndWFInstance !== undefined)
+            xml += `      <EndWFInstance>${item.EndWFInstance}</EndWFInstance>\n`;
+        // QueryDescriptor (QD)
+        if (item.QD) {
+            const qdXmlContent = serializeQueryDescriptorXml(item.QD);
+            xml += `      <QD><![CDATA[${qdXmlContent}]]></QD>\n`;
+        }
+        if (item.SOD)
+            xml += `      <SOD>${escapeXml(item.SOD)}</SOD>\n`;
+        // MetadataValues
+        if (item.MetadataValues) {
+            const mvXmlContent = serializeMetadataValuesXml(item.MetadataValues);
+            xml += `      <MetadataValues><![CDATA[${mvXmlContent}]]></MetadataValues>\n`;
         }
-        xml += `<OutputStatus>${outputStatusNumber}</OutputStatus>`;
-        xml += `<Description>${conn.Description || ''}</Description>`;
-        xml += `<SourceArrowSymbol>${conn.SourceArrowSymbol === ArrowSymbol.Arrow ? 'Arrow' : 'None'}</SourceArrowSymbol>`;
-        xml += `<SinkArrowSymbol>${conn.SinkArrowSymbol === ArrowSymbol.Arrow ? 'Arrow' : 'None'}</SinkArrowSymbol>`;
-        xml += `</Connection>`;
+        if (item.Severity !== undefined)
+            xml += `      <Severity>${getSeveritiesNumber(item.Severity)}</Severity>\n`;
+        if (item.RegAsWfInstPart !== undefined)
+            xml += `      <RegAsWfInstPart>${item.RegAsWfInstPart}</RegAsWfInstPart>\n`;
+        if (item.FormatCultureID !== undefined)
+            xml += `      <FormatCultureID>${getCultureIDsNumber(item.FormatCultureID)}</FormatCultureID>\n`;
+        if (item.Tos2)
+            xml += `      <Tos2>${escapeXml(item.Tos2)}</Tos2>\n`;
+        if (item.QD2)
+            xml += `      <QD2>${escapeXml(item.QD2)}</QD2>\n`;
+        if (item.PlatformObjName)
+            xml += `      <PlatformObjName>${escapeXml(item.PlatformObjName)}</PlatformObjName>\n`;
+        if (item.PlatformObjDescr)
+            xml += `      <PlatformObjDescr>${escapeXml(item.PlatformObjDescr)}</PlatformObjDescr>\n`;
+        if (item.Value1asInt !== undefined)
+            xml += `      <Value1asInt>${item.Value1asInt}</Value1asInt>\n`;
+        if (item.Value2asInt !== undefined)
+            xml += `      <Value2asInt>${item.Value2asInt}</Value2asInt>\n`;
+        if (item.Value3asInt !== undefined)
+            xml += `      <Value3asInt>${item.Value3asInt}</Value3asInt>\n`;
+        if (item.Value1asString)
+            xml += `      <Value1asString>${escapeXml(item.Value1asString)}</Value1asString>\n`;
+        if (item.AppType !== undefined)
+            xml += `      <AppType>${getWFAppTypesNumber(item.AppType)}</AppType>\n`;
+        if (item.AppName)
+            xml += `      <AppName>${escapeXml(item.AppName)}</AppName>\n`;
+        if (item.AppArgs)
+            xml += `      <AppArgs>${escapeXml(item.AppArgs)}</AppArgs>\n`;
+        if (item.Trunc !== undefined)
+            xml += `      <Trunc>${item.Trunc}</Trunc>\n`;
+        xml += '    </DiagramItem>\n';
     });
-    xml += `</Connections>`;
-    xml += `</Root>`;
+    xml += '  </DiagramItems>\n';
+    // 3. Serializzazione Connections
+    xml += '  <Connections>\n';
+    wfDiagram.Connections.forEach(conn => {
+        xml += '    <Connection>\n';
+        xml += `      <ID>${escapeXml(conn.ID)}</ID>\n`;
+        xml += `      <SourceID>${escapeXml(conn.Source.ParentDiagramItem.ID)}</SourceID>\n`;
+        xml += `      <SourceConnectorName>${escapeXml(conn.Source.ConnectorName || '')}</SourceConnectorName>\n`;
+        xml += `      <SinkID>${escapeXml(conn.Sink.ParentDiagramItem.ID)}</SinkID>\n`;
+        xml += `      <SinkConnectorName>${escapeXml(conn.Sink.ConnectorName || '')}</SinkConnectorName>\n`;
+        const outputStatusNumber = getWorkItemStatusNumber(conn.OutputStatus);
+        xml += `      <OutputStatus>${outputStatusNumber}</OutputStatus>\n`;
+        xml += `      <Description>${escapeXml(conn.Description || '')}</Description>\n`;
+        const sourceArrow = conn.SourceArrowSymbol === ArrowSymbol.Arrow ? 'Arrow' : (conn.SourceArrowSymbol === ArrowSymbol.Diamond ? 'Diamond' : 'None');
+        const sinkArrow = conn.SinkArrowSymbol === ArrowSymbol.Arrow ? 'Arrow' : (conn.SinkArrowSymbol === ArrowSymbol.Diamond ? 'Diamond' : 'None');
+        xml += `      <SourceArrowSymbol>${sourceArrow}</SourceArrowSymbol>\n`;
+        xml += `      <SinkArrowSymbol>${sinkArrow}</SinkArrowSymbol>\n`;
+        xml += '    </Connection>\n';
+    });
+    xml += '  </Connections>\n';
+    xml += '</Root>';
     return xml;
-}
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@topconsultnpm/sdkui-react-beta",
-    "version": "6.16.59",
+    "version": "6.16.60",
     "description": "",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1",