@topconsultnpm/sdkui-react-beta 6.16.3 → 6.16.5

package/lib/components/editors/TMLocalizedTextBox.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { CultureIDs } from '@topconsultnpm/sdk-ts-beta';
+interface TMLocalizedTextBoxProps {
+    label: string;
+    value?: string;
+    value_IT?: string;
+    value_EN?: string;
+    value_FR?: string;
+    value_PT?: string;
+    value_ES?: string;
+    value_DE?: string;
+    onValueChanged: (lang: CultureIDs, value: string) => void;
+}
+declare const TMLocalizedTextBox: React.FC<TMLocalizedTextBoxProps>;
+export default TMLocalizedTextBox;

package/lib/components/editors/TMLocalizedTextBox.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// TMLocalizedTextBox.tsx
+import { useEffect, useRef, useState } from 'react';
+import styled from 'styled-components';
+import TMTextBox from './TMTextBox';
+import { IconLanguage, SDKUI_Localizator } from '../../helper';
+import { CultureIDs } from '@topconsultnpm/sdk-ts-beta';
+import it from '../../assets/italy.svg';
+import en from '../../assets/united-kingdom.svg';
+import es from '../../assets/spain.svg';
+import fr from '../../assets/france.svg';
+import de from '../../assets/german.svg';
+import pt from '../../assets/portugal.svg';
+const LocalizedContainer = styled.div `
+  position: relative;
+  width: 100%;
+`;
+const Popover = styled.div `
+  display: ${props => props.$isVisible ? 'flex' : 'none'};
+  flex-direction: column;
+  position: absolute;
+  top: 100%; /* Position below the TMTextBox */
+  left: 0;
+  width: 100%;
+  border: 1px solid #ccc;
+  border-radius: 4px;
+  background-color: #fff;
+  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+  z-index: 1000;
+  padding: 8px;
+`;
+const Badge = styled.span `
+  position: absolute;
+  top: -8px; 
+  right: -8px;
+  background-color: #ff9800;
+  color: white;
+  border-radius: 50%;
+  padding: 2px 6px;
+  font-size: 10px;
+  font-weight: bold;
+  pointer-events: none;
+`;
+const IconContainer = styled.div `
+  position: relative;
+  display: flex;
+  align-items: center;
+`;
+// Helper function to get image path
+const getCultureIDImg = (cultureID) => {
+    switch (cultureID) {
+        case CultureIDs.En_US: return en;
+        case CultureIDs.De_DE: return de;
+        case CultureIDs.Es_ES: return es;
+        case CultureIDs.Fr_FR: return fr;
+        case CultureIDs.Pt_PT: return pt;
+        default: return it;
+    }
+};
+const TMLocalizedTextBox = ({ label, value, value_IT, value_EN, value_FR, value_PT, value_ES, value_DE, onValueChanged, }) => {
+    // const [isModalOpen, setIsModalOpen] = useState(false);
+    const [isPopoverVisible, setIsPopoverVisible] = useState(false);
+    const popoverRef = useRef(null);
+    const languages = [
+        { code: CultureIDs.It_IT, label: 'Italiano', value: value_IT },
+        { code: CultureIDs.En_US, label: 'English', value: value_EN },
+        { code: CultureIDs.Fr_FR, label: 'Français', value: value_FR },
+        { code: CultureIDs.Pt_PT, label: 'Português', value: value_PT },
+        { code: CultureIDs.Es_ES, label: 'Español', value: value_ES },
+        { code: CultureIDs.De_DE, label: 'Deutsch', value: value_DE },
+    ];
+    // Calcola il numero di lingue con valori non nulli o vuoti
+    const localizedCount = languages.filter(lang => lang.value && lang.value.trim() !== '').length;
+    const handleTogglePopover = () => setIsPopoverVisible(prev => !prev);
+    const handleClosePopover = () => setIsPopoverVisible(false);
+    // Close popover when clicking outside
+    useEffect(() => {
+        const handleClickOutside = (event) => {
+            if (popoverRef.current && !popoverRef.current.contains(event.target)) {
+                handleClosePopover();
+            }
+        };
+        document.addEventListener("mousedown", handleClickOutside);
+        return () => {
+            document.removeEventListener("mousedown", handleClickOutside);
+        };
+    }, []);
+    const localizationButton = {
+        text: SDKUI_Localizator.Localization,
+        icon: (_jsxs(IconContainer, { children: [_jsx(IconLanguage, {}), localizedCount > 0 && _jsx(Badge, { children: localizedCount })] })),
+        onClick: handleTogglePopover,
+    };
+    return (_jsxs(LocalizedContainer, { ref: popoverRef, children: [_jsx(TMTextBox, { type: "text", label: label, value: value, buttons: [localizationButton], onValueChanged: (e) => onValueChanged(CultureIDs.None, e.target.value) }), _jsx(Popover, { "$isVisible": isPopoverVisible, children: languages.map((lang) => (_jsx(TMTextBox, { label: `${lang.label}`, showClearButton: true, icon: _jsx("img", { src: getCultureIDImg(lang.code), alt: "Lang", width: 18, height: 18 }), value: lang.value || '', onValueChanged: (e) => onValueChanged(lang.code, e.target.value) }, lang.code))) })] }));
+};
+export default TMLocalizedTextBox;

package/lib/components/features/archive/TMArchive.d.ts

@@ -6,6 +6,7 @@ interface ITMArchiveProps {
         value: string;
     }>;
     inputTID?: number;
+    onDcmtTypeSelect?: (tid: number | undefined) => void;
     connectorFileSave?: () => Promise<File>;
     onSavedAsyncCallback?: (tid: number | undefined, did: number | undefined) => Promise<void>;
 }

package/lib/components/features/archive/TMArchive.js

@@ -12,7 +12,7 @@ import TMTreeSelector from '../search/TMTreeSelector';
 import TMPanel from '../../base/TMPanel';
 import { TMPanelManagerProvider, useTMPanelManagerContext } from '../../layout/panelManager/TMPanelManagerContext';
 import TMPanelManagerContainer from '../../layout/panelManager/TMPanelManagerContainer';
-const TMArchive = ({ inputTID, inputFile = null, connectorFileSave = undefined, onSavedAsyncCallback, inputMids = [] }) => {
+const TMArchive = ({ onDcmtTypeSelect = undefined, inputTID, inputFile = null, connectorFileSave = undefined, onSavedAsyncCallback, inputMids = [] }) => {
     const [currentTID, setCurrentTID] = useState(inputTID ?? 0);
     const [mruTIDs, setMruTIDs] = useState([]);
     const [currentMruTID, setCurrentMruTID] = useState(0);
@@ -28,10 +28,12 @@ const TMArchive = ({ inputTID, inputFile = null, connectorFileSave = undefined,
         if (!currentTID || currentTID <= 0) {
             return;
         }
+        if (onDcmtTypeSelect && currentTID !== inputTID)
+            onDcmtTypeSelect(currentTID);
         DcmtTypeListCacheService.GetAsync(currentTID).then(async (dtd) => {
             setFromDTD(dtd);
         });
-    }, [currentTID]);
+    }, [currentTID, onDcmtTypeSelect, inputTID]);
     const isMobile = deviceType === DeviceType.MOBILE;
     const tmTreeSelectorElement = useMemo(() => _jsx(TMTreeSelectorWrapper, { isMobile: isMobile, onSelectedTIDChanged: (tid) => {
             setCurrentTID(tid);

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

@@ -233,7 +233,6 @@ const DiagramItemComponent = ({ item, isSelected, isCurrent, readOnly, onClick,
                 textLines = wrapText(item.ItemName, MAX_ITEM_WIDTH - (PADDING_HORIZONTAL * 2), MAX_LINES, context);
                 // Check if the last line contains an ellipsis to determine truncation
                 isTruncated = textLines[textLines.length - 1].endsWith('...');
-                console.log('isTruncated ', isTruncated);
             }
         }
         return (_jsxs(_Fragment, { children: [isTruncated && _jsx("title", { children: item.ItemName }), _jsx("rect", { x: "0", y: "0", width: calculatedWidth, height: calculatedHeight, className: "item-main-shape" }), _jsx("g", { transform: `translate(${svgX}, ${svgY})`, children: _jsx(DiagramItemSvgContent, { itemType: item.Type, width: iconRenderWidth, height: iconRenderHeight }) }), textLines.length > 0 && (_jsx("text", { ref: textRef, x: calculatedWidth / 2, dominantBaseline: "central", className: "item-text", children: textLines.map((line, index) => (_jsx("tspan", { x: calculatedWidth / 2, dy: index === 0 ? PADDING_TOP + SVG_ICON_SIZE + SPACING_SVG_TEXT : FONT_SIZE + 1, children: line }, index))) })), connectors] }));

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

@@ -1,7 +1,8 @@
 import React from 'react';
-import { DiagramItem } from './interfaces';
+import { DiagramItem, WfInfo } from './interfaces';
 interface DiagramItemFormProps {
     itemToEdit: DiagramItem;
+    wf: WfInfo | null | undefined;
     onClose: () => void;
     onApply: (updatedItem: DiagramItem) => void;
 }

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

@@ -1,25 +1,188 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react'; // Importa useState
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useMemo, useState } from 'react'; // Importa useState
 import TMModal from '../../../base/TMModal';
 import { DiagramItemTypes } from './interfaces';
-const DiagramItemForm = ({ itemToEdit, onClose, onApply }) => {
-    // Usa uno stato locale per le modifiche
+import TMCheckBox from '../../../editors/TMCheckBox';
+import { SDKUI_Localizator } from '../../../../helper';
+import TMMetadataChooser from '../../../choosers/TMMetadataChooser';
+import TMButton from '../../../base/TMButton';
+import styled from 'styled-components';
+import TMQuerySummary from '../../../query/TMQuerySummary';
+import { CultureIDs } from '@topconsultnpm/sdk-ts-beta';
+import TMLocalizedTextBox from '../../../editors/TMLocalizedTextBox';
+const FormContainer = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+  padding: 10px;
+`;
+const ButtonsContainer = styled.div `
+  display: flex;
+  justify-content: center;
+  gap: 10px; 
+  margin-top: auto; 
+  padding-top: 20px;
+`;
+const DiagramItemForm = ({ itemToEdit, wf, onClose, onApply }) => {
     const [localItem, setLocalItem] = useState(itemToEdit);
+    const [localItemOrig] = useState(structuredClone(itemToEdit));
     if (!localItem) {
         return null;
     }
-    // Gestore per l'input
-    const handleNameChange = (event) => {
-        setLocalItem({
-            ...localItem,
-            ItemName: event.target.value
-        });
-    };
+    // Calcola dinamicamente larghezza e altezza del modal con useMemo
+    const { calculatedWidth, calculatedHeight } = useMemo(() => {
+        let width = '50%';
+        let height = '50%';
+        switch (localItem.Type) {
+            case DiagramItemTypes.Start:
+                width = '30%';
+                height = '40%';
+                break;
+            case DiagramItemTypes.End:
+            case DiagramItemTypes.Exit:
+                width = '30%';
+                height = '40%';
+                break;
+            case DiagramItemTypes.Condition:
+                width = '40%';
+                height = '60%';
+                break;
+            default:
+                width = '50%';
+                height = '50%';
+                break;
+        }
+        return { calculatedWidth: width, calculatedHeight: height };
+    }, [localItem.Type]);
+    const handleNameChange = useCallback((event) => {
+        const newValue = event.target.value;
+        setLocalItem(prevLocalItem => ({
+            ...prevLocalItem,
+            ItemName: newValue
+        }));
+    }, []);
+    const handleStartAfterArchiveChange = useCallback((newValue) => {
+        setLocalItem(prevLocalItem => ({
+            ...prevLocalItem,
+            StartAfterArchive: newValue
+        }));
+    }, []);
+    const handleStartAfterUpdateChange = useCallback((newValue) => {
+        setLocalItem(prevLocalItem => ({
+            ...prevLocalItem,
+            StartAfterUpdate: newValue
+        }));
+    }, []);
+    const handleStartAfterUpdateMIDsChange = useCallback((selectedMetadata) => {
+        const mids = selectedMetadata.map((item) => item.mid).filter((mid) => mid !== undefined);
+        setLocalItem(prevLocalItem => ({
+            ...prevLocalItem,
+            StartAfterUpdateMIDs: mids
+        }));
+    }, []);
+    const handleHistChange = useCallback((newValue) => {
+        setLocalItem(prevLocalItem => ({
+            ...prevLocalItem,
+            Hist: newValue
+        }));
+    }, []);
+    const handleEndWFInstanceChange = useCallback((newValue) => {
+        setLocalItem(prevLocalItem => ({
+            ...prevLocalItem,
+            EndWFInstance: newValue
+        }));
+    }, []);
+    const handleQDChange = useCallback((newValue) => {
+        setLocalItem(prevLocalItem => ({
+            ...prevLocalItem,
+            QD: newValue
+        }));
+    }, []);
     // Gestore per il salvataggio
     const handleSave = () => {
         onApply(localItem);
         onClose();
     };
-    return (_jsxs(TMModal, { title: DiagramItemTypes[localItem.Type].toString(), onClose: onClose, isModal: true, width: '50%', height: '50%', children: [_jsx("div", { children: _jsx("input", { type: "text", value: localItem.ItemName, onChange: handleNameChange }) }), _jsx("button", { onClick: handleSave, children: "Applica" })] }));
+    const handleLocalizedNameChange = useCallback((lang, newValue) => {
+        setLocalItem(prevLocalItem => {
+            const updatedItem = { ...prevLocalItem };
+            // Aggiungi la logica per aggiornare il campo corretto
+            switch (lang) {
+                case CultureIDs.It_IT:
+                    updatedItem.ItemName_IT = newValue;
+                    break;
+                case CultureIDs.En_US:
+                    updatedItem.ItemName_EN = newValue;
+                    break;
+                case CultureIDs.Fr_FR:
+                    updatedItem.ItemName_FR = newValue;
+                    break;
+                case CultureIDs.Pt_PT:
+                    updatedItem.ItemName_PT = newValue;
+                    break;
+                case CultureIDs.Es_ES:
+                    updatedItem.ItemName_ES = newValue;
+                    break;
+                case CultureIDs.De_DE:
+                    updatedItem.ItemName_DE = newValue;
+                    break;
+                default:
+                    updatedItem.ItemName = newValue;
+                    break;
+            }
+            return updatedItem;
+        });
+    }, []);
+    // Function to render common elements like the name textbox
+    const renderCommonFields = () => {
+        if (localItem.Type !== DiagramItemTypes.Start && localItem.Type !== DiagramItemTypes.End && localItem.Type !== DiagramItemTypes.Exit) {
+            return (_jsx(TMLocalizedTextBox, { label: SDKUI_Localizator.Name, value: localItem.ItemName, value_IT: localItem.ItemName_IT, value_EN: localItem.ItemName_EN, value_FR: localItem.ItemName_FR, value_PT: localItem.ItemName_PT, value_ES: localItem.ItemName_ES, value_DE: localItem.ItemName_DE, onValueChanged: handleLocalizedNameChange })
+            // <TMTextBox
+            //     type="text"
+            //     label={SDKUI_Localizator.Name}
+            //     value={localItem.ItemName}
+            //     isModifiedWhen={localItem.ItemName !== localItemOrig.ItemName}
+            //     onValueChanged={handleNameChange}
+            // />
+            );
+        }
+        return null;
+    };
+    // Function to render Start-specific fields
+    const renderStartFields = () => {
+        return (_jsxs(_Fragment, { children: [_jsx(TMCheckBox, { value: localItem.StartAfterArchive ?? 0, label: SDKUI_Localizator.WorkflowStartAfterArchive, isModifiedWhen: localItem.StartAfterArchive !== localItemOrig.StartAfterArchive, onValueChanged: handleStartAfterArchiveChange }), _jsx(TMCheckBox, { value: localItem.StartAfterUpdate ?? 0, label: SDKUI_Localizator.WorkflowStartAfterUpdate, isModifiedWhen: localItem.StartAfterUpdate !== localItemOrig.StartAfterUpdate, onValueChanged: handleStartAfterUpdateChange }), _jsx(TMMetadataChooser, { tids: wf?.MTID ? [wf.MTID] : [], allowMultipleSelection: true, allowSysMetadata: false, showClearButton: true, disabled: localItem.StartAfterUpdate !== 1, values: localItem.StartAfterUpdateMIDs?.map((mid) => ({ tid: wf?.MTID, mid: mid })) ?? [], onValueChanged: handleStartAfterUpdateMIDsChange, width: "100%" })] }));
+    };
+    // Function to render End-specific fields
+    const renderEndFields = () => {
+        return (_jsx(TMCheckBox, { value: localItem.Hist ?? 0, label: SDKUI_Localizator.WorkflowHistWI, isModifiedWhen: localItem.Hist !== localItemOrig.Hist, onValueChanged: handleHistChange }));
+    };
+    // Function to render Exit-specific fields
+    const renderExitFields = () => {
+        return (_jsx(TMCheckBox, { value: localItem.EndWFInstance ?? 0, label: SDKUI_Localizator.WorkflowEndInstance, isModifiedWhen: localItem.EndWFInstance !== localItemOrig.EndWFInstance, onValueChanged: handleEndWFInstanceChange }));
+    };
+    const renderConditionFields = () => {
+        return (_jsx(TMQuerySummary, { qd: localItem.QD, onValueChanged: handleQDChange }));
+    };
+    const renderForm = () => {
+        let specificFields;
+        switch (localItem.Type) {
+            case DiagramItemTypes.Start:
+                specificFields = renderStartFields();
+                break;
+            case DiagramItemTypes.End:
+                specificFields = renderEndFields();
+                break;
+            case DiagramItemTypes.Exit:
+                specificFields = renderExitFields();
+                break;
+            case DiagramItemTypes.Condition:
+                specificFields = renderConditionFields();
+                break;
+            default:
+                specificFields = null;
+        }
+        return (_jsxs(FormContainer, { children: [renderCommonFields(), specificFields, _jsx(ButtonsContainer, { children: _jsx(TMButton, { caption: 'Applica', color: 'success', showTooltip: false, onClick: handleSave }) })] }));
+    };
+    return (_jsx(TMModal, { title: DiagramItemTypes[localItem.Type].toString(), onClose: onClose, isModal: true, width: calculatedWidth, height: calculatedHeight, children: renderForm() }));
 };
 export default DiagramItemForm;

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

@@ -1297,7 +1297,6 @@ const WFDiagram = ({ xmlDiagramString, currentSetID, readOnly = false, zoomLevel
         setDraggedItemType(null);
     };
     const handleItemDimensionsChange = useCallback((itemId, width, height) => {
-        console.log('itemId', itemId, 'width', width, 'height', height);
         setWfDiagram(prevDiagram => {
             if (!prevDiagram)
                 return null;
@@ -1391,6 +1390,6 @@ const WFDiagram = ({ xmlDiagramString, currentSetID, readOnly = false, zoomLevel
                                 // Determina se questa è la connessione che stiamo trascinando
                                 const isThisConnectionBeingDragged = isDraggingExistingConnectionEndpoint && draggingConnectionId === connection.ID;
                                 return (_jsx(ConnectionComponent, { connection: connection, isSelected: selectedConnections.has(connection.ID), sourcePoint: sourcePoint, sinkPoint: sinkPoint, isTemporary: isThisConnectionBeingDragged, onClick: handleConnectionClick, onConnectionEndpointMouseDown: handleConnectionEndpointMouseDown }, connection.ID));
-                            }), isDrawingConnection && tempConnectionPathData && (_jsx(TempConnectionPath, { d: tempConnectionPathData })), isDraggingExistingConnectionEndpoint && tempConnectionPathData && (_jsx(TempConnectionPath, { d: tempConnectionPathData })), isDrawingSelectionRect && currentSelectionRect && (_jsx(SelectionRect, { x: currentSelectionRect.x, y: currentSelectionRect.y, width: currentSelectionRect.width, height: currentSelectionRect.height }))] }) })) : (_jsx(DiagramMessage, { children: `${SDKUI_Localizator.WorkflowDiagramMissingOrInvalid} ...` })) }), isModalOpen && itemToEdit && (_jsx(DiagramItemForm, { itemToEdit: itemToEdit, onClose: handleCloseModal, onApply: handleUpdateDiagramItem }))] }));
+                            }), isDrawingConnection && tempConnectionPathData && (_jsx(TempConnectionPath, { d: tempConnectionPathData })), isDraggingExistingConnectionEndpoint && tempConnectionPathData && (_jsx(TempConnectionPath, { d: tempConnectionPathData })), isDrawingSelectionRect && currentSelectionRect && (_jsx(SelectionRect, { x: currentSelectionRect.x, y: currentSelectionRect.y, width: currentSelectionRect.width, height: currentSelectionRect.height }))] }) })) : (_jsx(DiagramMessage, { children: `${SDKUI_Localizator.WorkflowDiagramMissingOrInvalid} ...` })) }), isModalOpen && itemToEdit && (_jsx(DiagramItemForm, { itemToEdit: itemToEdit, wf: wfDiagram?.Info, onClose: handleCloseModal, onApply: handleUpdateDiagramItem }))] }));
 };
 export default WFDiagram;

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

@@ -38,7 +38,19 @@ export interface DiagramItem {
     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;
@@ -46,7 +58,7 @@ export interface DiagramItem {
     SetRule?: number;
     StartAfterArchive?: number;
     StartAfterUpdate?: number;
-    StartAfterUpdateMIDs?: string;
+    StartAfterUpdateMIDs?: number[];
     StartManual?: number;
     Hist?: number;
     EndWFInstance?: number;

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

@@ -39,9 +39,9 @@ const getString = (element, selector) => {
 const parseSelectItem = (itemXML) => {
     const selectItem = new SelectItem();
     selectItem.function = getString(itemXML, "Function");
-    selectItem.tid = getNumber(itemXML, "Tid");
+    selectItem.tid = getNumber(itemXML, "TID");
     selectItem.alias = getString(itemXML, "Alias");
-    selectItem.mid = getNumber(itemXML, "Mid");
+    selectItem.mid = getNumber(itemXML, "MID");
     selectItem.as = getString(itemXML, "As");
     selectItem.visibility = getString(itemXML, "Visibility");
     return selectItem;
@@ -51,7 +51,7 @@ const parseSelectItem = (itemXML) => {
  */
 const parseFromItem = (itemXML) => {
     const fromItem = new FromItem();
-    fromItem.tid = getNumber(itemXML, "tid");
+    fromItem.tid = getNumber(itemXML, "TID");
     return fromItem;
 };
 /**
@@ -59,16 +59,16 @@ const parseFromItem = (itemXML) => {
  */
 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");
+    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;
 };
 /**
@@ -76,9 +76,9 @@ const parseOnJoinItem = (itemXML) => {
  */
 const parseJoinItem = (itemXML) => {
     const joinItem = new JoinItem();
-    joinItem.joinType = getString(itemXML, "joinType");
-    joinItem.tid = getNumber(itemXML, "tid");
-    joinItem.alias = getString(itemXML, "alias");
+    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));
@@ -91,15 +91,15 @@ const parseJoinItem = (itemXML) => {
  */
 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");
+    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;
 };
 /**
@@ -107,10 +107,10 @@ const parseWhereItem = (itemXML) => {
  */
 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");
+    orderByItem.tid = getNumber(itemXML, "TID");
+    orderByItem.alias = getString(itemXML, "Alias");
+    orderByItem.mid = getNumber(itemXML, "MID");
+    orderByItem.asc = getBoolean(itemXML, "Asc");
     return orderByItem;
 };
 /**
@@ -120,16 +120,17 @@ const parseOrderByItem = (itemXML) => {
 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");
+    const valueElement = itemXML.querySelector("Value");
     paramDescriptor.value = valueElement ? valueElement.textContent : undefined;
-    paramDescriptor.mappedTID = getNumber(itemXML, "mappedTID");
-    paramDescriptor.mappedMID = getNumber(itemXML, "mappedMID");
+    paramDescriptor.mappedTID = getNumber(itemXML, "MappedTID");
+    paramDescriptor.mappedMID = getNumber(itemXML, "MappedMID");
     return paramDescriptor;
 };
 export const parseQueryDescriptorXml = (xmlString) => {
     if (!xmlString || xmlString.trim() === '') {
         return undefined;
     }
+    console.log('QD xmlString', xmlString);
     const parser = new DOMParser();
     const xmlDoc = parser.parseFromString(xmlString, "application/xml");
     let queryDescriptorElement = xmlDoc.querySelector("QueryDescriptor");
@@ -142,11 +143,7 @@ export const parseQueryDescriptorXml = (xmlString) => {
         return undefined;
     }
     const queryDescriptor = new QueryDescriptor();
-    queryDescriptor.maxDcmtsToBeReturned = getNumber(queryDescriptorElement, "maxDcmtsToBeReturned");
-    queryDescriptor.isDistinct = getBoolean(queryDescriptorElement, "isDistinct");
-    queryDescriptor.offset = getNumber(queryDescriptorElement, "offset");
-    queryDescriptor.fetch = getNumber(queryDescriptorElement, "fetch");
-    queryDescriptor.isLexProt = getNumber(queryDescriptorElement, "isLexProt");
+    queryDescriptor.maxDcmtsToBeReturned = getNumber(queryDescriptorElement, "MaxDcmtsToBeReturned");
     const selectItems = [];
     queryDescriptorElement.querySelectorAll("Select > SelectItem").forEach(itemXML => {
         selectItems.push(parseSelectItem(itemXML));
@@ -176,5 +173,6 @@ export const parseQueryDescriptorXml = (xmlString) => {
         paramsItems.push(parseQueryParameterDescriptor(itemXML));
     });
     queryDescriptor.params = paramsItems.length > 0 ? paramsItems : undefined;
+    console.log('queryDescriptor', queryDescriptor);
     return queryDescriptor;
 };

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

@@ -75,7 +75,19 @@ export const parseWfDiagramXml = (xmlString) => {
             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",
@@ -83,7 +95,7 @@ export const parseWfDiagramXml = (xmlString) => {
             SetRule: parseInt(itemXML.querySelector("SetRule")?.textContent || "0", 10),
             StartAfterArchive: parseInt(itemXML.querySelector("StartAfterArchive")?.textContent || "0", 10),
             StartAfterUpdate: parseInt(itemXML.querySelector("StartAfterUpdate")?.textContent || "0", 10),
-            StartAfterUpdateMIDs: itemXML.querySelector("StartAfterUpdateMIDs")?.textContent || undefined,
+            StartAfterUpdateMIDs: itemXML.querySelector("StartAfterUpdateMIDs")?.textContent?.split(';').map(Number) || undefined,
             StartManual: parseInt(itemXML.querySelector("StartManual")?.textContent || "0", 10),
             Hist: parseInt(itemXML.querySelector("Hist")?.textContent || "0", 10),
             EndWFInstance: parseInt(itemXML.querySelector("EndWFInstance")?.textContent || "0", 10),

package/lib/components/forms/TMChooserForm.js

@@ -86,8 +86,8 @@ const TMChooserForm = ({ children, title, allowMultipleSelection = false, allowA
             ...summaryItems ?? {}
         });
     }, [manageUseLocalizedName, summaryItems]);
-    return (_jsx(TMModal, { title: renderTitle(), width: width ?? '550px', height: height ?? '600px', toolbar: _jsx(ToolbarButtons, {}), onClose: onClose, children: (children ??
-            filteredItems.length > 0)
+    return (_jsx(TMModal, { title: renderTitle(), width: width ?? '550px', height: height ?? '600px', toolbar: _jsx(ToolbarButtons, {}), onClose: onClose, children: children ??
+            filteredItems.length > 0
             ? _jsx(TMDataGrid, { dataSource: filteredItems, keyExpr: keyName, dataColumns: dataColumns, focusedRowKey: focusedRowKey, selectedRowKeys: selectedRowKeys, searchPanelFocusStarting: true, headerFilter: { visible: true }, selection: { mode: allowMultipleSelection ? 'multiple' : 'single', showCheckBoxesMode: 'always', selectAllMode: 'allPages' }, grouping: allowGrouping ? { autoExpandAll: false, expandMode: 'rowClick' } : undefined, summary: customSummary, onFocusedRowChanged: handleFocusedRowChange, onSelectionChanged: handleSelectionChanged, onRowDblClick: handleRowDoubleClick })
             : _jsx(TMLayoutContainer, { gap: 30, alignItems: 'center', justifyContent: 'center', children: _jsx(TMLayoutItem, { children: _jsx("p", { style: { height: "100%", color: TMColors.primaryColor, fontSize: "1.5rem", display: 'flex', alignItems: 'center', justifyContent: 'center' }, children: SDKUI_Localizator.NoDataToDisplay }) }) }) }));
 };

package/lib/components/query/TMQuerySummary.js

@@ -8,6 +8,7 @@ import TMButton from '../base/TMButton';
 import { getQueryCountAsync, IconCount, IconEraser, IconPencil, SDKUI_Localizator } from '../../helper';
 import TMVilViewer from '../base/TMVilViewer';
 import { FormModes } from '../../ts';
+import TMModal from '../base/TMModal';
 // #region Style
 const StyledWrapper = styled.div `
     display: flex;
@@ -26,7 +27,9 @@ const StyledQueryToolbar = styled.div `
 const TMQuerySummary = ({ children, qd, validateSelect = true, validateOrderBy = true, raiseWarningForOnlyMetadataDcmtTypes = false, validationItems = [], onValueChanged, onEditClick, onClose }) => {
     const [showEditor, setShowEditor] = useState(false);
     const validationItemsQd = validationItems.filter(o => o.PropertyScopes.includes(TMScopeNames.qd) || o.PropertyName == TMScopeNames.qd);
-    return (_jsxs(StyledWrapper, { children: [_jsxs(StyledQueryToolbar, { children: [_jsx(TMButton, { caption: SDKUI_Localizator.QueryDefine, icon: _jsx(IconPencil, { fontSize: 16 }), btnStyle: 'toolbar', onClick: () => onEditClick ? onEditClick() : setShowEditor(!showEditor) }), _jsx(TMButton, { caption: SDKUI_Localizator.QueryCount, icon: _jsx(IconCount, { fontSize: 16 }), disabled: validationItemsQd.filter(o => o.ResultType == ResultTypes.ERROR).length > 0, btnStyle: 'toolbar', onClick: () => getQueryCountAsync(qd, true) }), _jsx(TMButton, { caption: SDKUI_Localizator.QueryClear, icon: _jsx(IconEraser, { fontSize: 16 }), btnStyle: 'toolbar', onClick: () => onValueChanged?.(new QueryDescriptor()) }), children] }), _jsxs("div", { style: { display: 'flex', flexDirection: 'column', width: '100%', overflowX: 'auto' }, children: [qd && qd.from &&
-                        _jsx(TMQueryEditor, { formMode: FormModes.ReadOnly, inputData: qd, isModal: false, showToolbar: false, validateSelect: validateSelect, validateOrderBy: validateOrderBy, raiseWarningForOnlyMetadataDcmtTypes: raiseWarningForOnlyMetadataDcmtTypes }), _jsx("div", { style: { padding: '0px 5px' }, children: _jsx(TMVilViewer, { vil: validationItemsQd }) })] })] }));
+    const useInternalEditor = onEditClick === undefined;
+    return (_jsxs(StyledWrapper, { children: [_jsxs(StyledQueryToolbar, { children: [_jsx(TMButton, { caption: SDKUI_Localizator.QueryDefine, icon: _jsx(IconPencil, { fontSize: 16 }), btnStyle: 'toolbar', onClick: () => onEditClick ? onEditClick() : setShowEditor(true) }), _jsx(TMButton, { caption: SDKUI_Localizator.QueryCount, icon: _jsx(IconCount, { fontSize: 16 }), disabled: validationItemsQd.filter(o => o.ResultType == ResultTypes.ERROR).length > 0, btnStyle: 'toolbar', onClick: () => getQueryCountAsync(qd, true) }), _jsx(TMButton, { caption: SDKUI_Localizator.QueryClear, icon: _jsx(IconEraser, { fontSize: 16 }), btnStyle: 'toolbar', onClick: () => onValueChanged?.(new QueryDescriptor()) }), children] }), _jsxs("div", { style: { display: 'flex', flexDirection: 'column', width: '100%', overflowX: 'auto' }, children: [qd && qd.from &&
+                        _jsx(TMQueryEditor, { formMode: FormModes.ReadOnly, inputData: qd, isModal: false, showToolbar: false, validateSelect: validateSelect, validateOrderBy: validateOrderBy, raiseWarningForOnlyMetadataDcmtTypes: raiseWarningForOnlyMetadataDcmtTypes }), _jsx("div", { style: { padding: '0px 5px' }, children: _jsx(TMVilViewer, { vil: validationItemsQd }) })] }), useInternalEditor && showEditor &&
+                _jsx(TMModal, { title: SDKUI_Localizator.QueryDefine, children: _jsx(TMQueryEditor, { formMode: FormModes.Update, inputData: qd, isModal: true, raiseWarningForOnlyMetadataDcmtTypes: raiseWarningForOnlyMetadataDcmtTypes, validateSelect: validateSelect, validateOrderBy: validateOrderBy, onApplied: (newValue) => onValueChanged?.(newValue), onClose: () => { setShowEditor(false); } }) })] }));
 };
 export default TMQuerySummary;

package/lib/helper/SDKUI_Localizator.d.ts

@@ -254,6 +254,7 @@ export declare class SDKUI_Localizator {
     static get List_Hide(): "Liste ausblenden" | "Hide list" | "Ocultar lista" | "Masquer la liste" | "Nascondi la lista";
     static get List_Show(): "liste anzeigen" | "Show list" | "Ver lista" | "Afficher la liste" | "Visualizza la lista";
     static get Loading(): "Laden" | "Loading" | "Carga" | "Chargement" | "Caricamento";
+    static get Localization(): "Lokalisierung" | "Localization" | "Localización" | "Localisation" | "Localização" | "Localizzazione";
     static get LoadingWorkGroups(): string;
     static get LoadingParticipants(): string;
     static get Login(): string;
@@ -531,7 +532,11 @@ export declare class SDKUI_Localizator {
     static get WelcomeTo(): "Willkommen bei {{0}}" | "Welcome to {{0}}" | "Bienvenido a {{0}}" | "Bienvenue sur {{0}}" | "Bem-vindo à {{0}}" | "Benvenuto su {{0}}";
     static get WorkflowApproval(): "Workflow-Genehmigung" | "Workflow approval" | "Aprobación de flujo de trabajo" | "Approbation de workflow" | "Aprovação de fluxo de trabalho" | "Approvazione workflow";
     static get WorkflowDiagramMissingOrInvalid(): "Diagramm fehlt oder ist ungültig" | "Diagram missing or invalid" | "Diagrama no presente o no válido" | "Schéma manquant ou invalide" | "Diagrama ausente ou inválido" | "Diagramma non presente o non valido";
+    static get WorkflowEndInstance(): "Instanz beenden" | "End instance" | "Finalizar instancia" | "Termine l'instance" | "Pare a instância" | "Termina istanza";
+    static get WorkflowHistWI(): "Workitems historisieren" | "Historicize workitems" | "Incluir en historial los workitem" | "Historiser le workitems" | "Historicize workItem" | "Storicizza i workitem";
     static get WorkflowNoInstances(): "Keine Instanzen aktiv" | "No running instances" | "Ninguna instancia en curso" | "Aucune instance en cours" | "Nenhuma instância em execução" | "Nessuna istanza in corso";
+    static get WorkflowStartAfterArchive(): "Starten Sie die Instanz beim Archivieren des Dokuments" | "Start the instance when you archive the document" | "Iniciar la instancia cuando se almacena el documento" | "Démarrer l'instance lorsque vous archivez le document" | "Inicie a instância quando você fizer check in no documento" | "Avviare l'istanza quando si archivia il documento";
+    static get WorkflowStartAfterUpdate(): "Starten Sie die Instanz beim Bearbeiten der folgenden Methadaten" | "Start the instance when updating the following metadata" | "Iniciar la instancia cuando se modifican los siguientes metadatos" | "Démarrer l'instance lors de l'édition des métadonnées suivantes" | "Inicie a instância ao editar os seguintes metadados" | "Avviare l'istanza quando si modificano i seguenti metadati";
     static get WorkGroup(): "Arbeitsgruppe" | "Work Group" | "Grupo de Trabajo" | "Groupe de travail" | "Grupo de Trabalho" | "Gruppo di lavoro";
     static get WorkgroupOperations(): string;
     static get WorkingGroups(): "Arbeitsgruppen" | "Work groups" | "Grupos de trabajo" | "Groupes de travail" | "Grupos de trabalho" | "Gruppi di lavoro";

package/lib/helper/SDKUI_Localizator.js

@@ -2506,6 +2506,16 @@ export class SDKUI_Localizator {
             default: return "Caricamento";
         }
     }
+    static get Localization() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Lokalisierung";
+            case CultureIDs.En_US: return "Localization";
+            case CultureIDs.Es_ES: return "Localización";
+            case CultureIDs.Fr_FR: return "Localisation";
+            case CultureIDs.Pt_PT: return "Localização";
+            default: return "Localizzazione";
+        }
+    }
     static get LoadingWorkGroups() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Laden von Arbeitsgruppen";
@@ -5275,6 +5285,26 @@ export class SDKUI_Localizator {
             default: return "Diagramma non presente o non valido";
         }
     }
+    static get WorkflowEndInstance() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Instanz beenden";
+            case CultureIDs.En_US: return "End instance";
+            case CultureIDs.Es_ES: return "Finalizar instancia";
+            case CultureIDs.Fr_FR: return "Termine l'instance";
+            case CultureIDs.Pt_PT: return "Pare a instância";
+            default: return "Termina istanza";
+        }
+    }
+    static get WorkflowHistWI() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Workitems historisieren";
+            case CultureIDs.En_US: return "Historicize workitems";
+            case CultureIDs.Es_ES: return "Incluir en historial los workitem";
+            case CultureIDs.Fr_FR: return "Historiser le workitems";
+            case CultureIDs.Pt_PT: return "Historicize workItem";
+            default: return "Storicizza i workitem";
+        }
+    }
     static get WorkflowNoInstances() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Keine Instanzen aktiv";
@@ -5285,6 +5315,26 @@ export class SDKUI_Localizator {
             default: return "Nessuna istanza in corso";
         }
     }
+    static get WorkflowStartAfterArchive() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Starten Sie die Instanz beim Archivieren des Dokuments";
+            case CultureIDs.En_US: return "Start the instance when you archive the document";
+            case CultureIDs.Es_ES: return "Iniciar la instancia cuando se almacena el documento";
+            case CultureIDs.Fr_FR: return "Démarrer l'instance lorsque vous archivez le document";
+            case CultureIDs.Pt_PT: return "Inicie a instância quando você fizer check in no documento";
+            default: return "Avviare l'istanza quando si archivia il documento";
+        }
+    }
+    static get WorkflowStartAfterUpdate() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Starten Sie die Instanz beim Bearbeiten der folgenden Methadaten";
+            case CultureIDs.En_US: return "Start the instance when updating the following metadata";
+            case CultureIDs.Es_ES: return "Iniciar la instancia cuando se modifican los siguientes metadatos";
+            case CultureIDs.Fr_FR: return "Démarrer l'instance lors de l'édition des métadonnées suivantes";
+            case CultureIDs.Pt_PT: return "Inicie a instância ao editar os seguintes metadados";
+            default: return "Avviare l'istanza quando si modificano i seguenti metadati";
+        }
+    }
     static get WorkGroup() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Arbeitsgruppe";

package/lib/utils/theme.js

@@ -21,8 +21,16 @@ Colors.toolbar_color = '#F0F4FA';
 Colors.black = '#000000';
 Colors.white = '#ffffff';
 class TMColors {
-    static get primaryColor() { return this._primaryColor; }
-    static set primaryColor(thePrimaryColor) { this._primaryColor = thePrimaryColor; }
+    static get primaryColor() {
+        return this._primaryColor;
+    }
+    static set primaryColor(thePrimaryColor) {
+        this._primaryColor = thePrimaryColor;
+        // Verifica se il codice sta girando in un ambiente browser e aggiorno la variabile CSS
+        if (typeof document !== 'undefined' && this._primaryColor) {
+            document.documentElement.style.setProperty('--primary-color', this._primaryColor);
+        }
+    }
     static get backgroundColorHeader() { return this._backgroundColorHeader; }
     static set backgroundColorHeader(theBackgroundColorHeader) { this._backgroundColorHeader = theBackgroundColorHeader; }
     static get colorHeader() { return this._colorHeader; }

package/package.json

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