schedule step

Author: danielgerlag

src/WorkflowCore/Interface/IStepBuilder.cs

@@ -45,6 +45,13 @@ public interface IStepBuilder<TData, TStepBody>
         /// <returns></returns>
         IStepBuilder<TData, InlineStepBody> Then(Func<IStepExecutionContext, ExecutionResult> body);
 
+        /// <summary>
+        /// Specify an inline next step in the workflow
+        /// </summary>
+        /// <param name="body"></param>
+        /// <returns></returns>
+        IStepBuilder<TData, ActionStepBody> Then(Action<IStepExecutionContext> body);
+
         /// <summary>
         /// Configure an outcome for this step, then wire it to another step
         /// </summary>
@@ -126,5 +133,7 @@ public interface IStepBuilder<TData, TStepBody>
         IContainerStepBuilder<TData, When, OutcomeSwitch> When(Expression<Func<TData, object>> outcomeValue, string label = null);
 
         IParallelStepBuilder<TData, Sequence> Parallel();
+
+        IContainerStepBuilder<TData, Schedule, TStepBody> Schedule(Expression<Func<TData, TimeSpan>> time);
     }
 }

src/WorkflowCore/Interface/IWorkflowBuilder.cs

@@ -24,6 +24,8 @@ public interface IWorkflowBuilder<TData> : IWorkflowBuilder
 
         IStepBuilder<TData, InlineStepBody> StartWith(Func<IStepExecutionContext, ExecutionResult> body);
 
+        IStepBuilder<TData, ActionStepBody> StartWith(Action<IStepExecutionContext> body);
+
         IEnumerable<WorkflowStep> GetUpstreamSteps(int id);
 
         IWorkflowBuilder<TData> UseDefaultErrorBehavior(WorkflowErrorHandling behavior, TimeSpan? retryInterval = null);

src/WorkflowCore/Models/SchedulePersistenceData.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace WorkflowCore.Models
+{
+    public class SchedulePersistenceData
+    {
+        public bool Elapsed { get; set; }
+
+    }
+}

src/WorkflowCore/Primitives/ActionStepBody.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+using WorkflowCore.Interface;
+using WorkflowCore.Models;
+
+namespace WorkflowCore.Primitives
+{
+    public class ActionStepBody : StepBody
+    {
+        public Action<IStepExecutionContext> Body { get; set; }
+        
+        public override ExecutionResult Run(IStepExecutionContext context)
+        {
+            Body(context);
+            return ExecutionResult.Next();
+        }
+    }
+}

src/WorkflowCore/Primitives/Schedule.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using WorkflowCore.Interface;
+using WorkflowCore.Models;
+
+namespace WorkflowCore.Primitives
+{
+    public class Schedule : ContainerStepBody
+    {
+        public TimeSpan Period { get; set; }
+
+        public override ExecutionResult Run(IStepExecutionContext context)
+        {
+            if (context.PersistenceData == null)
+                return ExecutionResult.Sleep(Period, new SchedulePersistenceData() { Elapsed = false });
+            
+
+            if (context.PersistenceData is SchedulePersistenceData)
+            {
+                if (!((SchedulePersistenceData) context.PersistenceData).Elapsed)
+                    return ExecutionResult.Branch(new List<object>() { null }, new SchedulePersistenceData() { Elapsed = true });
+
+                var complete = true;
+
+                foreach (var childId in context.ExecutionPointer.Children)
+                    complete = complete && IsBranchComplete(context.Workflow.ExecutionPointers, childId);
+
+                if (complete)
+                    return ExecutionResult.Next();
+            
+                return ExecutionResult.Persist(context.PersistenceData);
+            }
+            
+            throw new ArgumentException();
+        }
+    }
+}

src/WorkflowCore/Services/StepBuilder.cs

@@ -63,6 +63,16 @@ public IStepBuilder<TData, InlineStepBody> Then(Func<IStepExecutionContext, Exec
             return stepBuilder;
         }
 
+        public IStepBuilder<TData, ActionStepBody> Then(Action<IStepExecutionContext> body)
+        {
+            var newStep = new WorkflowStep<ActionStepBody>();
+            WorkflowBuilder.AddStep(newStep);
+            var stepBuilder = new StepBuilder<TData, ActionStepBody>(WorkflowBuilder, newStep);
+            stepBuilder.Input(x => x.Body, x => body);
+            Step.Outcomes.Add(new StepOutcome() { NextStep = newStep.Id });
+            return stepBuilder;
+        }
+
         public IStepOutcomeBuilder<TData> When(object outcomeValue, string label = null)
         {
             StepOutcome result = new StepOutcome();
@@ -274,7 +284,7 @@ public IContainerStepBuilder<TData, When, OutcomeSwitch> When(Expression<Func<TD
 
             WorkflowBuilder.AddStep(newStep);
             var stepBuilder = new SkipStepBuilder<TData, When, OutcomeSwitch>(WorkflowBuilder, newStep, switchBuilder);
-
+            
             switchBuilder.Step.Children.Add(newStep.Id);
 
             return stepBuilder;
@@ -292,6 +302,27 @@ public IParallelStepBuilder<TData, Sequence> Parallel()
             return stepBuilder;
         }
 
+        public IContainerStepBuilder<TData, Schedule, TStepBody> Schedule(Expression<Func<TData, TimeSpan>> time)
+        {
+            var newStep = new WorkflowStep<Schedule>();
+
+            Expression<Func<Schedule, TimeSpan>> inputExpr = (x => x.Period);
+
+            var mapping = new DataMapping()
+            {
+                Source = time,
+                Target = inputExpr
+            };
+            newStep.Inputs.Add(mapping);
+
+            WorkflowBuilder.AddStep(newStep);
+            var stepBuilder = new SkipStepBuilder<TData, Schedule, TStepBody>(WorkflowBuilder, newStep, this);
+            
+            Step.Outcomes.Add(new StepOutcome() { NextStep = newStep.Id });
+
+            return stepBuilder;
+        }
+
         public IStepBuilder<TData, TStepBody> Do(Action<IWorkflowBuilder<TData>> builder)
         {
             builder.Invoke(WorkflowBuilder);

src/WorkflowCore/Services/WorkflowBuilder.cs

@@ -82,6 +82,15 @@ public IStepBuilder<TData, InlineStepBody> StartWith(Func<IStepExecutionContext,
             return stepBuilder;
         }
 
+        public IStepBuilder<TData, ActionStepBody> StartWith(Action<IStepExecutionContext> body)
+        {
+            var newStep = new WorkflowStep<ActionStepBody>();
+            AddStep(newStep);
+            var stepBuilder = new StepBuilder<TData, ActionStepBody>(this, newStep);
+            stepBuilder.Input(x => x.Body, x => body);
+            return stepBuilder;
+        }
+
         public IEnumerable<WorkflowStep> GetUpstreamSteps(int id)
         {
             return Steps.Where(x => x.Outcomes.Any(y => y.NextStep == id)).ToList();

src/samples/WorkflowCore.Sample01/Program.cs

@@ -34,6 +34,7 @@ private static IServiceProvider ConfigureServices()
             IServiceCollection services = new ServiceCollection();
             services.AddLogging();
             services.AddWorkflow();
+            //services.AddWorkflow(x => x.UseMongoDB(@"mongodb://localhost:27017", "workflow"));
             services.AddTransient<GoodbyeWorld>();
 
             var serviceProvider = services.BuildServiceProvider();