Catch the exception and handling the exception in the workflow

src/modules/Elsa.Workflows.Core/Activities/Catch.cs

@@ -0,0 +1,37 @@
+using System.Runtime.CompilerServices;
+using Elsa.Workflows.Attributes;
+using Elsa.Workflows.Models;
+using Elsa.Workflows.UIHints;
+
+namespace Elsa.Workflows.Activities;
+
+/// <summary>
+/// Catch the Exception.
+/// </summary>
+[Activity("Elsa", "Primitives", "Catch the Exception.")]
+public class Catch : Activity
+{    
+    /// <inheritdoc />
+    public Catch([CallerFilePath] string? source = default, [CallerLineNumber] int? line = default) : base(source, line)
+    {
+    }
+
+    /// <summary>
+    /// A value indicating whether to catch all exceptions from all activities.
+    /// </summary>
+    [Input(Description = "A value indicating whether to catch all exceptions from all activities.")]
+    public Input<bool> CatchAll { get; set; } = default!;
+
+    /// <summary>
+    /// The IDs of the activities to catch exceptions from.
+    /// </summary>
+    [Input(Description = "The IDs of the activities to catch exceptions from.",
+        UIHint = InputUIHints.MultiText)]
+    public Input<ICollection<string>?> CatchActivities { get; set; } = default!;
+
+    /// <inheritdoc />
+    protected override ValueTask ExecuteAsync(ActivityExecutionContext context)
+    {
+        return context.CompleteActivityAsync();
+    }
+}

src/modules/Elsa.Workflows.Core/Activities/Flowchart/Activities/Flowchart.cs

@@ -27,6 +27,7 @@ public Flowchart([CallerFilePath] string? source = default, [CallerLineNumber] i
         OnSignalReceived<ScheduleActivityOutcomes>(OnScheduleOutcomesAsync);
         OnSignalReceived<ScheduleChildActivity>(OnScheduleChildActivityAsync);
         OnSignalReceived<CancelSignal>(OnActivityCanceledAsync);
+        OnSignalReceived<ExceptionSignal>(OnActivityExceptionAsync);
     }
 
     /// <summary>
@@ -89,7 +90,8 @@ protected override async ValueTask ScheduleChildrenAsync(ActivityExecutionContex
             return root;
 
         // If no start activity found, return the first activity.
-        return Activities.FirstOrDefault();
+        return Activities.Where(activity => activity is not Catch).FirstOrDefault();
+
     }
 
     /// <summary>
@@ -286,4 +288,55 @@ private async ValueTask OnActivityCanceledAsync(CancelSignal signal, SignalConte
     {
         await CompleteIfNoPendingWorkAsync(context.ReceiverActivityExecutionContext);
     }
+
+    private async ValueTask OnActivityExceptionAsync(ExceptionSignal signal, SignalContext context)
+    {
+        var activities = Activities.Where(a => a is Catch).Cast<Catch>().ToList();
+
+        if (activities.Count == 0)
+            return;
+
+        var flowchartContext = context.ReceiverActivityExecutionContext;
+        var workflowExecutionContext = flowchartContext.WorkflowExecutionContext;
+
+        var exceptionActivity = signal.Activity;
+
+        var options = new ActivityInvocationOptions
+        {
+            Owner = flowchartContext
+        };
+
+        foreach (var catchActivity in activities)
+        {
+            var catchContext = workflowExecutionContext.ActivityExecutionContexts.FirstOrDefault(x => x.Activity.Id == catchActivity!.Id);
+
+            if (catchContext == null)
+            {
+                catchContext = await workflowExecutionContext.CreateActivityExecutionContextAsync(catchActivity!, options);
+                workflowExecutionContext.AddActivityExecutionContext(catchContext);
+
+                await catchContext.EvaluateInputPropertiesAsync();
+            }
+
+            var scheduleWorkOptions = new ScheduleWorkOptions
+            {
+                CompletionCallback = OnChildCompletedAsync,
+                ExistingActivityExecutionContext = catchContext
+            };
+
+            var catchAll = catchActivity!.CatchAll.Get(catchContext);
+            if (catchAll)
+            {
+                var connections = Connections.Descendants(catchActivity).ToList();
+                if (!connections.Any(x => x.Target.Activity == exceptionActivity || x.Source.Activity == exceptionActivity))
+                    await flowchartContext.ScheduleActivityAsync(catchActivity, scheduleWorkOptions);
+            }
+            else
+            {
+                var catchActivities = catchActivity.CatchActivities?.Get(catchContext);
+                if (catchActivities != null && catchActivities.Contains(exceptionActivity.Id))
+                    await flowchartContext.ScheduleActivityAsync(catchActivity, scheduleWorkOptions);
+            }
+        }
+    }
 }

src/modules/Elsa.Workflows.Core/Middleware/Activities/ExceptionHandlingMiddleware.cs

@@ -1,7 +1,9 @@
 using Elsa.Common.Contracts;
+using Elsa.Extensions;
 using Elsa.Workflows.Contracts;
 using Elsa.Workflows.Models;
 using Elsa.Workflows.Pipelines.ActivityExecution;
+using Elsa.Workflows.Signals;
 using Elsa.Workflows.State;
 using Microsoft.Extensions.Logging;
 
@@ -60,6 +62,8 @@ public async ValueTask InvokeAsync(ActivityExecutionContext context)
 
             var strategy = await _incidentStrategyResolver.ResolveStrategyAsync(context);
             strategy.HandleIncident(context);
+
+            await context.SendSignalAsync(new ExceptionSignal(activity, e));
         }
     }
 }

src/modules/Elsa.Workflows.Core/Signals/ExceptionSignal.cs

@@ -0,0 +1,10 @@
+using Elsa.Workflows.Contracts;
+
+namespace Elsa.Workflows.Signals;
+
+/// <summary>
+/// /// Sent by ExceptionHandlingMiddleware to notify their composite container that it has exception.
+/// </summary>
+/// <param name="Activity">The exception activity</param>
+/// <param name="Exception">The exception</param>
+public record ExceptionSignal(IActivity Activity, Exception Exception);