[Fix] Dimension type validation false positive

Px.Utils.UnitTests/Validation/ContentValidationTests/ContentValidationTests.cs

@@ -536,6 +536,27 @@ public void ValidateValueTypesCalledWithStructuredEntryArrayWithWrongValuesRetur
             }
         }
 
+        [TestMethod]
+        public void ValidateValueTypesCalledWithStructuredEntryArrayWithKnownDimensionTypeAliasesReturnsWithWarnings()
+        {
+            // Arrange
+            ValidationStructuredEntry[] entries = ContentValidationFixtures.STRUCTURED_ENTRY_ARRAY_WITH_KNOWN_DIMENSIONTYPE_ALIASES;
+            ContentValidator validator = new(filename, encoding, entries);
+            // Act
+            foreach (ValidationStructuredEntry entry in entries)
+            {
+                ValidationFeedback? result = ContentValidator.ValidateValueContents(
+                    entry,
+                    validator
+                    );
+                // Assert
+                Assert.IsNotNull(result);
+                Assert.HasCount(1, result);
+                Assert.AreEqual(ValidationFeedbackRule.InvalidValueFound, result.First().Key.Rule);
+                Assert.AreEqual(ValidationFeedbackLevel.Warning, result.First().Key.Level);
+            }
+        }
+
         [TestMethod]
         public void ValidateValueAmountsCalledWithUnmatchingAmountOfElementsReturnsWithError()
         {

Px.Utils.UnitTests/Validation/Fixtures/ContentValidationFixtures.cs

@@ -429,6 +429,9 @@ internal static class ContentValidationFixtures
                 17,
                 Utils.Validation.ValueType.StringValue);
 
+        private static readonly ValidationStructuredEntryKey dimensionTypeEntryKey =
+                new ("VARIABLE-TYPE", "fi", "foo");
+
         internal static ValidationStructuredEntry[] MINIMAL_STRUCTURED_ENTRY_ARRAY =>
         [
             charsetEntry,
@@ -752,6 +755,12 @@ internal static class ContentValidationFixtures
                     Utils.Validation.ValueType.StringValue),
             ];
 
+        internal static ValidationStructuredEntry[] STRUCTURED_ENTRY_ARRAY_WITH_KNOWN_DIMENSIONTYPE_ALIASES =>
+            [
+                new ValidationStructuredEntry(filename, dimensionTypeEntryKey, "Contents", 0, [], 0, Utils.Validation.ValueType.StringValue),
+                new ValidationStructuredEntry(filename, dimensionTypeEntryKey, "Region", 1, [], 0, Utils.Validation.ValueType.StringValue),
+            ];
+
         internal static ValidationStructuredEntry StructuredEntryWithUnmatchingAmountOfElements =>
             new(filename,
                 codesBarEntry.Key,

Px.Utils/ModelBuilders/ValueParserUtilities.cs

@@ -1,4 +1,4 @@
-using Px.Utils.Models.Metadata.Enums;
+using Px.Utils.Models.Metadata.Enums;
 using Px.Utils.Models.Metadata.ExtensionMethods;
 using Px.Utils.PxFile;
 
@@ -113,10 +113,12 @@ public static DimensionType StringToDimensionType(string input, PxFileConfigurat
             Dictionary<string, DimensionType> map = new()
             {
                 {conf.Tokens.VariableTypes.Content, DimensionType.Content},
+                {conf.Tokens.VariableTypes.Contents, DimensionType.Content}, // Known alias for content dimension type
                 {conf.Tokens.VariableTypes.Time, DimensionType.Time},
                 {conf.Tokens.VariableTypes.Ordinal, DimensionType.Ordinal},
                 {conf.Tokens.VariableTypes.Nominal, DimensionType.Nominal},
                 {conf.Tokens.VariableTypes.Geographical, DimensionType.Geographical},
+                {conf.Tokens.VariableTypes.Region, DimensionType.Geographical}, // Known alias for geographical dimension type
                 {conf.Tokens.VariableTypes.Other, DimensionType.Other},
                 {conf.Tokens.VariableTypes.Unknown, DimensionType.Unknown}
             };

Px.Utils/PxFile/PxFileConfiguration.cs

@@ -1,4 +1,4 @@
-using Px.Utils.Models.Metadata.Enums;
+using Px.Utils.Models.Metadata.Enums;
 
 namespace Px.Utils.PxFile
 {
@@ -110,19 +110,23 @@ private TimeValue() { }
             public class VariableTypeTokens
             {
                 private const string CONTENT = "Content";
+                private const string CONTENTS = "Contents";
                 private const string TIME = "Time";
                 private const string ORDINAL = "Ordinal";
                 private const string NOMINAL = "Nominal";
                 private const string GEOGRAPHICAL = "Geographical";
+                private const string REGION = "Region";
                 private const string OTHER = "Other";
                 private const string UNKNOWN = "Unknown";
                 private const string CLASSIFICATORY = "Classificatory";
 
                 public string Content { get; set; } = CONTENT;
+                public string Contents { get; set; } = CONTENTS;
                 public string Time { get; set; } = TIME;
                 public string Ordinal { get; set; } = ORDINAL;
                 public string Nominal { get; set; } = NOMINAL;
                 public string Geographical { get; set; } = GEOGRAPHICAL;
+                public string Region { get; set; } = REGION;
                 public string Other { get; set; } = OTHER;
                 public string Unknown { get; set; } = UNKNOWN;
                 public string Classificatory { get; set; } = CLASSIFICATORY;

Px.Utils/Validation/ContentValidation/ContentValidator.ValidationEntryFunctions.cs

@@ -323,28 +323,38 @@ public sealed partial class ContentValidator
             string[] allowedCharsets = ["ANSI", "Unicode"];
 
             string[] dimensionTypes = [
-                    validator.Conf.Tokens.VariableTypes.Content,
+                validator.Conf.Tokens.VariableTypes.Content,
                 validator.Conf.Tokens.VariableTypes.Time,
                 validator.Conf.Tokens.VariableTypes.Geographical,
                 validator.Conf.Tokens.VariableTypes.Ordinal,
                 validator.Conf.Tokens.VariableTypes.Nominal,
                 validator.Conf.Tokens.VariableTypes.Other,
                 validator.Conf.Tokens.VariableTypes.Unknown,
                 validator.Conf.Tokens.VariableTypes.Classificatory
-                    ];
+            ];
+
+            string[] knownDimensionTypeAliases = [
+                validator.Conf.Tokens.VariableTypes.Contents,
+                validator.Conf.Tokens.VariableTypes.Region,
+            ];
 
             string value = SyntaxValidationUtilityMethods.CleanString(entry.Value, validator.Conf);
             if ((entry.Key.Keyword == validator.Conf.Tokens.KeyWords.Charset && !allowedCharsets.Contains(value)) ||
                 (entry.Key.Keyword == validator.Conf.Tokens.KeyWords.CodePage && !value.Equals(validator._encoding.BodyName, StringComparison.OrdinalIgnoreCase)) ||
                 (entry.Key.Keyword == validator.Conf.Tokens.KeyWords.DimensionType && !dimensionTypes.Contains(value)))
             {
+                // If the value is included in known aliases, set level to warning instead of error
+                ValidationFeedbackLevel level = entry.Key.Keyword == validator.Conf.Tokens.KeyWords.DimensionType && knownDimensionTypeAliases.Contains(value) ?
+                        ValidationFeedbackLevel.Warning : 
+                        ValidationFeedbackLevel.Error;
+
                 KeyValuePair<int, int> feedbackIndexes = SyntaxValidationUtilityMethods.GetLineAndCharacterIndex(
                     entry.KeyStartLineIndex,
                     entry.ValueStartIndex,
                     entry.LineChangeIndexes);
 
                 KeyValuePair<ValidationFeedbackKey, ValidationFeedbackValue> feedback = new(
-                    new(ValidationFeedbackLevel.Error,
+                    new(level,
                         ValidationFeedbackRule.InvalidValueFound),
                     new(validator._filename,
                         feedbackIndexes.Key,