@topconsultnpm/sdkui-react 6.17.0-test10

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import { QueryDescriptor } from '@topconsultnpm/sdk-ts';
+import { WorkItemActor } from './RecipientList';
+export declare const RecipientsContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const tosToActors: (tosString: string) => {
+    andRecipients: WorkItemActor[];
+    orRecipients: WorkItemActor[];
+};
+export declare const actorsToTos: (actors: WorkItemActor[]) => string;
+interface WorkitemRecipientsEditorProps {
+    tos: string;
+    qd: QueryDescriptor | undefined;
+    mTID: number | undefined;
+    onTosChange: (newTos: string) => void;
+    onQDChange: (newQD: QueryDescriptor | undefined) => void;
+}
+declare const WorkitemRecipientsEditor: React.FC<WorkitemRecipientsEditorProps>;
+export default WorkitemRecipientsEditor;

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

@@ -0,0 +1,97 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import styled from 'styled-components';
+import RecipientList, { WorkItemActorTypes } from './RecipientList';
+import { SDKUI_Localizator } from '../../../../helper';
+export const RecipientsContainer = styled.div `
+  display: flex;
+  gap: 20px;
+  flex-wrap: wrap;
+`;
+export const tosToActors = (tosString) => {
+    const andRecipients = [];
+    const orRecipients = [];
+    if (!tosString)
+        return { andRecipients, orRecipients };
+    const tokens1 = tosString.split(';');
+    for (const t of tokens1) {
+        const t1 = t.trim();
+        if (!t1)
+            continue;
+        const tokens2 = t1.split('|');
+        if (tokens2.length < 2)
+            continue;
+        const actorTypeStr = tokens2[0].toUpperCase();
+        const actorType = WorkItemActorTypes[actorTypeStr];
+        const actorID = tokens2[1];
+        const or = tokens2.length === 3 ? parseInt(tokens2[2], 10) : 0;
+        if (actorType !== undefined) {
+            const actor = {
+                ActorType: actorType,
+                ActorID: actorID,
+                Or: or,
+            };
+            if (or === 0) {
+                andRecipients.push(actor);
+            }
+            else {
+                orRecipients.push(actor);
+            }
+        }
+    }
+    return { andRecipients, orRecipients };
+};
+export const actorsToTos = (actors) => {
+    return actors.map(actor => `${WorkItemActorTypes[actor.ActorType]}|${actor.ActorID}|${actor.Or}`).join(';');
+};
+const WorkitemRecipientsEditor = ({ tos, qd, mTID, onTosChange, onQDChange }) => {
+    const [localTos, setLocalTos] = useState(tos);
+    useEffect(() => {
+        setLocalTos(tos);
+    }, [tos]);
+    const handleAddRecipients = useCallback((newRecipients, orValue) => {
+        setLocalTos(prevTos => {
+            const { andRecipients, orRecipients } = tosToActors(prevTos);
+            let allRecipients = [...andRecipients, ...orRecipients];
+            // 1. Rimuovi qualsiasi QID esistente se il nuovo destinatario è una query
+            if (newRecipients.length > 0 && newRecipients[0].ActorType === WorkItemActorTypes.QID) {
+                allRecipients = allRecipients.filter(r => r.ActorType !== WorkItemActorTypes.QID);
+            }
+            const updatedRecipients = [...allRecipients, ...newRecipients.map(r => ({ ...r, Or: orValue }))];
+            const newTos = actorsToTos(updatedRecipients);
+            onTosChange(newTos);
+            return newTos;
+        });
+    }, [onTosChange, onQDChange]);
+    const handleRemoveRecipient = useCallback((recipientToRemove) => {
+        setLocalTos(prevTos => {
+            const { andRecipients, orRecipients } = tosToActors(prevTos);
+            const allRecipients = [...andRecipients, ...orRecipients];
+            const updatedRecipients = allRecipients.filter(r => r.ActorType !== recipientToRemove.ActorType || r.ActorID !== recipientToRemove.ActorID || r.Or !== recipientToRemove.Or);
+            const newTos = actorsToTos(updatedRecipients);
+            onTosChange(newTos);
+            if (recipientToRemove.ActorType === WorkItemActorTypes.QID) {
+                onQDChange(undefined);
+            }
+            return newTos;
+        });
+    }, [onTosChange, onQDChange]);
+    const { andRecipients, orRecipients } = useMemo(() => {
+        return tosToActors(localTos);
+    }, [localTos]);
+    const handleQDChosen = useCallback((newQd, orValue) => {
+        const allRecipients = [...andRecipients, ...orRecipients];
+        const updatedRecipients = allRecipients.filter(r => r.ActorType !== WorkItemActorTypes.QID);
+        const recipientToAdd = {
+            ActorType: WorkItemActorTypes.QID,
+            ActorID: newQd.id ? newQd.id.toString() : '-1',
+            Or: orValue,
+        };
+        updatedRecipients.push(recipientToAdd);
+        const newTos = actorsToTos(updatedRecipients);
+        onTosChange(newTos);
+        onQDChange(newQd);
+    }, [andRecipients, orRecipients, onTosChange, onQDChange]);
+    return (_jsxs(RecipientsContainer, { children: [_jsx(RecipientList, { recipients: andRecipients, title: `${SDKUI_Localizator.Recipients} (AND)`, tid: mTID, qd: qd, onQDChange: (newQd) => newQd && handleQDChosen(newQd, 0), onAdd: (newRecipients) => handleAddRecipients(newRecipients, 0), onRemove: handleRemoveRecipient }), _jsx(RecipientList, { recipients: orRecipients, title: `${SDKUI_Localizator.Recipients} (OR)`, tid: mTID, qd: qd, onQDChange: (newQd) => newQd && handleQDChosen(newQd, 1), onAdd: (newRecipients) => handleAddRecipients(newRecipients, 1), onRemove: handleRemoveRecipient })] }));
+};
+export default WorkitemRecipientsEditor;

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

@@ -0,0 +1,126 @@
+import { CultureIDs, QueryDescriptor, Severities, WFAppTypes, WorkItemSetRules, WorkItemStatus } from "@topconsultnpm/sdk-ts";
+import { MetadataValueDescriptorEx } from "../../../../ts";
+export declare enum DiagramItemTypes {
+    None = 0,
+    Start = 1,
+    Condition = 2,
+    Status = 3,
+    Approval = 4,
+    DataEntry = 5,
+    ExecTask = 6,
+    UpdateDcmt = 7,
+    SignAndTimeStamp = 8,
+    Notification = 9,
+    WorkGroup_Create = 10,
+    CaseFlow_Create = 11,
+    RunApp = 12,
+    WorkGroup_AddParts = 13,
+    CaseFlow_AddParts = 14,
+    Exit = 88,
+    End = 99
+}
+export declare enum ArrowSymbol {
+    None = 0,
+    Arrow = 1,
+    Diamond = 2
+}
+export interface WfInfo {
+    ID: string;
+    MTID: number;
+    MStatusMID: number;
+    MStatusDLID: number;
+    Type?: number;
+}
+export interface DiagramItem {
+    ID: string;
+    Left: number;
+    Top: number;
+    Width: number;
+    Height: number;
+    Type: DiagramItemTypes;
+    ItemName: string;
+    ItemName_IT?: string;
+    ItemName_EN?: string;
+    ItemName_FR?: string;
+    ItemName_PT?: string;
+    ItemName_ES?: string;
+    ItemName_DE?: string;
+    Description: string;
+    Description_IT?: string;
+    Description_EN?: string;
+    Description_FR?: string;
+    Description_PT?: string;
+    Description_ES?: string;
+    Description_DE?: string;
+    StatusValue?: string;
+    RegisterPost?: boolean;
+    AllowZeroTos?: boolean;
+    Tos?: string;
+    SetRule?: WorkItemSetRules;
+    StartAfterArchive?: number;
+    StartAfterUpdate?: number;
+    StartAfterUpdateMIDs?: number[];
+    StartManual?: number;
+    Hist?: number;
+    EndWFInstance?: number;
+    QD?: QueryDescriptor;
+    SOD?: string;
+    MetadataValues?: MetadataValueDescriptorEx[];
+    Severity?: Severities;
+    RegAsWfInstPart?: number;
+    FormatCultureID?: CultureIDs | undefined;
+    Tos2?: string;
+    QD2?: QueryDescriptor;
+    PlatformObjName?: string;
+    PlatformObjDescr?: string;
+    Value1asInt?: number;
+    Value2asInt?: number;
+    Value3asInt?: number;
+    Value1asString?: string;
+    AppType?: WFAppTypes;
+    AppName?: string;
+    AppArgs?: string;
+    Trunc?: number;
+}
+export interface ConnectionPoint {
+    ParentDiagramItem: {
+        ID: string;
+    };
+    ConnectorName: string;
+}
+export interface Connection {
+    ID: string;
+    Source: ConnectionPoint;
+    Sink: ConnectionPoint;
+    OutputStatus: WorkItemStatus;
+    Description: string;
+    Description_IT?: string;
+    Description_EN?: string;
+    Description_FR?: string;
+    Description_PT?: string;
+    Description_ES?: string;
+    Description_DE?: string;
+    PathGeometry: string;
+    SourceArrowSymbol: ArrowSymbol;
+    SinkArrowSymbol: ArrowSymbol;
+    sinkArrowAngle?: number;
+}
+export interface WfDiagram {
+    Info: WfInfo | null;
+    DiagramItems: DiagramItem[];
+    Connections: Connection[];
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface TextDimensions {
+    width: number;
+    height: number;
+}

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

@@ -0,0 +1,26 @@
+export var DiagramItemTypes;
+(function (DiagramItemTypes) {
+    DiagramItemTypes[DiagramItemTypes["None"] = 0] = "None";
+    DiagramItemTypes[DiagramItemTypes["Start"] = 1] = "Start";
+    DiagramItemTypes[DiagramItemTypes["Condition"] = 2] = "Condition";
+    DiagramItemTypes[DiagramItemTypes["Status"] = 3] = "Status";
+    DiagramItemTypes[DiagramItemTypes["Approval"] = 4] = "Approval";
+    DiagramItemTypes[DiagramItemTypes["DataEntry"] = 5] = "DataEntry";
+    DiagramItemTypes[DiagramItemTypes["ExecTask"] = 6] = "ExecTask";
+    DiagramItemTypes[DiagramItemTypes["UpdateDcmt"] = 7] = "UpdateDcmt";
+    DiagramItemTypes[DiagramItemTypes["SignAndTimeStamp"] = 8] = "SignAndTimeStamp";
+    DiagramItemTypes[DiagramItemTypes["Notification"] = 9] = "Notification";
+    DiagramItemTypes[DiagramItemTypes["WorkGroup_Create"] = 10] = "WorkGroup_Create";
+    DiagramItemTypes[DiagramItemTypes["CaseFlow_Create"] = 11] = "CaseFlow_Create";
+    DiagramItemTypes[DiagramItemTypes["RunApp"] = 12] = "RunApp";
+    DiagramItemTypes[DiagramItemTypes["WorkGroup_AddParts"] = 13] = "WorkGroup_AddParts";
+    DiagramItemTypes[DiagramItemTypes["CaseFlow_AddParts"] = 14] = "CaseFlow_AddParts";
+    DiagramItemTypes[DiagramItemTypes["Exit"] = 88] = "Exit";
+    DiagramItemTypes[DiagramItemTypes["End"] = 99] = "End";
+})(DiagramItemTypes || (DiagramItemTypes = {}));
+export var ArrowSymbol;
+(function (ArrowSymbol) {
+    ArrowSymbol[ArrowSymbol["None"] = 0] = "None";
+    ArrowSymbol[ArrowSymbol["Arrow"] = 1] = "Arrow";
+    ArrowSymbol[ArrowSymbol["Diamond"] = 2] = "Diamond";
+})(ArrowSymbol || (ArrowSymbol = {}));

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

@@ -0,0 +1,14 @@
+import { MetadataValueDescriptorEx } from "../../../../ts";
+/**
+ * Parsa la stringa XML annidata di MetadataValues in un array di MetadataValueDescriptor.
+ * @param xmlString La stringa XML grezza contenente le entità codificate.
+ * @returns Un array di MetadataValueDescriptor.
+ */
+export declare const parseMetadataValuesXml: (xmlString: string) => MetadataValueDescriptorEx[];
+/**
+ * Serializza un array di MetadataValueDescriptor nella stringa XML richiesta
+ * dal C# DataContractSerializer, con le entità codificate.
+ * @param metadataValues L'array di MetadataValueDescriptor da serializzare.
+ * @returns La stringa XML pronta da inserire nel tag <MetadataValues>.
+ */
+export declare const serializeMetadataValuesToXml: (metadataValues: MetadataValueDescriptorEx[] | undefined) => string;

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

@@ -0,0 +1,54 @@
+import { MetadataValueDescriptorEx } from "../../../../ts";
+/**
+ * Parsa la stringa XML annidata di MetadataValues in un array di MetadataValueDescriptor.
+ * @param xmlString La stringa XML grezza contenente le entità codificate.
+ * @returns Un array di MetadataValueDescriptor.
+ */
+export const parseMetadataValuesXml = (xmlString) => {
+    const parser = new DOMParser();
+    const xmlDoc = parser.parseFromString(xmlString, "application/xml");
+    const metadataDescriptors = [];
+    const itemsXML = xmlDoc.querySelectorAll("MetadataValueDescriptor");
+    itemsXML.forEach(itemXML => {
+        const descriptor = new MetadataValueDescriptorEx();
+        descriptor.mid = parseInt(itemXML.querySelector("MID")?.textContent || "0", 10);
+        descriptor.metadataName = itemXML.querySelector("MetadataName")?.textContent || undefined;
+        descriptor.value = itemXML.querySelector("Value")?.textContent || undefined;
+        metadataDescriptors.push(descriptor);
+    });
+    return metadataDescriptors;
+};
+/**
+ * Serializza un array di MetadataValueDescriptor nella stringa XML richiesta
+ * dal C# DataContractSerializer, con le entità codificate.
+ * @param metadataValues L'array di MetadataValueDescriptor da serializzare.
+ * @returns La stringa XML pronta da inserire nel tag <MetadataValues>.
+ */
+export const serializeMetadataValuesToXml = (metadataValues) => {
+    if (!metadataValues || metadataValues.length === 0) {
+        return "";
+    }
+    let xml = `<ArrayOfMetadataValueDescriptor xmlns="http://schemas.datacontract.org/2004/07/TopConsult.TM5.Server.WEBSDK.Contracts" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">`;
+    metadataValues.forEach(md => {
+        xml += `<MetadataValueDescriptor>`;
+        xml += `<MID>${md.mid}</MID>`;
+        // Il C# DataContractSerializer usa <MetadataName i:nil="true"/> per valori nulli
+        if (md.metadataName === undefined || md.metadataName === null) {
+            xml += `<MetadataName i:nil="true"/>`;
+        }
+        else {
+            xml += `<MetadataName>${md.metadataName}</MetadataName>`;
+        }
+        // Gestione del valore (potrebbe essere nullo o vuoto)
+        if (md.value === undefined || md.value === null) {
+            xml += `<Value i:nil="true"/>`;
+        }
+        else {
+            xml += `<Value>${md.value}</Value>`;
+        }
+        xml += `</MetadataValueDescriptor>`;
+    });
+    xml += `</ArrayOfMetadataValueDescriptor>`;
+    // Codifica le entità XML per inserire la stringa nel tag principale
+    return xml;
+};

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

@@ -0,0 +1,3 @@
+import { QueryDescriptor } from '@topconsultnpm/sdk-ts';
+export declare const parseQueryDescriptorXml: (xmlString: string) => QueryDescriptor | undefined;
+export declare const serializeQueryDescriptorXml: (qd: QueryDescriptor | undefined) => Promise<string>;

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

@@ -0,0 +1,188 @@
+import { FromItem, JoinItem, OnJoinItem, OrderByItem, QueryDescriptor, QueryParameterDescriptor, SDK_Globals, SearchEngine, SelectItem, WhereItem } from '@topconsultnpm/sdk-ts';
+/**
+ * Safely gets text content of an element and converts to a number.
+ * Returns undefined if element or content is missing/invalid.
+ */
+const getNumber = (element, selector) => {
+    const text = element?.querySelector(selector)?.textContent;
+    if (text === null || text === undefined || text.trim() === '') {
+        return undefined;
+    }
+    const num = parseInt(text, 10);
+    return isNaN(num) ? undefined : num;
+};
+/**
+ * Safely gets text content of an element and converts to a boolean.
+ * Returns undefined if element or content is missing/invalid.
+ */
+const getBoolean = (element, selector) => {
+    const text = element?.querySelector(selector)?.textContent;
+    if (text === null || text === undefined || text.trim() === '') {
+        return undefined;
+    }
+    return text.toLowerCase() === 'true';
+};
+/**
+ * Safely gets text content of an element.
+ * Returns undefined if element or content is missing/empty.
+ */
+const getString = (element, selector) => {
+    const text = element?.querySelector(selector)?.textContent;
+    if (text === null || text === undefined || text.trim() === '') {
+        return undefined;
+    }
+    return text;
+};
+/**
+ * Parses a single SelectItem XML element.
+ */
+const parseSelectItem = (itemXML) => {
+    const selectItem = new SelectItem();
+    selectItem.function = getString(itemXML, "Function");
+    selectItem.tid = getNumber(itemXML, "TID");
+    selectItem.alias = getString(itemXML, "Alias");
+    selectItem.mid = getNumber(itemXML, "MID");
+    selectItem.as = getString(itemXML, "As");
+    selectItem.visibility = getString(itemXML, "Visibility");
+    return selectItem;
+};
+/**
+ * Parses a single FromItem XML element.
+ */
+const parseFromItem = (itemXML) => {
+    const fromItem = new FromItem();
+    fromItem.tid = getNumber(itemXML, "TID");
+    return fromItem;
+};
+/**
+ * Parses a single OnJoinItem XML element.
+ */
+const parseOnJoinItem = (itemXML) => {
+    const onJoinItem = new OnJoinItem();
+    onJoinItem.leftBrackets = getString(itemXML, "LeftBrackets");
+    onJoinItem.leftTID = getNumber(itemXML, "LeftTID");
+    onJoinItem.leftAlias = getString(itemXML, "LeftAlias");
+    onJoinItem.leftMID = getNumber(itemXML, "LeftMID");
+    onJoinItem.operator = getString(itemXML, "Operator");
+    onJoinItem.rightTID = getNumber(itemXML, "RightTID");
+    onJoinItem.rightAlias = getString(itemXML, "RightAlias");
+    onJoinItem.rightMID = getNumber(itemXML, "RightMID");
+    onJoinItem.rightBrackets = getString(itemXML, "RightBrackets");
+    onJoinItem.or = getBoolean(itemXML, "Or");
+    return onJoinItem;
+};
+/**
+ * Parses a single JoinItem XML element.
+ */
+const parseJoinItem = (itemXML) => {
+    const joinItem = new JoinItem();
+    joinItem.joinType = getString(itemXML, "JoinType");
+    joinItem.tid = getNumber(itemXML, "TID");
+    joinItem.alias = getString(itemXML, "Alias");
+    const onItems = [];
+    itemXML.querySelectorAll("On > OnJoinItem").forEach(onItemXML => {
+        onItems.push(parseOnJoinItem(onItemXML));
+    });
+    joinItem.on = onItems.length > 0 ? onItems : undefined;
+    return joinItem;
+};
+/**
+ * Parses a single WhereItem XML element.
+ */
+const parseWhereItem = (itemXML) => {
+    const whereItem = new WhereItem();
+    whereItem.leftBrackets = getString(itemXML, "LeftBrackets");
+    whereItem.tid = getNumber(itemXML, "TID");
+    whereItem.alias = getString(itemXML, "Alias");
+    whereItem.mid = getNumber(itemXML, "MID");
+    whereItem.operator = getString(itemXML, "Operator");
+    whereItem.value1 = getString(itemXML, "Value1");
+    whereItem.value2 = getString(itemXML, "Value2");
+    whereItem.rightBrackets = getString(itemXML, "RightBrackets");
+    whereItem.or = getBoolean(itemXML, "Or");
+    return whereItem;
+};
+/**
+ * Parses a single OrderByItem XML element.
+ */
+const parseOrderByItem = (itemXML) => {
+    const orderByItem = new OrderByItem();
+    orderByItem.tid = getNumber(itemXML, "TID");
+    orderByItem.alias = getString(itemXML, "Alias");
+    orderByItem.mid = getNumber(itemXML, "MID");
+    orderByItem.asc = getBoolean(itemXML, "Asc");
+    return orderByItem;
+};
+/**
+ * Parses a single QueryParameterDescriptor XML element.
+ * Note: 'value' parsing is generic, may need refinement based on actual data types.
+ */
+const parseQueryParameterDescriptor = (itemXML) => {
+    const paramDescriptor = new QueryParameterDescriptor();
+    // For 'value', you might need more sophisticated parsing depending on its type (string, number, boolean, etc.)
+    const valueElement = itemXML.querySelector("Value");
+    paramDescriptor.value = valueElement ? valueElement.textContent : undefined;
+    paramDescriptor.mappedTID = getNumber(itemXML, "MappedTID");
+    paramDescriptor.mappedMID = getNumber(itemXML, "MappedMID");
+    return paramDescriptor;
+};
+export const parseQueryDescriptorXml = (xmlString) => {
+    if (!xmlString || xmlString.trim() === '') {
+        return undefined;
+    }
+    const parser = new DOMParser();
+    const xmlDoc = parser.parseFromString(xmlString, "application/xml");
+    let queryDescriptorElement = xmlDoc.querySelector("QueryDescriptor");
+    if (!queryDescriptorElement && xmlDoc.documentElement?.tagName === "QueryDescriptor") {
+        // Fallback: If QueryDescriptor is the root element and not found as a child
+        queryDescriptorElement = xmlDoc.documentElement;
+    }
+    if (!queryDescriptorElement) {
+        console.warn("L'XML del QueryDescriptor non contiene l'elemento <QueryDescriptor>.");
+        return undefined;
+    }
+    const queryDescriptor = new QueryDescriptor();
+    queryDescriptor.maxDcmtsToBeReturned = getNumber(queryDescriptorElement, "MaxDcmtsToBeReturned");
+    const selectItems = [];
+    queryDescriptorElement.querySelectorAll("Select > SelectItem").forEach(itemXML => {
+        selectItems.push(parseSelectItem(itemXML));
+    });
+    queryDescriptor.select = selectItems.length > 0 ? selectItems : undefined;
+    const fromElement = queryDescriptorElement.querySelector("From");
+    if (fromElement) {
+        queryDescriptor.from = parseFromItem(fromElement);
+    }
+    const joinItems = [];
+    queryDescriptorElement.querySelectorAll("Join > JoinItem").forEach(itemXML => {
+        joinItems.push(parseJoinItem(itemXML));
+    });
+    queryDescriptor.join = joinItems.length > 0 ? joinItems : undefined;
+    const whereItems = [];
+    queryDescriptorElement.querySelectorAll("Where > WhereItem").forEach(itemXML => {
+        whereItems.push(parseWhereItem(itemXML));
+    });
+    queryDescriptor.where = whereItems.length > 0 ? whereItems : undefined;
+    const orderByItems = [];
+    queryDescriptorElement.querySelectorAll("OrderBy > OrderByItem").forEach(itemXML => {
+        orderByItems.push(parseOrderByItem(itemXML));
+    });
+    queryDescriptor.orderBy = orderByItems.length > 0 ? orderByItems : undefined;
+    const paramsItems = [];
+    queryDescriptorElement.querySelectorAll("Params > QueryParameterDescriptor").forEach(itemXML => {
+        paramsItems.push(parseQueryParameterDescriptor(itemXML));
+    });
+    queryDescriptor.params = paramsItems.length > 0 ? paramsItems : undefined;
+    return SearchEngine.NormalizeQueryDescriptor(queryDescriptor);
+};
+export const serializeQueryDescriptorXml = async (qd) => {
+    // try {
+    if (!qd)
+        return '';
+    let xml = await SDK_Globals.tmSession?.NewDcmtPlatformEngine().UtilsSerializeQdAsync(qd) ?? '';
+    return xml;
+    // } catch (error) {
+    // console.error('Error serializing QueryDescriptor to XML:', error);
+    //TODO: gestire errore
+    // 	return '';
+    // }
+};

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

@@ -0,0 +1,122 @@
+import { ValidationItem, WorkItemStatus } from '@topconsultnpm/sdk-ts';
+import { Point, Rect, DiagramItem, WfDiagram, TextDimensions, Connection, WfInfo } from './interfaces';
+/**
+ * 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 declare const calculateArrowAngle: (prevPoint: Point, currentPoint: Point) => number;
+/**
+ * Calculates the center point of a diagram item.
+ * @param item The diagram item.
+ * @returns The center point.
+ */
+export declare const getItemCenter: (item: DiagramItem) => Point;
+/**
+ * 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 declare const getConnectionPoint: (item: DiagramItem, connectorName: string) => Point;
+/**
+ * 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 declare const isConnectionNonLinear: (sourceRect: Rect, sinkRect: Rect, sourceConnectorName: string, sinkConnectorName: string) => boolean;
+export declare const SVG_ICON_SIZE = 60;
+export declare const PADDING_TOP = 5;
+export declare const PADDING_BOTTOM = 5;
+export declare const PADDING_HORIZONTAL = 5;
+export declare const SPACING_SVG_TEXT = 0;
+export declare const FONT_SIZE = 11;
+export declare const MAX_ITEM_WIDTH = 130;
+export declare const MIN_ITEM_WIDTH = 64;
+export declare 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 declare const wrapText: (text: string, maxWidth: number, maxLines: number, ctx: CanvasRenderingContext2D) => string[];
+/**
+ * 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 declare const calculateDiagramItemFullDimensions: (item: DiagramItem, textDimensions: TextDimensions) => {
+    calculatedWidth: number;
+    calculatedHeight: number;
+};
+/** 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;
+export declare const getNewWfDiagram: (info: WfInfo | null) => WfDiagram;
+export declare const workflowValidator: (wf: WfDiagram) => Promise<ValidationItem[]>;
+export declare const DiagramItemProps: {
+    ID: string;
+    Left: string;
+    Top: string;
+    Width: string;
+    Height: string;
+    Type: string;
+    ItemName: string;
+    ItemName_IT: string;
+    ItemName_EN: string;
+    ItemName_FR: string;
+    ItemName_PT: string;
+    ItemName_ES: string;
+    ItemName_DE: string;
+    Description: string;
+    Description_IT: string;
+    Description_EN: string;
+    Description_FR: string;
+    Description_PT: string;
+    Description_ES: string;
+    Description_DE: string;
+    StatusValue: string;
+    RegisterPost: string;
+    AllowZeroTos: string;
+    Tos: string;
+    SetRule: string;
+    StartAfterArchive: string;
+    StartAfterUpdate: string;
+    StartAfterUpdateMIDs: string;
+    StartManual: string;
+    Hist: string;
+    EndWFInstance: string;
+    QD: string;
+    SOD: string;
+    MetadataValues: string;
+    Severity: string;
+    RegAsWfInstPart: string;
+    FormatCultureID: string;
+    Tos2: string;
+    QD2: string;
+    PlatformObjName: string;
+    PlatformObjDescr: string;
+    Value1asInt: string;
+    Value2asInt: string;
+    Value3asInt: string;
+    Value1asString: string;
+    AppType: string;
+    AppName: string;
+    AppArgs: string;
+    Trunc: string;
+};
+export declare const wfDiagramItemValidator: (d: DiagramItem) => Promise<ValidationItem[]>;