Set data field by expression

src/Altinn.App.Core/Configuration/AppSettings.cs

@@ -8,14 +8,19 @@ public class AppSettings
 {
 #pragma warning disable CA1707 // Identifiers should not contain underscores
     /// <summary>
-    /// Constant for the location of json schema file
+    /// Constant for the suffix on json schema file names
     /// </summary>
     public const string JSON_SCHEMA_FILENAME = "schema.json";
 
     /// <summary>
-    /// Constant for the location of validation configuration file
+    /// Constant for the suffix on validation file names
     /// </summary>
     public const string VALIDATION_CONFIG_FILENAME = "validation.json";
+
+    /// <summary>
+    /// Constant for the suffix on calculation file names
+    /// </summary>
+    public const string CALCULATION_CONFIG_FILENAME = "calculation.json";
 #pragma warning restore CA1707 // Identifiers should not contain underscores
 
     /// <summary>
@@ -95,15 +100,20 @@ public class AppSettings
     public string RuleConfigurationJSONFileName { get; set; } = "RuleConfiguration.json";
 
     /// <summary>
-    /// Gets or sets The JSON schema file name
+    /// Gets or sets the file names suffix for the json schema files
     /// </summary>
     public string JsonSchemaFileName { get; set; } = JSON_SCHEMA_FILENAME;
 
     /// <summary>
-    /// Gets or sets The JSON schema file name
+    /// Gets or sets the file names suffix for the validation files
     /// </summary>
     public string ValidationConfigurationFileName { get; set; } = VALIDATION_CONFIG_FILENAME;
 
+    /// <summary>
+    /// Gets or sets the file names suffix for the calculation files
+    /// </summary>
+    public string CalculationConfigurationFileName { get; set; } = CALCULATION_CONFIG_FILENAME;
+
     /// <summary>
     /// Gets or sets the filename for application meta data
     /// </summary>

src/Altinn.App.Core/Extensions/ServiceCollectionExtensions.cs

@@ -182,13 +182,15 @@
 #pragma warning restore CS0618, CS0612 // Type or member is obsolete
         services.TryAddTransient<IInstantiationProcessor, NullInstantiationProcessor>();
         services.TryAddTransient<IInstantiationValidator, NullInstantiationValidator>();
+        services.TryAddTransient<DataFieldValueCalculator>();
         services.TryAddTransient<IAppModel, DefaultAppModel>();
         services.TryAddTransient<DataListsFactory>();
         services.TryAddTransient<InstanceDataListsFactory>();
         services.TryAddTransient<IDataElementAccessChecker, DataElementAccessChecker>();
         services.TryAddTransient<IDataListsService, DataListsService>();
         services.TryAddTransient<ILayoutEvaluatorStateInitializer, LayoutEvaluatorStateInitializer>();
         services.TryAddTransient<LayoutEvaluatorStateInitializer>();
+        services.AddTransient<IDataWriteProcessor, DataFieldValueCalculatorProcessor>();
         services.AddSingleton<IAuthenticationTokenResolver, AuthenticationTokenResolver>();
         services.AddTransient<IDataService, DataService>();
         services.AddSingleton<ModelSerializationService>();
@@ -263,7 +265,7 @@
         services.AddTransient<IEventHandlerResolver, EventHandlerResolver>();
         services.TryAddSingleton<IEventSecretCodeProvider, KeyVaultEventSecretCodeProvider>();
 
         // TODO: Event subs could be handled by the new automatic Maskinporten auth, once implemented.
         // The event subscription client depends upon a Maskinporten message handler being
         // added to the client during setup. As of now this needs to be done in the apps
         // if subscription is to be added. This registration is to prevent the DI container

src/Altinn.App.Core/Features/DataLists/InstanceDataListsFactory.cs

@@ -11,7 +11,7 @@
     private readonly AppImplementationFactory _appImplementationFactory;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="DataListsFactory"/> class.
+    /// Initializes a new instance of the <see cref="InstanceDataListsFactory"/> class.
     /// </summary>
     public InstanceDataListsFactory(IServiceProvider serviceProvider)
     {
@@ -26,7 +26,7 @@
     public IInstanceDataListProvider GetDataListProvider(string listId)
     {
         var instanceDataListProviders = _appImplementationFactory.GetAll<IInstanceDataListProvider>();
         foreach (var instanceDataListProvider in instanceDataListProviders)
         {
             if (instanceDataListProvider.Id.Equals(listId, StringComparison.OrdinalIgnoreCase))
             {

src/Altinn.App.Core/Features/DataProcessing/DataFieldValueCalculator.cs

@@ -0,0 +1,231 @@
+using System.Text.Json;
+using Altinn.App.Core.Internal.App;
+using Altinn.App.Core.Internal.Data;
+using Altinn.App.Core.Internal.Expressions;
+using Altinn.App.Core.Models;
+using Altinn.App.Core.Models.Layout;
+using Altinn.Platform.Storage.Interface.Models;
+using Microsoft.Extensions.Logging;
+using ComponentContext = Altinn.App.Core.Models.Expressions.ComponentContext;
+
+namespace Altinn.App.Core.Features.DataProcessing;
+
+internal sealed class DataFieldValueCalculator
+{
+    private static readonly JsonSerializerOptions _jsonSerializerOptions = new()
+    {
+        ReadCommentHandling = JsonCommentHandling.Skip,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    };
+
+    private readonly ILogger<DataFieldValueCalculator> _logger;
+    private readonly IAppResources _appResourceService;
+    private readonly ILayoutEvaluatorStateInitializer _layoutEvaluatorStateInitializer;
+    private readonly IDataElementAccessChecker _dataElementAccessChecker;
+    private readonly Telemetry? _telemetry;
+
+    public DataFieldValueCalculator(
+        ILogger<DataFieldValueCalculator> logger,
+        ILayoutEvaluatorStateInitializer layoutEvaluatorStateInitializer,
+        IAppResources appResourceService,
+        IDataElementAccessChecker dataElementAccessChecker,
+        Telemetry? telemetry
+    )
+    {
+        _logger = logger;
+        _appResourceService = appResourceService;
+        _layoutEvaluatorStateInitializer = layoutEvaluatorStateInitializer;
+        _dataElementAccessChecker = dataElementAccessChecker;
+        _telemetry = telemetry;
+    }
+
+    public async Task Calculate(IInstanceDataAccessor dataAccessor, string taskId)
+    {
+        using var activity = _telemetry?.StartCalculateActivity(dataAccessor.Instance.Id, taskId);
+        foreach (var (dataType, dataElement) in dataAccessor.GetDataElementsWithFormDataForTask(taskId))
+        {
+            if (await _dataElementAccessChecker.CanRead(dataAccessor.Instance, dataType) is false)
+            {
+                continue;
+            }
+
+            var calculationConfig = _appResourceService.GetCalculationConfiguration(dataType.Id);
+            if (!string.IsNullOrEmpty(calculationConfig))
+            {
+                await CalculateFormData(dataAccessor, dataElement, taskId, calculationConfig);
+            }
+        }
+    }
+
+    internal async Task CalculateFormData(
+        IInstanceDataAccessor dataAccessor,
+        DataElement dataElement,
+        string taskId,
+        string rawCalculationConfig
+    )
+    {
+        var evaluatorState = await _layoutEvaluatorStateInitializer.Init(dataAccessor, taskId);
+        var hiddenFields = await LayoutEvaluator.GetHiddenFieldsForRemoval(
+            evaluatorState,
+            evaluateRemoveWhenHidden: false
+        );
+        DataElementIdentifier dataElementIdentifier = dataElement;
+        var dataFieldCalculations = ParseDataFieldCalculationConfig(rawCalculationConfig, _logger);
+        var formDataWrapper = await dataAccessor.GetFormDataWrapper(dataElement);
+
+        foreach (var (baseField, calculations) in dataFieldCalculations)
+        {
+            var resolvedFields = await evaluatorState.GetResolvedKeys(
+                new DataReference() { Field = baseField, DataElementIdentifier = dataElementIdentifier },
+                true
+            );
+            foreach (var resolvedField in resolvedFields)
+            {
+                if (
+                    hiddenFields.Exists(d =>
+                        d.DataElementIdentifier == resolvedField.DataElementIdentifier
+                        && resolvedField.Field.StartsWith(d.Field, StringComparison.InvariantCulture)
+                    )
+                )
+                {
+                    continue;
+                }
+
+                var context = new ComponentContext(
+                    evaluatorState,
+                    component: null,
+                    rowIndices: ExpressionHelper.GetRowIndices(resolvedField.Field),
+                    dataElementIdentifier: resolvedField.DataElementIdentifier
+                );
+                var positionalArguments = new object[] { resolvedField.Field };
+                foreach (var calculation in calculations)
+                {
+                    await RunCalculation(
+                        formDataWrapper,
+                        evaluatorState,
+                        resolvedField,
+                        context,
+                        positionalArguments,
+                        calculation
+                    );
+                }
+            }
+        }
+    }
+
+    private async Task RunCalculation(
+        IFormDataWrapper formDataWrapper,
+        LayoutEvaluatorState evaluatorState,
+        DataReference resolvedField,
+        ComponentContext context,
+        object[] positionalArguments,
+        DataFieldCalculation calculation
+    )
+    {
+        try
+        {
+            var calculationResult = await ExpressionEvaluator.EvaluateExpressionToExpressionValue(
+                evaluatorState,
+                calculation.Condition,
+                context,
+                positionalArguments
+            );
+            if (!formDataWrapper.Set(resolvedField.Field, calculationResult))
+            {
+                _logger.LogWarning(
+                    "Could not set calculated value for field {Field} in data element {DataElementId}. "
+                        + "This is because the type conversion failed.",
+                    resolvedField.Field,
+                    resolvedField.DataElementIdentifier.Id
+                );
+            }
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Error while evaluating calculation for field {Field}", resolvedField.Field);
+            throw;
+        }
+    }
+
+    private Dictionary<string, List<DataFieldCalculation>> ParseDataFieldCalculationConfig(
+        string rawCalculationConfig,
+        ILogger<DataFieldValueCalculator> logger
+    )
+    {
+        using var calculationConfigDocument = JsonDocument.Parse(rawCalculationConfig);
+
+        var dataFieldCalculations = new Dictionary<string, List<DataFieldCalculation>>();
+        var hasCalculations = calculationConfigDocument.RootElement.TryGetProperty(
+            "calculations",
+            out JsonElement calculationsObject
+        );
+        if (hasCalculations)
+        {
+            foreach (var calculationArray in calculationsObject.EnumerateObject())
+            {
+                var field = calculationArray.Name;
+                var calculations = calculationArray.Value;
+                foreach (var calculation in calculations.EnumerateArray())
+                {
+                    if (!dataFieldCalculations.TryGetValue(field, out var dataFieldCalculation))
+                    {
+                        dataFieldCalculation = new List<DataFieldCalculation>();
+                        dataFieldCalculations[field] = dataFieldCalculation;
+                    }
+                    var resolvedDataFieldCalculation = ResolveDataFieldCalculation(field, calculation, logger);
+                    if (resolvedDataFieldCalculation == null)
+                    {
+                        logger.LogError("Calculation for field {Field} could not be resolved", field);
+                        continue;
+                    }
+                    dataFieldCalculation.Add(resolvedDataFieldCalculation);
+                }
+            }
+        }
+        return dataFieldCalculations;
+    }
+
+    private DataFieldCalculation? ResolveDataFieldCalculation(string field, JsonElement definition, ILogger logger)
+    {
+        var rawDataFieldValueCalculation = new RawDataFieldValueCalculation();
+
+        if (definition.ValueKind == JsonValueKind.String)
+        {
+            var stringReference = definition.GetString();
+            if (stringReference == null)
+            {
+                logger.LogError("Could not resolve null reference for calculation for field {Field}", field);
+                return null;
+            }
+        }
+        else
+        {
+            var dataFieldCalculationDefinition = definition.Deserialize<RawDataFieldValueCalculation>(
+                _jsonSerializerOptions
+            );
+            if (dataFieldCalculationDefinition == null)
+            {
+                logger.LogError("Calculation for field {Field} could not be parsed", field);
+                return null;
+            }
+
+            if (dataFieldCalculationDefinition.Condition != null)
+            {
+                rawDataFieldValueCalculation.Condition = dataFieldCalculationDefinition.Condition;
+            }
+        }
+
+        if (rawDataFieldValueCalculation.Condition == null)
+        {
+            logger.LogError("Calculation for field {Field} is missing condition", field);
+            return null;
+        }
+
+        var dataFieldCalculation = new DataFieldCalculation
+        {
+            Condition = rawDataFieldValueCalculation.Condition.Value,
+        };
+
+        return dataFieldCalculation;
+    }
+}

src/Altinn.App.Core/Features/DataProcessing/DataFieldValueCalculatorProcessor.cs

@@ -0,0 +1,37 @@
+using Altinn.App.Core.Models;
+
+namespace Altinn.App.Core.Features.DataProcessing;
+
+/// <summary>
+/// Processing data fields values that is calculated by expressions provided in [modelName].calculation.json.
+/// </summary>
+internal sealed class DataFieldValueCalculatorProcessor : IDataWriteProcessor
+{
+    private readonly DataFieldValueCalculator _dataFieldValueCalculator;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DataFieldValueCalculatorProcessor"/> class.
+    /// </summary>
+    /// <param name="dataFieldValueCalculator"></param>
+    public DataFieldValueCalculatorProcessor(DataFieldValueCalculator dataFieldValueCalculator)
+    {
+        _dataFieldValueCalculator = dataFieldValueCalculator;
+    }
+
+    /// <summary>
+    /// Processes data write operations on properties in the data model.
+    /// </summary>
+    /// <param name="instanceDataMutator">Object to fetch data elements not included in changes</param>
+    /// <param name="taskId">The current task ID</param>
+    /// <param name="changes">Not used in this context</param>
+    /// <param name="language">Not used in this context</param>
+    public async Task ProcessDataWrite(
+        IInstanceDataMutator instanceDataMutator,
+        string taskId,
+        DataElementChanges changes,
+        string? language
+    )
+    {
+        await _dataFieldValueCalculator.Calculate(instanceDataMutator, taskId);
+    }
+}

src/Altinn.App.Core/Features/DataProcessing/GenericDataProcessor.cs

@@ -16,7 +16,7 @@ public abstract class GenericDataProcessor<TModel> : IDataProcessor
 
     /// <summary>
     /// Do changes to the model before it is written to storage, and report back to frontend.
-    /// Tyipically used to add calculated values to the model.
+    /// Typically used to add calculated values to the model.
     /// </summary>
     public abstract Task ProcessDataWrite(
         Instance instance,

src/Altinn.App.Core/Features/Telemetry/Telemetry.ApplicationMetadata.Service.cs

@@ -49,6 +49,9 @@ partial class Telemetry
     internal Activity? StartGetValidationConfigurationActivity() =>
         ActivitySource.StartActivity($"{Prefix}.GetValidationConfiguration");
 
+    internal Activity? StartGetCalculationConfigurationActivity() =>
+        ActivitySource.StartActivity($"{Prefix}.GetCalculationConfiguration");
+
     internal Activity? StartGetLayoutModelActivity() => ActivitySource.StartActivity($"{Prefix}.GetLayoutModel");
 
     internal Activity? StartGetClassRefActivity() => ActivitySource.StartActivity($"{Prefix}.GetClassRef");

src/Altinn.App.Core/Features/Telemetry/Telemetry.DataFieldValueCalculator.cs

@@ -0,0 +1,20 @@
+using System.Diagnostics;
+using static Altinn.App.Core.Features.Telemetry.DataFieldValueCalculator;
+
+namespace Altinn.App.Core.Features;
+
+partial class Telemetry
+{
+    internal Activity? StartCalculateActivity(string instanceId, string taskId)
+    {
+        var activity = ActivitySource.StartActivity($"{Prefix}.Calculate");
+        activity?.SetInstanceId(instanceId);
+        activity?.SetTaskId(taskId);
+        return activity;
+    }
+
+    internal static class DataFieldValueCalculator
+    {
+        internal const string Prefix = "DataFieldValueCalculator";
+    }
+}