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.DecomposeRelationshipsOfIdentity;
+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<DecomposeRelationshipsOfIdentityCommand>.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,7 +1,6 @@
 using Backbone.BuildingBlocks.Application.Identities;
 using Backbone.DevelopmentKit.Identity.ValueObjects;
-using Backbone.Modules.Relationships.Application.Relationships.Commands.AnonymizeRelationshipsOfIdentity;
-using Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeRelationshipsOfIdentity;
+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;
@@ -21,12 +20,11 @@ public IdentityDeleter(IMediator mediator, IDeletionProcessLogger deletionProces
 
     public async Task Delete(IdentityAddress identityAddress)
     {
-        await _mediator.Send(new DecomposeRelationshipsOfIdentityCommand(identityAddress));
+        await _mediator.Send(new DecomposeAndAnonymizeRelationshipsOfIdentityCommand(identityAddress));
         await _deletionProcessLogger.LogDeletion(identityAddress, "Relationships");
         await _mediator.Send(new DeleteRelationshipTemplatesOfIdentityCommand(identityAddress));
         await _deletionProcessLogger.LogDeletion(identityAddress, "RelationshipTemplates");
         await _mediator.Send(new AnonymizeRelationshipTemplateAllocationsAllocatedByIdentityCommand(identityAddress));
         await _deletionProcessLogger.LogDeletion(identityAddress, "RelationshipTemplateAllocations");
-        await _mediator.Send(new AnonymizeRelationshipsOfIdentityCommand(identityAddress));
     }
 }

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/DecomposeRelationshipsOfIdentity/Handler.Tests.cs → Modules/Relationships/src/Relationships.Application/Relationships/Commands/DecomposeAndAnonymizeRelationshipsOfIdentity/Handler.Tests.cs

@@ -1,26 +1,26 @@
-using System.Linq.Expressions;
-using Backbone.Modules.Relationships.Application.Infrastructure.Persistence.Repository;
+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.DecomposeRelationshipsOfIdentity;
+namespace Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
 
 public class HandlerTests : AbstractTestsBase
 {
     [Fact]
-    public async Task Command_calls_find_on_repository()
+    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);
-        var request = new DecomposeRelationshipsOfIdentityCommand(CreateRandomIdentityAddress());
+        var handler = new Handler(mockRelationshipTemplatesRepository, mockOptions);
+        var request = new DecomposeAndAnonymizeRelationshipsOfIdentityCommand(CreateRandomIdentityAddress());
 
         // Act
         await handler.Handle(request, CancellationToken.None);
 
         // Assert
-        A.CallTo(() => mockRelationshipTemplatesRepository.FindRelationships(A<Expression<Func<Relationship, bool>>>._, A<CancellationToken>._)).MustHaveHappened();
         A.CallTo(() => mockRelationshipTemplatesRepository.Update(A<IEnumerable<Relationship>>._)).MustHaveHappened();
     }
 }

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

@@ -0,0 +1,31 @@
+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);
+            relationship.AnonymizeParticipant(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.Domain/Aggregates/Relationships/Relationship.AnonymizeTests.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 RelationshipAnonymizeTests : AbstractTestsBase
+{
+    private const string DID_DOMAIN_NAME = "localhost";
+
+    [Theory]
+    [InlineData(RelationshipStatus.DeletionProposed)]
+    [InlineData(RelationshipStatus.ReadyForDeletion)]
+    public void Anonymize_can_be_performed_for_decomposed_relationship(RelationshipStatus status)
+    {
+        // Arrange
+        var relationship = CreateRelationshipInStatus(status, IDENTITY_1, IDENTITY_2);
+
+        // Act
+        var acting = () => relationship.AnonymizeParticipant(IDENTITY_1, DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().NotThrow();
+        relationship.From.Should().Be(IdentityAddress.GetAnonymized(DID_DOMAIN_NAME));
+    }
+
+    [Fact]
+    public void Anonymize_can_be_performed_for_other_participant()
+    {
+        // Arrange
+        var relationship = CreateRelationshipReadyForDeletion(IDENTITY_1, IDENTITY_2);
+
+        // Act
+        var acting = () => relationship.AnonymizeParticipant(IDENTITY_2, DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().NotThrow();
+        relationship.To.Should().Be(IdentityAddress.GetAnonymized(DID_DOMAIN_NAME));
+    }
+
+    [Fact]
+    public void Anonymize_can_not_be_performed_by_other_identities()
+    {
+        // Arrange
+        var relationship = CreateRelationshipReadyForDeletion(IDENTITY_1, IDENTITY_2);
+
+        // Act
+        var acting = () => relationship.AnonymizeParticipant(CreateRandomIdentityAddress(), DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().Throw<DomainException>().WithError("error.platform.validation.relationship.requestingIdentityDoesNotBelongToRelationship");
+    }
+
+    [Theory]
+    [InlineData(RelationshipStatus.Pending)]
+    [InlineData(RelationshipStatus.Active)]
+    [InlineData(RelationshipStatus.Rejected)]
+    [InlineData(RelationshipStatus.Revoked)]
+    [InlineData(RelationshipStatus.Terminated)]
+    public void Anonymize_can_not_be_performed_when_not_decomposed(RelationshipStatus status)
+    {
+        // Arrange
+        var relationship = CreateRelationshipInStatus(status, IDENTITY_1, IDENTITY_2);
+
+        // Act
+        var acting = () => relationship.AnonymizeParticipant(IDENTITY_1, DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().Throw<DomainException>().WithError("error.platform.validation.relationship.relationshipIsNotInCorrectStatus");
+    }
+
+    [Fact]
+    public void Anonymize_anonymizes_the_audit_logs()
+    {
+        // Arrange
+        var relationship = CreateActiveRelationship(IDENTITY_1, IDENTITY_2);
+        relationship.DecomposeDueToIdentityDeletion(IDENTITY_1);
+        var anonymousIdentity = IdentityAddress.GetAnonymized(DID_DOMAIN_NAME);
+
+        // Act
+        relationship.AnonymizeParticipant(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);
+    }
+}