chore: upgrade script for next + rewriting RuleConfiguration to C# + expressions

src/App/backend/src/Altinn.App.Analyzers/SourceTextGenerator/SetterGenerator.cs

@@ -0,0 +1,147 @@
+using System.Text;
+
+namespace Altinn.App.Analyzers.SourceTextGenerator;
+
+internal static class SetterGenerator
+{
+    public static void Generate(StringBuilder builder, ModelPathNode rootNode)
+    {
+        if (rootNode.Properties.Count == 0)
+        {
+            builder.Append(
+                """
+
+                    /// <inheritdoc />
+                    public bool Set(global::System.ReadOnlySpan<char> path, object? value) => false;
+
+                """
+            );
+            return;
+        }
+        builder.Append(
+            """
+
+                /// <inheritdoc />
+                public bool Set(global::System.ReadOnlySpan<char> path, object? value)
+                {
+                    if (path.IsEmpty)
+                    {
+                        return false;
+                    }
+
+                    return SetRecursive(_dataModel, path, 0, value);
+                }
+
+            """
+        );
+
+        GenerateRecursive(builder, rootNode, new HashSet<string>(StringComparer.Ordinal));
+    }
+
+    private static void GenerateRecursive(
+        StringBuilder builder,
+        ModelPathNode modelPathNode,
+        HashSet<string> generatedTypes
+    )
+    {
+        if (modelPathNode.ListType != null && generatedTypes.Add(modelPathNode.ListType))
+        {
+            builder.Append(
+                $$"""
+
+                    private static bool SetRecursive(
+                        {{modelPathNode.ListType}}? model,
+                        global::System.ReadOnlySpan<char> path,
+                        int literalIndex,
+                        int offset,
+                        object? value
+                    )
+                    {
+                        if (model is null || literalIndex < 0 || literalIndex >= model.Count)
+                        {
+                            return false;
+                        }
+
+                        {{(
+                    modelPathNode.Properties.Count == 0
+                        ? GenerateListElementSet(modelPathNode)
+                        : "return SetRecursive(model[literalIndex], path, offset, value);"
+                )}}
+                    }
+
+                """
+            );
+        }
+        if (modelPathNode.IsJsonValueType || !generatedTypes.Add(modelPathNode.TypeName))
+        {
+            // Do not generate recursive setters for primitive types, or types already generated
+            return;
+        }
+
+        builder.Append(
+            $$"""
+
+                private static bool SetRecursive(
+                    {{modelPathNode.TypeName}}? model,
+                    global::System.ReadOnlySpan<char> path,
+                    int offset,
+                    object? value
+                )
+                {
+                    if (model is null || offset == -1)
+                    {
+                        return false;
+                    }
+
+                    return ParseSegment(path, offset, out int nextOffset, out int literalIndex) switch
+                    {
+
+            """
+        );
+        foreach (var child in modelPathNode.Properties)
+        {
+            builder.Append(
+                child switch
+                {
+                    { ListType: not null } =>
+                        $"            \"{child.JsonName}\" => SetRecursive(model.{child.CSharpName}, path, literalIndex, nextOffset, value),\r\n",
+                    { Properties.Count: 0 } =>
+                        $"            \"{child.JsonName}\" when nextOffset is -1 && literalIndex is -1 => TrySetValue(val => model.{child.CSharpName} = val, value),\r\n",
+                    _ =>
+                        $"            \"{child.JsonName}\" when literalIndex is -1 => SetRecursive(model.{child.CSharpName}, path, nextOffset, value),\r\n",
+                }
+            );
+        }
+
+        // Return false for unknown paths
+        builder.Append(
+            """
+                        _ => false,
+                    };
+                }
+
+            """
+        );
+
+        foreach (var child in modelPathNode.Properties)
+        {
+            GenerateRecursive(builder, child, generatedTypes);
+        }
+    }
+
+    private static string GenerateListElementSet(ModelPathNode modelPathNode)
+    {
+        // For list elements that are primitives, we need to handle the set differently
+        // Extract the element type from the list type (e.g., "List<int>" -> "int")
+        var elementType = modelPathNode.TypeName;
+
+        return @"if (offset == -1)
+                        {
+                            return TrySetValue<"
+            + elementType
+            + @">(val => model[literalIndex] = val, value);
+                        }
+                        return false;
+";
+    }
+}

src/App/backend/src/Altinn.App.Analyzers/SourceTextGenerator/SourceTextGenerator.cs

@@ -53,6 +53,9 @@ dataModel as {{rootNode.TypeName}}
         builder.Append("\r\n    #region Getters\r\n");
         GetterGenerator.Generate(builder, rootNode);
         builder.Append("\r\n    #endregion Getters\r\n");
+        builder.Append("    #region Setters\r\n");
+        SetterGenerator.Generate(builder, rootNode);
+        builder.Append("\r\n    #endregion Setters\r\n");
         builder.Append("    #region AddIndexToPath\r\n");
         AddIndexToPathGenerator.Generate(builder, rootNode);
         builder.Append("\r\n    #endregion AddIndexToPath\r\n");
@@ -68,6 +71,96 @@ dataModel as {{rootNode.TypeName}}
 
         builder.Append(
             $$"""
+                private static bool TrySetValue<T>(global::System.Action<T> setter, object? value)
+                {
+                    if (value is null)
+                    {
+                        if (typeof(T).IsValueType && global::System.Nullable.GetUnderlyingType(typeof(T)) is null)
+                        {
+                            return false;
+                        }
+                        setter(default(T)!);
+                        return true;
+                    }
+
+                    if (value is T typedValue)
+                    {
+                        setter(typedValue);
+                        return true;
+                    }
+
+                    try
+                    {
+                        var targetType = typeof(T);
+                        var underlyingType = global::System.Nullable.GetUnderlyingType(targetType);
+                        if (underlyingType is not null)
+                        {
+                            targetType = underlyingType;
+                        }
+
+                        if (targetType == typeof(string))
+                        {
+                            setter((T)(object)value.ToString()!);
+                            return true;
+                        }
+
+                        if (targetType == typeof(int))
+                        {
+                            setter((T)(object)global::System.Convert.ToInt32(value, global::System.Globalization.CultureInfo.InvariantCulture));
+                            return true;
+                        }
+
+                        if (targetType == typeof(long))
+                        {
+                            setter((T)(object)global::System.Convert.ToInt64(value, global::System.Globalization.CultureInfo.InvariantCulture));
+                            return true;
+                        }
+
+                        if (targetType == typeof(decimal))
+                        {
+                            setter((T)(object)global::System.Convert.ToDecimal(value, global::System.Globalization.CultureInfo.InvariantCulture));
+                            return true;
+                        }
+
+                        if (targetType == typeof(double))
+                        {
+                            setter((T)(object)global::System.Convert.ToDouble(value, global::System.Globalization.CultureInfo.InvariantCulture));
+                            return true;
+                        }
+
+                        if (targetType == typeof(float))
+                        {
+                            setter((T)(object)global::System.Convert.ToSingle(value, global::System.Globalization.CultureInfo.InvariantCulture));
+                            return true;
+                        }
+
+                        if (targetType == typeof(bool))
+                        {
+                            setter((T)(object)global::System.Convert.ToBoolean(value, global::System.Globalization.CultureInfo.InvariantCulture));
+                            return true;
+                        }
+
+                        if (targetType == typeof(global::System.DateTime))
+                        {
+                            setter((T)(object)global::System.Convert.ToDateTime(value, global::System.Globalization.CultureInfo.InvariantCulture));
+                            return true;
+                        }
+
+                        if (targetType.IsEnum)
+                        {
+                            setter((T)global::System.Enum.Parse(targetType, value.ToString() ?? string.Empty));
+                            return true;
+                        }
+
+                        setter((T)global::System.Convert.ChangeType(value, targetType, global::System.Globalization.CultureInfo.InvariantCulture));
+                        return true;
+                    }
+                    catch
+                    {
+                        return false;
+                    }
+                }
+
                 public static global::System.ReadOnlySpan<char> ParseSegment(global::System.ReadOnlySpan<char> path, int offset, out int nextOffset, out int literalIndex)
                 {
                     if (offset < 0 || offset > path.Length)

src/App/backend/src/Altinn.App.Core/Internal/Data/IFormDataWrapper.cs

@@ -37,6 +37,14 @@
     /// <param name="path">The dotted path to use (including inline indexes)</param>
     object? Get(ReadOnlySpan<char> path);
 
+    /// <summary>
+    /// Set the value at the given path in the data model
+    /// </summary>
+    /// <param name="path">The dotted path to use (including inline indexes)</param>
+    /// <param name="value">The value to set (will be automatically converted to the target type if possible)</param>
+    /// <returns>True if the value was set successfully, false if the path could not be resolved or type conversion failed</returns>
+    bool Set(ReadOnlySpan<char> path, object? value);
+
     /// <summary>
     /// Remove the field at the given path
     /// If the path points to a row (last segment is a list with an explicit [index]), the row will be removed or set to null based on rowRemovalOption
@@ -128,6 +136,37 @@
         }
     }
 
+    /// <summary>
+    /// Simple way to set a value in the form data model adding indexes from context
+    /// </summary>
+    /// <returns>True if the value was set successfully, false if the path could not be resolved or type conversion failed</returns>
+    public static bool Set(
+        this IFormDataWrapper formDataWrapper,
+        ReadOnlySpan<char> path,
+        object? value,
+        ReadOnlySpan<int> rowIndexes = default
+    )
+    {
+        int len = GetMaxBufferLength(path, rowIndexes);
+        if (len <= 512)
+        {
+            Span<char> buffer = stackalloc char[len];
+            var indexedPath = formDataWrapper.AddIndexToPath(path, rowIndexes, buffer);
+            return indexedPath.IsEmpty ? false : formDataWrapper.Set(indexedPath, value);
+        }
+
+        char[] pool = System.Buffers.ArrayPool<char>.Shared.Rent(len);
+        try
+        {
+            var indexedPath = formDataWrapper.AddIndexToPath(path, rowIndexes, pool);
+            return indexedPath.IsEmpty ? false : formDataWrapper.Set(indexedPath, value);
+        }
+        finally
+        {
+            System.Buffers.ArrayPool<char>.Shared.Return(pool);
+        }
+    }
+
     /// <summary>
     /// Get a string representation of the path with indexes from context added
     /// </summary>