feat: resolve and upsert CCR roles from A2 command (#411)

Author: Alxandr

src/Altinn.Register/src/Altinn.Register/PartyImport/A2/A2ExternalRoleResolveConsumer.cs

@@ -0,0 +1,138 @@
+#nullable enable
+
+using System.Diagnostics.Metrics;
+using Altinn.Authorization.ServiceDefaults.MassTransit;
+using Altinn.Register.Contracts.ExternalRoles;
+using Altinn.Register.Core;
+using Altinn.Register.Core.ExternalRoles;
+using MassTransit;
+
+namespace Altinn.Register.PartyImport.A2;
+
+/// <summary>
+/// Consumer for resolving A2 external role assignments.
+/// </summary>
+public sealed partial class A2ExternalRoleResolverConsumer
+    : IConsumer<ResolveAndUpsertA2CCRRoleAssignmentsCommand>
+{
+    private readonly ILogger<A2ExternalRoleResolverConsumer> _logger;
+    private readonly IExternalRoleDefinitionPersistence _persistence;
+    private readonly ICommandSender _sender;
+    private readonly ImportMeters _meters;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="A2ExternalRoleResolverConsumer"/> class.
+    /// </summary>
+    public A2ExternalRoleResolverConsumer(
+        ILogger<A2ExternalRoleResolverConsumer> logger,
+        IExternalRoleDefinitionPersistence externalRoleDefinitionPersistence,
+        ICommandSender sender,
+        RegisterTelemetry telemetry)
+    {
+        _logger = logger;
+        _persistence = externalRoleDefinitionPersistence;
+        _sender = sender;
+        _meters = telemetry.GetServiceMeters<ImportMeters>();
+    }
+
+    /// <inheritdoc/>
+    public async Task Consume(ConsumeContext<ResolveAndUpsertA2CCRRoleAssignmentsCommand> context)
+    {
+        if (context.Message.RoleAssignments.Count == 0)
+        {
+            await _sender.Send(new UpsertExternalRoleAssignmentsCommand
+            {
+                FromPartyUuid = context.Message.FromPartyUuid,
+                Source = ExternalRoleSource.CentralCoordinatingRegister,
+                Assignments = [],
+                Tracking = context.Message.Tracking,
+            });
+
+            return;
+        }
+
+        var assignments = new List<UpsertExternalRoleAssignmentsCommand.Assignment>(context.Message.RoleAssignments.Count);
+        foreach (var assignment in context.Message.RoleAssignments)
+        {
+            var roleDefinition = await _persistence.TryGetRoleDefinitionByRoleCode(assignment.RoleCode, context.CancellationToken);
+            if (roleDefinition is null)
+            {
+                Log.RoleWithRoleCodeNotFound(_logger, assignment.RoleCode, context.Message.FromPartyUuid, assignment.ToPartyUuid);
+                _meters.RoleDefinitionsNotFound.Add(1);
+                continue;
+            }
+
+            if (roleDefinition.Source != ExternalRoleSource.CentralCoordinatingRegister)
+            {
+                Log.RoleWithWrongSource(_logger, assignment.RoleCode, context.Message.FromPartyUuid, assignment.ToPartyUuid, roleDefinition.Source, roleDefinition.Identifier);
+                _meters.RoleDefinitionsWrongSource.Add(1);
+                continue;
+            }
+
+            _meters.RoleDefinitionsResolved.Add(1);
+            assignments.Add(new()
+            {
+                Identifier = roleDefinition.Identifier,
+                ToPartyUuid = assignment.ToPartyUuid,
+            });
+        }
+
+        await _sender.Send(
+            new UpsertExternalRoleAssignmentsCommand
+            {
+                FromPartyUuid = context.Message.FromPartyUuid,
+                Source = ExternalRoleSource.CentralCoordinatingRegister,
+                Assignments = assignments,
+                Tracking = context.Message.Tracking,
+            },
+            context.CancellationToken);
+    }
+
+    private static partial class Log
+    {
+        [LoggerMessage(0, LogLevel.Warning, "External role-definition with role code '{RoleCode}' not found. Attempted to add from party '{FromPartyUuid}' to party '{ToPartyUuid}'.", EventName = "RoleWithRoleCodeNotFound")]
+        public static partial void RoleWithRoleCodeNotFound(ILogger logger, string roleCode, Guid fromPartyUuid, Guid toPartyUuid);
+
+        [LoggerMessage(1, LogLevel.Warning, "External role-definition with role code '{RoleCode}' found, but with the wrong source '{Source}' and identifier '{Identifier}'. Attempted to add from party '{FromPartyUuid}' to party '{ToPartyUuid}'.", EventName = "RoleWithWrongSource")]
+        public static partial void RoleWithWrongSource(ILogger logger, string roleCode, Guid fromPartyUuid, Guid toPartyUuid, ExternalRoleSource source, string identifier);
+    }
+
+    /// <summary>
+    /// Consumer definition for <see cref="A2ExternalRoleResolverConsumer"/>.
+    /// </summary>
+    public sealed class Definition
+        : ConsumerDefinition<A2ExternalRoleResolverConsumer>
+    {
+        /// <inheritdoc/>
+        protected override void ConfigureConsumer(
+            IReceiveEndpointConfigurator endpointConfigurator,
+            IConsumerConfigurator<A2ExternalRoleResolverConsumer> consumerConfigurator,
+            IRegistrationContext context)
+        {
+            base.ConfigureConsumer(endpointConfigurator, consumerConfigurator, context);
+        }
+    }
+
+    /// <summary>
+    /// Meters for <see cref="PartyImportBatchConsumer"/>.
+    /// </summary>
+    private sealed class ImportMeters(RegisterTelemetry telemetry)
+        : IServiceMeters<ImportMeters>
+    {
+        /// <summary>
+        /// Gets a counter for the number of parties upserted.
+        /// </summary>
+        public Counter<int> RoleDefinitionsNotFound { get; }
+            = telemetry.CreateCounter<int>("register.party-import.a2.resolve-role.errors", description: "The number of times a role-code was not found.");
+
+        public Counter<int> RoleDefinitionsResolved { get; }
+            = telemetry.CreateCounter<int>("register.party-import.a2.resolve-role.found", description: "The number of times a role-code was resolved.");
+
+        public Counter<int> RoleDefinitionsWrongSource { get; }
+            = telemetry.CreateCounter<int>("register.party-import.a2.resolve-role.wrong-source", description: "The number of times a role-code was found, but with the wrong source.");
+
+        /// <inheritdoc/>
+        public static ImportMeters Create(RegisterTelemetry telemetry)
+            => new ImportMeters(telemetry);
+    }
+}

src/Altinn.Register/src/Altinn.Register/PartyImport/A2/ResolveAndUpsertA2CCRRoleAssignmentsCommand.cs

@@ -0,0 +1,29 @@
+#nullable enable
+
+using Altinn.Authorization.ServiceDefaults.MassTransit;
+using Altinn.Register.Core.PartyImport.A2;
+
+namespace Altinn.Register.PartyImport.A2;
+
+/// <summary>
+/// A command for resolving external role assignments fetched from A2
+/// and upserting them.
+/// </summary>
+public sealed record ResolveAndUpsertA2CCRRoleAssignmentsCommand
+    : CommandBase
+{
+    /// <summary>
+    /// Gets the party UUID that the role assignments are from.
+    /// </summary>
+    public required Guid FromPartyUuid { get; init; }
+
+    /// <summary>
+    /// Gets the role assignments.
+    /// </summary>
+    public required IReadOnlyList<A2PartyExternalRoleAssignment> RoleAssignments { get; init; }
+
+    /// <summary>
+    /// Gets the tracking information for the import.
+    /// </summary>
+    public required UpsertPartyTracking Tracking { get; init; }
+}

src/Altinn.Register/src/Altinn.Register/PartyImport/PartyImportBatchConsumer.cs

@@ -300,7 +300,7 @@ protected override void ConfigureConsumer(
             {
                 options
                     .SetMessageLimit(BATCH_SIZE)
-                    .SetTimeLimit(_isTest ? TimeSpan.FromSeconds(0.1) : TimeSpan.FromSeconds(15))
+                    .SetTimeLimit(_isTest ? TimeSpan.FromSeconds(1) : TimeSpan.FromSeconds(15))
                     .SetTimeLimitStart(BatchTimeLimitStart.FromFirst)
                     .SetConcurrencyLimit(1);
             });

src/Altinn.Register/test/Altinn.Register.TestUtils/BusTestBase.cs

@@ -48,6 +48,7 @@ public abstract class BusTestBase(ITestOutputHelper output)
     protected override ValueTask ConfigureServices(IServiceCollection services)
     {
         services.AddHttpClient<IA2PartyImportService, A2PartyImportService>();
+        services.AddTelemetryListener(new StringWriter(_harnessLogger), includeDetails: true);
         AltinnServiceDefaultsMassTransitTestingExtensions.AddAltinnMassTransitTestHarness(
             services,
             output: new StringWriter(_harnessLogger),
@@ -78,15 +79,19 @@ protected override async ValueTask DisposeAsync()
         {
             _harness.ForceInactive();
             _harness.Cancel();
-            await _harness.OutputTimeline(new StringWriter(_harnessLogger));
-            output.WriteLine(_harnessLogger.ToString());
 
-            await foreach (var consumeException in _harness.Consumed.SelectAsync(static m => m.Exception is not null).Select(static m => m.Exception))
+            var allExceptions = _harness.Consumed.SelectAsync(static m => m.Exception is not null).Select(static m => m.Exception)
+                .Concat(_harness.Sent.SelectAsync(static m => m.Exception is not null).Select(static m => m.Exception))
+                .Concat(_harness.Published.SelectAsync(static m => m.Exception is not null).Select(static m => m.Exception));
+
+            await foreach (var consumeException in allExceptions)
             {
                 output.WriteLine(consumeException.ToString());
             }
         }
 
         await base.DisposeAsync();
+
+        output.WriteLine(_harnessLogger.ToString());
     }
 }

src/Altinn.Register/test/Altinn.Register.TestUtils/MassTransit/TestHarnessConversation.cs

@@ -27,4 +27,10 @@ internal TestHarnessConversation(ITestHarness harness, Guid conversationId)
     /// </summary>
     public AsyncUnwrappedEnumerable<EventBase, IPublishedMessage<EventBase>> Events
         => new(_harness.Published.SelectAsync<EventBase>(m => m.Context.ConversationId == _conversationId), static m => m.Context.Message);
+
+    /// <summary>
+    /// Gets the commands in the conversation.
+    /// </summary>
+    public AsyncUnwrappedEnumerable<CommandBase, ISentMessage<CommandBase>> Commands
+        => new(_harness.Sent.SelectAsync<CommandBase>(m => m.Context.ConversationId == _conversationId), static m => m.Context.Message);
 }

src/Altinn.Register/test/Altinn.Register.TestUtils/MassTransit/TestHarnessExtensions.cs

@@ -1,4 +1,5 @@
-using MassTransit.Testing;
+using Altinn.Authorization.ServiceDefaults.MassTransit;
+using MassTransit.Testing;
 
 namespace Altinn.Register.TestUtils.MassTransit;
 
@@ -15,4 +16,21 @@ public static class TestHarnessExtensions
     /// <returns>A <see cref="TestHarnessConversation"/>.</returns>
     public static TestHarnessConversation Conversation(this ITestHarness harness, Guid guid)
         => new(harness, guid);
+
+    /// <summary>
+    /// Gets a conversation helper by the initial command.
+    /// </summary>
+    /// <typeparam name="TCommand">The command type.</typeparam>
+    /// <param name="harness">The <see cref="ITestHarness"/>.</param>
+    /// <param name="command">The initial command that started the conversation.</param>
+    /// <returns>A <see cref="TestHarnessConversation"/>.</returns>
+    public static async Task<TestHarnessConversation> Conversation<TCommand>(
+        this ITestHarness harness,
+        TCommand command)
+        where TCommand : CommandBase
+    {
+        var consumed = await harness.Consumed.SelectAsync<TCommand>(m => m.Context.CorrelationId == command.CommandId).FirstAsync();
+
+        return harness.Conversation(consumed.Context.ConversationId!.Value);
+    }
 }

src/Altinn.Register/test/Altinn.Register.Tests/PartyImport/A2/A2ExternalRoleResolverConsumerTests.cs

@@ -0,0 +1,96 @@
+#nullable enable
+
+using Altinn.Register.Contracts.ExternalRoles;
+using Altinn.Register.Core.ImportJobs;
+using Altinn.Register.Core.UnitOfWork;
+using Altinn.Register.PartyImport;
+using Altinn.Register.PartyImport.A2;
+using Altinn.Register.TestUtils;
+using Altinn.Register.TestUtils.MassTransit;
+using Altinn.Register.TestUtils.TestData;
+using Xunit.Abstractions;
+
+namespace Altinn.Register.Tests.PartyImport.A2;
+
+public class A2ExternalRoleResolverConsumerTests(ITestOutputHelper output)
+    : BusTestBase(output)
+{
+    protected override bool SeedData => false;
+
+    ////protected override ITestOutputHelper? TestOutputHelper => output;
+
+    [Fact]
+    public async Task ResolveAndUpsertA2CCRRoleAssignmentsCommand_LooksUpRoles_AndUpserts()
+    {
+        await GetRequiredService<IImportJobTracker>().TrackQueueStatus("test", new()
+        {
+            SourceMax = 10,
+            EnqueuedMax = 1,
+        });
+        var (org, person1, person2) = await Setup(async uow =>
+        {
+            var org = await uow.CreateOrg();
+            var person1 = await uow.CreatePerson();
+            var person2 = await uow.CreatePerson();
+
+            var roles = uow.GetPartyExternalRolePersistence();
+            await roles.UpsertExternalRolesFromPartyBySource(
+                commandId: Guid.CreateVersion7(),
+                partyUuid: org.PartyUuid.Value,
+                roleSource: ExternalRoleSource.CentralCoordinatingRegister,
+                assignments: [
+                    new("lede", person2.PartyUuid.Value),
+                ]);
+
+            return (org, person1, person2);
+        });
+
+        var cmd = new ResolveAndUpsertA2CCRRoleAssignmentsCommand 
+        {
+            FromPartyUuid = org.PartyUuid.Value,
+            Tracking = new("test", 1),
+            RoleAssignments = [
+                new() { ToPartyUuid = person1.PartyUuid.Value, RoleCode = "DAGL" },
+                new() { ToPartyUuid = person1.PartyUuid.Value, RoleCode = "MEDL" },
+                new() { ToPartyUuid = person2.PartyUuid.Value, RoleCode = "MEDL" },
+                new() { ToPartyUuid = person2.PartyUuid.Value, RoleCode = "NON_EXISTING" },
+            ],
+        };
+
+        await CommandSender.Send(cmd);
+        var conversation = await Harness.Conversation(cmd);
+
+        var upsertCommand = await conversation.Commands.OfType<UpsertExternalRoleAssignmentsCommand>().FirstOrDefaultAsync();
+        Assert.NotNull(upsertCommand);
+
+        Assert.Equal(ExternalRoleSource.CentralCoordinatingRegister, upsertCommand.Source);
+        Assert.Equal(org.PartyUuid.Value, upsertCommand.FromPartyUuid);
+        Assert.Equal(cmd.Tracking, upsertCommand.Tracking);
+        Assert.Collection(
+            upsertCommand.Assignments,
+            a =>
+            {
+                Assert.Equal(person1.PartyUuid.Value, a.ToPartyUuid);
+                Assert.Equal("dagl", a.Identifier);
+            },
+            a =>
+            {
+                Assert.Equal(person1.PartyUuid.Value, a.ToPartyUuid);
+                Assert.Equal("medl", a.Identifier);
+            },
+            a =>
+            {
+                Assert.Equal(person2.PartyUuid.Value, a.ToPartyUuid);
+                Assert.Equal("medl", a.Identifier);
+            });
+    }
+
+    private async Task<T> Setup<T>(Func<IUnitOfWork, Task<T>> setup)
+    {
+        await using var uow = await GetRequiredService<IUnitOfWorkManager>().CreateAsync(activityName: $"{nameof(PartyImportBatchConsumerTests)}.{nameof(Setup)}");
+        var result = await setup(uow);
+        await uow.CommitAsync();
+
+        return result;
+    }
+}

…artyImport/A2PartyImportConsumerTests.cs …yImport/A2/A2PartyImportConsumerTests.cssrc/Altinn.Register/test/Altinn.Register.Tests/PartyImport/A2PartyImportConsumerTests.cs renamed to src/Altinn.Register/test/Altinn.Register.Tests/PartyImport/A2/A2PartyImportConsumerTests.cs src/Altinn.Register/test/Altinn.Register.Tests/PartyImport/A2PartyImportConsumerTests.cs renamed to src/Altinn.Register/test/Altinn.Register.Tests/PartyImport/A2/A2PartyImportConsumerTests.cs

@@ -16,7 +16,7 @@
 
 using V1Models = Altinn.Platform.Register.Models;
 
-namespace Altinn.Register.Tests.PartyImport;
+namespace Altinn.Register.Tests.PartyImport.A2;
 
 public class A2PartyImportConsumerTests(ITestOutputHelper output)
     : BusTestBase(output)