Consumer Api: Decompose Relationships during Identity Deletion

Modules/Relationships/src/Relationships.Application/Identities/IdentityDeleter.Tests.cs

@@ -1,5 +1,5 @@
 using Backbone.BuildingBlocks.Application.Identities;
-using Backbone.Modules.Relationships.Application.Relationships.Commands.DeleteRelationshipsOfIdentity;
+using Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
 using Backbone.Modules.Relationships.Application.RelationshipTemplates.Commands.AnonymizeRelationshipTemplateAllocationsAllocatedByIdentity;
 using Backbone.Modules.Relationships.Application.RelationshipTemplates.Commands.DeleteRelationshipTemplatesOfIdentity;
 using FakeItEasy;
@@ -23,7 +23,7 @@ public async Task Deleter_calls_correct_command()
 
         // Assert
         A.CallTo(() => mockMediator.Send(
-            A<DeleteRelationshipsOfIdentityCommand>.That.Matches(i => i.IdentityAddress == identityAddress),
+            A<DecomposeAndAnonymizeRelationshipsOfIdentityCommand>.That.Matches(i => i.IdentityAddress == identityAddress),
             A<CancellationToken>._)).MustHaveHappenedOnceExactly();
         A.CallTo(() => mockMediator.Send(
             A<DeleteRelationshipTemplatesOfIdentityCommand>.That.Matches(i => i.IdentityAddress == identityAddress),

Modules/Relationships/src/Relationships.Application/Identities/IdentityDeleter.cs

@@ -1,6 +1,6 @@
 using Backbone.BuildingBlocks.Application.Identities;
 using Backbone.DevelopmentKit.Identity.ValueObjects;
-using Backbone.Modules.Relationships.Application.Relationships.Commands.DeleteRelationshipsOfIdentity;
+using Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
 using Backbone.Modules.Relationships.Application.RelationshipTemplates.Commands.AnonymizeRelationshipTemplateAllocationsAllocatedByIdentity;
 using Backbone.Modules.Relationships.Application.RelationshipTemplates.Commands.DeleteRelationshipTemplatesOfIdentity;
 using MediatR;
@@ -20,7 +20,7 @@ public IdentityDeleter(IMediator mediator, IDeletionProcessLogger deletionProces
 
     public async Task Delete(IdentityAddress identityAddress)
     {
-        await _mediator.Send(new DeleteRelationshipsOfIdentityCommand(identityAddress));
+        await _mediator.Send(new DecomposeAndAnonymizeRelationshipsOfIdentityCommand(identityAddress));
         await _deletionProcessLogger.LogDeletion(identityAddress, "Relationships");
         await _mediator.Send(new DeleteRelationshipTemplatesOfIdentityCommand(identityAddress));
         await _deletionProcessLogger.LogDeletion(identityAddress, "RelationshipTemplates");

Modules/Relationships/src/Relationships.Application/Relationships/Commands/DecomposeAndAnonymizeRelationshipsOfIdentity/DecomposeAndAnonymizeRelationshipsOfIdentityCommand.cs

@@ -0,0 +1,13 @@
+using MediatR;
+
+namespace Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
+
+public class DecomposeAndAnonymizeRelationshipsOfIdentityCommand : IRequest
+{
+    public DecomposeAndAnonymizeRelationshipsOfIdentityCommand(string identityAddress)
+    {
+        IdentityAddress = identityAddress;
+    }
+
+    public string IdentityAddress { get; set; }
+}

Modules/Relationships/src/Relationships.Application/Relationships/Commands/DecomposeAndAnonymizeRelationshipsOfIdentity/Handler.Tests.cs

@@ -0,0 +1,26 @@
+using Backbone.Modules.Relationships.Application.Infrastructure.Persistence.Repository;
+using Backbone.Modules.Relationships.Domain.Aggregates.Relationships;
+using FakeItEasy;
+using Microsoft.Extensions.Options;
+
+namespace Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
+
+public class HandlerTests : AbstractTestsBase
+{
+    [Fact]
+    public async Task Command_calls_update_on_repository()
+    {
+        // Arrange
+        var mockRelationshipTemplatesRepository = A.Fake<IRelationshipsRepository>();
+        var mockOptions = A.Dummy<IOptions<ApplicationOptions>>();
+
+        var handler = new Handler(mockRelationshipTemplatesRepository, mockOptions);
+        var request = new DecomposeAndAnonymizeRelationshipsOfIdentityCommand(CreateRandomIdentityAddress());
+
+        // Act
+        await handler.Handle(request, CancellationToken.None);
+
+        // Assert
+        A.CallTo(() => mockRelationshipTemplatesRepository.Update(A<IEnumerable<Relationship>>._)).MustHaveHappened();
+    }
+}

Modules/Relationships/src/Relationships.Application/Relationships/Commands/DecomposeAndAnonymizeRelationshipsOfIdentity/Handler.cs

@@ -0,0 +1,28 @@
+using Backbone.Modules.Relationships.Application.Infrastructure.Persistence.Repository;
+using Backbone.Modules.Relationships.Domain.Aggregates.Relationships;
+using MediatR;
+using Microsoft.Extensions.Options;
+
+namespace Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
+
+public class Handler : IRequestHandler<DecomposeAndAnonymizeRelationshipsOfIdentityCommand>
+{
+    private readonly IRelationshipsRepository _relationshipsRepository;
+    private readonly ApplicationOptions _applicationOptions;
+
+    public Handler(IRelationshipsRepository relationshipsRepository, IOptions<ApplicationOptions> applicationOptions)
+    {
+        _relationshipsRepository = relationshipsRepository;
+        _applicationOptions = applicationOptions.Value;
+    }
+
+    public async Task Handle(DecomposeAndAnonymizeRelationshipsOfIdentityCommand request, CancellationToken cancellationToken)
+    {
+        var relationships = (await _relationshipsRepository.FindRelationships(Relationship.HasParticipant(request.IdentityAddress), cancellationToken)).ToList();
+
+        foreach (var relationship in relationships)
+            relationship.DecomposeDueToIdentityDeletion(request.IdentityAddress, _applicationOptions.DidDomainName);
+
+        await _relationshipsRepository.Update(relationships);
+    }
+}

Modules/Relationships/src/Relationships.Application/Relationships/Commands/DecomposeAndAnonymizeRelationshipsOfIdentity/Validator.cs

@@ -0,0 +1,13 @@
+using Backbone.BuildingBlocks.Application.Extensions;
+using Backbone.DevelopmentKit.Identity.ValueObjects;
+using FluentValidation;
+
+namespace Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
+
+public class Validator : AbstractValidator<DecomposeAndAnonymizeRelationshipsOfIdentityCommand>
+{
+    public Validator()
+    {
+        RuleFor(x => x.IdentityAddress).ValidId<DecomposeAndAnonymizeRelationshipsOfIdentityCommand, IdentityAddress>();
+    }
+}

Modules/Relationships/src/Relationships.Application/Relationships/DTOs/RelationshipAuditLogEntryDTO.cs

@@ -8,15 +8,15 @@ public RelationshipAuditLogEntryDTO(RelationshipAuditLogEntry entry)
     {
         CreatedAt = entry.CreatedAt;
         CreatedBy = entry.CreatedBy;
-        CreatedByDevice = entry.CreatedByDevice;
+        CreatedByDevice = entry.CreatedByDevice?.Value;
         Reason = entry.Reason.ToString();
         OldStatus = entry.OldStatus.ToDtoString();
         NewStatus = entry.NewStatus.ToDtoString();
     }
 
     public DateTime CreatedAt { get; set; }
     public string CreatedBy { get; set; }
-    public string CreatedByDevice { get; set; }
+    public string? CreatedByDevice { get; set; }
     public string Reason { get; set; }
 
     public string? OldStatus { get; set; }

Modules/Relationships/src/Relationships.Domain/Aggregates/Relationships/Relationship.DecomposeDueToIdentityDeletionTests.cs

@@ -0,0 +1,89 @@
+using Backbone.BuildingBlocks.Domain.Exceptions;
+using Backbone.DevelopmentKit.Identity.ValueObjects;
+using Backbone.UnitTestTools.Extensions;
+using static Backbone.Modules.Relationships.Domain.TestHelpers.TestData;
+
+namespace Backbone.Modules.Relationships.Domain.Aggregates.Relationships;
+
+public class RelationshipDecomposeDueToIdentityDeletionTests : AbstractTestsBase
+{
+    private const string DID_DOMAIN_NAME = "localhost";
+
+    [Theory]
+    [InlineData(RelationshipStatus.Pending)]
+    [InlineData(RelationshipStatus.Active)]
+    [InlineData(RelationshipStatus.Rejected)]
+    [InlineData(RelationshipStatus.Revoked)]
+    [InlineData(RelationshipStatus.Terminated)]
+    public void Decomposition_can_be_performed_from_multiple_statuses(RelationshipStatus status)
+    {
+        // Arrange
+        var relationship = CreateRelationshipInStatus(status, IDENTITY_1, IDENTITY_2);
+
+        // Act
+        var acting = () => relationship.DecomposeDueToIdentityDeletion(IDENTITY_1, DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().NotThrow();
+        relationship.Status.Should().Be(RelationshipStatus.DeletionProposed);
+        relationship.FromHasDecomposed.Should().BeTrue();
+        relationship.ToHasDecomposed.Should().BeFalse();
+    }
+
+    [Fact]
+    public void Decomposition_can_not_be_called_by_the_same_identity_twice()
+    {
+        // Arrange
+        var relationship = CreateRelationshipDecomposedByFrom(IDENTITY_1, IDENTITY_2);
+
+        // Act
+        var acting = () => relationship.DecomposeDueToIdentityDeletion(IDENTITY_1, DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().Throw<DomainException>().WithError("error.platform.validation.relationship.relationshipAlreadyDecomposed");
+    }
+
+    [Fact]
+    public void Decomposition_can_not_be_performed_by_other_identities()
+    {
+        // Arrange
+        var relationship = CreateActiveRelationship(IDENTITY_1, IDENTITY_2);
+
+        // Act
+        var acting = () => relationship.DecomposeDueToIdentityDeletion(CreateRandomIdentityAddress(), DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().Throw<DomainException>().WithError("error.platform.validation.relationship.requestingIdentityDoesNotBelongToRelationship");
+    }
+
+    [Fact]
+    public void Decomposition_by_both_identities_transitions_relationship_to_status_ReadyForDeletion()
+    {
+        // Arrange
+        var relationship = CreateActiveRelationship(IDENTITY_1, IDENTITY_2);
+        relationship.DecomposeDueToIdentityDeletion(IDENTITY_1, DID_DOMAIN_NAME);
+
+        // Act
+        var acting = () => relationship.DecomposeDueToIdentityDeletion(IDENTITY_2, DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().NotThrow();
+        relationship.Status.Should().Be(RelationshipStatus.ReadyForDeletion);
+    }
+
+    [Fact]
+    public void Anonymize_anonymizes_the_audit_logs()
+    {
+        // Arrange
+        var relationship = CreateActiveRelationship(IDENTITY_1, IDENTITY_2);
+        var anonymousIdentity = IdentityAddress.GetAnonymized(DID_DOMAIN_NAME);
+
+        // Act
+        relationship.DecomposeDueToIdentityDeletion(IDENTITY_1, DID_DOMAIN_NAME);
+
+        // Assert
+        relationship.AuditLog.Should().HaveCount(3);
+        relationship.AuditLog[0].CreatedBy.Should().Be(anonymousIdentity);
+        relationship.AuditLog[2].CreatedBy.Should().Be(anonymousIdentity);
+    }
+}

Modules/Relationships/src/Relationships.Domain/Aggregates/Relationships/Relationship.cs

@@ -77,8 +77,8 @@ private static void EnsureTargetIsNotSelf(RelationshipTemplate relationshipTempl
     public RelationshipTemplateId? RelationshipTemplateId { get; }
     public RelationshipTemplate? RelationshipTemplate { get; }
 
-    public IdentityAddress From { get; }
-    public IdentityAddress To { get; }
+    public IdentityAddress From { get; private set; }
+    public IdentityAddress To { get; private set; }
 
     public DateTime CreatedAt { get; }
 
@@ -296,23 +296,35 @@ public void Decompose(IdentityAddress activeIdentity, DeviceId activeDevice)
         EnsureStatus(RelationshipStatus.Rejected, RelationshipStatus.Revoked, RelationshipStatus.Terminated, RelationshipStatus.DeletionProposed);
 
         if (Status is RelationshipStatus.Terminated or RelationshipStatus.Rejected or RelationshipStatus.Revoked)
-            DecomposeAsFirstParticipant(activeIdentity, activeDevice);
+            DecomposeAsFirstParticipant(activeIdentity, activeDevice, RelationshipAuditLogEntryReason.Decomposition);
         else
-            DecomposeAsSecondParticipant(activeIdentity, activeDevice);
+            DecomposeAsSecondParticipant(activeIdentity, activeDevice, RelationshipAuditLogEntryReason.Decomposition);
 
         RaiseDomainEvent(new RelationshipStatusChangedDomainEvent(this));
     }
 
-    private void DecomposeAsFirstParticipant(IdentityAddress activeIdentity, DeviceId activeDevice)
+    public void DecomposeDueToIdentityDeletion(IdentityAddress identityToBeDeleted, string didDomainName)
     {
-        EnsureStatus(RelationshipStatus.Terminated, RelationshipStatus.Rejected, RelationshipStatus.Revoked);
+        EnsureHasParticipant(identityToBeDeleted);
+        EnsureRelationshipNotDecomposedBy(identityToBeDeleted);
 
+        if (Status is RelationshipStatus.DeletionProposed)
+            DecomposeAsSecondParticipant(identityToBeDeleted, null, RelationshipAuditLogEntryReason.DecompositionDueToIdentityDeletion);
+        else
+            DecomposeAsFirstParticipant(identityToBeDeleted, null, RelationshipAuditLogEntryReason.DecompositionDueToIdentityDeletion);
+
+        AnonymizeParticipant(identityToBeDeleted, didDomainName);
+        RaiseDomainEvent(new RelationshipStatusChangedDomainEvent(this));
+    }
+
+    private void DecomposeAsFirstParticipant(IdentityAddress activeIdentity, DeviceId? activeDevice, RelationshipAuditLogEntryReason reason)
+    {
         var oldStatus = Status;
 
         Status = RelationshipStatus.DeletionProposed;
 
         var auditLogEntry = new RelationshipAuditLogEntry(
-            RelationshipAuditLogEntryReason.Decomposition,
+            reason,
             oldStatus,
             RelationshipStatus.DeletionProposed,
             activeIdentity,
@@ -326,14 +338,14 @@ private void DecomposeAsFirstParticipant(IdentityAddress activeIdentity, DeviceI
             ToHasDecomposed = true;
     }
 
-    private void DecomposeAsSecondParticipant(IdentityAddress activeIdentity, DeviceId activeDevice)
+    private void DecomposeAsSecondParticipant(IdentityAddress activeIdentity, DeviceId? activeDevice, RelationshipAuditLogEntryReason reason)
     {
         EnsureStatus(RelationshipStatus.DeletionProposed);
 
         Status = RelationshipStatus.ReadyForDeletion;
 
         var auditLogEntry = new RelationshipAuditLogEntry(
-            RelationshipAuditLogEntryReason.Decomposition,
+            reason,
             RelationshipStatus.DeletionProposed,
             RelationshipStatus.ReadyForDeletion,
             activeIdentity,
@@ -357,6 +369,23 @@ private void EnsureHasParticipant(IdentityAddress activeIdentity)
             throw new DomainException(DomainErrors.RequestingIdentityDoesNotBelongToRelationship());
     }
 
+    private void AnonymizeParticipant(IdentityAddress identityToAnonymize, string didDomainName)
+    {
+        EnsureHasParticipant(identityToAnonymize);
+        EnsureStatus(RelationshipStatus.DeletionProposed, RelationshipStatus.ReadyForDeletion);
+
+        var anonymousIdentity = IdentityAddress.GetAnonymized(didDomainName);
+
+        if (From == identityToAnonymize)
+            From = anonymousIdentity;
+        else
+            To = anonymousIdentity;
+
+        foreach (var auditLogEntry in AuditLog)
+            if (auditLogEntry.CreatedBy == identityToAnonymize)
+                auditLogEntry.AnonymizeIdentity(anonymousIdentity);
+    }
+
     public void ParticipantIsToBeDeleted(IdentityAddress identityToBeDeleted, DateTime gracePeriodEndsAt)
     {
         var peer = GetPeerOf(identityToBeDeleted);