use a manager in Pending Settlement query handler

TransactionProcessor.BusinessLogic.Tests/Mediator/DummyEstateManagementManager.cs

@@ -83,4 +83,11 @@ public async Task<Result<List<SettlementModel>>> GetSettlements(Guid estateId,
                                                                     CancellationToken cancellationToken) {
         return Result.Success(new List<SettlementModel>());
     }
+
+    public async Task<Result<PendingSettlementModel>> GetPendingSettlement(Guid estateId,
+                                                                           Guid merchantId,
+                                                                           DateTime settlementDate,
+                                                                           CancellationToken cancellationToken) {
+        return Result.Success(new PendingSettlementModel());
+    }
 }

TransactionProcessor.BusinessLogic.Tests/RequestHandler/SettlementRequestHandlerTests.cs

@@ -21,9 +21,8 @@ public class SettlementRequestHandlerTests
     public async Task SettlementRequestHandler_ProcessSettlementRequest_IsHandled()
     {
         Mock<ISettlementDomainService> settlementDomainService = new Mock<ISettlementDomainService>();
-        Mock<IAggregateService> aggregateService = new();
         Mock<ITransactionProcessorManager> manager = new Mock<ITransactionProcessorManager>();
-        SettlementRequestHandler handler = new SettlementRequestHandler(settlementDomainService.Object, aggregateService.Object, manager.Object);
+        SettlementRequestHandler handler = new SettlementRequestHandler(settlementDomainService.Object, manager.Object);
         settlementDomainService
             .Setup(s => s.ProcessSettlement(It.IsAny<SettlementCommands.ProcessSettlementCommand>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
         var command = TestData.Commands.ProcessSettlementCommand;

TransactionProcessor.BusinessLogic/Manager/ITransactionProcessorManager.cs

@@ -57,6 +57,11 @@ Task<Result<List<SettlementModel>>> GetSettlements(Guid estateId,
                                                            String endDate,
                                                            CancellationToken cancellationToken);
 
+        Task<Result<PendingSettlementModel>> GetPendingSettlement(Guid estateId,
+                                                            Guid merchantId,
+                                                            DateTime settlementDate,
+                                                            CancellationToken cancellationToken);
+
         #endregion
     }
 }

TransactionProcessor.BusinessLogic/Manager/TransactionProcessorManager.cs

@@ -1,18 +1,20 @@
-using System;
+using Shared.DomainDrivenDesign.EventSourcing;
+using Shared.EventStore.Aggregate;
+using Shared.Results;
+using SimpleResults;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Shared.DomainDrivenDesign.EventSourcing;
-using Shared.EventStore.Aggregate;
-using Shared.Results;
-using SimpleResults;
 using TransactionProcessor.Aggregates;
+using TransactionProcessor.BusinessLogic.Common;
 using TransactionProcessor.BusinessLogic.Services;
 using TransactionProcessor.Models.Contract;
 using TransactionProcessor.Models.Merchant;
 using TransactionProcessor.Models.Settlement;
 using TransactionProcessor.Repository;
+using static TransactionProcessor.BusinessLogic.Requests.SettlementQueries;
 using Contract = TransactionProcessor.Models.Contract.Contract;
 using Operator = TransactionProcessor.Models.Estate.Operator;
 
@@ -246,6 +248,31 @@ public async Task<Result<List<SettlementModel>>> GetSettlements(Guid estateId,
             return await this.TransactionProcessorReadModelRepository.GetSettlements(estateId, merchantId, startDate, endDate, cancellationToken);
         }
 
+        public async Task<Result<PendingSettlementModel>> GetPendingSettlement(Guid estateId,
+                                                                               Guid merchantId,
+                                                                               DateTime settlementDate,
+                                                                               CancellationToken cancellationToken) {
+
+            Guid aggregateId = Helpers.CalculateSettlementAggregateId(settlementDate, merchantId, estateId);
+
+            Result<SettlementAggregate> getSettlementResult = await this.AggregateService.GetLatest<SettlementAggregate>(aggregateId, cancellationToken);
+            if (getSettlementResult.IsFailed)
+                return ResultHelpers.CreateFailure(getSettlementResult);
+
+            SettlementAggregate settlementAggregate = getSettlementResult.Data;
+
+            PendingSettlementModel model = new PendingSettlementModel {
+                EstateId = settlementAggregate.EstateId,
+                MerchantId = settlementAggregate.MerchantId,
+                NumberOfFeesPendingSettlement = settlementAggregate.GetNumberOfFeesPendingSettlement(),
+                NumberOfFeesSettled = settlementAggregate.GetNumberOfFeesSettled(),
+                SettlementDate = settlementAggregate.SettlementDate,
+                SettlementCompleted = settlementAggregate.SettlementComplete,
+            };
+
+            return Result.Success(model);
+        }
+
         #endregion
     }
 }

TransactionProcessor.BusinessLogic/RequestHandlers/SettlementRequestHandler.cs

@@ -19,19 +19,16 @@ namespace TransactionProcessor.BusinessLogic.RequestHandlers
     public class SettlementRequestHandler : IRequestHandler<SettlementCommands.ProcessSettlementCommand, Result<Guid>>,
                                             IRequestHandler<SettlementCommands.AddMerchantFeePendingSettlementCommand, Result>,
                                             IRequestHandler<SettlementCommands.AddSettledFeeToSettlementCommand, Result>,
-                                            IRequestHandler<SettlementQueries.GetPendingSettlementQuery, Result<SettlementAggregate>>,
+                                            IRequestHandler<SettlementQueries.GetPendingSettlementQuery, Result<PendingSettlementModel>>,
                                             IRequestHandler<SettlementQueries.GetSettlementQuery, Result<SettlementModel>>,
                                             IRequestHandler<SettlementQueries.GetSettlementsQuery, Result<List<SettlementModel>>>
     {
         private readonly ISettlementDomainService SettlementDomainService;
-        private readonly IAggregateService AggregateService;
         private readonly ITransactionProcessorManager TransactionProcessorManager;
 
         public SettlementRequestHandler(ISettlementDomainService settlementDomainService,
-                                        IAggregateService aggregateService,
                                         ITransactionProcessorManager transactionProcessorManager) {
             this.SettlementDomainService = settlementDomainService;
-            this.AggregateService = aggregateService;
             this.TransactionProcessorManager = transactionProcessorManager;
         }
 
@@ -51,19 +48,9 @@ public async Task<Result> Handle(SettlementCommands.AddSettledFeeToSettlementCom
             return await this.SettlementDomainService.AddSettledFeeToSettlement(command, cancellationToken);
         }
 
-        public async Task<Result<SettlementAggregate>> Handle(SettlementQueries.GetPendingSettlementQuery query,
-                                                              CancellationToken cancellationToken) {
-            // TODO: Convert to using a manager/model/factory
-            // Convert the date passed in to a guid
-            Guid aggregateId = Helpers.CalculateSettlementAggregateId(query.SettlementDate, query.MerchantId, query.EstateId);
-
-            Result<SettlementAggregate> getSettlementResult = await this.AggregateService.GetLatest<SettlementAggregate>(aggregateId, cancellationToken);
-            if (getSettlementResult.IsFailed)
-                return getSettlementResult;
-
-            SettlementAggregate settlementAggregate = getSettlementResult.Data;
-
-            return Result.Success(settlementAggregate);
+        public async Task<Result<PendingSettlementModel>> Handle(SettlementQueries.GetPendingSettlementQuery query,
+                                                                 CancellationToken cancellationToken) {
+            return await this.TransactionProcessorManager.GetPendingSettlement(query.EstateId, query.MerchantId, query.SettlementDate, cancellationToken);
         }
 
         public async Task<Result<SettlementModel>> Handle(SettlementQueries.GetSettlementQuery request,

TransactionProcessor.BusinessLogic/Requests/SettlementQueries.cs

@@ -10,7 +10,7 @@ namespace TransactionProcessor.BusinessLogic.Requests;
 [ExcludeFromCodeCoverage]
 public record SettlementQueries {
     public record GetPendingSettlementQuery(DateTime SettlementDate, Guid MerchantId, Guid EstateId)
-        : IRequest<Result<SettlementAggregate>>;
+        : IRequest<Result<PendingSettlementModel>>;
     public record GetSettlementQuery(Guid EstateId, Guid MerchantId, Guid SettlementId)
         : IRequest<Result<SettlementModel>>;
 

TransactionProcessor.Models/Settlement/SettlementModel.cs

@@ -31,4 +31,15 @@ public SettlementModel()
     public Decimal ValueOfFeesSettled { get; set; }
 
     #endregion
+}
+
+public class PendingSettlementModel
+{
+    public Guid EstateId { get; set; }
+    public Guid MerchantId { get; set; }
+    public DateTime SettlementDate { get; set; }
+    public Int32 NumberOfFeesPendingSettlement { get; set; }
+
+    public Int32 NumberOfFeesSettled { get; set; }
+    public Boolean SettlementCompleted { get; set; }
 }

TransactionProcessor/Bootstrapper/MediatorRegistry.cs

@@ -103,7 +103,7 @@ private void RegisterSettlementRequestHandler() {
             this.AddSingleton<IRequestHandler<SettlementCommands.ProcessSettlementCommand, Result<Guid>>, SettlementRequestHandler>();
             this.AddSingleton<IRequestHandler<SettlementCommands.AddMerchantFeePendingSettlementCommand, Result>, SettlementRequestHandler>();
             this.AddSingleton<IRequestHandler<SettlementCommands.AddSettledFeeToSettlementCommand, Result>, SettlementRequestHandler>();
-            this.AddSingleton<IRequestHandler<SettlementQueries.GetPendingSettlementQuery, Result<SettlementAggregate>>, SettlementRequestHandler>();
+            this.AddSingleton<IRequestHandler<SettlementQueries.GetPendingSettlementQuery, Result<PendingSettlementModel>>, SettlementRequestHandler>();
             this.AddSingleton<IRequestHandler<SettlementQueries.GetSettlementQuery, Result<SettlementModel>>, SettlementRequestHandler>();
             this.AddSingleton<IRequestHandler<SettlementQueries.GetSettlementsQuery, Result<List<SettlementModel>>>, SettlementRequestHandler>();
         }

TransactionProcessor/Handlers/SettlementHandlers.cs

@@ -19,16 +19,16 @@ public static class SettlementHandlers
         public static async Task<IResult> GetPendingSettlement(IMediator mediator, HttpContext ctx, DateTime settlementDate, [FromRoute] Guid estateId, Guid merchantId, CancellationToken cancellationToken)
         {
             SettlementQueries.GetPendingSettlementQuery query = new(settlementDate, merchantId, estateId);
-            Result<SettlementAggregate> getPendingSettlementResult = await mediator.Send(query, cancellationToken);
+            Result<PendingSettlementModel> getPendingSettlementResult = await mediator.Send(query, cancellationToken);
 
             return ResponseFactory.FromResult(getPendingSettlementResult, r => new TransactionProcessor.DataTransferObjects.SettlementResponse
             {
                 EstateId = r.EstateId,
                 MerchantId = r.MerchantId,
-                NumberOfFeesPendingSettlement = r.GetNumberOfFeesPendingSettlement(),
-                NumberOfFeesSettled = r.GetNumberOfFeesSettled(),
+                NumberOfFeesPendingSettlement = r.NumberOfFeesPendingSettlement,
+                NumberOfFeesSettled = r.NumberOfFeesSettled,
                 SettlementDate = r.SettlementDate,
-                SettlementCompleted = r.SettlementComplete
+                SettlementCompleted = r.SettlementCompleted
             });
         }