feat(application): implement MediatR pipeline behaviors for DEX job stages

- Add MainQueryExecutionBehavior
  - Execute main SQL query via ISQLExecutor
  - Populate command.MainQueryResults
  - Throw JobSqlException on failure
- Add CheckQueryExecutionBehavior
  - Execute check SQL query via ISQLExecutor
  - Validate ErrorAction.SkipInsert for zero results
  - Throw JobSqlException on failure/validation error
- Add ReCRequestExecutionBehavior
  - Execute ReC API requests for each main query result
  - Batch ID tracking, error handling
  - Throw JobHttpException on API failures
- Conditional compilation for MediatR signature differences
  - net480: Handle(request, cancellationToken, next)
  - net8.0: Handle(request, next, cancellationToken)
- Refactor TriggeringDEXJobCommand handler: delegate all logic to behaviors

ECMJobRunner.Application/Behaviors/CheckQueryExecutionBehavior.cs

@@ -0,0 +1,116 @@
+using ECMJobRunner.Application.Common.Constants;
+using ECMJobRunner.Application.Common.Dtos;
+using ECMJobRunner.Application.Common.Exceptions;
+using ECMJobRunner.Domain.Interfaces;
+using ECMJobRunner.Application.Common.Options;
+using ECMJobRunner.Application.DEXJob;
+using MediatR;
+using Microsoft.Extensions.Options;
+using System;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ECMJobRunner.Application.Behaviors
+{
+    /// <summary>
+    /// Pipeline behavior that executes the check SQL query for DEX jobs
+    /// Runs after MainQueryExecutionBehavior and validates query results
+    /// </summary>
+    /// <typeparam name="TRequest">The request type</typeparam>
+    /// <typeparam name="TResponse">The response type</typeparam>
+    public class CheckQueryExecutionBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+        where TRequest : notnull
+    {
+        private readonly ISQLExecutor _executor;
+        private readonly DexJobOptions _options;
+
+        /// <summary>
+        /// Initializes a new instance of CheckQueryExecutionBehavior
+        /// </summary>
+        /// <param name="executor">SQL executor for query execution</param>
+        /// <param name="options">DEX job configuration options</param>
+        public CheckQueryExecutionBehavior(ISQLExecutor executor, IOptions<DexJobOptions> options)
+        {
+            _executor = executor;
+            _options = options.Value;
+        }
+
+        /// <summary>
+        /// Handles the pipeline behavior
+        /// Executes check query if request is TriggeringDEXJobCommand
+        /// </summary>
+#if NET48
+        public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
+#else
+        public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+#endif
+        {
+            if (request is TriggeringDEXJobCommand command)
+            {
+                await ExecuteCheckQueryAsync(command, cancellationToken);
+            }
+
+            return await next();
+        }
+
+        private async Task ExecuteCheckQueryAsync(TriggeringDEXJobCommand command, CancellationToken cancel)
+        {
+            if (!string.IsNullOrWhiteSpace(command.Job.SqlCheckQuery))
+            {
+                var sqlCheckQuery = Regex.Replace(
+                    command.Job.SqlCheckQuery!,
+                    _options.Placeholders.BatchId.Pattern,
+                    command.BatchId,
+                    _options.Placeholders.BatchId.RegexOptions);
+
+                try
+                {
+                    var result = await _executor.ExecuteQueryAsync<CheckQueryResult>(sqlCheckQuery, cancel);
+                    if (_options.Error.CheckQuery.OnUnexpectedResult == ErrorAction.Stop)
+                    {
+                        if (result is null)
+                            throw new JobSqlException(
+                                jobName: "Triggering DEX",
+                                processName: "Check Query",
+                                batchId: command.BatchId,
+                                reason: "Check Query returned nothing.",
+                                query: sqlCheckQuery,
+                                innerException: null);
+                        else if (result.ReturnValue <= 0)
+                            throw new JobSqlException(
+                                jobName: "Triggering DEX",
+                                processName: "Check Query",
+                                batchId: command.BatchId,
+                                reason: $"The query unexpectedly returned the value {result.ReturnValue}. The expected value was any value greater than 0.",
+                                query: sqlCheckQuery,
+                                innerException: null);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    if (_options.Error.CheckQuery.OnExecution == ErrorAction.Stop)
+                        throw new JobSqlException(
+                            jobName: "Triggering DEX",
+                            processName: "Check Query",
+                            batchId: command.BatchId,
+                            reason: null,
+                            query: sqlCheckQuery,
+                            innerException: ex
+                        );
+                }
+            }
+            else if (_options.Error.CheckQuery.IfNullOrWhiteSpace == ErrorAction.Stop)
+            {
+                throw new JobSqlException(
+                    jobName:"Triggering DEX", 
+                    processName:"Check Query", 
+                    batchId:command.BatchId, 
+                    reason: "SQL Check Query is null or empty",
+                    query: null,
+                    innerException: null
+                );
+            }
+        }
+    }
+}

ECMJobRunner.Application/Behaviors/MainQueryExecutionBehavior.cs

@@ -0,0 +1,113 @@
+using ECMJobRunner.Application.Common.Constants;
+using ECMJobRunner.Application.Common.Dtos;
+using ECMJobRunner.Application.Common.Exceptions;
+using ECMJobRunner.Domain.Interfaces;
+using ECMJobRunner.Application.Common.Options;
+using ECMJobRunner.Application.DEXJob;
+using MediatR;
+using Microsoft.Extensions.Options;
+using System;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ECMJobRunner.Application.Behaviors
+{
+    /// <summary>
+    /// Pipeline behavior that executes the main SQL query for DEX jobs
+    /// Runs before the command handler and validates query results
+    /// </summary>
+    /// <typeparam name="TRequest">The request type</typeparam>
+    /// <typeparam name="TResponse">The response type</typeparam>
+    public class MainQueryExecutionBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+        where TRequest : notnull
+    {
+        private readonly ISQLExecutor _executor;
+        private readonly DexJobOptions _options;
+
+        /// <summary>
+        /// Initializes a new instance of MainQueryExecutionBehavior
+        /// </summary>
+        /// <param name="executor">SQL executor for query execution</param>
+        /// <param name="options">DEX job configuration options</param>
+        public MainQueryExecutionBehavior(ISQLExecutor executor, IOptions<DexJobOptions> options)
+        {
+            _executor = executor;
+            _options = options.Value;
+        }
+
+        /// <summary>
+        /// Handles the pipeline behavior
+        /// Executes main query if request is TriggeringDEXJobCommand
+        /// </summary>
+#if NET48
+        public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
+#else
+        public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+#endif
+        {
+            if (request is TriggeringDEXJobCommand command)
+            {
+                await ExecuteMainQueryAsync(command, cancellationToken);
+            }
+
+            return await next();
+        }
+
+        private async Task ExecuteMainQueryAsync(TriggeringDEXJobCommand command, CancellationToken cancel)
+        {
+            if (!string.IsNullOrWhiteSpace(command.Job.SqlMainQuery))
+            {
+                var sqlMainQuery = Regex.Replace(
+                    command.Job.SqlMainQuery!,
+                    _options.Placeholders.BatchId.Pattern,
+                    command.BatchId,
+                    _options.Placeholders.BatchId.RegexOptions);
+
+                try
+                {
+                    var result = await _executor.ExecuteQueryAsync<MainQueryResult>(sqlMainQuery, cancel);
+                    if (_options.Error.MainQuery.OnUnexpectedResult == ErrorAction.Stop)
+                    {
+                        if (result is null)
+                            throw new JobSqlException(
+                                jobName: "Triggering DEX",
+                                processName: "Main Query",
+                                batchId: command.BatchId,
+                                reason: "Main Query returned nothing.",
+                                query: sqlMainQuery,
+                                innerException: null);
+                        else if (result.ReturnValue is not null)
+                            throw new JobSqlException(
+                                jobName: "Triggering DEX",
+                                processName: "Main Query",
+                                batchId: command.BatchId,
+                                reason: $"The query unexpectedly returned the value {result.ReturnValue}. The expected value was null.",
+                                query: sqlMainQuery, innerException: null);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    if (_options.Error.MainQuery.OnExecution == ErrorAction.Stop)
+                        throw new JobSqlException(
+                            jobName: "Triggering DEX",
+                            processName: "Main Query",
+                            batchId: command.BatchId,
+                            reason: null,
+                            query: sqlMainQuery,
+                            innerException: ex);
+                }
+            }
+            else if (_options.Error.MainQuery.IfNullOrWhiteSpace == ErrorAction.Stop)
+            {
+                throw new JobSqlException(
+                    jobName: "Triggering DEX",
+                    processName: "Main Query",
+                    batchId: command.BatchId,
+                    reason: "SQL Check Query is null or empty",
+                    query: null,
+                    innerException: null);
+            }
+        }
+    }
+}

ECMJobRunner.Application/Behaviors/ReCRequestExecutionBehavior.cs

@@ -0,0 +1,81 @@
+using ECMJobRunner.Application.Common.Constants;
+using ECMJobRunner.Application.Common.Exceptions;
+using ECMJobRunner.Application.Common.Options;
+using ECMJobRunner.Application.DEXJob;
+using MediatR;
+using Microsoft.Extensions.Options;
+using ReC.Client;
+using ReC.Client.Api;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ECMJobRunner.Application.Behaviors
+{
+    /// <summary>
+    /// Pipeline behavior that sends ReC HTTP request for DEX jobs
+    /// Runs after CheckQueryExecutionBehavior and invokes ReC API
+    /// </summary>
+    /// <typeparam name="TRequest">The request type</typeparam>
+    /// <typeparam name="TResponse">The response type</typeparam>
+    public class ReCRequestExecutionBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+        where TRequest : notnull
+    {
+        private readonly ReCClient _reCClient;
+        private readonly DexJobOptions _options;
+
+        /// <summary>
+        /// Initializes a new instance of ReCRequestExecutionBehavior
+        /// </summary>
+        /// <param name="reCClient">ReC client for HTTP requests</param>
+        /// <param name="options">DEX job configuration options</param>
+        public ReCRequestExecutionBehavior(ReCClient reCClient, IOptions<DexJobOptions> options)
+        {
+            _reCClient = reCClient;
+            _options = options.Value;
+        }
+
+        /// <summary>
+        /// Handles the pipeline behavior
+        /// Sends ReC request if request is TriggeringDEXJobCommand
+        /// </summary>
+#if NET48
+        public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
+#else
+        public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+#endif
+        {
+            if (request is TriggeringDEXJobCommand command)
+            {
+                await SendReCRequestAsync(command, cancellationToken);
+            }
+
+            return await next();
+        }
+
+        private async Task SendReCRequestAsync(TriggeringDEXJobCommand command, CancellationToken cancel)
+        {
+            try
+            {
+                await _reCClient.RecActions.InvokeAsync(command.Job.ProfileId, new InvokeReferences()
+                {
+                    BatchId = command.BatchId,
+                }, cancel);
+            }
+            catch (Exception ex)
+            {
+                if (_options.Error.ReCRequest.OnSending == ErrorAction.Stop)
+                {
+                    throw new JobHttpException(
+                        jobName: "Triggering DEX",
+                        processName: "ReC Http Request",
+                        batchId: command.BatchId,
+                        reason: null,
+                        clientLibrary: "ReC.Client",
+                        clientMethod: "RecActions.InvokeAsync",
+                        innerException: ex);
+                }
+            }
+        }
+    }
+}

ECMJobRunner.Application/DEXJob/TriggeringDEXJobCommand.cs

@@ -1,15 +1,5 @@
-using ECMJobRunner.Application.Common.Constants;
+using ECMJobRunner.Domain.Entities;
-using ECMJobRunner.Application.Common.Dtos;
-using ECMJobRunner.Application.Common.Exceptions;
-using ECMJobRunner.Application.Common.Interfaces;
-using ECMJobRunner.Application.Common.Options;
-using ECMJobRunner.Domain.Entities;
 using MediatR;
-using Microsoft.Extensions.Options;
-using ReC.Client;
-using ReC.Client.Api;
-using System;
-using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -17,7 +7,10 @@ namespace ECMJobRunner.Application.DEXJob
 {
     /// <summary>
     /// Command to trigger a single DEX job execution
-    /// Executes main query, check query, and ReC request in sequence
+    /// Execution logic is handled by pipeline behaviors:
+    /// 1. MainQueryExecutionBehavior - executes main SQL query
+    /// 2. CheckQueryExecutionBehavior - validates with check SQL query
+    /// 3. ReCRequestExecutionBehavior - invokes ReC HTTP request
     /// </summary>
     public class TriggeringDEXJobCommand : IRequest<Unit>
     {
@@ -34,98 +27,25 @@ namespace ECMJobRunner.Application.DEXJob
 
     /// <summary>
     /// Handler for TriggeringDEXJobCommand
-    /// Orchestrates execution of main query, check query, and ReC HTTP request
+    /// All execution logic is delegated to pipeline behaviors
+    /// This handler simply returns completion after behaviors execute
     /// </summary>
-    public class TriggeringDEXJobCommandHandler(
+    public class TriggeringDEXJobCommandHandler : IRequestHandler<TriggeringDEXJobCommand, Unit>
-        ISQLExecutor executor, 
-        IOptions<DexJobOptions> options, 
-        ReCClient reCClient) 
-        : IRequestHandler<TriggeringDEXJobCommand, Unit>
     {
-        private readonly DexJobOptions _options = options.Value;
-
         /// <summary>
         /// Handles the TriggeringDEXJobCommand
-        /// Executes main query, check query, and ReC request according to configuration
+        /// Returns immediately as behaviors perform all work
         /// </summary>
         /// <param name="request">The command containing job and batch ID</param>
-        /// <param name="cancel">Cancellation token</param>
+        /// <param name="cancellationToken">Cancellation token</param>
         /// <returns>Unit value indicating completion</returns>
-        public async Task<Unit> Handle(TriggeringDEXJobCommand request, CancellationToken cancel)
+        public Task<Unit> Handle(TriggeringDEXJobCommand request, CancellationToken cancellationToken)
         {
-            #region Main Query
+            // All execution logic is handled by pipeline behaviors:
-            if (!string.IsNullOrWhiteSpace(request.Job.SqlMainQuery))
+            // - MainQueryExecutionBehavior
-            {
+            // - CheckQueryExecutionBehavior
-                var sqlMainQuery = Regex.Replace(
+            // - ReCRequestExecutionBehavior
-                    request.Job.SqlMainQuery!,
+            return Task.FromResult(Unit.Value);
-                    _options.Placeholders.BatchId.Pattern,
-                    request.BatchId,
-                    _options.Placeholders.BatchId.RegexOptions);
-
-                try
-                {
-                    var result = await executor.ExecuteQueryAsync<MainQueryResult>(sqlMainQuery, cancel);
-                    if (_options.Error.MainQuery.OnUnexpectedResult == ErrorAction.Stop)
-                    {
-                        if (result is null)
-                            throw new DEXJobException("SQL Main Query", request.BatchId, sqlMainQuery, "Main Query returned nothing.");
-                        else if (result.ReturnValue is not null)
-                            throw new DEXJobException("SQL Main Query", request.BatchId, sqlMainQuery, $"The query unexpectedly returned the value {result.ReturnValue}. The expected value was null.");
-                    }
-                }
-                catch (Exception ex)
-                {
-                    if (_options.Error.MainQuery.OnExecution == ErrorAction.Stop)
-                        throw new DEXJobException("SQL Main Query", request.BatchId, sqlMainQuery, ex);
-                }
-            }
-            else if (_options.Error.MainQuery.IfNullOrWhiteSpace == ErrorAction.Stop)
-            {
-                throw new DEXJobException("SQL Main Query", request.BatchId, null, "SQL Main Query is null or empty");
-            }
-            #endregion
-
-            #region Check Query
-            if (!string.IsNullOrWhiteSpace(request.Job.SqlCheckQuery))
-            {
-                var sqlCheckQuery = Regex.Replace(
-                    request.Job.SqlCheckQuery!,
-                    _options.Placeholders.BatchId.Pattern,
-                    request.BatchId,
-                    _options.Placeholders.BatchId.RegexOptions);
-
-                try
-                {
-                    var result = await executor.ExecuteQueryAsync<CheckQueryResult>(sqlCheckQuery, cancel);
-                    if (_options.Error.CheckQuery.OnUnexpectedResult == ErrorAction.Stop)
-                    {
-                        if (result is null)
-                            throw new DEXJobException("SQL Check Query", request.BatchId, sqlCheckQuery, "Check Query returned nothing.");
-                        else if (result.ReturnValue <= 0)
-                            throw new DEXJobException("SQL Check Query", request.BatchId, sqlCheckQuery, $"The query unexpectedly returned the value {result.ReturnValue}. The expected value was any value greater than 0.");
-                    }
-                }
-                catch (Exception ex)
-                {
-                    if (_options.Error.CheckQuery.OnExecution == ErrorAction.Stop)
-                        throw new DEXJobException("SQL Check Query", request.BatchId, sqlCheckQuery, ex);
-                }
-            }
-            else if (_options.Error.CheckQuery.IfNullOrWhiteSpace == ErrorAction.Stop)
-            {
-                throw new DEXJobException("SQL Check Query", request.BatchId, null, "SQL Check Query is null or empty");
-            }
-            #endregion
-
-            #region ReC Request
-            long profileId = request.Job.ProfileId;
-            await reCClient.RecActions.InvokeAsync(profileId, new InvokeReferences()
-            {
-                BatchId = request.BatchId,  // Fixed: Use request.BatchId instead of profileId.ToString()
-            }, cancel);
-            #endregion
-
-            return Unit.Value;  // Fixed: Added missing return statement
         }
     }
 }