@topconsultnpm/sdkui-react 6.17.0-test9

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

@@ -0,0 +1,490 @@
+import { ArrowSymbol, DiagramItemTypes } from './interfaces';
+import { CultureIDs, Severities, WFAppTypes, WorkItemSetRules, WorkItemStatus } from '@topconsultnpm/sdk-ts';
+import { parseQueryDescriptorXml, serializeQueryDescriptorXml } from './queryDescriptorParser'; // Import the new parser
+import { parseMetadataValuesXml, serializeMetadataValuesToXml } 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:
+            return CultureIDs.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) {
+        case 0:
+            return WorkItemStatus.New;
+        case 1:
+            return WorkItemStatus.Completed;
+        case -1:
+            return WorkItemStatus.Rejected;
+        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;
+    }
+};
+export const parseWfDiagramXml = (xmlString) => {
+    const parser = new DOMParser();
+    const xmlDoc = parser.parseFromString(xmlString, "application/xml");
+    const wfDiagram = {
+        Info: {
+            ID: "",
+            MTID: 0,
+            MStatusMID: 0,
+            MStatusDLID: 0,
+            Type: 0,
+        },
+        DiagramItems: [],
+        Connections: [],
+    };
+    const rootElement = xmlDoc.querySelector("Root");
+    if (!rootElement) {
+        console.warn("L'XML non contiene l'elemento <Root>.");
+        return wfDiagram;
+    }
+    // Parsing WfInfo
+    const workflowXML = rootElement.querySelector("Workflow");
+    if (workflowXML) {
+        wfDiagram.Info = {
+            ID: workflowXML.querySelector("WFID")?.textContent || "",
+            MTID: parseInt(workflowXML.querySelector("WFMTID")?.textContent || "0", 10),
+            MStatusMID: parseInt(workflowXML.querySelector("WFMStatusMID")?.textContent || "0", 10),
+            MStatusDLID: parseInt(workflowXML.querySelector("WFMStatusDLID")?.textContent || "0", 10),
+            Type: 0,
+        };
+    }
+    // Parsing DiagramItems
+    const diagramItemsXML = rootElement.querySelectorAll("DiagramItems > DiagramItem");
+    diagramItemsXML.forEach(itemXML => {
+        const left = parseFloat(itemXML.querySelector("L")?.textContent || "0");
+        const top = parseFloat(itemXML.querySelector("T")?.textContent || "0");
+        const parsedWidth = parseFloat(itemXML.querySelector("W")?.textContent || "0");
+        const width = isNaN(parsedWidth) ? 64 : parsedWidth; // Valore di default 100 se NaN
+        const parsedHeight = parseFloat(itemXML.querySelector("H")?.textContent || "0");
+        const height = isNaN(parsedHeight) ? 64 : parsedHeight; // Valore di default 80 se NaN
+        // Get the raw XML string for QD
+        const qdXmlString = itemXML.querySelector("QD")?.textContent || undefined;
+        let parsedQD = undefined;
+        if (qdXmlString) {
+            // Parse the QD XML string into a QueryDescriptor object
+            parsedQD = parseQueryDescriptorXml(qdXmlString);
+        }
+        const qd2XmlString = itemXML.querySelector("QD2")?.textContent || undefined;
+        let parsedQD2 = undefined;
+        if (qd2XmlString) {
+            // Parse the QD XML string into a QueryDescriptor object
+            parsedQD2 = parseQueryDescriptorXml(qd2XmlString);
+        }
+        const metadataValuesXmlString = itemXML.querySelector("MetadataValues")?.textContent || undefined;
+        let parsedMetadataValues = undefined;
+        if (metadataValuesXmlString) {
+            parsedMetadataValues = parseMetadataValuesXml(metadataValuesXmlString);
+        }
+        const startAfterUpdateMIDsContent = itemXML.querySelector("StartAfterUpdateMIDs")?.textContent;
+        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,
+            Top: top,
+            Width: width,
+            Height: height,
+            Type: parseInt(itemXML.querySelector("Type")?.textContent || "0", 10),
+            ItemName: itemXML.querySelector("Name")?.textContent || "",
+            ItemName_IT: itemXML.querySelector("Name_IT")?.textContent || "",
+            ItemName_EN: itemXML.querySelector("Name_EN")?.textContent || "",
+            ItemName_FR: itemXML.querySelector("Name_FR")?.textContent || "",
+            ItemName_PT: itemXML.querySelector("Name_PT")?.textContent || "",
+            ItemName_ES: itemXML.querySelector("Name_ES")?.textContent || "",
+            ItemName_DE: itemXML.querySelector("Name_DE")?.textContent || "",
+            Description: itemXML.querySelector("Description")?.textContent || "",
+            Description_IT: itemXML.querySelector("Description_IT")?.textContent || "",
+            Description_EN: itemXML.querySelector("Description_EN")?.textContent || "",
+            Description_FR: itemXML.querySelector("Description_FR")?.textContent || "",
+            Description_PT: itemXML.querySelector("Description_PT")?.textContent || "",
+            Description_ES: itemXML.querySelector("Description_ES")?.textContent || "",
+            Description_DE: itemXML.querySelector("Description_DE")?.textContent || "",
+            StatusValue: itemXML.querySelector("StatusValue")?.textContent || undefined,
+            RegisterPost: itemXML.querySelector("RegisterPost")?.textContent === "true",
+            AllowZeroTos: itemXML.querySelector("AllowZeroTos")?.textContent === "true",
+            Tos: itemXML.querySelector("Tos")?.textContent || undefined,
+            SetRule: mapWorkItemSetRules(xmlSetRule),
+            StartAfterArchive: parseInt(itemXML.querySelector("StartAfterArchive")?.textContent || "0", 10),
+            StartAfterUpdate: parseInt(itemXML.querySelector("StartAfterUpdate")?.textContent || "0", 10),
+            StartAfterUpdateMIDs: startAfterUpdateMIDsArray,
+            StartManual: parseInt(itemXML.querySelector("StartManual")?.textContent || "0", 10),
+            Hist: parseInt(itemXML.querySelector("Hist")?.textContent || "0", 10),
+            EndWFInstance: parseInt(itemXML.querySelector("EndWFInstance")?.textContent || "0", 10),
+            QD: parsedQD,
+            SOD: itemXML.querySelector("SOD")?.textContent || undefined,
+            MetadataValues: parsedMetadataValues,
+            Severity: mapSeverity(xmlSeverity),
+            RegAsWfInstPart: parseInt(itemXML.querySelector("RegAsWfInstPart")?.textContent || "0", 10),
+            FormatCultureID: mapCultureIDs(parseInt(itemXML.querySelector("FormatCultureID")?.textContent || "0", 10)),
+            Tos2: itemXML.querySelector("Tos2")?.textContent || undefined,
+            QD2: parsedQD2,
+            PlatformObjName: itemXML.querySelector("PlatformObjName")?.textContent || undefined,
+            PlatformObjDescr: itemXML.querySelector("PlatformObjDescr")?.textContent || undefined,
+            Value1asInt: parseInt(itemXML.querySelector("Value1asInt")?.textContent || "0", 10),
+            Value2asInt: parseInt(itemXML.querySelector("Value2asInt")?.textContent || "0", 10),
+            Value3asInt: parseInt(itemXML.querySelector("Value3asInt")?.textContent || "0", 10),
+            Value1asString: itemXML.querySelector("Value1asString")?.textContent || undefined,
+            AppType: mapWFAppTypes(xmlAppType),
+            AppName: itemXML.querySelector("AppName")?.textContent || undefined,
+            AppArgs: itemXML.querySelector("AppArgs")?.textContent || undefined,
+            Trunc: parseInt(itemXML.querySelector("Trunc")?.textContent || "0", 10),
+        };
+        wfDiagram.DiagramItems.push(item);
+    });
+    // Parsing Connections
+    const connectionsXML = rootElement.querySelectorAll("Connections > Connection");
+    connectionsXML.forEach((connectionXML) => {
+        const connectionId = connectionXML.querySelector("ID")?.textContent || crypto.randomUUID();
+        // Leggi il valore numerico di OutputStatus dall'XML
+        const xmlOutputStatus = parseInt(connectionXML.querySelector("OutputStatus")?.textContent || "0", 10);
+        const connection = {
+            ID: connectionId,
+            Source: {
+                ParentDiagramItem: { ID: connectionXML.querySelector("SourceID")?.textContent || "" },
+                // QUESTO assegna il valore di SourceConnectorName alla proprietà ConnectorName
+                ConnectorName: connectionXML.querySelector("SourceConnectorName")?.textContent || "",
+            },
+            Sink: {
+                ParentDiagramItem: { ID: connectionXML.querySelector("SinkID")?.textContent || "" },
+                // QUESTO assegna il valore di SinkConnectorName alla proprietà ConnectorName
+                ConnectorName: connectionXML.querySelector("SinkConnectorName")?.textContent || "",
+            },
+            // Usa la funzione di mappatura per assegnare il valore corretto dell'enum
+            OutputStatus: mapOutputStatus(xmlOutputStatus),
+            Description: connectionXML.querySelector("Description")?.textContent || "",
+            Description_IT: connectionXML.querySelector("Description_IT")?.textContent || "",
+            Description_EN: connectionXML.querySelector("Description_EN")?.textContent || "",
+            Description_FR: connectionXML.querySelector("Description_FR")?.textContent || "",
+            Description_PT: connectionXML.querySelector("Description_PT")?.textContent || "",
+            Description_ES: connectionXML.querySelector("Description_ES")?.textContent || "",
+            Description_DE: connectionXML.querySelector("Description_DE")?.textContent || "",
+            PathGeometry: "", // Sarà calcolato in WFCanvas.tsx
+            SourceArrowSymbol: connectionXML.querySelector("SourceArrowSymbol")?.textContent === "Arrow" ? ArrowSymbol.Arrow : ArrowSymbol.None,
+            SinkArrowSymbol: connectionXML.querySelector("SinkArrowSymbol")?.textContent === "Arrow" ? ArrowSymbol.Arrow : ArrowSymbol.None,
+        };
+        wfDiagram.Connections.push(connection);
+    });
+    return wfDiagram;
+};
+// Funzione di serializzazione (inclusa per completezza, se l'avevi)
+export const serializeWfDiagramToXml = async (wfDiagram) => {
+    if (!wfDiagram) {
+        return '<?xml version="1.0" encoding="utf-8"?>\n<Root></Root>';
+    }
+    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';
+    // Usa Promise.all con map invece di forEach
+    for (const item of wfDiagram.DiagramItems) {
+        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) {
+            let qdXmlContent = await serializeQueryDescriptorXml(item.QD);
+            let qdEscaped = escapeXml(qdXmlContent);
+            xml += `      <QD>${qdEscaped}</QD>\n`;
+        }
+        if (item.SOD)
+            xml += `      <SOD>${escapeXml(item.SOD)}</SOD>\n`;
+        // MetadataValues
+        if (item.Type === DiagramItemTypes.UpdateDcmt && item.MetadataValues && item.MetadataValues.length > 0) {
+            const mvXmlContent = serializeMetadataValuesToXml(item.MetadataValues);
+            let mvEscaped = escapeXml(mvXmlContent);
+            xml += `      <MetadataValues>${mvEscaped}</MetadataValues>\n`;
+        }
+        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) {
+            let qdXmlContent = await serializeQueryDescriptorXml(item.QD2);
+            let qdEscaped = escapeXml(qdXmlContent);
+            xml += `      <QD2>${qdEscaped}</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 += '  </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`;
+        if (conn.Description_IT)
+            xml += `      <Description_IT>${escapeXml(conn.Description_IT)}</Description_IT>\n`;
+        if (conn.Description_EN)
+            xml += `      <Description_EN>${escapeXml(conn.Description_EN)}</Description_EN>\n`;
+        if (conn.Description_FR)
+            xml += `      <Description_FR>${escapeXml(conn.Description_FR)}</Description_FR>\n`;
+        if (conn.Description_PT)
+            xml += `      <Description_PT>${escapeXml(conn.Description_PT)}</Description_PT>\n`;
+        if (conn.Description_ES)
+            xml += `      <Description_ES>${escapeXml(conn.Description_ES)}</Description_ES>\n`;
+        if (conn.Description_DE)
+            xml += `      <Description_DE>${escapeXml(conn.Description_DE)}</Description_DE>\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/lib/components/filesystem/ProgressBar.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface ITMProgressBar {
+    bgcolor?: any;
+    completed?: any;
+}
+declare const ProgressBar: React.FC<ITMProgressBar>;
+export default ProgressBar;

package/lib/components/filesystem/ProgressBar.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const ProgressBar = ({ bgcolor, completed }) => {
+    // const { bgcolor, completed } = props;
+    const containerStyles = {
+        height: 20,
+        width: '100%',
+        backgroundColor: "#e0e0de",
+        borderRadius: 50,
+        // margin: 50
+    };
+    // const fillerStyles = {
+    //   height: '100%',
+    //   width: `${completed}%`,
+    //   backgroundColor: bgcolor,
+    //   borderRadius: 'inherit',
+    //   textAlign: 'right'
+    // }
+    const labelStyles = {
+        padding: 5,
+        color: 'white',
+        fontWeight: 'bold'
+    };
+    return (_jsx("div", { style: containerStyles, children: _jsx("div", { style: { height: '100%', width: `${completed}%`, backgroundColor: bgcolor, borderRadius: 'inherit', textAlign: 'right' }, children: _jsx("span", { style: labelStyles, children: `${completed}%` }) }) }));
+};
+export default ProgressBar;

package/lib/components/forms/Login/ChangePassword.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { ITopMediaSession } from '@topconsultnpm/sdk-ts';
+interface ChangePasswordProps {
+    tmSession: ITopMediaSession;
+    hasBack?: boolean;
+    onClose?: () => void;
+}
+declare const ChangePassword: React.FC<ChangePasswordProps>;
+export default ChangePassword;

package/lib/components/forms/Login/ChangePassword.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import styled from 'styled-components';
+import ChangePasswordInputs from './ChangePasswordInputs';
+import { ChangePswDescriptor } from '@topconsultnpm/sdk-ts';
+import { IconArrowLeft, SDKUI_Localizator } from '../../../helper';
+import TMButton from '../../base/TMButton';
+const ChangePassword = ({ onClose, tmSession, hasBack = true }) => {
+    const [oldPassword, setOldPassword] = useState('');
+    const cpd = useMemo(() => {
+        let descriptor = new ChangePswDescriptor();
+        descriptor.archiveID = tmSession.SessionDescr?.archiveID;
+        descriptor.userName = tmSession.SessionDescr?.userName;
+        descriptor.cultureID = tmSession.SessionDescr?.cultureID;
+        descriptor.oldPassword = oldPassword;
+        return descriptor;
+    }, [tmSession, oldPassword]);
+    return (_jsxs(Container, { children: [_jsx(ChangePasswordInputs, { tmSession: tmSession, cpd: cpd, changePassword: true, oldPassword: oldPassword, onOldPasswordChanged: (value) => setOldPassword(value), onClose: onClose }), hasBack && _jsx(BackButtonWrapper, { children: _jsx(TMButton, { onClick: onClose, btnStyle: "icon", icon: _jsx(IconArrowLeft, { fontSize: 20 }), caption: SDKUI_Localizator.Back }) })] }));
+};
+export default ChangePassword;
+const Container = styled.div ` width: 100%; background-color: white; position: absolute; top: 0; left: 0; height: 100%; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 10px; padding: 10px 65px; `;
+const BackButtonWrapper = styled.div ` position: absolute; top: 20px; left: 20px; `;

package/lib/components/forms/Login/ChangePasswordInputs.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { ChangePswDescriptor, ITopMediaSession } from '@topconsultnpm/sdk-ts';
+interface ChangePasswordInputsProps {
+    oldPassword?: string;
+    changePassword?: boolean;
+    otp?: string;
+    tmSession: ITopMediaSession;
+    cpd: ChangePswDescriptor;
+    onOldPasswordChanged?: (value: string) => void;
+    onClose?: () => void;
+}
+declare const ChangePasswordInputs: React.FC<ChangePasswordInputsProps>;
+export default ChangePasswordInputs;
+export declare const Divider: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/lib/components/forms/Login/ChangePasswordInputs.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import PasswordStrengthChecker from './PasswordStrengthChecker';
+import styled from 'styled-components';
+import TextBox from './TextBox';
+import { ChangePasswordValidator } from './LoginValidatorService';
+import { SDKUI_Localizator, IconPassword } from '../../../helper';
+import TMButton from '../../base/TMButton';
+import { TMMessageBoxManager, ButtonNames, TMExceptionBoxManager } from '../../base/TMPopUp';
+import TMSpinner from '../../base/TMSpinner';
+const ChangePasswordInputs = ({ changePassword = false, oldPassword, onOldPasswordChanged, otp, tmSession, onClose, cpd }) => {
+    const oldPasswordRef = useRef(null);
+    const newPasswordRef = useRef(null);
+    const confirmPasswordRef = useRef(null);
+    const [newPassword, setNewPassword] = useState('');
+    const [confirmPassword, setConfirmPassword] = useState('');
+    const [isValid, setIsValid] = useState(false);
+    const changePasswordData = useMemo(() => {
+        return {
+            confirmPassword: confirmPassword,
+            newPassword: newPassword,
+            oldPassword: oldPassword ?? '',
+            username: tmSession.SessionDescr?.userName ?? '',
+            changePassword: changePassword,
+            isValid: isValid
+        };
+    }, [tmSession.SessionDescr?.userName, oldPassword, newPassword, confirmPassword, isValid]);
+    const validators = ChangePasswordValidator.validate(changePasswordData);
+    const saveBtnDisable = useMemo(() => {
+        return !isValid || validators.totalValidationItems.length > 0;
+    }, [validators, isValid]);
+    const fieldValidations = useCallback((key) => {
+        return validators.fieldValidations.get(key) ?? [];
+    }, [validators]);
+    useEffect(() => {
+        let inputs = [oldPasswordRef, newPasswordRef, confirmPasswordRef];
+        const firstEmpty = inputs.find(input => input.current && input.current.value === '');
+        if (firstEmpty?.current) {
+            firstEmpty.current.focus();
+        }
+    }, []);
+    const onSavePasswordAsync = async () => {
+        cpd.otp = changePassword ? undefined : Number(otp);
+        cpd.onlyCheckOTP = changePassword ? undefined : 0;
+        cpd.newPassword = newPassword;
+        try {
+            TMSpinner.show();
+            await tmSession.NewUserEngine().ChangePasswordAsync(cpd);
+            TMMessageBoxManager.show({ buttons: [ButtonNames.OK], onButtonClick: (e) => { if (e === ButtonNames.OK) {
+                    onClose?.();
+                    return;
+                } ; }, message: SDKUI_Localizator.PasswordChangedSuccessfully });
+        }
+        catch (e) {
+            TMExceptionBoxManager.show({ exception: e });
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    };
+    useEffect(() => {
+        const handleKeyDown = (e) => {
+            if (e.key === 'Enter') {
+                if (!saveBtnDisable) {
+                    onSavePasswordAsync();
+                }
+            }
+        };
+        window.addEventListener('keydown', handleKeyDown);
+        return () => {
+            window.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [saveBtnDisable, onSavePasswordAsync]);
+    return (_jsxs(StepContentContainer, { children: [_jsx(Title, { children: SDKUI_Localizator.ChangePassword + ` (${tmSession.SessionDescr?.userName})` }), _jsx(Divider, {}), changePassword && _jsx(TextBox, { ref: oldPasswordRef, showSuccess: true, type: 'password', value: oldPassword, onValueChanged: onOldPasswordChanged, label: SDKUI_Localizator.OldPassword, icon: _jsx(IconPassword, {}), validationItems: changePassword ? fieldValidations('oldPassword') : [] }), _jsx(TextBox, { ref: newPasswordRef, type: 'password', value: newPassword, showSuccess: isValid, onValueChanged: (e) => setNewPassword(e), label: SDKUI_Localizator.NewPassword, icon: _jsx(IconPassword, {}), validationItems: fieldValidations('newPassword'), disabled: oldPassword ? oldPassword.length === 0 : false }), _jsx(TextBox, { ref: confirmPasswordRef, type: 'password', value: confirmPassword, showSuccess: true, onValueChanged: (e) => setConfirmPassword(e), label: SDKUI_Localizator.ConfirmPassword, icon: _jsx(IconPassword, {}), validationItems: fieldValidations('confirmPassword') }), _jsx(TMButton, { fontSize: "1.2rem", caption: SDKUI_Localizator.Save, showTooltip: false, onClick: async () => await onSavePasswordAsync(), disabled: saveBtnDisable }), _jsx(StrengthWrapper, { children: _jsx(PasswordStrengthChecker, { password: newPassword, onValidationChange: (isValid) => { setIsValid(isValid); } }) })] }));
+};
+export default ChangePasswordInputs;
+const StepContentContainer = styled.div ` width: 100%; display: flex; gap: 10px; flex-direction: column; align-items: center; `;
+const Title = styled.h2 ` font-size: 16px; text-align: left; width: 100%; color: #333; `;
+export const Divider = styled.div ` width: 100%; height: 1px; background-color: lightgray; `;
+const StrengthWrapper = styled.div ` width: 100%; margin-top: 10px; display: flex; align-items: center; justify-content: center; `;