diff --git a/CallbackHandler.BusinessLogic.Tests/Mediator/MediatorTests.cs b/CallbackHandler.BusinessLogic.Tests/Mediator/MediatorTests.cs
index 55a1ae8..cec79ca 100644
--- a/CallbackHandler.BusinessLogic.Tests/Mediator/MediatorTests.cs
+++ b/CallbackHandler.BusinessLogic.Tests/Mediator/MediatorTests.cs
@@ -12,58 +12,58 @@
 using System.Threading.Tasks;
 using Xunit;
 
-namespace CallbackHandler.BusinessLogic.Tests.Mediator
+namespace CallbackHandler.BusinessLogic.Tests.Mediator;
+
+using BusinessLogic.Services;
+using Lamar;
+using Microsoft.Extensions.DependencyInjection;
+
+public class MediatorTests
 {
-    using BusinessLogic.Services;
-    using Lamar;
-    using Microsoft.Extensions.DependencyInjection;
+    private readonly List<IBaseRequest> Requests = new List<IBaseRequest>();
 
-    public class MediatorTests
+    public MediatorTests()
     {
-        private readonly List<IBaseRequest> Requests = new List<IBaseRequest>();
+        this.Requests.Add(TestData.RecordCallbackRequest);
+    }
 
-        public MediatorTests()
-        {
-            this.Requests.Add(TestData.RecordCallbackRequest);
-        }
+    [Fact]
+    public async Task Mediator_Send_RequestHandled()
+    {
+        Mock<IWebHostEnvironment> hostingEnvironment = new();
+        hostingEnvironment.Setup(he => he.EnvironmentName).Returns("Development");
+        hostingEnvironment.Setup(he => he.ContentRootPath).Returns("/home");
+        hostingEnvironment.Setup(he => he.ApplicationName).Returns("Test Application");
+
+        ServiceRegistry services = new();
+        Startup s = new(hostingEnvironment.Object);
+        Startup.Configuration = this.SetupMemoryConfiguration();
 
-        [Fact]
-        public async Task Mediator_Send_RequestHandled()
+        this.AddTestRegistrations(services, hostingEnvironment.Object);
+        s.ConfigureContainer(services);
+        Startup.Container.AssertConfigurationIsValid(AssertMode.Full);
+
+        List<String> errors = new();
+        IMediator mediator = Startup.Container.GetService<IMediator>();
+        foreach (IBaseRequest baseRequest in this.Requests)
         {
-            Mock<IWebHostEnvironment> hostingEnvironment = new();
-            hostingEnvironment.Setup(he => he.EnvironmentName).Returns("Development");
-            hostingEnvironment.Setup(he => he.ContentRootPath).Returns("/home");
-            hostingEnvironment.Setup(he => he.ApplicationName).Returns("Test Application");
-
-            ServiceRegistry services = new();
-            Startup s = new(hostingEnvironment.Object);
-            Startup.Configuration = this.SetupMemoryConfiguration();
-
-            this.AddTestRegistrations(services, hostingEnvironment.Object);
-            s.ConfigureContainer(services);
-            Startup.Container.AssertConfigurationIsValid(AssertMode.Full);
-
-            List<String> errors = new();
-            IMediator mediator = Startup.Container.GetService<IMediator>();
-            foreach (IBaseRequest baseRequest in this.Requests)
+            try
             {
-                try
-                {
-                    await mediator.Send(baseRequest);
-                }
-                catch (Exception ex)
-                {
-                    errors.Add(ex.Message);
-                }
+                await mediator.Send(baseRequest);
             }
-
-            if (errors.Any())
+            catch (Exception ex)
             {
-                String errorMessage = String.Join(Environment.NewLine, errors);
-                throw new Exception(errorMessage);
+                errors.Add(ex.Message);
             }
         }
 
+        if (errors.Any())
+        {
+            String errorMessage = String.Join(Environment.NewLine, errors);
+            throw new Exception(errorMessage);
+        }
+    }
+
         private IConfigurationRoot SetupMemoryConfiguration()
         {
             Dictionary<String, String> configuration = new Dictionary<String, String>();
@@ -100,4 +100,3 @@ private void AddTestRegistrations(ServiceRegistry services,
             services.OverrideServices(s => { s.AddSingleton<ICallbackDomainService, DummyCallbackDomainService>(); });
         }
     }
-}
diff --git a/CallbackHandler.BusinessLogic.Tests/RequestHandler/CallbackHandlerRequestHandlerTests.cs b/CallbackHandler.BusinessLogic.Tests/RequestHandler/CallbackHandlerRequestHandlerTests.cs
index 3c493b6..7dece2c 100644
--- a/CallbackHandler.BusinessLogic.Tests/RequestHandler/CallbackHandlerRequestHandlerTests.cs
+++ b/CallbackHandler.BusinessLogic.Tests/RequestHandler/CallbackHandlerRequestHandlerTests.cs
@@ -1,56 +1,56 @@
 using SimpleResults;
 
-namespace CallbackHandler.BusinessLogic.Tests.RequestHandler
-{
-    using System;
-    using System.Threading;
-    using BusinessLogic.RequestHandler;
-    using BusinessLogic.Requests;
-    using BusinessLogic.Services;
-    using CallbackHander.Testing;
-    using CallbackHandlers.Models;
-    using CallbackMessageAggregate;
-    using MediatR;
-    using Moq;
-    using Services;
-    using Shared.DomainDrivenDesign.EventSourcing;
-    using Shared.EventStore.Aggregate;
-    using Shouldly;
-    using Xunit;
+namespace CallbackHandler.BusinessLogic.Tests.RequestHandler;
+
+using System;
+using System.Threading;
+using BusinessLogic.RequestHandler;
+using BusinessLogic.Requests;
+using BusinessLogic.Services;
+using CallbackHander.Testing;
+using CallbackHandlers.Models;
+using CallbackMessageAggregate;
+using MediatR;
+using Moq;
+using Services;
+using Shared.DomainDrivenDesign.EventSourcing;
+using Shared.EventStore.Aggregate;
+using Shouldly;
+using Xunit;
 
-    public class CallbackHandlerRequestHandlerTests
+public class CallbackHandlerRequestHandlerTests
+{
+    [Fact]
+    public void CallbackHandlerRequestHandlerTests_RecordCallbackRequest_IsHandled()
     {
-        [Fact]
-        public void CallbackHandlerRequestHandlerTests_RecordCallbackRequest_IsHandled()
-        {
-            Mock<ICallbackDomainService> domainService = new();
-            domainService.Setup(a => a.RecordCallback(It.IsAny<Guid>(),
-                                                      It.IsAny<String>(),
-                                                      It.IsAny<MessageFormat>(),
-                                                      It.IsAny<String>(),
-                                                      It.IsAny<String>(),
-                                                      It.IsAny<String[]>(),
-                                                      It.IsAny<CancellationToken>()));
-            Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>> aggregateRepository = new();
+        Mock<ICallbackDomainService> domainService = new();
+        domainService.Setup(a => a.RecordCallback(It.IsAny<Guid>(),
+                                                  It.IsAny<String>(),
+                                                  It.IsAny<MessageFormat>(),
+                                                  It.IsAny<String>(),
+                                                  It.IsAny<String>(),
+                                                  It.IsAny<String[]>(),
+                                                  It.IsAny<CancellationToken>()));
+        Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>> aggregateRepository = new();
 
-            CallbackHandlerRequestHandler handler = new(domainService.Object, aggregateRepository.Object);
-            
-            CallbackCommands.RecordCallbackRequest request = TestData.RecordCallbackRequest;
+        CallbackHandlerRequestHandler handler = new(domainService.Object, aggregateRepository.Object);
+        
+        CallbackCommands.RecordCallbackRequest request = TestData.RecordCallbackRequest;
 
-            Should.NotThrow(async () => await handler.Handle(request, CancellationToken.None));
-        }
+        Should.NotThrow(async () => await handler.Handle(request, CancellationToken.None));
+    }
 
-        [Fact]
-        public void CallbackHandlerRequestHandlerTests_GetCallbackQuery_IsHandled()
-        {
-            Mock<ICallbackDomainService> domainService =
-                new();
-            domainService.Setup(a => a.RecordCallback(It.IsAny<Guid>(),
-                It.IsAny<String>(),
-                It.IsAny<MessageFormat>(),
-                It.IsAny<String>(),
-                It.IsAny<String>(),
-                It.IsAny<String[]>(),
+    [Fact]
+    public void CallbackHandlerRequestHandlerTests_GetCallbackQuery_IsHandled()
+    {
+        Mock<ICallbackDomainService> domainService =
+            new();
+        domainService.Setup(a => a.RecordCallback(It.IsAny<Guid>(),
+            It.IsAny<String>(),
+            It.IsAny<MessageFormat>(),
+            It.IsAny<String>(),
+            It.IsAny<String>(),
+            It.IsAny<String[]>(),
                 It.IsAny<CancellationToken>()));
             Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>> aggregateRepository =
                 new();
@@ -70,4 +70,3 @@ public void CallbackHandlerRequestHandlerTests_GetCallbackQuery_IsHandled()
             });
         }
     }
-}
diff --git a/CallbackHandler.BusinessLogic.Tests/Services/CallbackDomainServiceTests.cs b/CallbackHandler.BusinessLogic.Tests/Services/CallbackDomainServiceTests.cs
index 92ad2e6..3b2100b 100644
--- a/CallbackHandler.BusinessLogic.Tests/Services/CallbackDomainServiceTests.cs
+++ b/CallbackHandler.BusinessLogic.Tests/Services/CallbackDomainServiceTests.cs
@@ -1,46 +1,44 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace CallbackHandler.BusinessLogic.Tests.Services
-{
-    using System.Threading;
-    using BusinessLogic.Services;
-    using CallbackHander.Testing;
-    using CallbackHandlers.Models;
-    using CallbackMessageAggregate;
-    using Moq;
-    using Shared.DomainDrivenDesign.EventSourcing;
-    using Shared.EventStore.Aggregate;
-    using Shouldly;
-    using Xunit;
+namespace CallbackHandler.BusinessLogic.Tests.Services;
+
+using System.Threading;
+using BusinessLogic.Services;
+using CallbackHander.Testing;
+using CallbackHandlers.Models;
+using CallbackMessageAggregate;
+using Moq;
+using Shared.DomainDrivenDesign.EventSourcing;
+using Shared.EventStore.Aggregate;
+using Shouldly;
+using Xunit;
 
-    public class CallbackDomainServiceTests
-    {
-        private readonly ICallbackDomainService DomainService;
+public class CallbackDomainServiceTests
+{
+    private readonly ICallbackDomainService DomainService;
 
-        private readonly Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>> AggregateRepository;
-        public CallbackDomainServiceTests() {
-            this.AggregateRepository = new Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>>();
-            this.DomainService = new CallbackDomainService(this.AggregateRepository.Object);
-            
-        }
+    private readonly Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>> AggregateRepository;
+    public CallbackDomainServiceTests() {
+        this.AggregateRepository = new Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>>();
+        this.DomainService = new CallbackDomainService(this.AggregateRepository.Object);
+        
+    }
 
-        [Fact]
-        public async Task CallbackDomainService_RecordCallback_CallbackRecorded() {
-            this.AggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.EmptyCallbackMessageAggregate());
+    [Fact]
+    public async Task CallbackDomainService_RecordCallback_CallbackRecorded() {
+        this.AggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+                               .ReturnsAsync(TestData.EmptyCallbackMessageAggregate());
 
-            Should.NotThrow(async () => {
-                                await this.DomainService.RecordCallback(TestData.CallbackId,
-                                                                        TestData.TypeString,
-                                                                        (MessageFormat)TestData.MessageFormat,
-                                                                        TestData.CallbackMessage,
-                                                                        TestData.Reference,
-                                                                        TestData.Destinations,
-                                                                        CancellationToken.None);
-                            });
-        }
+        Should.NotThrow(async () => await this.DomainService.RecordCallback(TestData.CallbackId,
+                                                                            TestData.TypeString,
+                                                                            (MessageFormat)TestData.MessageFormat,
+                                                                            TestData.CallbackMessage,
+                                                                            TestData.Reference,
+                                                                            TestData.Destinations,
+                                                                            CancellationToken.None));
     }
 }
diff --git a/CallbackHandler.CallbackMessageAggregate.Tests/CallbackMessageAggregateTests.cs b/CallbackHandler.CallbackMessageAggregate.Tests/CallbackMessageAggregateTests.cs
index 67ef6e3..cfa2c88 100644
--- a/CallbackHandler.CallbackMessageAggregate.Tests/CallbackMessageAggregateTests.cs
+++ b/CallbackHandler.CallbackMessageAggregate.Tests/CallbackMessageAggregateTests.cs
@@ -1,37 +1,36 @@
 using SimpleResults;
 
-namespace CallbackHandler.CallbackMessageAggregate.Tests
-{
-    using CallbackHander.Testing;
-    using CallbackHandlers.Models;
-    using Shouldly;
-    using Xunit;
+namespace CallbackHandler.CallbackMessageAggregate.Tests;
 
-    public class CallbackMessageAggregateTests
-    {
-        //[Fact]
-        //public void CallbackMessageAggregate_CanBeCreated_IsCreated()
-        //{
-        //    CallbackMessageAggregate aggregate = CallbackMessageAggregate.Create(TestData.CallbackId);
+using CallbackHander.Testing;
+using CallbackHandlers.Models;
+using Shouldly;
+using Xunit;
 
-        //    aggregate.AggregateId.ShouldBe(TestData.CallbackId);
-        //}
+public class CallbackMessageAggregateTests
+{
+    //[Fact]
+    //public void CallbackMessageAggregate_CanBeCreated_IsCreated()
+    //{
+    //    CallbackMessageAggregate aggregate = CallbackMessageAggregate.Create(TestData.CallbackId);
 
-        [Fact]
-        public void CallbackMessageAggregate_RecordCallback_CallbackIsRecorded()
-        {
-            CallbackMessageAggregate aggregate = new();
+    //    aggregate.AggregateId.ShouldBe(TestData.CallbackId);
+    //}
+
+    [Fact]
+    public void CallbackMessageAggregate_RecordCallback_CallbackIsRecorded()
+    {
+        CallbackMessageAggregate aggregate = new();
 
-            Result result = aggregate.RecordCallback(TestData.CallbackId, TestData.TypeString, MessageFormat.JSON, TestData.CallbackMessage, TestData.Reference, TestData.Destinations,
-                TestData.EstateReference, TestData.MerchantReference);
-            result.IsSuccess.ShouldBeTrue();
+        Result result = aggregate.RecordCallback(TestData.CallbackId, TestData.TypeString, MessageFormat.JSON, TestData.CallbackMessage, TestData.Reference, TestData.Destinations,
+            TestData.EstateReference, TestData.MerchantReference);
+        result.IsSuccess.ShouldBeTrue();
 
-            aggregate.ShouldSatisfyAllConditions(() => aggregate.CallbackMessage.ShouldBe(TestData.CallbackMessage),
-                                                 () => aggregate.TypeString.ShouldBe(TestData.TypeString),
-                                                 () => aggregate.MessageFormat.ShouldBe(MessageFormat.JSON),
-                                                 () => aggregate.Reference.ShouldBe(TestData.Reference),
-                                                 () => aggregate.GetDestinations().ShouldNotBeEmpty(),
-                                                 () => aggregate.GetDestinations().Length.ShouldBe(TestData.Destinations.Length));
-        }
+        aggregate.ShouldSatisfyAllConditions(() => aggregate.CallbackMessage.ShouldBe(TestData.CallbackMessage),
+                                             () => aggregate.TypeString.ShouldBe(TestData.TypeString),
+                                             () => aggregate.MessageFormat.ShouldBe(MessageFormat.JSON),
+                                             () => aggregate.Reference.ShouldBe(TestData.Reference),
+                                             () => aggregate.GetDestinations().ShouldNotBeEmpty(),
+                                             () => aggregate.GetDestinations().Length.ShouldBe(TestData.Destinations.Length));
     }
 }
\ No newline at end of file
diff --git a/CallbackHandler.CallbackMessageAggregate/CallbackMessageAggregate.cs b/CallbackHandler.CallbackMessageAggregate/CallbackMessageAggregate.cs
index 2ee0830..ebd09e5 100644
--- a/CallbackHandler.CallbackMessageAggregate/CallbackMessageAggregate.cs
+++ b/CallbackHandler.CallbackMessageAggregate/CallbackMessageAggregate.cs
@@ -1,106 +1,95 @@
 using System.Runtime.CompilerServices;
 using SimpleResults;
 
-namespace CallbackHandler.CallbackMessageAggregate
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Diagnostics.CodeAnalysis;
-    using CallbackHandlers.Models;
-    using CallbackMessage.DomainEvents;
-    using Shared.DomainDrivenDesign.EventSourcing;
-    using Shared.EventStore.Aggregate;
-    using Shared.General;
+namespace CallbackHandler.CallbackMessageAggregate;
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using CallbackHandlers.Models;
+using CallbackMessage.DomainEvents;
+using Shared.DomainDrivenDesign.EventSourcing;
+using Shared.EventStore.Aggregate;
+using Shared.General;
     
-    public record CallbackMessageAggregate : Aggregate
+public record CallbackMessageAggregate : Aggregate
+{
+    public CallbackMessageAggregate()
     {
-        public CallbackMessageAggregate()
-        {
-            this.Destinations = new List<String>();
-        }
+        this.Destinations = new List<String>();
+    }
 
-        public String CallbackMessage { get; internal set; }
+    public String CallbackMessage { get; internal set; }
 
-        public MessageFormat MessageFormat { get; internal set; }
+    public MessageFormat MessageFormat { get; internal set; }
 
-        public String TypeString { get; internal set; }
+    public String TypeString { get; internal set; }
 
-        public String Reference { get; internal set; }
+    public String Reference { get; internal set; }
 
-        internal List<String> Destinations;
+    internal List<String> Destinations;
 
-        [ExcludeFromCodeCoverage]
-        protected override Object GetMetadata()
-        {
-            return null;
-        }
+    [ExcludeFromCodeCoverage]
+    protected override Object GetMetadata()
+    {
+        return null;
+    }
+
+    public override void PlayEvent(IDomainEvent domainEvent) => CallbackMessageAggregateExtensions.PlayEvent(this, (dynamic)domainEvent);
+}
 
-        public override void PlayEvent(IDomainEvent domainEvent) => CallbackMessageAggregateExtensions.PlayEvent(this, (dynamic)domainEvent);
+public static class CallbackMessageAggregateExtensions {
+    public static void PlayEvent(this CallbackMessageAggregate aggregate,
+                                 CallbackReceivedEvent domainEvent) {
+        // Mutate the state here based on the event
+        aggregate.CallbackMessage = domainEvent.CallbackMessage;
+        aggregate.MessageFormat = (MessageFormat)domainEvent.MessageFormat;
+        aggregate.TypeString = domainEvent.TypeString;
+        aggregate.Reference = domainEvent.Reference;
+        aggregate.Destinations.Add(domainEvent.Destination);
     }
 
-    public static class CallbackMessageAggregateExtensions
-    {
-        public static void PlayEvent(this CallbackMessageAggregate aggregate, CallbackReceivedEvent domainEvent)
-        {
-            // Mutate the state here based on the event
-            aggregate.CallbackMessage = domainEvent.CallbackMessage;
-            aggregate.MessageFormat = (MessageFormat) domainEvent.MessageFormat;
-            aggregate.TypeString = domainEvent.TypeString;
-            aggregate.Reference = domainEvent.Reference;
-            aggregate.Destinations.Add(domainEvent.Destination);
-        }
+    public static Result RecordCallback(this CallbackMessageAggregate aggregate,
+                                        Guid aggregateId,
+                                        String typeString,
+                                        MessageFormat messageFormat,
+                                        String callbackMessage,
+                                        String reference,
+                                        String[] destinations,
+                                        Guid estateId,
+                                        Guid merchantId) {
+        foreach (String destination in destinations) {
+            DomainEvent callbackReceivedEvent = CreateCallbackReceivedEvent(aggregate, aggregateId, typeString, messageFormat, callbackMessage, reference, destination, estateId, merchantId);
 
-        public static Result RecordCallback(this CallbackMessageAggregate aggregate,
-            Guid aggregateId,
-            String typeString,
-            MessageFormat messageFormat,
-            String callbackMessage,
-            String reference,
-            String[] destinations,
-            Guid estateId,Guid merchantId)
-        {
-            foreach (String destination in destinations)
-            {
-                DomainEvent callbackReceivedEvent = CreateCallbackReceivedEvent(aggregate,aggregateId, typeString,
-                    messageFormat, callbackMessage, reference, destination,
-                    estateId, merchantId);
-
-                aggregate.ApplyAndAppend(callbackReceivedEvent);
-            }
-
-            return Result.Success();
+            aggregate.ApplyAndAppend(callbackReceivedEvent);
         }
 
-        internal static DomainEvent CreateCallbackReceivedEvent(this CallbackMessageAggregate aggregate,
-            Guid aggregateId,
-            String typeString,
-            MessageFormat messageFormat,
-            String callbackMessage,
-            String reference,
-            String destination,
-            Guid estateId, Guid merchantId)
-        {
-            return new CallbackReceivedEvent(aggregateId, typeString, (Int32) messageFormat,
-                callbackMessage,
-                reference,
-                destination, estateId, merchantId);
-        }
+        return Result.Success();
+    }
 
-        public static String[] GetDestinations(this CallbackMessageAggregate aggregate)
-        {
-            return aggregate.Destinations.ToArray();
-        }
+    internal static DomainEvent CreateCallbackReceivedEvent(this CallbackMessageAggregate aggregate,
+                                                            Guid aggregateId,
+                                                            String typeString,
+                                                            MessageFormat messageFormat,
+                                                            String callbackMessage,
+                                                            String reference,
+                                                            String destination,
+                                                            Guid estateId,
+                                                            Guid merchantId) {
+        return new CallbackReceivedEvent(aggregateId, typeString, (Int32)messageFormat, callbackMessage, reference, destination, estateId, merchantId);
+    }
 
-        public static CallbackMessage GetCallbackMessage(this CallbackMessageAggregate aggregate)
-        {
-            return new CallbackMessage
-            {
-                Reference = aggregate.Reference,
-                Destinations = aggregate.Destinations,
-                Message = aggregate.CallbackMessage,
-                MessageFormat = aggregate.MessageFormat,
-                TypeString = aggregate.TypeString
-            };
-        }
+    public static String[] GetDestinations(this CallbackMessageAggregate aggregate) {
+        return aggregate.Destinations.ToArray();
+    }
+
+    public static CallbackMessage GetCallbackMessage(this CallbackMessageAggregate aggregate) {
+        return new CallbackMessage {
+            Reference = aggregate.Reference,
+            Destinations = aggregate.Destinations,
+            Message = aggregate.CallbackMessage,
+            MessageFormat = aggregate.MessageFormat,
+            TypeString = aggregate.TypeString
+        };
     }
 }
\ No newline at end of file