Initial Transaction Flow to Operator Proxy

TransactionProcessor.BusinessLogic.Tests/RequestHandler/TransactionRequestHandlerTests.cs

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

TransactionProcessor.BusinessLogic.Tests/Requests/RequestTests.cs

@@ -14,16 +14,38 @@ public class RequestTests
         [Fact]
         public void ProcessLogonTransactionRequest_CanBeCreated_IsCreated()
         {
-            ProcessLogonTransactionRequest processLogonTransactionRequest = ProcessLogonTransactionRequest.Create(TestData.TransactionId, TestData.EstateId, TestData.MerchantId, TestData.DeviceIdentifier,TestData.TransactionType, TestData.TransactionDateTime,
+            ProcessLogonTransactionRequest processLogonTransactionRequest = ProcessLogonTransactionRequest.Create(TestData.TransactionId, TestData.EstateId, TestData.MerchantId, TestData.DeviceIdentifier,TestData.TransactionTypeLogon.ToString(), TestData.TransactionDateTime,
                                                                                                                   TestData.TransactionNumber);
 
             processLogonTransactionRequest.ShouldNotBeNull();
             processLogonTransactionRequest.EstateId.ShouldBe(TestData.EstateId);
             processLogonTransactionRequest.MerchantId.ShouldBe(TestData.MerchantId);
             processLogonTransactionRequest.DeviceIdentifier.ShouldBe(TestData.DeviceIdentifier);
-            processLogonTransactionRequest.TransactionType.ShouldBe(TestData.TransactionType);
+            processLogonTransactionRequest.TransactionType.ShouldBe(TestData.TransactionTypeLogon.ToString());
             processLogonTransactionRequest.TransactionDateTime.ShouldBe(TestData.TransactionDateTime);
             processLogonTransactionRequest.TransactionNumber.ShouldBe(TestData.TransactionNumber);
+            processLogonTransactionRequest.TransactionId.ShouldBe(processLogonTransactionRequest.TransactionId);
+        }
+
+        [Fact]
+        public void ProcessSaleTransactionRequest_CanBeCreated_IsCreated()
+        {
+            ProcessSaleTransactionRequest processSaleTransactionRequest = ProcessSaleTransactionRequest.Create(TestData.TransactionId, TestData.EstateId, TestData.MerchantId, TestData.DeviceIdentifier, TestData.TransactionTypeLogon.ToString(), TestData.TransactionDateTime,
+                                                                                                               TestData.TransactionNumber,
+                                                                                                               TestData.OperatorIdentifier,
+                                                                                                               TestData.AdditionalTransactionMetaData);
+
+            processSaleTransactionRequest.ShouldNotBeNull();
+            processSaleTransactionRequest.EstateId.ShouldBe(TestData.EstateId);
+            processSaleTransactionRequest.MerchantId.ShouldBe(TestData.MerchantId);
+            processSaleTransactionRequest.DeviceIdentifier.ShouldBe(TestData.DeviceIdentifier);
+            processSaleTransactionRequest.TransactionType.ShouldBe(TestData.TransactionTypeLogon.ToString());
+            processSaleTransactionRequest.TransactionDateTime.ShouldBe(TestData.TransactionDateTime);
+            processSaleTransactionRequest.TransactionNumber.ShouldBe(TestData.TransactionNumber);
+            processSaleTransactionRequest.TransactionId.ShouldBe(TestData.TransactionId);
+            processSaleTransactionRequest.OperatorIdentifier.ShouldBe(TestData.OperatorIdentifier);
+            processSaleTransactionRequest.AdditionalTransactionMetadata.ShouldNotBeNull();
+            processSaleTransactionRequest.AdditionalTransactionMetadata.Count.ShouldBe(TestData.AdditionalTransactionMetaData.Count);
         }
     }
 }

TransactionProcessor.BusinessLogic.Tests/TransactionProcessor.BusinessLogic.Tests.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
-    <DebugType>Full</DebugType>
+    <DebugType>None</DebugType>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 

TransactionProcessor.BusinessLogic/OperatorInterfaces/ISafaricomProxy.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TransactionProcessor.BusinessLogic.OperatorInterfaces
+{
+    using System.Diagnostics.CodeAnalysis;
+    using System.Net;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    public interface IOperatorProxy
+    {
+        Task ProcessMessage(CancellationToken cancellationToken);
+    }
+
+    [ExcludeFromCodeCoverage]
+    public class SafaricomPinlessProxy : IOperatorProxy
+    {
+        public async Task ProcessMessage(CancellationToken cancellationToken)
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    /*http://{{linuxservername}}:8000/api/safaricom?
+     VENDOR=D-S136 - Fixed
+     &REQTYPE=EXRCTRFREQ - Fixed
+     &DATA=
+     <?xml version="1.0" encoding="utf-8"?>
+        <ns0:COMMAND xmlns:ns0="http://safaricom.co.ke/Pinless/keyaccounts/">
+            <ns0:TYPE>EXRCTRFREQ</ns0:TYPE> - Fixed
+            <ns0:DATE>02-JUL-2018</ns0:DATE> - From Sales Transaction 
+            <ns0:EXTNWCODE>SA</ns0:EXTNWCODE> - Fixed
+            <ns0:MSISDN>700945625</ns0:MSISDN> - Config
+            <ns0:PIN>0322</ns0:PIN> - Config
+            <ns0:LOGINID>D-S136</ns0:LOGINID> - Config
+            <ns0:PASSWORD>@SafePay33</ns0:PASSWORD> - Config
+            <ns0:EXTCODE>D-S136</ns0:EXTCODE> - Config ?
+            <ns0:EXTREFNUM>100022814</ns0:EXTREFNUM> - From Sales Transaction 
+            <ns0:MSISDN2>0723581504</ns0:MSISDN2> - From Sales Transaction 
+            <ns0:AMOUNT>65000</ns0:AMOUNT> - From Sales Transaction 
+            <ns0:LANGUAGE1>0</ns0:LANGUAGE1> - Fixed
+            <ns0:LANGUAGE2>0</ns0:LANGUAGE2> - Fixed
+            <ns0:SELECTOR>1</ns0:SELECTOR> - Fixed
+        </ns0:COMMAND>*/
+}

TransactionProcessor.BusinessLogic/RequestHandlers/TransactionRequestHandler.cs

@@ -12,7 +12,8 @@
     /// </summary>
     /// <seealso cref="MediatR.IRequestHandler{TransactionProcessor.BusinessLogic.Requests.ProcessLogonTransactionRequest, TransactionProcessor.Models.ProcessLogonTransactionResponse}" />
     /// <seealso cref="" />
-    public class TransactionRequestHandler : IRequestHandler<ProcessLogonTransactionRequest, ProcessLogonTransactionResponse> 
+    public class TransactionRequestHandler : IRequestHandler<ProcessLogonTransactionRequest, ProcessLogonTransactionResponse>,
+                                             IRequestHandler<ProcessSaleTransactionRequest, ProcessSaleTransactionResponse>
     {
         #region Fields
 
@@ -34,6 +35,12 @@ public TransactionRequestHandler(ITransactionDomainService transactionDomainServ
 
         #region Methods
 
+        /// <summary>
+        /// Handles the specified request.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns></returns>
         public async Task<ProcessLogonTransactionResponse> Handle(ProcessLogonTransactionRequest request,
                                                                   CancellationToken cancellationToken)
         {
@@ -50,5 +57,27 @@ await this.TransactionDomainService.ProcessLogonTransaction(request.TransactionI
         }
 
         #endregion
+
+        /// <summary>
+        /// Handles the specified request.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns></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.AdditionalTransactionMetadata,
+                                                                                                                     cancellationToken);
+
+            return saleResponse;
+        }
     }
 }

TransactionProcessor.BusinessLogic/Requests/ProcessSaleTransactionRequest.cs

@@ -0,0 +1,164 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TransactionProcessor.BusinessLogic.Requests
+{
+    using MediatR;
+    using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+    using Models;
+
+    public class ProcessSaleTransactionRequest : IRequest<ProcessSaleTransactionResponse>
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ProcessSaleTransactionRequest" /> 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="transactionType">Type of the transaction.</param>
+        /// <param name="transactionDateTime">The transaction date time.</param>
+        /// <param name="transactionNumber">The transaction number.</param>
+        /// <param name="operatorIdentifier">The operator identifier.</param>
+        /// <param name="additionalTransactionMetadata">The additional transaction metadata.</param>
+        private ProcessSaleTransactionRequest(Guid transactionId,
+                                              Guid estateId,
+                                              Guid merchantId,
+                                              String deviceIdentifier,
+                                              String transactionType,
+                                              DateTime transactionDateTime,
+                                              String transactionNumber,
+                                              String operatorIdentifier,
+                                              Dictionary<String, String> additionalTransactionMetadata)
+        {
+            this.TransactionId = transactionId;
+            this.EstateId = estateId;
+            this.DeviceIdentifier = deviceIdentifier;
+            this.MerchantId = merchantId;
+            this.TransactionDateTime = transactionDateTime;
+            this.TransactionNumber = transactionNumber;
+            this.OperatorIdentifier = operatorIdentifier;
+            this.AdditionalTransactionMetadata = additionalTransactionMetadata;
+            this.TransactionType = transactionType;
+        }
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets the device identifier.
+        /// </summary>
+        /// <value>
+        /// The device identifier.
+        /// </value>
+        public String DeviceIdentifier { 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; }
+
+        /// <summary>
+        /// Gets the transaction date time.
+        /// </summary>
+        /// <value>
+        /// The transaction date time.
+        /// </value>
+        public DateTime TransactionDateTime { get; }
+
+        /// <summary>
+        /// Gets the transaction identifier.
+        /// </summary>
+        /// <value>
+        /// The transaction identifier.
+        /// </value>
+        public Guid TransactionId { get; }
+
+        /// <summary>
+        /// Gets the transaction number.
+        /// </summary>
+        /// <value>
+        /// The transaction number.
+        /// </value>
+        public String TransactionNumber { get; }
+
+        /// <summary>
+        /// Gets the type of the transaction.
+        /// </summary>
+        /// <value>
+        /// The type of the transaction.
+        /// </value>
+        public String TransactionType { get; }
+
+        /// <summary>
+        /// Gets or sets the operator identifier.
+        /// </summary>
+        /// <value>
+        /// The operator identifier.
+        /// </value>
+        public String OperatorIdentifier { get; }
+
+        /// <summary>
+        /// Gets or sets the additional transaction metadata.
+        /// </summary>
+        /// <value>
+        /// The additional transaction metadata.
+        /// </value>
+        public Dictionary<String, String> AdditionalTransactionMetadata { get; }
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Creates the specified estate identifier.
+        /// </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="transactionType">Type of the transaction.</param>
+        /// <param name="transactionDateTime">The transaction date time.</param>
+        /// <param name="transactionNumber">The transaction number.</param>
+        /// <param name="operatorIdentifier">The operator identifier.</param>
+        /// <param name="additionalTransactionMetadata">The additional transaction metadata.</param>
+        /// <returns></returns>
+        public static ProcessSaleTransactionRequest Create(Guid transactionId,
+                                                           Guid estateId,
+                                                           Guid merchantId,
+                                                           String deviceIdentifier,
+                                                           String transactionType,
+                                                           DateTime transactionDateTime,
+                                                           String transactionNumber,
+                                                           String operatorIdentifier,
+                                                           Dictionary<String, String> additionalTransactionMetadata)
+        {
+            return new ProcessSaleTransactionRequest(transactionId,
+                                                     estateId,
+                                                     merchantId,
+                                                     deviceIdentifier,
+                                                     transactionType,
+                                                     transactionDateTime,
+                                                     transactionNumber,
+                                                     operatorIdentifier,
+                                                     additionalTransactionMetadata);
+        }
+
+        #endregion
+    }
+}

TransactionProcessor.BusinessLogic/Services/ITransactionDomainService.cs

@@ -1,6 +1,7 @@
 namespace TransactionProcessor.BusinessLogic.Services
 {
     using System;
+    using System.Collections.Generic;
     using System.Threading;
     using System.Threading.Tasks;
     using Models;
@@ -23,8 +24,36 @@ public interface ITransactionDomainService
         /// <param name="deviceIdentifier">The device identifier.</param>
         /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns></returns>
-        Task<ProcessLogonTransactionResponse> ProcessLogonTransaction(Guid transactionId, Guid estateId, Guid merchantId, DateTime transactionDateTime,
-                                                                      String transactionNumber, String deviceIdentifier, CancellationToken cancellationToken);
+        Task<ProcessLogonTransactionResponse> ProcessLogonTransaction(Guid transactionId,
+                                                                      Guid estateId,
+                                                                      Guid merchantId,
+                                                                      DateTime transactionDateTime,
+                                                                      String transactionNumber,
+                                                                      String deviceIdentifier,
+                                                                      CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Processes the sale 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="transactionDateTime">The transaction date time.</param>
+        /// <param name="transactionNumber">The transaction number.</param>
+        /// <param name="deviceIdentifier">The device identifier.</param>
+        /// <param name="operatorId">The operator identifier.</param>
+        /// <param name="additionalTransactionMetadata">The additional transaction metadata.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns></returns>
+        Task<ProcessSaleTransactionResponse> ProcessSaleTransaction(Guid transactionId,
+                                                                    Guid estateId,
+                                                                    Guid merchantId,
+                                                                    DateTime transactionDateTime,
+                                                                    String transactionNumber,
+                                                                    String deviceIdentifier,
+                                                                    String operatorId,
+                                                                    Dictionary<String, String> additionalTransactionMetadata,
+                                                                    CancellationToken cancellationToken);
 
         #endregion
     }