Input / Output (danielgerlag#245)

Author: danielgerlag

ReleaseNotes/next.md

@@ -0,0 +1,41 @@
+
+## Action Inputs / Outputs
+
+Added the action Input & Output overloads on the fluent step builder.
+
+```c#
+Input(Action<TStepBody, TData> action);
+```
+
+This will allow one to manipulate properties on the step before it executes and properties on the data object after it executes, for example
+
+```c#
+Input((step, data) => step.Value1 = data.Value1)
+```
+
+```c#
+.Output((step, data) => data["Value3"] = step.Output)
+```
+
+```c#
+.Output((step, data) => data.MyCollection.Add(step.Output))
+```
+
+## Breaking changes
+
+The existing ability to assign values to entries in dictionaries or dynamic objects on `.Output` was problematic, 
+since it broke the ability to pass collections on the Output mappings.
+
+
+```c#
+.Output(data => data["Value3"], step => step.Output)
+```
+
+This feature has been removed, and it is advised to use the action Output API instead, for example
+
+
+```c#
+.Output((step, data) => data["Value3"] = step.Output)
+```
+
+This functionality remains intact for JSON defined workflows.

WorkflowCore.sln

@@ -95,6 +95,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ReleaseNotes", "ReleaseNote
 		ReleaseNotes\1.6.8.md = ReleaseNotes\1.6.8.md
 		ReleaseNotes\1.6.9.md = ReleaseNotes\1.6.9.md
 		ReleaseNotes\1.7.0.md = ReleaseNotes\1.7.0.md
+		ReleaseNotes\next.md = ReleaseNotes\next.md
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WorkflowCore.Sample14", "src\samples\WorkflowCore.Sample14\WorkflowCore.Sample14.csproj", "{6BC66637-B42A-4334-ADFB-DBEC9F29D293}"
@@ -123,7 +124,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WorkflowCore.Tests.MySQL",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WorkflowCore.Tests.DynamoDB", "test\WorkflowCore.Tests.DynamoDB\WorkflowCore.Tests.DynamoDB.csproj", "{3ECEC028-7E2C-4983-B928-26C073B51BB7}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WorkflowCore.Providers.Redis", "src\providers\WorkflowCore.Providers.Redis\WorkflowCore.Providers.Redis.csproj", "{435C6263-C6F8-4E93-B417-D861E9C22E18}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WorkflowCore.Providers.Redis", "src\providers\WorkflowCore.Providers.Redis\WorkflowCore.Providers.Redis.csproj", "{435C6263-C6F8-4E93-B417-D861E9C22E18}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

src/WorkflowCore/Interface/IStepBuilder.cs

@@ -77,6 +77,13 @@ public interface IStepBuilder<TData, TStepBody>
         /// <returns></returns>
         IStepBuilder<TData, TStepBody> Input<TInput>(Expression<Func<TStepBody, TInput>> stepProperty, Expression<Func<TData, IStepExecutionContext, TInput>> value);
 
+        /// <summary>
+        /// Manipulate properties on the step before its executed.
+        /// </summary>
+        /// <param name="action"></param>
+        /// <returns></returns>
+        IStepBuilder<TData, TStepBody> Input(Action<TStepBody, TData> action);
+
         /// <summary>
         /// Map properties on the workflow data object to properties on the step after the step executes
         /// </summary>
@@ -86,6 +93,13 @@ public interface IStepBuilder<TData, TStepBody>
         /// <returns></returns>
         IStepBuilder<TData, TStepBody> Output<TOutput>(Expression<Func<TData, TOutput>> dataProperty, Expression<Func<TStepBody, object>> value);
 
+        /// <summary>
+        /// Manipulate properties on the data object after the step executes
+        /// </summary>
+        /// <param name="action"></param>
+        /// <returns></returns>
+        IStepBuilder<TData, TStepBody> Output(Action<TStepBody, TData> action);
+
         /// <summary>
         /// Wait here until to specified event is published
         /// </summary>
@@ -222,4 +236,4 @@ public interface IStepBuilder<TData, TStepBody>
         IStepBuilder<TData, TStepBody> CancelCondition(Expression<Func<TData, bool>> cancelCondition, bool proceedAfterCancel = false);
 
     }
-}
+}

src/WorkflowCore/Interface/IStepParameter.cs

@@ -0,0 +1,11 @@
+using WorkflowCore.Interface;
+using WorkflowCore.Models;
+
+namespace WorkflowCore.Interface
+{
+    public interface IStepParameter
+    {
+        void AssignInput(object data, IStepBody body, IStepExecutionContext context);
+        void AssignOutput(object data, IStepBody body, IStepExecutionContext context);
+    }
+}

src/WorkflowCore/Models/ActionParameter.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using WorkflowCore.Interface;
+
+namespace WorkflowCore.Models
+{
+    public class ActionParameter<TStepBody, TData> : IStepParameter
+    {
+        private readonly Action<TStepBody, TData> _action;
+     
+        public ActionParameter(Action<TStepBody, TData> action)
+        {
+            _action = action;
+        }
+
+        private void Assign(object data, IStepBody step, IStepExecutionContext context)
+        {
+            _action.Invoke((TStepBody)step, (TData)data);
+        }
+
+        public void AssignInput(object data, IStepBody body, IStepExecutionContext context)
+        {
+            Assign(data, body, context);
+        }
+
+        public void AssignOutput(object data, IStepBody body, IStepExecutionContext context)
+        {
+            Assign(data, body, context);
+        }
+    }
+}

src/WorkflowCore/Models/DataMapping.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using WorkflowCore.Interface;
+
+namespace WorkflowCore.Models
+{
+    public class MemberMapParameter : IStepParameter
+    {
+        private readonly LambdaExpression _source;
+        private readonly LambdaExpression _target;
+     
+        public MemberMapParameter(LambdaExpression source, LambdaExpression target)
+        {
+            if (target.Body.NodeType != ExpressionType.MemberAccess)
+                throw new NotSupportedException();
+
+            _source = source;
+            _target = target;
+        }
+
+        private void Assign(object sourceObject, LambdaExpression sourceExpr, object targetObject, LambdaExpression targetExpr, IStepExecutionContext context)
+        {
+            object resolvedValue = null;
+
+            switch (sourceExpr.Parameters.Count)
+            {
+                case 1:
+                    resolvedValue = sourceExpr.Compile().DynamicInvoke(sourceObject);
+                    break;
+                case 2:
+                    resolvedValue = sourceExpr.Compile().DynamicInvoke(sourceObject, context);
+                    break;
+                default:
+                    throw new ArgumentException();
+            }
+
+            if (resolvedValue == null)
+            {
+                var defaultAssign = Expression.Lambda(Expression.Assign(targetExpr.Body, Expression.Default(targetExpr.ReturnType)), targetExpr.Parameters.Single());
+                defaultAssign.Compile().DynamicInvoke(targetObject);
+                return;
+            }
+
+            var valueExpr = Expression.Convert(Expression.Constant(resolvedValue), targetExpr.ReturnType);
+            var assign = Expression.Lambda(Expression.Assign(targetExpr.Body, valueExpr), targetExpr.Parameters.Single());
+            assign.Compile().DynamicInvoke(targetObject);
+        }
+
+        public void AssignInput(object data, IStepBody body, IStepExecutionContext context)
+        {
+            Assign(data, _source, body, _target, context);
+        }
+
+        public void AssignOutput(object data, IStepBody body, IStepExecutionContext context)
+        {
+            Assign(body, _source, data, _target, context);
+        }
+    }
+}

src/WorkflowCore/Models/MemberMapParameter.cs

@@ -20,9 +20,9 @@ public abstract class WorkflowStep
 
         public virtual List<StepOutcome> Outcomes { get; set; } = new List<StepOutcome>();
 
-        public virtual List<DataMapping> Inputs { get; set; } = new List<DataMapping>();
+        public virtual List<IStepParameter> Inputs { get; set; } = new List<IStepParameter>();
 
-        public virtual List<DataMapping> Outputs { get; set; } = new List<DataMapping>();
+        public virtual List<IStepParameter> Outputs { get; set; } = new List<IStepParameter>();
 
         public virtual WorkflowErrorHandling? ErrorBehavior { get; set; }
 

src/WorkflowCore/Models/WorkflowStep.cs

@@ -177,11 +177,7 @@ private void AttachInputs(StepSourceV1 source, Type dataType, Type stepType, Wor
                 var targetProperty = Expression.Property(stepParameter, input.Key);
                 var targetExpr = Expression.Lambda(targetProperty, stepParameter);
 
-                step.Inputs.Add(new DataMapping
-                {
-                    Source = sourceExpr,
-                    Target = targetExpr
-                });
+                step.Inputs.Add(new MemberMapParameter(sourceExpr, targetExpr));
             }
         }
 
@@ -200,20 +196,23 @@ private void AttachOutputs(StepSourceV1 source, Type dataType, Type stepType, Wo
                 if (propertyInfo != null)
                 {
                     targetProperty = Expression.Property(dataParameter, propertyInfo);
+                    var targetExpr = Expression.Lambda(targetProperty, dataParameter);
+                    step.Outputs.Add(new MemberMapParameter(sourceExpr, targetExpr));
                 }
                 else
                 {
                     // If we did not find a matching property try to find a Indexer with string parameter
                     propertyInfo = dataType.GetProperty("Item");
                     targetProperty = Expression.Property(dataParameter, propertyInfo, Expression.Constant(output.Key));
-                }
-                var targetExpr = Expression.Lambda(targetProperty, dataParameter);
+                    
+                    Action<IStepBody, object> acn = (pStep, pData) =>
+                    {
+                        object resolvedValue = sourceExpr.Compile().DynamicInvoke(pStep); ;
+                        propertyInfo.SetValue(pData, resolvedValue, new object[] { output.Key });
+                    };
 
-                step.Outputs.Add(new DataMapping
-                {
-                    Source = sourceExpr,
-                    Target = targetExpr
-                });
+                    step.Outputs.Add(new ActionParameter<IStepBody, object>(acn));
+                }
             }
         }