feat: add GeoJSONMultiLineString / GeoJSONLineString WR-725

src/Be.Vlaanderen.Basisregisters.GrAr.Legacy/SpatialTools/GeoJSONLineString.cs

@@ -0,0 +1,28 @@
+namespace Be.Vlaanderen.Basisregisters.GrAr.Legacy.SpatialTools
+{
+    using Newtonsoft.Json;
+
+    /// <summary>
+    /// Een GeoJSON linestring.
+    /// </summary>
+    public class GeoJSONLineString
+    {
+        /// <summary>
+        /// Coördinaten volgens Lambert-72 (EPSG:31370).
+        /// </summary>
+        [JsonConverter(typeof(LineStringCoordinatesConverter))]
+        [JsonProperty(Required = Required.DisallowNull)]
+        public double[][] Coordinates { get; set; }
+
+        /// <summary>
+        /// GeoJSON-geometrietype.
+        /// </summary>
+        [JsonProperty(Required = Required.DisallowNull)]
+        public string Type { get; }
+
+        public GeoJSONLineString()
+        {
+            Type = "LineString";
+        }
+    }
+}

src/Be.Vlaanderen.Basisregisters.GrAr.Legacy/SpatialTools/GeoJSONMultiLineString.cs

@@ -0,0 +1,28 @@
+namespace Be.Vlaanderen.Basisregisters.GrAr.Legacy.SpatialTools
+{
+    using Newtonsoft.Json;
+
+    /// <summary>
+    /// Een GeoJSON multi linestring.
+    /// </summary>
+    public class GeoJSONMultiLineString
+    {
+        /// <summary>
+        /// Coördinaten volgens Lambert-72 (EPSG:31370).
+        /// </summary>
+        [JsonConverter(typeof(PolygonCoordinatesConverter))]
+        [JsonProperty(Required = Required.DisallowNull)]
+        public double[][][] Coordinates { get; set; }
+
+        /// <summary>
+        /// GeoJSON-geometrietype.
+        /// </summary>
+        [JsonProperty(Required = Required.DisallowNull)]
+        public string Type { get; }
+
+        public GeoJSONMultiLineString()
+        {
+            Type = "MultiLineString";
+        }
+    }
+}

src/Be.Vlaanderen.Basisregisters.GrAr.Legacy/SpatialTools/GeometryCoordinates/GeometryCoordinateValue.cs

@@ -40,6 +40,14 @@ public PolygonGeometryCoordinateValue(double value) : base(value, "F11") { }
             => TryParse(jsonValue, value => new PolygonGeometryCoordinateValue(value));
     }
 
+    public class LineStringGeometryCoordinateValue : GeometryCoordinateValue
+    {
+        public LineStringGeometryCoordinateValue(double value) : base(value, "F11") { }
+
+        public static LineStringGeometryCoordinateValue? TryParse(string jsonValue)
+            => TryParse(jsonValue, value => new LineStringGeometryCoordinateValue(value));
+    }
+
     public class PointGeometryCoordinateValue : GeometryCoordinateValue
     {
         public PointGeometryCoordinateValue(double value) : base(value, "F2") { }

src/Be.Vlaanderen.Basisregisters.GrAr.Legacy/SpatialTools/GeometryCoordinates/LineStringCoordinatesConverter.cs

@@ -0,0 +1,37 @@
+namespace Be.Vlaanderen.Basisregisters.GrAr.Legacy.SpatialTools
+{
+    using System;
+    using System.Linq;
+    using Newtonsoft.Json;
+
+    public class LineStringCoordinatesConverter : JsonConverter<double[][]>
+    {
+        private static readonly object Lock = new object();
+
+        public override void WriteJson(
+            JsonWriter writer,
+            double[][] lineString,
+            JsonSerializer serializer)
+        {
+            lock (Lock)
+            {
+                if (!serializer.Converters.Any(converter => converter is GeometryCoordinateValueConverter))
+                    serializer.Converters.Add(new GeometryCoordinateValueConverter());
+            }
+
+            serializer.Serialize(
+                writer,
+                lineString.Select(points =>
+                    points.Select(coordinateValue => new LineStringGeometryCoordinateValue(coordinateValue))),
+                typeof(GeometryCoordinateValueConverter));
+        }
+
+        public override double[][] ReadJson(
+            JsonReader reader,
+            Type objectType,
+            double[][] existingValue,
+            bool hasExistingValue,
+            JsonSerializer serializer)
+            => throw new NotImplementedException($"Json deserialization of LineStringCoordinates is not supported");
+    }
+}

test/Be.Vlaanderen.Basisregisters.GrAr.Tests/GeometryCoordinates/GeometryCoordinateValueSerializationTests.cs

@@ -15,18 +15,23 @@ public void ThenTheCoordinateValuesAreFormattedCorrect()
                 DefaultDoubleFormat = 0.1,
                 CoordinateValue = new PointGeometryCoordinateValue(3.1234567890138493),
                 PointCoordinates = new[] { 5.2, 2.20192302932029399020, -0.0160097 },
+                LineStringCoordinates = new[]
+                {
+                    new []{3209.1, -83.013, 0.135000003829},
+                    new []{5.3, 2.20192302932029399020}
+                },
                 PolygonCoordinates = new[]
+                {
+                    new []
                     {
-                        new []
-                        {
-                            new []{3209.1, -83.013, 0.135000003829},
-                            new []{5.3, 2.20192302932029399020}
-                        },
-                        new []
-                        {
-                            new []{5.21}
-                        }
+                        new []{3209.1, -83.013, 0.135000003829},
+                        new []{5.3, 2.20192302932029399020}
                     },
+                    new []
+                    {
+                        new []{5.21}
+                    }
+                },
                 DoubleFormatIsStillDefault = 0.2,
             };
 
@@ -35,6 +40,9 @@ public void ThenTheCoordinateValuesAreFormattedCorrect()
                 "\"DefaultDoubleFormat\": 0.1" +
                 ",\"CoordinateValue\": 3.12" +
                 ",\"PointCoordinates\":[ 5.20, 2.20, -0.02 ]" +
+                ",\"LineStringCoordinates\":[" +
+                    "[ 3209.10000000000, -83.01300000000, 0.13500000383], [ 5.30000000000, 2.20192302932 ]" +
+                "]" +
                 ",\"PolygonCoordinates\":[" +
                     "[" +
                         "[ 3209.10000000000, -83.01300000000, 0.13500000383], [ 5.30000000000, 2.20192302932 ]" +
@@ -61,6 +69,9 @@ private class CoordinatesSerializationTestModel
             [JsonConverter(typeof(PointCoordinatesConverter))]
             public double[] PointCoordinates { get; set; }
 
+            [JsonConverter(typeof(LineStringCoordinatesConverter))]
+            public double[][] LineStringCoordinates { get; set; }
+
             [JsonConverter(typeof(PolygonCoordinatesConverter))]
             public double[][][] PolygonCoordinates { get; set; }
 

test/Be.Vlaanderen.Basisregisters.GrAr.Tests/GeometryCoordinates/LineStringGeometryCoordinateValueTests.cs

@@ -0,0 +1,118 @@
+namespace Be.Vlaanderen.Basisregisters.GrAr.Tests.GeometryCoordinates
+{
+    using System;
+    using System.Globalization;
+    using AutoFixture;
+    using FluentAssertions;
+    using Infrastructure;
+    using Legacy.SpatialTools;
+    using Xunit;
+
+    public class WhenConvertingACreatingALineStringGeometryCoordinateValueBackToADouble
+    {
+        private readonly double _originalValue;
+        private readonly GeometryCoordinateValue _coordinateValue;
+
+        public WhenConvertingACreatingALineStringGeometryCoordinateValueBackToADouble()
+        {
+            _originalValue = new Fixture().CreateDoubleWithPrecision(12, 25);
+
+            _coordinateValue = new LineStringGeometryCoordinateValue(_originalValue);
+        }
+
+        [Fact]
+        public void ThenOriginalPrecisionShouldBeMaintained()
+        {
+            _coordinateValue
+                .Should()
+                .Be(_originalValue);
+        }
+
+    }
+
+    public class WhenWritingALineStringGeometryCoordinateValueWithLessPrecisionThanExpected
+    {
+        private readonly double _originalValue;
+        private readonly string _printedValue;
+
+        public WhenWritingALineStringGeometryCoordinateValueWithLessPrecisionThanExpected()
+        {
+            _originalValue = new Fixture().CreateDoubleWithPrecision(0, 10);
+
+            _printedValue = new LineStringGeometryCoordinateValue(_originalValue).ToString();
+        }
+
+        [Fact]
+        public void ThenTheDecimalPrecisionShouldBeExtendedToShowElevenDecimals()
+        {
+            _printedValue
+                .Should()
+                .MatchRegex(@"^-?\d+\.\d{11}$");
+        }
+
+        [Fact]
+        public void ThenPrintedValueShouldBeEqualToTheOriginal()
+        {
+            double.Parse(_printedValue, CultureInfo.InvariantCulture)
+                .Should()
+                .Be(_originalValue);
+        }
+    }
+
+    public class WhenWritingALineStringGeometryCoordinateValueWithMorePrecisionThanSupported
+    {
+        private readonly double _originalValue;
+        private readonly string _printedValue;
+
+        public WhenWritingALineStringGeometryCoordinateValueWithMorePrecisionThanSupported()
+        {
+            _originalValue = new Fixture().CreateDoubleWithPrecision(12, 20);
+
+            _printedValue = new LineStringGeometryCoordinateValue(_originalValue).ToString();
+        }
+
+        [Fact]
+        public void ThenTheDecimalPrecisionShouldBeReducedToElevenDecimals()
+        {
+            _printedValue
+                .Should()
+                .MatchRegex(@"^-?\d+\.\d{11}$");
+        }
+
+        [Fact]
+        public void ThenThePrintedValueShouldBeRoundedToElevenDecimalsPrecision()
+        {
+            var roundedValue = Math.Round(_originalValue, 11);
+            double.Parse(_printedValue, CultureInfo.InvariantCulture)
+                .Should()
+                .Be(roundedValue);
+        }
+    }
+
+    public class WhenParsingAValidDoubleStringAsLineStringGeometryCoordinateValue
+    {
+        [Fact]
+        public void ThenAGeometryCoordinateValueShouldBeReturned()
+        {
+            var value = new Fixture().CreateDoubleWithPrecision(15);
+            LineStringGeometryCoordinateValue
+                .TryParse(value.ToString(CultureInfo.InvariantCulture))
+                .Should()
+                .NotBeNull()
+                .And.BeOfType<LineStringGeometryCoordinateValue>()
+                .And.Be(value);
+        }
+    }
+
+    public class WhenParsingAnInvalidDoubleStringAsLineStringGeometryCoordinateValue
+    {
+        [Fact]
+        public void ThenNothingShouldBeReturned()
+        {
+            LineStringGeometryCoordinateValue
+                .TryParse(new Fixture().Create<string>())
+                .Should()
+                .BeNull();
+        }
+    }
+}