Add resend receipt endpoint and command support

Added support for resending transaction receipts via a new API endpoint and command. Introduced DTOs for request and response, updated the application service and handler logic, and implemented validation. Extended unit and integration tests to cover the new functionality. Refactored integration test table variable names for clarity.

Author: StuartFerguson

TransactionProcessorACL.BusinessLogic.Tests/MediatorTests.cs

@@ -18,6 +18,7 @@ namespace TransactionProcessorACL.BusinessLogic.Tests
 {
     using System.Threading;
     using Microsoft.Extensions.DependencyInjection;
+    using TransactionProcessorACL.BusinessLogic.Requests;
     using TransactionProcessorACL.DataTransferObjects.Requests;
     using Models;
     using Services;
@@ -40,6 +41,7 @@ public MediatorTests()
             this.Requests.Add(TestData.GetMerchantDailyPerformanceSummaryQuery);
             this.Requests.Add(TestData.GetMerchantTransactionMixSummaryQuery);
             this.Requests.Add(TestData.GetRecentActivityReceiptSearchQuery);
+            this.Requests.Add(new TransactionCommands.ResendReceiptCommand(TestData.EstateId, TestData.MerchantId, "RCPT-0001", "recipient@example.com"));
         }
 
         [Fact]
@@ -185,5 +187,14 @@ public async Task<Result<RecentActivityReceiptSearchResponse>> GetRecentActivity
         {
             return Result.Success(new RecentActivityReceiptSearchResponse());
         }
+
+        public async Task<Result<ResendReceiptResponse>> ResendReceipt(Guid estateId,
+                                                                        Guid merchantId,
+                                                                        String reference,
+                                                                        String recipientEmailAddress,
+                                                                        CancellationToken cancellationToken)
+        {
+            return Result.Success(new ResendReceiptResponse { Success = true, Message = "Receipt resend requested." });
+        }
     }
 }

TransactionProcessorACL.BusinessLogic.Tests/RequestHandlerTests.cs

@@ -285,6 +285,33 @@ public async Task ReportingRequestHandler_GetRecentActivityReceiptSearchQuery_Ha
             result.Data.ShouldNotBeNull();
         }
 
+        [Fact]
+        public async Task TransactionRequestHandler_ResendReceiptCommand_Handle_RequestIsHandled()
+        {
+            Mock<ITransactionProcessorACLApplicationService> applicationService = new Mock<ITransactionProcessorACLApplicationService>();
+            applicationService
+                .Setup(a => a.ResendReceipt(It.IsAny<Guid>(),
+                                            It.IsAny<Guid>(),
+                                            It.IsAny<String>(),
+                                            It.IsAny<String>(),
+                                            It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new ResendReceiptResponse { Success = true, Message = "Receipt resend requested." });
+
+            TransactionRequestHandler requestHandler = new TransactionRequestHandler(applicationService.Object);
+
+            TransactionCommands.ResendReceiptCommand command = new(
+                TestData.EstateId,
+                TestData.MerchantId,
+                "RCPT-0001",
+                "recipient@example.com");
+
+            Result<ResendReceiptResponse> result = await requestHandler.Handle(command, CancellationToken.None);
+
+            result.IsSuccess.ShouldBeTrue();
+            result.Data.ShouldNotBeNull();
+            result.Data.Success.ShouldBeTrue();
+        }
+
         #endregion
     }
 }

TransactionProcessorACL.BusinessLogic/RequestHandlers/ProcessLogonTransactionRequestHandler.cs

@@ -16,7 +16,8 @@ namespace TransactionProcessorACL.BusinessLogic.RequestHandlers
     /// <seealso cref="ProcessLogonTransactionResponse" />
     public class TransactionRequestHandler : IRequestHandler<TransactionCommands.ProcessLogonTransactionCommand, Result<ProcessLogonTransactionResponse>>,
         IRequestHandler<TransactionCommands.ProcessReconciliationCommand, Result<ProcessReconciliationResponse>>,
-        IRequestHandler<TransactionCommands.ProcessSaleTransactionCommand, Result<ProcessSaleTransactionResponse>>
+        IRequestHandler<TransactionCommands.ProcessSaleTransactionCommand, Result<ProcessSaleTransactionResponse>>,
+        IRequestHandler<TransactionCommands.ResendReceiptCommand, Result<ResendReceiptResponse>>
     {
         #region Fields
 
@@ -62,7 +63,7 @@ public async Task<Result<ProcessReconciliationResponse>> Handle(TransactionComma
         }
 
         public async Task<Result<ProcessSaleTransactionResponse>> Handle(TransactionCommands.ProcessSaleTransactionCommand command,
-                                                                         CancellationToken cancellationToken)
+                                                                          CancellationToken cancellationToken)
         {
             return await this.ApplicationService.ProcessSaleTransaction((command.EstateId, command.MerchantId),
                 command.TransactionDateTime,
@@ -74,6 +75,16 @@ public async Task<Result<ProcessSaleTransactionResponse>> Handle(TransactionComm
                 cancellationToken);
         }
 
+        public async Task<Result<ResendReceiptResponse>> Handle(TransactionCommands.ResendReceiptCommand command,
+                                                                CancellationToken cancellationToken)
+        {
+            return await this.ApplicationService.ResendReceipt(command.EstateId,
+                                                               command.MerchantId,
+                                                               command.Reference,
+                                                               command.RecipientEmailAddress,
+                                                               cancellationToken);
+        }
+
         #endregion
     }
 }

TransactionProcessorACL.BusinessLogic/Requests/TransactionCommands.cs

@@ -36,4 +36,10 @@ public record ProcessReconciliationCommand(Guid EstateId,
                                                Int32 TransactionCount,
                                                Decimal TransactionValue)
         : IRequest<Result<ProcessReconciliationResponse>>;
+
+    public record ResendReceiptCommand(Guid EstateId,
+                                       Guid MerchantId,
+                                       String Reference,
+                                       String RecipientEmailAddress)
+        : IRequest<Result<ResendReceiptResponse>>;
 }

TransactionProcessorACL.BusinessLogic/Services/ITransactionProcessorACLApplicationService.cs

@@ -73,5 +73,11 @@ Task<Result<MerchantTransactionMixSummaryResponse>> GetMerchantTransactionMixSum
         Task<Result<RecentActivityReceiptSearchResponse>> GetRecentActivityReceiptSearch(Guid estateId,
                                                                                           RecentActivityReceiptSearchRequest request,
                                                                                           CancellationToken cancellationToken);
+
+        Task<Result<ResendReceiptResponse>> ResendReceipt(Guid estateId,
+                                                          Guid merchantId,
+                                                          String reference,
+                                                          String recipientEmailAddress,
+                                                          CancellationToken cancellationToken);
     }
 }

TransactionProcessorACL.BusinessLogic/Services/TransactionProcessorACLApplicationService.cs

@@ -492,6 +492,200 @@ public async Task<Result<RecentActivityReceiptSearchResponse>> GetRecentActivity
             return response;
         }
 
+        public async Task<Result<ResendReceiptResponse>> ResendReceipt(Guid estateId,
+                                                                       Guid merchantId,
+                                                                       String reference,
+                                                                       String recipientEmailAddress,
+                                                                       CancellationToken cancellationToken)
+        {
+            Result<TokenResponse> accessTokenResult = await this.GetAccessToken(cancellationToken);
+            if (accessTokenResult.IsFailed) {
+                return ResultHelpers.CreateFailure(accessTokenResult);
+            }
+
+            if (string.IsNullOrWhiteSpace(reference)) {
+                return Result.Invalid("A transaction reference or receipt reference is required.");
+            }
+
+            if (string.IsNullOrWhiteSpace(recipientEmailAddress)) {
+                return Result.Invalid("Recipient email address is required.");
+            }
+
+            try {
+                _ = new System.Net.Mail.MailAddress(recipientEmailAddress);
+            }
+            catch (FormatException) {
+                return Result.Invalid("Recipient email address is not valid.");
+            }
+
+            Result<ResendReceiptResponse> resendResult = await this.InvokeResendReceiptAsync(accessTokenResult.Data.AccessToken,
+                                                                                              estateId,
+                                                                                              merchantId,
+                                                                                              reference,
+                                                                                              recipientEmailAddress,
+                                                                                              cancellationToken);
+
+            if (resendResult.IsFailed) {
+                return resendResult;
+            }
+
+            return resendResult;
+        }
+
+        private async Task<Result<ResendReceiptResponse>> InvokeResendReceiptAsync(String accessToken,
+                                                                                   Guid estateId,
+                                                                                   Guid merchantId,
+                                                                                   String reference,
+                                                                                   String recipientEmailAddress,
+                                                                                   CancellationToken cancellationToken)
+        {
+            System.Reflection.MethodInfo? method = typeof(ITransactionProcessorClient)
+                .GetMethods()
+                .SingleOrDefault(m => string.Equals(m.Name, "ResendEmailReceipt", StringComparison.Ordinal));
+
+            if (method == null) {
+                return Result.Failure("Receipt resend is not supported by the transaction client.");
+            }
+
+            System.Reflection.ParameterInfo[] parameters = method.GetParameters();
+            object?[] args = new object?[parameters.Length];
+            bool estateAssigned = false;
+            bool merchantAssigned = false;
+            object? request = null;
+
+            for (int index = 0; index < parameters.Length; index++) {
+                System.Reflection.ParameterInfo parameter = parameters[index];
+
+                if (parameter.ParameterType == typeof(String)) {
+                    args[index] = accessToken;
+                    continue;
+                }
+
+                if (parameter.ParameterType == typeof(Guid)) {
+                    if (estateAssigned == false) {
+                        args[index] = estateId;
+                        estateAssigned = true;
+                    }
+                    else if (merchantAssigned == false) {
+                        args[index] = merchantId;
+                        merchantAssigned = true;
+                    }
+                    else {
+                        args[index] = Guid.Empty;
+                    }
+
+                    continue;
+                }
+
+                if (parameter.ParameterType == typeof(CancellationToken)) {
+                    args[index] = cancellationToken;
+                    continue;
+                }
+
+                request ??= System.Activator.CreateInstance(parameter.ParameterType);
+                if (request == null) {
+                    return Result.Failure($"Unable to create resend receipt request type '{parameter.ParameterType.FullName}'.");
+                }
+
+                PopulateResendReceiptRequest(request, estateId, merchantId, reference, recipientEmailAddress);
+                args[index] = request;
+            }
+
+            object? invocationResult = method.Invoke(this.TransactionProcessorClient, args);
+            if (invocationResult is not Task task) {
+                return Result.Failure("Receipt resend call did not return a task.");
+            }
+
+            await task.ConfigureAwait(false);
+
+            object? taskResult = task.GetType().GetProperty("Result")?.GetValue(task);
+            if (taskResult == null) {
+                return Result.Failure("Receipt resend call returned no result.");
+            }
+
+            bool isFailed = (bool)(taskResult.GetType().GetProperty("IsFailed")?.GetValue(taskResult) ?? true);
+            if (isFailed) {
+                string? message = taskResult.GetType().GetProperty("Message")?.GetValue(taskResult)?.ToString();
+                string? status = taskResult.GetType().GetProperty("Status")?.GetValue(taskResult)?.ToString();
+
+                if (string.Equals(status, "NotFound", StringComparison.OrdinalIgnoreCase)) {
+                    return Result.NotFound(message ?? "Receipt could not be found.");
+                }
+
+                if (string.Equals(status, "Invalid", StringComparison.OrdinalIgnoreCase)) {
+                    return Result.Invalid(message ?? "Receipt resend request was invalid.");
+                }
+
+                return Result.Failure(message ?? "Receipt resend failed.");
+            }
+
+            object? data = taskResult.GetType().GetProperty("Data")?.GetValue(taskResult);
+            return Result.Success(MapResendReceiptResponse(data, reference));
+        }
+
+        private static void PopulateResendReceiptRequest(object request,
+                                                         Guid estateId,
+                                                         Guid merchantId,
+                                                         String reference,
+                                                         String recipientEmailAddress)
+        {
+            Type requestType = request.GetType();
+            SetIfPresent(requestType, request, "EstateId", estateId);
+            SetIfPresent(requestType, request, "MerchantId", merchantId);
+            SetIfPresent(requestType, request, "Reference", reference);
+            SetIfPresent(requestType, request, "ReceiptReference", reference);
+            SetIfPresent(requestType, request, "TransactionReference", reference);
+            SetIfPresent(requestType, request, "RecipientEmail", recipientEmailAddress);
+            SetIfPresent(requestType, request, "RecipientEmailAddress", recipientEmailAddress);
+            SetIfPresent(requestType, request, "EmailAddress", recipientEmailAddress);
+        }
+
+        private static void SetIfPresent(Type requestType, object request, String propertyName, object value)
+        {
+            System.Reflection.PropertyInfo? property = requestType.GetProperty(propertyName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.IgnoreCase);
+            if (property == null || property.CanWrite == false) {
+                return;
+            }
+
+            property.SetValue(request, value);
+        }
+
+        private static ResendReceiptResponse MapResendReceiptResponse(object? data, String reference)
+        {
+            ResendReceiptResponse response = new()
+            {
+                Success = true,
+                Message = "Receipt resend requested.",
+                Reference = reference
+            };
+
+            if (data == null) {
+                return response;
+            }
+
+            Type responseType = data.GetType();
+            response.Message = GetStringProperty(responseType, data, "Message") ?? response.Message;
+            response.Reference = GetStringProperty(responseType, data, "Reference") ?? response.Reference;
+            response.ReceiptReference = GetStringProperty(responseType, data, "ReceiptReference");
+            response.TransactionReference = GetStringProperty(responseType, data, "TransactionReference");
+
+            if (string.IsNullOrWhiteSpace(response.Reference) && string.IsNullOrWhiteSpace(response.ReceiptReference) == false) {
+                response.Reference = response.ReceiptReference;
+            }
+
+            if (string.IsNullOrWhiteSpace(response.Reference) && string.IsNullOrWhiteSpace(response.TransactionReference) == false) {
+                response.Reference = response.TransactionReference;
+            }
+
+            return response;
+        }
+
+        private static string? GetStringProperty(Type type, object instance, String propertyName)
+        {
+            System.Reflection.PropertyInfo? property = type.GetProperty(propertyName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.IgnoreCase);
+            return property?.GetValue(instance)?.ToString();
+        }
+
         private static ProcessReconciliationResponse CreateProcessReconciliationResponse(ReconciliationResponse reconciliationResponse)
         {
             return new ProcessReconciliationResponse

TransactionProcessorACL.DataTransferObjects/Requests/ResendReceiptRequestMessage.cs

@@ -0,0 +1,11 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace TransactionProcessorACL.DataTransferObjects.Requests;
+
+[ExcludeFromCodeCoverage]
+public class ResendReceiptRequestMessage
+{
+    public string Reference { get; set; }
+
+    public string RecipientEmailAddress { get; set; }
+}