Patterns

ConductorSharp.sln

@@ -26,6 +26,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		.editorconfig = .editorconfig
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConductorSharp.Patterns", "src\ConductorSharp.Patterns\ConductorSharp.Patterns.csproj", "{9A55F1CF-2553-4F44-A8BC-0063A402582F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -64,6 +66,10 @@ Global
 		{7FC97985-07CE-4643-8415-C48BA2117D88}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{7FC97985-07CE-4643-8415-C48BA2117D88}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{7FC97985-07CE-4643-8415-C48BA2117D88}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9A55F1CF-2553-4F44-A8BC-0063A402582F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9A55F1CF-2553-4F44-A8BC-0063A402582F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9A55F1CF-2553-4F44-A8BC-0063A402582F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9A55F1CF-2553-4F44-A8BC-0063A402582F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

examples/ConductorSharp.Definitions/ConductorModule.cs

@@ -11,6 +11,7 @@ protected override void Load(ContainerBuilder builder)
             base.Load(builder);
 
             builder.RegisterWorkflow<SendCustomerNotification>();
+            builder.RegisterWorkflow<HandleNotificationFailure>();
         }
     }
 }

examples/ConductorSharp.Definitions/ConductorSharp.Definitions.csproj

@@ -35,6 +35,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\ConductorSharp.Engine\ConductorSharp.Engine.csproj" />
+    <ProjectReference Include="..\..\src\ConductorSharp.Patterns\ConductorSharp.Patterns.csproj" />
   </ItemGroup>
 
 </Project>

examples/ConductorSharp.Definitions/Program.cs

@@ -3,6 +3,7 @@
 using ConductorSharp.Definitions;
 using ConductorSharp.Engine.Extensions;
 using ConductorSharp.Engine.Health;
+using ConductorSharp.Patterns.Extensions;
 using MediatR.Extensions.Autofac.DependencyInjection;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -40,6 +41,7 @@
                     longPollInterval: configuration.GetValue<int>("Conductor:LongPollInterval"),
                     domain: configuration.GetValue<string>("Conductor:WorkerDomain")
                 )
+                .AddConductorSharpPatterns()
                 .SetHealthCheckService<FileHealthService>()
                 .AddPipelines(pipelines =>
                 {

examples/ConductorSharp.Definitions/Workflows/HandleNotificationFailure.cs

@@ -0,0 +1,40 @@
+using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Engine.Builders;
+using ConductorSharp.Engine.Util;
+using ConductorSharp.Patterns.Tasks;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ConductorSharp.Definitions.Workflows
+{
+    public class HandleNotificationFailureInput : WorkflowInput<HandleNotificationFailureOutput>
+    {
+        [JsonProperty("workflowId")]
+        public string? WorkflowId { get; set; }
+    }
+
+    public class HandleNotificationFailureOutput : WorkflowOutput { }
+
+    [OriginalName("NOTIFICATION_handle_failure")]
+    public class HandleNotificationFailure : Workflow<HandleNotificationFailureInput, HandleNotificationFailureOutput>
+    {
+        public ReadWorkflowTasks? ReadExecutedTasks { get; set; }
+
+        public override WorkflowDefinition GetDefinition()
+        {
+            var builder = new WorkflowDefinitionBuilder<HandleNotificationFailure>();
+
+            builder.AddTask(a => a.ReadExecutedTasks, b => new() { TaskNames = "dynamic_handler", WorkflowId = b.WorkflowInput.WorkflowId });
+
+            return builder.Build(options =>
+            {
+                options.Version = 1;
+                options.OwnerEmail = "example@example.local";
+            });
+        }
+    }
+}

examples/ConductorSharp.Definitions/Workflows/SendCustomerNotification.cs

@@ -3,6 +3,7 @@
 using ConductorSharp.Engine.Builders;
 using ConductorSharp.Engine.Model;
 using ConductorSharp.Engine.Util;
+using ConductorSharp.Patterns.Tasks;
 using MediatR;
 
 namespace ConductorSharp.Definitions.Workflows
@@ -28,6 +29,7 @@ public class SendCustomerNotification : Workflow<SendCustomerNotificationInput,
         public EmailPrepareV1? PrepareEmail { get; set; }
         public DynamicTaskModel<ExpectedDynamicInput, ExpectedDynamicOutput>? DynamicHandler { get; set; }
         public SendCustomerNotification? SendNotif { get; set; }
+        public WaitSeconds? WaitSeconds { get; set; }
 
         public override WorkflowDefinition GetDefinition()
         {
@@ -43,10 +45,13 @@ public override WorkflowDefinition GetDefinition()
                     }
             );
 
+            builder.AddTask(a => a.WaitSeconds, b => new() { Seconds = 10 });
+
             builder.AddTask(a => a.PrepareEmail, b => new() { Address = b.DynamicHandler!.Output.Address, Name = b.DynamicHandler!.Output.Name });
 
             return builder.Build(options =>
             {
+                options.FailureWorkflow = typeof(HandleNotificationFailure);
                 options.Version = 1;
                 options.OwnerEmail = "example@example.local";
             });

src/ConductorSharp.Engine/Builders/DecisionTaskBuilder.cs

@@ -10,6 +10,28 @@
 
 namespace ConductorSharp.Engine.Builders
 {
+    public static class DecisionTaskExtensions
+    {
+        public static ITaskOptionsBuilder AddTask<TWorkflow>(
+            this WorkflowDefinitionBuilder<TWorkflow> builder,
+            Expression<Func<TWorkflow, DecisionTaskModel>> taskSelector,
+            Expression<Func<TWorkflow, DecisionTaskInput>> expression,
+            params (string, Action<DecisionTaskBuilder<TWorkflow>>)[] caseActions
+        ) where TWorkflow : ITypedWorkflow
+        {
+            var taskBbuilder = new DecisionTaskBuilder<TWorkflow>(taskSelector.Body, expression.Body);
+
+            foreach (var funcase in caseActions)
+            {
+                taskBbuilder.AddCase(funcase.Item1);
+                funcase.Item2.Invoke(taskBbuilder);
+            }
+
+            builder.Context.TaskBuilders.Add(taskBbuilder);
+            return taskBbuilder;
+        }
+    }
+
     public class DecisionTaskBuilder<TWorkflow> : BaseTaskBuilder<DecisionTaskInput, NoOutput> where TWorkflow : ITypedWorkflow
     {
         private Dictionary<string, List<ITaskBuilder>> _caseDictionary = new();

src/ConductorSharp.Engine/Builders/DynamicForkJoinTaskBuilder.cs

@@ -1,10 +1,26 @@
 using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Engine.Interface;
 using ConductorSharp.Engine.Model;
 using Newtonsoft.Json.Linq;
+using System;
 using System.Linq.Expressions;
 
 namespace ConductorSharp.Engine.Builders
 {
+    public static class DynamicForkJoinTaskExtensions
+    {
+        public static ITaskOptionsBuilder AddTask<TWorkflow>(
+            this WorkflowDefinitionBuilder<TWorkflow> builder,
+            Expression<Func<TWorkflow, DynamicForkJoinTaskModel>> refference,
+            Expression<Func<TWorkflow, DynamicForkJoinInput>> input
+        ) where TWorkflow : ITypedWorkflow
+        {
+            var taskBuilder = new DynamicForkJoinTaskBuilder(refference.Body, input.Body);
+            builder.Context.TaskBuilders.Add(taskBuilder);
+            return taskBuilder;
+        }
+    }
+
     public class DynamicForkJoinTaskBuilder : BaseTaskBuilder<DynamicForkJoinInput, NoOutput>
     {
         public DynamicForkJoinTaskBuilder(Expression taskExpression, Expression inputExpression) : base(taskExpression, inputExpression) { }

src/ConductorSharp.Engine/Builders/DynamicTaskBuilder.cs

@@ -1,5 +1,7 @@
 using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Engine.Interface;
 using ConductorSharp.Engine.Model;
+using MediatR;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using System;
@@ -9,6 +11,20 @@
 
 namespace ConductorSharp.Engine.Builders
 {
+    public static class DynamicTaskExtensions
+    {
+        public static ITaskOptionsBuilder AddTask<TWorkflow, F, G>(
+            this WorkflowDefinitionBuilder<TWorkflow> builder,
+            Expression<Func<TWorkflow, DynamicTaskModel<F, G>>> reference,
+            Expression<Func<TWorkflow, DynamicTaskInput<F, G>>> input
+        ) where TWorkflow : ITypedWorkflow
+        {
+            var taskBuilder = new DynamicTaskBuilder<F, G>(reference.Body, input.Body);
+            builder.Context.TaskBuilders.Add(taskBuilder);
+            return taskBuilder;
+        }
+    }
+
     public class DynamicTaskBuilder<I, O> : BaseTaskBuilder<DynamicTaskInput<I, O>, O>
     {
         private const string TaskType = "DYNAMIC";

src/ConductorSharp.Engine/Builders/JsonJqTransformTaskBuilder.cs

@@ -1,10 +1,28 @@
 using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Engine.Interface;
+using ConductorSharp.Engine.Model;
 using MediatR;
 using System;
 using System.Linq.Expressions;
 
 namespace ConductorSharp.Engine.Builders
 {
+    public static class JsonJqTransformTaskExtensions
+    {
+        public static ITaskOptionsBuilder AddTask<TWorkflow, F, G>(
+            this WorkflowDefinitionBuilder<TWorkflow> builder,
+            Expression<Func<TWorkflow, JsonJqTransformTaskModel<F, G>>> refference,
+            Expression<Func<TWorkflow, F>> input
+        )
+            where TWorkflow : ITypedWorkflow
+            where F : IRequest<G>
+        {
+            var taskBuilder = new JsonJqTransformTaskBuilder<F, G>(refference.Body, input.Body);
+            builder.Context.TaskBuilders.Add(taskBuilder);
+            return taskBuilder;
+        }
+    }
+
     public class JsonJqTransformTaskBuilder<A, B> : BaseTaskBuilder<A, B> where A : IRequest<B>
     {
         public JsonJqTransformTaskBuilder(Expression taskExpression, Expression inputExpression) : base(taskExpression, inputExpression)

src/ConductorSharp.Engine/Builders/LambdaTaskBuilder.cs

@@ -1,10 +1,30 @@
 using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Engine.Interface;
+using ConductorSharp.Engine.Model;
 using MediatR;
 using Newtonsoft.Json.Linq;
+using System;
 using System.Linq.Expressions;
 
 namespace ConductorSharp.Engine.Builders
 {
+    public static class LambdaTaskExtensions
+    {
+        public static ITaskOptionsBuilder AddTask<TWorkflow, F, G>(
+            this WorkflowDefinitionBuilder<TWorkflow> builder,
+            Expression<Func<TWorkflow, LambdaTaskModel<F, G>>> referrence,
+            Expression<Func<TWorkflow, F>> input,
+            string script
+        )
+            where TWorkflow : ITypedWorkflow
+            where F : IRequest<G>
+        {
+            var taskBuilder = new LambdaTaskBuilder<F, G>(script, referrence.Body, input.Body);
+            builder.Context.TaskBuilders.Add(taskBuilder);
+            return taskBuilder;
+        }
+    }
+
     public class LambdaTaskBuilder<A, B> : BaseTaskBuilder<A, B> where A : IRequest<B>
     {
         private readonly string _script;

src/ConductorSharp.Engine/Builders/PassThroughTaskBuilder.cs

@@ -6,6 +6,12 @@
 
 namespace ConductorSharp.Engine.Builders
 {
+    public static class PassThroughTaskExtensions
+    {
+        public static void AddTasks<TWorkflow>(this WorkflowDefinitionBuilder<TWorkflow> builder, params WorkflowDefinition.Task[] taskDefinitions)
+            where TWorkflow : ITypedWorkflow => builder.Context.TaskBuilders.Add(new PassThroughTaskBuilder(taskDefinitions));
+    }
+
     public class PassThroughTaskBuilder : ITaskBuilder
     {
         private readonly WorkflowDefinition.Task[] _tasks;

src/ConductorSharp.Engine/Builders/SimpleTaskBuilder.cs

@@ -1,11 +1,30 @@
 using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Engine.Interface;
 using ConductorSharp.Engine.Model;
 using MediatR;
 using Newtonsoft.Json.Linq;
+using System;
 using System.Linq.Expressions;
 
 namespace ConductorSharp.Engine.Builders
 {
+    public static class SimpleTaskExtensions
+    {
+        public static ITaskOptionsBuilder AddTask<TWorkflow, F, G>(
+            this WorkflowDefinitionBuilder<TWorkflow> builder,
+            Expression<Func<TWorkflow, SimpleTaskModel<F, G>>> refference,
+            Expression<Func<TWorkflow, F>> input,
+            AdditionalTaskParameters additionalParameters = null
+        )
+            where TWorkflow : ITypedWorkflow
+            where F : IRequest<G>
+        {
+            var taskBuilder = new SimpleTaskBuilder<F, G>(refference.Body, input.Body, additionalParameters);
+            builder.Context.TaskBuilders.Add(taskBuilder);
+            return taskBuilder;
+        }
+    }
+
     public class SimpleTaskBuilder<A, B> : BaseTaskBuilder<A, B> where A : IRequest<B>
     {
         public SimpleTaskBuilder(Expression taskExpression, Expression inputExpression, AdditionalTaskParameters additionalParameters)

src/ConductorSharp.Engine/Builders/SubWorkflowTaskBuilder.cs

@@ -1,12 +1,31 @@
 using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Engine.Interface;
+using ConductorSharp.Engine.Model;
 using ConductorSharp.Engine.Util;
 using MediatR;
 using Newtonsoft.Json.Linq;
+using System;
 using System.Linq.Expressions;
 using System.Reflection;
 
 namespace ConductorSharp.Engine.Builders
 {
+    public static class SubWorkflowTaskExtensions
+    {
+        public static ITaskOptionsBuilder AddTask<TWorkflow, F, G>(
+            this WorkflowDefinitionBuilder<TWorkflow> builder,
+            Expression<Func<TWorkflow, SubWorkflowTaskModel<F, G>>> referrence,
+            Expression<Func<TWorkflow, F>> input
+        )
+            where TWorkflow : ITypedWorkflow
+            where F : IRequest<G>
+        {
+            var taskBuilder = new SubWorkflowTaskBuilder<F, G>(referrence.Body, input.Body);
+            builder.Context.TaskBuilders.Add(taskBuilder);
+            return taskBuilder;
+        }
+    }
+
     public class SubWorkflowTaskBuilder<TInput, TOutput> : BaseTaskBuilder<TInput, TOutput> where TInput : IRequest<TOutput>
     {
         private readonly int _version;

src/ConductorSharp.Engine/Builders/SwitchTaskBuilder.cs

@@ -10,6 +10,28 @@
 
 namespace ConductorSharp.Engine.Builders
 {
+    public static class SwitchTaskExtensions
+    {
+        public static ITaskOptionsBuilder AddTask<TWorkflow>(
+            this WorkflowDefinitionBuilder<TWorkflow> builder,
+            Expression<Func<TWorkflow, SwitchTaskModel>> taskSelector,
+            Expression<Func<TWorkflow, SwitchTaskInput>> expression,
+            params (string, Action<SwitchTaskBuilder<TWorkflow>>)[] caseActions
+        ) where TWorkflow : ITypedWorkflow
+        {
+            var taskBuilder = new SwitchTaskBuilder<TWorkflow>(taskSelector.Body, expression.Body);
+
+            foreach (var funcase in caseActions)
+            {
+                taskBuilder.AddCase(funcase.Item1);
+                funcase.Item2.Invoke(taskBuilder);
+            }
+
+            builder.Context.TaskBuilders.Add(taskBuilder);
+            return taskBuilder;
+        }
+    }
+
     public class SwitchTaskBuilder<TWorkflow> : BaseTaskBuilder<SwitchTaskInput, NoOutput> where TWorkflow : ITypedWorkflow
     {
         private Dictionary<string, ICollection<ITaskBuilder>> _caseDictionary = new();

src/ConductorSharp.Engine/Builders/TerminateTaskBuilder.cs

@@ -1,4 +1,5 @@
 using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Engine.Interface;
 using ConductorSharp.Engine.Model;
 using Newtonsoft.Json.Linq;
 using System;
@@ -8,6 +9,20 @@
 
 namespace ConductorSharp.Engine.Builders
 {
+    public static class TerminateTaskExtensions
+    {
+        public static ITaskOptionsBuilder AddTask<TWorkflow>(
+            this WorkflowDefinitionBuilder<TWorkflow> builder,
+            Expression<Func<TWorkflow, TerminateTaskModel>> reference,
+            Expression<Func<TWorkflow, TerminateTaskInput>> input
+        ) where TWorkflow : ITypedWorkflow
+        {
+            var taskBuilder = new TerminateTaskBuilder(reference.Body, input.Body);
+            builder.Context.TaskBuilders.Add(taskBuilder);
+            return taskBuilder;
+        }
+    }
+
     internal class TerminateTaskBuilder : BaseTaskBuilder<TerminateTaskInput, NoOutput>
     {
         public TerminateTaskBuilder(Expression taskExpression, Expression memberExpression) : base(taskExpression, memberExpression) { }