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

@@ -185,13 +185,15 @@
 #pragma warning restore CS0618, CS0612 // Type or member is obsolete
         services.TryAddTransient<IInstantiationProcessor, NullInstantiationProcessor>();
         services.TryAddTransient<IInstantiationValidator, NullInstantiationValidator>();
+        services.TryAddTransient<DataModelFieldCalculator>();
         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, DataModelFieldCalculatorProcessor>();
         services.AddSingleton<IAuthenticationTokenResolver, AuthenticationTokenResolver>();
         services.AddTransient<IDataService, DataService>();
         services.AddSingleton<ModelSerializationService>();
@@ -266,7 +268,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/DataModelFieldCalculator.cs

@@ -0,0 +1,227 @@
+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 DataModelFieldCalculator
+{
+    private static readonly JsonSerializerOptions _jsonSerializerOptions = new()
+    {
+        ReadCommentHandling = JsonCommentHandling.Skip,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    };
+
+    private readonly ILogger<DataModelFieldCalculator> _logger;
+    private readonly IAppResources _appResourceService;
+    private readonly ILayoutEvaluatorStateInitializer _layoutEvaluatorStateInitializer;
+    private readonly IDataElementAccessChecker _dataElementAccessChecker;
+    private readonly Telemetry? _telemetry;
+
+    public DataModelFieldCalculator(
+        ILogger<DataModelFieldCalculator> logger,
+        ILayoutEvaluatorStateInitializer layoutEvaluatorStateInitializer,
+        IAppResources appResourceService,
+        IDataElementAccessChecker dataElementAccessChecker,
+        Telemetry? telemetry = null
+    )
+    {
+        _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 dataModelFieldCalculations = ParseDataModelFieldCalculationConfig(rawCalculationConfig);
+        var formDataWrapper = await dataAccessor.GetFormDataWrapper(dataElement);
+
+        foreach (var (baseField, calculation) in dataModelFieldCalculations)
+        {
+            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
+                        && IsSameOrDescendantField(resolvedField.Field, d.Field)
+                    )
+                )
+                {
+                    continue;
+                }
+
+                var context = new ComponentContext(
+                    evaluatorState,
+                    component: null,
+                    rowIndices: ExpressionHelper.GetRowIndices(resolvedField.Field),
+                    dataElementIdentifier: resolvedField.DataElementIdentifier
+                );
+                var positionalArguments = new object[] { resolvedField.Field };
+
+                await RunCalculation(
+                    formDataWrapper,
+                    evaluatorState,
+                    resolvedField,
+                    context,
+                    positionalArguments,
+                    calculation
+                );
+            }
+        }
+    }
+
+    private async Task RunCalculation(
+        IFormDataWrapper formDataWrapper,
+        LayoutEvaluatorState evaluatorState,
+        DataReference resolvedField,
+        ComponentContext context,
+        object[] positionalArguments,
+        DataModelFieldCalculation calculation
+    )
+    {
+        try
+        {
+            var calculationResult = await ExpressionEvaluator.EvaluateExpressionToExpressionValue(
+                evaluatorState,
+                calculation.Expression,
+                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, DataModelFieldCalculation> ParseDataModelFieldCalculationConfig(
+        string rawCalculationConfig
+    )
+    {
+        JsonDocument calculationConfigDocument;
+        try
+        {
+            calculationConfigDocument = JsonDocument.Parse(
+                rawCalculationConfig,
+                new JsonDocumentOptions { CommentHandling = JsonCommentHandling.Skip }
+            );
+        }
+        catch (JsonException e)
+        {
+            _logger.LogError(e, "Failed to parse calculation configuration JSON");
+            return new Dictionary<string, DataModelFieldCalculation>();
+        }
+        using (calculationConfigDocument)
+        {
+            var dataModelFieldCalculations = new Dictionary<string, DataModelFieldCalculation>();
+            var hasCalculations = calculationConfigDocument.RootElement.TryGetProperty(
+                "calculations",
+                out JsonElement calculationsObject
+            );
+            if (hasCalculations)
+            {
+                foreach (var calculationArray in calculationsObject.EnumerateObject())
+                {
+                    var field = calculationArray.Name;
+                    var calculation = calculationArray.Value;
+                    var resolvedDataModelFieldCalculation = ResolveDataModelFieldCalculation(field, calculation);
+                    if (resolvedDataModelFieldCalculation == null)
+                    {
+                        _logger.LogError("Calculation for field {Field} could not be resolved", field);
+                        continue;
+                    }
+                    dataModelFieldCalculations[field] = resolvedDataModelFieldCalculation;
+                }
+            }
+            return dataModelFieldCalculations;
+        }
+    }
+
+    private DataModelFieldCalculation? ResolveDataModelFieldCalculation(string field, JsonElement definition)
+    {
+        var dataModelFieldCalculationDefinition = definition.Deserialize<RawDataModelFieldCalculation>(
+            _jsonSerializerOptions
+        );
+        if (dataModelFieldCalculationDefinition == null)
+        {
+            _logger.LogError("Calculation for field {Field} could not be parsed", field);
+            return null;
+        }
+
+        if (dataModelFieldCalculationDefinition.Expression == null)
+        {
+            _logger.LogError("Calculation for field {Field} is missing expression", field);
+            return null;
+        }
+
+        var dataModelFieldCalculation = new DataModelFieldCalculation
+        {
+            Expression = dataModelFieldCalculationDefinition.Expression.Value,
+        };
+
+        return dataModelFieldCalculation;
+    }
+
+    private static bool IsSameOrDescendantField(string candidate, string hiddenField)
+    {
+        if (candidate.Equals(hiddenField, StringComparison.Ordinal))
+        {
+            return true;
+        }
+
+        return candidate.StartsWith(hiddenField, StringComparison.Ordinal)
+            && candidate.Length > hiddenField.Length
+            && (candidate[hiddenField.Length] == '.' || candidate[hiddenField.Length] == '[');
+    }
+}

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

@@ -0,0 +1,37 @@
+using Altinn.App.Core.Models;
+
+namespace Altinn.App.Core.Features.DataProcessing;
+
+/// <summary>
+/// Processing data model fields that is calculated by expressions provided in [modelName].calculation.json.
+/// </summary>
+internal sealed class DataModelFieldCalculatorProcessor : IDataWriteProcessor
+{
+    private readonly DataModelFieldCalculator _dataModelFieldCalculator;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DataModelFieldCalculatorProcessor"/> class.
+    /// </summary>
+    /// <param name="dataModelFieldCalculator"></param>
+    public DataModelFieldCalculatorProcessor(DataModelFieldCalculator dataModelFieldCalculator)
+    {
+        _dataModelFieldCalculator = dataModelFieldCalculator;
+    }
+
+    /// <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 _dataModelFieldCalculator.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.DataModelFieldCalculator;
+
+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 DataModelFieldCalculator
+    {
+        internal const string Prefix = "DataModelFieldCalculator";
+    }
+}