@topconsultnpm/sdkui-react 6.17.0-test9

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

@@ -0,0 +1,488 @@
+import { PlatformObjectValidator, QueryValidatorOptions, ResultTypes, TMPropertyNames, ValidationItem, WorkItemStatus } from '@topconsultnpm/sdk-ts';
+import { DiagramItemTypes, ArrowSymbol } from './interfaces'; // Assicurati che il percorso sia corretto
+import { generateUUID, SDKUI_Localizator } from '../../../../helper';
+/**
+ * Calculates the angle in degrees of an arrow based on two points.
+ * @param prevPoint The previous point on the trajectory.
+ * @param currentPoint The current point (where the arrow tip is located).
+ * @returns The angle in degrees.
+ */
+export const calculateArrowAngle = (prevPoint, currentPoint) => {
+    const angleRad = Math.atan2(currentPoint.y - prevPoint.y, currentPoint.x - prevPoint.x);
+    return angleRad * 180 / Math.PI;
+};
+/**
+ * Calculates the center point of a diagram item.
+ * @param item The diagram item.
+ * @returns The center point.
+ */
+export const getItemCenter = (item) => {
+    return {
+        x: item.Left + item.Width / 2,
+        y: item.Top + item.Height / 2,
+    };
+};
+/**
+ * Calculates the specific connection point for a given connector of an item.
+ * @param item The diagram item.
+ * @param connectorName The name of the connector (e.g., "Left", "Right", "Top", "Bottom").
+ * @returns The connection point.
+ */
+export const getConnectionPoint = (item, connectorName) => {
+    const { Left, Top, Width, Height } = item;
+    switch (connectorName) {
+        case 'Left': return { x: Left, y: Top + Height / 2 };
+        case 'Right': return { x: Left + Width, y: Top + Height / 2 };
+        case 'Top': return { x: Left + Width / 2, y: Top };
+        case 'Bottom': return { x: Left + Width / 2, y: Top + Height };
+        default: return getItemCenter(item);
+    }
+};
+/**
+ * Determines whether a connection requires a non-linear path (one that "bends" around the nodes).
+ * This typically occurs when the source and sink connectors are on the same side
+ * or when the node alignment is inverted relative to the opposite connectors.
+ *
+ * @param sourceRect The rectangle of the source node.
+ * @param sinkRect The rectangle of the sink node.
+ * @param sourceConnectorName The name of the source connector (e.g., "Right", "Left").
+ * @param sinkConnectorName The name of the sink connector (e.g., "Right", "Left").
+ * @returns True if the connection is considered non-linear, otherwise False.
+ */
+export const isConnectionNonLinear = (sourceRect, sinkRect, sourceConnectorName, sinkConnectorName) => {
+    const srcConn = sourceConnectorName.toLowerCase();
+    const snkConn = sinkConnectorName.toLowerCase();
+    // Case 1: The connectors are on the same side (e.g., Right-Right, Left-Left, Top-Top, Bottom-Bottom)
+    if (srcConn === snkConn) {
+        return true;
+    }
+    // Case 2: The connectors are opposite, but the node alignment is inverted
+    // (e.g., Right-Left, but the source node is to the right of the sink node)
+    if (srcConn === 'right' && snkConn === 'left' && sourceRect.x > sinkRect.x) {
+        return true;
+    }
+    if (srcConn === 'left' && snkConn === 'right' && sourceRect.x < sinkRect.x) {
+        return true;
+    }
+    if (srcConn === 'bottom' && snkConn === 'top' && sourceRect.y > sinkRect.y) {
+        return true;
+    }
+    if (srcConn === 'top' && snkConn === 'bottom' && sourceRect.y < sinkRect.y) {
+        return true;
+    }
+    // If none of the above conditions are true, the connection is considered "linear"
+    return false;
+};
+// Layout constants of DiagramItemComponent.tsx
+export const SVG_ICON_SIZE = 60;
+export const PADDING_TOP = 5;
+export const PADDING_BOTTOM = 5;
+export const PADDING_HORIZONTAL = 5;
+export const SPACING_SVG_TEXT = 0;
+export const FONT_SIZE = 11;
+export const MAX_ITEM_WIDTH = 130;
+export const MIN_ITEM_WIDTH = 64;
+export const MAX_LINES = 2;
+/**
+ * Breaks a string into multiple lines to fit a maximum width, adding an ellipsis if it exceeds the maximum number of lines.
+ *
+ * @param text The string to be wrapped.
+ * @param maxWidth The maximum width for a single line of text.
+ * @param maxLines The maximum number of lines allowed before truncation.
+ * @returns An array of strings, where each element is a line of text.
+ */
+export const wrapText = (text, maxWidth, maxLines, ctx) => {
+    if (!text || !ctx) {
+        return [];
+    }
+    // Per un calcolo accurato, usiamo un contesto canvas
+    // La logica precedente aveva un piccolo problema con la gestione degli spazi
+    const words = text.split(' ');
+    let lines = [];
+    let currentLine = '';
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        let testLine = currentLine.length > 0 ? currentLine + ' ' + word : word;
+        const metrics = ctx.measureText(testLine);
+        const testWidth = metrics.width;
+        if (testWidth > maxWidth) {
+            lines.push(currentLine);
+            currentLine = word;
+        }
+        else {
+            currentLine = testLine;
+        }
+    }
+    lines.push(currentLine);
+    // Gestisce il caso dell'ellissi
+    if (lines.length > maxLines) {
+        let lastLine = lines[maxLines - 1];
+        while (ctx.measureText(lastLine + '...').width > maxWidth) {
+            lastLine = lastLine.slice(0, -1);
+        }
+        lines[maxLines - 1] = lastLine + '...';
+        lines = lines.slice(0, maxLines);
+    }
+    return lines;
+};
+/**
+ * Calculates the full dimensions of a diagram item, including the icon and text.
+ * This function is based on already measured or estimated text dimensions.
+ *
+ * @param item The DiagramItem.
+ * @param textDimensions The dimensions (width, height) of the item's text.
+ * @returns An object with the calculatedWidth and calculatedHeight of the item.
+*/
+export const calculateDiagramItemFullDimensions = (item, textDimensions) => {
+    // Calcola la larghezza del testo con padding
+    const textWidthWithPadding = textDimensions.width + (PADDING_HORIZONTAL * 2);
+    // Applica i vincoli: la larghezza è il valore maggiore tra il minimo e il minore tra la larghezza calcolata e il massimo
+    const finalCalculatedWidth = Math.max(MIN_ITEM_WIDTH, Math.min(textWidthWithPadding, MAX_ITEM_WIDTH));
+    const textHeight = textDimensions.height;
+    let finalCalculatedHeight;
+    if (item.ItemName) {
+        // Calculate height based on wrapped text lines
+        const canvas = document.createElement('canvas');
+        const context = canvas.getContext('2d');
+        if (context) {
+            context.font = `${FONT_SIZE}px sans-serif`;
+            const lines = wrapText(item.ItemName, MAX_ITEM_WIDTH - (PADDING_HORIZONTAL * 2), MAX_LINES, context);
+            // Calculate height based on number of lines
+            finalCalculatedHeight = PADDING_TOP + SVG_ICON_SIZE + SPACING_SVG_TEXT + (lines.length * FONT_SIZE) + PADDING_BOTTOM;
+        }
+        else {
+            // Fallback if canvas context is not available
+            finalCalculatedHeight = PADDING_TOP + SVG_ICON_SIZE + SPACING_SVG_TEXT + textHeight + PADDING_BOTTOM;
+        }
+    }
+    else {
+        // No text, so height is just icon + padding
+        finalCalculatedHeight = PADDING_TOP + SVG_ICON_SIZE + PADDING_BOTTOM;
+    }
+    // Applies the guarantee that dimensions are never less than 64px
+    finalCalculatedHeight = Math.max(finalCalculatedHeight, 64);
+    return { calculatedWidth: finalCalculatedWidth, calculatedHeight: finalCalculatedHeight };
+};
+/** Helper function to get the color based on connection status */
+export const getConnectionColor = (status) => {
+    switch (status) {
+        case WorkItemStatus.Rejected:
+            return 'red';
+        case WorkItemStatus.Completed:
+            return 'green';
+        case WorkItemStatus.New:
+        default: // Default to gray for 'New' or any unhandled status
+            return 'gray';
+    }
+};
+export const validateDiagram = (diagram, newConnection) => {
+    // 1. Validazione di tutte le connessioni esistenti e della nuova
+    const connectionsToValidate = newConnection ? [...diagram.Connections, newConnection] : diagram.Connections;
+    // Usiamo una mappa per tracciare le connessioni in uscita da ciascun nodo
+    const connectionsFromSourceMap = new Map();
+    connectionsToValidate.forEach(conn => {
+        const sourceId = conn.Source.ParentDiagramItem.ID;
+        if (!connectionsFromSourceMap.has(sourceId)) {
+            connectionsFromSourceMap.set(sourceId, []);
+        }
+        connectionsFromSourceMap.get(sourceId)?.push(conn);
+    });
+    // Esegui la validazione per ogni connessione
+    for (const connection of connectionsToValidate) {
+        const sourceItem = diagram.DiagramItems.find(item => item.ID === connection.Source.ParentDiagramItem.ID);
+        const sinkItem = diagram.DiagramItems.find(item => item.ID === connection.Sink.ParentDiagramItem.ID);
+        if (!sourceItem || !sinkItem) {
+            throw new Error(SDKUI_Localizator.WorkflowDiagramConnectionInvalidNodes);
+        }
+        const sourceName = sourceItem.ItemName.length > 0 ? sourceItem.ItemName : DiagramItemTypes[sourceItem.Type].toString().toUpperCase();
+        const sinkName = sinkItem.ItemName.length > 0 ? sinkItem.ItemName : DiagramItemTypes[sinkItem.Type].toString().toUpperCase();
+        // Verifica la connessione di base (non verso 'Start' o da 'End')
+        if (sinkItem.Type === DiagramItemTypes.Start) {
+            throw new Error(SDKUI_Localizator.WorkflowDiagramCannotConnectToStart);
+        }
+        if (sourceItem.Type === DiagramItemTypes.End) {
+            throw new Error(SDKUI_Localizator.WorkflowDiagramCannotConnectFromEnd);
+        }
+        if (sourceItem.ID === sinkItem.ID) {
+            throw new Error(SDKUI_Localizator.WorkflowDiagramConnectionSelf.replace('{0}', sourceName));
+        }
+        // Verifica se la connessione esiste già
+        const connectionsFromCurrentSource = connectionsToValidate.filter(c => c.Source.ParentDiagramItem.ID === sourceItem.ID &&
+            c.Sink.ParentDiagramItem.ID === sinkItem.ID &&
+            c.ID !== connection.ID // Escludi la connessione corrente se stiamo aggiornando
+        );
+        if (connectionsFromCurrentSource.length > 0) {
+            throw new Error(SDKUI_Localizator.WorkflowDiagramConnectionAlreadyExists.replace('{0}', sourceName).replace('{1}', sinkName));
+        }
+    }
+    // 2. Validazione sul numero di connessioni in uscita per tipo di nodo
+    connectionsFromSourceMap.forEach((connections, sourceId) => {
+        const sourceItem = diagram.DiagramItems.find(item => item.ID === sourceId);
+        if (!sourceItem)
+            return;
+        const sourceName = sourceItem.ItemName.length > 0 ? sourceItem.ItemName : DiagramItemTypes[sourceItem.Type].toString().toUpperCase();
+        switch (sourceItem.Type) {
+            case DiagramItemTypes.Exit:
+                if (connections.length > 0) {
+                    throw new Error(SDKUI_Localizator.WorkflowDiagramExitCannotHaveOutgoing.replace('{0}', sourceName));
+                }
+                break;
+            case DiagramItemTypes.Start:
+            case DiagramItemTypes.UpdateDcmt:
+                if (connections.length > 1) {
+                    throw new Error(SDKUI_Localizator.WorkflowDiagramMaxOneOutgoing.replace('{0}', sourceName));
+                }
+                break;
+            default:
+                if (connections.length > 2) {
+                    throw new Error(SDKUI_Localizator.WorkflowDiagramMaxTwoOutgoing.replace('{0}', sourceName));
+                }
+                break;
+        }
+    });
+};
+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);
+};
+export const getNewWfDiagram = (info) => {
+    const startItem = {
+        ID: generateUUID(),
+        Left: 100,
+        Top: 100,
+        Width: 32,
+        Height: 32,
+        Type: DiagramItemTypes.Start,
+        StartAfterArchive: 1,
+        ItemName: '',
+        Description: '',
+    };
+    const endItem = {
+        ID: generateUUID(),
+        Left: 300,
+        Top: 100,
+        Width: 32,
+        Height: 32,
+        Type: DiagramItemTypes.End,
+        Hist: 1,
+        ItemName: '',
+        Description: '',
+    };
+    const newConnection = {
+        ID: generateUUID(),
+        Source: { ParentDiagramItem: { ID: startItem.ID }, ConnectorName: 'Right' },
+        Sink: { ParentDiagramItem: { ID: endItem.ID }, ConnectorName: 'Left' },
+        OutputStatus: WorkItemStatus.New,
+        Description: "",
+        PathGeometry: "",
+        SourceArrowSymbol: ArrowSymbol.None,
+        SinkArrowSymbol: ArrowSymbol.Arrow,
+    };
+    const newWfDiagram = {
+        DiagramItems: [startItem, endItem],
+        Connections: [newConnection],
+        Info: info,
+    };
+    return newWfDiagram;
+};
+export const workflowValidator = async (wf) => {
+    const validationItems = [];
+    if (!wf.Info) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "info", SDKUI_Localizator.WorkflowDiagramMissingInfo));
+    }
+    if (!wf.DiagramItems || wf.DiagramItems.length === 0) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "diagramItems", SDKUI_Localizator.WorkflowDiagramNoItems));
+    }
+    if (!wf.Connections || wf.Connections.length === 0) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "connections", SDKUI_Localizator.WorkflowDiagramNoConnections));
+    }
+    const startItems = wf.DiagramItems.filter(item => item.Type === DiagramItemTypes.Start);
+    if (startItems.length === 0) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "startItems", SDKUI_Localizator.WorkflowDiagramStartMissing));
+    }
+    if (startItems.length > 1) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "startItems", SDKUI_Localizator.WorkflowDiagramStartMultiple));
+    }
+    const endItems = wf.DiagramItems.filter(item => item.Type === DiagramItemTypes.End);
+    if (endItems.length === 0) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "endItems", SDKUI_Localizator.WorkflowDiagramEndMissing));
+    }
+    for (const item of wf.DiagramItems) {
+        const vil = await wfDiagramItemValidator(item);
+        vil.forEach(v => v.PropertyScopes = ['diagramItem']);
+        validationItems.push(...vil);
+        switch (item.Type) {
+            case DiagramItemTypes.Start:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.ERROR, `item-${item.ID}`, SDKUI_Localizator.WorkflowDiagramStartMustHaveOutgoing, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length > 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.ERROR, `item-${item.ID}`, SDKUI_Localizator.WorkflowDiagramStartCannotHaveIncoming, ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.End:
+            case DiagramItemTypes.Exit:
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.ERROR, `item-${item.ID}`, `L'elemento '${DiagramItemTypes[item.Type]}' deve avere almeno una connessione in ingresso.`, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length > 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.ERROR, `item-${item.ID}`, `L'elemento '${DiagramItemTypes[item.Type]}' non può avere connessioni in uscita.`, ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.Condition:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length !== 2) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, SDKUI_Localizator.WorkflowDiagramConditionTwoOutgoing, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.ERROR, `item-${item.ID}`, SDKUI_Localizator.WorkflowDiagramConditionMustHaveIncoming, ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.Approval:
+            case DiagramItemTypes.ExecTask:
+            case DiagramItemTypes.DataEntry:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length !== 2) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, SDKUI_Localizator.WorkflowDiagramElementShouldHaveTwoOutgoing.replace('{0}', item.ItemName), ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, SDKUI_Localizator.WorkflowDiagramElementShouldHaveIncoming.replace('{0}', item.ItemName), ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.Notification:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' dovrebbe avere almeno una connessione in uscita.`, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' deve avere almeno una connessione in ingresso.`, ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.UpdateDcmt:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length !== 1) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' dovrebbe avere esattamente una connessione in uscita.`, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' deve avere almeno una connessione in ingresso.`, ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.Status:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length !== 1) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' dovrebbe avere esattamente una connessione in uscita.`, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' deve avere almeno una connessione in ingresso.`, ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.RunApp:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' dovrebbe avere almeno una connessione in uscita.`, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' deve avere almeno una connessione in ingresso.`, ['diagramItem']));
+                }
+                break;
+        }
+    }
+    // Tutte le validazioni sono passate
+    return validationItems;
+};
+export const DiagramItemProps = {
+    ID: 'ID',
+    Left: 'Left',
+    Top: 'Top',
+    Width: 'Width',
+    Height: 'Height',
+    Type: 'Type',
+    ItemName: 'ItemName',
+    ItemName_IT: 'ItemName_IT',
+    ItemName_EN: 'ItemName_EN',
+    ItemName_FR: 'ItemName_FR',
+    ItemName_PT: 'ItemName_PT',
+    ItemName_ES: 'ItemName_ES',
+    ItemName_DE: 'ItemName_DE',
+    Description: 'Description',
+    Description_IT: 'Description_IT',
+    Description_EN: 'Description_EN',
+    Description_FR: 'Description_FR',
+    Description_PT: 'Description_PT',
+    Description_ES: 'Description_ES',
+    Description_DE: 'Description_DE',
+    StatusValue: 'StatusValue',
+    RegisterPost: 'RegisterPost',
+    AllowZeroTos: 'AllowZeroTos',
+    Tos: 'Tos',
+    SetRule: 'SetRule',
+    StartAfterArchive: 'StartAfterArchive',
+    StartAfterUpdate: 'StartAfterUpdate',
+    StartAfterUpdateMIDs: 'StartAfterUpdateMIDs',
+    StartManual: 'StartManual',
+    Hist: 'Hist',
+    EndWFInstance: 'EndWFInstance',
+    QD: 'QD',
+    SOD: 'SOD',
+    MetadataValues: 'MetadataValues',
+    Severity: 'Severity',
+    RegAsWfInstPart: 'RegAsWfInstPart',
+    FormatCultureID: 'FormatCultureID',
+    Tos2: 'Tos2',
+    QD2: 'QD2',
+    PlatformObjName: 'PlatformObjName',
+    PlatformObjDescr: 'PlatformObjDescr',
+    Value1asInt: 'Value1asInt',
+    Value2asInt: 'Value2asInt',
+    Value3asInt: 'Value3asInt',
+    Value1asString: 'Value1asString',
+    AppType: 'AppType',
+    AppName: 'AppName',
+    AppArgs: 'AppArgs',
+    Trunc: 'Trunc',
+};
+export const wfDiagramItemValidator = async (d) => {
+    let vil = [];
+    switch (d.Type) {
+        case DiagramItemTypes.Start:
+            if (d.StartAfterArchive !== 1 && d.StartAfterUpdate !== 1 && d.StartManual !== 1)
+                vil.push(new ValidationItem(ResultTypes.ERROR, "*", "Indicare la modalità di avvio dell'istanza di workflow"));
+            if (d.StartAfterUpdate === 1 && (d.StartAfterUpdateMIDs === undefined || d.StartAfterUpdateMIDs.length <= 0))
+                vil.push(new ValidationItem(ResultTypes.ERROR, DiagramItemProps.StartAfterUpdateMIDs, "Indicare almeno un metadato la cui modifica avvii l'istanza"));
+            break;
+        case DiagramItemTypes.Approval:
+            PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
+            PlatformObjectValidator.RequiredStringValidator(d.Description, DiagramItemProps.Description, vil, SDKUI_Localizator.Description);
+            PlatformObjectValidator.RequiredStringValidator(d.Tos, DiagramItemProps.Tos, vil, SDKUI_Localizator.Recipients);
+            break;
+        case DiagramItemTypes.ExecTask:
+            PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
+            PlatformObjectValidator.RequiredStringValidator(d.Description, DiagramItemProps.Description, vil, SDKUI_Localizator.Description);
+            PlatformObjectValidator.RequiredStringValidator(d.Tos, DiagramItemProps.Tos, vil, SDKUI_Localizator.Recipients);
+            PlatformObjectValidator.RequiredStringValidator(d.AppName, DiagramItemProps.AppName, vil, SDKUI_Localizator.WorkflowAppName);
+            PlatformObjectValidator.RequiredStringValidator(d.AppType, DiagramItemProps.AppType, vil, SDKUI_Localizator.WorkflowAppType);
+            break;
+        case DiagramItemTypes.Notification:
+            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);
+            break;
+        case DiagramItemTypes.RunApp:
+            PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
+            PlatformObjectValidator.RequiredStringValidator(d.AppName, DiagramItemProps.AppName, vil, SDKUI_Localizator.WorkflowAppName);
+            PlatformObjectValidator.RequiredStringValidator(d.AppType, DiagramItemProps.AppType, vil, SDKUI_Localizator.WorkflowAppType);
+            break;
+        case DiagramItemTypes.Condition:
+            PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
+            let qvo = new QueryValidatorOptions();
+            qvo.DoSelectValidation = false;
+            qvo.DoOrderByValidation = false;
+            await PlatformObjectValidator.QueryValidatorAsync(d.QD, vil, qvo);
+            if (d.QD?.where === undefined || d.QD.where.length <= 0) {
+                vil.push(new ValidationItem(ResultTypes.ERROR, TMPropertyNames.where, "La query della condizione non contiene criteri di selezione", [DiagramItemProps.QD]));
+            }
+            break;
+    }
+    return vil;
+};

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

@@ -0,0 +1,10 @@
+import { WfDiagram } from './interfaces';
+import { CultureIDs, Severities, WFAppTypes, WorkItemSetRules, WorkItemStatus } from '@topconsultnpm/sdk-ts';
+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 const serializeWfDiagramToXml: (wfDiagram: WfDiagram | null) => Promise<string>;