feat: Restore dialog action

src/Digdir.Domain.Dialogporten.Application/Externals/IUnitOfWork.cs

@@ -7,7 +7,6 @@ namespace Digdir.Domain.Dialogporten.Application.Externals;
 
 public interface IUnitOfWork
 {
-    IUnitOfWork WithoutAggregateSideEffects();
     Task<SaveChangesResult> SaveChangesAsync(CancellationToken cancellationToken = default);
 
     IUnitOfWork EnableConcurrencyCheck<TEntity>(
@@ -16,6 +15,11 @@ IUnitOfWork EnableConcurrencyCheck<TEntity>(
         where TEntity : class, IVersionableEntity;
 
     Task BeginTransactionAsync(CancellationToken cancellationToken = default);
+
+    IUnitOfWork DisableAggregateFilter();
+    IUnitOfWork DisableVersionableFilter();
+    IUnitOfWork DisableUpdatableFilter();
+    IUnitOfWork DisableSoftDeletableFilter();
 }
 
 [GenerateOneOf]

src/Digdir.Domain.Dialogporten.Application/Features/V1/EndUser/Dialogs/Queries/Get/GetDialogQuery.cs

@@ -126,7 +126,8 @@ public async Task<GetDialogResult> Handle(GetDialogQuery request, CancellationTo
             currentUserInformation.Name);
 
         var saveResult = await _unitOfWork
-            .WithoutAggregateSideEffects()
+            .DisableUpdatableFilter()
+            .DisableVersionableFilter()
             .SaveChangesAsync(cancellationToken);
 
         saveResult.Switch(

src/Digdir.Domain.Dialogporten.Application/Features/V1/ServiceOwner/Dialogs/Commands/Restore/RestoreDialogCommand.cs

@@ -0,0 +1,71 @@
+using System.Diagnostics;
+using Digdir.Domain.Dialogporten.Application.Common;
+using Digdir.Domain.Dialogporten.Application.Common.Extensions;
+using Digdir.Domain.Dialogporten.Application.Common.ReturnTypes;
+using Digdir.Domain.Dialogporten.Application.Externals;
+using Digdir.Domain.Dialogporten.Domain.Dialogs.Entities;
+using Digdir.Library.Entity.Abstractions.Features.SoftDeletable;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using OneOf;
+
+namespace Digdir.Domain.Dialogporten.Application.Features.V1.ServiceOwner.Dialogs.Commands.Restore;
+
+public sealed class RestoreDialogCommand : IRequest<RestoreDialogResult>
+{
+    public Guid DialogId { get; set; }
+    public Guid? IfMatchDialogRevision { get; set; }
+}
+
+[GenerateOneOf]
+public sealed partial class RestoreDialogResult : OneOfBase<RestoreDialogSuccess, EntityNotFound, ConcurrencyError>;
+
+public sealed record RestoreDialogSuccess(Guid Revision);
+
+internal sealed class RestoreDialogCommandHandler : IRequestHandler<RestoreDialogCommand, RestoreDialogResult>
+{
+    private readonly IDialogDbContext _db;
+    private readonly IUnitOfWork _unitOfWork;
+    private readonly IUserResourceRegistry _userResourceRegistry;
+
+    public RestoreDialogCommandHandler(IDialogDbContext db, IUnitOfWork unitOfWork, IUserResourceRegistry userResourceRegistry)
+    {
+        _db = db ?? throw new ArgumentNullException(nameof(db));
+        _unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
+        _userResourceRegistry = userResourceRegistry ?? throw new ArgumentNullException(nameof(userResourceRegistry));
+    }
+
+    public async Task<RestoreDialogResult> Handle(RestoreDialogCommand request, CancellationToken cancellationToken)
+    {
+        var resourceIds = await _userResourceRegistry.GetCurrentUserResourceIds(cancellationToken);
+
+        var dialog = await _db.Dialogs
+            .WhereIf(!_userResourceRegistry.IsCurrentUserServiceOwnerAdmin(), x => resourceIds.Contains(x.ServiceResource))
+            .IgnoreQueryFilters()
+            .FirstOrDefaultAsync(x => x.Id == request.DialogId, cancellationToken);
+
+        if (dialog is null)
+        {
+            return new EntityNotFound<DialogEntity>(request.DialogId);
+        }
+
+        if (!dialog.Deleted)
+        {
+            return new RestoreDialogSuccess(dialog.Revision);
+        }
+
+        dialog.Restore();
+
+        var saveResult = await _unitOfWork
+            .DisableUpdatableFilter()
+            .DisableSoftDeletableFilter()
+            .EnableConcurrencyCheck(dialog, request.IfMatchDialogRevision)
+            .SaveChangesAsync(cancellationToken);
+
+        return saveResult.Match<RestoreDialogResult>(
+            success => new RestoreDialogSuccess(dialog.Revision),
+            domainError => throw new UnreachableException("Should never get a domain error when restoring a dialog"),
+            concurrencyError => concurrencyError
+        );
+    }
+}

src/Digdir.Domain.Dialogporten.Application/Features/V1/ServiceOwner/Dialogs/Queries/Get/GetDialogQuery.cs

@@ -115,7 +115,8 @@ public async Task<GetDialogResult> Handle(GetDialogQuery request, CancellationTo
                 currentUserInformation.Name);
 
             var saveResult = await _unitOfWork
-                .WithoutAggregateSideEffects()
+                .DisableUpdatableFilter()
+                .DisableVersionableFilter()
                 .SaveChangesAsync(cancellationToken);
 
             saveResult.Switch(

src/Digdir.Domain.Dialogporten.Domain/Dialogs/Entities/DialogEntity.cs

@@ -19,7 +19,8 @@ public sealed class DialogEntity :
     ISoftDeletableEntity,
     IVersionableEntity,
     IAggregateChangedHandler,
-    IEventPublisher
+    IEventPublisher,
+    IAggregateRestoredHandler
 {
     public Guid Id { get; set; }
     public Guid Revision { get; set; }
@@ -84,6 +85,9 @@ public void OnUpdate(AggregateNode self, DateTimeOffset utcNow) =>
     public void OnDelete(AggregateNode self, DateTimeOffset utcNow)
         => _domainEvents.Add(new DialogDeletedDomainEvent(Id, ServiceResource, Party, Process, PrecedingProcess));
 
+    public void OnRestore(AggregateNode self, DateTimeOffset utcNow) =>
+        _domainEvents.Add(new DialogRestoredDomainEvent(Id, ServiceResource, Party, Process, PrecedingProcess));
+
     public void UpdateSeenAt(string endUserId, DialogUserType.Values userTypeId, string? endUserName)
     {
         var lastSeenAt = SeenLog

src/Digdir.Domain.Dialogporten.Domain/Dialogs/Events/DialogRestoredDomainEvent.cs

@@ -0,0 +1,10 @@
+using Digdir.Domain.Dialogporten.Domain.Common;
+
+namespace Digdir.Domain.Dialogporten.Domain.Dialogs.Events;
+
+public sealed record DialogRestoredDomainEvent(
+    Guid DialogId,
+    string ServiceResource,
+    string Party,
+    string? Process,
+    string? PrecedingProcess) : DomainEvent, IProcessEvent;

src/Digdir.Domain.Dialogporten.Infrastructure/Persistence/DialogDbContext.cs

@@ -62,8 +62,9 @@ internal bool TrySetOriginalRevision<TEntity>(
         }
 
         var prop = Entry(entity).Property(x => x.Revision);
+        var isModified = prop.IsModified;
         prop.OriginalValue = revision.Value;
-        prop.IsModified = false;
+        prop.IsModified = isModified;
         return true;
     }
 

src/Digdir.Domain.Dialogporten.Infrastructure/UnitOfWork.cs

@@ -25,10 +25,10 @@ internal sealed class UnitOfWork : IUnitOfWork, IAsyncDisposable, IDisposable
     private readonly DialogDbContext _dialogDbContext;
     private readonly ITransactionTime _transactionTime;
     private readonly IDomainContext _domainContext;
+    private readonly SaveChangesOptions _saveChangesOptions = new();
 
     private IDbContextTransaction? _transaction;
 
-    private bool _aggregateSideEffects = true;
     private bool _enableConcurrencyCheck;
 
     public UnitOfWork(DialogDbContext dialogDbContext, ITransactionTime transactionTime, IDomainContext domainContext)
@@ -51,14 +51,32 @@ public IUnitOfWork EnableConcurrencyCheck<TEntity>(
         return this;
     }
 
-    public IUnitOfWork WithoutAggregateSideEffects()
+    public async Task BeginTransactionAsync(CancellationToken cancellationToken = default)
+        => _transaction ??= await _dialogDbContext.Database.BeginTransactionAsync(cancellationToken);
+
+    public IUnitOfWork DisableAggregateFilter()
     {
-        _aggregateSideEffects = false;
+        _saveChangesOptions.EnableAggregateFilter = false;
         return this;
     }
 
-    public async Task BeginTransactionAsync(CancellationToken cancellationToken = default)
-        => _transaction ??= await _dialogDbContext.Database.BeginTransactionAsync(cancellationToken);
+    public IUnitOfWork DisableVersionableFilter()
+    {
+        _saveChangesOptions.EnableVersionableFilter = false;
+        return this;
+    }
+
+    public IUnitOfWork DisableUpdatableFilter()
+    {
+        _saveChangesOptions.EnableUpdatableFilter = false;
+        return this;
+    }
+
+    public IUnitOfWork DisableSoftDeletableFilter()
+    {
+        _saveChangesOptions.EnableSoftDeletableFilter = false;
+        return this;
+    }
 
     public async Task<SaveChangesResult> SaveChangesAsync(CancellationToken cancellationToken = default)
     {
@@ -92,12 +110,10 @@ private async Task<SaveChangesResult> SaveChangesAsync_Internal(CancellationToke
             return new Success();
         }
 
-        _dialogDbContext.ChangeTracker.HandleAuditableEntities(_transactionTime.Value);
-
-        if (_aggregateSideEffects)
-        {
-            await _dialogDbContext.ChangeTracker.HandleAggregateEntities(_transactionTime.Value, cancellationToken);
-        }
+        await _dialogDbContext.ChangeTracker.HandleAuditableEntities(
+            _transactionTime.Value,
+            _saveChangesOptions,
+            cancellationToken);
 
         if (!_enableConcurrencyCheck)
         {
@@ -185,4 +201,20 @@ public void Dispose()
         _transaction?.Dispose();
         _transaction = null;
     }
+
+    // Although the entity framework supports all the options,
+    // enabling some of them ia an incredibly bad idea. Therefore,
+    // only some of them have setters until the day we actually
+    // have a use case for them.
+    private sealed class SaveChangesOptions : IEntityOptions
+    {
+        public bool EnableSoftDeletableFilter { get; set; } = true;
+        public bool EnableImmutableFilter { get; } = true;
+        public bool EnableVersionableFilter { get; set; } = true;
+        public bool EnableUpdatableFilter { get; set; } = true;
+        public bool EnableCreatableFilter { get; } = true;
+        public bool EnableLookupFilter { get; } = true;
+        public bool EnableIdentifiableFilter { get; } = true;
+        public bool EnableAggregateFilter { get; set; } = true;
+    }
 }

src/Digdir.Domain.Dialogporten.WebApi/Endpoints/V1/ServiceOwner/Dialogs/Restore/RestoreDialogEndpoint.cs

@@ -0,0 +1,59 @@
+using Digdir.Domain.Dialogporten.Application.Features.V1.ServiceOwner.Dialogs.Commands.Restore;
+using Digdir.Domain.Dialogporten.WebApi.Common;
+using Digdir.Domain.Dialogporten.WebApi.Common.Authorization;
+using Digdir.Domain.Dialogporten.WebApi.Common.Extensions;
+using Digdir.Domain.Dialogporten.WebApi.Endpoints.V1.Common.Extensions;
+using FastEndpoints;
+using MediatR;
+
+namespace Digdir.Domain.Dialogporten.WebApi.Endpoints.V1.ServiceOwner.Dialogs.Restore;
+
+public sealed class RestoreDialogEndpoint : Endpoint<RestoreDialogRequest>
+{
+    private readonly ISender _sender;
+
+    public RestoreDialogEndpoint(ISender sender)
+    {
+        _sender = sender;
+    }
+
+    public override void Configure()
+    {
+        Post("dialogs/{dialogId}/actions/restore");
+        Policies(AuthorizationPolicy.ServiceProvider);
+        Group<ServiceOwnerGroup>();
+
+        Description(b => b
+            .Accepts<RestoreDialogRequest>()
+            .ProducesOneOf(
+                StatusCodes.Status204NoContent,
+                StatusCodes.Status404NotFound,
+                StatusCodes.Status412PreconditionFailed));
+    }
+
+    public override async Task HandleAsync(RestoreDialogRequest req, CancellationToken ct)
+    {
+        var command = new RestoreDialogCommand
+        {
+            DialogId = req.DialogId,
+            IfMatchDialogRevision = req.IfMatchDialogRevision
+        };
+        var result = await _sender.Send(command, ct);
+        await result.Match(
+            success =>
+            {
+                HttpContext.Response.Headers.Append(Constants.ETag, success.Revision.ToString());
+                return SendNoContentAsync(ct);
+            },
+            notFound => this.NotFoundAsync(notFound, ct),
+            concurrencyError => this.PreconditionFailed(ct));
+    }
+}
+
+public sealed class RestoreDialogRequest
+{
+    public Guid DialogId { get; init; }
+
+    [FromHeader(headerName: Constants.IfMatch, isRequired: false, removeFromSchema: true)]
+    public Guid? IfMatchDialogRevision { get; init; }
+}

src/Digdir.Domain.Dialogporten.WebApi/Endpoints/V1/ServiceOwner/Dialogs/Restore/RestoreDialogEndpointSummary.cs

@@ -0,0 +1,8 @@
+using FastEndpoints;
+
+namespace Digdir.Domain.Dialogporten.WebApi.Endpoints.V1.ServiceOwner.Dialogs.Restore;
+
+public class RestoreDialogEndpointSummary : Summary<RestoreDialogEndpoint>
+{
+
+}

src/Digdir.Library.Entity.EntityFrameworkCore/EntityLibraryEfCoreExtensions.cs

@@ -26,13 +26,18 @@ namespace Digdir.Library.Entity.EntityFrameworkCore;
 public static class EntityLibraryEfCoreExtensions
 {
     /// <summary>
-    /// Updates the properties and sets the correct <see cref="EntityState"/> on the <see cref="ChangeTracker"/> for the entities implementing the following abstractions in context of aggregates.
+    /// Updates the properties and sets the correct <see cref="EntityState"/> on the <see cref="ChangeTracker"/> for the entities implementing the following abstractions.
     /// <list type="bullet">
     ///     <item><see cref="IAggregateCreatedHandler"/></item>
     ///     <item><see cref="IAggregateUpdatedHandler"/></item>
     ///     <item><see cref="IAggregateDeletedHandler"/></item>
     ///     <item><see cref="IAggregateRestoredHandler"/></item>
+    ///     <item><see cref="IIdentifiableEntity"/></item>
+    ///     <item><see cref="ICreatableEntity"/></item>
     ///     <item><see cref="IUpdateableEntity"/></item>
+    ///     <item><see cref="ISoftDeletableEntity"/></item>
+    ///     <item><see cref="IImmutableEntity"/></item>
+    ///     <item><see cref="ILookupEntity"/></item>
     ///     <item><see cref="IVersionableEntity"/></item>
     /// </list>
     /// </summary>
@@ -41,38 +46,26 @@ public static class EntityLibraryEfCoreExtensions
     /// </remarks>
     /// <param name="changeTracker">The change tracker.</param>
     /// <param name="utcNow">The time in UTC in which the changes took place.</param>
+    /// <param name="options">Optional settings to configure entity handling behavior.</param>
     /// <param name="cancellationToken">A token for requesting cancellation of the operation.</param>
     /// <returns>The same <see cref="ChangeTracker"/> instance so that multiple calls can be chained.</returns>
-    public static Task<ChangeTracker> HandleAggregateEntities(
+    public static Task<ChangeTracker> HandleAuditableEntities(
         this ChangeTracker changeTracker,
         DateTimeOffset utcNow,
+        IEntityOptions options,
         CancellationToken cancellationToken = default)
-        => AggregateExtensions.HandleAggregateEntities(changeTracker, utcNow, cancellationToken);
+    {
+        changeTracker.DoIf(options.EnableLookupFilter, x => x.HandleLookupEntities())
+            .DoIf(options.EnableIdentifiableFilter, x => x.HandleIdentifiableEntities())
+            .DoIf(options.EnableImmutableFilter, x => x.HandleImmutableEntities())
+            .DoIf(options.EnableCreatableFilter, x => x.HandleCreatableEntities(utcNow))
+            .DoIf(options.EnableUpdatableFilter, x => x.HandleUpdatableEntities(utcNow))
+            .DoIf(options.EnableSoftDeletableFilter, x => x.HandleSoftDeletableEntities(utcNow));
+        return changeTracker.HandleAggregateEntities(utcNow, options, cancellationToken);
+    }
 
-    /// <summary>
-    /// Updates the properties and sets the correct <see cref="EntityState"/> on the <see cref="ChangeTracker"/> for the entities implementing the following abstractions.
-    /// <list type="bullet">
-    ///     <item><see cref="IIdentifiableEntity"/></item>
-    ///     <item><see cref="ICreatableEntity"/></item>
-    ///     <item><see cref="IUpdateableEntity"/></item>
-    ///     <item><see cref="ISoftDeletableEntity"/></item>
-    ///     <item><see cref="IImmutableEntity"/></item>
-    ///     <item><see cref="ILookupEntity"/></item>
-    /// </list>
-    /// </summary>
-    /// <remarks>
-    /// Should be called right before saving the entities.
-    /// </remarks>
-    /// <param name="changeTracker">The change tracker.</param>
-    /// <param name="utcNow">The time in UTC in which the changes took place.</param>
-    /// <returns>The same <see cref="ChangeTracker"/> instance so that multiple calls can be chained.</returns>
-    public static ChangeTracker HandleAuditableEntities(this ChangeTracker changeTracker, DateTimeOffset utcNow)
-        => changeTracker.HandleLookupEntities()
-            .HandleIdentifiableEntities()
-            .HandleImmutableEntities()
-            .HandleCreatableEntities(utcNow)
-            .HandleUpdatableEntities(utcNow)
-            .HandleSoftDeletableEntities(utcNow);
+    private static ChangeTracker DoIf(this ChangeTracker changeTracker, bool predicate, Func<ChangeTracker, ChangeTracker> action)
+        => predicate ? action(changeTracker) : changeTracker;
 
     /// <summary>
     /// Configures the shape of, and how the entities implementing the following abstractions are mapped to the database.