Incremental work

src/designer/elsa-workflows-designer/src/components/activities/flowchart/activity-walker.ts

@@ -1,4 +1,5 @@
 import 'reflect-metadata';
+import {camelCase} from 'lodash';
 import {Container} from "typedi"
 import {Activity, ActivityDescriptor} from "../../../models";
 import {PortProviderRegistry} from "./port-provider-registry";
@@ -50,12 +51,12 @@ function walkRecursive(node: ActivityNode, activity: Activity, collectedActiviti
       collectedNodes.add(childNode);
     }
 
-    if(childNode !== node) {
+    if (childNode !== node) {
       childNode.parents.push(node);
       node.children.push(childNode);
       collectedActivities.add(port.activity);
+      walkRecursive(childNode, port.activity, collectedActivities, collectedNodes, descriptors);
     }
-    walkRecursive(childNode, port.activity, collectedActivities, collectedNodes, descriptors);
   }
 }
 
@@ -64,5 +65,22 @@ function getPorts(node: ActivityNode, activity: Activity, descriptors: Array<Act
   const portProvider = portProviderRegistry.get(activity.typeName);
   const activityDescriptor = descriptors.find(x => x.activityType == activity.typeName);
   const ports = portProvider.getOutboundPorts({activity, activityDescriptor});
-  return ports.map(x => ({ port: x.name, activity }));
+  let activityPorts: Array<ActivityPort> = [];
+
+  for (const port of ports) {
+    const propName = camelCase(port.name);
+    const value = activity[propName];
+
+    if (!value)
+      continue;
+
+    if (Array.isArray(value)) {
+      const activities = value as Array<Activity>;
+      activityPorts = [...activityPorts, ...activities.map(x => ({port: port.name, activity: x}))];
+    } else {
+      activityPorts.push({port: port.name, activity: value});
+    }
+  }
+
+  return activityPorts;
 }

src/designer/elsa-workflows-designer/src/components/activities/flowchart/flowchart-port-provider.ts

@@ -1,16 +0,0 @@
-import 'reflect-metadata';
-import {Service} from "typedi"
-import {Port} from "../../../models";
-import {PortProvider, PortProviderContext} from "./port-provider";
-
-@Service()
-export class FlowchartPortProvider implements PortProvider {
-  getInboundPorts(context: PortProviderContext): Array<Port> {
-    return [];
-  }
-
-  getOutboundPorts(context: PortProviderContext): Array<Port> {
-    return [];
-  }
-
-}

src/designer/elsa-workflows-designer/src/components/activities/flowchart/flowchart.tsx

@@ -199,9 +199,6 @@ export class FlowchartComponent implements ContainerActivityComponent {
     const activities = flowchart.activities;
     const connections = flowchart.connections;
 
-    // Clear inbound port for start activity.
-    const startActivity = activities.find(x => x.id === flowchart.start);
-
     let edges: Array<Edge.Metadata> = [];
 
     // Create an X6 node for each activity.

src/designer/elsa-workflows-designer/src/components/activities/flowchart/port-provider-registry.ts

@@ -2,7 +2,6 @@ import 'reflect-metadata';
 import {Container, Service} from "typedi";
 import {PortProvider} from "./port-provider";
 import {DefaultPortProvider} from "./default-port-provider";
-import {FlowchartPortProvider} from "./flowchart-port-provider";
 
 export type PortProviderFactory = () => PortProvider;
 
@@ -11,10 +10,6 @@ export class PortProviderRegistry {
   private map: Map<string, PortProviderFactory> = new Map<string, PortProviderFactory>();
   private defaultProviderFactory: PortProviderFactory = () => Container.get(DefaultPortProvider);
 
-  constructor() {
-    this.add('Elsa.Flowchart', () => Container.get(FlowchartPortProvider));
-  }
-
   public add(activityType: string, defaultProviderFactory: PortProviderFactory) {
     this.map.set(activityType, defaultProviderFactory);
   }