SemianiakaVY/elsa-core
1
0
Fork 0
Code Issues Pull requests Actions 1 Packages Projects Releases Wiki Activity

Separated data from behavior

Browse source
This commit is contained in:
Sipke Schoorstra 2018-10-15 14:15:36 +02:00
parent d0b60e18d1
commit ccea05ffdd
48 changed files with 519 additions and 629 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

117
src/Flowsharp.Core/Activities/Activity.cs
View file

@ -1,117 +0,0 @@
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.ActivityResults;
using Flowsharp.Models;
namespace Flowsharp.Activities
{
public abstract class Activity : IActivity
{
public virtual Task<bool> CanExecuteAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
return Task.FromResult(CanExecute(workflowContext, activityContext));
}
public virtual Task<ActivityExecutionResult> ExecuteAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
return Task.FromResult(Execute(workflowContext, activityContext));
}
public virtual Task<ActivityExecutionResult> ResumeAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
return Task.FromResult(Resume(workflowContext, activityContext));
}
public virtual Task OnActivityExecutedAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
OnActivityExecuted(workflowContext, activityContext);
return Task.CompletedTask;
}
public virtual Task OnActivityExecutingAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
OnActivityExecuting(workflowContext, activityContext);
return Task.CompletedTask;
}
public virtual Task ReceiveInputAsync(WorkflowExecutionContext workflowContext, IDictionary<string, object> input, CancellationToken cancellationToken)
{
ReceiveInput(workflowContext, input);
return Task.CompletedTask;
}
public virtual Task WorkflowResumedAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
WorkflowResumed(workflowContext);
return Task.CompletedTask;
}
public virtual Task WorkflowResumingAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
WorkflowResuming(workflowContext);
return Task.CompletedTask;
}
public virtual Task WorkflowStartedAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
WorkflowStarted(workflowContext);
return Task.CompletedTask;
}
public virtual Task WorkflowStartingAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
WorkflowStarting(workflowContext);
return Task.CompletedTask;
}
protected virtual ActivityExecutionResult Execute(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext)
{
return ActivateEndpoint();
}
protected virtual ActivityExecutionResult Resume(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext)
{
return ActivateEndpoint();
}
protected virtual bool CanExecute(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext) => true;
protected virtual void OnActivityExecuted(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext) {}
protected virtual void OnActivityExecuting(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext) {}
protected virtual void ReceiveInput(WorkflowExecutionContext workflowContext, IDictionary<string, object> input) {}
protected virtual void WorkflowResumed(WorkflowExecutionContext workflowContext) {}
protected virtual void WorkflowResuming(WorkflowExecutionContext workflowContext) {}
protected virtual void WorkflowStarted(WorkflowExecutionContext workflowContext) {}
protected virtual void WorkflowStarting(WorkflowExecutionContext workflowContext) {}
protected HaltResult Halt()
{
return new HaltResult();
}
protected ActivateEndpointResult ActivateEndpoint(string name = null)
{
return new ActivateEndpointResult(new SourceEndpoint(this, name));
}
protected ScheduleActivityResult ScheduleActivity(IActivity activity)
{
return new ScheduleActivityResult(activity);
}
protected ReturnValueResult SetReturnValue(object value)
{
return new ReturnValueResult(value);
}
protected FinishWorkflowResult Finish()
{
return new FinishWorkflowResult();
}
protected NoopResult Noop()
{
return new NoopResult();
}
}
}

67
src/Flowsharp.Core/Activities/IActivity.cs
View file

@ -1,67 +0,0 @@
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.ActivityResults;
using Flowsharp.Models;
namespace Flowsharp.Activities
{
public interface IActivity
{
/// <summary>
/// Returns a value of whether the specified activity can execute.
/// </summary>
Task<bool> CanExecuteAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken);
/// <summary>
/// Executes the specified activity.
/// </summary>
Task<ActivityExecutionResult> ExecuteAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken);
/// <summary>
/// Resumes the specified activity.
/// </summary>
Task<ActivityExecutionResult> ResumeAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken);
/// <summary>
/// Executes before a workflow starts or resumes, giving activities an opportunity to read and store any values of interest.
/// </summary>
Task ReceiveInputAsync(WorkflowExecutionContext workflowContext, IDictionary<string, object> input, CancellationToken cancellationToken);
/// <summary>
/// Executes when a workflow is about to start.
/// </summary>
Task WorkflowStartingAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken);
/// <summary>
/// Executes when a workflow has started.
/// </summary>
Task WorkflowStartedAsync(WorkflowExecutionContext context, CancellationToken cancellationToken);
/// <summary>
/// Executes when a workflow is about to be resumed.
/// </summary>
Task WorkflowResumingAsync(WorkflowExecutionContext context, CancellationToken cancellationToken);
/// <summary>
/// Executes when a workflow is resumed.
/// </summary>
Task WorkflowResumedAsync(WorkflowExecutionContext context, CancellationToken cancellationToken);
/// <summary>
/// Executes when an activity is about to be executed.
/// </summary>
/// <param name="workflowContext">The workflow execution context.</param>
/// <param name="activityContext">The activity context containing the activity that is the subject of the event.</param>
/// <param name="cancellationToken">The cancellation token.</param>
Task OnActivityExecutingAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Called on each activity when an activity has been executed.
/// </summary>
/// <param name="workflowContext">The workflow execution context.</param>
/// <param name="activityContext">The activity context containing the activity that is the subject of the event.</param>
/// <param name="cancellationToken">The cancellation token.</param>
Task OnActivityExecutedAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken);
}
}

21
src/Flowsharp.Core/Activities/IfElse.cs
View file

@ -1,27 +1,10 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.ActivityResults;
using Flowsharp.Expressions;
using Flowsharp.Models;
using Flowsharp.Scripting;
namespace Flowsharp.Activities
{
public class IfElse : Activity
{
private readonly IScriptEvaluator scriptEvaluator;
public IfElse(IScriptEvaluator scriptEvaluator)
{
this.scriptEvaluator = scriptEvaluator;
}
public ScriptExpression<bool> ConditionExpression { get; set; }
public override async Task<ActivityExecutionResult> ExecuteAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
var result = await scriptEvaluator.EvaluateAsync(ConditionExpression, workflowContext, cancellationToken);
return ActivateEndpoint(result ? "True" : "False");
}
public WorkflowExpression<bool> ConditionExpression { get; set; }
}
}

21
src/Flowsharp.Core/Activities/SetVariable.cs
View file

@ -1,28 +1,11 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.ActivityResults;
using Flowsharp.Expressions;
using Flowsharp.Models;
using Flowsharp.Scripting;
namespace Flowsharp.Activities
{
public class SetVariable : Activity
{
private readonly IScriptEvaluator scriptEvaluator;
public SetVariable(IScriptEvaluator scriptEvaluator)
{
this.scriptEvaluator = scriptEvaluator;
}
public string VariableName { get; set; }
public ScriptExpression<object> ValueExpression { get; set; }
public override async Task<ActivityExecutionResult> ExecuteAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
var value = await scriptEvaluator.EvaluateAsync(ValueExpression, workflowContext, cancellationToken);
workflowContext.CurrentScope.SetVariable(VariableName, value);
return ActivateEndpoint();
}
public WorkflowExpression<object> ValueExpression { get; set; }
}
}

12
src/Flowsharp.Core/Expressions/IExpressionEvaluator.cs Normal file
View file

@ -0,0 +1,12 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
namespace Flowsharp.Expressions
{
public interface IExpressionEvaluator
{
string Syntax { get; }
Task<T> EvaluateAsync<T>(string expression, WorkflowExecutionContext workflowExecutionContext, CancellationToken cancellationToken);
}
}

11
src/Flowsharp.Core/Expressions/IWorkflowExpressionEvaluator.cs Normal file
View file

@ -0,0 +1,11 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
namespace Flowsharp.Expressions
{
public interface IWorkflowExpressionEvaluator
{
Task<T> EvaluateAsync<T>(WorkflowExpression<T> expression, WorkflowExecutionContext workflowExecutionContext, CancellationToken cancellationToken);
}
}

36
src/Flowsharp.Core/Expressions/JavaScriptEvaluator.cs Normal file
View file

@ -0,0 +1,36 @@
using System;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
using Jint;
namespace Flowsharp.Expressions
{
public class JavaScriptEvaluator : IExpressionEvaluator
{
public const string SyntaxName = "JavaScript";
private readonly Engine engine;
public JavaScriptEvaluator()
{
engine = new Engine(options => { options.AllowClr(); });
}
public string Syntax => SyntaxName;
public Task<T> EvaluateAsync<T>(string expression, WorkflowExecutionContext workflowExecutionContext, CancellationToken cancellationToken)
{
var workflowApi = new
{
getVariable = (Func<string, object>) (name => workflowExecutionContext.CurrentScope.GetVariable(name)),
getLastResult = (Func<object>)(() => workflowExecutionContext.CurrentScope.LastResult)
};
engine.SetValue("workflow", workflowApi);
engine.Execute(expression);
var returnValue = engine.GetCompletionValue();
return Task.FromResult((T)returnValue.ToObject());
}
}
}

18
src/Flowsharp.Core/Expressions/PlainTextEvaluator.cs Normal file
View file

@ -0,0 +1,18 @@
using System;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
namespace Flowsharp.Expressions
{
public class PlainTextEvaluator : IExpressionEvaluator
{
public const string SyntaxName = "PlainText";
public string Syntax => SyntaxName;
public Task<T> EvaluateAsync<T>(string expression, WorkflowExecutionContext workflowExecutionContext, CancellationToken cancellationToken)
{
return Task.FromResult((T) Convert.ChangeType(expression, typeof(T)));
}
}
}

16
src/Flowsharp.Core/Expressions/WorkflowExpression.cs Normal file
View file

@ -0,0 +1,16 @@
namespace Flowsharp.Expressions
{
public class WorkflowExpression<T>
{
public WorkflowExpression(string syntax, string expression)
{
Syntax = syntax;
Expression = expression;
}
public string Syntax { get; set; }
public string Expression { get; }
public override string ToString() => Expression;
}
}

24
src/Flowsharp.Core/Expressions/WorkflowExpressionEvaluator.cs Normal file
View file

@ -0,0 +1,24 @@
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
namespace Flowsharp.Expressions
{
public class WorkflowExpressionEvaluator : IWorkflowExpressionEvaluator
{
private readonly IDictionary<string, IExpressionEvaluator> evaluators;
public WorkflowExpressionEvaluator(IEnumerable<IExpressionEvaluator> evaluators)
{
this.evaluators = evaluators.ToDictionary(x => x.Syntax);
}
public async Task<T> EvaluateAsync<T>(WorkflowExpression<T> expression, WorkflowExecutionContext workflowExecutionContext, CancellationToken cancellationToken)
{
var evaluator = evaluators[expression.Syntax];
return await evaluator.EvaluateAsync<T>(expression.Expression, workflowExecutionContext, cancellationToken);
}
}
}

6
src/Flowsharp.Core/Extensions/ConnectionActivityExtensions.cs
View file

@ -1,6 +0,0 @@
namespace Flowsharp.Extensions
{
public static class ConnectionExtensions
{
}
}

4
src/Flowsharp.Core/Flowsharp.Core.csproj
View file

@ -8,8 +8,12 @@
<ItemGroup>
<PackageReference Include="Jint" Version="2.11.58" />
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.1.1" />
<PackageReference Include="Microsoft.Extensions.Localization.Abstractions" Version="2.1.1" />
<PackageReference Include="Microsoft.Extensions.Logging" Version="2.1.1" />
<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.1.1" />
<PackageReference Include="Microsoft.Extensions.Logging.Console" Version="2.1.1" />
<PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="2.1.1" />
<PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
</ItemGroup>

117
src/Flowsharp.Core/Handlers/ActivityHandler.cs
View file

@ -1,117 +0,0 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Activities;
using Flowsharp.ActivityResults;
using Flowsharp.Models;
namespace Flowsharp.Handlers
{
public abstract class ActivityHandler<T> : IActivityHandler<T> where T : IActivity
{
public virtual Task<bool> CanExecuteAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
return Task.FromResult(CanExecute(workflowContext, activityContext));
}
public virtual Task<ActivityExecutionResult> ExecuteAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
return Task.FromResult(Execute(workflowContext, activityContext));
}
public virtual Task<ActivityExecutionResult> ResumeAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
return Task.FromResult(Resume(workflowContext, activityContext));
}
public virtual Task OnActivityExecutedAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
OnActivityExecuted(workflowContext, activityContext);
return Task.CompletedTask;
}
public virtual Task OnActivityExecutingAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
OnActivityExecuting(workflowContext, activityContext);
return Task.CompletedTask;
}
public virtual Task ReceiveInputAsync(WorkflowExecutionContext workflowContext, Variables input, CancellationToken cancellationToken)
{
ReceiveInput(workflowContext, input);
return Task.CompletedTask;
}
public virtual Task WorkflowResumedAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
WorkflowResumed(workflowContext);
return Task.CompletedTask;
}
public virtual Task WorkflowResumingAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
WorkflowResuming(workflowContext);
return Task.CompletedTask;
}
public virtual Task WorkflowStartedAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
WorkflowStarted(workflowContext);
return Task.CompletedTask;
}
public virtual Task WorkflowStartingAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
WorkflowStarting(workflowContext);
return Task.CompletedTask;
}
protected virtual ActivityExecutionResult Execute(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext)
{
return ActivateEndpoint();
}
protected virtual ActivityExecutionResult Resume(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext)
{
return ActivateEndpoint();
}
protected virtual bool CanExecute(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext) => true;
protected virtual void OnActivityExecuted(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext) {}
protected virtual void OnActivityExecuting(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext) {}
protected virtual void ReceiveInput(WorkflowExecutionContext workflowContext, Variables input) {}
protected virtual void WorkflowResumed(WorkflowExecutionContext workflowContext) {}
protected virtual void WorkflowResuming(WorkflowExecutionContext workflowContext) {}
protected virtual void WorkflowStarted(WorkflowExecutionContext workflowContext) {}
protected virtual void WorkflowStarting(WorkflowExecutionContext workflowContext) {}
protected HaltResult Halt()
{
return new HaltResult();
}
protected ActivateEndpointResult ActivateEndpoint(string name = null)
{
return new ActivateEndpointResult(new SourceEndpoint(this, name));
}
protected ScheduleActivityResult ScheduleActivity(IActivity activity)
{
return new ScheduleActivityResult(activity);
}
protected ReturnValueResult SetReturnValue(object value)
{
return new ReturnValueResult(value);
}
protected FinishWorkflowResult Finish()
{
return new FinishWorkflowResult();
}
protected NoopResult Noop()
{
return new NoopResult();
}
}
}

65
src/Flowsharp.Core/Handlers/IActivityHandler.cs
View file

@ -1,65 +0,0 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Activities;
using Flowsharp.ActivityResults;
using Flowsharp.Models;
namespace Flowsharp.Handlers
{
public interface IActivityHandler
{
}
public interface IActivityHandler<in T> : IActivityHandler where T:IActivity
{
/// <summary>
/// Returns a value of whether the specified activity can execute.
/// </summary>
Task<bool> CanExecuteAsync(WorkflowExecutionContext workflowContext, T activity, CancellationToken cancellationToken);
/// <summary>
/// Executes the specified activity.
/// </summary>
Task<ActivityExecutionResult> ExecuteAsync(WorkflowExecutionContext workflowContext, T activity, CancellationToken cancellationToken);
/// <summary>
/// Resumes the specified activity.
/// </summary>
Task<ActivityExecutionResult> ResumeAsync(WorkflowExecutionContext workflowContext, T activity, CancellationToken cancellationToken);
/// <summary>
/// Executes before a workflow starts or resumes, giving activities an opportunity to read and store any values of interest.
/// </summary>
Task ReceiveInputAsync(WorkflowExecutionContext workflowContext, Variables input, CancellationToken cancellationToken);
/// <summary>
/// Executes when a workflow is about to start.
/// </summary>
Task WorkflowStartingAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken);
/// <summary>
/// Executes when a workflow has started.
/// </summary>
Task WorkflowStartedAsync(WorkflowExecutionContext context, CancellationToken cancellationToken);
/// <summary>
/// Executes when a workflow is about to be resumed.
/// </summary>
Task WorkflowResumingAsync(WorkflowExecutionContext context, CancellationToken cancellationToken);
/// <summary>
/// Executes when a workflow is resumed.
/// </summary>
Task WorkflowResumedAsync(WorkflowExecutionContext context, CancellationToken cancellationToken);
/// <summary>
/// Executes when an activity is about to be executed.
/// </summary>
Task OnActivityExecutingAsync(WorkflowExecutionContext workflowContext, T activity, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Called on each activity when an activity has been executed.
/// </summary>
Task OnActivityExecutedAsync(WorkflowExecutionContext workflowContext, T activity, CancellationToken cancellationToken);
}
}

23
src/Flowsharp.Core/Handlers/IfElseHandler.cs
View file

@ -1,7 +1,26 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Activities;
using Flowsharp.Expressions;
using Flowsharp.Models;
using Flowsharp.Results;
using Flowsharp.Services;
namespace Flowsharp.Handlers
{
public class IfElseHandler
public class IfElseHandler : ActivityHandler<IfElse>
{
private readonly IWorkflowExpressionEvaluator expressionEvaluator;
public IfElseHandler(IWorkflowExpressionEvaluator expressionEvaluator)
{
this.expressionEvaluator = expressionEvaluator;
}
protected override async Task<ActivityExecutionResult> OnExecuteAsync(IfElse activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
var result = await expressionEvaluator.EvaluateAsync(activity.ConditionExpression, workflowContext, cancellationToken);
return ActivateEndpoint(result ? "True" : "False");
}
}
}

27
src/Flowsharp.Core/Handlers/SetVariableHandler.cs Normal file
View file

@ -0,0 +1,27 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Activities;
using Flowsharp.Expressions;
using Flowsharp.Models;
using Flowsharp.Results;
using Flowsharp.Services;
namespace Flowsharp.Handlers
{
public class SetVariableHandler : ActivityHandler<SetVariable>
{
private readonly IWorkflowExpressionEvaluator expressionEvaluator;
public SetVariableHandler(IWorkflowExpressionEvaluator expressionEvaluator)
{
this.expressionEvaluator = expressionEvaluator;
}
protected override async Task<ActivityExecutionResult> OnExecuteAsync(SetVariable activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
var value = await expressionEvaluator.EvaluateAsync(activity.ValueExpression, workflowContext, cancellationToken);
workflowContext.CurrentScope.SetVariable(activity.VariableName, value);
return ActivateEndpoint();
}
}
}

6
src/Flowsharp.Core/Models/Activity.cs Normal file
View file

@ -0,0 +1,6 @@
namespace Flowsharp.Models
{
public abstract class Activity : IActivity
{
}
}

6
src/Flowsharp.Core/Models/IActivity.cs Normal file
View file

@ -0,0 +1,6 @@
namespace Flowsharp.Models
{
public interface IActivity
{
}
}

4
src/Flowsharp.Core/Models/Workflow.cs
View file

@ -1,10 +1,10 @@
using System.Collections.Generic;
using System.Linq;
using Flowsharp.Models;
using Flowsharp.Activities;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
namespace Flowsharp.Activities
namespace Flowsharp.Models
{
public class Workflow
{

2
src/Flowsharp.Core/Models/WorkflowExecutionContext.cs
View file

@ -77,7 +77,7 @@ namespace Flowsharp.Models
Workflow.Status = WorkflowStatus.Finished;
}
public virtual void ScheduleNextActivities(WorkflowExecutionContext workflowContext, SourceEndpoint endpoint)
public void ScheduleNextActivities(WorkflowExecutionContext workflowContext, SourceEndpoint endpoint)
{
var completedActivity = workflowContext.CurrentActivity;
var connections = Workflow.Connections.Where(x => x.Source.Activity == completedActivity && x.Source.Name == endpoint.Name);

14
src/Flowsharp.Core/Results/ActivateEndpointResult.cs
View file

@ -1,22 +1,24 @@
using Flowsharp.Models;
using Flowsharp.Services;
namespace Flowsharp.ActivityResults
namespace Flowsharp.Results
{
/// <summary>
/// A result that carries information about the next activity to execute.
/// </summary>
public class ActivateEndpointResult : ActivityExecutionResult
{
public ActivateEndpointResult(SourceEndpoint endpoint)
public ActivateEndpointResult(string endpointName = null)
{
Endpoint = endpoint;
EndpointName = endpointName;
}
public SourceEndpoint Endpoint { get; }
public string EndpointName { get; }
protected override void Execute(WorkflowExecutionContext workflowContext)
protected override void Execute(IWorkflowInvoker invoker, WorkflowExecutionContext workflowContext)
{
workflowContext.ScheduleNextActivities(workflowContext, Endpoint);
var currentActivity = workflowContext.CurrentActivity;
workflowContext.ScheduleNextActivities(workflowContext, new SourceEndpoint(currentActivity, EndpointName));
}
}
}

10
src/Flowsharp.Core/Results/ActivityExecutionResult.cs
View file

@ -2,20 +2,20 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
using Flowsharp.Services;
namespace Flowsharp.ActivityResults
namespace Flowsharp.Results
{
public abstract class ActivityExecutionResult : IActivityExecutionResult
{
public virtual Task ExecuteAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
public virtual Task ExecuteAsync(IWorkflowInvoker invoker, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
Execute(workflowContext);
Execute(invoker, workflowContext);
return Task.CompletedTask;
}
protected virtual void Execute(WorkflowExecutionContext workflowContext)
protected virtual void Execute(IWorkflowInvoker invoker, WorkflowExecutionContext workflowContext)
{
throw new NotImplementedException("You must either implement ExecuteAsync or Execute");
}
}
}

5
src/Flowsharp.Core/Results/FinishWorkflowResult.cs
View file

@ -1,10 +1,11 @@
using Flowsharp.Models;
using Flowsharp.Services;
namespace Flowsharp.ActivityResults
namespace Flowsharp.Results
{
public class FinishWorkflowResult : ActivityExecutionResult
{
protected override void Execute(WorkflowExecutionContext workflowContext)
protected override void Execute(IWorkflowInvoker invoker, WorkflowExecutionContext workflowContext)
{
workflowContext.Finish();
}

15
src/Flowsharp.Core/Results/HaltResult.cs
View file

@ -1,25 +1,24 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
using Flowsharp.Services;
namespace Flowsharp.ActivityResults
namespace Flowsharp.Results
{
/// <summary>
/// Halts workflow execution.
/// </summary>
public class HaltResult : ActivityExecutionResult
{
public override async Task ExecuteAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
var currentActivity = workflowContext.CurrentActivity;
public override async Task ExecuteAsync(IWorkflowInvoker invoker, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
if (workflowContext.IsFirstPass)
{
// Resume immediately when this is the first pass.
var result = await currentActivity.ResumeAsync(workflowContext, new ActivityExecutionContext(currentActivity), cancellationToken);
var activity = workflowContext.CurrentActivity;
var result = await invoker.ActivityInvoker.ResumeAsync(activity, workflowContext, cancellationToken);
workflowContext.IsFirstPass = false;
await result.ExecuteAsync(workflowContext, cancellationToken);
await result.ExecuteAsync(invoker, workflowContext, cancellationToken);
}
else
{

5
src/Flowsharp.Core/Results/IActivityExecutionResult.cs
View file

@ -1,11 +1,12 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
using Flowsharp.Services;
namespace Flowsharp.ActivityResults
namespace Flowsharp.Results
{
public interface IActivityExecutionResult
{
Task ExecuteAsync(WorkflowExecutionContext workflowContext, CancellationToken cancellationToken);
Task ExecuteAsync(IWorkflowInvoker invoker, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken);
}
}

5
src/Flowsharp.Core/Results/NoopResult.cs
View file

@ -1,13 +1,14 @@
using Flowsharp.Models;
using Flowsharp.Services;
namespace Flowsharp.ActivityResults
namespace Flowsharp.Results
{
/// <summary>
/// A result that does nothing.
/// </summary>
public class NoopResult : ActivityExecutionResult
{
protected override void Execute(WorkflowExecutionContext workflowContext)
protected override void Execute(IWorkflowInvoker invoker, WorkflowExecutionContext workflowContext)
{
// Noop.
}

5
src/Flowsharp.Core/Results/ReturnValueResult.cs
View file

@ -1,6 +1,7 @@
using Flowsharp.Models;
using Flowsharp.Services;
namespace Flowsharp.ActivityResults
namespace Flowsharp.Results
{
public class ReturnValueResult : ActivityExecutionResult
{
@ -11,7 +12,7 @@ namespace Flowsharp.ActivityResults
this.value = value;
}
protected override void Execute(WorkflowExecutionContext workflowContext)
protected override void Execute(IWorkflowInvoker invoker, WorkflowExecutionContext workflowContext)
{
workflowContext.SetLastResult(value);
}

5
src/Flowsharp.Core/Results/ScheduleActivityResult.cs
View file

@ -1,7 +1,8 @@
using Flowsharp.Activities;
using Flowsharp.Models;
using Flowsharp.Services;
namespace Flowsharp.ActivityResults
namespace Flowsharp.Results
{
public class ScheduleActivityResult : ActivityExecutionResult
{
@ -12,7 +13,7 @@ namespace Flowsharp.ActivityResults
this.activity = activity;
}
protected override void Execute(WorkflowExecutionContext workflowContext)
protected override void Execute(IWorkflowInvoker invoker, WorkflowExecutionContext workflowContext)
{
workflowContext.ScheduleActivity(activity);
}

11
src/Flowsharp.Core/Scripting/IScriptEvaluator.cs
View file

@ -1,11 +0,0 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
namespace Flowsharp.Scripting
{
public interface IScriptEvaluator
{
Task<T> EvaluateAsync<T>(ScriptExpression<T> script, WorkflowExecutionContext workflowExecutionContext, CancellationToken cancellationToken);
}
}

27
src/Flowsharp.Core/Scripting/JintEvaluator.cs
View file

@ -1,27 +0,0 @@
using System;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
using Jint;
namespace Flowsharp.Scripting
{
public class JintEvaluator : IScriptEvaluator
{
private readonly Engine engine;
public JintEvaluator()
{
engine = new Engine(options => { options.AllowClr(); });
}
public Task<T> EvaluateAsync<T>(ScriptExpression<T> script, WorkflowExecutionContext workflowExecutionContext, CancellationToken cancellationToken)
{
engine.SetValue("workflow.getVariable", (Func<string, object>)(name => workflowExecutionContext.CurrentScope.GetVariable(name)));
engine.Execute(script.Expression);
var returnValue = engine.GetCompletionValue();
return Task.FromResult((T)returnValue.ToObject());
}
}
}

17
src/Flowsharp.Core/Scripting/ScriptExpression.cs
View file

@ -1,17 +0,0 @@
namespace Flowsharp.Scripting
{
public class ScriptExpression<T>
{
public static implicit operator string(ScriptExpression<T> expression) => expression.Expression;
public static implicit operator ScriptExpression<T>(string expression) => new ScriptExpression<T>(expression);
public ScriptExpression(string expression)
{
Expression = expression;
}
public string Expression { get; }
public override string ToString() => Expression;
}
}

1
src/Flowsharp.Core/Serialization/IWorkflowSerializer.cs
View file

@ -1,6 +1,7 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Activities;
using Flowsharp.Models;
namespace Flowsharp.Serialization
{

1
src/Flowsharp.Core/Serialization/JsonWorkflowSerializer.cs
View file

@ -1,6 +1,7 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Activities;
using Flowsharp.Models;
using Flowsharp.Services;
using Newtonsoft.Json;

32
src/Flowsharp.Core/Services/ActivityHandler.cs Normal file
View file

@ -0,0 +1,32 @@
using System;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
using Flowsharp.Results;
namespace Flowsharp.Services
{
public abstract class ActivityHandler<T> : IActivityHandler where T : IActivity
{
public Type ActivityType => typeof(T);
public Task<bool> CanExecuteAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken) => OnCanExecuteAsync((T)activity, workflowContext, cancellationToken);
public Task<ActivityExecutionResult> ExecuteAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken) => OnExecuteAsync((T) activity, workflowContext, cancellationToken);
public Task<ActivityExecutionResult> ResumeAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken) => OnResumeAsync((T)activity, workflowContext, cancellationToken);
protected virtual Task<bool> OnCanExecuteAsync(T activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken) => Task.FromResult(OnCanExecute(activity, workflowContext));
protected virtual Task<ActivityExecutionResult> OnExecuteAsync(T activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken) => Task.FromResult(OnExecute(activity, workflowContext));
protected virtual Task<ActivityExecutionResult> OnResumeAsync(T activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken) => Task.FromResult(OnResume(activity, workflowContext));
protected virtual bool OnCanExecute(T activity, WorkflowExecutionContext workflowContext) => true;
protected virtual ActivityExecutionResult OnExecute(T activity, WorkflowExecutionContext workflowContext) => Noop();
protected virtual ActivityExecutionResult OnResume(T activity, WorkflowExecutionContext workflowContext) => Noop();
protected HaltResult Halt() => new HaltResult();
protected ActivateEndpointResult ActivateEndpoint(string name = null) => new ActivateEndpointResult(name);
protected ScheduleActivityResult ScheduleActivity(IActivity activity) => new ScheduleActivityResult(activity);
protected ReturnValueResult SetReturnValue(object value) => new ReturnValueResult(value);
protected FinishWorkflowResult Finish() => new FinishWorkflowResult();
protected NoopResult Noop() => new NoopResult();
}
}

40
src/Flowsharp.Core/Services/ActivityInvoker.cs Normal file
View file

@ -0,0 +1,40 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
using Flowsharp.Results;
namespace Flowsharp.Services
{
public class ActivityInvoker : IActivityInvoker
{
private readonly IDictionary<Type, IActivityHandler> handlers;
public ActivityInvoker(IEnumerable<IActivityHandler> handlers)
{
this.handlers = handlers.ToDictionary(x => x.ActivityType);
}
public async Task<bool> CanExecuteAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
return await GetHandlerFor(activity).CanExecuteAsync(activity, workflowContext, cancellationToken);
}
public async Task<ActivityExecutionResult> ExecuteAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
return await GetHandlerFor(activity).ExecuteAsync(activity, workflowContext, cancellationToken);
}
public async Task<ActivityExecutionResult> ResumeAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
return await GetHandlerFor(activity).ResumeAsync(activity, workflowContext, cancellationToken);
}
private IActivityHandler GetHandlerFor(IActivity activity)
{
return handlers[activity.GetType()];
}
}
}

31
src/Flowsharp.Core/Services/IActivityHandler.cs Normal file
View file

@ -0,0 +1,31 @@
using System;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
using Flowsharp.Results;
namespace Flowsharp.Services
{
public interface IActivityHandler
{
/// <summary>
/// The type of activity handled by this handler.
/// </summary>
Type ActivityType { get; }
/// <summary>
/// Returns a value of whether the specified activity can execute.
/// </summary>
Task<bool> CanExecuteAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken);
/// <summary>
/// Executes the specified activity.
/// </summary>
Task<ActivityExecutionResult> ExecuteAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken);
/// <summary>
/// Resumes the specified activity.
/// </summary>
Task<ActivityExecutionResult> ResumeAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken);
}
}

14
src/Flowsharp.Core/Services/IActivityInvoker.cs Normal file
View file

@ -0,0 +1,14 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Models;
using Flowsharp.Results;
namespace Flowsharp.Services
{
public interface IActivityInvoker
{
Task<bool> CanExecuteAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken);
Task<ActivityExecutionResult> ExecuteAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken);
Task<ActivityExecutionResult> ResumeAsync(IActivity activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken);
}
}

1
src/Flowsharp.Core/Services/IWorkflowInvoker.cs
View file

@ -7,6 +7,7 @@ namespace Flowsharp.Services
{
public interface IWorkflowInvoker
{
IActivityInvoker ActivityInvoker { get; }
Task<WorkflowExecutionContext> InvokeAsync(Workflow workflow, IActivity startActivity = default, CancellationToken cancellationToken = default);
}
}

31
src/Flowsharp.Core/Services/WorkflowInvoker.cs
View file

@ -2,22 +2,23 @@
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Activities;
using Flowsharp.ActivityResults;
using Flowsharp.Extensions;
using Flowsharp.Models;
using Flowsharp.Results;
using Microsoft.Extensions.Logging;
namespace Flowsharp.Services
{
public class WorkflowInvoker : IWorkflowInvoker
{
public WorkflowInvoker(ILogger<WorkflowInvoker> logger)
public WorkflowInvoker(IActivityInvoker activityInvoker, ILogger<WorkflowInvoker> logger)
{
ActivityInvoker = activityInvoker;
this.logger = logger;
}
private readonly ILogger logger;
public IActivityInvoker ActivityInvoker { get; }
public async Task<WorkflowExecutionContext> InvokeAsync(Workflow workflow, IActivity startActivity = default, CancellationToken cancellationToken = default)
{
@ -31,7 +32,6 @@ namespace Flowsharp.Services
workflowExecutionContext.Workflow.Status = WorkflowStatus.Executing;
workflowExecutionContext.ScheduleActivity(startActivity);
await InvokeActivitiesAsync(workflowExecutionContext, x => x.WorkflowStartingAsync(workflowExecutionContext, cancellationToken));
while (workflowExecutionContext.HasScheduledActivities)
{
@ -41,7 +41,7 @@ namespace Flowsharp.Services
if(result == null)
break;
await result.ExecuteAsync(workflowExecutionContext, cancellationToken);
await result.ExecuteAsync(this, workflowExecutionContext, cancellationToken);
workflowExecutionContext.IsFirstPass = false;
isResuming = false;
@ -57,8 +57,6 @@ namespace Flowsharp.Services
{
try
{
//await InvokeActivitiesAsync(workflowContext, x => x.ActivityDescriptor.OnActivityExecutingAsync(workflowContext, activity, cancellationToken));
if (cancellationToken.IsCancellationRequested)
{
workflowContext.Workflow.Status = WorkflowStatus.Aborted;
@ -66,7 +64,6 @@ namespace Flowsharp.Services
}
return await ExecuteOrResumeActivityAsync(workflowContext, activity, isResuming, cancellationToken);
//await InvokeActivitiesAsync(workflowContext, x => x.ActivityDescriptor.OnActivityExecutedAsync(workflowContext, activity, cancellationToken));
}
catch (Exception ex)
@ -88,21 +85,9 @@ namespace Flowsharp.Services
private async Task<ActivityExecutionResult> ExecuteOrResumeActivityAsync(WorkflowExecutionContext workflowContext, IActivity activity, bool isResuming, CancellationToken cancellationToken)
{
if (!isResuming)
{
// Execute the current activity.
return await activity.ExecuteAsync(workflowContext, new ActivityExecutionContext(activity), cancellationToken);
}
else
{
// Resume the current activity.
return await activity.ResumeAsync(workflowContext, new ActivityExecutionContext(activity), cancellationToken);
}
}
private async Task InvokeActivitiesAsync(WorkflowExecutionContext workflowContext, Func<IActivity, Task> action)
{
await workflowContext.Workflow.Activities.InvokeAsync(action, logger);
return isResuming
? await ActivityInvoker.ResumeAsync(activity, workflowContext, cancellationToken)
: await ActivityInvoker.ExecuteAsync(activity, workflowContext, cancellationToken);
}
}
}

37
src/Flowsharp.Samples.Console/Activities/ReadLine.cs
View file

@ -2,48 +2,13 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Activities;
using Flowsharp.ActivityResults;
using Flowsharp.Models;
using Flowsharp.Results;
namespace Flowsharp.Samples.Console.Activities
{
public class ReadLine : Activity
{
private readonly TextReader input;
public ReadLine() : this(System.Console.In)
{
}
public ReadLine(TextReader input)
{
this.input = input;
}
public ReadLine(string argumentName)
{
ArgumentName = argumentName;
input = null;
}
public string ArgumentName { get; set; }
public override async Task<ActivityExecutionResult> ExecuteAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
if (input == null)
return Halt();
var value = await input.ReadLineAsync();
workflowContext.SetLastResult(value);
return ActivateEndpoint();
}
protected override ActivityExecutionResult Resume(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext)
{
var receivedInput = workflowContext.Workflow.Arguments[ArgumentName];
workflowContext.SetLastResult(receivedInput);
return ActivateEndpoint();
}
}
}

40
src/Flowsharp.Samples.Console/Activities/WriteLine.cs
View file

@ -2,9 +2,10 @@
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.ActivityResults;
using Flowsharp.Expressions;
using Flowsharp.Models;
using Activity = Flowsharp.Activities.Activity;
using Flowsharp.Results;
using Activity = Flowsharp.Models.Activity;
namespace Flowsharp.Samples.Console.Activities
{
@ -13,42 +14,15 @@ namespace Flowsharp.Samples.Console.Activities
/// </summary>
public class WriteLine : Activity
{
private readonly TextWriter output;
private readonly Func<WorkflowExecutionContext, ActivityExecutionContext, string> textProvider;
public WriteLine() : this(System.Console.Out, null)
public WriteLine()
{
}
public WriteLine(string text) : this(System.Console.Out, text)
public WriteLine(string text)
{
TextExpression = new WorkflowExpression<string>(PlainTextEvaluator.SyntaxName, text);
}
public WriteLine(Func<WorkflowExecutionContext, ActivityExecutionContext, string> textProvider) : this(System.Console.Out, null)
{
this.textProvider = textProvider;
}
public WriteLine(TextWriter output, string text)
{
this.output = output;
Text = text;
textProvider = (w, a) => Text;
}
public string Text { get; set; }
protected override bool CanExecute(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext)
{
var text = textProvider(workflowContext, activityContext);
return text != null;
}
public override async Task<ActivityExecutionResult> ExecuteAsync(WorkflowExecutionContext workflowContext, ActivityExecutionContext activityContext, CancellationToken cancellationToken)
{
var text = textProvider(workflowContext, activityContext);
await output.WriteLineAsync(text);
return ActivateEndpoint();
}
public WorkflowExpression<string> TextExpression { get; set; }
}
}

43
src/Flowsharp.Samples.Console/Handlers/ReadLineHandler.cs Normal file
View file

@ -0,0 +1,43 @@
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Handlers;
using Flowsharp.Models;
using Flowsharp.Results;
using Flowsharp.Samples.Console.Activities;
using Flowsharp.Services;
namespace Flowsharp.Samples.Console.Handlers
{
public class ReadLineHandler : ActivityHandler<ReadLine>
{
private readonly TextReader input;
public ReadLineHandler()
{
}
public ReadLineHandler(TextReader input)
{
this.input = input;
}
protected override async Task<ActivityExecutionResult> OnExecuteAsync(ReadLine activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
if (input == null)
return Halt();
var value = await input.ReadLineAsync();
workflowContext.SetLastResult(value);
return ActivateEndpoint();
}
protected override ActivityExecutionResult OnResume(ReadLine activity, WorkflowExecutionContext workflowContext)
{
var receivedInput = workflowContext.Workflow.Arguments[activity.ArgumentName];
workflowContext.SetLastResult(receivedInput);
return ActivateEndpoint();
}
}
}

38
src/Flowsharp.Samples.Console/Handlers/WriteLineHandler.cs Normal file
View file

@ -0,0 +1,38 @@
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Expressions;
using Flowsharp.Handlers;
using Flowsharp.Models;
using Flowsharp.Results;
using Flowsharp.Samples.Console.Activities;
using Flowsharp.Services;
namespace Flowsharp.Samples.Console.Handlers
{
/// <summary>
/// Writes a text string to the specified stream.
/// </summary>
public class WriteLineHandler : ActivityHandler<WriteLine>
{
private readonly IWorkflowExpressionEvaluator evaluator;
private readonly TextWriter output;
public WriteLineHandler(IWorkflowExpressionEvaluator evaluator) : this(evaluator, System.Console.Out)
{
}
public WriteLineHandler(IWorkflowExpressionEvaluator evaluator, TextWriter output)
{
this.evaluator = evaluator;
this.output = output;
}
protected override async Task<ActivityExecutionResult> OnExecuteAsync(WriteLine activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
var text = await evaluator.EvaluateAsync(activity.TextExpression, workflowContext, cancellationToken);
await output.WriteLineAsync(text);
return ActivateEndpoint();
}
}
}

32
src/Flowsharp.Samples.Console/Program.cs
View file

@ -1,6 +1,13 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Expressions;
using Flowsharp.Handlers;
using Flowsharp.Samples.Console.Handlers;
using Flowsharp.Samples.Console.Programs;
using Flowsharp.Serialization;
using Flowsharp.Services;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
namespace Flowsharp.Samples.Console
{
@ -8,8 +15,29 @@ namespace Flowsharp.Samples.Console
{
static async Task Main()
{
//await new AdditionWorkflowProgram().RunAsync(CancellationToken.None);
await new AdditionWorkflowProgramLongRunning().RunAsync(CancellationToken.None);
var services = new ServiceCollection()
.AddSingleton<IExpressionEvaluator, JavaScriptEvaluator>()
.AddSingleton<IExpressionEvaluator, PlainTextEvaluator>()
.AddSingleton<IWorkflowExpressionEvaluator, WorkflowExpressionEvaluator>()
.AddSingleton<IWorkflowInvoker, WorkflowInvoker>()
.AddSingleton<IActivityInvoker, ActivityInvoker>()
.AddSingleton<IWorkflowSerializer, JsonWorkflowSerializer>()
.AddLogging(logging => logging.AddConsole());
services
.AddSingleton<IActivityHandler, SetVariableHandler>()
.AddSingleton<IActivityHandler, IfElseHandler>()
.AddSingleton<IActivityHandler, ReadLineHandler>()
.AddSingleton<IActivityHandler, WriteLineHandler>();
services
.AddSingleton<AdditionWorkflowProgram>()
.AddSingleton<AdditionWorkflowProgramLongRunning>();
var serviceProvider = services.BuildServiceProvider();
var program = serviceProvider.GetRequiredService<AdditionWorkflowProgramLongRunning>();
await program.RunAsync(CancellationToken.None);
}
}
}

17
src/Flowsharp.Samples.Console/Programs/AdditionWorkflowProgram.cs
View file

@ -1,5 +1,9 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Expressions;
using Flowsharp.Handlers;
using Flowsharp.Samples.Console.Activities;
using Flowsharp.Samples.Console.Handlers;
using Flowsharp.Samples.Console.Workflows;
using Flowsharp.Serialization;
using Flowsharp.Services;
@ -10,12 +14,19 @@ namespace Flowsharp.Samples.Console.Programs
{
public class AdditionWorkflowProgram
{
private readonly IWorkflowInvoker workflowInvoker;
private readonly IWorkflowSerializer serializer;
public AdditionWorkflowProgram(IWorkflowInvoker workflowInvoker, IWorkflowSerializer serializer)
{
this.workflowInvoker = workflowInvoker;
this.serializer = serializer;
}
public async Task RunAsync(CancellationToken cancellationToken)
{
var invoker = new WorkflowInvoker(new Logger<WorkflowInvoker>(new NullLoggerFactory()));
var workflow = new AdditionWorkflow();
var workflowContext = await invoker.InvokeAsync(workflow, null, cancellationToken);
var serializer = new JsonWorkflowSerializer();
var workflowContext = await workflowInvoker.InvokeAsync(workflow, null, cancellationToken);
var json = await serializer.SerializeAsync(workflow, cancellationToken);
System.Console.WriteLine(json);

14
src/Flowsharp.Samples.Console/Programs/AdditionWorkflowProgramLongRunning.cs
View file

@ -2,7 +2,10 @@
using System.Threading;
using System.Threading.Tasks;
using Flowsharp.Activities;
using Flowsharp.Expressions;
using Flowsharp.Handlers;
using Flowsharp.Models;
using Flowsharp.Samples.Console.Handlers;
using Flowsharp.Samples.Console.Workflows;
using Flowsharp.Serialization;
using Flowsharp.Services;
@ -13,13 +16,13 @@ namespace Flowsharp.Samples.Console.Programs
{
public class AdditionWorkflowProgramLongRunning
{
private readonly WorkflowInvoker workflowInvoker;
private readonly IWorkflowInvoker workflowInvoker;
private readonly IWorkflowSerializer serializer;
public AdditionWorkflowProgramLongRunning()
public AdditionWorkflowProgramLongRunning(IWorkflowInvoker workflowInvoker, IWorkflowSerializer serializer)
{
workflowInvoker = new WorkflowInvoker(new Logger<WorkflowInvoker>(new NullLoggerFactory()));
serializer = new JsonWorkflowSerializer();
this.workflowInvoker = workflowInvoker;
this.serializer = serializer;
}
public async Task RunAsync(CancellationToken cancellationToken)
@ -33,6 +36,9 @@ namespace Flowsharp.Samples.Console.Programs
workflowContext = await ReadAndResumeAsync(workflowContext.Workflow, "y", cancellationToken);
workflowContext = await ReadAndResumeAsync(workflowContext.Workflow, "tryAgain", cancellationToken);
}
var json = await serializer.SerializeAsync(workflowContext.Workflow, cancellationToken);
System.Console.WriteLine(json);
}
private async Task<WorkflowExecutionContext> ReadAndResumeAsync(Workflow workflow, string argumentName, CancellationToken cancellationToken)

24
src/Flowsharp.Samples.Console/Workflows/AdditionWorkflow.cs
View file

@ -1,8 +1,8 @@
using System;
using Flowsharp.Activities;
using Flowsharp.Expressions;
using Flowsharp.Models;
using Flowsharp.Samples.Console.Activities;
using Flowsharp.Scripting;
namespace Flowsharp.Samples.Console.Workflows
{
@ -10,26 +10,24 @@ namespace Flowsharp.Samples.Console.Workflows
{
public AdditionWorkflow()
{
var scriptEvaluator = new JintEvaluator();
var writeLine1 = new WriteLine("Welcome to Addition Workflow!");
var writeLine2 = new WriteLine("Let's run an interactive program.");
var writeLine3 = new WriteLine("Enter first value:");
var readLine1 = new ReadLine();
var setVariable1 = new SetVariable(scriptEvaluator){ VariableName = "x", ValueExpression = "workflow.getLastResult()"};
var setVariable1 = new SetVariable{ VariableName = "x", ValueExpression = new WorkflowExpression<object>(JavaScriptEvaluator.SyntaxName, "workflow.getLastResult()")};
var writeLine4 = new WriteLine("Enter second value:");
var readLine2 = new ReadLine();
var setVariable2 = new SetVariable(scriptEvaluator){ VariableName = "y", ValueExpression = "workflow.getLastResult()"};
var writeLine5 = new WriteLine((w, a) =>
{
var x = w.CurrentScope.GetVariable<int>("x");
var y = w.CurrentScope.GetVariable<int>("y");
var z = x + y;
return $"{x} + {y} = {z}";
});
var setVariable2 = new SetVariable{ VariableName = "y", ValueExpression = new WorkflowExpression<object>(JavaScriptEvaluator.SyntaxName, "workflow.getLastResult()")};
var writeLine5 = new WriteLine {TextExpression = new WorkflowExpression<string>(JavaScriptEvaluator.SyntaxName,
"var x = workflow.getVariable('x');\r\n" +
"var y = workflow.getVariable('y');\r\n" +
"var sum = parseInt(x) + parseInt(y);\r\n" +
"x + ' + ' + y + ' = ' + sum;"
)};
var writeLine6 = new WriteLine("Try again? (Y/N)");
var readLine3 = new ReadLine();
var setVariable3 = new SetVariable(scriptEvaluator){ VariableName = "tryAgain", ValueExpression = "'y' === workflow.getLastResult().toLowerCase()"};
var ifElse1 = new IfElse(scriptEvaluator){ ConditionExpression = "workflow.getVariable('tryAgain')"};
var setVariable3 = new SetVariable{ VariableName = "tryAgain", ValueExpression = new WorkflowExpression<object>(JavaScriptEvaluator.SyntaxName, "'y' === workflow.getLastResult().toLowerCase()")};
var ifElse1 = new IfElse{ ConditionExpression = new WorkflowExpression<bool>(JavaScriptEvaluator.SyntaxName, "workflow.getVariable('tryAgain')")};
var writeLine7 = new WriteLine("Bye!");
Activities = new IActivity[] { writeLine1, writeLine2, writeLine3, writeLine4, writeLine5, writeLine6, readLine1, readLine2, readLine3, setVariable1, setVariable2, setVariable3, ifElse1 };

30
src/Flowsharp.Samples.Console/Workflows/AdditionWorkflowLongRunning.cs
View file

@ -1,8 +1,8 @@
using System;
using Flowsharp.Activities;
using Flowsharp.Expressions;
using Flowsharp.Models;
using Flowsharp.Samples.Console.Activities;
using Flowsharp.Scripting;
namespace Flowsharp.Samples.Console.Workflows
{
@ -10,26 +10,24 @@ namespace Flowsharp.Samples.Console.Workflows
{
public AdditionWorkflowLongRunning()
{
var scriptEvaluator = new JintEvaluator();
var writeLine1 = new WriteLine("Welcome to Addition Workflow - Long Running edition!");
var writeLine2 = new WriteLine("Let's run a long-running program.");
var writeLine3 = new WriteLine("Enter first value:");
var readLine1 = new ReadLine("x");
var setVariable1 = new SetVariable(scriptEvaluator){ VariableName = "x", ValueExpression = "workflow.getLastResult()"};
var readLine1 = new ReadLine { ArgumentName = "x"};
var setVariable1 = new SetVariable{ VariableName = "x", ValueExpression = new WorkflowExpression<object>(JavaScriptEvaluator.SyntaxName, "workflow.getLastResult()")};
var writeLine4 = new WriteLine("Enter second value:");
var readLine2 = new ReadLine("y");
var setVariable2 = new SetVariable(scriptEvaluator){ VariableName = "y", ValueExpression = "workflow.getLastResult()"};
var writeLine5 = new WriteLine((w, a) =>
{
var x = w.CurrentScope.GetVariable<int>("x");
var y = w.CurrentScope.GetVariable<int>("y");
var z = x + y;
return $"{x} + {y} = {z}";
});
var readLine2 = new ReadLine { ArgumentName = "y"};
var setVariable2 = new SetVariable{ VariableName = "y", ValueExpression = new WorkflowExpression<object>(JavaScriptEvaluator.SyntaxName, "workflow.getLastResult()")};
var writeLine5 = new WriteLine {TextExpression = new WorkflowExpression<string>(JavaScriptEvaluator.SyntaxName,
"var x = workflow.getVariable('x');\r\n" +
"var y = workflow.getVariable('y');\r\n" +
"var sum = parseInt(x) + parseInt(y);\r\n" +
"x + ' + ' + y + ' = ' + sum;"
)};
var writeLine6 = new WriteLine("Try again? (Y/N)");
var readLine3 = new ReadLine("tryAgain");
var setVariable3 = new SetVariable(scriptEvaluator){ VariableName = "tryAgain", ValueExpression = "'y' === workflow.getLastResult().toLowerCase()"};
var ifElse1 = new IfElse(scriptEvaluator){ ConditionExpression = "workflow.getVariable('tryAgain')"};
var readLine3 = new ReadLine { ArgumentName = "tryAgain"};
var setVariable3 = new SetVariable{ VariableName = "tryAgain", ValueExpression = new WorkflowExpression<object>(JavaScriptEvaluator.SyntaxName, "'y' === workflow.getLastResult().toLowerCase()")};
var ifElse1 = new IfElse{ ConditionExpression = new WorkflowExpression<bool>(JavaScriptEvaluator.SyntaxName, "workflow.getVariable('tryAgain')")};
var writeLine7 = new WriteLine("Bye!");
Activities = new IActivity[] { writeLine1, writeLine2, writeLine3, writeLine4, writeLine5, writeLine6, readLine1, readLine2, readLine3, setVariable1, setVariable2, setVariable3, ifElse1 };