| | | 1 | | using Elsa.Extensions; |
| | | 2 | | using Elsa.Workflows.Activities.Flowchart.Contracts; |
| | | 3 | | using Elsa.Workflows.Activities.Flowchart.Extensions; |
| | | 4 | | using Elsa.Workflows.Activities.Flowchart.Models; |
| | | 5 | | using Elsa.Workflows.Options; |
| | | 6 | | using Elsa.Workflows.Signals; |
| | | 7 | | |
| | | 8 | | namespace Elsa.Workflows.Activities.Flowchart.Activities; |
| | | 9 | | |
| | | 10 | | public partial class Flowchart |
| | | 11 | | { |
| | | 12 | | private const string ScopeProperty = "FlowScope"; |
| | | 13 | | private const string GraphTransientProperty = "FlowGraph"; |
| | | 14 | | private const string BackwardConnectionActivityInput = "BackwardConnection"; |
| | | 15 | | |
| | | 16 | | |
| | | 17 | | private async ValueTask OnChildCompletedCounterBasedLogicAsync(ActivityCompletedContext context) |
| | | 18 | | { |
| | 136 | 19 | | var flowchartContext = context.TargetContext; |
| | 136 | 20 | | var completedActivityContext = context.ChildContext; |
| | 136 | 21 | | var completedActivity = completedActivityContext.Activity; |
| | 136 | 22 | | var result = context.Result; |
| | | 23 | | |
| | | 24 | | // Determine the outcomes from the completed activity |
| | 136 | 25 | | var outcomes = result is Outcomes o ? o : Outcomes.Default; |
| | | 26 | | |
| | 136 | 27 | | await ProcessChildCompletedAsync(flowchartContext, completedActivity, completedActivityContext, outcomes); |
| | 136 | 28 | | } |
| | | 29 | | |
| | | 30 | | private IActivity? GetStartActivity(ActivityExecutionContext context) |
| | | 31 | | { |
| | | 32 | | // If there's a trigger that triggered this workflow, use that. |
| | 734 | 33 | | var triggerActivityId = context.WorkflowExecutionContext.TriggerActivityId; |
| | 1344 | 34 | | var triggerActivity = triggerActivityId != null ? Activities.FirstOrDefault(x => x.Id == triggerActivityId) : nu |
| | | 35 | | |
| | 734 | 36 | | if (triggerActivity != null) |
| | 207 | 37 | | return triggerActivity; |
| | | 38 | | |
| | | 39 | | // If an explicit Start activity was provided, use that. |
| | 527 | 40 | | if (Start != null) |
| | 106 | 41 | | return Start; |
| | | 42 | | |
| | | 43 | | // If there is a Start activity on the flowchart, use that. |
| | 849 | 44 | | var startActivity = Activities.FirstOrDefault(x => x is Start); |
| | | 45 | | |
| | 421 | 46 | | if (startActivity != null) |
| | 2 | 47 | | return startActivity; |
| | | 48 | | |
| | | 49 | | // If there's an activity marked as "Can Start Workflow", use that. |
| | 845 | 50 | | var canStartWorkflowActivity = Activities.FirstOrDefault(x => x.GetCanStartWorkflow()); |
| | | 51 | | |
| | 419 | 52 | | if (canStartWorkflowActivity != null) |
| | 0 | 53 | | return canStartWorkflowActivity; |
| | | 54 | | |
| | | 55 | | // If there is a single activity that has no inbound connections, use that. |
| | 419 | 56 | | var root = GetRootActivity(); |
| | | 57 | | |
| | 419 | 58 | | if (root != null) |
| | 416 | 59 | | return root; |
| | | 60 | | |
| | | 61 | | // If no start activity found, return the first activity. |
| | 3 | 62 | | return Activities.FirstOrDefault(); |
| | | 63 | | } |
| | | 64 | | |
| | | 65 | | /// <summary> |
| | | 66 | | /// Checks if there is any pending work for the flowchart. |
| | | 67 | | /// </summary> |
| | | 68 | | private bool HasPendingWork(ActivityExecutionContext context) |
| | | 69 | | { |
| | 47 | 70 | | var workflowExecutionContext = context.WorkflowExecutionContext; |
| | | 71 | | |
| | | 72 | | // Use HashSet for O(1) lookups |
| | 301 | 73 | | var activityIds = new HashSet<string>(Activities.Select(x => x.Id)); |
| | | 74 | | |
| | | 75 | | // Short circuit evaluation - check running instances first before more expensive scheduler check |
| | 240 | 76 | | if (context.Children.Any(x => activityIds.Contains(x.Activity.Id) && x.Status == ActivityStatus.Running)) |
| | 1 | 77 | | return true; |
| | | 78 | | |
| | | 79 | | // Scheduler check - optimize to avoid repeated LINQ evaluations |
| | 46 | 80 | | var scheduledItems = workflowExecutionContext.Scheduler.List().ToList(); |
| | | 81 | | |
| | 46 | 82 | | return scheduledItems.Any(workItem => |
| | 46 | 83 | | { |
| | 13 | 84 | | var ownerInstanceId = workItem.Owner?.Id; |
| | 46 | 85 | | |
| | 13 | 86 | | if (ownerInstanceId == null) |
| | 0 | 87 | | return false; |
| | 46 | 88 | | |
| | 13 | 89 | | if (ownerInstanceId == context.Id) |
| | 13 | 90 | | return true; |
| | 46 | 91 | | |
| | 0 | 92 | | var ownerContext = workflowExecutionContext.ActivityExecutionContexts.First(x => x.Id == ownerInstanceId); |
| | 0 | 93 | | return ownerContext.GetAncestors().Any(x => x == context); |
| | 46 | 94 | | }); |
| | | 95 | | } |
| | | 96 | | |
| | | 97 | | private IActivity? GetRootActivity() |
| | | 98 | | { |
| | | 99 | | // Get the first activity that has no inbound connections. |
| | 419 | 100 | | var query = |
| | 419 | 101 | | from activity in Activities |
| | 426 | 102 | | let inboundConnections = Connections.Any(x => x.Target.Activity == activity) |
| | 416 | 103 | | where !inboundConnections |
| | 835 | 104 | | select activity; |
| | | 105 | | |
| | 419 | 106 | | var rootActivity = query.FirstOrDefault(); |
| | 419 | 107 | | return rootActivity; |
| | | 108 | | } |
| | | 109 | | |
| | | 110 | | private FlowGraph GetFlowGraph(ActivityExecutionContext context) |
| | | 111 | | { |
| | | 112 | | // Store in TransientProperties so FlowChart is not persisted in WorkflowState |
| | 176 | 113 | | return context.TransientProperties.GetOrAdd(GraphTransientProperty, () => new FlowGraph(Connections, GetStartAct |
| | | 114 | | } |
| | | 115 | | |
| | | 116 | | private FlowScope GetFlowScope(ActivityExecutionContext context) |
| | | 117 | | { |
| | 170 | 118 | | return context.GetProperty(ScopeProperty, () => new FlowScope()); |
| | | 119 | | } |
| | | 120 | | |
| | | 121 | | private async ValueTask ProcessChildCompletedAsync(ActivityExecutionContext flowchartContext, IActivity completedAct |
| | | 122 | | { |
| | 136 | 123 | | if (flowchartContext.Activity != this) |
| | | 124 | | { |
| | 0 | 125 | | throw new("Target context activity must be this flowchart"); |
| | | 126 | | } |
| | | 127 | | |
| | | 128 | | // If the completed activity's status is anything but "Completed", do not schedule its outbound activities. |
| | 136 | 129 | | if (completedActivityContext.Status != ActivityStatus.Completed) |
| | | 130 | | { |
| | 0 | 131 | | return; |
| | | 132 | | } |
| | | 133 | | |
| | | 134 | | // If the complete activity is a terminal node, complete the flowchart immediately. |
| | 136 | 135 | | if (completedActivity is ITerminalNode) |
| | | 136 | | { |
| | 1 | 137 | | await flowchartContext.CompleteActivityAsync(); |
| | 1 | 138 | | return; |
| | | 139 | | } |
| | | 140 | | |
| | | 141 | | // Schedule the outbound activities |
| | 135 | 142 | | var flowGraph = GetFlowGraph(flowchartContext); |
| | 135 | 143 | | var flowScope = GetFlowScope(flowchartContext); |
| | 135 | 144 | | var completedActivityExcecutedByBackwardConnection = completedActivityContext.ActivityInput.GetValueOrDefault<bo |
| | 135 | 145 | | bool hasScheduledActivity = await MaybeScheduleOutboundActivitiesAsync(flowGraph, flowScope, flowchartContext, c |
| | | 146 | | |
| | | 147 | | // If there are not any outbound connections, complete the flowchart activity if there is no other pending work |
| | 135 | 148 | | if (!hasScheduledActivity) |
| | | 149 | | { |
| | 46 | 150 | | await CompleteIfNoPendingWorkAsync(flowchartContext); |
| | | 151 | | } |
| | 136 | 152 | | } |
| | | 153 | | |
| | | 154 | | /// <summary> |
| | | 155 | | /// Schedules outbound activities based on the flowchart's structure and execution state. |
| | | 156 | | /// This method determines whether an activity should be scheduled based on visited connections, |
| | | 157 | | /// forward traversal rules, and backward connections. If outcomes is Outcomes.Empty, it indicates |
| | | 158 | | /// that the activity should be skipped - all outbound connections will be visited and treated as |
| | | 159 | | /// not followed. |
| | | 160 | | /// </summary> |
| | | 161 | | /// <param name="flowGraph">The graph representation of the flowchart.</param> |
| | | 162 | | /// <param name="flowScope">Tracks activity and connection visits.</param> |
| | | 163 | | /// <param name="flowchartContext">The execution context of the flowchart.</param> |
| | | 164 | | /// <param name="activity">The current activity being processed.</param> |
| | | 165 | | /// <param name="completedActivityContext">The execution context of the completed activity (for call stack tracking) |
| | | 166 | | /// <param name="outcomes">The outcomes that determine which connections were followed.</param> |
| | | 167 | | /// <param name="completionCallback">The callback to invoke upon activity completion.</param> |
| | | 168 | | /// <param name="completedActivityExecutedByBackwardConnection">Indicates if the completed activity |
| | | 169 | | /// was executed due to a backward connection.</param> |
| | | 170 | | /// <returns>True if at least one activity was scheduled; otherwise, false.</returns> |
| | | 171 | | private static async ValueTask<bool> MaybeScheduleOutboundActivitiesAsync(FlowGraph flowGraph, FlowScope flowScope, |
| | | 172 | | { |
| | 152 | 173 | | bool hasScheduledActivity = false; |
| | | 174 | | |
| | | 175 | | // Check if the activity is dangling (i.e., it is not reachable from the flowchart graph) |
| | 152 | 176 | | if (flowGraph.IsDanglingActivity(activity)) |
| | | 177 | | { |
| | 0 | 178 | | throw new($"Activity {activity.Id} is not reachable from the flowchart graph. Unable to schedule it's outbou |
| | | 179 | | } |
| | | 180 | | |
| | | 181 | | // Register the activity as visited unless it was executed due to a backward connection |
| | 152 | 182 | | if (!completedActivityExecutedByBackwardConnection) |
| | | 183 | | { |
| | 152 | 184 | | flowScope.RegisterActivityVisit(activity); |
| | | 185 | | } |
| | | 186 | | |
| | | 187 | | // Process each outbound connection from the current activity |
| | 568 | 188 | | foreach (var outboundConnection in flowGraph.GetOutboundConnections(activity)) |
| | | 189 | | { |
| | 132 | 190 | | var connectionFollowed = outcomes.Names.Contains(outboundConnection.Source.Port); |
| | 132 | 191 | | flowScope.RegisterConnectionVisit(outboundConnection, connectionFollowed); |
| | 132 | 192 | | var outboundActivity = outboundConnection.Target.Activity; |
| | | 193 | | |
| | | 194 | | // Determine the scheduling strategy based on connection-type. |
| | 132 | 195 | | if (flowGraph.IsBackwardConnection(outboundConnection, out var backwardConnectionIsValid)) |
| | | 196 | | // Backward connections are scheduled differently |
| | 0 | 197 | | hasScheduledActivity |= await MaybeScheduleBackwardConnectionActivityAsync(flowGraph, flowchartContext, |
| | | 198 | | else |
| | 132 | 199 | | hasScheduledActivity |= await MaybeScheduleOutboundActivityAsync(flowGraph, flowScope, flowchartContext, |
| | | 200 | | } |
| | | 201 | | |
| | 152 | 202 | | return hasScheduledActivity; |
| | 152 | 203 | | } |
| | | 204 | | |
| | | 205 | | /// <summary> |
| | | 206 | | /// Schedules an outbound activity that originates from a backward connection. |
| | | 207 | | /// </summary> |
| | | 208 | | private static async ValueTask<bool> MaybeScheduleBackwardConnectionActivityAsync(FlowGraph flowGraph, ActivityExecu |
| | | 209 | | { |
| | 0 | 210 | | if (!connectionFollowed) |
| | | 211 | | { |
| | 0 | 212 | | return false; |
| | | 213 | | } |
| | | 214 | | |
| | 0 | 215 | | if (!backwardConnectionIsValid) |
| | | 216 | | { |
| | 0 | 217 | | throw new($"Invalid backward connection: Every path from the source ('{outboundConnection.Source.Activity.Id |
| | | 218 | | } |
| | | 219 | | |
| | 0 | 220 | | var scheduleWorkOptions = new ScheduleWorkOptions |
| | 0 | 221 | | { |
| | 0 | 222 | | CompletionCallback = completionCallback, |
| | 0 | 223 | | Input = new Dictionary<string, object>() { { BackwardConnectionActivityInput, true } }, |
| | 0 | 224 | | SchedulingActivityExecutionId = completedActivityContext?.Id |
| | 0 | 225 | | }; |
| | | 226 | | |
| | 0 | 227 | | await flowchartContext.ScheduleActivityAsync(outboundActivity, scheduleWorkOptions); |
| | 0 | 228 | | return true; |
| | 0 | 229 | | } |
| | | 230 | | |
| | | 231 | | /// <summary> |
| | | 232 | | /// Determines the merge mode for a given outbound activity. If the outbound activity is a FlowJoin, it retrieves it |
| | | 233 | | /// mode. Otherwise, it defaults to FlowJoinMode.WaitAllActive for implicit joins. |
| | | 234 | | /// </summary> |
| | | 235 | | private static async ValueTask<FlowJoinMode> GetMergeModeAsync(ActivityExecutionContext flowchartContext, IActivity |
| | | 236 | | { |
| | 132 | 237 | | if (outboundActivity is FlowJoin) |
| | | 238 | | { |
| | 26 | 239 | | var outboundActivityExecutionContext = await flowchartContext.WorkflowExecutionContext.CreateActivityExecuti |
| | 26 | 240 | | return await outboundActivityExecutionContext.EvaluateInputPropertyAsync<FlowJoin, FlowJoinMode>(x => x.Mode |
| | | 241 | | } |
| | | 242 | | else |
| | | 243 | | { |
| | | 244 | | // Implicit join case - treat as WaitAllActive |
| | 106 | 245 | | return FlowJoinMode.WaitAllActive; |
| | | 246 | | } |
| | 132 | 247 | | } |
| | | 248 | | |
| | | 249 | | /// <summary> |
| | | 250 | | /// Schedules a join activity based on inbound connection statuses. |
| | | 251 | | /// </summary> |
| | | 252 | | private static async ValueTask<bool> MaybeScheduleOutboundActivityAsync(FlowGraph flowGraph, FlowScope flowScope, Ac |
| | | 253 | | { |
| | 132 | 254 | | FlowJoinMode mode = await GetMergeModeAsync(flowchartContext, outboundActivity); |
| | | 255 | | |
| | 132 | 256 | | return mode switch |
| | 132 | 257 | | { |
| | 15 | 258 | | FlowJoinMode.WaitAll => await MaybeScheduleWaitAllActivityAsync(flowGraph, flowScope, flowchartContext, comp |
| | 106 | 259 | | FlowJoinMode.WaitAllActive => await MaybeScheduleWaitAllActiveActivityAsync(flowGraph, flowScope, flowchartC |
| | 11 | 260 | | FlowJoinMode.WaitAny => await MaybeScheduleWaitAnyActivityAsync(flowGraph, flowScope, flowchartContext, comp |
| | 0 | 261 | | _ => throw new($"Unsupported FlowJoinMode: {mode}"), |
| | 132 | 262 | | }; |
| | 132 | 263 | | } |
| | | 264 | | |
| | | 265 | | /// <summary> |
| | | 266 | | /// Determines whether to schedule an activity based on the FlowJoinMode.WaitAll behavior. |
| | | 267 | | /// If all inbound connections were visited, it checks if they were all followed to decide whether to schedule or sk |
| | | 268 | | /// </summary> |
| | | 269 | | private static async ValueTask<bool> MaybeScheduleWaitAllActivityAsync(FlowGraph flowGraph, FlowScope flowScope, Act |
| | | 270 | | { |
| | 15 | 271 | | if (!flowScope.AllInboundConnectionsVisited(flowGraph, outboundActivity)) |
| | | 272 | | // Not all inbound connections have been visited yet; do not schedule anything yet. |
| | 7 | 273 | | return false; |
| | | 274 | | |
| | 8 | 275 | | if (flowScope.AllInboundConnectionsFollowed(flowGraph, outboundActivity)) |
| | | 276 | | // All inbound connections were followed; schedule the outbound activity. |
| | 8 | 277 | | return await ScheduleOutboundActivityAsync(flowchartContext, completedActivityContext, outboundActivity, com |
| | | 278 | | else |
| | | 279 | | // No inbound connections were followed; skip the outbound activity. |
| | 0 | 280 | | return await SkipOutboundActivityAsync(flowGraph, flowScope, flowchartContext, completedActivityContext, out |
| | 15 | 281 | | } |
| | | 282 | | |
| | | 283 | | /// <summary> |
| | | 284 | | /// Determines whether to schedule an activity based on the FlowJoinMode.WaitAllActive behavior. |
| | | 285 | | /// If all inbound connections have been visited, it checks if any were followed to decide whether to schedule or sk |
| | | 286 | | /// </summary> |
| | | 287 | | private static async ValueTask<bool> MaybeScheduleWaitAllActiveActivityAsync(FlowGraph flowGraph, FlowScope flowScop |
| | | 288 | | { |
| | 106 | 289 | | if (!flowScope.AllInboundConnectionsVisited(flowGraph, outboundActivity)) |
| | | 290 | | // Not all inbound connections have been visited yet; do not schedule anything yet. |
| | 2 | 291 | | return false; |
| | | 292 | | |
| | 104 | 293 | | if (flowScope.AnyInboundConnectionsFollowed(flowGraph, outboundActivity)) |
| | | 294 | | // At least one inbound connection was followed; schedule the outbound activity. |
| | 88 | 295 | | return await ScheduleOutboundActivityAsync(flowchartContext, completedActivityContext, outboundActivity, com |
| | | 296 | | else |
| | | 297 | | // No inbound connections were followed; skip the outbound activity. |
| | 16 | 298 | | return await SkipOutboundActivityAsync(flowGraph, flowScope, flowchartContext, completedActivityContext, out |
| | 106 | 299 | | } |
| | | 300 | | |
| | | 301 | | /// <summary> |
| | | 302 | | /// Determines whether to schedule an activity based on the FlowJoinMode.WaitAny behavior. |
| | | 303 | | /// If any inbound connection has been followed, it schedules the activity and cancels remaining inbound activities. |
| | | 304 | | /// If a subsequent inbound connection is followed after the activity has been scheduled, it ignores it. |
| | | 305 | | /// </summary> |
| | | 306 | | private static async ValueTask<bool> MaybeScheduleWaitAnyActivityAsync(FlowGraph flowGraph, FlowScope flowScope, Act |
| | | 307 | | { |
| | 11 | 308 | | if (flowScope.ShouldIgnoreConnection(outboundConnection, outboundActivity)) |
| | | 309 | | // Ignore the connection if the outbound activity has already completed (JoinAny scenario) |
| | 0 | 310 | | return false; |
| | | 311 | | |
| | 20 | 312 | | if (flowchartContext.WorkflowExecutionContext.Scheduler.List().Any(workItem => workItem.Owner == flowchartContex |
| | | 313 | | // Ignore the connection if the outbound activity is already scheduled |
| | 4 | 314 | | return false; |
| | | 315 | | |
| | 7 | 316 | | if (flowScope.AnyInboundConnectionsFollowed(flowGraph, outboundActivity)) |
| | | 317 | | { |
| | | 318 | | // This is the first inbound connection followed; schedule the outbound activity |
| | 7 | 319 | | var scheduleResponse = await ScheduleOutboundActivityAsync(flowchartContext, completedActivityContext, outbo |
| | | 320 | | // An inbound connection has been followed; cancel remaining inbound activities |
| | 7 | 321 | | await CancelRemainingInboundActivitiesAsync(flowchartContext, outboundActivity); |
| | | 322 | | |
| | 7 | 323 | | return scheduleResponse; |
| | | 324 | | } |
| | | 325 | | |
| | 0 | 326 | | if (flowScope.AllInboundConnectionsVisited(flowGraph, outboundActivity)) |
| | | 327 | | // All inbound connections have been visited without any being followed; skip the outbound activity |
| | 0 | 328 | | return await SkipOutboundActivityAsync(flowGraph, flowScope, flowchartContext, completedActivityContext, out |
| | | 329 | | |
| | | 330 | | // No inbound connections have been followed yet; do not schedule anything yet. |
| | 0 | 331 | | return false; |
| | 11 | 332 | | } |
| | | 333 | | |
| | | 334 | | /// <summary> |
| | | 335 | | /// Schedules the outbound activity. |
| | | 336 | | /// </summary> |
| | | 337 | | private static async ValueTask<bool> ScheduleOutboundActivityAsync(ActivityExecutionContext flowchartContext, Activi |
| | | 338 | | { |
| | 103 | 339 | | var options = new ScheduleWorkOptions |
| | 103 | 340 | | { |
| | 103 | 341 | | CompletionCallback = completionCallback, |
| | 103 | 342 | | SchedulingActivityExecutionId = completedActivityContext?.Id |
| | 103 | 343 | | }; |
| | 103 | 344 | | await flowchartContext.ScheduleActivityAsync(outboundActivity, options); |
| | 103 | 345 | | return true; |
| | 103 | 346 | | } |
| | | 347 | | |
| | | 348 | | /// <summary> |
| | | 349 | | /// Skips the outbound activity by propagating skipped connections. |
| | | 350 | | /// </summary> |
| | | 351 | | private static async ValueTask<bool> SkipOutboundActivityAsync(FlowGraph flowGraph, FlowScope flowScope, ActivityExe |
| | | 352 | | { |
| | 16 | 353 | | return await MaybeScheduleOutboundActivitiesAsync(flowGraph, flowScope, flowchartContext, outboundActivity, comp |
| | 16 | 354 | | } |
| | | 355 | | |
| | | 356 | | private static async ValueTask CancelRemainingInboundActivitiesAsync(ActivityExecutionContext flowchartContext, IAct |
| | | 357 | | { |
| | 7 | 358 | | var flowchart = (Flowchart)flowchartContext.Activity; |
| | 7 | 359 | | var flowGraph = flowchart.GetFlowGraph(flowchartContext); |
| | 7 | 360 | | var ancestorActivities = flowGraph.GetAncestorActivities(outboundActivity); |
| | 44 | 361 | | var inboundActivityExecutionContexts = flowchartContext.WorkflowExecutionContext.ActivityExecutionContexts.Where |
| | | 362 | | |
| | | 363 | | // Cancel each ancestor activity. |
| | 58 | 364 | | foreach (var activityExecutionContext in inboundActivityExecutionContexts) |
| | | 365 | | { |
| | 22 | 366 | | await activityExecutionContext.CancelActivityAsync(); |
| | | 367 | | } |
| | 7 | 368 | | } |
| | | 369 | | |
| | | 370 | | private async ValueTask OnScheduleOutcomesAsync(ScheduleActivityOutcomes signal, SignalContext context) |
| | | 371 | | { |
| | 0 | 372 | | var flowchartContext = context.ReceiverActivityExecutionContext; |
| | 0 | 373 | | var schedulingActivityContext = context.SenderActivityExecutionContext; |
| | 0 | 374 | | var schedulingActivity = schedulingActivityContext.Activity; |
| | 0 | 375 | | var outcomes = new Outcomes(signal.Outcomes); |
| | 0 | 376 | | } |
| | | 377 | | |
| | | 378 | | private async ValueTask OnCounterFlowActivityCanceledAsync(CancelSignal signal, SignalContext context) |
| | | 379 | | { |
| | 1 | 380 | | var flowchartContext = context.ReceiverActivityExecutionContext; |
| | 1 | 381 | | await CompleteIfNoPendingWorkAsync(flowchartContext); |
| | 1 | 382 | | var flowchart = (Flowchart)flowchartContext.Activity; |
| | 1 | 383 | | var flowGraph = flowchartContext.GetFlowGraph(); |
| | 1 | 384 | | var flowScope = flowchart.GetFlowScope(flowchartContext); |
| | | 385 | | |
| | | 386 | | // Propagate canceled connections visited count by scheduling with Outcomes.Empty |
| | 1 | 387 | | await MaybeScheduleOutboundActivitiesAsync(flowGraph, flowScope, flowchartContext, context.SenderActivityExecuti |
| | 1 | 388 | | } |
| | | 389 | | } |