Merge pull request #599 from TransactionProcessing/copilot/dc3061045dc208c2e8ccc1109986021d-reduce-method-com

Reduce `ProcessReconciliation` method size by extracting reconciliation helpers

Author: StuartFerguson

TransactionProcessorACL.BusinessLogic.Tests/TransactionProcessorACLApplicationServiceTests.cs

@@ -1,6 +1,7 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Text;
+using Newtonsoft.Json;
 using SimpleResults;
 
 namespace TransactionProcessorACL.BusinesssLogic.Tests
@@ -237,6 +238,40 @@ public async Task TransactionProcessorACLApplicationService_ProcessReconciliatio
             reconciliationResponse.ResponseCode.ShouldBe(TestData.ResponseCode);
         }
 
+        [Fact]
+        public async Task TransactionProcessorACLApplicationService_ProcessReconciliation_RequestIsSerialisedCorrectly()
+        {
+            SerialisedMessage capturedMessage = null;
+
+            transactionProcessorClient.Setup(t => t.PerformTransaction(It.IsAny<String>(), It.IsAny<SerialisedMessage>(), It.IsAny<CancellationToken>()))
+                                      .Callback<String, SerialisedMessage, CancellationToken>((_, message, _) => capturedMessage = message)
+                                      .ReturnsAsync(TestData.SerialisedMessageResponseReconciliation);
+            securityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.TokenResponse));
+
+            await applicationService.ProcessReconciliation(TestData.EstateId,
+                                                           TestData.MerchantId,
+                                                           TestData.TransactionDateTime,
+                                                           TestData.DeviceIdentifier,
+                                                           TestData.ReconciliationTransactionCount,
+                                                           TestData.ReconciliationTransactionValue,
+                                                           CancellationToken.None);
+
+            capturedMessage.ShouldNotBeNull();
+            capturedMessage.Metadata[MetadataContants.KeyNameEstateId].ShouldBe(TestData.EstateId.ToString());
+            capturedMessage.Metadata[MetadataContants.KeyNameMerchantId].ShouldBe(TestData.MerchantId.ToString());
+
+            ReconciliationRequest reconciliationRequest = JsonConvert.DeserializeObject<ReconciliationRequest>(capturedMessage.SerialisedData,
+                new JsonSerializerSettings {
+                    TypeNameHandling = TypeNameHandling.All
+                });
+
+            reconciliationRequest.ShouldNotBeNull();
+            reconciliationRequest.DeviceIdentifier.ShouldBe(TestData.DeviceIdentifier);
+            reconciliationRequest.TransactionDateTime.ShouldBe(TestData.TransactionDateTime);
+            reconciliationRequest.TransactionCount.ShouldBe(TestData.ReconciliationTransactionCount);
+            reconciliationRequest.TransactionValue.ShouldBe(TestData.ReconciliationTransactionValue);
+        }
+
         [Fact]
         public async Task TransactionProcessorACLApplicationService_ProcessReconciliation_GetTokenFailed_ResultFailed()
         {

TransactionProcessorACL.BusinessLogic/Services/TransactionProcessorACLApplicationService.cs

@@ -250,52 +250,25 @@ public async Task<Result<ProcessReconciliationResponse>> ProcessReconciliation(G
             }
 
             TokenResponse accessToken = accessTokenResult.Data;
-            ReconciliationRequest reconciliationRequest = new ReconciliationRequest();
-            reconciliationRequest.DeviceIdentifier = deviceIdentifier;
-            reconciliationRequest.TransactionDateTime = transactionDateTime;
-            reconciliationRequest.TransactionCount = transactionCount;
-            reconciliationRequest.TransactionValue = transactionValue;
-
-            SerialisedMessage requestSerialisedMessage = new SerialisedMessage();
-            requestSerialisedMessage.Metadata.Add(MetadataContants.KeyNameEstateId, estateId.ToString());
-            requestSerialisedMessage.Metadata.Add(MetadataContants.KeyNameMerchantId, merchantId.ToString());
-            requestSerialisedMessage.SerialisedData = JsonConvert.SerializeObject(reconciliationRequest,
-                                                                                  new JsonSerializerSettings
-                                                                                  {
-                                                                                      TypeNameHandling = TypeNameHandling.All
-                                                                                  });
-
-            ProcessReconciliationResponse response = null;
+            SerialisedMessage requestSerialisedMessage = CreateReconciliationRequestMessage(estateId,
+                                                                                            merchantId,
+                                                                                            transactionDateTime,
+                                                                                            deviceIdentifier,
+                                                                                            transactionCount,
+                                                                                            transactionValue);
 
             try
             {
                 Result<SerialisedMessage> transactionResult = 
                     await this.TransactionProcessorClient.PerformTransaction(accessToken.AccessToken, requestSerialisedMessage, cancellationToken);
                 if (transactionResult.IsFailed)
                     return ResultHelpers.CreateFailure(transactionResult);
-                SerialisedMessage responseSerialisedMessage = transactionResult.Data;
-                ReconciliationResponse reconciliationResponse = JsonConvert.DeserializeObject<ReconciliationResponse>(responseSerialisedMessage.SerialisedData);
-
-                response = new ProcessReconciliationResponse
-                {
-                    ResponseCode = reconciliationResponse.ResponseCode,
-                    ResponseMessage = reconciliationResponse.ResponseMessage,
-                    TransactionId = reconciliationResponse.TransactionId,
-                };
+                return Result.Success(CreateProcessReconciliationResponse(transactionResult.Data));
             }
             catch (Exception ex)
             {
-                response = new ProcessReconciliationResponse
-                {
-                    ResponseCode = "0001", // Request Message error
-                    ResponseMessage = "Process Reconciliation Failed",
-                    EstateId = estateId,
-                    MerchantId = merchantId,
-                    ErrorMessages = ex.GetExceptionMessages()
-                };
+                return Result.Success(CreateReconciliationErrorResponse(estateId, merchantId, ex));
             }
-
-            return Result.Success(response);
         }
 
         public async Task<GetVoucherResponse> GetVoucher(Guid estateId,
@@ -526,6 +499,59 @@ public async Task<Result<MerchantResponse>> GetMerchant(Guid estateId,
             return merchantResponse;
         }
 
+        private static ProcessReconciliationResponse CreateProcessReconciliationResponse(SerialisedMessage responseSerialisedMessage)
+        {
+            ReconciliationResponse reconciliationResponse = JsonConvert.DeserializeObject<ReconciliationResponse>(responseSerialisedMessage.SerialisedData);
+
+            return new ProcessReconciliationResponse
+            {
+                ResponseCode = reconciliationResponse.ResponseCode,
+                ResponseMessage = reconciliationResponse.ResponseMessage,
+                TransactionId = reconciliationResponse.TransactionId,
+            };
+        }
+
+        private static ProcessReconciliationResponse CreateReconciliationErrorResponse(Guid estateId,
+                                                                                       Guid merchantId,
+                                                                                       Exception ex)
+        {
+            return new ProcessReconciliationResponse
+            {
+                ResponseCode = "0001", // Request Message error
+                ResponseMessage = "Process Reconciliation Failed",
+                EstateId = estateId,
+                MerchantId = merchantId,
+                ErrorMessages = ex.GetExceptionMessages()
+            };
+        }
+
+        private static SerialisedMessage CreateReconciliationRequestMessage(Guid estateId,
+                                                                            Guid merchantId,
+                                                                            DateTime transactionDateTime,
+                                                                            String deviceIdentifier,
+                                                                            Int32 transactionCount,
+                                                                            Decimal transactionValue)
+        {
+            ReconciliationRequest reconciliationRequest = new ReconciliationRequest
+            {
+                DeviceIdentifier = deviceIdentifier,
+                TransactionDateTime = transactionDateTime,
+                TransactionCount = transactionCount,
+                TransactionValue = transactionValue
+            };
+
+            SerialisedMessage requestSerialisedMessage = new SerialisedMessage();
+            requestSerialisedMessage.Metadata.Add(MetadataContants.KeyNameEstateId, estateId.ToString());
+            requestSerialisedMessage.Metadata.Add(MetadataContants.KeyNameMerchantId, merchantId.ToString());
+            requestSerialisedMessage.SerialisedData = JsonConvert.SerializeObject(reconciliationRequest,
+                                                                                  new JsonSerializerSettings
+                                                                                  {
+                                                                                      TypeNameHandling = TypeNameHandling.All
+                                                                                  });
+
+            return requestSerialisedMessage;
+        }
+
         #endregion
     }
 }