WIP

src/Flowsharp.Core/Handlers/ActivityHandler.cs

@@ -0,0 +1,117 @@
+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();
+        }
+    }
+}

src/Flowsharp.Core/Handlers/IActivityHandler.cs

@@ -0,0 +1,65 @@
+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);
+    }
+}

src/Flowsharp.Core/Handlers/IfElseHandler.cs

@@ -0,0 +1,7 @@
+namespace Flowsharp.Handlers
+{
+    public class IfElseHandler
+    {
+        
+    }
+}