support for executing a sub-workflow added + test

kfrajtak · kfrajtak · commit 6c6eb4377d05 · 2025-06-16T20:08:15.000+02:00
diff --git a/src/WorkflowCore.Testing/WorkflowCore.Testing.csproj b/src/WorkflowCore.Testing/WorkflowCore.Testing.csproj
@@ -12,6 +12,7 @@
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="3.1.0" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="3.1.0" />
+    <PackageReference Include="xunit.abstractions" Version="2.0.3" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/WorkflowCore/Interface/IWorkflowModifier.cs b/src/WorkflowCore/Interface/IWorkflowModifier.cs
@@ -183,5 +183,15 @@ IStepBuilder<TData, Activity> Activity(string activityName, Expression<Func<TDat
     /// <returns></returns>
     IStepBuilder<TData, Activity> Activity(Expression<Func<TData, IStepExecutionContext, string>> activityName, Expression<Func<TData, object>> parameters = null,
         Expression<Func<TData, DateTime>> effectiveDate = null, Expression<Func<TData, bool>> cancelCondition = null);
+    
+    /// <summary>
+    /// Execute a sub-workflow
+    /// </summary>
+    /// <param name="subWorkflowId">Id of the sub-workflow to start</param>
+    /// <param name="parameters">The data to pass to the sub-workflow</param>
+    /// <param name="cancelCondition">A condition that when true will cancel this sub-workflow</param>
+    /// <returns></returns>
+    IStepBuilder<TData, SubWorkflowStepBody> SubWorkflow(string subWorkflowId, Expression<Func<TData, object>> parameters = null,
+        Expression<Func<TData, bool>> cancelCondition = null);
     }
 }
diff --git a/src/WorkflowCore/Models/ExecutionPointer.cs b/src/WorkflowCore/Models/ExecutionPointer.cs
@@ -51,6 +51,10 @@ public IReadOnlyCollection<string> Scope
             get => _scope;
             set => _scope = new List<string>(value);
         }
+
+        public bool IsComplete => Status == PointerStatus.Complete;
+        
+        public bool HasChildren => Children?.Count > 0;
     }
 
     public enum PointerStatus
diff --git a/src/WorkflowCore/Primitives/SubWorkflowStepBody.cs b/src/WorkflowCore/Primitives/SubWorkflowStepBody.cs
@@ -1,15 +1,57 @@
 ﻿using System;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using WorkflowCore.Interface;
 using WorkflowCore.Models;
+using WorkflowCore.Models.LifeCycleEvents;
 
 namespace WorkflowCore.Primitives
 {
     public class SubWorkflowStepBody : StepBody
     {
+        private readonly IScopeProvider _scopeProvider;
+
+        public SubWorkflowStepBody(IScopeProvider scopeProvider)
+        {
+            _scopeProvider = scopeProvider;
+        }
+
         public override ExecutionResult Run(IStepExecutionContext context)
         {
-            // TODO: What is this supposed to do?
-            throw new NotImplementedException();
+            var eventKey = context.ExecutionPointer.EventKey;
+
+            var scope = _scopeProvider.CreateScope(context);
+            var workflowController = scope.ServiceProvider.GetRequiredService<IWorkflowController>();
+            var logger = scope.ServiceProvider.GetRequiredService<ILoggerFactory>().CreateLogger(
+                typeof(SubWorkflowStepBody).Namespace + "." + nameof(SubWorkflowStepBody));
+            
+            if (!context.ExecutionPointer.EventPublished)
+            {
+                var result = workflowController.StartWorkflow(SubWorkflowId, context.Workflow.Data, context.Workflow.Id).Result;
+            
+                logger.LogDebug("Started sub workflow {Name} with id='{SubId}' from workflow {WorkflowDefinitionId} ({Id})", 
+                    SubWorkflowId, result, context.Workflow.WorkflowDefinitionId, context.Workflow.Id);
+
+                logger.LogDebug("Workflow {Name} ({SubId}) is waiting for event WorkflowCompleted with key='{EventKey}'", 
+                    SubWorkflowId, result, result);
+
+                var effectiveDate = DateTime.MinValue;
+                return ExecutionResult.WaitForEvent(nameof(WorkflowCompleted), result, effectiveDate);
+            }
+            
+            logger.LogDebug("Sub workflow {Name} ({SubId}) completed", SubWorkflowId, 
+                context.ExecutionPointer.EventKey);
+
+            var persistenceProvider = scope.ServiceProvider.GetRequiredService<IPersistenceProvider>();
+
+            Result = persistenceProvider.GetWorkflowInstance(context.ExecutionPointer.EventKey).Result.Data;
+            return ExecutionResult.Next();
         }
+
+        public string SubWorkflowId { get; set; }
+
+        public object Parameters { get; set; }
+
+        public object Result { get; set; }
     }
 }
diff --git a/src/WorkflowCore/Primitives/WaitFor.cs b/src/WorkflowCore/Primitives/WaitFor.cs
@@ -25,7 +25,8 @@ public override ExecutionResult Run(IStepExecutionContext context)
                     effectiveDate = EffectiveDate;
                 }
 
-                return ExecutionResult.WaitForEvent(EventName, EventKey, effectiveDate);
+                var eventKey = context.Workflow.Reference ?? EventKey;
+                return ExecutionResult.WaitForEvent(EventName, eventKey, effectiveDate);
             }
 
             EventData = context.ExecutionPointer.EventData;
diff --git a/src/WorkflowCore/ServiceCollectionExtensions.cs b/src/WorkflowCore/ServiceCollectionExtensions.cs
@@ -81,6 +81,7 @@ public static IServiceCollection AddWorkflow(this IServiceCollection services, A
             services.AddTransient<ISyncWorkflowRunner, SyncWorkflowRunner>();
 
             services.AddTransient<Foreach>();
+            services.AddTransient<SubWorkflowStepBody>();
 
             return services;
         }
diff --git a/src/WorkflowCore/Services/ExecutionResultProcessor.cs b/src/WorkflowCore/Services/ExecutionResultProcessor.cs
@@ -29,12 +29,16 @@ public ExecutionResultProcessor(IExecutionPointerFactory pointerFactory, IDateTi
 
         public void ProcessExecutionResult(WorkflowInstance workflow, WorkflowDefinition def, ExecutionPointer pointer, WorkflowStep step, ExecutionResult result, WorkflowExecutorResult workflowResult)
         {
+            var stepInfo = $"{step.Name ?? step.BodyType.Name} ({step.Id})";
+
             pointer.PersistenceData = result.PersistenceData;
             pointer.Outcome = result.OutcomeValue;
             if (result.SleepFor.HasValue)
             {
                 pointer.SleepUntil = _datetimeProvider.UtcNow.Add(result.SleepFor.Value);
                 pointer.Status = PointerStatus.Sleeping;
+                _logger.LogDebug("Step {StepName} on workflow {WorkflowDefinitionId} ({WorkflowId}) will sleep for {SleepUntil}",
+                    stepInfo, workflow.WorkflowDefinitionId, workflow.Id, result.SleepFor.Value);
             }
 
             if (!string.IsNullOrEmpty(result.EventName))
@@ -54,6 +58,9 @@ public void ProcessExecutionResult(WorkflowInstance workflow, WorkflowDefinition
                     SubscribeAsOf = result.EventAsOf,
                     SubscriptionData = result.SubscriptionData
                 });
+
+                _logger.LogDebug("Step {StepName} on workflow {WorkflowDefinitionId} ({WorkflowId}) waiting for event {EventName}",
+                    stepInfo, workflow.WorkflowDefinitionId, workflow.Id, pointer.EventName);
             }
 
             if (result.Proceed)
@@ -87,6 +94,9 @@ public void ProcessExecutionResult(WorkflowInstance workflow, WorkflowDefinition
                     WorkflowDefinitionId = workflow.WorkflowDefinitionId,
                     Version = workflow.Version
                 });
+
+                _logger.LogDebug("Step {StepName} on workflow {WorkflowDefinitionId} ({WorkflowId}) completed",
+                    stepInfo, workflow.WorkflowDefinitionId, workflow.Id);
             }
             else
             {
diff --git a/src/WorkflowCore/Services/FluentBuilders/StepBuilder.cs b/src/WorkflowCore/Services/FluentBuilders/StepBuilder.cs
@@ -588,5 +588,24 @@ public IStepBuilder<TData, Activity> Activity(Expression<Func<TData, IStepExecut
             Step.Outcomes.Add(new ValueOutcome { NextStep = newStep.Id });
             return stepBuilder;
         }
+
+        public IStepBuilder<TData, SubWorkflowStepBody> SubWorkflow(
+            string subWorkflowId, 
+            Expression<Func<TData, object>> parameters = null,
+            Expression<Func<TData, bool>> cancelCondition = null)
+        {
+            var newStep = new WorkflowStep<SubWorkflowStepBody>();
+            newStep.CancelCondition = cancelCondition;
+
+            WorkflowBuilder.AddStep(newStep);
+            var stepBuilder = new StepBuilder<TData, SubWorkflowStepBody>(WorkflowBuilder, newStep);
+            stepBuilder.Input((step) => step.SubWorkflowId, (data) => subWorkflowId);
+
+            if (parameters != null)
+                stepBuilder.Input((step) => step.Parameters, parameters);
+
+            Step.Outcomes.Add(new ValueOutcome { NextStep = newStep.Id });
+            return stepBuilder;
+        }
     }
 }
diff --git a/src/WorkflowCore/Services/FluentBuilders/WorkflowBuilder.cs b/src/WorkflowCore/Services/FluentBuilders/WorkflowBuilder.cs
@@ -296,10 +296,16 @@ public IStepBuilder<TData, Activity> Activity(string activityName, Expression<Fu
         {
             return Start().Activity(activityName, parameters, effectiveDate, cancelCondition);
         }
+        
         public IStepBuilder<TData, Activity> Activity(Expression<Func<TData, IStepExecutionContext, string>> activityName, Expression<Func<TData, object>> parameters = null, Expression<Func<TData, DateTime>> effectiveDate = null, Expression<Func<TData, bool>> cancelCondition = null)
         {
             return Start().Activity(activityName, parameters, effectiveDate, cancelCondition);
         }
+        
+        public IStepBuilder<TData, SubWorkflowStepBody> SubWorkflow(string subWorkflowId, Expression<Func<TData, object>> parameters = null, Expression<Func<TData, bool>> cancelCondition = null)
+        {
+            return Start().SubWorkflow(subWorkflowId, parameters, cancelCondition);
+        }
 
         private IStepBuilder<TData, InlineStepBody> Start()
         {
diff --git a/src/WorkflowCore/Services/WorkflowExecutor.cs b/src/WorkflowCore/Services/WorkflowExecutor.cs
@@ -156,9 +156,11 @@ private async Task ExecuteStep(WorkflowInstance workflow, WorkflowStep step, Exe
                 CancellationToken = cancellationToken
             };
 
+            var stepInfo = $"{step.Name ?? step.BodyType.Name} ({step.Id})";
+
             using (var scope = _scopeProvider.CreateScope(context))
             {
-                _logger.LogDebug("Starting step {StepName} on workflow {WorkflowId}", step.Name, workflow.Id);
+                _logger.LogDebug("Starting step {StepName} on workflow {WorkflowDefinitionId} ({WorkflowId})", stepInfo, workflow.WorkflowDefinitionId, workflow.Id);
 
                 IStepBody body = step.ConstructBody(scope.ServiceProvider);
                 var stepExecutor = scope.ServiceProvider.GetRequiredService<IStepExecutor>();
@@ -221,6 +223,7 @@ private async Task DetermineNextExecutionTime(WorkflowInstance workflow, Workflo
 
             if (workflow.Status == WorkflowStatus.Complete)
             {
+                await OnComplete(workflow, def);
                 return;
             }
 
@@ -236,7 +239,7 @@ private async Task DetermineNextExecutionTime(WorkflowInstance workflow, Workflo
                 workflow.NextExecution = Math.Min(pointerSleep, workflow.NextExecution ?? pointerSleep);
             }
 
-            foreach (var pointer in workflow.ExecutionPointers.Where(x => x.Active && (x.Children ?? new List<string>()).Count > 0))
+            foreach (var pointer in workflow.ExecutionPointers.Where(x => x.Active && x.HasChildren))
             {
                 if (!workflow.ExecutionPointers.FindByScope(pointer.Id).All(x => x.EndTime.HasValue))
                     continue;
@@ -256,6 +259,11 @@ private async Task DetermineNextExecutionTime(WorkflowInstance workflow, Workflo
                 return;
             }
 
+            await OnComplete(workflow, def);
+        }
+
+        private async Task OnComplete(WorkflowInstance workflow, WorkflowDefinition def)
+        {
             workflow.Status = WorkflowStatus.Complete;
             workflow.CompleteTime = _datetimeProvider.UtcNow;
 
@@ -264,6 +272,8 @@ private async Task DetermineNextExecutionTime(WorkflowInstance workflow, Workflo
                 var middlewareRunner = scope.ServiceProvider.GetRequiredService<IWorkflowMiddlewareRunner>();
                 await middlewareRunner.RunPostMiddleware(workflow, def);
             }
+            
+            _logger.LogDebug("Workflow {WorkflowDefinitionId} ({Id}) completed", workflow.WorkflowDefinitionId, workflow.Id);
 
             _publisher.PublishNotification(new WorkflowCompleted
             {
diff --git a/src/WorkflowCore/Services/WorkflowHost.cs b/src/WorkflowCore/Services/WorkflowHost.cs
@@ -165,6 +165,12 @@ public Task<bool> TerminateWorkflow(string workflowId)
 
         public void HandleLifeCycleEvent(LifeCycleEvent evt)
         {
+            if (evt is WorkflowCompleted completed)
+            {
+                _workflowController.PublishEvent(nameof(WorkflowCompleted), completed.WorkflowInstanceId,
+                    completed.Reference);
+            }
+            
             OnLifeCycleEvent?.Invoke(evt);
         }
 
diff --git a/test/WorkflowCore.IntegrationTests/Scenarios/ApprovalScenario.cs b/test/WorkflowCore.IntegrationTests/Scenarios/ApprovalScenario.cs
@@ -0,0 +1,118 @@
+using System;
+using FluentAssertions;
+using WorkflowCore.Interface;
+using WorkflowCore.Models;
+using WorkflowCore.Testing;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace WorkflowCore.IntegrationTests.Scenarios;
+
+public class ApprovalScenario : WorkflowTest<ApprovalScenario.ParentWorkflow, ApprovalScenario.ApprovalInput>
+{
+    public class ApprovalInput
+    {
+        public string Id { get; set; }
+        public bool Approved { get; set; }
+        public TimeSpan TimeSpan { get; set; }
+        public string Message { get; set; }
+    }
+
+    public class ParentWorkflow : IWorkflow<ApprovalInput>
+    {
+        public string Id => nameof(ParentWorkflow);
+
+        public int Version => 1;
+        
+        public void Build(IWorkflowBuilder<ApprovalInput> builder)
+        {
+            builder
+                .StartWith(context => ExecutionResult.Next())
+                .SubWorkflow(nameof(ChildWorkflow))
+                .Output(i => i.Approved, step => ((ApprovalInput)step.Result).Approved)
+                /*
+                 * this does throw an exception
+                 .If(data => data.Approved)
+                    .Do(then =>
+                        ExecutionResult.Outcome(1248))*/;
+        }
+    }
+    
+    public class ChildWorkflow : IWorkflow<ApprovalInput>
+    {
+        public string Id => nameof(ChildWorkflow);
+
+        public int Version => 1;
+
+        public void Build(IWorkflowBuilder<ApprovalInput> builder)
+        {
+            builder
+                .StartWith(context => ExecutionResult.Next())
+                .Parallel()
+                .Do(then
+                    => then
+                        .Delay(i => i.TimeSpan)
+                        .Output(i => i.Approved, step => false)
+                        .EndWorkflow()
+                )
+                .Do(then
+                    => then
+                        .WaitFor("Approved", e => e.Id)
+                        .Output(i => i.Approved, step => step.EventData) 
+                        .EndWorkflow()
+                )
+                .Join();
+        }
+    }
+
+    public ApprovalScenario()
+    {
+        Setup();
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void Scenario(bool approved)
+    {
+        Host.Registry.RegisterWorkflow(new ChildWorkflow());
+        
+        var eventKey = Guid.NewGuid().ToString();
+        var workflowId = StartWorkflow(new ApprovalInput
+        {
+            Id = eventKey, 
+            TimeSpan = TimeSpan.FromMinutes(10)
+        });
+        
+        WaitForEventSubscription("Approved", workflowId, TimeSpan.FromSeconds(5));
+        UnhandledStepErrors.Should().BeEmpty();
+
+        Host.PublishEvent("Approved", workflowId, approved);
+
+        WaitForWorkflowToComplete(workflowId, TimeSpan.FromSeconds(10));
+        
+        System.Threading.Thread.Sleep(2000);
+
+        UnhandledStepErrors.Should().BeEmpty();
+        GetStatus(workflowId).Should().Be(WorkflowStatus.Complete);
+        GetData(workflowId).Approved.Should().Be(approved);
+    }
+    
+    [Fact]
+    public void Timeout()
+    {
+        Host.Registry.RegisterWorkflow(new ChildWorkflow());
+        
+        var workflowId = StartWorkflow(new ApprovalInput
+        {
+            Id = Guid.NewGuid().ToString(),
+            TimeSpan = TimeSpan.FromSeconds(5)
+        });
+        WaitForEventSubscription("Approved", workflowId, TimeSpan.FromSeconds(2));
+        WaitForWorkflowToComplete(workflowId, TimeSpan.FromSeconds(10));
+
+        UnhandledStepErrors.Should().BeEmpty();
+        GetStatus(workflowId).Should().Be(WorkflowStatus.Complete);
+        GetData(workflowId).Approved.Should().BeFalse();
+    }
+}
diff --git a/test/WorkflowCore.Tests.SqlServer/Scenarios/SqlServerApprovalScenario.cs b/test/WorkflowCore.Tests.SqlServer/Scenarios/SqlServerApprovalScenario.cs
@@ -0,0 +1,16 @@
+﻿using Microsoft.Extensions.DependencyInjection;
+using WorkflowCore.IntegrationTests.Scenarios;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace WorkflowCore.Tests.SqlServer.Scenarios
+{
+    [Collection("SqlServer collection")]
+    public class SqlServerApprovalScenario() : ApprovalScenario()
+    {
+        protected override void ConfigureServices(IServiceCollection services)
+        {
+            services.AddWorkflow(x => x.UseSqlServer(SqlDockerSetup.ScenarioConnectionString, true, true));
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -51,6 +51,10 @@ public IReadOnlyCollection<string> Scope`
`51`	`51`	`get => _scope;`
`52`	`52`	`set => _scope = new List<string>(value);`
`53`	`53`	`}`
	`54`	`+`
	`55`	`+ public bool IsComplete => Status == PointerStatus.Complete;`
	`56`	`+`
	`57`	`+ public bool HasChildren => Children?.Count > 0;`
`54`	`58`	`}`
`55`	`59`
`56`	`60`	`public enum PointerStatus`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,8 @@ public override ExecutionResult Run(IStepExecutionContext context)`
`25`	`25`	`effectiveDate = EffectiveDate;`
`26`	`26`	`}`
`27`	`27`
`28`		`- return ExecutionResult.WaitForEvent(EventName, EventKey, effectiveDate);`
	`28`	`+ var eventKey = context.Workflow.Reference ?? EventKey;`
	`29`	`+ return ExecutionResult.WaitForEvent(EventName, eventKey, effectiveDate);`
`29`	`30`	`}`
`30`	`31`
`31`	`32`	`EventData = context.ExecutionPointer.EventData;`
Original file line number	Diff line number	Diff line change
`@@ -81,6 +81,7 @@ public static IServiceCollection AddWorkflow(this IServiceCollection services, A`
`81`	`81`	`services.AddTransient<ISyncWorkflowRunner, SyncWorkflowRunner>();`
`82`	`82`
`83`	`83`	`services.AddTransient<Foreach>();`
	`84`	`+ services.AddTransient<SubWorkflowStepBody>();`
`84`	`85`
`85`	`86`	`return services;`
`86`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,12 +29,16 @@ public ExecutionResultProcessor(IExecutionPointerFactory pointerFactory, IDateTi`
`29`	`29`
`30`	`30`	`public void ProcessExecutionResult(WorkflowInstance workflow, WorkflowDefinition def, ExecutionPointer pointer, WorkflowStep step, ExecutionResult result, WorkflowExecutorResult workflowResult)`
`31`	`31`	`{`
	`32`	`+ var stepInfo = $"{step.Name ?? step.BodyType.Name} ({step.Id})";`
	`33`	`+`
`32`	`34`	`pointer.PersistenceData = result.PersistenceData;`
`33`	`35`	`pointer.Outcome = result.OutcomeValue;`
`34`	`36`	`if (result.SleepFor.HasValue)`
`35`	`37`	`{`
`36`	`38`	`pointer.SleepUntil = _datetimeProvider.UtcNow.Add(result.SleepFor.Value);`
`37`	`39`	`pointer.Status = PointerStatus.Sleeping;`
	`40`	`+ _logger.LogDebug("Step {StepName} on workflow {WorkflowDefinitionId} ({WorkflowId}) will sleep for {SleepUntil}",`
	`41`	`+ stepInfo, workflow.WorkflowDefinitionId, workflow.Id, result.SleepFor.Value);`
`38`	`42`	`}`
`39`	`43`
`40`	`44`	`if (!string.IsNullOrEmpty(result.EventName))`
`@@ -54,6 +58,9 @@ public void ProcessExecutionResult(WorkflowInstance workflow, WorkflowDefinition`
`54`	`58`	`SubscribeAsOf = result.EventAsOf,`
`55`	`59`	`SubscriptionData = result.SubscriptionData`
`56`	`60`	`});`
	`61`	`+`
	`62`	`+ _logger.LogDebug("Step {StepName} on workflow {WorkflowDefinitionId} ({WorkflowId}) waiting for event {EventName}",`
	`63`	`+ stepInfo, workflow.WorkflowDefinitionId, workflow.Id, pointer.EventName);`
`57`	`64`	`}`
`58`	`65`
`59`	`66`	`if (result.Proceed)`
`@@ -87,6 +94,9 @@ public void ProcessExecutionResult(WorkflowInstance workflow, WorkflowDefinition`
`87`	`94`	`WorkflowDefinitionId = workflow.WorkflowDefinitionId,`
`88`	`95`	`Version = workflow.Version`
`89`	`96`	`});`
	`97`	`+`
	`98`	`+ _logger.LogDebug("Step {StepName} on workflow {WorkflowDefinitionId} ({WorkflowId}) completed",`
	`99`	`+ stepInfo, workflow.WorkflowDefinitionId, workflow.Id);`
`90`	`100`	`}`
`91`	`101`	`else`
`92`	`102`	`{`
Original file line number	Diff line number	Diff line change
`@@ -296,10 +296,16 @@ public IStepBuilder<TData, Activity> Activity(string activityName, Expression<Fu`
`296`	`296`	`{`
`297`	`297`	`return Start().Activity(activityName, parameters, effectiveDate, cancelCondition);`
`298`	`298`	`}`
	`299`	`+`
`299`	`300`	`public IStepBuilder<TData, Activity> Activity(Expression<Func<TData, IStepExecutionContext, string>> activityName, Expression<Func<TData, object>> parameters = null, Expression<Func<TData, DateTime>> effectiveDate = null, Expression<Func<TData, bool>> cancelCondition = null)`
`300`	`301`	`{`
`301`	`302`	`return Start().Activity(activityName, parameters, effectiveDate, cancelCondition);`
`302`	`303`	`}`
	`304`	`+`
	`305`	`+ public IStepBuilder<TData, SubWorkflowStepBody> SubWorkflow(string subWorkflowId, Expression<Func<TData, object>> parameters = null, Expression<Func<TData, bool>> cancelCondition = null)`
	`306`	`+ {`
	`307`	`+ return Start().SubWorkflow(subWorkflowId, parameters, cancelCondition);`
	`308`	`+ }`
`303`	`309`
`304`	`310`	`private IStepBuilder<TData, InlineStepBody> Start()`
`305`	`311`	`{`
Original file line number	Diff line number	Diff line change
`@@ -156,9 +156,11 @@ private async Task ExecuteStep(WorkflowInstance workflow, WorkflowStep step, Exe`
`156`	`156`	`CancellationToken = cancellationToken`
`157`	`157`	`};`
`158`	`158`
	`159`	`+ var stepInfo = $"{step.Name ?? step.BodyType.Name} ({step.Id})";`
	`160`	`+`
`159`	`161`	`using (var scope = _scopeProvider.CreateScope(context))`
`160`	`162`	`{`
`161`		`- _logger.LogDebug("Starting step {StepName} on workflow {WorkflowId}", step.Name, workflow.Id);`
	`163`	`+ _logger.LogDebug("Starting step {StepName} on workflow {WorkflowDefinitionId} ({WorkflowId})", stepInfo, workflow.WorkflowDefinitionId, workflow.Id);`
`162`	`164`
`163`	`165`	`IStepBody body = step.ConstructBody(scope.ServiceProvider);`
`164`	`166`	`var stepExecutor = scope.ServiceProvider.GetRequiredService<IStepExecutor>();`
`@@ -221,6 +223,7 @@ private async Task DetermineNextExecutionTime(WorkflowInstance workflow, Workflo`
`221`	`223`
`222`	`224`	`if (workflow.Status == WorkflowStatus.Complete)`
`223`	`225`	`{`
	`226`	`+ await OnComplete(workflow, def);`
`224`	`227`	`return;`
`225`	`228`	`}`
`226`	`229`
`@@ -236,7 +239,7 @@ private async Task DetermineNextExecutionTime(WorkflowInstance workflow, Workflo`
`236`	`239`	`workflow.NextExecution = Math.Min(pointerSleep, workflow.NextExecution ?? pointerSleep);`
`237`	`240`	`}`
`238`	`241`
`239`		`- foreach (var pointer in workflow.ExecutionPointers.Where(x => x.Active && (x.Children ?? new List<string>()).Count > 0))`
	`242`	`+ foreach (var pointer in workflow.ExecutionPointers.Where(x => x.Active && x.HasChildren))`
`240`	`243`	`{`
`241`	`244`	`if (!workflow.ExecutionPointers.FindByScope(pointer.Id).All(x => x.EndTime.HasValue))`
`242`	`245`	`continue;`
`@@ -256,6 +259,11 @@ private async Task DetermineNextExecutionTime(WorkflowInstance workflow, Workflo`
`256`	`259`	`return;`
`257`	`260`	`}`
`258`	`261`
	`262`	`+ await OnComplete(workflow, def);`
	`263`	`+ }`
	`264`	`+`
	`265`	`+ private async Task OnComplete(WorkflowInstance workflow, WorkflowDefinition def)`
	`266`	`+ {`
`259`	`267`	`workflow.Status = WorkflowStatus.Complete;`
`260`	`268`	`workflow.CompleteTime = _datetimeProvider.UtcNow;`
`261`	`269`
`@@ -264,6 +272,8 @@ private async Task DetermineNextExecutionTime(WorkflowInstance workflow, Workflo`
`264`	`272`	`var middlewareRunner = scope.ServiceProvider.GetRequiredService<IWorkflowMiddlewareRunner>();`
`265`	`273`	`await middlewareRunner.RunPostMiddleware(workflow, def);`
`266`	`274`	`}`
	`275`	`+`
	`276`	`+ _logger.LogDebug("Workflow {WorkflowDefinitionId} ({Id}) completed", workflow.WorkflowDefinitionId, workflow.Id);`
`267`	`277`
`268`	`278`	`_publisher.PublishNotification(new WorkflowCompleted`
`269`	`279`	`{`