Make external event payloads strongly typed

Modules/Synchronization/src/Synchronization.Application/DomainEvents/Incoming/IdentityDeletionProcessStarted/IdentityDeletionProcessStartedDomainEventHandler.cs

@@ -18,23 +18,29 @@ public IdentityDeletionProcessStartedDomainEventHandler(ISynchronizationDbContex
         _logger = logger;
     }
 
-    public async Task Handle(IdentityDeletionProcessStartedDomainEvent domainEvent)
+    public async Task Handle(IdentityDeletionProcessStartedDomainEvent @event)
     {
-        // No need to create an external event if the deletion process was started by the identity itself (in that case it's not "external").
-        if (domainEvent.Initiator == domainEvent.Address)
-            return;
-
-#pragma warning disable IDE0037
-        var payload = new { DeletionProcessId = domainEvent.DeletionProcessId };
-#pragma warning restore IDE0037
         try
         {
-            await _dbContext.CreateExternalEvent(IdentityAddress.Parse(domainEvent.Address), ExternalEventType.IdentityDeletionProcessStarted, payload);
+            await CreateIdentityDeletionProcessStartedExternalEvent(@event);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "An error occured while processing a domain event.");
             throw;
         }
     }
+
+    private async Task CreateIdentityDeletionProcessStartedExternalEvent(IdentityDeletionProcessStartedDomainEvent @event)
+    {
+        // No need to create an external event if the deletion process was started by the identity itself (in that case it's not "external").
+        if (@event.Initiator == @event.Address)
+            return;
+
+        var payload = new IdentityDeletionProcessStartedExternalEvent.EventPayload { DeletionProcessId = @event.DeletionProcessId };
+
+        var externalEvent = new IdentityDeletionProcessStartedExternalEvent(IdentityAddress.Parse(@event.Address), payload);
+
+        await _dbContext.CreateExternalEvent(externalEvent);
+    }
 }

Modules/Synchronization/src/Synchronization.Application/DomainEvents/Incoming/IdentityDeletionProcessStatusChanged/IdentityDeletionProcessStatusChangedDomainEventHandler.cs

@@ -21,21 +21,27 @@ public IdentityDeletionProcessStatusChangedDomainEventHandler(ISynchronizationDb
 
     public async Task Handle(IdentityDeletionProcessStatusChangedDomainEvent @event)
     {
-        // No need to create an external event if the action that triggered the event was initiated by the owner of the deletion process (in that case it's not "external").
-        if (@event.Initiator == @event.Address)
-            return;
-
-#pragma warning disable IDE0037
-        var payload = new { DeletionProcessId = @event.DeletionProcessId };
-#pragma warning restore IDE0037
         try
         {
-            await _dbContext.CreateExternalEvent(IdentityAddress.Parse(@event.Address), ExternalEventType.IdentityDeletionProcessStatusChanged, payload);
+            await CreateIdentityDeletionProcessStatusChangedExternalEvent(@event);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "An error occured while processing a domain event.");
             throw;
         }
     }
+
+    private async Task CreateIdentityDeletionProcessStatusChangedExternalEvent(IdentityDeletionProcessStatusChangedDomainEvent @event)
+    {
+        // No need to create an external event if the action that triggered the event was initiated by the owner of the deletion process (in that case it's not "external").
+        if (@event.Initiator == @event.Address)
+            return;
+
+        var payload = new IdentityDeletionProcessStatusChangedExternalEvent.EventPayload { DeletionProcessId = @event.DeletionProcessId };
+
+        var externalEvent = new IdentityDeletionProcessStatusChangedExternalEvent(IdentityAddress.Parse(@event.Address), payload);
+
+        await _dbContext.CreateExternalEvent(externalEvent);
+    }
 }

Modules/Synchronization/src/Synchronization.Application/DomainEvents/Incoming/MessageCreated/MessageCreatedDomainEventHandler.cs

@@ -18,27 +18,28 @@ public MessageCreatedDomainEventHandler(ISynchronizationDbContext dbContext, ILo
         _logger = logger;
     }
 
-    public async Task Handle(MessageCreatedDomainEvent domainEvent)
+    public async Task Handle(MessageCreatedDomainEvent @event)
     {
-        await CreateExternalEvents(domainEvent);
+        try
+        {
+            await CreateMessageReceivedExternalEvents(@event);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "An error occured while processing a domain event.");
+            throw;
+        }
     }
 
-    private async Task CreateExternalEvents(MessageCreatedDomainEvent domainEvent)
+    private async Task CreateMessageReceivedExternalEvents(MessageCreatedDomainEvent @event)
     {
-        foreach (var recipient in domainEvent.Recipients)
+        foreach (var recipient in @event.Recipients)
         {
-#pragma warning disable IDE0037
-            var payload = new { Id = domainEvent.Id };
-#pragma warning restore IDE0037
-            try
-            {
-                await _dbContext.CreateExternalEvent(IdentityAddress.Parse(recipient), ExternalEventType.MessageReceived, payload);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "An error occured while processing a domain event.");
-                throw;
-            }
+            var payload = new MessageReceivedExternalEvent.EventPayload { Id = @event.Id };
+
+            var externalEvent = new MessageReceivedExternalEvent(IdentityAddress.Parse(recipient), payload);
+
+            await _dbContext.CreateExternalEvent(externalEvent);
         }
     }
 }

Modules/Synchronization/src/Synchronization.Application/DomainEvents/Incoming/PeerDeleted/PeerDeletedDomainEventHandler.cs

@@ -1,4 +1,5 @@
 using Backbone.BuildingBlocks.Application.Abstractions.Infrastructure.EventBus;
+using Backbone.DevelopmentKit.Identity.ValueObjects;
 using Backbone.Modules.Synchronization.Application.Infrastructure;
 using Backbone.Modules.Synchronization.Domain.DomainEvents.Incoming.PeerDeleted;
 using Backbone.Modules.Synchronization.Domain.Entities.Sync;
@@ -18,28 +19,25 @@ public PeerDeletedDomainEventHandler(ISynchronizationDbContext dbContext, ILogge
         _logger = logger;
     }
 
-    public async Task Handle(PeerDeletedDomainEvent domainEvent)
+    public async Task Handle(PeerDeletedDomainEvent @event)
     {
-        await CreateExternalEvent(domainEvent);
-    }
-
-    private async Task CreateExternalEvent(PeerDeletedDomainEvent @event)
-    {
-#pragma warning disable IDE0037
-        var payload = new
-        {
-            RelationshipId = @event.RelationshipId,
-            DeletionDate = SystemTime.UtcNow
-        };
-#pragma warning restore IDE0037
         try
         {
-            await _dbContext.CreateExternalEvent(@event.PeerOfDeletedIdentity, ExternalEventType.PeerDeleted, payload);
+            await CreatePeerDeletedExternalEvent(@event);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "An error occured while processing a domain event.");
             throw;
         }
     }
+
+    private async Task CreatePeerDeletedExternalEvent(PeerDeletedDomainEvent @event)
+    {
+        var payload = new PeerDeletedExternalEvent.EventPayload { RelationshipId = @event.RelationshipId, DeletionDate = SystemTime.UtcNow };
+
+        var externalEvent = new PeerDeletedExternalEvent(IdentityAddress.Parse(@event.PeerOfDeletedIdentity), payload);
+
+        await _dbContext.CreateExternalEvent(externalEvent);
+    }
 }

Modules/Synchronization/src/Synchronization.Application/DomainEvents/Incoming/PeerDeletionCancelled/PeerDeletionCancelledDomainEventHandler.cs

@@ -1,4 +1,5 @@
 using Backbone.BuildingBlocks.Application.Abstractions.Infrastructure.EventBus;
+using Backbone.DevelopmentKit.Identity.ValueObjects;
 using Backbone.Modules.Synchronization.Application.Infrastructure;
 using Backbone.Modules.Synchronization.Domain.DomainEvents.Incoming.PeerDeletionCancelled;
 using Backbone.Modules.Synchronization.Domain.Entities.Sync;
@@ -17,24 +18,25 @@ public PeerDeletionCancelledDomainEventHandler(ISynchronizationDbContext dbConte
         _logger = logger;
     }
 
-    public async Task Handle(PeerDeletionCancelledDomainEvent domainEvent)
+    public async Task Handle(PeerDeletionCancelledDomainEvent @event)
     {
-        await CreateExternalEvent(domainEvent);
-    }
-
-    private async Task CreateExternalEvent(PeerDeletionCancelledDomainEvent @event)
-    {
-#pragma warning disable IDE0037
-        var payload = new { RelationshipId = @event.RelationshipId };
-#pragma warning restore IDE0037
         try
         {
-            await _dbContext.CreateExternalEvent(@event.PeerOfIdentityWithDeletionCancelled, ExternalEventType.PeerDeletionCancelled, payload);
+            await CreatePeerDeletionCancelledExternalEvent(@event);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "An error occured while processing a domain event.");
             throw;
         }
     }
+
+    private async Task CreatePeerDeletionCancelledExternalEvent(PeerDeletionCancelledDomainEvent @event)
+    {
+        var payload = new PeerDeletionCancelledExternalEvent.EventPayload { RelationshipId = @event.RelationshipId };
+
+        var externalEvent = new PeerDeletionCancelledExternalEvent(IdentityAddress.Parse(@event.PeerOfIdentityWithDeletionCancelled), payload);
+
+        await _dbContext.CreateExternalEvent(externalEvent);
+    }
 }

Modules/Synchronization/src/Synchronization.Application/DomainEvents/Incoming/PeerToBeDeleted/PeerToBeDeletedDomainEventHandler.cs

@@ -1,4 +1,5 @@
 using Backbone.BuildingBlocks.Application.Abstractions.Infrastructure.EventBus;
+using Backbone.DevelopmentKit.Identity.ValueObjects;
 using Backbone.Modules.Synchronization.Application.Infrastructure;
 using Backbone.Modules.Synchronization.Domain.DomainEvents.Incoming.PeerToBeDeleted;
 using Backbone.Modules.Synchronization.Domain.Entities.Sync;
@@ -17,28 +18,25 @@ public PeerToBeDeletedDomainEventHandler(ISynchronizationDbContext dbContext, IL
         _logger = logger;
     }
 
-    public async Task Handle(PeerToBeDeletedDomainEvent domainEvent)
+    public async Task Handle(PeerToBeDeletedDomainEvent @event)
     {
-        await CreateExternalEvent(domainEvent);
-    }
-
-    private async Task CreateExternalEvent(PeerToBeDeletedDomainEvent @event)
-    {
-#pragma warning disable IDE0037
-        var payload = new
-        {
-            RelationshipId = @event.RelationshipId,
-            DeletionDate = @event.GracePeriodEndsAt
-        };
-#pragma warning restore IDE0037
         try
         {
-            await _dbContext.CreateExternalEvent(@event.PeerOfIdentityToBeDeleted, ExternalEventType.PeerToBeDeleted, payload);
+            await CreatePeerToBeDeletedExternalEvent(@event);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "An error occured while processing a domain event.");
             throw;
         }
     }
+
+    private async Task CreatePeerToBeDeletedExternalEvent(PeerToBeDeletedDomainEvent @event)
+    {
+        var payload = new PeerToBeDeletedExternalEvent.EventPayload { RelationshipId = @event.RelationshipId, DeletionDate = @event.GracePeriodEndsAt };
+
+        var externalEvent = new PeerToBeDeletedExternalEvent(IdentityAddress.Parse(@event.PeerOfIdentityToBeDeleted), payload);
+
+        await _dbContext.CreateExternalEvent(externalEvent);
+    }
 }

Modules/Synchronization/src/Synchronization.Application/DomainEvents/Incoming/RelationshipReactivationCompleted/RelationshipReactivationCompletedDomainEventHandler.cs

@@ -1,5 +1,4 @@
 using Backbone.BuildingBlocks.Application.Abstractions.Infrastructure.EventBus;
-using Backbone.DevelopmentKit.Identity.ValueObjects;
 using Backbone.Modules.Synchronization.Application.Infrastructure;
 using Backbone.Modules.Synchronization.Domain.DomainEvents.Incoming.RelationshipReactivationCompleted;
 using Backbone.Modules.Synchronization.Domain.Entities.Sync;
@@ -18,24 +17,25 @@ public RelationshipReactivationCompletedDomainEventHandler(ISynchronizationDbCon
         _logger = logger;
     }
 
-    public async Task Handle(RelationshipReactivationCompletedDomainEvent domainEvent)
+    public async Task Handle(RelationshipReactivationCompletedDomainEvent @event)
     {
-        await CreateExternalEvent(domainEvent);
-    }
-
-    private async Task CreateExternalEvent(RelationshipReactivationCompletedDomainEvent @event)
-    {
-#pragma warning disable IDE0037
-        var payload = new { RelationshipId = @event.RelationshipId };
-#pragma warning restore IDE0037
         try
         {
-            await _dbContext.CreateExternalEvent(IdentityAddress.Parse(@event.Peer), ExternalEventType.RelationshipReactivationCompleted, payload);
+            await CreateRelationshipReactivationCompletedExternalEvent(@event);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "An error occured while processing a domain event.");
             throw;
         }
     }
+
+    private async Task CreateRelationshipReactivationCompletedExternalEvent(RelationshipReactivationCompletedDomainEvent @event)
+    {
+        var payload = new RelationshipReactivationCompletedExternalEvent.EventPayload { RelationshipId = @event.RelationshipId };
+
+        var externalEvent = new RelationshipReactivationCompletedExternalEvent(@event.Peer, payload);
+
+        await _dbContext.CreateExternalEvent(externalEvent);
+    }
 }

Modules/Synchronization/src/Synchronization.Application/DomainEvents/Incoming/RelationshipReactivationRequested/RelationshipReactivationRequestedDomainEventHandler.cs

@@ -1,5 +1,4 @@
 using Backbone.BuildingBlocks.Application.Abstractions.Infrastructure.EventBus;
-using Backbone.DevelopmentKit.Identity.ValueObjects;
 using Backbone.Modules.Synchronization.Application.DomainEvents.Incoming.MessageCreated;
 using Backbone.Modules.Synchronization.Application.Infrastructure;
 using Backbone.Modules.Synchronization.Domain.DomainEvents.Incoming.RelationshipReactivationRequested;
@@ -19,24 +18,25 @@ public RelationshipReactivationRequestedDomainEventHandler(ISynchronizationDbCon
         _logger = logger;
     }
 
-    public async Task Handle(RelationshipReactivationRequestedDomainEvent integrationEvent)
+    public async Task Handle(RelationshipReactivationRequestedDomainEvent @event)
     {
-        await CreateExternalEvents(integrationEvent);
-    }
-
-    private async Task CreateExternalEvents(RelationshipReactivationRequestedDomainEvent @event)
-    {
-#pragma warning disable IDE0037
-        var payload = new { RelationshipId = @event.RelationshipId };
-#pragma warning restore IDE0037
         try
         {
-            await _dbContext.CreateExternalEvent(IdentityAddress.Parse(@event.Peer), ExternalEventType.RelationshipReactivationRequested, payload);
+            await CreateRelationshipReactivationRequestedExternalEvent(@event);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "An error occured while processing a domain event.");
             throw;
         }
     }
+
+    private async Task CreateRelationshipReactivationRequestedExternalEvent(RelationshipReactivationRequestedDomainEvent @event)
+    {
+        var payload = new RelationshipReactivationRequestedExternalEvent.EventPayload { RelationshipId = @event.RelationshipId };
+
+        var externalEvent = new RelationshipReactivationRequestedExternalEvent(@event.Peer, payload);
+
+        await _dbContext.CreateExternalEvent(externalEvent);
+    }
 }

Modules/Synchronization/src/Synchronization.Application/DomainEvents/Incoming/RelationshipStatusChanged/RelationshipStatusChangedDomainEventHandler.cs

@@ -19,23 +19,27 @@ public RelationshipStatusChangedDomainEventHandler(ISynchronizationDbContext dbC
 
     public async Task Handle(RelationshipStatusChangedDomainEvent @event)
     {
-        // if the relationship is in status "ReadyForDeletion", the peer doesn't know anything about it; therefore we must not create an external event
-        if (@event.NewStatus == "ReadyForDeletion")
-        {
-            return;
-        }
-
-#pragma warning disable IDE0037
-        var payload = new { RelationshipId = @event.RelationshipId };
-#pragma warning restore IDE0037
         try
         {
-            await _dbContext.CreateExternalEvent(@event.Peer, ExternalEventType.RelationshipStatusChanged, payload);
+            await CreateRelationshipStatusChangedExternalEvent(@event);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "An error occured while processing a domain event.");
             throw;
         }
     }
+
+    private async Task CreateRelationshipStatusChangedExternalEvent(RelationshipStatusChangedDomainEvent @event)
+    {
+        // if the relationship is in status "ReadyForDeletion", the peer doesn't know anything about it; therefore we must not create an external event
+        if (@event.NewStatus == "ReadyForDeletion")
+            return;
+
+        var payload = new RelationshipStatusChangedExternalEvent.EventPayload { RelationshipId = @event.RelationshipId };
+
+        var externalEvent = new RelationshipStatusChangedExternalEvent(@event.Peer, payload);
+
+        await _dbContext.CreateExternalEvent(externalEvent);
+    }
 }