verben-workflow-ui 0.2.2 → 0.2.4

package/esm2022/lib/components/workflow-designer/services/swimlane.service.mjs

@@ -0,0 +1,145 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../workflow-designer.state";
+export class SwimlaneService {
+    state;
+    swimlaneHeight = 263;
+    constructor(state) {
+        this.state = state;
+    }
+    /**
+     * Add a new swimlane
+     */
+    addSwimlane(name, tags) {
+        const newSwimlane = {
+            order: this.state.swimlanes.length,
+            label: name,
+            tags,
+            nodes: [],
+        };
+        this.state.swimlanes.push(newSwimlane);
+        return newSwimlane;
+    }
+    /**
+     * Update an existing swimlane
+     */
+    updateSwimlane(index, name, tags) {
+        if (index < 0 || index >= this.state.swimlanes.length) {
+            console.error('Invalid swimlane index:', index);
+            return false;
+        }
+        this.state.swimlanes[index] = {
+            ...this.state.swimlanes[index],
+            label: name,
+            tags: tags,
+        };
+        return true;
+    }
+    /**
+     * Reorder swimlanes (move a swimlane up or down in the list)
+     */
+    reorderSwimlane(fromIndex, toIndex) {
+        if (fromIndex < 0 ||
+            fromIndex >= this.state.swimlanes.length ||
+            toIndex < 0 ||
+            toIndex >= this.state.swimlanes.length) {
+            return false;
+        }
+        // Remove the swimlane from its current position
+        const [swimlane] = this.state.swimlanes.splice(fromIndex, 1);
+        // Insert it at the new position
+        this.state.swimlanes.splice(toIndex, 0, swimlane);
+        // Update order properties for all swimlanes
+        this.state.swimlanes.forEach((lane, idx) => {
+            lane.order = idx;
+        });
+        return true;
+    }
+    /**
+     * Delete a swimlane by index
+     */
+    deleteSwimlane(index) {
+        if (index < 0 || index >= this.state.swimlanes.length) {
+            return false;
+        }
+        // Check if the swimlane has nodes
+        if (this.state.swimlanes[index].nodes?.length) {
+            console.error('Cannot delete swimlane with nodes');
+            return false;
+        }
+        // Remove the swimlane
+        this.state.swimlanes.splice(index, 1);
+        // Update order properties for all swimlanes
+        this.state.swimlanes.forEach((lane, idx) => {
+            lane.order = idx;
+        });
+        return true;
+    }
+    /**
+     * Get all swimlanes
+     */
+    getSwimlanes() {
+        return this.state.swimlanes;
+    }
+    /**
+     * Get swimlane by index
+     */
+    getSwimlane(index) {
+        if (index < 0 || index >= this.state.swimlanes.length) {
+            return null;
+        }
+        return this.state.swimlanes[index];
+    }
+    /**
+     * Calculate total canvas height needed for all swimlanes
+     */
+    calculateCanvasHeight(minHeight = 2000) {
+        const requiredHeight = (this.state.swimlanes.length + 1) * this.swimlaneHeight;
+        return Math.max(minHeight, requiredHeight);
+    }
+    /**
+     * Check if a Y position is within any swimlane
+     */
+    isPositionInsideSwimlane(y) {
+        // Check if y position is within any swimlane
+        const swimlaneCount = this.state.swimlanes.length;
+        if (swimlaneCount === 0)
+            return false;
+        // Each swimlane has a height of 263px
+        const totalSwimlaneHeight = swimlaneCount * this.swimlaneHeight;
+        // Check if y is within the total height of all swimlanes
+        return y >= 0 && y < totalSwimlaneHeight;
+    }
+    /**
+     * Calculate swimlane index from Y position
+     */
+    getSwimlaneIndexFromPosition(y) {
+        if (!this.isPositionInsideSwimlane(y))
+            return -1;
+        return Math.floor(y / this.swimlaneHeight);
+    }
+    /**
+     * Find swimlane index by Lane ID
+     */
+    findSwimlaneIndexByLaneId(laneId) {
+        // In a real implementation, you would maintain a mapping between API lane IDs and UI swimlane indices
+        // For now we'll just return the index based on position
+        const parts = laneId.split('-');
+        if (parts.length > 1) {
+            const index = parseInt(parts[1]);
+            if (!isNaN(index) && index < this.state.swimlanes.length) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SwimlaneService, deps: [{ token: i1.WorkflowDesignerState }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SwimlaneService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SwimlaneService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.WorkflowDesignerState }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"swimlane.service.js","sourceRoot":"","sources":["../../../../../../../projects/verben-workflow-ui/src/lib/components/workflow-designer/services/swimlane.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { SwimlaneItem } from '../workflow-designer.types';\nimport { Tag } from '../../../models/Tag';\nimport { WorkflowDesignerState } from '../workflow-designer.state';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SwimlaneService {\n  readonly swimlaneHeight = 263;\n\n  constructor(private state: WorkflowDesignerState) {}\n\n  /**\n   * Add a new swimlane\n   */\n  addSwimlane(name: string, tags: Tag[]): SwimlaneItem {\n    const newSwimlane: SwimlaneItem = {\n      order: this.state.swimlanes.length,\n      label: name,\n      tags,\n      nodes: [],\n    };\n\n    this.state.swimlanes.push(newSwimlane);\n    return newSwimlane;\n  }\n\n  /**\n   * Update an existing swimlane\n   */\n  updateSwimlane(index: number, name: string, tags: Tag[]): boolean {\n    if (index < 0 || index >= this.state.swimlanes.length) {\n      console.error('Invalid swimlane index:', index);\n      return false;\n    }\n\n    this.state.swimlanes[index] = {\n      ...this.state.swimlanes[index],\n      label: name,\n      tags: tags,\n    };\n\n    return true;\n  }\n\n  /**\n   * Reorder swimlanes (move a swimlane up or down in the list)\n   */\n  reorderSwimlane(fromIndex: number, toIndex: number): boolean {\n    if (\n      fromIndex < 0 ||\n      fromIndex >= this.state.swimlanes.length ||\n      toIndex < 0 ||\n      toIndex >= this.state.swimlanes.length\n    ) {\n      return false;\n    }\n\n    // Remove the swimlane from its current position\n    const [swimlane] = this.state.swimlanes.splice(fromIndex, 1);\n\n    // Insert it at the new position\n    this.state.swimlanes.splice(toIndex, 0, swimlane);\n\n    // Update order properties for all swimlanes\n    this.state.swimlanes.forEach((lane, idx) => {\n      lane.order = idx;\n    });\n\n    return true;\n  }\n\n  /**\n   * Delete a swimlane by index\n   */\n  deleteSwimlane(index: number): boolean {\n    if (index < 0 || index >= this.state.swimlanes.length) {\n      return false;\n    }\n\n    // Check if the swimlane has nodes\n    if (this.state.swimlanes[index].nodes?.length) {\n      console.error('Cannot delete swimlane with nodes');\n      return false;\n    }\n\n    // Remove the swimlane\n    this.state.swimlanes.splice(index, 1);\n\n    // Update order properties for all swimlanes\n    this.state.swimlanes.forEach((lane, idx) => {\n      lane.order = idx;\n    });\n\n    return true;\n  }\n\n  /**\n   * Get all swimlanes\n   */\n  getSwimlanes(): SwimlaneItem[] {\n    return this.state.swimlanes;\n  }\n\n  /**\n   * Get swimlane by index\n   */\n  getSwimlane(index: number): SwimlaneItem | null {\n    if (index < 0 || index >= this.state.swimlanes.length) {\n      return null;\n    }\n    return this.state.swimlanes[index];\n  }\n\n  /**\n   * Calculate total canvas height needed for all swimlanes\n   */\n  calculateCanvasHeight(minHeight: number = 2000): number {\n    const requiredHeight =\n      (this.state.swimlanes.length + 1) * this.swimlaneHeight;\n    return Math.max(minHeight, requiredHeight);\n  }\n\n  /**\n   * Check if a Y position is within any swimlane\n   */\n  isPositionInsideSwimlane(y: number): boolean {\n    // Check if y position is within any swimlane\n    const swimlaneCount = this.state.swimlanes.length;\n    if (swimlaneCount === 0) return false;\n\n    // Each swimlane has a height of 263px\n    const totalSwimlaneHeight = swimlaneCount * this.swimlaneHeight;\n\n    // Check if y is within the total height of all swimlanes\n    return y >= 0 && y < totalSwimlaneHeight;\n  }\n\n  /**\n   * Calculate swimlane index from Y position\n   */\n  getSwimlaneIndexFromPosition(y: number): number {\n    if (!this.isPositionInsideSwimlane(y)) return -1;\n    return Math.floor(y / this.swimlaneHeight);\n  }\n\n  /**\n   * Find swimlane index by Lane ID\n   */\n  findSwimlaneIndexByLaneId(laneId: string): number {\n    // In a real implementation, you would maintain a mapping between API lane IDs and UI swimlane indices\n    // For now we'll just return the index based on position\n    const parts = laneId.split('-');\n    if (parts.length > 1) {\n      const index = parseInt(parts[1]);\n      if (!isNaN(index) && index < this.state.swimlanes.length) {\n        return index;\n      }\n    }\n    return -1;\n  }\n}\n"]}

package/esm2022/lib/components/workflow-designer/services/transformer.service.mjs

@@ -0,0 +1,260 @@
+import { Injectable } from '@angular/core';
+import { ObjectState } from '../../../models/object-state';
+import { Status } from '../../../models/status';
+import { TaskAssignmentType } from '../../../models/TaskAssignmentType';
+import { StageActorRule } from '../../../models/StageActorRule';
+import * as i0 from "@angular/core";
+import * as i1 from "../workflow-designer.state";
+import * as i2 from "./swimlane.service";
+import * as i3 from "./node-management.service";
+import * as i4 from "./connection.service";
+export class TransformerService {
+    state;
+    swimlaneService;
+    nodeService;
+    connectionService;
+    // Map to track loaded objects
+    loadedObjectIds = {}; // Format: { id: code }
+    constructor(state, swimlaneService, nodeService, connectionService) {
+        this.state = state;
+        this.swimlaneService = swimlaneService;
+        this.nodeService = nodeService;
+        this.connectionService = connectionService;
+    }
+    /**
+     * Transform the UI model to a Workflow API model
+     */
+    transformToWorkflowModel() {
+        // Create base workflow object
+        const workflow = {
+            // BaseModel properties
+            Id: this.wasLoadedFromApi(this.state.workflowId || '')
+                ? this.state.workflowId || ''
+                : '',
+            Code: this.getCodeForObject(this.state.workflowId || ''),
+            TenantId: '',
+            id: this.wasLoadedFromApi(this.state.workflowId || '')
+                ? this.state.workflowId || ''
+                : '',
+            ServiceName: '',
+            CreatedAt: new Date(),
+            UpdatedAt: new Date(),
+            DataState: this.wasLoadedFromApi(this.state.workflowId || '')
+                ? ObjectState.Changed
+                : ObjectState.New,
+            // Workflow specific properties
+            Name: 'New Workflow', // Default name
+            Description: '', // Default description
+            StageEntryRule: '',
+            Form: this.state.workflowFormId || undefined,
+            AssignmentType: TaskAssignmentType.AutoRoute,
+            Operation: '',
+            Status: Status.Active,
+            Actions: [],
+            Lanes: [],
+            Stages: [],
+        };
+        // Transform swimlanes to SwimLane[]
+        workflow.Lanes = this.state.swimlanes.map((swimlane, index) => {
+            const laneId = `lane-${index}`;
+            return {
+                // BaseModel properties
+                Id: '',
+                Code: '',
+                TenantId: '',
+                id: laneId,
+                ServiceName: '',
+                CreatedAt: new Date(),
+                UpdatedAt: new Date(),
+                DataState: ObjectState.New,
+                // SwimLane specific properties
+                Workflow: workflow.Id,
+                Tags: swimlane.tags || [],
+                Position: swimlane.order,
+                Coordinates: { X: 0, Y: swimlane.order * 263 },
+                Size: { Width: 3000, Height: 263 },
+            };
+        });
+        // Transform nodes to WorkflowStage[]
+        const stages = [];
+        this.state.swimlanes.forEach((swimlane, swimlaneIndex) => {
+            swimlane.nodes?.forEach((node) => {
+                if (node.type === 'stage') {
+                    // Create a stage from the node
+                    const stage = {
+                        // BaseModel properties
+                        Id: node.id,
+                        Code: this.getCodeForObject(node.id),
+                        TenantId: '',
+                        id: node.id,
+                        ServiceName: '',
+                        CreatedAt: new Date(),
+                        UpdatedAt: new Date(),
+                        DataState: this.wasLoadedFromApi(node.id)
+                            ? ObjectState.Changed
+                            : ObjectState.New,
+                        // WorkflowStage specific properties
+                        Workflow: workflow.Id,
+                        Name: node.stageData?.Name || 'Unnamed Stage',
+                        Description: node.stageData?.Description || '',
+                        Duration: node.stageData?.Duration || 0,
+                        PassOnRule: node.stageData?.PassOnRule || '',
+                        ActorRule: node.stageData?.ActorRule || StageActorRule.None,
+                        MinNoOfActor: node.stageData?.MinNoOfActor || 0,
+                        IsParallel: node.stageData?.IsParallel || false,
+                        IsEntryPoint: node.isStartNode,
+                        IsExitPoint: false, // Will be updated below
+                        Tags: node.stageData?.Tags || [],
+                        Form: node.stageData?.formId ? node.stageData.formId : '',
+                        AllowMultiSubProcess: false,
+                        AssignmentType: TaskAssignmentType.AutoRoute,
+                        SubWorkFlow: '',
+                        SwimLane: workflow.Lanes[swimlaneIndex].Id,
+                        Coordinates: { X: node.x, Y: node.y },
+                        IsSubProcess: false,
+                        Key: node.stageData?.Key || undefined,
+                    };
+                    stages.push(stage);
+                }
+            });
+        });
+        // Determine which stages are exit points (no outgoing connections)
+        stages.forEach((stage) => {
+            const hasOutgoingConnections = this.state.connections.some((conn) => conn.sourceNodeId === stage.Id);
+            if (!hasOutgoingConnections) {
+                stage.IsExitPoint = true;
+            }
+        });
+        // Transform connections to WorkflowAction[]
+        workflow.Actions = this.state.connections.map((conn) => {
+            const sourceNode = this.nodeService.findNodeById(conn.sourceNodeId)?.node;
+            const targetNode = this.nodeService.findNodeById(conn.targetNodeId)?.node;
+            return {
+                // BaseModel properties
+                Id: conn.id,
+                Code: this.getCodeForObject(conn.id),
+                TenantId: '',
+                id: conn.id,
+                ServiceName: '',
+                CreatedAt: new Date(),
+                UpdatedAt: new Date(),
+                DataState: this.wasLoadedFromApi(conn.id)
+                    ? ObjectState.Changed
+                    : ObjectState.New,
+                // WorkflowAction specific properties
+                Workflow: workflow.Id,
+                Name: `Action from ${sourceNode?.stageData?.Name || 'Unknown'} to ${targetNode?.stageData?.Name || 'Unknown'}`,
+                FromStage: conn.sourceNodeId,
+                ToStage: conn.targetNodeId,
+                IsParallel: sourceNode?.stageData?.hasParallel || false,
+                PassOnRule: '', // Optional property
+            };
+        });
+        workflow.Stages = stages;
+        return workflow;
+    }
+    /**
+     * Parse API workflow model and convert to UI model
+     */
+    parseWorkflowData(workflow) {
+        // Clear existing state
+        this.state.swimlanes = [];
+        this.state.connections = [];
+        // Set workflow form if exists
+        if (workflow.Form) {
+            this.state.setWorkflowForm(workflow.Form, workflow.FormName || 'Workflow Form');
+        }
+        // Store the workflow ID
+        this.state.setWorkflowId(workflow.Id);
+        // Register the workflow itself
+        this.registerLoadedObject(workflow.Id, workflow.Code);
+        // Process swimlanes first
+        if (workflow.Lanes && workflow.Lanes.length) {
+            workflow.Lanes.sort((a, b) => a.Position - b.Position).forEach((lane) => {
+                this.swimlaneService.addSwimlane(lane.Name || `Lane ${lane.Position}`, lane.Tags || []);
+                // Register loaded lane
+                this.registerLoadedObject(lane.Id, lane.Code);
+            });
+        }
+        // Process stages
+        if (workflow.Stages && workflow.Stages.length) {
+            workflow.Stages.forEach((stage) => {
+                // Find swimlane index
+                const swimlaneIndex = this.swimlaneService.findSwimlaneIndexByLaneId(stage.SwimLane);
+                if (swimlaneIndex !== -1) {
+                    const x = stage.Coordinates?.X || 100;
+                    const y = stage.Coordinates?.Y || 50;
+                    this.nodeService.addNode(swimlaneIndex, 'stage', x, y, {
+                        Name: stage.Name,
+                        Description: stage.Description,
+                        Duration: stage.Duration,
+                        PassOnRule: stage.PassOnRule,
+                        ActorRule: stage.ActorRule,
+                        MinNoOfActor: stage.MinNoOfActor,
+                        Tags: stage.Tags || [],
+                        IsParallel: stage.IsParallel,
+                        IsEntryPoint: stage.IsEntryPoint,
+                        IsExitPoint: stage.IsExitPoint,
+                        Id: stage.Id,
+                    });
+                    // Register loaded stage
+                    this.registerLoadedObject(stage.Id, stage.Code);
+                }
+            });
+        }
+        // Process connections/actions
+        if (workflow.Actions && workflow.Actions.length) {
+            workflow.Actions.forEach((action) => {
+                // Find source and target nodes
+                const sourceNodeInfo = this.nodeService.findNodeById(action.FromStage);
+                const targetNodeInfo = this.nodeService.findNodeById(action.ToStage);
+                if (sourceNodeInfo && targetNodeInfo) {
+                    // Find suitable connection points
+                    const sourcePoint = sourceNodeInfo.node.connectionPoints?.[0];
+                    const targetPoint = targetNodeInfo.node.connectionPoints?.[0];
+                    if (sourcePoint && targetPoint) {
+                        const connection = {
+                            id: action.Id,
+                            sourceNodeId: action.FromStage,
+                            targetNodeId: action.ToStage,
+                            sourcePointId: sourcePoint.id,
+                            targetPointId: targetPoint.id,
+                            sourceSwimlaneIndex: sourceNodeInfo.swimlaneIndex,
+                            targetSwimlaneIndex: targetNodeInfo.swimlaneIndex,
+                        };
+                        this.state.connections.push(connection);
+                        // Register loaded action
+                        this.registerLoadedObject(action.Id, action.Code);
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Register a loaded object from the API
+     */
+    registerLoadedObject(id, code) {
+        this.loadedObjectIds[id] = code;
+    }
+    /**
+     * Check if an object was loaded from API
+     */
+    wasLoadedFromApi(id) {
+        return id in this.loadedObjectIds;
+    }
+    /**
+     * Get the code for a loaded object
+     */
+    getCodeForObject(id) {
+        return this.loadedObjectIds[id] || '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TransformerService, deps: [{ token: i1.WorkflowDesignerState }, { token: i2.SwimlaneService }, { token: i3.NodeManagementService }, { token: i4.ConnectionService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TransformerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TransformerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.WorkflowDesignerState }, { type: i2.SwimlaneService }, { type: i3.NodeManagementService }, { type: i4.ConnectionService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transformer.service.js","sourceRoot":"","sources":["../../../../../../../projects/verben-workflow-ui/src/lib/components/workflow-designer/services/transformer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { WorkflowDesignerState } from '../workflow-designer.state';\nimport { Workflow } from '../../../models/Workflow';\nimport { WorkflowStage } from '../../../models/WorkflowStage';\nimport { ObjectState } from '../../../models/object-state';\nimport { Status } from '../../../models/status';\nimport { TaskAssignmentType } from '../../../models/TaskAssignmentType';\nimport { StageActorRule } from '../../../models/StageActorRule';\nimport { SwimlaneService } from './swimlane.service';\nimport { NodeManagementService } from './node-management.service';\nimport { ConnectionService } from './connection.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TransformerService {\n  // Map to track loaded objects\n  private loadedObjectIds: { [key: string]: string } = {}; // Format: { id: code }\n\n  constructor(\n    private state: WorkflowDesignerState,\n    private swimlaneService: SwimlaneService,\n    private nodeService: NodeManagementService,\n    private connectionService: ConnectionService\n  ) {}\n\n  /**\n   * Transform the UI model to a Workflow API model\n   */\n  transformToWorkflowModel(): Workflow {\n    // Create base workflow object\n    const workflow: Workflow = {\n      // BaseModel properties\n      Id: this.wasLoadedFromApi(this.state.workflowId || '')\n        ? this.state.workflowId || ''\n        : '',\n      Code: this.getCodeForObject(this.state.workflowId || ''),\n      TenantId: '',\n      id: this.wasLoadedFromApi(this.state.workflowId || '')\n        ? this.state.workflowId || ''\n        : '',\n      ServiceName: '',\n      CreatedAt: new Date(),\n      UpdatedAt: new Date(),\n      DataState: this.wasLoadedFromApi(this.state.workflowId || '')\n        ? ObjectState.Changed\n        : ObjectState.New,\n\n      // Workflow specific properties\n      Name: 'New Workflow', // Default name\n      Description: '', // Default description\n      StageEntryRule: '',\n      Form: this.state.workflowFormId || undefined,\n      AssignmentType: TaskAssignmentType.AutoRoute,\n      Operation: '',\n      Status: Status.Active,\n      Actions: [],\n      Lanes: [],\n      Stages: [],\n    };\n\n    // Transform swimlanes to SwimLane[]\n    workflow.Lanes = this.state.swimlanes.map((swimlane, index) => {\n      const laneId = `lane-${index}`;\n\n      return {\n        // BaseModel properties\n        Id: '',\n        Code: '',\n        TenantId: '',\n        id: laneId,\n        ServiceName: '',\n        CreatedAt: new Date(),\n        UpdatedAt: new Date(),\n        DataState: ObjectState.New,\n\n        // SwimLane specific properties\n        Workflow: workflow.Id,\n        Tags: swimlane.tags || [],\n        Position: swimlane.order,\n        Coordinates: { X: 0, Y: swimlane.order * 263 },\n        Size: { Width: 3000, Height: 263 },\n      };\n    });\n\n    // Transform nodes to WorkflowStage[]\n    const stages: WorkflowStage[] = [];\n\n    this.state.swimlanes.forEach((swimlane, swimlaneIndex) => {\n      swimlane.nodes?.forEach((node) => {\n        if (node.type === 'stage') {\n          // Create a stage from the node\n          const stage: WorkflowStage = {\n            // BaseModel properties\n            Id: node.id,\n            Code: this.getCodeForObject(node.id),\n            TenantId: '',\n            id: node.id,\n            ServiceName: '',\n            CreatedAt: new Date(),\n            UpdatedAt: new Date(),\n            DataState: this.wasLoadedFromApi(node.id)\n              ? ObjectState.Changed\n              : ObjectState.New,\n\n            // WorkflowStage specific properties\n            Workflow: workflow.Id,\n            Name: node.stageData?.Name || 'Unnamed Stage',\n            Description: node.stageData?.Description || '',\n            Duration: node.stageData?.Duration || 0,\n            PassOnRule: node.stageData?.PassOnRule || '',\n            ActorRule: node.stageData?.ActorRule || StageActorRule.None,\n            MinNoOfActor: node.stageData?.MinNoOfActor || 0,\n            IsParallel: node.stageData?.IsParallel || false,\n            IsEntryPoint: node.isStartNode,\n            IsExitPoint: false, // Will be updated below\n            Tags: node.stageData?.Tags || [],\n            Form: node.stageData?.formId ? node.stageData.formId : '',\n            AllowMultiSubProcess: false,\n            AssignmentType: TaskAssignmentType.AutoRoute,\n            SubWorkFlow: '',\n            SwimLane: workflow.Lanes[swimlaneIndex].Id,\n            Coordinates: { X: node.x, Y: node.y },\n            IsSubProcess: false,\n            Key: node.stageData?.Key || undefined,\n          };\n\n          stages.push(stage);\n        }\n      });\n    });\n\n    // Determine which stages are exit points (no outgoing connections)\n    stages.forEach((stage) => {\n      const hasOutgoingConnections = this.state.connections.some(\n        (conn) => conn.sourceNodeId === stage.Id\n      );\n      if (!hasOutgoingConnections) {\n        stage.IsExitPoint = true;\n      }\n    });\n\n    // Transform connections to WorkflowAction[]\n    workflow.Actions = this.state.connections.map((conn) => {\n      const sourceNode = this.nodeService.findNodeById(conn.sourceNodeId)?.node;\n      const targetNode = this.nodeService.findNodeById(conn.targetNodeId)?.node;\n\n      return {\n        // BaseModel properties\n        Id: conn.id,\n        Code: this.getCodeForObject(conn.id),\n        TenantId: '',\n        id: conn.id,\n        ServiceName: '',\n        CreatedAt: new Date(),\n        UpdatedAt: new Date(),\n        DataState: this.wasLoadedFromApi(conn.id)\n          ? ObjectState.Changed\n          : ObjectState.New,\n\n        // WorkflowAction specific properties\n        Workflow: workflow.Id,\n        Name: `Action from ${sourceNode?.stageData?.Name || 'Unknown'} to ${\n          targetNode?.stageData?.Name || 'Unknown'\n        }`,\n        FromStage: conn.sourceNodeId,\n        ToStage: conn.targetNodeId,\n        IsParallel: sourceNode?.stageData?.hasParallel || false,\n        PassOnRule: '', // Optional property\n      };\n    });\n\n    workflow.Stages = stages;\n\n    return workflow;\n  }\n\n  /**\n   * Parse API workflow model and convert to UI model\n   */\n  parseWorkflowData(workflow: Workflow): void {\n    // Clear existing state\n    this.state.swimlanes = [];\n    this.state.connections = [];\n\n    // Set workflow form if exists\n    if (workflow.Form) {\n      this.state.setWorkflowForm(\n        workflow.Form,\n        workflow.FormName || 'Workflow Form'\n      );\n    }\n\n    // Store the workflow ID\n    this.state.setWorkflowId(workflow.Id);\n\n    // Register the workflow itself\n    this.registerLoadedObject(workflow.Id, workflow.Code);\n\n    // Process swimlanes first\n    if (workflow.Lanes && workflow.Lanes.length) {\n      workflow.Lanes.sort((a: any, b: any) => a.Position - b.Position).forEach(\n        (lane: any) => {\n          this.swimlaneService.addSwimlane(\n            lane.Name || `Lane ${lane.Position}`,\n            lane.Tags || []\n          );\n\n          // Register loaded lane\n          this.registerLoadedObject(lane.Id, lane.Code);\n        }\n      );\n    }\n\n    // Process stages\n    if (workflow.Stages && workflow.Stages.length) {\n      workflow.Stages.forEach((stage: any) => {\n        // Find swimlane index\n        const swimlaneIndex = this.swimlaneService.findSwimlaneIndexByLaneId(\n          stage.SwimLane\n        );\n        if (swimlaneIndex !== -1) {\n          const x = stage.Coordinates?.X || 100;\n          const y = stage.Coordinates?.Y || 50;\n\n          this.nodeService.addNode(swimlaneIndex, 'stage', x, y, {\n            Name: stage.Name,\n            Description: stage.Description,\n            Duration: stage.Duration,\n            PassOnRule: stage.PassOnRule,\n            ActorRule: stage.ActorRule,\n            MinNoOfActor: stage.MinNoOfActor,\n            Tags: stage.Tags || [],\n            IsParallel: stage.IsParallel,\n            IsEntryPoint: stage.IsEntryPoint,\n            IsExitPoint: stage.IsExitPoint,\n            Id: stage.Id,\n          });\n\n          // Register loaded stage\n          this.registerLoadedObject(stage.Id, stage.Code);\n        }\n      });\n    }\n\n    // Process connections/actions\n    if (workflow.Actions && workflow.Actions.length) {\n      workflow.Actions.forEach((action: any) => {\n        // Find source and target nodes\n        const sourceNodeInfo = this.nodeService.findNodeById(action.FromStage);\n        const targetNodeInfo = this.nodeService.findNodeById(action.ToStage);\n\n        if (sourceNodeInfo && targetNodeInfo) {\n          // Find suitable connection points\n          const sourcePoint = sourceNodeInfo.node.connectionPoints?.[0];\n          const targetPoint = targetNodeInfo.node.connectionPoints?.[0];\n\n          if (sourcePoint && targetPoint) {\n            const connection = {\n              id: action.Id,\n              sourceNodeId: action.FromStage,\n              targetNodeId: action.ToStage,\n              sourcePointId: sourcePoint.id,\n              targetPointId: targetPoint.id,\n              sourceSwimlaneIndex: sourceNodeInfo.swimlaneIndex,\n              targetSwimlaneIndex: targetNodeInfo.swimlaneIndex,\n            };\n            this.state.connections.push(connection);\n\n            // Register loaded action\n            this.registerLoadedObject(action.Id, action.Code);\n          }\n        }\n      });\n    }\n  }\n\n  /**\n   * Register a loaded object from the API\n   */\n  registerLoadedObject(id: string, code: string): void {\n    this.loadedObjectIds[id] = code;\n  }\n\n  /**\n   * Check if an object was loaded from API\n   */\n  wasLoadedFromApi(id: string): boolean {\n    return id in this.loadedObjectIds;\n  }\n\n  /**\n   * Get the code for a loaded object\n   */\n  getCodeForObject(id: string): string {\n    return this.loadedObjectIds[id] || '';\n  }\n}\n"]}