feat: Restore dialog action

docs/schema/V1/swagger.verified.json

@@ -6379,6 +6379,72 @@
         ]
       }
     },
+    "/api/v1/serviceowner/dialogs/{dialogId}/actions/restore": {
+      "post": {
+        "description": "Restore a dialog. For more information see the documentation (link TBD). ",
+        "operationId": "V1ServiceOwnerDialogsRestore_RestoreDialog",
+        "parameters": [
+          {
+            "in": "path",
+            "name": "dialogId",
+            "required": true,
+            "schema": {
+              "format": "guid",
+              "type": "string"
+            }
+          },
+          {
+            "in": "header",
+            "name": "if-Match",
+            "schema": {
+              "format": "guid",
+              "nullable": true,
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "The dialog aggregate was restored successfully."
+          },
+          "401": {
+            "description": "Unauthorized"
+          },
+          "403": {
+            "description": "Forbidden"
+          },
+          "404": {
+            "content": {
+              "application/problem\u002Bjson": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            },
+            "description": "The given dialog ID was not found or is already deleted."
+          },
+          "412": {
+            "content": {
+              "application/problem\u002Bjson": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            },
+            "description": "The supplied If-Match header did not match the current Revision value for the dialog. The request was not applied."
+          }
+        },
+        "security": [
+          {
+            "JWTBearerAuth": []
+          }
+        ],
+        "summary": "Restore a dialog",
+        "tags": [
+          "Serviceowner"
+        ]
+      }
+    },
     "/api/v1/serviceowner/dialogs/{dialogId}/actions/should-send-notification": {
       "get": {
         "description": "Used by Altinn Notification only. Takes a dialogId and returns a boolean value based on conditions used to determine if a notification is to be sent.",
@@ -7067,4 +7133,4 @@
       "url": "https://altinn-dev-api.azure-api.net/dialogporten"
     }
   ]
-}
+}

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/Common/Events/AltinnForwarders/DialogEventToAltinnForwarder.cs

@@ -11,6 +11,7 @@ internal sealed class DialogEventToAltinnForwarder : DomainEventToAltinnForwarde
     INotificationHandler<DialogCreatedDomainEvent>,
     INotificationHandler<DialogUpdatedDomainEvent>,
     INotificationHandler<DialogDeletedDomainEvent>,
+    INotificationHandler<DialogRestoredDomainEvent>,
     INotificationHandler<DialogSeenDomainEvent>
 {
     public DialogEventToAltinnForwarder(ICloudEventBus cloudEventBus, IOptions<ApplicationSettings> settings)
@@ -108,6 +109,29 @@ public async Task Handle(DialogDeletedDomainEvent domainEvent, CancellationToken
         await CloudEventBus.Publish(cloudEvent, cancellationToken);
     }
 
+    public async Task Handle(DialogRestoredDomainEvent domainEvent, CancellationToken cancellationToken)
+    {
+        if (domainEvent.ShouldNotBeSentToAltinnEvents())
+        {
+            return;
+        }
+
+        var cloudEvent = new CloudEvent
+        {
+            Id = domainEvent.EventId,
+            Type = CloudEventTypes.Get(nameof(DialogRestoredDomainEvent)),
+            Time = domainEvent.OccurredAt,
+            Resource = domainEvent.ServiceResource,
+            ResourceInstance = domainEvent.DialogId.ToString(),
+            Subject = domainEvent.Party,
+            Source = $"{SourceBaseUrl()}{domainEvent.DialogId}",
+            Data = GetCloudEventData(domainEvent)
+        };
+
+        await CloudEventBus.Publish(cloudEvent, cancellationToken);
+
+    }
+
     private static Dictionary<string, object>? GetCloudEventData(IProcessEvent domainEvent)
     {
         var data = new Dictionary<string, object>();
@@ -123,4 +147,5 @@ public async Task Handle(DialogDeletedDomainEvent domainEvent, CancellationToken
 
         return data.Count == 0 ? null : data;
     }
+
 }

src/Digdir.Domain.Dialogporten.Application/Features/V1/Common/Events/CloudEventTypes.cs

@@ -8,6 +8,7 @@ internal static class CloudEventTypes
     internal static string Get(string eventName) => eventName switch
     {
         // Dialog
+        nameof(DialogRestoredDomainEvent) => "dialogporten.dialog.restored.v1",
         nameof(DialogCreatedDomainEvent) => "dialogporten.dialog.created.v1",
         nameof(DialogUpdatedDomainEvent) => "dialogporten.dialog.updated.v1",
         nameof(DialogDeletedDomainEvent) => "dialogporten.dialog.deleted.v1",

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

@@ -125,7 +125,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.DomainEvents;
+
+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,
+    // But we only have use cases for some of them. 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/Common/Constants.cs

@@ -13,6 +13,7 @@ internal static class SwaggerSummary
         internal const string ReturnedResult = "Successfully returned the dialog {0}.";
         internal const string Created = "The UUID of the created dialog {0}. A relative URL to the newly created activity is set in the \"Location\" header.";
         internal const string Deleted = "The dialog {0} was deleted successfully.";
+        internal const string Restored = "The dialog {0} was restored successfully.";
         internal const string Updated = "The dialog {0} was updated successfully.";
         internal const string ValidationError = "Validation error occurred. See problem details for a list of errors.";
         internal const string DomainError = "Domain error occurred. See problem details for a list of errors.";