Merge remote-tracking branch 'origin/master' into 11642-resourceadm-a…

…dd-option-to-set-which-organizations-can-access-a-resource

.github/labeler.yml

@@ -41,6 +41,11 @@ area/text-editor:
   - 'frontend/packages/text-editor/**'
   - 'frontend/app-development/features/textEditor/**/*'
 
+area/process:
+  - 'frontend/app-development/features/processEditor/**/*'
+  - 'frontend/packages/process-editor/**/*'
+  - 'backend/src/Designer/**/*ProcessesModeling*.cs'
+
 area/ui-editor:
   - 'frontend/packages/ux-editor/**/*'
 

.github/release.yml

@@ -6,7 +6,7 @@ changelog:
       - skip-releasenotes
       - area/resource-registry
   categories:
-    - title: Apps editor 🛠
+    - title: Forms editor 🛠
       labels:
         - area/ui-editor
       exclude:
@@ -24,6 +24,12 @@ changelog:
       exclude:
         labels:
           - kind/bug
+    - title: Process editor ⏺→◻️→⏺
+      labels:
+        - area/process
+      exclude:
+        labels:
+          - kind/bug
     - title: Data modelling 📈
       labels:
         - area/data-modeling

backend/src/Designer/Controllers/ProcessModelingController.cs

@@ -10,6 +10,7 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using NuGet.Versioning;
 
 namespace Altinn.Studio.Designer.Controllers
 {
@@ -56,14 +57,14 @@ public async Task<IActionResult> SaveProcessDefinition(string org, string repo,
         }
 
         [HttpGet("templates/{appVersion}")]
-        public IEnumerable<string> GetTemplates(string org, string repo, Version appVersion)
+        public IEnumerable<string> GetTemplates(string org, string repo, SemanticVersion appVersion)
         {
             Guard.AssertArgumentNotNull(appVersion, nameof(appVersion));
             return _processModelingService.GetProcessDefinitionTemplates(appVersion);
         }
 
         [HttpPut("templates/{appVersion}/{templateName}")]
-        public async Task<FileStreamResult> SaveProcessDefinitionFromTemplate(string org, string repo, Version appVersion, string templateName, CancellationToken cancellationToken)
+        public async Task<FileStreamResult> SaveProcessDefinitionFromTemplate(string org, string repo, SemanticVersion appVersion, string templateName, CancellationToken cancellationToken)
         {
             Guard.AssertArgumentNotNull(appVersion, nameof(appVersion));
             string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
@@ -73,5 +74,27 @@ public async Task<FileStreamResult> SaveProcessDefinitionFromTemplate(string org
             Stream processDefinitionStream = _processModelingService.GetProcessDefinitionStream(editingContext);
             return new FileStreamResult(processDefinitionStream, MediaTypeNames.Text.Plain);
         }
+
+        [HttpPut("tasks/{taskId}/{taskName}")]
+        public async Task<ActionResult> UpdateProcessTaskName(string org, string repo, string taskId, string taskName, CancellationToken cancellationToken)
+        {
+            Guard.AssertArgumentNotNull(taskId, nameof(taskId));
+            Guard.AssertArgumentNotNull(taskName, nameof(taskName));
+            string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+            var editingContext = AltinnRepoEditingContext.FromOrgRepoDeveloper(org, repo, developer);
+            try
+            {
+                Stream updatedProcessDefinitionStream = await _processModelingService.UpdateProcessTaskNameAsync(editingContext, taskId, taskName, cancellationToken);
+                return new FileStreamResult(updatedProcessDefinitionStream, MediaTypeNames.Text.Plain);
+            }
+            catch (InvalidOperationException)
+            {
+                return BadRequest("Could not deserialize process definition.");
+            }
+            catch (ArgumentException)
+            {
+                return BadRequest("Could not find task with given id.");
+            }
+        }
     }
 }

backend/src/Designer/Helpers/PackageVersionHelper.cs

@@ -1,12 +1,13 @@
 using System.Linq;
 using System.Xml.Linq;
 using System.Xml.XPath;
+using NuGet.Versioning;
 
 namespace Altinn.Studio.Designer.Helpers
 {
     public static class PackageVersionHelper
     {
-        public static bool TryGetPackageVersionFromCsprojFile(string csprojFilePath, string packageName, out System.Version version)
+        public static bool TryGetPackageVersionFromCsprojFile(string csprojFilePath, string packageName, out SemanticVersion version)
         {
             version = null;
             var doc = XDocument.Load(csprojFilePath);
@@ -26,8 +27,7 @@ public static bool TryGetPackageVersionFromCsprojFile(string csprojFilePath, str
                 return false;
             }
 
-            version = System.Version.Parse(versionString);
-            return true;
+            return SemanticVersion.TryParse(versionString, out version);
         }
     }
 }

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

@@ -10,6 +10,7 @@
 using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
 using Microsoft.AspNetCore.Http;
+using NuGet.Versioning;
 
 namespace Altinn.Studio.Designer.Services.Implementation
 {
@@ -218,15 +219,15 @@ public async Task SaveRuleConfig(AltinnRepoEditingContext altinnRepoEditingConte
         }
 
         /// <inheritdoc />
-        public Version GetAppLibVersion(AltinnRepoEditingContext altinnRepoEditingContext)
+        public SemanticVersion GetAppLibVersion(AltinnRepoEditingContext altinnRepoEditingContext)
         {
             AltinnAppGitRepository altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(altinnRepoEditingContext.Org, altinnRepoEditingContext.Repo, altinnRepoEditingContext.Developer);
 
             var csprojFiles = altinnAppGitRepository.FindFiles(new[] { "*.csproj" });
 
             foreach (string csprojFile in csprojFiles)
             {
-                if (PackageVersionHelper.TryGetPackageVersionFromCsprojFile(csprojFile, "Altinn.App.Api", out Version version))
+                if (PackageVersionHelper.TryGetPackageVersionFromCsprojFile(csprojFile, "Altinn.App.Api", out SemanticVersion version))
                 {
                     return version;
                 }

backend/src/Designer/Services/Implementation/ProcessModeling/ProcessModelingService.cs

@@ -1,12 +1,16 @@
-using System;
+#nullable enable
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Xml.Serialization;
+using Altinn.App.Core.Internal.Process.Elements;
 using Altinn.Studio.Designer.Infrastructure.GitRepository;
 using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
+using NuGet.Versioning;
 
 namespace Altinn.Studio.Designer.Services.Implementation.ProcessModeling
 {
@@ -18,18 +22,18 @@ public ProcessModelingService(IAltinnGitRepositoryFactory altinnGitRepositoryFac
             _altinnGitRepositoryFactory = altinnGitRepositoryFactory;
         }
 
-        private string TemplatesFolderIdentifier(Version version) => string.Join(".", nameof(Services), nameof(Implementation), nameof(ProcessModeling), "Templates", $"v{version.Major}");
+        private string TemplatesFolderIdentifier(SemanticVersion version) => string.Join(".", nameof(Services), nameof(Implementation), nameof(ProcessModeling), "Templates", $"v{version.Major}");
 
         /// <inheritdoc/>
-        public IEnumerable<string> GetProcessDefinitionTemplates(Version version)
+        public IEnumerable<string> GetProcessDefinitionTemplates(SemanticVersion version)
         {
             return EnumerateTemplateResources(version)
                 .Select(
                 templateName => templateName.Split(TemplatesFolderIdentifier(version)).Last().TrimStart('.'))!;
         }
 
         /// <inheritdoc/>
-        public async Task SaveProcessDefinitionFromTemplateAsync(AltinnRepoEditingContext altinnRepoEditingContext, string templateName, Version version, CancellationToken cancellationToken = default)
+        public async Task SaveProcessDefinitionFromTemplateAsync(AltinnRepoEditingContext altinnRepoEditingContext, string templateName, SemanticVersion version, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
             AltinnAppGitRepository altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(altinnRepoEditingContext.Org, altinnRepoEditingContext.Repo, altinnRepoEditingContext.Developer);
@@ -52,13 +56,44 @@ public Stream GetProcessDefinitionStream(AltinnRepoEditingContext altinnRepoEdit
             return altinnAppGitRepository.GetProcessDefinitionFile();
         }
 
-        private IEnumerable<string> EnumerateTemplateResources(Version version)
+        public async Task<Stream> UpdateProcessTaskNameAsync(AltinnRepoEditingContext altinnRepoEditingContext, string taskId, string taskName, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            AltinnAppGitRepository altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(altinnRepoEditingContext.Org, altinnRepoEditingContext.Repo, altinnRepoEditingContext.Developer);
+            XmlSerializer serializer = new(typeof(Definitions));
+            Definitions? definitions;
+            using (Stream processDefinitionStream = GetProcessDefinitionStream(altinnRepoEditingContext))
+            {
+                definitions = (Definitions?)serializer.Deserialize(processDefinitionStream);
+            }
+
+            if (definitions == null)
+            {
+                throw new InvalidOperationException("Could not deserialize process definition.");
+            }
+
+            ProcessTask? processTask = (definitions.Process.Tasks?.FirstOrDefault(t => t.Id == taskId)) ?? throw new ArgumentException($"Could not find task with id {taskId}.");
+            processTask.Name = taskName;
+
+            Stream processStream = new MemoryStream();
+            serializer.Serialize(processStream, definitions);
+
+            // Reset stream position to beginning after serialization
+            processStream.Seek(0, SeekOrigin.Begin);
+            await altinnAppGitRepository.SaveProcessDefinitionFileAsync(processStream, cancellationToken);
+
+            // Reset stream position to beginning after saving
+            processStream.Seek(0, SeekOrigin.Begin);
+            return processStream;
+        }
+
+        private IEnumerable<string> EnumerateTemplateResources(SemanticVersion version)
         {
             return typeof(ProcessModelingService).Assembly.GetManifestResourceNames()
                 .Where(resourceName => resourceName.Contains(TemplatesFolderIdentifier(version)));
         }
 
-        private Stream GetTemplateStream(Version version, string templateName)
+        private Stream GetTemplateStream(SemanticVersion version, string templateName)
         {
             var templates = EnumerateTemplateResources(version).ToList();
             if (!templates.Exists(template => template.EndsWith(templateName)))

backend/src/Designer/Services/Interfaces/IAppDevelopmentService.cs

@@ -133,6 +133,6 @@ public interface IAppDevelopmentService
         /// </summary>
         /// <param name="altinnRepoEditingContext">An <see cref="AltinnRepoEditingContext"/>.</param>
         /// <returns>A <see cref="System.Version"/> holding the version of the app-lib used in app.</returns>
-        public System.Version GetAppLibVersion(AltinnRepoEditingContext altinnRepoEditingContext);
+        public NuGet.Versioning.SemanticVersion GetAppLibVersion(AltinnRepoEditingContext altinnRepoEditingContext);
     }
 }

backend/src/Designer/Services/Interfaces/IProcessModelingService.cs

@@ -1,9 +1,9 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using Altinn.Studio.Designer.Models;
+using NuGet.Versioning;
 
 namespace Altinn.Studio.Designer.Services.Interfaces
 {
@@ -14,7 +14,7 @@ public interface IProcessModelingService
         /// </summary>
         /// <param name="version">Version of the app-lib</param>
         /// <returns>An IEnumerable containing supported templates for given version.</returns>
-        IEnumerable<string> GetProcessDefinitionTemplates(Version version);
+        IEnumerable<string> GetProcessDefinitionTemplates(SemanticVersion version);
 
         /// <summary>
         /// Saves the process definition file for a given app from a template.
@@ -23,7 +23,7 @@ public interface IProcessModelingService
         /// <param name="templateName">Name of the template.</param>
         /// <param name="version">Version of the app-lib.</param>
         /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
-        Task SaveProcessDefinitionFromTemplateAsync(AltinnRepoEditingContext altinnRepoEditingContext, string templateName, Version version, CancellationToken cancellationToken = default);
+        Task SaveProcessDefinitionFromTemplateAsync(AltinnRepoEditingContext altinnRepoEditingContext, string templateName, SemanticVersion version, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Saves the process definition file for a given app.
@@ -39,5 +39,15 @@ public interface IProcessModelingService
         /// <param name="altinnRepoEditingContext">An <see cref="AltinnRepoEditingContext"/>.</param>
         /// <returns>A <see cref="Stream"/> of a process definition file.</returns>
         Stream GetProcessDefinitionStream(AltinnRepoEditingContext altinnRepoEditingContext);
+
+        /// <summary>
+        /// Updates the name of a task in the process definition file.
+        /// </summary>
+        /// <param name="altinnRepoEditingContext">n <see cref="AltinnRepoEditingContext"/>.</param>
+        /// <param name="taskId">The ID of the task to update</param>
+        /// <param name="taskName">The name to set for the task</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+        /// <returns></returns>
+        Task<Stream> UpdateProcessTaskNameAsync(AltinnRepoEditingContext altinnRepoEditingContext, string taskId, string taskName, CancellationToken cancellationToken = default);
     }
 }

backend/src/Designer/ViewModels/Response/VersionResponse.cs

@@ -1,9 +1,10 @@
 using System;
+using NuGet.Versioning;
 
 namespace Altinn.Studio.Designer.ViewModels.Response
 {
     public class VersionResponse
     {
-        public Version Version { get; set; }
+        public SemanticVersion Version { get; set; }
     }
 }

backend/tests/Designer.Tests/Controllers/AppDevelopmentController/GetVersionOfTheAppLibTests.cs

@@ -21,6 +21,7 @@ public GetVersionOfTheAppLibTests(WebApplicationFactory<Program> factory) : base
 
         [Theory]
         [InlineData("ttd", "empty-app", "testUser", "7.4.0", "Templates/AppCsprojTemplate.txt")]
+        [InlineData("ttd", "empty-app", "testUser", "8.0.0-preview.11", "Templates/AppCsprojTemplate.txt")]
         public async Task GetAppLibVersion_GivenCsProjFile_ShouldReturnOK(string org, string app, string developer, string version, string csprojTemplate)
         {
             string targetRepository = TestDataHelper.GenerateTestRepoName();

backend/tests/Designer.Tests/Controllers/ProcessModelingController/GetTemplatesTests.cs

@@ -19,6 +19,7 @@ public GetTemplatesTests(WebApplicationFactory<Program> factory) : base(factory)
 
         [Theory]
         [InlineData("ttd", "empty-app", "8.0.0", "start-data-confirmation-end.bpmn", "start-data-confirmation-feedback-end.bpmn", "start-data-end.bpmn", "start-data-signing-end.bpmn")]
+        [InlineData("ttd", "empty-app", "8.0.0-preview.11", "start-data-confirmation-end.bpmn", "start-data-confirmation-feedback-end.bpmn", "start-data-end.bpmn", "start-data-signing-end.bpmn")]
         [InlineData("ttd", "empty-app", "7.4.0", "start-data-confirmation-end.bpmn", "start-data-data-data-end.bpmn", "start-data-end.bpmn")]
         [InlineData("ttd", "empty-app", "6.1.0")]
         public async Task GetTemplates_ShouldReturnOK(string org, string app, string version, params string[] expectedTemplates)

backend/tests/Designer.Tests/Controllers/ProcessModelingController/SaveProcessDefinitionFromTemplateTests.cs

@@ -33,6 +33,7 @@ public async Task SaveProcessDefinitionFromTemplate_WrongTemplate_ShouldReturn40
 
         [Theory]
         [InlineData("ttd", "empty-app", "testUser", "8.0.0", "start-data-confirmation-end.bpmn")]
+        [InlineData("ttd", "empty-app", "testUser", "8.0.0-preview.11", "start-data-confirmation-end.bpmn")]
         public async Task SaveProcessDefinitionFromTemplate_ShouldReturnOk_AndSaveTemplate(string org, string app, string developer, string version, string templateName)
         {
             string targetRepository = TestDataHelper.GenerateTestRepoName();

backend/tests/Designer.Tests/Controllers/ProcessModelingController/UpdateProcessTaskNameTests.cs

@@ -0,0 +1,54 @@
+using System.Net;
+using System.Net.Http;
+using System.Net.Mime;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using FluentAssertions;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.ProcessModelingController
+{
+    public class UpdateProcessTaskName : DisagnerEndpointsTestsBase<UpdateProcessTaskName>, IClassFixture<WebApplicationFactory<Program>>
+    {
+        private static string Url(string org, string repository, string taskId, string taskName) => $"/designer/api/{org}/{repository}/process-modelling/tasks/{taskId}/{taskName}";
+
+        public UpdateProcessTaskName(WebApplicationFactory<Program> factory) : base(factory)
+        {
+        }
+
+        [Theory]
+        [InlineData("ttd", "app-with-process", "testUser", "Task_1", "NewTaskName")]
+        public async Task UpdateProcessTaskName_ShouldReturnUpdatedProcess(string org, string app, string developer, string taskId, string taskName)
+        {
+            string targetRepository = TestDataHelper.GenerateTestRepoName();
+            await CopyRepositoryForTest(org, app, developer, targetRepository);
+
+            string url = Url(org, targetRepository, taskId, taskName);
+
+            using var response = await HttpClient.PutAsync(url, null);
+            response.StatusCode.Should().Be(HttpStatusCode.OK);
+
+            string responseContent = await response.Content.ReadAsStringAsync();
+
+            responseContent.Should().NotBeNullOrEmpty();
+            responseContent.Should().Contain(taskName);
+        }
+
+        [Theory]
+        [InlineData("ttd", "app-with-process", "testUser", "Does_not_exist", "NewTaskName")]
+        public async Task InvalidTaskId_ShouldReturnBadRequest(string org, string app, string developer, string taskId, string taskName)
+        {
+            string targetRepository = TestDataHelper.GenerateTestRepoName();
+            await CopyRepositoryForTest(org, app, developer, targetRepository);
+
+            string url = Url(org, targetRepository, taskId, taskName);
+
+            using var response = await HttpClient.PutAsync(url, null);
+            response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
+        }
+    }
+}

backend/tests/Designer.Tests/Helpers/PackageVersionHelperTests.cs

@@ -16,7 +16,7 @@ public void TryGetPackageVersionFromCsprojFile_GivenValidCsprojFile_ReturnsTrue(
         {
             string testTemplateCsProjPath = Path.Combine(CommonDirectoryPath.GetSolutionDirectory().DirectoryPath, "..", "testdata", "AppTemplates", "AspNet", "App", "App.csproj");
 
-            bool result = PackageVersionHelper.TryGetPackageVersionFromCsprojFile(testTemplateCsProjPath, packageName, out Version version);
+            bool result = PackageVersionHelper.TryGetPackageVersionFromCsprojFile(testTemplateCsProjPath, packageName, out var version);
 
             result.Should().Be(expectedResult);