feat: Update all Summary 2.0 components that has a reference to an updated component id

backend/src/Designer/Controllers/AppDevelopmentController.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Text.Json.Nodes;
 using System.Threading;
 using System.Threading.Tasks;
@@ -123,8 +124,17 @@ public async Task<ActionResult> SaveFormLayout(string org, string app, [FromQuer
 
                 if (formLayoutPayload.ComponentIdsChange is not null && !string.IsNullOrEmpty(layoutSetName))
                 {
-                    foreach (var componentIdChange in formLayoutPayload.ComponentIdsChange)
+                    foreach (var componentIdChange in formLayoutPayload.ComponentIdsChange.Where((componentIdChange) => componentIdChange.OldComponentId != componentIdChange.NewComponentId))
                     {
+                        if (componentIdChange.NewComponentId == null)
+                        {
+                            await _mediator.Publish(new ComponentDeletedEvent
+                            {
+                                ComponentId = componentIdChange.OldComponentId,
+                                LayoutSetName = layoutSetName,
+                                EditingContext = editingContext
+                            }, cancellationToken);
+                        }
                         await _mediator.Publish(new ComponentIdChangedEvent
                         {
                             OldComponentId = componentIdChange.OldComponentId,
@@ -159,16 +169,26 @@ await _mediator.Publish(new LayoutPageAddedEvent
         /// <param name="app">Application identifier which is unique within an organisation.</param>
         /// <param name="layoutSetName">The name of the layout set the specific layout belongs to</param>
         /// <param name="layoutName">The form layout to be deleted</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
         /// <returns>A success message if the save was successful</returns>
         [HttpDelete]
         [Route("form-layout/{layoutName}")]
-        public ActionResult DeleteFormLayout(string org, string app, [FromQuery] string layoutSetName, [FromRoute] string layoutName)
+        public async Task<ActionResult> DeleteFormLayout(string org, string app, [FromQuery] string layoutSetName, [FromRoute] string layoutName, CancellationToken cancellationToken)
         {
             try
             {
                 string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
                 var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
+
+                await _mediator.Publish(new LayoutPageDeletedEvent
+                {
+                    EditingContext = editingContext,
+                    LayoutSetName = layoutSetName,
+                    LayoutName = layoutName,
+                }, cancellationToken);
+
                 _appDevelopmentService.DeleteFormLayout(editingContext, layoutSetName, layoutName);
+
                 return Ok();
             }
             catch (FileNotFoundException exception)
@@ -185,16 +205,24 @@ public ActionResult DeleteFormLayout(string org, string app, [FromQuery] string
         /// <param name="app">Application identifier which is unique within an organisation.</param>
         /// <param name="layoutSetName">Name of the layout set the specific layout belongs to</param>
         /// <param name="layoutName">The current name of the form layout</param>
+        /// <param name="cancellationToken">An <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
         /// <returns>A success message if the save was successful</returns>
         [HttpPost]
         [Route("form-layout-name/{layoutName}")]
-        public ActionResult UpdateFormLayoutName(string org, string app, [FromQuery] string layoutSetName, [FromRoute] string layoutName, [FromBody] string newName)
+        public async Task<ActionResult> UpdateFormLayoutName(string org, string app, [FromQuery] string layoutSetName, [FromRoute] string layoutName, [FromBody] string newName, CancellationToken cancellationToken)
         {
             try
             {
                 string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
                 var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
                 _appDevelopmentService.UpdateFormLayoutName(editingContext, layoutSetName, layoutName, newName);
+                await _mediator.Publish(new LayoutPageIdChangedEvent
+                {
+                    EditingContext = editingContext,
+                    LayoutSetName = layoutSetName,
+                    LayoutName = layoutName,
+                    NewLayoutName = newName,
+                }, cancellationToken);
                 return Ok();
             }
             catch (FileNotFoundException exception)
@@ -385,6 +413,12 @@ public async Task<ActionResult> UpdateLayoutSetName(string org, string app, [Fro
             string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
             var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
             LayoutSets layoutSets = await _appDevelopmentService.UpdateLayoutSetName(editingContext, layoutSetIdToUpdate, newLayoutSetName, cancellationToken);
+            await _mediator.Publish(new LayoutSetIdChangedEvent
+            {
+                EditingContext = editingContext,
+                LayoutSetName = layoutSetIdToUpdate,
+                NewLayoutSetName = newLayoutSetName,
+            }, cancellationToken);
             return Ok(layoutSets);
         }
 
@@ -402,13 +436,15 @@ public async Task<ActionResult> DeleteLayoutSet(string org, string app, [FromRou
         {
             string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
             var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
-            LayoutSets layoutSets = await _appDevelopmentService.DeleteLayoutSet(editingContext, layoutSetIdToUpdate, cancellationToken);
 
             await _mediator.Publish(new LayoutSetDeletedEvent
             {
                 EditingContext = editingContext,
-                LayoutSetId = layoutSetIdToUpdate
+                LayoutSetName = layoutSetIdToUpdate
             }, cancellationToken);
+
+            LayoutSets layoutSets = await _appDevelopmentService.DeleteLayoutSet(editingContext, layoutSetIdToUpdate, cancellationToken);
+
             return Ok(layoutSets);
         }
 

backend/src/Designer/EventHandlers/ComponentDeleted/ComponentDeletedLayoutsHandler.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Events;
+using Altinn.Studio.Designer.Hubs.SyncHub;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Interfaces;
+using MediatR;
+
+namespace Altinn.Studio.Designer.EventHandlers.ComponentDeleted;
+
+public class ComponentDeletedLayoutsHandler(IFileSyncHandlerExecutor fileSyncHandlerExecutor, IAppDevelopmentService appDevelopmentService) : INotificationHandler<ComponentDeletedEvent>
+{
+    public async Task Handle(ComponentDeletedEvent notification, CancellationToken cancellationToken)
+    {
+        await fileSyncHandlerExecutor.ExecuteWithExceptionHandlingAndConditionalNotification(
+            notification.EditingContext,
+            SyncErrorCodes.ComponentDeletedLayoutsSyncError,
+            "layouts",
+            async () =>
+            {
+                List<Reference> referencesToDelete = [new Reference("component", notification.LayoutSetName, notification.ComponentId)];
+                return await appDevelopmentService.UpdateLayoutReferences(notification.EditingContext, referencesToDelete, cancellationToken);
+            });
+    }
+}

backend/src/Designer/EventHandlers/ComponentIdChanged/ComponentIdChangedLayoutsHandler.cs

@@ -1,9 +1,11 @@
+using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json.Nodes;
 using System.Threading;
 using System.Threading.Tasks;
 using Altinn.Studio.Designer.Events;
 using Altinn.Studio.Designer.Hubs.SyncHub;
+using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
 using MediatR;
 
@@ -13,12 +15,15 @@ public class ComponentIdChangedLayoutsHandler : INotificationHandler<ComponentId
 {
     private readonly IAltinnGitRepositoryFactory _altinnGitRepositoryFactory;
     private readonly IFileSyncHandlerExecutor _fileSyncHandlerExecutor;
+    private readonly IAppDevelopmentService _appDevelopmentService;
 
     public ComponentIdChangedLayoutsHandler(IAltinnGitRepositoryFactory altinnGitRepositoryFactory,
-        IFileSyncHandlerExecutor fileSyncHandlerExecutor)
+        IFileSyncHandlerExecutor fileSyncHandlerExecutor,
+        IAppDevelopmentService appDevelopmentService)
     {
         _altinnGitRepositoryFactory = altinnGitRepositoryFactory;
         _fileSyncHandlerExecutor = fileSyncHandlerExecutor;
+        _appDevelopmentService = appDevelopmentService;
     }
 
     public async Task Handle(ComponentIdChangedEvent notification, CancellationToken cancellationToken)
@@ -45,6 +50,10 @@ await _fileSyncHandlerExecutor.ExecuteWithExceptionHandlingAndConditionalNotific
                             hasChanges = true;
                         }
                     }
+
+                    List<Reference> referencesToUpdate = [new Reference("component", notification.LayoutSetName, notification.OldComponentId, notification.NewComponentId)];
+                    hasChanges |= await _appDevelopmentService.UpdateLayoutReferences(notification.EditingContext, referencesToUpdate, cancellationToken);
+
                     return hasChanges;
                 });
     }

backend/src/Designer/EventHandlers/LayoutPageDeleted/LayoutPageDeletedLayoutsHandler.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Events;
+using Altinn.Studio.Designer.Hubs.SyncHub;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Interfaces;
+using MediatR;
+
+namespace Altinn.Studio.Designer.EventHandlers.LayoutPageDeleted;
+
+public class LayoutPageDeletedLayoutsHandler(IFileSyncHandlerExecutor fileSyncHandlerExecutor, IAppDevelopmentService appDevelopmentService) : INotificationHandler<LayoutPageDeletedEvent>
+{
+    public async Task Handle(LayoutPageDeletedEvent notification, CancellationToken cancellationToken)
+    {
+        await fileSyncHandlerExecutor.ExecuteWithExceptionHandlingAndConditionalNotification(
+            notification.EditingContext,
+            SyncErrorCodes.LayoutPageDeletedLayoutsSyncError,
+            "layouts",
+            async () =>
+            {
+                List<Reference> referencesToDelete = [new Reference("page", notification.LayoutSetName, notification.LayoutName)];
+                return await appDevelopmentService.UpdateLayoutReferences(notification.EditingContext, referencesToDelete, cancellationToken);
+            });
+    }
+}

backend/src/Designer/EventHandlers/LayoutPageIdChanged/LayoutPageIdChangedLayoutsHandler.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Events;
+using Altinn.Studio.Designer.Hubs.SyncHub;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Interfaces;
+using MediatR;
+
+namespace Altinn.Studio.Designer.EventHandlers.LayoutPageDeleted;
+
+public class LayoutPageIdChangedLayoutsHandler(IFileSyncHandlerExecutor fileSyncHandlerExecutor, IAppDevelopmentService appDevelopmentService) : INotificationHandler<LayoutPageIdChangedEvent>
+{
+    public async Task Handle(LayoutPageIdChangedEvent notification, CancellationToken cancellationToken)
+    {
+        await fileSyncHandlerExecutor.ExecuteWithExceptionHandlingAndConditionalNotification(
+            notification.EditingContext,
+            SyncErrorCodes.LayoutPageIdChangedLayoutsSyncError,
+            "layouts",
+            async () =>
+            {
+                List<Reference> referencesToUpdate = [new Reference("page", notification.LayoutSetName, notification.LayoutName, notification.NewLayoutName)];
+                return await appDevelopmentService.UpdateLayoutReferences(notification.EditingContext, referencesToUpdate, cancellationToken);
+            });
+    }
+}

backend/src/Designer/EventHandlers/LayoutSetDeleted/LayoutSetDeletedLayoutsHandler.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Events;
+using Altinn.Studio.Designer.Hubs.SyncHub;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Interfaces;
+using MediatR;
+
+namespace Altinn.Studio.Designer.EventHandlers.LayoutSetDeleted;
+
+public class LayoutSetDeletedLayoutsHandler(IFileSyncHandlerExecutor fileSyncHandlerExecutor, IAppDevelopmentService appDevelopmentService) : INotificationHandler<LayoutSetDeletedEvent>
+{
+    public async Task Handle(LayoutSetDeletedEvent notification, CancellationToken cancellationToken)
+    {
+        await fileSyncHandlerExecutor.ExecuteWithExceptionHandlingAndConditionalNotification(
+            notification.EditingContext,
+            SyncErrorCodes.LayoutSetDeletedLayoutsSyncError,
+            "layouts",
+            async () =>
+            {
+                List<Reference> referencesToDelete = [new Reference("layoutSet", notification.LayoutSetName, notification.LayoutSetName)];
+                return await appDevelopmentService.UpdateLayoutReferences(notification.EditingContext, referencesToDelete, cancellationToken);
+            });
+    }
+}

backend/src/Designer/EventHandlers/LayoutSetIdChanged/LayoutSetIdChangedLayoutsHandler.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Events;
+using Altinn.Studio.Designer.Hubs.SyncHub;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Interfaces;
+using MediatR;
+
+namespace Altinn.Studio.Designer.EventHandlers.LayoutSetDeleted;
+
+public class LayoutSetIdChangedLayoutsHandler(IFileSyncHandlerExecutor fileSyncHandlerExecutor, IAppDevelopmentService appDevelopmentService) : INotificationHandler<LayoutSetIdChangedEvent>
+{
+    public async Task Handle(LayoutSetIdChangedEvent notification, CancellationToken cancellationToken)
+    {
+        await fileSyncHandlerExecutor.ExecuteWithExceptionHandlingAndConditionalNotification(
+            notification.EditingContext,
+            SyncErrorCodes.LayoutSetIdChangedLayoutsSyncError,
+            "layouts",
+            async () =>
+            {
+                List<Reference> referencesToUpdate = [new Reference("layoutSet", notification.LayoutSetName, notification.LayoutSetName, notification.NewLayoutSetName)];
+                return await appDevelopmentService.UpdateLayoutReferences(notification.EditingContext, referencesToUpdate, cancellationToken);
+            });
+    }
+}