Reconciliation Message support added

TransactionProcessor.BusinessLogic.Tests/RequestHandler/TransactionRequestHandlerTests.cs

@@ -44,5 +44,20 @@ public void TransactionRequestHandler_ProcessSaleTransactionRequest_IsHandled()
                             });
 
         }
+
+        [Fact]
+        public void TransactionRequestHandler_ProcessReconciliationRequest_IsHandled()
+        {
+            Mock<ITransactionDomainService> transactionDomainService = new Mock<ITransactionDomainService>();
+            TransactionRequestHandler handler = new TransactionRequestHandler(transactionDomainService.Object);
+
+            ProcessReconciliationRequest command = TestData.ProcessReconciliationRequest;
+
+            Should.NotThrow(async () =>
+                            {
+                                await handler.Handle(command, CancellationToken.None);
+                            });
+
+        }
     }
 }

TransactionProcessor.BusinessLogic.Tests/Requests/RequestTests.cs

@@ -53,5 +53,26 @@ public void ProcessSaleTransactionRequest_CanBeCreated_IsCreated()
             processSaleTransactionRequest.ContractId.ShouldBe(TestData.ContractId);
             processSaleTransactionRequest.ProductId.ShouldBe(TestData.ProductId);
         }
+
+        [Fact]
+        public void ProcessReconciliationRequest_CanBeCreated_IsCreated()
+        {
+            ProcessReconciliationRequest processReconciliationRequest = ProcessReconciliationRequest.Create(TestData.TransactionId,
+                                                                                                            TestData.EstateId,
+                                                                                                            TestData.MerchantId,
+                                                                                                            TestData.DeviceIdentifier,
+                                                                                                            TestData.TransactionDateTime,
+                                                                                                            TestData.ReconciliationTransactionCount,
+                                                                                                            TestData.ReconciliationTransactionValue);
+
+            processReconciliationRequest.ShouldNotBeNull();
+            processReconciliationRequest.EstateId.ShouldBe(TestData.EstateId);
+            processReconciliationRequest.MerchantId.ShouldBe(TestData.MerchantId);
+            processReconciliationRequest.DeviceIdentifier.ShouldBe(TestData.DeviceIdentifier);
+            processReconciliationRequest.TransactionDateTime.ShouldBe(TestData.TransactionDateTime);
+            processReconciliationRequest.TransactionCount.ShouldBe(TestData.ReconciliationTransactionCount);
+            processReconciliationRequest.TransactionValue.ShouldBe(TestData.ReconciliationTransactionValue);
+            processReconciliationRequest.TransactionId.ShouldBe(TestData.TransactionId);
+        }
     }
 }

TransactionProcessor.BusinessLogic/RequestHandlers/TransactionRequestHandler.cs

@@ -10,10 +10,14 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <seealso cref="MediatR.IRequestHandler{TransactionProcessor.BusinessLogic.Requests.ProcessLogonTransactionRequest, TransactionProcessor.Models.ProcessLogonTransactionResponse}" />
+    /// <seealso cref="MediatR.IRequestHandler{TransactionProcessor.BusinessLogic.Requests.ProcessSaleTransactionRequest, TransactionProcessor.Models.ProcessSaleTransactionResponse}" />
+    /// <seealso cref="MediatR.IRequestHandler{TransactionProcessor.BusinessLogic.Requests.ProcessReconciliationRequest, TransactionProcessor.BusinessLogic.Requests.ProcessReconciliationResponse}" />
     /// <seealso cref="MediatR.IRequestHandler{ProcessLogonTransactionRequest, ProcessLogonTransactionResponse}" />
     /// <seealso cref="" />
     public class TransactionRequestHandler : IRequestHandler<ProcessLogonTransactionRequest, ProcessLogonTransactionResponse>,
-                                             IRequestHandler<ProcessSaleTransactionRequest, ProcessSaleTransactionResponse>
+                                             IRequestHandler<ProcessSaleTransactionRequest, ProcessSaleTransactionResponse>,
+                                             IRequestHandler<ProcessReconciliationRequest, ProcessReconciliationTransactionResponse>
     {
         #region Fields
 
@@ -26,6 +30,10 @@ public class TransactionRequestHandler : IRequestHandler<ProcessLogonTransaction
 
         #region Constructors
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TransactionRequestHandler"/> class.
+        /// </summary>
+        /// <param name="transactionDomainService">The transaction domain service.</param>
         public TransactionRequestHandler(ITransactionDomainService transactionDomainService)
         {
             this.TransactionDomainService = transactionDomainService;
@@ -40,7 +48,9 @@ public TransactionRequestHandler(ITransactionDomainService transactionDomainServ
         /// </summary>
         /// <param name="request">The request.</param>
         /// <param name="cancellationToken">The cancellation token.</param>
-        /// <returns></returns>
+        /// <returns>
+        /// Response from the request
+        /// </returns>
         public async Task<ProcessLogonTransactionResponse> Handle(ProcessLogonTransactionRequest request,
                                                                   CancellationToken cancellationToken)
         {
@@ -56,31 +66,56 @@ await this.TransactionDomainService.ProcessLogonTransaction(request.TransactionI
             return logonResponse;
         }
 
-        #endregion
-
         /// <summary>
         /// Handles the specified request.
         /// </summary>
         /// <param name="request">The request.</param>
         /// <param name="cancellationToken">The cancellation token.</param>
-        /// <returns></returns>
+        /// <returns>
+        /// Response from the request
+        /// </returns>
         public async Task<ProcessSaleTransactionResponse> Handle(ProcessSaleTransactionRequest request,
                                                                  CancellationToken cancellationToken)
         {
             ProcessSaleTransactionResponse saleResponse = await this.TransactionDomainService.ProcessSaleTransaction(request.TransactionId,
-                                                                                                                     request.EstateId,
-                                                                                                                     request.MerchantId,
-                                                                                                                     request.TransactionDateTime,
-                                                                                                                     request.TransactionNumber,
-                                                                                                                     request.DeviceIdentifier,
-                                                                                                                     request.OperatorIdentifier,
-                                                                                                                     request.CustomerEmailAddress,
-                                                                                                                     request.AdditionalTransactionMetadata,
-                                                                                                                     request.ContractId,
-                                                                                                                     request.ProductId,
-                                                                                                                     cancellationToken);
+                request.EstateId,
+                request.MerchantId,
+                request.TransactionDateTime,
+                request.TransactionNumber,
+                request.DeviceIdentifier,
+                request.OperatorIdentifier,
+                request.CustomerEmailAddress,
+                request.AdditionalTransactionMetadata,
+                request.ContractId,
+                request.ProductId,
+                cancellationToken);
 
             return saleResponse;
         }
+
+        /// <summary>
+        /// Handles a request
+        /// </summary>
+        /// <param name="request">The request</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <returns>
+        /// Response from the request
+        /// </returns>
+        public async Task<ProcessReconciliationTransactionResponse> Handle(ProcessReconciliationRequest request,
+                                                                           CancellationToken cancellationToken)
+        {
+            ProcessReconciliationTransactionResponse reconciliationResponse= await this.TransactionDomainService.ProcessReconciliationTransaction(request.TransactionId,
+                                                                                         request.EstateId,
+                                                                                         request.MerchantId,
+                                                                                         request.DeviceIdentifier,
+                                                                                         request.TransactionDateTime,
+                                                                                         request.TransactionCount,
+                                                                                         request.TransactionValue,
+                                                                                         cancellationToken);
+
+            return reconciliationResponse;
+        }
+
+        #endregion
     }
 }

TransactionProcessor.BusinessLogic/Requests/ProcessReconciliationRequest.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TransactionProcessor.BusinessLogic.Requests
+{
+    using System.Diagnostics.CodeAnalysis;
+    using MediatR;
+    using Models;
+
+    public class ProcessReconciliationRequest : IRequest<ProcessReconciliationTransactionResponse>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ProcessReconciliationRequest"/> class.
+        /// </summary>
+        /// <param name="transactionId">The transaction identifier.</param>
+        /// <param name="estateId">The estate identifier.</param>
+        /// <param name="merchantId">The merchant identifier.</param>
+        /// <param name="deviceIdentifier">The device identifier.</param>
+        /// <param name="transactionDateTime">The transaction date time.</param>
+        /// <param name="transactionCount">The transaction count.</param>
+        /// <param name="transactionValue">The transaction value.</param>
+        private ProcessReconciliationRequest(Guid transactionId,
+                                             Guid estateId,
+                                             Guid merchantId,
+                                             String deviceIdentifier,
+                                             DateTime transactionDateTime,
+                                             Int32 transactionCount,
+                                             Decimal transactionValue)
+        {
+            this.TransactionId = transactionId;
+            this.EstateId = estateId;
+            this.MerchantId = merchantId;
+            this.DeviceIdentifier = deviceIdentifier;
+            this.TransactionDateTime = transactionDateTime;
+            this.TransactionCount = transactionCount;
+            this.TransactionValue = transactionValue;
+        }
+
+        /// <summary>
+        /// Gets the transaction identifier.
+        /// </summary>
+        /// <value>
+        /// The transaction identifier.
+        /// </value>
+        public Guid TransactionId { get; }
+
+        /// <summary>
+        /// Gets the estate identifier.
+        /// </summary>
+        /// <value>
+        /// The estate identifier.
+        /// </value>
+        public Guid EstateId { get; }
+
+        /// <summary>
+        /// Gets the merchant identifier.
+        /// </summary>
+        /// <value>
+        /// The merchant identifier.
+        /// </value>
+        public Guid MerchantId { get; }
+
+        public String DeviceIdentifier { get; }
+
+        public DateTime TransactionDateTime { get; }
+
+        public Int32 TransactionCount { get; }
+
+        public Decimal TransactionValue { get; }
+
+        public static ProcessReconciliationRequest Create(Guid transactionId,
+                                                          Guid estateId,
+                                                          Guid merchantId,
+                                                          String deviceIdentifier,
+                                                          DateTime transactionDateTime,
+                                                          Int32 transactionCount,
+                                                          Decimal transactionValue)
+        {
+            return new ProcessReconciliationRequest(transactionId, estateId, merchantId, deviceIdentifier, transactionDateTime, transactionCount, transactionValue);
+        }
+    }
+}

TransactionProcessor.BusinessLogic/Services/ITransactionDomainService.cs

@@ -61,6 +61,27 @@ Task<ProcessSaleTransactionResponse> ProcessSaleTransaction(Guid transactionId,
                                                                     Guid productId,
                                                                     CancellationToken cancellationToken);
 
+        /// <summary>
+        /// Processes the reconciliation transaction.
+        /// </summary>
+        /// <param name="transactionId">The transaction identifier.</param>
+        /// <param name="estateId">The estate identifier.</param>
+        /// <param name="merchantId">The merchant identifier.</param>
+        /// <param name="deviceIdentifier">The device identifier.</param>
+        /// <param name="transactionDateTime">The transaction date time.</param>
+        /// <param name="transactionCount">The transaction count.</param>
+        /// <param name="transactionValue">The transaction value.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns></returns>
+        Task<ProcessReconciliationTransactionResponse> ProcessReconciliationTransaction(Guid transactionId,
+                                                                                        Guid estateId,
+                                                                                        Guid merchantId,
+                                                                                        String deviceIdentifier,
+                                                                                        DateTime transactionDateTime,
+                                                                                        Int32 transactionCount,
+                                                                                        Decimal transactionValue,
+                                                                                        CancellationToken cancellationToken);
+
         #endregion
     }
 }