rewrite point2d type to be a geometry string with a type

Author: runeanielsen

src/CIM.Core/DAX.CIM.PhysicalNetworkModel/Equipment/GeometryType.cs

@@ -0,0 +1,9 @@
+namespace CIM.PhysicalNetworkModel
+{
+    [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://daxgrid.net/PhysicalNetworkModel_0_1")]
+    public enum GeometryType
+    {
+        Point,
+        LineString
+    }
+}

src/CIM.Core/DAX.CIM.PhysicalNetworkModel/Equipment/LocationExt.cs

@@ -6,17 +6,31 @@
     [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://daxgrid.net/PhysicalNetworkModel_0_1")]
     public partial class LocationExt : Location
     {
-        private Point2D[] coordinatesField;
+        private GeometryType geometryType;
 
-        public Point2D[] coordinates
+        private string geometry;
+
+        public GeometryType GeometryType
+        {
+            get
+            {
+                return this.geometryType;
+            }
+            set
+            {
+                this.geometryType = value;
+            }
+        }
+
+        public string Geometry
         {
             get
             {
-                return this.coordinatesField;
+                return this.geometry;
             }
             set
             {
-                this.coordinatesField = value;
+                this.geometry = value;
             }
         }
     }

src/CIM.Core/DAX.CIM.PhysicalNetworkModel/Equipment/Point2D.cs

@@ -2,6 +2,7 @@
 using DAX.IO.CIM.Processing;
 using DAX.Util;
 using System.Globalization;
+using System.Text;
 
 namespace DAX.IO.CIM.Serialization.CIM100
 {
@@ -2099,20 +2100,29 @@ private Location CreateLocation(double[] coords, CIMIdentifiedObject cimObj)
             loc = new LocationExt() { mRID = GUIDHelper.CreateDerivedGuid(cimObj.mRID, 999, true).ToString() };
             loc.CoordinateSystem = new LocationCoordinateSystem() { @ref = _coordSys.mRID };
 
-            if (coords != null)
+            if (coords is not null)
             {
-                List<Point2D> points = new List<Point2D>();
-
-                for (int i = 0; i < coords.Length; i += 2)
-                {
-                    double x = ((double)coords[i]);
-                    double y = ((double)coords[i + 1]);
+                var stringBuilder = new StringBuilder();
 
-                    points.Add(new Point2D(x, y));
+                stringBuilder.AppendLine("[");
 
+                // LineString
+                if (coords.Length > 2)
+                {
+                    ((LocationExt)loc).GeometryType = GeometryType.LineString;
+                    ((LocationExt)loc).Geometry = $"[{String.Join(",", coords.Chunk(2).Select(x => $"[{x[0]}, {x[1]}]"))}]";
+                }
+                // Point
+                else if (coords.Length == 2)
+                {
+                    ((LocationExt)loc).GeometryType = GeometryType.Point;
+                    ((LocationExt)loc).Geometry = $"[{coords[0]}, {coords[1]}]";
+                }
+                // Not handled geometry type
+                else
+                {
+                    throw new InvalidOperationException($"Could not handle geometry with length '{coords.Length}'.");
                 }
-
-                ((LocationExt)loc).coordinates = points.ToArray();
             }
 
             return loc;

src/CIM.Cson/Converters/Point2DConverter.cs

@@ -50,14 +50,6 @@ private int GetSortNumber()
     }
 }
 
-#pragma warning disable CA1812 // Type class for utility useage.
-internal sealed record Point2D
-{
-    public double X { get; init; }
-    public double Y { get; init; }
-}
-#pragma warning restore CA1812
-
 #pragma warning disable CA1812 // Type class for utility useage.
 internal sealed class CompositeObject { }
 #pragma warning restore CA1812
@@ -253,17 +245,6 @@ private static Type ConvertJsonType(JsonElement jsonElement)
             case JsonValueKind.False:
                 return typeof(bool);
             default:
-                if (jsonElement.TryGetProperty("$type", out var elementType))
-                {
-                    // Point2D is a special type.
-                    // In the future it might be simplified to an array of arrays with doubles in side.
-                    // Until then it's handled in this way.
-                    if (elementType.GetString() == "Point2D")
-                    {
-                        return typeof(Point2D);
-                    }
-                }
-
                 return typeof(CompositeObject);
         }
 

src/CIM.Mapper/DAX.IO.CIM/Serialization/CIM100/CIM100Serializer.cs

@@ -169,19 +169,27 @@ await manyToManyBinaryPostgresWriter
                     {
                         parameter = propertyValue.Value.GetRawText();
                     }
-                    else if (propertyType == typeof(ICollection<Point2D>))
+                    else if (schemaProperty.Key.Equals("Geometry", StringComparison.OrdinalIgnoreCase))
                     {
-                        var points = propertyValue.Value.Deserialize<ICollection<Point2D>>()?.ToArray()
-                            ?? throw new InvalidOperationException("Could not deserialize point array.");
+                        var geometryType = properties.First(x => x.Key == "GeometryType").Value.GetString()!;
 
                         Geometry? geometry;
-                        if (points.Length == 1)
+
+                        var coordinateJson = propertyValue.Value.GetString()!;
+
+                        if (geometryType.Equals("Point", StringComparison.OrdinalIgnoreCase))
+                        {
+                            var coordinates = JsonSerializer.Deserialize<double[]>(coordinateJson)!;
+                            geometry = new Point(coordinates[0], coordinates[1]);
+                        }
+                        else if (geometryType.Equals("LineString", StringComparison.OrdinalIgnoreCase))
                         {
-                            geometry = new Point(points[0].X, points[0].Y);
+                            var coordinates = JsonSerializer.Deserialize<double[][]>(coordinateJson)!;
+                            geometry = new LineString(coordinates.Select(x => new Coordinate(x[0], x[1])).ToArray());
                         }
                         else
                         {
-                            geometry = new LineString(points.Select(x => new Coordinate(x.X, x.Y)).ToArray());
+                            throw new InvalidOperationException($"Could not handle: '{geometryType}'.");
                         }
 
                         geometry.SRID = srid;
@@ -195,7 +203,8 @@ await manyToManyBinaryPostgresWriter
                     await postgresqlBinaryWriter
                         .WriteAsync(
                             parameter,
-                            ConvertInternalTypeToPostgresqlType(propertyType))
+                            schemaProperty.Key.Equals("Geometry", StringComparison.OrdinalIgnoreCase)
+                            ? NpgsqlDbType.Geometry : ConvertInternalTypeToPostgresqlType(propertyType))
                         .ConfigureAwait(false);
                 }
             }
@@ -219,7 +228,6 @@ await postgresqlBinaryWriter
         { typeof(Guid), NpgsqlDbType.Uuid },
         { typeof(string), NpgsqlDbType.Text },
         { typeof(bool), NpgsqlDbType.Boolean },
-        { typeof(ICollection<Point2D>), NpgsqlDbType.Geometry },
         { typeof(ICollection<Guid>), NpgsqlDbType.Array | NpgsqlDbType.Uuid },
         { typeof(ICollection<string>), NpgsqlDbType.Array | NpgsqlDbType.Text },
         { typeof(CompositeObject), NpgsqlDbType.Jsonb }

src/CIM.PostgresImporter.CLI/DynamicSchema.cs

@@ -15,7 +15,7 @@ private static string Build(SchemaType schemaType, string schemaName, bool addIf
         var primaryKeys = string.Join(",", schemaType.Properties.Where(x => x.IsPrimaryKey).Select(x => CustomTableAndColumnNameConverter(x.Name)));
 
         var ifExists = addIfNotExists ? "IF NOT EXISTS" : "";
-        var columns = string.Join(",\n  ", schemaType.Properties.Where(x => !x.ManyToManyAttribute).Select(x => $"\"{CustomTableAndColumnNameConverter(x.Name)}\" {ConvertInternalTypeToPostgresqlType(x.Type)}"));
+        var columns = string.Join(",\n  ", schemaType.Properties.Where(x => !x.ManyToManyAttribute).Select(x => $"\"{CustomTableAndColumnNameConverter(x.Name)}\" {ConvertInternalTypeToPostgresqlType(x.Type, x.Name)}"));
         return @$"
 CREATE TABLE {ifExists} ""{schemaName}"".""{CustomTableAndColumnNameConverter(schemaType.Name)}"" (
   {columns},
@@ -38,9 +38,13 @@ public static string CustomTableAndColumnNameConverter(string x)
         #pragma warning restore CA1308
     }
 
-    private static string ConvertInternalTypeToPostgresqlType(Type type)
+    private static string ConvertInternalTypeToPostgresqlType(Type type, string propertyName)
     {
-        if (type == typeof(int))
+        if (propertyName.Equals("geometry", StringComparison.OrdinalIgnoreCase))
+        {
+            return "GEOMETRY";
+        }
+        else if (type == typeof(int))
         {
             return "INTEGER";
         }
@@ -60,10 +64,6 @@ private static string ConvertInternalTypeToPostgresqlType(Type type)
         {
             return "BOOLEAN";
         }
-        else if (type == typeof(ICollection<Point2D>))
-        {
-            return $"GEOMETRY";
-        }
         else if (type == typeof(ICollection<Guid>))
         {
             return $"UUID[]";

src/CIM.PostgresImporter.CLI/PostgresImport.cs

@@ -220,7 +220,11 @@ await CimReader
         logger.LogInformation($"Total CIM objects imported: '{totalInsertCountByType.Sum(x => x.Value)}'.");
         foreach (var insertionCountPair in totalInsertCountByType)
         {
-            logger.LogInformation($"Inserted a total of '{insertionCountPair.Value}' of type '{insertionCountPair.Key}'.");
+            // This is done to handle relationship types, so they're not written out, since the count will always be 0.
+            if (insertionCountPair.Value > 0)
+            {
+                logger.LogInformation($"Inserted a total of '{insertionCountPair.Value}' of type '{insertionCountPair.Key}'.");
+            }
         }
     }
 }

src/CIM.PostgresImporter.CLI/PostgresSqlBuilder.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Newtonsoft.Json;
 
 namespace CIM.PowerFactoryExporter
 {
@@ -62,16 +63,18 @@ public void AddLocation(Guid psrId, PhysicalNetworkModel.LocationExt loc)
         {
             Guid locationId = AddLocation(psrId, Guid.Parse(loc.mRID));
 
-            if (loc.coordinates.Length == 1)
+            if (loc.GeometryType == PhysicalNetworkModel.GeometryType.Point)
             {
-                AddPositionPoint(locationId, 0, loc.coordinates[0].X, loc.coordinates[0].Y);
+                var point = JsonConvert.DeserializeObject<double[]>(loc.Geometry);
+                AddPositionPoint(locationId, 0, point[0], point[1]);
             }
             else
             {
                 int seqNo = 1;
-                foreach (var coord in loc.coordinates)
+                var points = JsonConvert.DeserializeObject<double[][]>(loc.Geometry);
+                foreach (var point in points)
                 {
-                    AddPositionPoint(locationId, seqNo, coord.X, coord.Y);
+                    AddPositionPoint(locationId, seqNo, point[0], point[1]);
                     seqNo++;
                 }
             }