Refactor envelope creation logic and add IEnvelopeExecutor

Updated CreateEnvelopeCommandHandler to use IEnvelopeExecutor for managing envelope creation. Introduced CreateParmas method for parameter handling in CreateEnvelopeSQL. Corrected Dapper type mapping method name and added service registration for IEnvelopeExecutor in DependencyExtensions. Refactored SQLExecutor to enhance encapsulation. Created EnvelopeExecutor class implementing IEnvelopeExecutor for dedicated envelope operations.

EnvelopeGenerator.Application/Contracts/SQLExecutor/IEnvelopeExecutor.cs

@@ -0,0 +1,19 @@
+using Dapper;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.SQLExecutor;
+
+/// <summary>
+/// 
+/// </summary>
+public interface IEnvelopeExecutor : ISQLExecutor
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="parameters"></param>
+    /// <param name="addUser"></param>
+    /// <param name="cancellation"></param>
+    /// <returns></returns>
+    Task<Envelope?> CreateEnvelopeAsync(DynamicParameters parameters, bool addUser = true, CancellationToken cancellation = default);
+}

EnvelopeGenerator.Application/Envelopes/Commands/CreateEnvelopeCommandHandler.cs

@@ -1,8 +1,6 @@
 using AutoMapper;
-using Dapper;
 using EnvelopeGenerator.Application.Contracts.SQLExecutor;
 using EnvelopeGenerator.Application.SQL;
-using EnvelopeGenerator.Domain.Entities;
 using MediatR;
 
 namespace EnvelopeGenerator.Application.Envelopes.Commands;
@@ -12,18 +10,18 @@ namespace EnvelopeGenerator.Application.Envelopes.Commands;
 /// </summary>
 public class CreateEnvelopeCommandHandler : IRequestHandler<CreateEnvelopeCommand, CreateEnvelopeResponse?>
 {
-    private readonly ISQLExecutor _sqlExecutor;
+    private readonly IEnvelopeExecutor _envelopeExecutor;
 
     private readonly IMapper _mapper;
 
     /// <summary>
     /// 
     /// </summary>
-    /// <param name="sqlExecutor"></param>
+    /// <param name="envelopeExecutor"></param>
     /// <param name="mapper"></param>
-    public CreateEnvelopeCommandHandler(ISQLExecutor<Envelope> sqlExecutor, IMapper mapper)
+    public CreateEnvelopeCommandHandler(IEnvelopeExecutor envelopeExecutor, IMapper mapper)
     {
-        _sqlExecutor = sqlExecutor;
+        _envelopeExecutor = envelopeExecutor;
         _mapper = mapper;
     }
 
@@ -37,7 +35,7 @@ public class CreateEnvelopeCommandHandler : IRequestHandler<CreateEnvelopeComman
     {
         int userId = request.UserId ?? throw new InvalidOperationException("UserId cannot be null when creating an envelope.");
 
-        var envelope = await _sqlExecutor.CreateEnvelopeAsync<Envelope>(userId, request.Title, request.Message, request.TFAEnabled, cancellationToken);
+        var envelope = await _envelopeExecutor.CreateEnvelopeAsync(userId, request.Title, request.Message, request.TFAEnabled, cancellationToken);
 
         return _mapper.Map<CreateEnvelopeResponse>(envelope);
     }

EnvelopeGenerator.Application/SQL/CreateEnvelopeSQL.cs

@@ -34,6 +34,16 @@ public class CreateEnvelopeSQL : ISQL<Envelope>
 /// </summary>
 public static class Extension
 {
+    private static DynamicParameters CreateParmas(int userId, string title = "", string message = "", bool tfaEnabled = false)
+    {
+        var parameters = new DynamicParameters();
+        parameters.Add("@UserId", userId);
+        parameters.Add("@Title", title);
+        parameters.Add("@TfaEnabled", tfaEnabled ? 1 : 0);
+        parameters.Add("@Message", message);
+        return parameters;
+    }
+
     /// <summary>
     /// 
     /// </summary>
@@ -48,13 +58,26 @@ public static class Extension
     public static async Task<TEntity?> CreateEnvelopeAsync<TEntity>(this ISQLExecutor executor, int userId, string title = "", string message = "", bool tfaEnabled = false, CancellationToken cancellation = default)
         where TEntity : class
     {
-        var parameters = new DynamicParameters();
-        parameters.Add("@UserId", userId);
-        parameters.Add("@Title", title);
-        parameters.Add("@TfaEnabled", tfaEnabled ? 1 : 0);
-        parameters.Add("@Message", message);
+        var parameters = CreateParmas(userId, title, message, tfaEnabled);
 
         var envelopes = await executor.Execute<TEntity, CreateEnvelopeSQL>(parameters, cancellation);
         return envelopes.FirstOrDefault();
     }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="executor"></param>
+    /// <param name="userId"></param>
+    /// <param name="title"></param>
+    /// <param name="message"></param>
+    /// <param name="tfaEnabled"></param>
+    /// <param name="cancellation"></param>
+    /// <returns></returns>
+    public static async Task<Envelope?> CreateEnvelopeAsync(this IEnvelopeExecutor executor, int userId, string title = "", string message = "", bool tfaEnabled = false, CancellationToken cancellation = default)
+    {
+        var parameters = CreateParmas(userId, title, message, tfaEnabled);
+
+        return await executor.CreateEnvelopeAsync(parameters, cancellation: cancellation);
+    }
 }

EnvelopeGenerator.Infrastructure/DependencyExtensions.cs

@@ -12,6 +12,7 @@ using EnvelopeGenerator.Infrastructure.Executor;
 using Dapper;
 using System.ComponentModel.DataAnnotations.Schema;
 using System.Reflection;
+using DigitalData.UserManager.Domain.Entities;
 
 namespace EnvelopeGenerator.Infrastructure;
 
@@ -74,11 +75,14 @@ public static class DIExtensions
         services.AddSQLExecutor<DocumentReceiverElement>();
         services.AddSQLExecutor<DocumentStatus>();
 
-        SetDappeTypeMap<Envelope>();
-        SetDappeTypeMap<Receiver>();
-        SetDappeTypeMap<EnvelopeDocument>();
-        SetDappeTypeMap<DocumentReceiverElement>();
-        SetDappeTypeMap<DocumentStatus>();
+        SetDapperTypeMap<Envelope>();
+        SetDapperTypeMap<User>();
+        SetDapperTypeMap<Receiver>();
+        SetDapperTypeMap<EnvelopeDocument>();
+        SetDapperTypeMap<DocumentReceiverElement>();
+        SetDapperTypeMap<DocumentStatus>();
+
+        services.AddScoped<IEnvelopeExecutor, EnvelopeExecutor>();
 
         if (sqlExecutorConfiguration is not null || sqlExecutorConfigureOptions is not null)
             services.AddSQLExecutor(sqlExecutorConfiguration, sqlExecutorConfigureOptions);
@@ -100,7 +104,7 @@ public static class DIExtensions
         return services.AddSingleton<ISQLExecutor, SQLExecutor>();
     }
 
-    private static void SetDappeTypeMap<TModel>()
+    private static void SetDapperTypeMap<TModel>()
     {
         Dapper.SqlMapper.SetTypeMap(typeof(TModel), new CustomPropertyTypeMap(
             typeof(TModel),

EnvelopeGenerator.Infrastructure/Executor/EnvelopeExecutor.cs

@@ -0,0 +1,43 @@
+using Dapper;
+using DigitalData.UserManager.Application.Contracts.Repositories;
+using DigitalData.UserManager.Infrastructure.Repositories;
+using EnvelopeGenerator.Application.Contracts.SQLExecutor;
+using EnvelopeGenerator.Application.SQL;
+using EnvelopeGenerator.Domain.Entities;
+using Microsoft.Data.SqlClient;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace EnvelopeGenerator.Infrastructure.Executor;
+
+public class EnvelopeExecutor : SQLExecutor, IEnvelopeExecutor
+{
+    private readonly IUserRepository _userRepository;
+
+    public EnvelopeExecutor(ILogger<EnvelopeExecutor> logger, IServiceProvider provider, IOptions<SQLExecutorParams> sqlExecutorParamsOptions, IUserRepository userRepository) : base(provider, sqlExecutorParamsOptions)
+    {
+        _userRepository = userRepository;
+    }
+
+    public async Task<Envelope?> CreateEnvelopeAsync(DynamicParameters parameters, bool addUser = true, CancellationToken cancellation = default)
+    {
+        using var connection = new SqlConnection(Params.ConnectionString);
+        var sql = Provider.GetRequiredService<CreateEnvelopeSQL>();
+        await connection.OpenAsync(cancellation);
+        var envelopes = await connection.QueryAsync<Envelope>(sql.Raw, parameters);
+        var envelope = envelopes.FirstOrDefault();
+
+        if (envelope is null)
+            return null;
+
+        // Add User
+        if (addUser)
+        {
+            var user = await _userRepository.ReadByIdAsync(envelope.UserId);
+            envelope.User = user;
+        }
+
+        return envelope;
+    }
+}

EnvelopeGenerator.Infrastructure/Executor/SQLExecutor.cs

@@ -8,26 +8,26 @@ namespace EnvelopeGenerator.Infrastructure.Executor;
 
 public class SQLExecutor : ISQLExecutor
 {
-    private readonly SQLExecutorParams _params;
+    protected readonly SQLExecutorParams Params;
 
-    private readonly IServiceProvider _provider;
+    protected readonly IServiceProvider Provider;
 
     public SQLExecutor(IServiceProvider provider, IOptions<SQLExecutorParams> sqlExecutorParamsOptions)
     {
-        _provider = provider;
-        _params = sqlExecutorParamsOptions.Value;
+        Provider = provider;
+        Params = sqlExecutorParamsOptions.Value;
     }
 
     public async Task<IEnumerable<TEntity>> Execute<TEntity>(string sql, DynamicParameters parameters, CancellationToken cancellation = default)
     {
-        using var connection = new SqlConnection(_params.ConnectionString);
+        using var connection = new SqlConnection(Params.ConnectionString);
         await connection.OpenAsync(cancellation);
         return await connection.QueryAsync<TEntity>(sql, parameters);
     }
 
     public Task<IEnumerable<TEntity>> Execute<TEntity, TSQL>(DynamicParameters parameters, CancellationToken cancellation = default) where TSQL : ISQL
     {
-        var sql = _provider.GetRequiredService<TSQL>();
+        var sql = Provider.GetRequiredService<TSQL>();
         return Execute<TEntity>(sql.Raw, parameters, cancellation);
     }
 }