load statement lines from transactions and fees

TransactionProcessor.Aggregates/MerchantStatementForDateAggregate.cs

@@ -25,7 +25,7 @@ public static Result AddSettledFeeToStatement(this MerchantStatementForDateAggre
         if (result.IsFailed)
             return result;
 
-        MerchantStatementForDateDomainEvents.SettledFeeAddedToStatementForDateEvent settledFeeAddedToStatementEvent = new(aggregate.AggregateId, eventId, aggregate.EstateId, aggregate.MerchantId, settledFee.SettledFeeId, settledFee.TransactionId, settledFee.DateTime, settledFee.Amount);
+        MerchantStatementForDateDomainEvents.SettledFeeAddedToStatementForDateEvent settledFeeAddedToStatementEvent = new(aggregate.AggregateId, eventId, aggregate.EstateId, aggregate.MerchantId, merchantStatementId, settledFee.SettledFeeId, settledFee.TransactionId, settledFee.DateTime, settledFee.Amount);
 
         aggregate.ApplyAndAppend(settledFeeAddedToStatementEvent);
 
@@ -45,7 +45,7 @@ public static Result AddDepositToStatement(this MerchantStatementForDateAggregat
         if (result.IsFailed)
             return result;
 
-        MerchantStatementForDateDomainEvents.DepositAddedToStatementForDateEvent depositAddedToStatementEvent = new(aggregate.AggregateId, eventId, aggregate.EstateId, aggregate.MerchantId, deposit.DepositId, deposit.DepositDateTime, deposit.Amount);
+        MerchantStatementForDateDomainEvents.DepositAddedToStatementForDateEvent depositAddedToStatementEvent = new(aggregate.AggregateId, eventId, aggregate.EstateId, aggregate.MerchantId, merchantStatementId, deposit.DepositId, deposit.DepositDateTime, deposit.Amount);
 
         aggregate.ApplyAndAppend(depositAddedToStatementEvent);
 
@@ -65,7 +65,7 @@ public static Result AddWithdrawalToStatement(this MerchantStatementForDateAggre
         if (result.IsFailed)
             return result;
 
-        MerchantStatementForDateDomainEvents.WithdrawalAddedToStatementForDateEvent withdrawalAddedToStatementEvent = new(aggregate.AggregateId, eventId, aggregate.EstateId, aggregate.MerchantId, withdrawal.WithdrawalId, withdrawal.WithdrawalDateTime, withdrawal.Amount);
+        MerchantStatementForDateDomainEvents.WithdrawalAddedToStatementForDateEvent withdrawalAddedToStatementEvent = new(aggregate.AggregateId, eventId, aggregate.EstateId, aggregate.MerchantId, merchantStatementId, withdrawal.WithdrawalId, withdrawal.WithdrawalDateTime, withdrawal.Amount);
 
         aggregate.ApplyAndAppend(withdrawalAddedToStatementEvent);
 
@@ -89,6 +89,7 @@ public static Result AddTransactionToStatement(this MerchantStatementForDateAggr
                                                                                                                  eventId,
                                                                                                                  aggregate.EstateId,
                                                                                                                  aggregate.MerchantId,
+                                                                                                                 merchantStatementId,
                                                                                                                  transaction.TransactionId,
                                                                                                                  transaction.DateTime,
                                                                                                                  transaction.Amount);

TransactionProcessor.BusinessLogic/EventHandling/ReadModelDomainEventHandler.cs

@@ -92,10 +92,8 @@ public async Task<Result> Handle(IDomainEvent domainEvent,
                 FileProcessor.File.DomainEvents.FileProcessingCompletedEvent de => this.EstateReportingRepository.UpdateFileAsComplete(de, cancellationToken),
 
                 MerchantStatementDomainEvents.StatementCreatedEvent de => this.EstateReportingRepository.CreateStatement(de, cancellationToken),
-                // TODO@ Add this back in
-                //MerchantStatementDomainEvents.TransactionAddedToStatementEvent de => this.EstateReportingRepository.AddTransactionToStatement(de, cancellationToken),
-                // TODO@ Add this back in
-                //MerchantStatementDomainEvents.SettledFeeAddedToStatementEvent de => this.EstateReportingRepository.AddSettledFeeToStatement(de, cancellationToken),
+                MerchantStatementForDateDomainEvents.TransactionAddedToStatementForDateEvent de => this.EstateReportingRepository.AddTransactionToStatement(de, cancellationToken),
+                MerchantStatementForDateDomainEvents.SettledFeeAddedToStatementForDateEvent de => this.EstateReportingRepository.AddSettledFeeToStatement(de, cancellationToken),
                 MerchantStatementDomainEvents.StatementGeneratedEvent de => this.HandleSpecificDomainEvent(de, cancellationToken),
 
                 FloatCreatedForContractProductEvent de => this.EstateReportingRepository.CreateFloat(de, cancellationToken),

TransactionProcessor.DomainEvents/MerchantStatementDomainEvents.cs

@@ -26,12 +26,12 @@ public record StatementSummaryForDateEvent(Guid MerchantStatementId, Guid Estate
     public class MerchantStatementForDateDomainEvents {
         public record StatementCreatedForDateEvent(Guid MerchantStatementForDateId, DateTime ActivityDate, DateTime MerchantStatementDate, Guid MerchantStatementId, Guid EstateId, Guid MerchantId) : DomainEvent(MerchantStatementForDateId, Guid.NewGuid());
 
-        public record SettledFeeAddedToStatementForDateEvent(Guid MerchantStatementForDateId, Guid EventId, Guid EstateId, Guid MerchantId, Guid SettledFeeId, Guid TransactionId, DateTime SettledDateTime, Decimal SettledValue) : DomainEvent(MerchantStatementForDateId, EventId);
+        public record SettledFeeAddedToStatementForDateEvent(Guid MerchantStatementForDateId, Guid EventId, Guid EstateId, Guid MerchantId, Guid MerchantStatementId, Guid SettledFeeId, Guid TransactionId, DateTime SettledDateTime, Decimal SettledValue) : DomainEvent(MerchantStatementForDateId, EventId);
 
-        public record TransactionAddedToStatementForDateEvent(Guid MerchantStatementForDateId, Guid EventId, Guid EstateId, Guid MerchantId, Guid TransactionId, DateTime TransactionDateTime, Decimal TransactionValue) : DomainEvent(MerchantStatementForDateId, EventId);
+        public record TransactionAddedToStatementForDateEvent(Guid MerchantStatementForDateId, Guid EventId, Guid EstateId, Guid MerchantId, Guid MerchantStatementId, Guid TransactionId, DateTime TransactionDateTime, Decimal TransactionValue) : DomainEvent(MerchantStatementForDateId, EventId);
 
-        public record DepositAddedToStatementForDateEvent(Guid MerchantStatementForDateId, Guid EventId, Guid EstateId, Guid MerchantId, Guid DepositId, DateTime DepositDateTime, Decimal DepositAmount) : DomainEvent(MerchantStatementForDateId, EventId);
-        public record WithdrawalAddedToStatementForDateEvent(Guid MerchantStatementForDateId, Guid EventId, Guid EstateId, Guid MerchantId, Guid WithdrawalId, DateTime WithdrawalDateTime, Decimal WithdrawalAmount) : DomainEvent(MerchantStatementForDateId, EventId);
+        public record DepositAddedToStatementForDateEvent(Guid MerchantStatementForDateId, Guid EventId, Guid EstateId, Guid MerchantId, Guid MerchantStatementId, Guid DepositId, DateTime DepositDateTime, Decimal DepositAmount) : DomainEvent(MerchantStatementForDateId, EventId);
+        public record WithdrawalAddedToStatementForDateEvent(Guid MerchantStatementForDateId, Guid EventId, Guid EstateId, Guid MerchantId, Guid MerchantStatementId, Guid WithdrawalId, DateTime WithdrawalDateTime, Decimal WithdrawalAmount) : DomainEvent(MerchantStatementForDateId, EventId);
 
     }
 }

TransactionProcessor.Repository/ITransactionProcessorReadModelRepository.cs

@@ -286,7 +286,13 @@ Task<Result<List<SettlementModel>>> GetSettlements(Guid estateId,
                                                            String endDate,
                                                            CancellationToken cancellationToken);
 
-        Task<Result> RecordTransactionTimings(TransactionDomainEvents.TransactionTimingsAddedToTransactionEvent de,
+        Task<Result> RecordTransactionTimings(TransactionDomainEvents.TransactionTimingsAddedToTransactionEvent domainEvent,
+                                              CancellationToken cancellationToken);
+
+        Task<Result> AddTransactionToStatement(MerchantStatementForDateDomainEvents.TransactionAddedToStatementForDateEvent domainEvent,
+                                               CancellationToken cancellationToken);
+
+        Task<Result> AddSettledFeeToStatement(MerchantStatementForDateDomainEvents.SettledFeeAddedToStatementForDateEvent domainEvent,
                                               CancellationToken cancellationToken);
     }
 
@@ -2050,7 +2056,7 @@ public async Task<Result> RecordTransactionTimings(TransactionDomainEvents.Trans
                                                            CancellationToken cancellationToken) {
             // Calculate the timings for the transaction
             TimeSpan totalTime = domainEvent.TransactionCompletedDateTime.Subtract(domainEvent.TransactionStartedDateTime);
-            // Calculte the timings for the operator communications
+            // Calculate the timings for the operator communications
             TimeSpan operatorCommunicationsTime = domainEvent.OperatorCommunicationsCompletedEvent?.Subtract(domainEvent.OperatorCommunicationsStartedEvent ?? DateTime.MinValue) ?? TimeSpan.Zero;
             // Calculate the timings for the transaction without operator timings
             TimeSpan transactionTime = totalTime.Subtract(operatorCommunicationsTime);
@@ -2071,5 +2077,71 @@ public async Task<Result> RecordTransactionTimings(TransactionDomainEvents.Trans
             await context.TransactionTimings.AddAsync(timings, cancellationToken);
             return await context.SaveChangesWithDuplicateHandling(cancellationToken);
         }
+
+        public async Task<Result> AddTransactionToStatement(MerchantStatementForDateDomainEvents.TransactionAddedToStatementForDateEvent domainEvent,
+                                                            CancellationToken cancellationToken) {
+            // Load this information to the database
+            EstateManagementContext context = await this.GetContext(domainEvent.EstateId);
+
+            // Find the corresponding transaction
+            Result<Transaction> transactionResult = await context.LoadTransaction(domainEvent, cancellationToken);
+            if (transactionResult.IsFailed)
+                return ResultHelpers.CreateFailure(transactionResult);
+
+            Transaction transaction = transactionResult.Data;
+
+            Result<Operator> operatorResult = await context.LoadOperator(transaction.OperatorId, cancellationToken);
+            if (operatorResult.IsFailed)
+                return ResultHelpers.CreateFailure(operatorResult);
+            Operator @operator = operatorResult.Data;
+
+            StatementLine line = new StatementLine
+            {
+                StatementId = domainEvent.MerchantStatementId,
+                ActivityDateTime = domainEvent.TransactionDateTime,
+                ActivityDate = domainEvent.TransactionDateTime.Date,
+                ActivityDescription = $"{@operator.Name} Transaction",
+                ActivityType = 1, // Transaction
+                TransactionId = domainEvent.TransactionId,
+                OutAmount = domainEvent.TransactionValue
+            };
+
+            await context.StatementLines.AddAsync(line, cancellationToken);
+            return await context.SaveChangesWithDuplicateHandling(cancellationToken);
+        }
+
+        public async Task<Result> AddSettledFeeToStatement(MerchantStatementForDateDomainEvents.SettledFeeAddedToStatementForDateEvent domainEvent,
+                                                           CancellationToken cancellationToken)
+        {
+            // Load this information to the database
+            EstateManagementContext context = await this.GetContext(domainEvent.EstateId);
+
+            // Find the corresponding transaction
+            var getTransactionResult = await context.LoadTransaction(domainEvent, cancellationToken);
+            if (getTransactionResult.IsFailed)
+                return ResultHelpers.CreateFailure(getTransactionResult);
+            var transaction = getTransactionResult.Data;
+
+            Result<Operator> operatorResult = await context.LoadOperator(transaction.OperatorId, cancellationToken);
+            if (operatorResult.IsFailed)
+                return ResultHelpers.CreateFailure(operatorResult);
+            var @operator = operatorResult.Data;
+
+            StatementLine line = new StatementLine
+            {
+                StatementId = domainEvent.MerchantStatementId,
+                ActivityDateTime = domainEvent.SettledDateTime,
+                ActivityDate = domainEvent.SettledDateTime.Date,
+                ActivityDescription = $"{@operator.Name} Transaction Fee",
+                ActivityType = 2, // Transaction Fee
+                TransactionId = domainEvent.TransactionId,
+                InAmount = domainEvent.SettledValue
+            };
+
+            await context.StatementLines.AddAsync(line, cancellationToken);
+
+            return await context.SaveChangesWithDuplicateHandling(cancellationToken);
+        }
+
     }
 }