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

backend/src/Designer/Controllers/AppDevelopmentController.cs

@@ -201,16 +201,24 @@ await _mediator.Publish(new LayoutPageDeletedEvent
         /// <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)
@@ -401,6 +409,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);
         }
 

backend/src/Designer/Enums/ReferenceType.cs

@@ -2,6 +2,7 @@ namespace Altinn.Studio.Designer.Enums
 {
     public enum ReferenceType
     {
+        Task,
         LayoutSet,
         Layout,
         Component

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

@@ -1,9 +1,12 @@
+using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json.Nodes;
 using System.Threading;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Enums;
 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 +16,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 +51,10 @@ await _fileSyncHandlerExecutor.ExecuteWithExceptionHandlingAndConditionalNotific
                             hasChanges = true;
                         }
                     }
+
+                    List<Reference> referencesToUpdate = [new Reference(ReferenceType.Component, notification.LayoutSetName, notification.OldComponentId, notification.NewComponentId)];
+                    hasChanges |= await _appDevelopmentService.UpdateLayoutReferences(notification.EditingContext, referencesToUpdate, cancellationToken);
+
                     return hasChanges;
                 });
     }

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

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Enums;
+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(ReferenceType.Layout, notification.LayoutSetName, notification.LayoutName, notification.NewLayoutName)];
+                return await appDevelopmentService.UpdateLayoutReferences(notification.EditingContext, referencesToUpdate, cancellationToken);
+            });
+    }
+}

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

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Enums;
+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(ReferenceType.LayoutSet, notification.LayoutSetName, notification.LayoutSetName, notification.NewLayoutSetName)];
+                return await appDevelopmentService.UpdateLayoutReferences(notification.EditingContext, referencesToUpdate, cancellationToken);
+            });
+    }
+}

backend/src/Designer/EventHandlers/ProcessTaskIdChanged/ProcessTaskIdChangedLayoutsHandler.cs

@@ -1,101 +1,36 @@
-using System.IO;
-using System.Linq;
-using System.Text.Json.Nodes;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Enums;
 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.ProcessTaskIdChanged;
 
 public class ProcessTaskIdChangedLayoutsHandler : INotificationHandler<ProcessTaskIdChangedEvent>
 {
-    private readonly IAltinnGitRepositoryFactory _altinnGitRepositoryFactory;
     private readonly IFileSyncHandlerExecutor _fileSyncHandlerExecutor;
+    private readonly IAppDevelopmentService _appDevelopmentService;
 
-    public ProcessTaskIdChangedLayoutsHandler(IAltinnGitRepositoryFactory altinnGitRepositoryFactory,
-        IFileSyncHandlerExecutor fileSyncHandlerExecutor)
+    public ProcessTaskIdChangedLayoutsHandler(IFileSyncHandlerExecutor fileSyncHandlerExecutor, IAppDevelopmentService appDevelopmentService)
     {
-        _altinnGitRepositoryFactory = altinnGitRepositoryFactory;
         _fileSyncHandlerExecutor = fileSyncHandlerExecutor;
+        _appDevelopmentService = appDevelopmentService;
     }
 
     public async Task Handle(ProcessTaskIdChangedEvent notification, CancellationToken cancellationToken)
     {
-        var repository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(
-            notification.EditingContext.Org,
-            notification.EditingContext.Repo,
-            notification.EditingContext.Developer);
-
-        if (!repository.AppUsesLayoutSets())
-        {
-            return;
-        }
-
-        var layoutSetsFile = await repository.GetLayoutSetsFile(cancellationToken);
-
-        foreach (string layoutSetName in layoutSetsFile.Sets.Select(layoutSet => layoutSet.Id))
-        {
-            string[] layoutNames;
-            try
-            {
-                layoutNames = repository.GetLayoutNames(layoutSetName);
-            }
-            catch (FileNotFoundException)
+        await _fileSyncHandlerExecutor.ExecuteWithExceptionHandlingAndConditionalNotification(
+            notification.EditingContext,
+            SyncErrorCodes.LayoutTaskIdSyncError,
+            "layouts",
+            async () =>
             {
-                continue;
-            }
-
-            await _fileSyncHandlerExecutor.ExecuteWithExceptionHandlingAndConditionalNotification(
-                notification.EditingContext,
-                SyncErrorCodes.LayoutTaskIdSyncError,
-                $"App/ui/{layoutSetName}/layouts",
-                async () =>
-                {
-                    bool hasChanged = false;
-
-                    foreach (string layoutName in layoutNames)
-                    {
-                        var layout = await repository.GetLayout(layoutSetName, layoutName, cancellationToken);
-                        if (TryChangeLayoutTaskIds(layout, notification.OldId, notification.NewId))
-                        {
-                            await repository.SaveLayout(layoutSetName, layoutName, layout, cancellationToken);
-                            hasChanged = true;
-                        }
-                    }
-
-                    return hasChanged;
-                });
-        }
-    }
-
-    private static bool TryChangeLayoutTaskIds(JsonNode node, string oldId, string newId)
-    {
-        bool hasChanged = false;
-
-        if (node is JsonObject jsonObject)
-        {
-            foreach (var property in jsonObject.ToList())
-            {
-                if (property.Key == "taskId" && property.Value?.ToString() == oldId)
-                {
-                    jsonObject["taskId"] = newId;
-                    hasChanged = true;
-                }
-
-                hasChanged |= TryChangeLayoutTaskIds(property.Value, oldId, newId);
-            }
-        }
-        else if (node is JsonArray jsonArray)
-        {
-            foreach (var element in jsonArray)
-            {
-                hasChanged |= TryChangeLayoutTaskIds(element, oldId, newId);
-            }
-        }
-
-        return hasChanged;
+                List<Reference> referencesToUpdate = [new Reference(ReferenceType.Task, null, notification.OldId, notification.NewId)];
+                return await _appDevelopmentService.UpdateLayoutReferences(notification.EditingContext, referencesToUpdate, cancellationToken);
+            });
     }
 }

backend/src/Designer/Events/LayoutPageIdChangedEvent.cs

@@ -0,0 +1,12 @@
+using Altinn.Studio.Designer.Models;
+using MediatR;
+
+namespace Altinn.Studio.Designer.Events;
+
+public class LayoutPageIdChangedEvent : INotification
+{
+    public AltinnRepoEditingContext EditingContext { get; set; }
+    public string LayoutSetName { get; set; }
+    public string LayoutName { get; set; }
+    public string NewLayoutName { get; set; }
+}

backend/src/Designer/Events/LayoutSetIdChangedEvent.cs

@@ -0,0 +1,11 @@
+using Altinn.Studio.Designer.Models;
+using MediatR;
+
+namespace Altinn.Studio.Designer.Events;
+
+public class LayoutSetIdChangedEvent : INotification
+{
+    public AltinnRepoEditingContext EditingContext { get; set; }
+    public string LayoutSetName { get; set; }
+    public string NewLayoutSetName { get; set; }
+}

backend/src/Designer/Hubs/SyncHub/SyncErrorCodes.cs

@@ -10,9 +10,11 @@ public static class SyncErrorCodes
     public const string LayoutSetsDataTypeSyncError = nameof(LayoutSetsDataTypeSyncError);
     public const string LayoutSetComponentIdSyncError = nameof(LayoutSetComponentIdSyncError);
     public const string LayoutSetDeletedLayoutsSyncError = nameof(LayoutSetDeletedLayoutsSyncError);
+    public const string LayoutSetIdChangedLayoutsSyncError = nameof(LayoutSetIdChangedLayoutsSyncError);
     public const string LayoutSetSubFormButtonSyncError = nameof(LayoutSetSubFormButtonSyncError);
     public const string SettingsComponentIdSyncError = nameof(SettingsComponentIdSyncError);
     public const string LayoutPageAddSyncError = nameof(LayoutPageAddSyncError);
     public const string ComponentDeletedLayoutsSyncError = nameof(ComponentDeletedLayoutsSyncError);
     public const string LayoutPageDeletedLayoutsSyncError = nameof(LayoutPageDeletedLayoutsSyncError);
+    public const string LayoutPageIdChangedLayoutsSyncError = nameof(LayoutPageIdChangedLayoutsSyncError);
 }