refactor(pages-api): implement page api on frontend

backend/src/Designer/Controllers/LayoutController.cs

@@ -0,0 +1,127 @@
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Helpers;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Models.Dto;
+using Altinn.Studio.Designer.Services.Interfaces;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing;
+
+namespace Altinn.Studio.Designer.Controllers
+{
+    [ApiController]
+    [Authorize]
+    [AutoValidateAntiforgeryToken]
+    [Route("designer/api/{org}/{app}/layouts/layoutSet/{layoutSetId}/")]
+    public class LayoutController(ILayoutService layoutService) : Controller
+    {
+        [EndpointSummary("Retrieve pages")]
+        [ProducesResponseType<Pages>(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [HttpGet("pages")]
+        public async Task<ActionResult<Pages>> GetPages(
+                [FromRoute] string org,
+                [FromRoute] string app,
+                [FromRoute] string layoutSetId
+        )
+        {
+            string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+            var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
+            Pages pages = await layoutService.GetPagesByLayoutSetId(editingContext, layoutSetId);
+            return Ok(pages);
+        }
+
+        [EndpointSummary("Create page")]
+        [ProducesResponseType<Pages>(StatusCodes.Status201Created)]
+        [ProducesResponseType(StatusCodes.Status409Conflict)]
+        [HttpPost("pages")]
+        public async Task<ActionResult<Page>> CreatePage(
+                [FromRoute] string org,
+                [FromRoute] string app,
+                [FromRoute] string layoutSetId,
+                [FromBody] Page page
+        )
+        {
+            string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+            var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
+
+            Page existingPage = await layoutService.GetPageById(editingContext, layoutSetId, page.id);
+            if (existingPage != null)
+            {
+                return Conflict();
+            }
+            await layoutService.CreatePage(editingContext, layoutSetId, page.id);
+            return Created();
+        }
+
+        [EndpointSummary("Retrieve page")]
+        [ProducesResponseType<Page>(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [HttpGet("pages/{pageId}")]
+        [ProducesResponseType<Page>(StatusCodes.Status200OK)]
+        public async Task<ActionResult<Page>> GetPage(
+                [FromRoute] string org,
+                [FromRoute] string app,
+                [FromRoute] string layoutSetId,
+                [FromRoute] string pageId
+        )
+        {
+            string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+            var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
+            Page page = await layoutService.GetPageById(editingContext, layoutSetId, pageId);
+            if (page == null)
+            {
+                return NotFound();
+            }
+            return Ok(page);
+        }
+
+        [EndpointSummary("Modify page")]
+        [ProducesResponseType<Page>(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [HttpPut("pages/{pageId}")]
+        public async Task<ActionResult<Page>> ModifyPage(
+                [FromRoute] string org,
+                [FromRoute] string app,
+                [FromRoute] string layoutSetId,
+                [FromRoute] string pageId,
+                [FromBody] Page page
+        )
+        {
+            string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+            var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
+            Page existingPage = await layoutService.GetPageById(editingContext, layoutSetId, pageId);
+            if (existingPage == null)
+            {
+                return NotFound();
+            }
+
+            await layoutService.UpdatePage(editingContext, layoutSetId, pageId, page);
+            return Ok();
+        }
+
+        [EndpointSummary("Delete page")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [HttpDelete("pages/{pageId}")]
+        public async Task<ActionResult> DeletePage(
+                [FromRoute] string org,
+                [FromRoute] string app,
+                [FromRoute] string layoutSetId,
+                [FromRoute] string pageId
+        )
+        {
+            string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+            var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, app, developer);
+            Page page = await layoutService.GetPageById(editingContext, layoutSetId, pageId);
+            if (page == null)
+            {
+                return NotFound();
+            }
+
+            await layoutService.DeletePage(editingContext, layoutSetId, pageId);
+            return Ok();
+        }
+    }
+}

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

@@ -42,8 +42,10 @@ await _fileSyncHandlerExecutor.ExecuteWithExceptionHandlingAndConditionalNotific
                 {
                     bool hasChanges = false;
                     string[] layoutNames = repository.GetLayoutNames(notification.LayoutSetName);
-                    foreach (var layoutName in layoutNames)
+                    foreach (var layoutFileName in layoutNames)
                     {
+
+                        string layoutName = layoutFileName.Replace(".json", "");
                         var layout = await repository.GetLayout(notification.LayoutSetName, layoutName, cancellationToken);
                         if (TryChangeComponentId(layout, notification.OldComponentId, notification.NewComponentId))
                         {

backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs

@@ -60,11 +60,11 @@ public class AltinnAppGitRepository : AltinnGitRepository
         private const string SchemaFilePatternJson = "*.schema.json";
         private const string SchemaFilePatternXsd = "*.xsd";
 
-        public static readonly string InitialLayoutFileName = "Side1.json";
+        public static readonly string InitialLayoutFileName = "Side1";
 
         public readonly JsonNode InitialLayout = new JsonObject { ["$schema"] = LayoutSchemaUrl, ["data"] = new JsonObject { ["layout"] = new JsonArray([]) } };
 
-        public readonly JsonNode InitialLayoutSettings = new JsonObject { ["$schema"] = LayoutSettingsSchemaUrl, ["pages"] = new JsonObject { ["order"] = new JsonArray([InitialLayoutFileName.Replace(".json", "")]) } };
+        public readonly JsonNode InitialLayoutSettings = new JsonObject { ["$schema"] = LayoutSettingsSchemaUrl, ["pages"] = new JsonObject { ["order"] = new JsonArray([InitialLayoutFileName]) } };
 
         private static readonly JsonSerializerOptions JsonOptions = new()
         {
@@ -359,6 +359,16 @@ public void DeleteTexts(string languageCode)
             }
         }
 
+        public async Task CreatePageLayoutFile(string layoutSetId, string pageId)
+        {
+            JsonObject defaultPageLayout = new()
+            {
+                ["$schema"] = LayoutSchemaUrl,
+                ["data"] = new JsonObject { ["layout"] = new JsonArray([]) }
+            };
+            await WriteObjectByRelativePathAsync(Path.Combine([LayoutsFolderName, layoutSetId, LayoutsInSetFolderName, $"{pageId}.json"]), defaultPageLayout);
+        }
+
         /// <summary>
         /// Returns all the layouts for a specific layout set
         /// </summary>
@@ -370,10 +380,11 @@ public async Task<Dictionary<string, JsonNode>> GetFormLayouts(string layoutSetN
             cancellationToken.ThrowIfCancellationRequested();
             Dictionary<string, JsonNode> formLayouts = new();
             string[] layoutNames = GetLayoutNames(layoutSetName);
-            foreach (string layoutName in layoutNames)
+            foreach (string layoutFileName in layoutNames)
             {
+                string layoutName = layoutFileName.Replace(".json", "");
                 JsonNode layout = await GetLayout(layoutSetName, layoutName, cancellationToken);
-                formLayouts[layoutName.Replace(".json", "")] = layout;
+                formLayouts[layoutName] = layout;
             }
 
             return formLayouts;
@@ -479,7 +490,7 @@ public string[] GetLayoutNames(string layoutSetName)
             {
                 foreach (string layoutPath in GetFilesByRelativeDirectory(layoutSetPath))
                 {
-                    layoutNames.Add(Path.GetFileName(layoutPath));
+                    layoutNames.Add(Path.GetFileNameWithoutExtension(layoutPath));
                 }
             }
 
@@ -652,11 +663,11 @@ public async Task SaveLayout(string layoutSetName, string layoutFileName, JsonNo
             await WriteTextByRelativePathAsync(layoutFilePath, serializedLayout, true, cancellationToken);
         }
 
-        public void UpdateFormLayoutName(string layoutSetName, string layoutFileName, string newFileName)
+        public void UpdateFormLayoutName(string layoutSetName, string layoutName, string newLayoutName)
         {
-            string currentFilePath = GetPathToLayoutFile(layoutSetName, layoutFileName);
-            string newFilePath = GetPathToLayoutFile(layoutSetName, newFileName);
-            MoveFileByRelativePath(currentFilePath, newFilePath, newFileName);
+            string currentFilePath = GetPathToLayoutFile(layoutSetName, layoutName);
+            string newFilePath = GetPathToLayoutFile(layoutSetName, newLayoutName);
+            MoveFileByRelativePath(currentFilePath, newFilePath, newLayoutName);
         }
 
         public async Task<LayoutSets> GetLayoutSetsFile(CancellationToken cancellationToken = default)
@@ -1067,11 +1078,11 @@ private static string GetPathToLayoutSet(string layoutSetName, bool excludeLayou
         }
 
         // can be null if app does not use layout set
-        private static string GetPathToLayoutFile(string layoutSetName, string fileName)
+        private static string GetPathToLayoutFile(string layoutSetName, string layoutName)
         {
             return string.IsNullOrEmpty(layoutSetName) ?
-                Path.Combine(LayoutsFolderName, LayoutsInSetFolderName, fileName) :
-                Path.Combine(LayoutsFolderName, layoutSetName, LayoutsInSetFolderName, fileName);
+                Path.Combine(LayoutsFolderName, LayoutsInSetFolderName, $"{layoutName}.json") :
+                Path.Combine(LayoutsFolderName, layoutSetName, LayoutsInSetFolderName, $"{layoutName}.json");
         }
 
         // can be null if app does not use layout set

backend/src/Designer/Infrastructure/ServiceRegistration.cs

@@ -76,6 +76,7 @@ public static IServiceCollection RegisterServiceImplementations(this IServiceCol
             services.AddTransient<IInstanceService, InstanceService>();
             services.AddTransient<IProcessModelingService, ProcessModelingService>();
             services.AddTransient<IImagesService, ImagesService>();
+            services.AddTransient<ILayoutService, LayoutService>();
             services.RegisterDatamodeling(configuration);
             services.RegisterSettingsSingleton<KafkaSettings>(configuration);
             services.AddTransient<IKafkaProducer, KafkaProducer>();

backend/src/Designer/Models/Dto/Page.cs

@@ -0,0 +1,9 @@
+using System.Text.Json.Serialization;
+
+namespace Altinn.Studio.Designer.Models.Dto;
+
+public class Page
+{
+    [JsonPropertyName("id")]
+    public string id { get; set; }
+}

backend/src/Designer/Models/Dto/Pages.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Altinn.Studio.Designer.Models.Dto;
+
+public class Pages
+{
+    [JsonPropertyName("pages")]
+    public List<Page> pages { get; set; }
+}

backend/src/Designer/Services/Implementation/AppDevelopmentService.cs

@@ -68,7 +68,6 @@ public async Task SaveFormLayout(AltinnRepoEditingContext altinnRepoEditingConte
             string layoutName, JsonNode formLayout, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
-            string layoutFileName = $"{layoutName}.json";
             AltinnAppGitRepository altinnAppGitRepository =
                 _altinnGitRepositoryFactory.GetAltinnAppGitRepository(altinnRepoEditingContext.Org,
                     altinnRepoEditingContext.Repo, altinnRepoEditingContext.Developer);
@@ -79,14 +78,13 @@ public async Task SaveFormLayout(AltinnRepoEditingContext altinnRepoEditingConte
                     "This app uses layout sets, but no layout set name was provided for this request");
             }
 
-            await altinnAppGitRepository.SaveLayout(layoutSetName, layoutFileName, formLayout, cancellationToken);
+            await altinnAppGitRepository.SaveLayout(layoutSetName, layoutName, formLayout, cancellationToken);
         }
 
         /// <inheritdoc />
         public void DeleteFormLayout(AltinnRepoEditingContext altinnRepoEditingContext, string layoutSetName,
             string layoutName)
         {
-            string layoutFileName = $"{layoutName}.json";
             AltinnAppGitRepository altinnAppGitRepository =
                 _altinnGitRepositoryFactory.GetAltinnAppGitRepository(altinnRepoEditingContext.Org,
                     altinnRepoEditingContext.Repo, altinnRepoEditingContext.Developer);
@@ -97,7 +95,7 @@ public void DeleteFormLayout(AltinnRepoEditingContext altinnRepoEditingContext,
                     "This app uses layout sets, but no layout set name was provided for this request");
             }
 
-            altinnAppGitRepository.DeleteLayout(layoutSetName, layoutFileName);
+            altinnAppGitRepository.DeleteLayout(layoutSetName, layoutName);
         }
 
         /// <inheritdoc />
@@ -114,7 +112,7 @@ public void UpdateFormLayoutName(AltinnRepoEditingContext altinnRepoEditingConte
                     "This app uses layout sets, but no layout set name was provided for this request");
             }
 
-            altinnAppGitRepository.UpdateFormLayoutName(layoutSetName, $"{layoutName}.json", $"{newName}.json");
+            altinnAppGitRepository.UpdateFormLayoutName(layoutSetName, layoutName, newName);
         }
 
         /// <inheritdoc />
@@ -586,7 +584,7 @@ public async Task AddComponentToLayout(
                 editingContext.Repo,
                 editingContext.Developer
             );
-            JsonNode formLayout = await altinnAppGitRepository.GetLayout(layoutSetName, $"{layoutName}.json", cancellationToken);
+            JsonNode formLayout = await altinnAppGitRepository.GetLayout(layoutSetName, layoutName, cancellationToken);
             if (formLayout["data"] is not JsonObject data || data["layout"] is not JsonArray layoutArray)
             {
                 throw new InvalidOperationException("Invalid form layout structure");
@@ -802,7 +800,7 @@ private async Task<bool> UpdateLayoutReferences(AltinnAppGitRepository altinnApp
 
                     if (hasLayoutChanges)
                     {
-                        await altinnAppGitRepository.SaveLayout(layoutSet.Id, $"{layout.Key}.json", layout.Value, cancellationToken);
+                        await altinnAppGitRepository.SaveLayout(layoutSet.Id, layout.Key, layout.Value, cancellationToken);
                         hasChanges = true;
                     }
                 }

backend/src/Designer/Services/Implementation/LayoutService.cs

@@ -0,0 +1,85 @@
+using System.Linq;
+using System.Text.Json.Nodes;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Infrastructure.GitRepository;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Models.Dto;
+using Altinn.Studio.Designer.Services.Interfaces;
+
+namespace Altinn.Studio.Designer.Services.Implementation
+{
+    public class LayoutService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory) : ILayoutService
+    {
+        private static Pages GetPagesFromSettings(JsonNode settings)
+        {
+            Pages pages = new()
+            {
+                pages = []
+            };
+
+            JsonNode pagesNode = settings["pages"];
+            JsonArray pagesArray = pagesNode["order"] as JsonArray;
+            foreach (JsonNode pageNode in pagesArray)
+            {
+                string pageId = pageNode.GetValue<string>();
+                pages.pages.Add(new Page { id = pageId });
+            }
+
+            return pages;
+        }
+
+        public async Task<Pages> GetPagesByLayoutSetId(AltinnRepoEditingContext editingContext, string layoutSetId)
+        {
+            AltinnAppGitRepository appRepository = altinnGitRepositoryFactory.GetAltinnAppGitRepository(editingContext.Org, editingContext.Repo, editingContext.Developer);
+            JsonNode jsonNode = await appRepository.GetLayoutSettingsAndCreateNewIfNotFound(layoutSetId);
+            Pages pages = GetPagesFromSettings(jsonNode);
+            return pages;
+        }
+
+        public async Task<Page> GetPageById(AltinnRepoEditingContext editingContext, string layoutSetId, string pageId)
+        {
+            AltinnAppGitRepository appRepository = altinnGitRepositoryFactory.GetAltinnAppGitRepository(editingContext.Org, editingContext.Repo, editingContext.Developer);
+            JsonNode jsonNode = await appRepository.GetLayoutSettingsAndCreateNewIfNotFound(layoutSetId);
+            Pages pages = GetPagesFromSettings(jsonNode);
+            return pages.pages.Find(page => page.id == pageId);
+        }
+
+        public async Task CreatePage(AltinnRepoEditingContext editingContext, string layoutSetId, string pageId)
+        {
+            AltinnAppGitRepository appRepository = altinnGitRepositoryFactory.GetAltinnAppGitRepository(editingContext.Org, editingContext.Repo, editingContext.Developer);
+
+            await appRepository.CreatePageLayoutFile(layoutSetId, pageId);
+
+            JsonNode jsonNode = await appRepository.GetLayoutSettingsAndCreateNewIfNotFound(layoutSetId);
+            (jsonNode["pages"]["order"] as JsonArray).Add(pageId);
+            await appRepository.SaveLayoutSettings(layoutSetId, jsonNode);
+        }
+
+        public async Task DeletePage(AltinnRepoEditingContext editingContext, string layoutSetId, string pageId)
+        {
+            AltinnAppGitRepository appRepository = altinnGitRepositoryFactory.GetAltinnAppGitRepository(editingContext.Org, editingContext.Repo, editingContext.Developer);
+
+            appRepository.DeleteLayout(layoutSetId, pageId);
+
+            JsonNode jsonNode = await appRepository.GetLayoutSettingsAndCreateNewIfNotFound(layoutSetId);
+            JsonArray orderArray = jsonNode["pages"]["order"] as JsonArray;
+            JsonNode orderPage = orderArray.First(node => node.GetValue<string>().Equals(pageId));
+            orderArray.Remove(orderPage);
+            await appRepository.SaveLayoutSettings(layoutSetId, jsonNode);
+        }
+
+        public async Task UpdatePage(AltinnRepoEditingContext editingContext, string layoutSetId, string pageId, Page page)
+        {
+            AltinnAppGitRepository appRepository = altinnGitRepositoryFactory.GetAltinnAppGitRepository(editingContext.Org, editingContext.Repo, editingContext.Developer);
+
+            appRepository.UpdateFormLayoutName(layoutSetId, pageId, page.id);
+
+            JsonNode jsonNode = await appRepository.GetLayoutSettingsAndCreateNewIfNotFound(layoutSetId);
+            JsonArray orderArray = jsonNode["pages"]["order"] as JsonArray;
+            JsonNode orderPage = orderArray.First(node => node.GetValue<string>().Equals(pageId));
+            int pageIndex = orderArray.IndexOf(orderPage);
+            orderArray[pageIndex] = page.id;
+            await appRepository.SaveLayoutSettings(layoutSetId, jsonNode);
+        }
+    }
+}