Feat/methods to access xsd

src/Altinn.App.Api/packaging/Altinn.App.Api.Experimental.props

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+  <!--
+    This props file is included in the Altinn.App.Api nuget package and will
+    apply to the App projects when they reference said nuget package.
+   -->
+  <PropertyGroup>
+    <IsAltinnApp>true</IsAltinnApp>
+  </PropertyGroup>
+  <ItemGroup>
+    <!--
+      This props file is included in the build/ path of the Altinn.App.Api nuget package
+      but the Rosly analyzer is included transitively, for example in unit test projects or similar.
+      We only need to do app-based analysis on actual app projects, so this let's us distinguish
+      in the Roslyn Analyzer code.
+    -->
+    <CompilerVisibleProperty Include="IsAltinnApp" />
+  </ItemGroup>
+  <ItemGroup>
+    <!--
+      We include config files as addition files so that they are more easily referenced
+      in analyzers and source generators.
+    -->
+    <AdditionalFiles Include="config/**" />
+    <AdditionalFiles Include="ui/**/*.json" />
+  </ItemGroup>
+</Project>

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

@@ -215,6 +215,11 @@ public class AppSettings
     /// </summary>
     public bool ExpressionValidation { get; set; }
 
+    /// <summary>
+    /// Enable the functionality to validate form data against corresponding XSD if present
+    /// </summary>
+    public bool XsdValidation { get; set; }
+
     /// <summary>
     /// Enables OpenTelemetry as a substitute for Application Insights SDK
     /// Improves instrumentation throughout the Altinn app libraries.

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

@@ -243,6 +243,11 @@ private static void AddValidationServices(IServiceCollection services, IConfigur
         {
             services.AddTransient<IValidator, ExpressionValidator>();
         }
+
+        if (appSettings?.XsdValidation is true)
+        {
+            services.AddTransient<IValidator, XsdValidator>();
+        }
     }
 
     /// <summary>

src/Altinn.App.Core/Features/Validation/Default/XsdValidator.cs

@@ -0,0 +1,120 @@
+using System.Xml;
+using System.Xml.Schema;
+using Altinn.App.Core.Helpers;
+using Altinn.App.Core.Helpers.Serialization;
+using Altinn.App.Core.Internal.App;
+using Altinn.App.Core.Models;
+using Altinn.App.Core.Models.Validation;
+using Microsoft.Extensions.Logging;
+
+namespace Altinn.App.Core.Features.Validation.Default;
+
+/// <summary>
+/// Validates form data against the XSD schema for the data model, if it exists
+/// </summary>
+public class XsdValidator : IValidator
+{
+    private readonly ILogger<XsdValidator> _logger;
+    private readonly IAppResources _appResourceService;
+    private readonly IAppMetadata _appMetadata;
+    private readonly ModelSerializationService _modelSerializationService;
+
+    /// <summary>
+    /// Constructor for the expression validator
+    /// </summary>
+    public XsdValidator(
+        ILogger<XsdValidator> logger,
+        IAppResources appResourceService,
+        IAppMetadata appMetadata,
+        ModelSerializationService modelSerializationService
+    )
+    {
+        _logger = logger;
+        _appResourceService = appResourceService;
+        _appMetadata = appMetadata;
+        _modelSerializationService = modelSerializationService;
+    }
+
+    /// <summary>
+    /// We implement <see cref="ShouldRunForTask"/> instead
+    /// </summary>
+    public string TaskId => "*";
+
+    /// <summary>
+    /// Only run for tasks that specifies a layout set
+    /// </summary>
+    public bool ShouldRunForTask(string taskId) =>
+        _appMetadata
+            .GetApplicationMetadata()
+            .Result.DataTypes.Exists(dt => dt.TaskId == taskId && dt.AppLogic?.ClassRef is not null);
+
+    /// <inheritdoc />
+    public string ValidationSource => "Xsd";
+
+    /// <inheritdoc />
+    public bool NoIncrementalValidation => true;
+
+    /// <summary>
+    /// This is not used for incremental validation
+    /// </summary>
+    public Task<bool> HasRelevantChanges(
+        IInstanceDataAccessor dataAccessor,
+        string taskId,
+        DataElementChanges changes
+    ) => Task.FromResult(true);
+
+    /// <inheritdoc />
+    public async Task<List<ValidationIssue>> Validate(
+        IInstanceDataAccessor dataAccessor,
+        string taskId,
+        string? language
+    )
+    {
+        var validationIssues = new List<ValidationIssue>();
+        foreach (var (dataType, dataElement) in dataAccessor.GetDataElementsForTask(taskId))
+        {
+            var schema = _appResourceService.GetXsdSchema(dataType.Id);
+            if (schema is null)
+            {
+                _logger.LogInformation(
+                    "No XSD schema found for data type {DataTypeId}, skipping XSD validation",
+                    dataType.Id
+                );
+                continue;
+            }
+            var formData = await dataAccessor.GetFormData(dataElement);
+            ObjectUtils.RemoveAltinnRowId(formData);
+
+            var serializedFormData = _modelSerializationService.SerializeToXml(formData);
+            var parsedSchema = new XmlSchemaSet();
+            using (var xsdReader = XmlReader.Create(new StringReader(schema)))
+            {
+                parsedSchema.Add(null, xsdReader);
+            }
+            var settings = new XmlReaderSettings { ValidationType = ValidationType.Schema, Schemas = parsedSchema };
+            settings.ValidationEventHandler += (sender, e) =>
+            {
+                validationIssues.Add(
+                    new ValidationIssue()
+                    {
+                        Code = "Xsd",
+                        CustomTextKey = "backend.xsd_validation",
+                        DataElementId = dataElement.Id,
+                        Severity = ValidationIssueSeverity.Error,
+                        CustomTextParameters = new Dictionary<string, string>()
+                        {
+                            { "schema", dataType.Id },
+                            { "message", e.Message },
+                        },
+                    }
+                );
+            };
+
+            using var xmlStream = new MemoryStream(serializedFormData.ToArray(), writable: false);
+            using var reader = XmlReader.Create(xmlStream, settings);
+            while (reader.Read()) { }
+        }
+
+        return validationIssues;
+    }
+}

src/Altinn.App.Core/Internal/Texts/TranslationService.cs

@@ -318,6 +318,25 @@ await state.GetModelData(binding, context?.DataElementIdentifier, context?.RowIn
                         _ => "Dokumentet er en forhåndsvisning",
                     },
                 };
+            case "backend.xsd_validation":
+                return new TextResourceElement()
+                {
+                    Id = "backend.xsd_validation",
+                    Value = language switch
+                    {
+                        LanguageConst.Nb => "Et felt bryter reglene satt av XSD. Melding: {0]",
+                        LanguageConst.Nn => "Eit felt bryt reglane sette av XSD. Melding: {0}",
+                        _ => "A field is in violation of the rules set by the XSD schema. Message: {0}",
+                    },
+                    Variables = [
+                        new TextResourceVariable()
+                        {
+                            DataSource = "customTextParameters",
+                            Key = "message",
+                            DefaultValue = ""
+                        }
+                    ]
+                };
         }
 
         return null;