@topconsultnpm/sdkui-react-beta 6.16.99 → 6.16.100

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

@@ -7,6 +7,7 @@ interface ConnectionComponentProps {
     sinkPoint: Point;
     isTemporary?: boolean;
     onClick: (id: string, event: React.MouseEvent) => void;
+    onDoubleClick: (id: string) => void;
     onConnectionEndpointMouseDown?: (connectionId: string, endpointType: 'source' | 'sink', mouseEvent: React.MouseEvent) => void;
 }
 declare const _default: React.NamedExoticComponent<ConnectionComponentProps>;

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

@@ -37,7 +37,7 @@ const StyledSquareConnector = styled.rect `
   stroke-width: 1;
   pointer-events: all;
 `;
-const ConnectionComponent = ({ connection, isSelected, sourcePoint, sinkPoint, isTemporary, onClick, onConnectionEndpointMouseDown }) => {
+const ConnectionComponent = ({ connection, isSelected, sourcePoint, sinkPoint, isTemporary, onClick, onDoubleClick, onConnectionEndpointMouseDown }) => {
     const connectionColor = getConnectionColor(connection.OutputStatus);
     // Funzione per renderizzare la forma della freccia
     const renderArrow = useCallback((arrowType, angle) => {
@@ -78,7 +78,11 @@ const ConnectionComponent = ({ connection, isSelected, sourcePoint, sinkPoint, i
         // Sposta l'origine della rotazione al punto della freccia
         return `translate(${point.x}, ${point.y}) rotate(${angleDeg})`;
     }, [connection.PathGeometry]);
-    return (_jsxs("g", { children: [_jsx(StyledPathHitArea, { d: connection.PathGeometry, onClick: (e) => onClick(connection.ID, e) }), _jsx(StyledPath, { d: connection.PathGeometry, "$isSelected": isSelected, "$isTemporary": isTemporary, "$outputStatus": connection.OutputStatus, onClick: (e) => onClick(connection.ID, e) }), connection.SinkArrowSymbol !== ArrowSymbol.None && (_jsxs("g", { transform: calculateArrowTransform(true), children: [renderArrow(connection.SinkArrowSymbol, 0), " "] })), connection.SourceArrowSymbol !== ArrowSymbol.None && (_jsx("g", { transform: calculateArrowTransform(false) + ' rotate(180)', children: renderArrow(connection.SourceArrowSymbol, 0) })), isSelected && (_jsxs(_Fragment, { children: [_jsx(StyledSquareConnector, { "$color": connectionColor, x: sourcePoint.x - 5, y: sourcePoint.y - 5, width: 10, height: 10 }), _jsx(StyledSquareConnector, { "$color": connectionColor, x: sinkPoint.x - 5, y: sinkPoint.y - 5, width: 10, height: 10, cursor: 'move', onMouseDown: (e) => {
+    const handleDoubleClick = useCallback((event) => {
+        event.stopPropagation();
+        onDoubleClick?.(connection.ID);
+    }, [onDoubleClick, connection.ID]);
+    return (_jsxs("g", { children: [_jsx(StyledPathHitArea, { d: connection.PathGeometry, onClick: (e) => onClick(connection.ID, e), onDoubleClick: handleDoubleClick }), _jsx(StyledPath, { d: connection.PathGeometry, "$isSelected": isSelected, "$isTemporary": isTemporary, "$outputStatus": connection.OutputStatus, onClick: (e) => onClick(connection.ID, e), onDoubleClick: handleDoubleClick }), connection.SinkArrowSymbol !== ArrowSymbol.None && (_jsxs("g", { transform: calculateArrowTransform(true), children: [renderArrow(connection.SinkArrowSymbol, 0), " "] })), connection.SourceArrowSymbol !== ArrowSymbol.None && (_jsx("g", { transform: calculateArrowTransform(false) + ' rotate(180)', children: renderArrow(connection.SourceArrowSymbol, 0) })), isSelected && (_jsxs(_Fragment, { children: [_jsx(StyledSquareConnector, { "$color": connectionColor, x: sourcePoint.x - 5, y: sourcePoint.y - 5, width: 10, height: 10 }), _jsx(StyledSquareConnector, { "$color": connectionColor, x: sinkPoint.x - 5, y: sinkPoint.y - 5, width: 10, height: 10, cursor: 'move', onMouseDown: (e) => {
                             e.stopPropagation(); // Impedisce la propagazione dell'evento a elementi sottostanti
                             onConnectionEndpointMouseDown?.(connection.ID, 'sink', e);
                         } })] }))] }));

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Connection } from './interfaces';
+interface IConnectionFormProps {
+    connectionToEdit: Connection;
+    onClose: () => void;
+    onApply: (updatedConnection: Connection) => void;
+}
+declare const ConnectionForm: React.FC<IConnectionFormProps>;
+export default ConnectionForm;

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

@@ -0,0 +1,82 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// filepath: c:\TM6\Sorgenti\WebClient\tm-sdkui-react\src\components\features\workflow\diagram\ConnectionForm.tsx
+import { useState, useCallback, useMemo } from 'react';
+import styled from 'styled-components';
+import { calcIsModified, IconApply, IconUndo, SDKUI_Localizator } from '../../../../helper';
+import TMButton from '../../../base/TMButton';
+import TMModal from '../../../base/TMModal';
+import { TMColors } from '../../../../utils/theme';
+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 ModalContent = styled.div `
+    background: white;
+    padding: 20px;
+    border-radius: 8px;
+    box-shadow: 0 5px 15px rgba(0, 0, 0, 0.3);
+    width: 500px;
+    max-width: 90%;
+    display: flex;
+    flex-direction: column;
+    gap: 15px;
+`;
+const ModalHeader = styled.h3 `
+    margin-top: 0;
+    border-bottom: 1px solid #eee;
+    padding-bottom: 10px;
+`;
+const ModalFooter = styled.div `
+    display: flex;
+    justify-content: flex-end;
+    gap: 10px;
+    margin-top: 20px;
+`;
+const ConnectionForm = ({ connectionToEdit, onClose, onApply }) => {
+    const [localItem, setLocalItem] = useState(connectionToEdit);
+    const [localItemOrig] = useState(structuredClone(connectionToEdit));
+    const isModified = useMemo(() => calcIsModified(localItem, localItemOrig), [localItem, localItemOrig]);
+    const handleCancel = () => {
+        setLocalItem(localItemOrig);
+    };
+    const handleSave = () => {
+        onApply(localItem);
+        onClose();
+    };
+    const handleLocalizedDescriptionChange = useCallback((lang, newValue) => {
+        setLocalItem(prevLocalItem => {
+            const updatedItem = { ...prevLocalItem };
+            // Aggiungi la logica per aggiornare il campo corretto
+            switch (lang) {
+                case CultureIDs.It_IT:
+                    updatedItem.Description_IT = newValue;
+                    break;
+                case CultureIDs.En_US:
+                    updatedItem.Description_EN = newValue;
+                    break;
+                case CultureIDs.Fr_FR:
+                    updatedItem.Description_FR = newValue;
+                    break;
+                case CultureIDs.Pt_PT:
+                    updatedItem.Description_PT = newValue;
+                    break;
+                case CultureIDs.Es_ES:
+                    updatedItem.Description_ES = newValue;
+                    break;
+                case CultureIDs.De_DE:
+                    updatedItem.Description_DE = newValue;
+                    break;
+                default:
+                    updatedItem.Description = newValue;
+                    break;
+            }
+            return updatedItem;
+        });
+    }, []);
+    return (_jsx(TMModal, { title: "Modifica Connessione", onClose: onClose, isModal: true, width: "500px", height: "175px", children: _jsxs(FormContainer, { onClick: (e) => e.stopPropagation(), children: [_jsx(TMLocalizedTextBox, { label: SDKUI_Localizator.Description, value: localItem.Description, value_IT: localItem.Description_IT, value_EN: localItem.Description_EN, value_FR: localItem.Description_FR, value_PT: localItem.Description_PT, value_ES: localItem.Description_ES, value_DE: localItem.Description_DE, isModifiedWhen: localItem.Description !== localItemOrig.Description, onValueChanged: handleLocalizedDescriptionChange }), _jsxs(ModalFooter, { children: [_jsx(TMButton, { caption: SDKUI_Localizator.Apply, btnStyle: 'advanced', advancedColor: TMColors.tertiary, icon: _jsx(IconApply, {}), showTooltip: false, disabled: !isModified, onClick: handleSave }), _jsx(TMButton, { caption: SDKUI_Localizator.Cancel, btnStyle: 'toolbar', color: 'primary', icon: _jsx(IconUndo, {}), showTooltip: false, disabled: !isModified, onClick: handleCancel })] })] }) }));
+};
+export default ConnectionForm;

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

@@ -10,7 +10,7 @@ import TMTextBox from '../../../editors/TMTextBox';
 import TMButton from '../../../base/TMButton';
 import styled from 'styled-components';
 import TMQuerySummary from '../../../query/TMQuerySummary';
-import { CultureIDs, DcmtTypeListCacheService, FromItem, MetadataDataDomains, PlatformObjectValidator, QueryValidatorOptions, ResultTypes, SDK_Globals, SearchEngine, Severities, TMPropertyNames, ValidationItem, WFAppTypes, WorkItemSetRules } from '@topconsultnpm/sdk-ts-beta';
+import { CultureIDs, DcmtTypeListCacheService, FromItem, MetadataDataDomains, SDK_Globals, SearchEngine, Severities, WFAppTypes, WorkItemSetRules } from '@topconsultnpm/sdk-ts-beta';
 import TMLocalizedTextBox from '../../../editors/TMLocalizedTextBox';
 import TMDataListItemPicker from '../../../choosers/TMDataListItemPicker';
 import WorkitemRecipientsEditor, { actorsToTos, RecipientsContainer, tosToActors } from './WorkitemRecipientsEditor';
@@ -26,6 +26,7 @@ import TMCultureIDPicker from '../../../choosers/TMCultureIDPicker';
 import RecipientList, { WorkItemActorTypes } from './RecipientList';
 import TMRadioButton from '../../../editors/TMRadioButton';
 import TMVilViewer from '../../../base/TMVilViewer';
+import { DiagramItemProps, wfDiagramItemValidator } from './workflowHelpers';
 const FormContainer = styled.div `
   display: flex;
   flex-direction: column;
@@ -136,53 +137,8 @@ const DiagramItemForm = ({ itemToEdit, wf, onClose, onApply }) => {
         }
         return { calculatedWidth: width, calculatedHeight: height };
     }, [localItem.Type]);
-    const validator = async (d) => {
-        let vil = [];
-        switch (d.Type) {
-            case DiagramItemTypes.Start:
-                if (d.StartAfterArchive !== 1 && d.StartAfterUpdate !== 1 && d.StartManual !== 1)
-                    vil.push(new ValidationItem(ResultTypes.ERROR, "*", "Indicare la modalità di avvio dell'istanza di workflow"));
-                if (d.StartAfterUpdate === 1 && (d.StartAfterUpdateMIDs === undefined || d.StartAfterUpdateMIDs.length <= 0))
-                    vil.push(new ValidationItem(ResultTypes.ERROR, DiagramItemProps.StartAfterUpdateMIDs, "Indicare almeno un metadato la cui modifica avvii l'istanza"));
-                break;
-            case DiagramItemTypes.Approval:
-                PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
-                PlatformObjectValidator.RequiredStringValidator(d.Description, DiagramItemProps.Description, vil, SDKUI_Localizator.Description);
-                PlatformObjectValidator.RequiredStringValidator(d.Tos, DiagramItemProps.Tos, vil, SDKUI_Localizator.Recipients);
-                break;
-            case DiagramItemTypes.ExecTask:
-                PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
-                PlatformObjectValidator.RequiredStringValidator(d.Description, DiagramItemProps.Description, vil, SDKUI_Localizator.Description);
-                PlatformObjectValidator.RequiredStringValidator(d.Tos, DiagramItemProps.Tos, vil, SDKUI_Localizator.Recipients);
-                PlatformObjectValidator.RequiredStringValidator(d.AppName, DiagramItemProps.AppName, vil, SDKUI_Localizator.WorkflowAppName);
-                PlatformObjectValidator.RequiredStringValidator(d.AppType, DiagramItemProps.AppType, vil, SDKUI_Localizator.WorkflowAppType);
-                break;
-            case DiagramItemTypes.Notification:
-                PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
-                PlatformObjectValidator.RequiredStringValidator(d.Tos, DiagramItemProps.Tos, vil, SDKUI_Localizator.Recipients);
-                PlatformObjectValidator.RequiredStringValidator(d.Severity, DiagramItemProps.Severity, vil, SDKUI_Localizator.Severity);
-                break;
-            case DiagramItemTypes.RunApp:
-                PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
-                PlatformObjectValidator.RequiredStringValidator(d.Tos, DiagramItemProps.Tos, vil, SDKUI_Localizator.Recipients);
-                PlatformObjectValidator.RequiredStringValidator(d.AppName, DiagramItemProps.AppName, vil, SDKUI_Localizator.WorkflowAppName);
-                PlatformObjectValidator.RequiredStringValidator(d.AppType, DiagramItemProps.AppType, vil, SDKUI_Localizator.WorkflowAppType);
-                break;
-            case DiagramItemTypes.Condition:
-                PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
-                let qvo = new QueryValidatorOptions();
-                qvo.DoSelectValidation = false;
-                qvo.DoOrderByValidation = false;
-                await PlatformObjectValidator.QueryValidatorAsync(localItem.QD, vil, qvo);
-                if (localItem.QD?.where === undefined || localItem.QD.where.length <= 0) {
-                    vil.push(new ValidationItem(ResultTypes.ERROR, TMPropertyNames.where, "La query della condizione non contiene criteri di selezione", [DiagramItemProps.QD]));
-                }
-                break;
-        }
-        return vil;
-    };
     useEffect(() => {
-        validator(localItem).then((vil) => setValidationItems(vil));
+        wfDiagramItemValidator(localItem).then((vil) => setValidationItems(vil));
     }, [localItem]);
     const isModified = useMemo(() => calcIsModified(localItem, localItemOrig), [localItem, localItemOrig]);
     const handleCancel = () => {
@@ -723,54 +679,3 @@ const DiagramItemForm = ({ itemToEdit, wf, onClose, onApply }) => {
     return (_jsx(TMModal, { title: DiagramItemTypes[localItem.Type].toString(), onClose: onClose, isModal: true, width: calculatedWidth, height: calculatedHeight, children: renderForm() }));
 };
 export default DiagramItemForm;
-const DiagramItemProps = {
-    ID: 'ID',
-    Left: 'Left',
-    Top: 'Top',
-    Width: 'Width',
-    Height: 'Height',
-    Type: 'Type',
-    ItemName: 'ItemName',
-    ItemName_IT: 'ItemName_IT',
-    ItemName_EN: 'ItemName_EN',
-    ItemName_FR: 'ItemName_FR',
-    ItemName_PT: 'ItemName_PT',
-    ItemName_ES: 'ItemName_ES',
-    ItemName_DE: 'ItemName_DE',
-    Description: 'Description',
-    Description_IT: 'Description_IT',
-    Description_EN: 'Description_EN',
-    Description_FR: 'Description_FR',
-    Description_PT: 'Description_PT',
-    Description_ES: 'Description_ES',
-    Description_DE: 'Description_DE',
-    StatusValue: 'StatusValue',
-    RegisterPost: 'RegisterPost',
-    AllowZeroTos: 'AllowZeroTos',
-    Tos: 'Tos',
-    SetRule: 'SetRule',
-    StartAfterArchive: 'StartAfterArchive',
-    StartAfterUpdate: 'StartAfterUpdate',
-    StartAfterUpdateMIDs: 'StartAfterUpdateMIDs',
-    StartManual: 'StartManual',
-    Hist: 'Hist',
-    EndWFInstance: 'EndWFInstance',
-    QD: 'QD',
-    SOD: 'SOD',
-    MetadataValues: 'MetadataValues',
-    Severity: 'Severity',
-    RegAsWfInstPart: 'RegAsWfInstPart',
-    FormatCultureID: 'FormatCultureID',
-    Tos2: 'Tos2',
-    QD2: 'QD2',
-    PlatformObjName: 'PlatformObjName',
-    PlatformObjDescr: 'PlatformObjDescr',
-    Value1asInt: 'Value1asInt',
-    Value2asInt: 'Value2asInt',
-    Value3asInt: 'Value3asInt',
-    Value1asString: 'Value1asString',
-    AppType: 'AppType',
-    AppName: 'AppName',
-    AppArgs: 'AppArgs',
-    Trunc: 'Trunc',
-};

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

@@ -13,6 +13,7 @@ import { ButtonNames, TMExceptionBoxManager, TMMessageBoxManager } from '../../.
 import { StyledLoadingContainer, StyledSpinner } from '../../../base/Styled';
 import DiagramItemForm from './DiagramItemForm';
 import ReactDOM from 'react-dom';
+import ConnectionForm from './ConnectionForm';
 const ZoomLevelText = styled.span `
     font-size: 0.9em;
     color: #555; 
@@ -340,6 +341,8 @@ const WFDiagram = ({ xmlDiagramString, currentSetID, allowEdit = true, onDiagram
     const [isToolboxVisible, setIsToolboxVisible] = useState(true);
     const [isModalOpen, setIsModalOpen] = useState(false);
     const [itemToEdit, setItemToEdit] = useState(null);
+    const [isConnectionModalOpen, setIsConnectionModalOpen] = useState(false);
+    const [connectionToEdit, setConnectionToEdit] = useState(null);
     const { svgWidth, svgHeight } = useMemo(() => {
         if (!wfDiagram) {
             return { svgWidth: 0, svgHeight: 0 };
@@ -580,6 +583,25 @@ const WFDiagram = ({ xmlDiagramString, currentSetID, allowEdit = true, onDiagram
             return false;
         });
     }, [isReadOnly]);
+    const handleDoubleClickConnection = useCallback((connectionId) => {
+        if (isReadOnly)
+            return;
+        const connFound = wfDiagram?.Connections.find(c => c.ID === connectionId);
+        if (connFound) {
+            const sinkItem = wfDiagram?.DiagramItems.find(item => item.ID === connFound.Sink.ParentDiagramItem.ID);
+            if (sinkItem) {
+                const canOpen = [
+                    DiagramItemTypes.Approval,
+                    DiagramItemTypes.DataEntry,
+                    DiagramItemTypes.ExecTask
+                ].includes(sinkItem.Type);
+                if (canOpen) {
+                    setConnectionToEdit(connFound);
+                    setIsConnectionModalOpen(true);
+                }
+            }
+        }
+    }, [wfDiagram, isReadOnly]);
     const handleKeyDown = useCallback((event) => {
         if (isReadOnly)
             return;
@@ -1453,6 +1475,21 @@ const WFDiagram = ({ xmlDiagramString, currentSetID, allowEdit = true, onDiagram
             return { ...prevDiagram, DiagramItems: updatedDiagramItems };
         });
     }, []);
+    const handleUpdateConnection = useCallback((updatedConnection) => {
+        setWfDiagram(prevDiagram => {
+            if (!prevDiagram)
+                return null;
+            const updatedConnections = prevDiagram.Connections.map(conn => {
+                if (conn.ID === updatedConnection.ID) {
+                    return updatedConnection;
+                }
+                return conn;
+            });
+            const newDiagram = { ...prevDiagram, Connections: updatedConnections };
+            updateDiagram(newDiagram);
+            return newDiagram;
+        });
+    }, [updateDiagram]);
     const availableItemTypes = useMemo(() => {
         return [
             DiagramItemTypes.Approval,
@@ -1571,8 +1608,8 @@ const WFDiagram = ({ xmlDiagramString, currentSetID, allowEdit = true, onDiagram
                                 const sinkPoint = getConnectionPoint(sinkItem, connection.Sink.ConnectorName);
                                 // 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, wf: wfDiagram?.Info, onClose: handleCloseModal, onApply: handleUpdateDiagramItem }))] }));
+                                return (_jsx(ConnectionComponent, { connection: connection, isSelected: selectedConnections.has(connection.ID), sourcePoint: sourcePoint, sinkPoint: sinkPoint, isTemporary: isThisConnectionBeingDragged, onClick: handleConnectionClick, onDoubleClick: handleDoubleClickConnection, 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, wf: wfDiagram?.Info, onClose: handleCloseModal, onApply: handleUpdateDiagramItem })), isConnectionModalOpen && connectionToEdit && (_jsx(ConnectionForm, { connectionToEdit: connectionToEdit, onClose: () => setIsConnectionModalOpen(false), onApply: handleUpdateConnection }))] }));
     const diagramRef = useRef(null);
     return (_jsxs(_Fragment, { children: [!isFullScreen && (_jsx(DiagramWrapper, { ref: diagramRef, children: diagramContent })), isFullScreen && ReactDOM.createPortal(_jsx(FullScreenContainer, { children: diagramContent }), document.body)] }));
 };

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

@@ -94,6 +94,12 @@ export interface Connection {
     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;

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

@@ -1,4 +1,4 @@
-import { WorkItemStatus } from '@topconsultnpm/sdk-ts-beta';
+import { ValidationItem, WorkItemStatus } from '@topconsultnpm/sdk-ts-beta';
 import { Point, Rect, DiagramItem, WfDiagram, TextDimensions, Connection, WfInfo } from './interfaces';
 /**
  * Calculates the angle in degrees of an arrow based on two points.
@@ -67,3 +67,56 @@ 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[]>;

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

@@ -1,6 +1,6 @@
-import { WorkItemStatus } from '@topconsultnpm/sdk-ts-beta';
+import { PlatformObjectValidator, QueryValidatorOptions, ResultTypes, TMPropertyNames, ValidationItem, WorkItemStatus } from '@topconsultnpm/sdk-ts-beta';
 import { DiagramItemTypes, ArrowSymbol } from './interfaces'; // Assicurati che il percorso sia corretto
-import { generateUUID } from '../../../../helper';
+import { generateUUID, SDKUI_Localizator } from '../../../../helper';
 /**
  * Calculates the angle in degrees of an arrow based on two points.
  * @param prevPoint The previous point on the trajectory.
@@ -294,3 +294,197 @@ export const getNewWfDiagram = (info) => {
     };
     return newWfDiagram;
 };
+export const workflowValidator = async (wf) => {
+    const validationItems = [];
+    if (!wf.Info) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "info", "Il workflow deve avere informazioni generali valide."));
+    }
+    if (!wf.DiagramItems || wf.DiagramItems.length === 0) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "diagramItems", "Il workflow deve contenere almeno un elemento nel diagramma."));
+    }
+    if (!wf.Connections || wf.Connections.length === 0) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "connections", "Il workflow deve contenere almeno una connessione tra gli elementi."));
+    }
+    const startItems = wf.DiagramItems.filter(item => item.Type === DiagramItemTypes.Start);
+    if (startItems.length === 0) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "startItems", "Il workflow deve contenere esattamente un elemento di tipo 'Start'."));
+    }
+    if (startItems.length > 1) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "startItems", "Il workflow non può contenere più di un elemento di tipo 'Start'."));
+    }
+    const endItems = wf.DiagramItems.filter(item => item.Type === DiagramItemTypes.End);
+    if (endItems.length === 0) {
+        validationItems.push(new ValidationItem(ResultTypes.ERROR, "endItems", "Il workflow deve contenere almeno un elemento di tipo 'End'."));
+    }
+    for (const item of wf.DiagramItems) {
+        const vil = await wfDiagramItemValidator(item);
+        vil.forEach(v => v.PropertyScopes = ['diagramItem']);
+        validationItems.push(...vil);
+        switch (item.Type) {
+            case DiagramItemTypes.Start:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.ERROR, `item-${item.ID}`, "L'elemento 'Start' deve avere almeno una connessione in uscita.", ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length > 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.ERROR, `item-${item.ID}`, "L'elemento 'Start' non può avere connessioni in ingresso.", ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.End:
+            case DiagramItemTypes.Exit:
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.ERROR, `item-${item.ID}`, `L'elemento '${DiagramItemTypes[item.Type]}' deve avere almeno una connessione in ingresso.`, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length > 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.ERROR, `item-${item.ID}`, `L'elemento '${DiagramItemTypes[item.Type]}' non può avere connessioni in uscita.`, ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.Condition:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length !== 2) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, "L'elemento 'Condition' deve avere esattamente due connessioni in uscita.", ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.ERROR, `item-${item.ID}`, "L'elemento 'Condition' deve avere almeno una connessione in ingresso.", ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.Approval:
+            case DiagramItemTypes.ExecTask:
+            case DiagramItemTypes.DataEntry:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length !== 2) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' dovrebbe avere esattamente due connessioni in uscita.`, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' deve avere almeno una connessione in ingresso.`, ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.Notification:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' dovrebbe avere almeno una connessione in uscita.`, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' deve avere almeno una connessione in ingresso.`, ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.UpdateDcmt:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length !== 1) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' dovrebbe avere esattamente una connessione in uscita.`, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' deve avere almeno una connessione in ingresso.`, ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.Status:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length !== 1) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' dovrebbe avere esattamente una connessione in uscita.`, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' deve avere almeno una connessione in ingresso.`, ['diagramItem']));
+                }
+                break;
+            case DiagramItemTypes.RunApp:
+                if (wf.Connections.filter(c => c.Source.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' dovrebbe avere almeno una connessione in uscita.`, ['diagramItem']));
+                }
+                if (wf.Connections.filter(c => c.Sink.ParentDiagramItem.ID === item.ID).length === 0) {
+                    validationItems.push(new ValidationItem(ResultTypes.WARNING, `item-${item.ID}`, `L'elemento '${item.ItemName}' deve avere almeno una connessione in ingresso.`, ['diagramItem']));
+                }
+                break;
+        }
+    }
+    // Tutte le validazioni sono passate
+    return validationItems;
+};
+export const DiagramItemProps = {
+    ID: 'ID',
+    Left: 'Left',
+    Top: 'Top',
+    Width: 'Width',
+    Height: 'Height',
+    Type: 'Type',
+    ItemName: 'ItemName',
+    ItemName_IT: 'ItemName_IT',
+    ItemName_EN: 'ItemName_EN',
+    ItemName_FR: 'ItemName_FR',
+    ItemName_PT: 'ItemName_PT',
+    ItemName_ES: 'ItemName_ES',
+    ItemName_DE: 'ItemName_DE',
+    Description: 'Description',
+    Description_IT: 'Description_IT',
+    Description_EN: 'Description_EN',
+    Description_FR: 'Description_FR',
+    Description_PT: 'Description_PT',
+    Description_ES: 'Description_ES',
+    Description_DE: 'Description_DE',
+    StatusValue: 'StatusValue',
+    RegisterPost: 'RegisterPost',
+    AllowZeroTos: 'AllowZeroTos',
+    Tos: 'Tos',
+    SetRule: 'SetRule',
+    StartAfterArchive: 'StartAfterArchive',
+    StartAfterUpdate: 'StartAfterUpdate',
+    StartAfterUpdateMIDs: 'StartAfterUpdateMIDs',
+    StartManual: 'StartManual',
+    Hist: 'Hist',
+    EndWFInstance: 'EndWFInstance',
+    QD: 'QD',
+    SOD: 'SOD',
+    MetadataValues: 'MetadataValues',
+    Severity: 'Severity',
+    RegAsWfInstPart: 'RegAsWfInstPart',
+    FormatCultureID: 'FormatCultureID',
+    Tos2: 'Tos2',
+    QD2: 'QD2',
+    PlatformObjName: 'PlatformObjName',
+    PlatformObjDescr: 'PlatformObjDescr',
+    Value1asInt: 'Value1asInt',
+    Value2asInt: 'Value2asInt',
+    Value3asInt: 'Value3asInt',
+    Value1asString: 'Value1asString',
+    AppType: 'AppType',
+    AppName: 'AppName',
+    AppArgs: 'AppArgs',
+    Trunc: 'Trunc',
+};
+export const wfDiagramItemValidator = async (d) => {
+    let vil = [];
+    switch (d.Type) {
+        case DiagramItemTypes.Start:
+            if (d.StartAfterArchive !== 1 && d.StartAfterUpdate !== 1 && d.StartManual !== 1)
+                vil.push(new ValidationItem(ResultTypes.ERROR, "*", "Indicare la modalità di avvio dell'istanza di workflow"));
+            if (d.StartAfterUpdate === 1 && (d.StartAfterUpdateMIDs === undefined || d.StartAfterUpdateMIDs.length <= 0))
+                vil.push(new ValidationItem(ResultTypes.ERROR, DiagramItemProps.StartAfterUpdateMIDs, "Indicare almeno un metadato la cui modifica avvii l'istanza"));
+            break;
+        case DiagramItemTypes.Approval:
+            PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
+            PlatformObjectValidator.RequiredStringValidator(d.Description, DiagramItemProps.Description, vil, SDKUI_Localizator.Description);
+            PlatformObjectValidator.RequiredStringValidator(d.Tos, DiagramItemProps.Tos, vil, SDKUI_Localizator.Recipients);
+            break;
+        case DiagramItemTypes.ExecTask:
+            PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
+            PlatformObjectValidator.RequiredStringValidator(d.Description, DiagramItemProps.Description, vil, SDKUI_Localizator.Description);
+            PlatformObjectValidator.RequiredStringValidator(d.Tos, DiagramItemProps.Tos, vil, SDKUI_Localizator.Recipients);
+            PlatformObjectValidator.RequiredStringValidator(d.AppName, DiagramItemProps.AppName, vil, SDKUI_Localizator.WorkflowAppName);
+            PlatformObjectValidator.RequiredStringValidator(d.AppType, DiagramItemProps.AppType, vil, SDKUI_Localizator.WorkflowAppType);
+            break;
+        case DiagramItemTypes.Notification:
+            PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
+            PlatformObjectValidator.RequiredStringValidator(d.Tos, DiagramItemProps.Tos, vil, SDKUI_Localizator.Recipients);
+            PlatformObjectValidator.RequiredStringValidator(d.Severity, DiagramItemProps.Severity, vil, SDKUI_Localizator.Severity);
+            break;
+        case DiagramItemTypes.RunApp:
+            PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
+            PlatformObjectValidator.RequiredStringValidator(d.AppName, DiagramItemProps.AppName, vil, SDKUI_Localizator.WorkflowAppName);
+            PlatformObjectValidator.RequiredStringValidator(d.AppType, DiagramItemProps.AppType, vil, SDKUI_Localizator.WorkflowAppType);
+            break;
+        case DiagramItemTypes.Condition:
+            PlatformObjectValidator.RequiredStringValidator(d.ItemName, DiagramItemProps.ItemName, vil, SDKUI_Localizator.Name);
+            let qvo = new QueryValidatorOptions();
+            qvo.DoSelectValidation = false;
+            qvo.DoOrderByValidation = false;
+            await PlatformObjectValidator.QueryValidatorAsync(d.QD, vil, qvo);
+            if (d.QD?.where === undefined || d.QD.where.length <= 0) {
+                vil.push(new ValidationItem(ResultTypes.ERROR, TMPropertyNames.where, "La query della condizione non contiene criteri di selezione", [DiagramItemProps.QD]));
+            }
+            break;
+    }
+    return vil;
+};

package/package.json

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