feat: upsert external role assignments command (#410)

Author: Alxandr

src/Altinn.Register/src/Altinn.Register.Contracts/ExternalRoles/ExternalRoleAssignmentAddedEvent.cs

@@ -0,0 +1,28 @@
+using Altinn.Authorization.ServiceDefaults.MassTransit;
+using Altinn.Register.Contracts.Parties;
+using MassTransit;
+
+namespace Altinn.Register.Contracts.ExternalRoles;
+
+/// <summary>
+/// An event that is published when an external role assignment is added.
+/// </summary>
+[MessageUrn("event:altinn-register:external-role-assignment-added")]
+public sealed record ExternalRoleAssignmentAddedEvent
+    : EventBase
+{
+    /// <summary>
+    /// Gets the role that was assigned.
+    /// </summary>
+    public required ExternalRoleReference Role { get; init; }
+
+    /// <summary>
+    /// Gets the party that the role was assigned from.
+    /// </summary>
+    public required PartyReference From { get; init; }
+
+    /// <summary>
+    /// Gets the party that the role was assigned to.
+    /// </summary>
+    public required PartyReference To { get; init; }
+}

src/Altinn.Register/src/Altinn.Register.Contracts/ExternalRoles/ExternalRoleAssignmentRemovedEvent.cs

@@ -0,0 +1,28 @@
+using Altinn.Authorization.ServiceDefaults.MassTransit;
+using Altinn.Register.Contracts.Parties;
+using MassTransit;
+
+namespace Altinn.Register.Contracts.ExternalRoles;
+
+/// <summary>
+/// An event that is published when an external role assignment is removed.
+/// </summary>
+[MessageUrn("event:altinn-register:external-role-assignment-removed")]
+public sealed record ExternalRoleAssignmentRemovedEvent
+    : EventBase
+{
+    /// <summary>
+    /// Gets the role that was assigned.
+    /// </summary>
+    public required ExternalRoleReference Role { get; init; }
+
+    /// <summary>
+    /// Gets the party that the role was assigned from.
+    /// </summary>
+    public required PartyReference From { get; init; }
+
+    /// <summary>
+    /// Gets the party that the role was assigned to.
+    /// </summary>
+    public required PartyReference To { get; init; }
+}

src/Altinn.Register/src/Altinn.Register.Contracts/ExternalRoles/ExternalRoleReference.cs

@@ -0,0 +1,31 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Altinn.Register.Contracts.ExternalRoles;
+
+/// <summary>
+/// Represents a reference to an external role.
+/// </summary>
+public sealed record ExternalRoleReference
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ExternalRoleReference"/> class.
+    /// </summary>
+    /// <param name="source">The source of the external role.</param>
+    /// <param name="identifier">The identifier of the external role.</param>
+    [SetsRequiredMembers]
+    public ExternalRoleReference(ExternalRoleSource source, string identifier)
+    {
+        Source = source;
+        Identifier = identifier;
+    }
+
+    /// <summary>
+    /// Gets the source of the external role.
+    /// </summary>
+    public required ExternalRoleSource Source { get; init; }
+
+    /// <summary>
+    /// Gets the identifier of the external role.
+    /// </summary>
+    public required string Identifier { get; init; }
+}

src/Altinn.Register/src/Altinn.Register.Contracts/Parties/PartyUpdatedEvent.cs

@@ -1,4 +1,4 @@
-using Altinn.Authorization.ServiceDefaults.MassTransit;
+using Altinn.Authorization.ServiceDefaults.MassTransit;
 using MassTransit;
 
 namespace Altinn.Register.Contracts.Parties;

src/Altinn.Register/src/Altinn.Register.Core/Parties/IPartyExternalRolePersistence.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Altinn.Register.Contracts.ExternalRoles;
 using Altinn.Register.Core.Parties.Records;
+using Altinn.Register.Core.Utils;
 
 namespace Altinn.Register.Core.Parties;
 
@@ -48,7 +49,7 @@ public IAsyncEnumerable<PartyExternalRoleAssignmentRecord> GetExternalRoleAssign
     /// <param name="assignments">The new role-assignments.</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/>.</param>
     /// <returns></returns>
-    public IAsyncEnumerable<ExternalRoleAssignmentEvent> UpsertExternalRolesFromPartyBySource(
+    public IAsyncSideEffectEnumerable<ExternalRoleAssignmentEvent> UpsertExternalRolesFromPartyBySource(
         Guid commandId,
         Guid partyUuid,
         ExternalRoleSource roleSource,

src/Altinn.Register/src/Altinn.Register.Core/Utils/AsyncEnumerableExtensions.cs

@@ -1,5 +1,6 @@
 #nullable enable
 
+using System.Runtime.CompilerServices;
 using CommunityToolkit.Diagnostics;
 
 namespace Altinn.Register.Core.Utils;
@@ -28,7 +29,26 @@ public static IAsyncEnumerable<T> WrapExceptions<T>(
         return new WrapExceptionsAsyncEnumerable<T>(source, wrap, cancellationToken);
     }
 
-    private sealed class WrapExceptionsAsyncEnumerable<T>
+    /// <summary>
+    /// Wraps exceptions thrown by the source enumerable in a new exception.
+    /// </summary>
+    /// <typeparam name="T">The item type.</typeparam>
+    /// <param name="source">The source enumerable.</param>
+    /// <param name="wrap">The exception wrapper.</param>
+    /// <param name="cancellationToken">Cancellation token (used to filter out <see cref="OperationCanceledException"/>s).</param>
+    /// <returns>The source enumerable, but with any exceptions optionally wrapped by <paramref name="wrap"/>.</returns>
+    public static IAsyncSideEffectEnumerable<T> WrapExceptions<T>(
+        this IAsyncSideEffectEnumerable<T> source,
+        Func<Exception, Exception?> wrap,
+        CancellationToken cancellationToken)
+    {
+        Guard.IsNotNull(source);
+        Guard.IsNotNull(wrap);
+
+        return new WrapExceptionsAsyncSideEffectEnumerable<T>(source, wrap, cancellationToken);
+    }
+
+    private class WrapExceptionsAsyncEnumerable<T>
         : IAsyncEnumerable<T>
     {
         private readonly IAsyncEnumerable<T> _source;
@@ -45,19 +65,26 @@ public WrapExceptionsAsyncEnumerable(
             _cancellationToken = cancellationToken;
         }
 
+        protected Exception? WrapException(Exception source)
+            => _wrap(source);
+
+        protected bool ShouldRethrowAsIs(Exception exception)
+            => exception is OperationCanceledException ex && ex.CancellationToken == _cancellationToken;
+
         public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
         {
             try
             {
                 return new Enumerator(_source.GetAsyncEnumerator(cancellationToken), _wrap, _cancellationToken);
             }
-            catch (OperationCanceledException ex) when (ex.CancellationToken == _cancellationToken)
-            {
-                throw;
-            }
             catch (Exception ex)
             {
-                if (_wrap(ex) is Exception wrapped)
+                if (ShouldRethrowAsIs(ex))
+                {
+                    throw;
+                }
+
+                if (WrapException(ex) is Exception wrapped)
                 {
                     throw wrapped;
                 }
@@ -83,6 +110,12 @@ public Enumerator(
                 _cancellationToken = cancellationToken;
             }
 
+            private Exception? WrapException(Exception source)
+                => _wrap(source);
+
+            private bool ShouldRethrowAsIs(Exception exception)
+                => exception is OperationCanceledException ex && ex.CancellationToken == _cancellationToken;
+
             public T Current => _source.Current;
 
             public async ValueTask DisposeAsync()
@@ -91,13 +124,14 @@ public async ValueTask DisposeAsync()
                 {
                     await _source.DisposeAsync();
                 }
-                catch (OperationCanceledException ex) when (ex.CancellationToken == _cancellationToken)
-                {
-                    throw;
-                }
                 catch (Exception ex)
                 {
-                    if (_wrap(ex) is Exception wrapped)
+                    if (ShouldRethrowAsIs(ex))
+                    {
+                        throw;
+                    }
+
+                    if (WrapException(ex) is Exception wrapped)
                     {
                         throw wrapped;
                     }
@@ -112,13 +146,14 @@ public async ValueTask<bool> MoveNextAsync()
                 {
                     return await _source.MoveNextAsync();
                 }
-                catch (OperationCanceledException ex) when (ex.CancellationToken == _cancellationToken)
-                {
-                    throw;
-                }
                 catch (Exception ex)
                 {
-                    if (_wrap(ex) is Exception wrapped)
+                    if (ShouldRethrowAsIs(ex))
+                    {
+                        throw;
+                    }
+
+                    if (WrapException(ex) is Exception wrapped)
                     {
                         throw wrapped;
                     }
@@ -128,4 +163,45 @@ public async ValueTask<bool> MoveNextAsync()
             }
         }
     }
+
+    private sealed class WrapExceptionsAsyncSideEffectEnumerable<T>
+        : WrapExceptionsAsyncEnumerable<T>
+        , IAsyncSideEffectEnumerable<T>
+    {
+        private readonly IAsyncSideEffectEnumerable<T> _source;
+
+        public WrapExceptionsAsyncSideEffectEnumerable(
+            IAsyncSideEffectEnumerable<T> source,
+            Func<Exception, Exception?> wrap,
+            CancellationToken cancellationToken)
+            : base(source, wrap, cancellationToken)
+        {
+            _source = source;
+        }
+
+        public TaskAwaiter GetAwaiter()
+            => Run().GetAwaiter();
+
+        private async Task Run()
+        {
+            try
+            {
+                await _source;
+            }
+            catch (Exception ex)
+            {
+                if (ShouldRethrowAsIs(ex))
+                {
+                    throw;
+                }
+
+                if (WrapException(ex) is Exception wrapped)
+                {
+                    throw wrapped;
+                }
+
+                throw;
+            }
+        }
+    }
 }

src/Altinn.Register/src/Altinn.Register.Core/Utils/IAsyncSideEffectEnumerable.cs

@@ -0,0 +1,17 @@
+#nullable enable
+
+using System.Runtime.CompilerServices;
+
+namespace Altinn.Register.Core.Utils;
+
+/// <summary>
+/// Represents an async enumerable that can be executed just for its side effects.
+/// </summary>
+/// <typeparam name="T">The item type.</typeparam>
+public interface IAsyncSideEffectEnumerable<out T>
+    : IAsyncEnumerable<T>
+{
+    /// <summary>Gets an awaiter used to await this <see cref="IAsyncSideEffectEnumerable{T}"/>.</summary>
+    /// <returns>An awaiter instance.</returns>
+    TaskAwaiter GetAwaiter();
+}

src/Altinn.Register/src/Altinn.Register.Persistence/Altinn.Register.Persistence.csproj

@@ -23,4 +23,8 @@
     <EmbeddedResource Include="TestData/**/*.sql" />
   </ItemGroup>
 
+  <ItemGroup>
+		<InternalsVisibleTo Include="Altinn.Register.TestUtils"/>
+	</ItemGroup>
+
 </Project>