Multipart form data

cli-tools/altinn-app-cli/Program.cs

@@ -1,4 +1,4 @@
-using System.CommandLine;
+using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.Reflection;
 using altinn_app_cli.v7Tov8.AppSettingsRewriter;
@@ -180,12 +180,20 @@ static async Task<int> UpgradeCode(string projectFile)
             {
                 await File.WriteAllTextAsync(sourceTree.FilePath, newSource.ToFullString());
             }
+
             UsingRewriter usingRewriter = new();
             var newUsingSource = usingRewriter.Visit(newSource);
             if (newUsingSource != newSource)
             {
                 await File.WriteAllTextAsync(sourceTree.FilePath, newUsingSource.ToFullString());
             }
+
+            DataProcessorRewriter dataProcessorRewriter = new(sm);
+            var dataProcessorSource = dataProcessorRewriter.Visit(newUsingSource);
+            if (dataProcessorSource != newUsingSource)
+            {
+                await File.WriteAllTextAsync(sourceTree.FilePath, dataProcessorSource.ToFullString());
+            }
         }
 
         Console.WriteLine("References and using upgraded");

cli-tools/altinn-app-cli/altinn-app-cli.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <RootNamespace>altinn_app_cli</RootNamespace>
     <LangVersion>latest</LangVersion>
     <ImplicitUsings>enable</ImplicitUsings>
@@ -31,7 +31,7 @@
     <MinVerDefaultPreReleaseIdentifiers>preview.0</MinVerDefaultPreReleaseIdentifiers>
     <MinVerTagPrefix>altinn-app-cli</MinVerTagPrefix>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <LangVersion>10.0</LangVersion>
+    <LangVersion>12</LangVersion>
   </PropertyGroup>
 
   <Target Name="AssemblyVersionTarget" AfterTargets="MinVer" Condition="'$(MinVerVersion)'!=''">

cli-tools/altinn-app-cli/v7Tov8/CodeRewriters/IDataProcessorRewriter.cs

@@ -0,0 +1,179 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace altinn_app_cli.v7Tov8.CodeRewriters
+{
+    public class DataProcessorRewriter : CSharpSyntaxRewriter
+    {
+        private readonly SemanticModel semanticModel;
+
+        public DataProcessorRewriter(SemanticModel semanticModel)
+        {
+            this.semanticModel = semanticModel;
+        }
+
+        public override SyntaxNode? VisitClassDeclaration(ClassDeclarationSyntax node)
+        {
+            // Ignore any classes that don't implement `IDataProcessor` (consider using semantic model to ensure correct reference)
+            if (node.BaseList?.Types.Any(t => t.Type.ToString() == "IDataProcessor") == true)
+            {
+                var processDataWrite = node.Members.OfType<MethodDeclarationSyntax>()
+                    .FirstOrDefault(m => m.Identifier.ValueText == "ProcessDataWrite");
+                if (processDataWrite is not null)
+                {
+                    node = node.ReplaceNode(processDataWrite, Update_DataProcessWrite(processDataWrite));
+                }
+
+                var processDataRead = node.Members.OfType<MethodDeclarationSyntax>()
+                    .FirstOrDefault(m => m.Identifier.ValueText == "ProcessDataRead");
+                if (processDataRead is not null)
+                {
+                    node = node.ReplaceNode(processDataRead, Update_DataProcessRead(processDataRead));
+                }
+            }
+
+            return base.VisitClassDeclaration(node);
+        }
+
+        private MethodDeclarationSyntax Update_DataProcessRead(MethodDeclarationSyntax processDataRead)
+        {
+            if (processDataRead.ParameterList.Parameters.Count == 3 &&
+                processDataRead.ReturnType.ToString() == "Task<bool>")
+            {
+                processDataRead = ChangeReturnType_FromTaskBool_ToTask(processDataRead);
+            }
+
+            return processDataRead;
+        }
+
+        private MethodDeclarationSyntax Update_DataProcessWrite(MethodDeclarationSyntax processDataWrite)
+        {
+            if (processDataWrite.ParameterList.Parameters.Count == 3 &&
+                processDataWrite.ReturnType.ToString() == "Task<bool>")
+            {
+                processDataWrite = AddParameter_ChangedFields(processDataWrite);
+                processDataWrite = ChangeReturnType_FromTaskBool_ToTask(processDataWrite);
+            }
+
+            return processDataWrite;
+        }
+
+        private MethodDeclarationSyntax AddParameter_ChangedFields(MethodDeclarationSyntax method)
+        {
+            return method.ReplaceNode(method.ParameterList,
+                method.ParameterList.AddParameters(SyntaxFactory.Parameter(SyntaxFactory.Identifier("changedFields"))
+                    .WithLeadingTrivia(SyntaxFactory.Space)
+                    .WithType(SyntaxFactory.ParseTypeName("System.Collections.Generic.Dictionary<string, string?>?"))
+                    .WithLeadingTrivia(SyntaxFactory.Space)));
+        }
+
+        private MethodDeclarationSyntax ChangeReturnType_FromTaskBool_ToTask(MethodDeclarationSyntax method)
+        {
+            if (method.ReturnType.ToString() == "Task<bool>")
+            {
+                var returnTypeRewriter = new ReturnTypeTaskBooleanRewriter();
+                method = (MethodDeclarationSyntax)returnTypeRewriter.Visit(method)!;
+            }
+
+            return method;
+
+        }
+    }
+
+    public class ReturnTypeTaskBooleanRewriter : CSharpSyntaxRewriter
+    {
+        public override SyntaxNode? VisitMethodDeclaration(MethodDeclarationSyntax node)
+        {
+            if (node.ReturnType.ToString() == "Task<bool>")
+            {
+                // Change return type
+                node = node.WithReturnType(
+                    SyntaxFactory.ParseTypeName("Task").WithTrailingTrivia(SyntaxFactory.Space));
+            }
+            return base.VisitMethodDeclaration(node);
+        }
+
+        public override SyntaxNode? VisitBlock(BlockSyntax node)
+        {
+            foreach (var returnStatementSyntax in node.Statements.OfType<ReturnStatementSyntax>())
+            {
+                var leadingTrivia = returnStatementSyntax.GetLeadingTrivia();
+                var trailingTrivia = returnStatementSyntax.GetTrailingTrivia();
+                // When we add multiple lines of code, we need the indentation and a newline
+                var leadingTriviaMiddle = leadingTrivia.LastOrDefault(t => t.IsKind(SyntaxKind.WhitespaceTrivia));
+                var trailingTriviaMiddle = trailingTrivia.FirstOrDefault(t => t.IsKind(SyntaxKind.EndOfLineTrivia));
+                // If we don't find a newline, just guess that LF is used. Will likely work anyway.
+                if (trailingTriviaMiddle == default) trailingTriviaMiddle = SyntaxFactory.LineFeed; 
+
+
+                switch (returnStatementSyntax.Expression)
+                {
+                    // return true/false/variableName
+                    case IdentifierNameSyntax:
+                    case LiteralExpressionSyntax:
+                    case null:
+                        node = node.ReplaceNode(returnStatementSyntax,
+                            SyntaxFactory.ReturnStatement()
+                                .WithLeadingTrivia(leadingTrivia).WithTrailingTrivia(trailingTrivia));
+                        break;
+                    // case "Task.FromResult(...)":
+                    case InvocationExpressionSyntax
+                    {
+                        Expression: MemberAccessExpressionSyntax
+                        {
+                            Expression: IdentifierNameSyntax { Identifier: {Text: "Task" } },
+                            Name: { Identifier: {Text: "FromResult"}}
+                        },
+                        ArgumentList: { Arguments: { Count: 1 } }
+                    }:
+                        node = node.ReplaceNode(returnStatementSyntax,
+                            SyntaxFactory.ReturnStatement(SyntaxFactory.ParseExpression(" Task.CompletedTask"))
+                                .WithLeadingTrivia(leadingTrivia).WithTrailingTrivia(trailingTrivia));
+                        break;
+                    // case "await Task.FromResult(...)":
+                    // Assume we need an await to silence CS1998 and rewrite to 
+                    // await Task.CompletedTask; return;
+                    // Could be dropped if we ignore CS1998
+                    case AwaitExpressionSyntax
+                    {
+                        Expression: InvocationExpressionSyntax
+                        {
+                            Expression: MemberAccessExpressionSyntax
+                            {
+                                Expression: IdentifierNameSyntax { Identifier: {Text: "Task" } },
+                                Name: { Identifier: {Text: "FromResult"}}
+                            },
+                            ArgumentList: { Arguments:  [{Expression: IdentifierNameSyntax or LiteralExpressionSyntax}]}
+                        }
+                    }:
+                        node = node.WithStatements(node.Statements.ReplaceRange(returnStatementSyntax, new StatementSyntax[]
+                        { 
+                            // Uncomment if cs1998 isn't disabled
+                            // SyntaxFactory.ParseStatement("await Task.CompletedTask;")
+                            //     .WithLeadingTrivia(leadingTrivia).WithTrailingTrivia(trailingTriviaMiddle),
+
+                            SyntaxFactory.ReturnStatement()
+                                .WithLeadingTrivia(leadingTriviaMiddle).WithTrailingTrivia(trailingTrivia),
+
+                        }));
+                        break;
+                    // Just add move the return; statement after the existing return value
+                    default:
+                        node = node.WithStatements(node.Statements.ReplaceRange(returnStatementSyntax,
+                            new StatementSyntax[]
+                        {
+                            SyntaxFactory.ExpressionStatement(returnStatementSyntax.Expression)
+                                .WithLeadingTrivia(leadingTrivia).WithTrailingTrivia(trailingTriviaMiddle),
+
+                            SyntaxFactory.ReturnStatement()
+                                .WithLeadingTrivia(leadingTriviaMiddle).WithTrailingTrivia(trailingTrivia),
+                        }));
+                        break;
+                }
+            }
+
+            return base.VisitBlock(node);
+        }
+    }
+}

cli-tools/altinn-app-cli/v7Tov8/ProjectRewriters/ProjectFileRewriter.cs

@@ -21,12 +21,36 @@ public ProjectFileRewriter(string projectFilePath, string targetVersion = "8.0.0
     public async Task Upgrade()
     {
         var altinnAppCoreElements = GetAltinnAppCoreElement();
+        altinnAppCoreElements?.ForEach(c => c.Attribute("Version")?.SetValue(targetVersion));
+
         var altinnAppApiElements = GetAltinnAppApiElement();
-        if (altinnAppCoreElements != null && altinnAppApiElements != null)
+        altinnAppApiElements?.ForEach(a => a.Attribute("Version")?.SetValue(targetVersion));
+
+        IgnoreWarnings("1591", "1998"); // Require xml doc and await in async methods
+
+        await Save();
+    }
+
+    private void IgnoreWarnings(params string[] warnings)
+    {
+        var noWarn = doc.Root?.Elements("PropertyGroup").Elements("NoWarn").ToList();
+        switch (noWarn?.Count)
         {
-            altinnAppCoreElements.ForEach(c => c.Attribute("Version")?.SetValue(targetVersion));
-            altinnAppApiElements.ForEach(a => a.Attribute("Version")?.SetValue(targetVersion));
-            await Save();
+            case 0:
+                doc.Root?.Elements("PropertyGroup").First().Add(new XElement("NoWarn", "$(NoWarn);" + string.Join(';', warnings)));
+                break;
+
+            case 1:
+                var valueElement = noWarn.First();
+                foreach (var warning in warnings)
+                {
+                    if (!valueElement.Value.Contains(warning))
+                    {
+                        valueElement.SetValue($"{valueElement.Value};{warning}");
+                    }
+                }
+
+                break;
         }
     }
 

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

@@ -39,7 +39,7 @@ public class DataController : ControllerBase
     {
         private readonly ILogger<DataController> _logger;
         private readonly IDataClient _dataClient;
-        private readonly IDataProcessor _dataProcessor;
+        private readonly IEnumerable<IDataProcessor> _dataProcessors;
         private readonly IInstanceClient _instanceClient;
         private readonly IInstantiationProcessor _instantiationProcessor;
         private readonly IAppModel _appModel;
@@ -58,7 +58,7 @@ public class DataController : ControllerBase
         /// <param name="instanceClient">instance service to store instances</param>
         /// <param name="instantiationProcessor">Instantiation processor</param>
         /// <param name="dataClient">A service with access to data storage.</param>
-        /// <param name="dataProcessor">Serive implemnting logic during data read/write</param>
+        /// <param name="dataProcessors">Serive implemnting logic during data read/write</param>
         /// <param name="appModel">Service for generating app model</param>
         /// <param name="appResourcesService">The apps resource service</param>
         /// <param name="appMetadata">The app metadata service</param>
@@ -71,7 +71,7 @@ public DataController(
             IInstanceClient instanceClient,
             IInstantiationProcessor instantiationProcessor,
             IDataClient dataClient,
-            IDataProcessor dataProcessor,
+            IEnumerable<IDataProcessor> dataProcessors,
             IAppModel appModel,
             IAppResources appResourcesService,
             IPrefill prefillService,
@@ -85,7 +85,7 @@ public DataController(
             _instanceClient = instanceClient;
             _instantiationProcessor = instantiationProcessor;
             _dataClient = dataClient;
-            _dataProcessor = dataProcessor;
+            _dataProcessors = dataProcessors;
             _appModel = appModel;
             _appResourcesService = appResourcesService;
             _appMetadata = appMetadata;
@@ -175,7 +175,7 @@ public async Task<ActionResult> Create(
                         _logger.LogError(errorMessage);
                         return BadRequest(await GetErrorDetails(new List<ValidationIssue> { error }));
                     }
-                    
+
                     bool parseSuccess = Request.Headers.TryGetValue("Content-Disposition", out StringValues headerValues);
                     string? filename = parseSuccess ? DataRestrictionValidation.GetFileNameFromHeader(headerValues) : null;
 
@@ -584,7 +584,11 @@ private async Task<ActionResult> GetFormData(
                 return BadRequest($"Did not find form data for data element {dataGuid}");
             }
 
-            await _dataProcessor.ProcessDataRead(instance, dataGuid, appModel);
+            foreach (var dataProcessor in _dataProcessors)
+            {
+                _logger.LogInformation("ProcessDataRead for {modelType} using {dataProcesor}", appModel.GetType().Name, dataProcessor.GetType().Name);
+                await dataProcessor.ProcessDataRead(instance, dataGuid, appModel);
+            }
 
             string? userOrgClaim = User.GetOrg();
             if (userOrgClaim == null || !org.Equals(userOrgClaim, StringComparison.InvariantCultureIgnoreCase))
@@ -625,16 +629,7 @@ private async Task<ActionResult> PutFormData(string org, string app, Instance in
                 return BadRequest(deserializerResult.Error);
             }
 
-            Dictionary<string, object?>? changedFields = null;
-            if (deserializerResult.ReportedChanges is not null)
-            {
-                //TODO: call new and old dataProcessors
-                changedFields = await JsonHelper.ProcessDataWriteWithDiff(instance, dataGuid, deserializerResult.Model, _dataProcessor, _logger);
-            }
-            else
-            {
-                changedFields = await JsonHelper.ProcessDataWriteWithDiff(instance, dataGuid, deserializerResult.Model, _dataProcessor, _logger);
-            }
+            Dictionary<string, object?>? changedFields = await JsonHelper.ProcessDataWriteWithDiff(instance, dataGuid, deserializerResult.Model, _dataProcessors, deserializerResult.ReportedChanges, _logger);
 
             await UpdatePresentationTextsOnInstance(instance, dataType, deserializerResult.Model);
             await UpdateDataValuesOnInstance(instance, dataType, deserializerResult.Model);