feat: add merchant yearly operating schedule endpoint

Co-authored-by: StuartFerguson <16325469+StuartFerguson@users.noreply.github.com>

Author: Copilot

TransactionProcessor.Aggregates.Tests/MerchantAggregateTests.cs

@@ -409,7 +409,76 @@ public void MerchantAggregate_SetSetttlmentSchedule_SameValue_NoEventRaised(Sett
             Merchant merchant = aggregate.GetMerchant();
             merchant.SettlementSchedule.ShouldBe(originalSettlementSchedule);
         }
-        
+
+        [Fact]
+        public void MerchantAggregate_SetOperatingSchedule_ScheduleIsSet()
+        {
+            MerchantAggregate aggregate = MerchantAggregate.Create(TestData.MerchantId);
+            aggregate.Create(TestData.EstateId, TestData.MerchantName, TestData.DateMerchantCreated, TestData.AddressModel, TestData.ContactModel,
+                TestData.SettlementScheduleModel);
+
+            List<MerchantOperatingSchedulePeriod> periods = new()
+            {
+                new MerchantOperatingSchedulePeriod(TestData.OperatingSchedulePeriod1StartDate, TestData.OperatingSchedulePeriod1EndDate, false),
+                new MerchantOperatingSchedulePeriod(TestData.OperatingSchedulePeriod2StartDate, TestData.OperatingSchedulePeriod2EndDate, false)
+            };
+
+            Result result = aggregate.SetOperatingSchedule(TestData.OperatingScheduleYear, true, periods);
+            result.IsSuccess.ShouldBeTrue();
+
+            Merchant merchant = aggregate.GetMerchant();
+            merchant.OperatingSchedules.ShouldHaveSingleItem();
+            merchant.OperatingSchedules.Single().Year.ShouldBe(TestData.OperatingScheduleYear);
+            merchant.OperatingSchedules.Single().DefaultIsOpen.ShouldBeTrue();
+            merchant.OperatingSchedules.Single().Periods.Count.ShouldBe(2);
+            merchant.OperatingSchedules.Single().Periods[0].StartDate.ShouldBe(TestData.OperatingSchedulePeriod1StartDate);
+            merchant.OperatingSchedules.Single().Periods[0].EndDate.ShouldBe(TestData.OperatingSchedulePeriod1EndDate);
+            merchant.OperatingSchedules.Single().Periods[0].IsOpen.ShouldBeFalse();
+        }
+
+        [Fact]
+        public void MerchantAggregate_SetOperatingSchedule_OverlappingPeriods_ErrorReturned()
+        {
+            MerchantAggregate aggregate = MerchantAggregate.Create(TestData.MerchantId);
+            aggregate.Create(TestData.EstateId, TestData.MerchantName, TestData.DateMerchantCreated, TestData.AddressModel, TestData.ContactModel,
+                TestData.SettlementScheduleModel);
+
+            List<MerchantOperatingSchedulePeriod> periods = new()
+            {
+                new MerchantOperatingSchedulePeriod(new DateTime(TestData.OperatingScheduleYear, 1, 1), new DateTime(TestData.OperatingScheduleYear, 1, 3), false),
+                new MerchantOperatingSchedulePeriod(new DateTime(TestData.OperatingScheduleYear, 1, 3), new DateTime(TestData.OperatingScheduleYear, 1, 4), true)
+            };
+
+            Result result = aggregate.SetOperatingSchedule(TestData.OperatingScheduleYear, true, periods);
+            result.IsFailed.ShouldBeTrue();
+            result.Status.ShouldBe(ResultStatus.Invalid);
+            result.Message.ShouldBe("Operating schedule periods must not overlap");
+        }
+
+        [Fact]
+        public void MerchantAggregate_SetOperatingSchedule_SameValue_NoEventRaised()
+        {
+            MerchantAggregate aggregate = MerchantAggregate.Create(TestData.MerchantId);
+            aggregate.Create(TestData.EstateId, TestData.MerchantName, TestData.DateMerchantCreated, TestData.AddressModel, TestData.ContactModel,
+                TestData.SettlementScheduleModel);
+
+            List<MerchantOperatingSchedulePeriod> periods = new()
+            {
+                new MerchantOperatingSchedulePeriod(TestData.OperatingSchedulePeriod1StartDate, TestData.OperatingSchedulePeriod1EndDate, false)
+            };
+
+            aggregate.SetOperatingSchedule(TestData.OperatingScheduleYear, true, periods);
+            Result result = aggregate.SetOperatingSchedule(TestData.OperatingScheduleYear, true, periods);
+            result.IsSuccess.ShouldBeTrue();
+
+            Type type = aggregate.GetType();
+            PropertyInfo property = type.GetProperty("PendingEvents", BindingFlags.Instance | BindingFlags.NonPublic);
+            Object value = property.GetValue(aggregate);
+            value.ShouldNotBeNull();
+            List<IDomainEvent> eventHistory = (List<IDomainEvent>)value;
+            eventHistory.Count.ShouldBe(6);
+        }
+
         [Fact]
         public void MerchantAggregate_SwapDevice_DeviceIsSwapped(){
             MerchantAggregate aggregate = MerchantAggregate.Create(TestData.MerchantId);

TransactionProcessor.Aggregates/MerchantAggregate.cs

@@ -5,6 +5,8 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using TransactionProcessor.DomainEvents;
+using OperatingScheduleModel = TransactionProcessor.Models.Merchant.MerchantOperatingSchedule;
+using OperatingSchedulePeriodModel = TransactionProcessor.Models.Merchant.MerchantOperatingSchedulePeriod;
 using TransactionProcessor.Models.Contract;
 using TransactionProcessor.Models.Merchant;
 using Address = TransactionProcessor.Aggregates.Models.Address;
@@ -425,6 +427,20 @@ public static Merchant GetMerchant(this MerchantAggregate aggregate)
                 }
             }
 
+            if (aggregate.OperatingSchedules.Any())
+            {
+                merchantModel.OperatingSchedules = aggregate.OperatingSchedules
+                                                            .OrderBy(o => o.Key)
+                                                            .Select(o => new OperatingScheduleModel
+                                                            {
+                                                                Year = o.Value.Year,
+                                                                DefaultIsOpen = o.Value.DefaultIsOpen,
+                                                                Periods = o.Value.Periods
+                                                                                  .Select(p => new OperatingSchedulePeriodModel(p.StartDate, p.EndDate, p.IsOpen))
+                                                                                  .ToList()
+                                                            }).ToList();
+            }
+
             return merchantModel;
         }
 
@@ -474,6 +490,61 @@ public static Result SetSettlementSchedule(this MerchantAggregate aggregate, Set
             return Result.Success();
         }
 
+        public static Result SetOperatingSchedule(this MerchantAggregate aggregate,
+                                                  Int32 year,
+                                                  Boolean defaultIsOpen,
+                                                  List<OperatingSchedulePeriodModel> periods)
+        {
+            Result result = aggregate.EnsureMerchantHasBeenCreated();
+            if (result.IsFailed)
+                return result;
+
+            if (year < 1)
+                return Result.Invalid("A valid year must be provided");
+
+            List<OperatingSchedulePeriodModel> normalisedPeriods = (periods ?? new List<OperatingSchedulePeriodModel>())
+                                                                   .Select(p => new OperatingSchedulePeriodModel(p.StartDate.Date, p.EndDate.Date, p.IsOpen))
+                                                                   .OrderBy(p => p.StartDate)
+                                                                   .ThenBy(p => p.EndDate)
+                                                                   .ToList();
+
+            for (Int32 i = 0; i < normalisedPeriods.Count; i++)
+            {
+                OperatingSchedulePeriodModel period = normalisedPeriods[i];
+                if (period.StartDate > period.EndDate)
+                    return Result.Invalid("Operating schedule periods must have a start date on or before the end date");
+
+                if (period.StartDate.Year != year || period.EndDate.Year != year)
+                    return Result.Invalid("Operating schedule periods must fall within the requested year");
+
+                if (i > 0)
+                {
+                    OperatingSchedulePeriodModel previousPeriod = normalisedPeriods[i - 1];
+                    if (period.StartDate <= previousPeriod.EndDate)
+                        return Result.Invalid("Operating schedule periods must not overlap");
+                }
+            }
+
+            if (aggregate.OperatingSchedules.TryGetValue(year, out OperatingScheduleModel existingSchedule))
+            {
+                Boolean isUnchanged = existingSchedule.DefaultIsOpen == defaultIsOpen &&
+                                      existingSchedule.Periods.SequenceEqual(normalisedPeriods);
+                if (isUnchanged)
+                    return Result.Success();
+            }
+
+            MerchantDomainEvents.MerchantOperatingScheduleSetEvent merchantOperatingScheduleSetEvent = new(
+                aggregate.AggregateId,
+                aggregate.EstateId,
+                year,
+                defaultIsOpen,
+                normalisedPeriods.Select(p => new TransactionProcessor.DomainEvents.MerchantOperatingSchedulePeriod(p.StartDate, p.EndDate, p.IsOpen)).ToList());
+
+            aggregate.ApplyAndAppend(merchantOperatingScheduleSetEvent);
+
+            return Result.Success();
+        }
+
         public static Result Create(this MerchantAggregate aggregate, 
                            Guid estateId,
                            String merchantName,
@@ -854,6 +925,18 @@ public static void PlayEvent(this MerchantAggregate aggregate, MerchantDomainEve
             aggregate.Contracts[domainEvent.ContractId] = contract.Value;
         }
 
+        public static void PlayEvent(this MerchantAggregate aggregate, MerchantDomainEvents.MerchantOperatingScheduleSetEvent domainEvent)
+        {
+            aggregate.OperatingSchedules[domainEvent.Year] = new OperatingScheduleModel
+            {
+                Year = domainEvent.Year,
+                DefaultIsOpen = domainEvent.DefaultIsOpen,
+                Periods = domainEvent.Periods?
+                    .Select(p => new OperatingSchedulePeriodModel(p.StartDate.Date, p.EndDate.Date, p.IsOpen))
+                    .ToList() ?? new List<OperatingSchedulePeriodModel>()
+            };
+        }
+
         public static void PlayEvent(this MerchantAggregate aggregate, MerchantDomainEvents.DeviceSwappedForMerchantEvent domainEvent)
         {
             KeyValuePair<Guid, Device> device = aggregate.Devices.Single(d => d.Key == domainEvent.OriginalDeviceId);
@@ -887,6 +970,8 @@ public record MerchantAggregate : Aggregate
 
         internal readonly Dictionary<Guid, Contract> Contracts;
 
+        internal readonly Dictionary<Int32, OperatingScheduleModel> OperatingSchedules;
+
         #endregion
 
         #region Constructors
@@ -904,6 +989,7 @@ public MerchantAggregate()
             this.SecurityUsers = new List<SecurityUser>();
             this.Devices = new Dictionary<Guid, Device>();
             this.Contracts = new Dictionary<Guid, Contract>();
+            this.OperatingSchedules = new Dictionary<Int32, OperatingScheduleModel>();
         }
 
         /// <summary>
@@ -922,6 +1008,7 @@ private MerchantAggregate(Guid aggregateId)
             this.SecurityUsers = new List<SecurityUser>();
             this.Devices = new Dictionary<Guid, Device>();
             this.Contracts = new Dictionary<Guid, Contract>();
+            this.OperatingSchedules = new Dictionary<Int32, OperatingScheduleModel>();
         }
 
         #endregion
@@ -970,4 +1057,4 @@ protected override Object GetMetadata()
 
 
     }
-}
+}

TransactionProcessor.BusinessLogic.Tests/Mediator/MediatorTests.cs

@@ -86,6 +86,7 @@ public MediatorTests()
             this.Requests.Add(TestData.Commands.UpdateMerchantContactCommand);
             this.Requests.Add(TestData.Commands.RemoveOperatorFromMerchantCommand);
             this.Requests.Add(TestData.Commands.RemoveMerchantContractCommand);
+            this.Requests.Add(TestData.Commands.SetMerchantOperatingScheduleCommand);
             this.Requests.Add(TestData.Queries.GetMerchantsQuery);
             this.Requests.Add(TestData.Queries.GetMerchantQuery);
             this.Requests.Add(TestData.Queries.GetMerchantContractsQuery);

TransactionProcessor.BusinessLogic.Tests/Services/MerchantDomainServiceTests.cs

@@ -1462,6 +1462,31 @@ public async Task MerchantDomainService_UpdateMerchant_SaveFailed_ResultIsFailed
         result.IsFailed.ShouldBeTrue();
     }
 
+    [Fact]
+    public async Task MerchantDomainService_SetMerchantOperatingSchedule_ScheduleSet() {
+        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
+        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
+        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(Result.Success());
+
+        var result = await this.DomainService.SetMerchantOperatingSchedule(TestData.Commands.SetMerchantOperatingScheduleCommand, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task MerchantDomainService_SetMerchantOperatingSchedule_ValidationFailure_ResultIsFailed()
+    {
+        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
+        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
+
+        var result = await this.DomainService.SetMerchantOperatingSchedule(TestData.Commands.SetMerchantOperatingScheduleCommand, CancellationToken.None);
+        result.IsFailed.ShouldBeTrue();
+    }
+
     [Fact]
     public async Task MerchantDomainService_AddMerchantAddress_GetEstateFailed_ResultIsFailed() {
         this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))

TransactionProcessor.BusinessLogic/RequestHandlers/MerchantRequestHandler.cs

@@ -37,9 +37,10 @@ public class MerchantRequestHandler :
                                           IRequestHandler<MerchantCommands.AddMerchantAddressCommand, Result>,
                                           IRequestHandler<MerchantCommands.UpdateMerchantAddressCommand, Result>,
                                           IRequestHandler<MerchantCommands.AddMerchantContactCommand, Result>,
-                                          IRequestHandler<MerchantCommands.UpdateMerchantContactCommand, Result>,
-                                          IRequestHandler<MerchantCommands.RemoveOperatorFromMerchantCommand, Result>,
-                                          IRequestHandler<MerchantCommands.RemoveMerchantContractCommand, Result>
+                                           IRequestHandler<MerchantCommands.UpdateMerchantContactCommand, Result>,
+                                           IRequestHandler<MerchantCommands.RemoveOperatorFromMerchantCommand, Result>,
+                                           IRequestHandler<MerchantCommands.RemoveMerchantContractCommand, Result>,
+                                           IRequestHandler<MerchantCommands.SetMerchantOperatingScheduleCommand, Result>
 {
     private readonly IProjectionStateRepository<MerchantBalanceState> MerchantBalanceStateRepository;
     private readonly IEventStoreContext EventStoreContext;
@@ -182,4 +183,9 @@ public async Task<Result> Handle(MerchantCommands.RemoveMerchantContractCommand
     {
         return await this.MerchantDomainService.RemoveContractFromMerchant(command, cancellationToken);
     }
-}
+
+    public async Task<Result> Handle(MerchantCommands.SetMerchantOperatingScheduleCommand command, CancellationToken cancellationToken)
+    {
+        return await this.MerchantDomainService.SetMerchantOperatingSchedule(command, cancellationToken);
+    }
+}

TransactionProcessor.BusinessLogic/Requests/MerchantCommands.cs

@@ -39,7 +39,9 @@ public record UpdateMerchantAddressCommand(Guid EstateId, Guid MerchantId, Guid
         public record AddMerchantContactCommand(Guid EstateId, Guid MerchantId, Contact RequestDto) : IRequest<Result>;
 
         public record UpdateMerchantContactCommand(Guid EstateId, Guid MerchantId, Guid ContactId, Contact RequestDto) : IRequest<Result>;
+
+        public record SetMerchantOperatingScheduleCommand(Guid EstateId, Guid MerchantId, Int32 Year, SetMerchantOperatingScheduleRequest RequestDto) : IRequest<Result>;
     }
 
 
-}
+}

TransactionProcessor.BusinessLogic/Services/MerchantDomainService.cs

@@ -43,6 +43,7 @@ public interface IMerchantDomainService
         Task<Result> UpdateMerchantContact(MerchantCommands.UpdateMerchantContactCommand command, CancellationToken cancellationToken);
         Task<Result> RemoveOperatorFromMerchant(MerchantCommands.RemoveOperatorFromMerchantCommand command, CancellationToken cancellationToken);
         Task<Result> RemoveContractFromMerchant(MerchantCommands.RemoveMerchantContractCommand command, CancellationToken cancellationToken);
+        Task<Result> SetMerchantOperatingSchedule(MerchantCommands.SetMerchantOperatingScheduleCommand command, CancellationToken cancellationToken);
 
         #endregion
     }
@@ -490,6 +491,45 @@ public async Task<Result> UpdateMerchant(MerchantCommands.UpdateMerchantCommand
             }
         }
 
+        public async Task<Result> SetMerchantOperatingSchedule(MerchantCommands.SetMerchantOperatingScheduleCommand command, CancellationToken cancellationToken)
+        {
+            try
+            {
+                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
+                if (estateResult.IsFailed)
+                    return ResultHelpers.CreateFailure(estateResult);
+
+                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
+                if (merchantResult.IsFailed)
+                    return ResultHelpers.CreateFailure(merchantResult);
+
+                EstateAggregate estateAggregate = estateResult.Data;
+                MerchantAggregate merchantAggregate = merchantResult.Data;
+
+                Result result = this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
+                if (result.IsFailed)
+                    return ResultHelpers.CreateFailure(result);
+
+                List<MerchantOperatingSchedulePeriod> periods = command.RequestDto.Periods?
+                    .Select(p => new MerchantOperatingSchedulePeriod(p.StartDate, p.EndDate, p.IsOpen))
+                    .ToList() ?? new List<MerchantOperatingSchedulePeriod>();
+
+                Result stateResult = merchantAggregate.SetOperatingSchedule(command.Year, command.RequestDto.DefaultIsOpen, periods);
+                if (stateResult.IsFailed)
+                    return stateResult;
+
+                Result saveResult = await this.AggregateService.Save(merchantAggregate, cancellationToken);
+                if (saveResult.IsFailed)
+                    return ResultHelpers.CreateFailure(saveResult);
+
+                return saveResult;
+            }
+            catch (Exception ex)
+            {
+                return Result.Failure(ex.GetExceptionMessages());
+            }
+        }
+
         public async Task<Result> AddMerchantAddress(MerchantCommands.AddMerchantAddressCommand command, CancellationToken cancellationToken)
         {
             try