Feat/multi data model with validation

.editorconfig

@@ -111,7 +111,7 @@ csharp_style_namespace_declarations = file_scoped:error
 dotnet_diagnostic.IDE1006.severity = error
 
 # Unused usings
-dotnet_diagnostic.IDE0005.severity = suggestion
+dotnet_diagnostic.IDE0005.severity = warning
 
 # CA1848: Use the LoggerMessage delegates
 dotnet_diagnostic.CA1848.severity = none
@@ -123,7 +123,7 @@ dotnet_diagnostic.CA1727.severity = suggestion
 dotnet_diagnostic.CA2254.severity = none
 
 # CA1822: Mark members as static
-dotnet_diagnostic.CA1822.severity = suggestion
+dotnet_diagnostic.CA1822.severity = warning
 
 # IDE0080: Remove unnecessary suppression operator
 dotnet_diagnostic.IDE0080.severity = error
@@ -146,6 +146,9 @@ dotnet_diagnostic.CA2201.severity = suggestion
 # TODO: fixing this would be breaking
 dotnet_diagnostic.CA1720.severity = suggestion
 
+# CA1816: Call GC.SuppressFinalize correctly
+dotnet_diagnostic.CA1816.severity = warning
+
 [Program.cs]
 dotnet_diagnostic.CA1050.severity = none
 dotnet_diagnostic.S1118.severity = none

.gitignore

@@ -377,3 +377,6 @@ src/Altinn.Apps/AppTemplates/AspNet/App/Properties/launchSettings.json
 *.iml
 
 .mono/
+
+*.received.txt
+*.recevied.json

src/Altinn.App.Api/Altinn.App.Api.csproj

@@ -16,7 +16,7 @@
 
   <ItemGroup>
     <PackageReference Include="Altinn.Common.PEP" Version="4.0.0" />
-    <PackageReference Include="Altinn.Platform.Storage.Interface" Version="3.30.0"/>
+    <PackageReference Include="Altinn.Platform.Storage.Interface" Version="4.0.0" />
     <PackageReference Include="Microsoft.FeatureManagement.AspNetCore" Version="3.5.0" />
     <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.9.0" />
     <PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.9.0" />

src/Altinn.App.Api/Controllers/ActionsController.cs

@@ -3,7 +3,7 @@
 using Altinn.App.Core.Extensions;
 using Altinn.App.Core.Features;
 using Altinn.App.Core.Features.Action;
-using Altinn.App.Core.Helpers;
+using Altinn.App.Core.Helpers.Serialization;
 using Altinn.App.Core.Internal.App;
 using Altinn.App.Core.Internal.Data;
 using Altinn.App.Core.Internal.Instances;
@@ -33,23 +33,19 @@ public class ActionsController : ControllerBase
     private readonly IValidationService _validationService;
     private readonly IDataClient _dataClient;
     private readonly IAppMetadata _appMetadata;
+    private readonly ModelSerializationService _modelSerialization;
 
     /// <summary>
     /// Create new instance of the <see cref="ActionsController"/> class
     /// </summary>
-    /// <param name="authorization">The authorization service</param>
-    /// <param name="instanceClient">The instance client</param>
-    /// <param name="userActionService">The user action service</param>
-    /// <param name="validationService">Service for performing validations of user data</param>
-    /// <param name="dataClient">Client for accessing data in storage</param>
-    /// <param name="appMetadata">Service for getting application metadata</param>
     public ActionsController(
         IAuthorizationService authorization,
         IInstanceClient instanceClient,
         UserActionService userActionService,
         IValidationService validationService,
         IDataClient dataClient,
-        IAppMetadata appMetadata
+        IAppMetadata appMetadata,
+        ModelSerializationService modelSerialization
     )
     {
         _authorization = authorization;
@@ -58,12 +54,13 @@ IAppMetadata appMetadata
         _validationService = validationService;
         _dataClient = dataClient;
         _appMetadata = appMetadata;
+        _modelSerialization = modelSerialization;
     }
 
     /// <summary>
     /// Perform a task action on an instance
     /// </summary>
-    /// <param name="org">unique identfier of the organisation responsible for the app</param>
+    /// <param name="org">unique identifier of the organisation responsible for the app</param>
     /// <param name="app">application identifier which is unique within an organisation</param>
     /// <param name="instanceOwnerPartyId">unique id of the party that this the owner of the instance</param>
     /// <param name="instanceGuid">unique id to identify the instance</param>
@@ -129,8 +126,9 @@ public async Task<ActionResult<UserActionResponse>> Perform(
             return Forbid();
         }
 
+        var dataAccessor = new CachedInstanceDataAccessor(instance, _dataClient, _appMetadata, _modelSerialization);
         UserActionContext userActionContext =
-            new(instance, userId.Value, actionRequest.ButtonId, actionRequest.Metadata, language);
+            new(dataAccessor, userId.Value, actionRequest.ButtonId, actionRequest.Metadata, language);
         IUserAction? actionHandler = _userActionService.GetActionHandler(action);
         if (actionHandler == null)
         {
@@ -162,105 +160,103 @@ public async Task<ActionResult<UserActionResponse>> Perform(
             );
         }
 
+        // If the action handler returns UpdatedDataModels, instead of using the dataMutator
+        // we need to update the dataAccessor with the new data in case it was fetched with DataClient
+#pragma warning disable CS0618 // Type or member is obsolete
         if (result.UpdatedDataModels is { Count: > 0 })
         {
-            await SaveChangedModels(instance, result.UpdatedDataModels);
+            foreach (var (elementId, newModel) in result.UpdatedDataModels)
+            {
+                if (newModel is null)
+                {
+                    continue;
+                }
+
+                var dataElement =
+                    instance.Data.First(d => d.Id.Equals(elementId, StringComparison.OrdinalIgnoreCase))
+                    ?? throw new InvalidOperationException(
+                        $"Action handler {actionHandler.GetType().Name} returned an updated data model for a data element that does not exist: {elementId}"
+                    );
+
+                // update dataAccessor to use the changed data
+                dataAccessor.ReplaceFormDataAssumeSavedToStorage(dataElement, newModel);
+            }
         }
+#pragma warning restore CS0618 // Type or member is obsolete
+
+        var changes = dataAccessor.GetDataElementChanges(initializeAltinnRowId: true);
+
+        await dataAccessor.UpdateInstanceData();
+
+        var saveTask = dataAccessor.SaveChanges(changes);
+
+        var validationIssues = await GetIncrementalValidations(
+            instance,
+            dataAccessor,
+            changes,
+            actionRequest.IgnoredValidators,
+            language
+        );
+        await saveTask;
 
-        return new OkObjectResult(
+        return Ok(
             new UserActionResponse()
             {
                 ClientActions = result.ClientActions,
-                UpdatedDataModels = result.UpdatedDataModels,
-                UpdatedValidationIssues = await GetValidations(
-                    instance,
-                    result.UpdatedDataModels,
-                    actionRequest.IgnoredValidators,
-                    language
-                ),
+                UpdatedDataModels = changes.ToDictionary(c => c.DataElement.Id, c => c.CurrentFormData),
+                UpdatedValidationIssues = validationIssues,
                 RedirectUrl = result.RedirectUrl,
             }
         );
     }
 
-    private async Task SaveChangedModels(Instance instance, Dictionary<string, object> resultUpdatedDataModels)
-    {
-        var instanceIdentifier = new InstanceIdentifier(instance);
-        foreach (var (elementId, newModel) in resultUpdatedDataModels)
-        {
-            if (newModel is null)
-            {
-                continue;
-            }
-
-            ObjectUtils.InitializeAltinnRowId(newModel);
-            ObjectUtils.PrepareModelForXmlStorage(newModel);
-
-            var dataElement = instance.Data.First(d => d.Id.Equals(elementId, StringComparison.OrdinalIgnoreCase));
-            await _dataClient.UpdateData(
-                newModel,
-                instanceIdentifier.InstanceGuid,
-                newModel.GetType(),
-                instance.Org,
-                instance.AppId.Split('/')[1],
-                instanceIdentifier.InstanceOwnerPartyId,
-                Guid.Parse(dataElement.Id)
-            );
-        }
-    }
-
-    private async Task<Dictionary<string, Dictionary<string, List<ValidationIssue>>>?> GetValidations(
+    private async Task<Dictionary<
+        string,
+        Dictionary<string, List<ValidationIssueWithSource>>
+    >?> GetIncrementalValidations(
         Instance instance,
-        Dictionary<string, object>? resultUpdatedDataModels,
+        IInstanceDataAccessor dataAccessor,
+        List<DataElementChange> changes,
         List<string>? ignoredValidators,
         string? language
     )
     {
-        if (resultUpdatedDataModels is null || resultUpdatedDataModels.Count < 1)
-        {
-            return null;
-        }
-
-        var instanceIdentifier = new InstanceIdentifier(instance);
-        var application = await _appMetadata.GetApplicationMetadata();
+        var taskId = instance.Process.CurrentTask.ElementId;
+        var validationIssues = await _validationService.ValidateIncrementalFormData(
+            instance,
+            dataAccessor,
+            taskId,
+            changes,
+            ignoredValidators,
+            language
+        );
 
-        var updatedValidationIssues = new Dictionary<string, Dictionary<string, List<ValidationIssue>>>();
+        // For historical reasons the validation issues from actions controller is separated per data element
+        // The easiest way was to keep this behaviour to improve compatibility with older frontend versions
+        return PartitionValidationIssuesByDataElement(validationIssues);
+    }
 
-        // TODO: Consider validating models in parallel
-        foreach (var (elementId, newModel) in resultUpdatedDataModels)
+    private static Dictionary<
+        string,
+        Dictionary<string, List<ValidationIssueWithSource>>
+    > PartitionValidationIssuesByDataElement(List<ValidationSourcePair> validationIssues)
+    {
+        var updatedValidationIssues = new Dictionary<string, Dictionary<string, List<ValidationIssueWithSource>>>();
+        foreach (var (validationSource, issuesFromSource) in validationIssues)
         {
-            if (newModel is null)
+            foreach (var issue in issuesFromSource)
             {
-                continue;
-            }
-
-            var dataElement = instance.Data.First(d => d.Id.Equals(elementId, StringComparison.OrdinalIgnoreCase));
-            var dataType = application.DataTypes.First(d =>
-                d.Id.Equals(dataElement.DataType, StringComparison.OrdinalIgnoreCase)
-            );
-
-            // TODO: Consider rewriting so that we get the original data the IUserAction have requested instead of fetching it again
-            var oldData = await _dataClient.GetFormData(
-                instanceIdentifier.InstanceGuid,
-                newModel.GetType(),
-                instance.Org,
-                instance.AppId.Split('/')[1],
-                instanceIdentifier.InstanceOwnerPartyId,
-                Guid.Parse(dataElement.Id)
-            );
-
-            var validationIssues = await _validationService.ValidateFormData(
-                instance,
-                dataElement,
-                dataType,
-                newModel,
-                oldData,
-                ignoredValidators,
-                language
-            );
-            if (validationIssues.Count > 0)
-            {
-                updatedValidationIssues.Add(elementId, validationIssues);
+                if (!updatedValidationIssues.TryGetValue(issue.DataElementId ?? "", out var elementIssues))
+                {
+                    elementIssues = [];
+                    updatedValidationIssues[issue.DataElementId ?? ""] = elementIssues;
+                }
+                if (!elementIssues.TryGetValue(validationSource, out var sourceIssues))
+                {
+                    sourceIssues = [];
+                    elementIssues[validationSource] = sourceIssues;
+                }
+                sourceIssues.Add(issue);
             }
         }