Add polygon to DTO convert strategy

DataAccess/DTOs/Converters/NdmCrossSections/EllipseNdmPrimitiveToDTOConvertStrategy.cs

@@ -70,7 +70,7 @@ namespace DataAccess.DTOs
 
         private EllipseNdmPrimitiveDTO GetNewPrimitive(IEllipseNdmPrimitive source)
         {
-            EllipseNdmPrimitiveDTO newItem = new() { Id = source.Id };
+            EllipseNdmPrimitiveDTO newItem = new(source.Id);
             updateStrategy.Update(newItem, source);
             newItem.NdmElement = ndmElementConvertStrategy.Convert(source.NdmElement);
             newItem.RectangleShape = rectangleShapeConvertStrategy.Convert(source.Shape as IRectangleShape);

DataAccess/DTOs/Converters/NdmCrossSections/NdmElementToDTOConvertStrategy.cs

@@ -55,8 +55,11 @@ namespace DataAccess.DTOs
             headMaterialConvertStrategy.ReferenceDictionary = ReferenceDictionary;
             headMaterialConvertStrategy.TraceLogger = TraceLogger;
             var convertLogic = new DictionaryConvertStrategy<HeadMaterialDTO, IHeadMaterial>(this, headMaterialConvertStrategy);
-            var headMaterial = convertLogic.Convert(source.HeadMaterial);
-            newItem.HeadMaterial = headMaterial;
+            if (source.HeadMaterial != null)
+            {
+                var headMaterial = convertLogic.Convert(source.HeadMaterial);
+                newItem.HeadMaterial = headMaterial;
+            }       
             forceUpdateStrategy.Update(newItem.UsersPrestrain, source.UsersPrestrain);
             (newItem.UsersPrestrain as ForceTupleDTO).Id = source.UsersPrestrain.Id;
             forceUpdateStrategy.Update(newItem.AutoPrestrain, source.AutoPrestrain);

DataAccess/DTOs/Converters/NdmCrossSections/NdmPrimitiveToDTOConvertStrategy.cs

@@ -11,6 +11,7 @@ namespace DataAccess.DTOs.Converters
         private readonly IConvertStrategy<PointNdmPrimitiveDTO, IPointNdmPrimitive> pointConvertStrategy;
         private readonly IConvertStrategy<EllipseNdmPrimitiveDTO, IEllipseNdmPrimitive> ellipseConvertStrategy;
         private readonly IConvertStrategy<RectangleNdmPrimitiveDTO, IRectangleNdmPrimitive> rectangleConvertStrategy;
+        private IConvertStrategy<ShapeNdmPrimitiveDTO, IShapeNdmPrimitive> shapeConvertStrategy;
 
         public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; }
         public IShiftTraceLogger TraceLogger { get; set; }
@@ -55,10 +56,21 @@ namespace DataAccess.DTOs.Converters
             {
                 return ProcessRectangle(rectangle);
             }
+            if (source is IShapeNdmPrimitive shape)
+            {
+                return ProcessShape(shape);
+            }
             TraceLogger.AddMessage("Object type is unknown", TraceLogStatuses.Error);
             throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source));
         }
 
+        private ShapeNdmPrimitiveDTO ProcessShape(IShapeNdmPrimitive shape)
+        {
+            shapeConvertStrategy = new DictionaryConvertStrategy<ShapeNdmPrimitiveDTO,IShapeNdmPrimitive>(this, new ShapeNdmPrimitiveToDTOConvertStrategy(this));
+            ShapeNdmPrimitiveDTO shapeNdmPrimitiveDTO = shapeConvertStrategy.Convert(shape);
+            return shapeNdmPrimitiveDTO;
+        }
+
         private RebarNdmPrimitiveDTO ProcessRebar(IRebarNdmPrimitive rebar)
         {
             rebarConvertStrategy.ReferenceDictionary = ReferenceDictionary;

DataAccess/DTOs/Converters/NdmCrossSections/ShapeNdmPrimitiveToDTOConvertStrategy.cs

@@ -0,0 +1,50 @@
+using DataAccess.DTOs.Converters;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
+using StructureHelperLogics.NdmCalculations.Primitives;
+
+namespace DataAccess.DTOs
+{
+    public class ShapeNdmPrimitiveToDTOConvertStrategy : ConvertStrategy<ShapeNdmPrimitiveDTO, IShapeNdmPrimitive>
+    {
+        private IUpdateStrategy<IShapeNdmPrimitive> updateStrategy;
+        private IConvertStrategy<IShape, IShape> shapeConvertStrategy;
+        private IConvertStrategy<NdmElementDTO, INdmElement> ndmElementConvertStrategy;
+        private IConvertStrategy<Point2DDTO, IPoint2D> pointConvertStrategy;
+        private IConvertStrategy<VisualPropertyDTO, IVisualProperty> visualPropsConvertStrategy;
+        private IConvertStrategy<DivisionSizeDTO, IDivisionSize> divisionConvertStrategy;
+
+        public ShapeNdmPrimitiveToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override ShapeNdmPrimitiveDTO GetNewItem(IShapeNdmPrimitive source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id);
+            InitializeStrategies();
+            updateStrategy.Update(NewItem, source);
+            updateChildProperties(source);
+            return NewItem;
+        }
+
+        private void updateChildProperties(IShapeNdmPrimitive source)
+        {
+            NewItem.SetShape(shapeConvertStrategy.Convert(source.Shape));
+            NewItem.NdmElement = ndmElementConvertStrategy.Convert(source.NdmElement);
+            NewItem.Center = pointConvertStrategy.Convert(source.Center);
+            NewItem.VisualProperty = visualPropsConvertStrategy.Convert(source.VisualProperty);
+            NewItem.DivisionSize = divisionConvertStrategy.Convert(source.DivisionSize);
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy = new ShapeNdmPrimitiveUpdateStrategy() { UpdateChildren = false };
+            shapeConvertStrategy = new DictionaryConvertStrategy<IShape, IShape>(this, new ShapeToDTOConvertStrategy(this));
+            ndmElementConvertStrategy = new NdmElementToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger};
+            pointConvertStrategy = new Point2DToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
+            visualPropsConvertStrategy = new VisualPropertyToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
+            divisionConvertStrategy = new DivisionSizeToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
+        }
+    }
+}

DataAccess/DTOs/Converters/Shapes/LinePolygonToDTOConvertStrategy.cs

@@ -0,0 +1,36 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataAccess.DTOs
+{
+    public class LinePolygonToDTOConvertStrategy : ConvertStrategy<LinePolygonShapeDTO, ILinePolygonShape>
+    {
+        private IUpdateStrategy<ILinePolygonShape> updateStrategy;
+        private IConvertStrategy<VertexDTO, IVertex> vertexConvertStrategy;
+
+        public LinePolygonToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override LinePolygonShapeDTO GetNewItem(ILinePolygonShape source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id);
+            updateStrategy = new LinePolygonShapeUpdateStrategy() { UpdateChildren = false };
+            vertexConvertStrategy = new VertexToDTOConvertStrategy(this);
+            updateStrategy.Update(NewItem, source);
+            NewItem.Clear();
+            foreach (var item in source.Vertices)
+            {
+                VertexDTO newVertex = vertexConvertStrategy.Convert(item);
+                NewItem.AddVertex(newVertex);
+            }
+            return NewItem;
+        }
+    }
+}

DataAccess/DTOs/Converters/Shapes/ShapeToDTOConvertStrategy.cs

@@ -9,6 +9,7 @@ namespace DataAccess.DTOs
     {
         private IConvertStrategy<RectangleShapeDTO, IRectangleShape> rectangleConvertStrategy;
         private IConvertStrategy<CircleShapeDTO, ICircleShape> circleConvertStrategy;
+        private IConvertStrategy<LinePolygonShapeDTO, ILinePolygonShape> linePolygonToDTOConvertStrategy;
 
         public ShapeToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
         {
@@ -32,6 +33,10 @@ namespace DataAccess.DTOs
             {
                 ProcessCircle(circle);
             }
+            else if (source is ILinePolygonShape linePolygon)
+            {
+                ProcessLinePolygon(linePolygon);
+            }
             else
             {
                 string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source) + ": shape type";
@@ -40,6 +45,13 @@ namespace DataAccess.DTOs
             TraceLogger?.AddMessage($"Shape converting Id = {NewItem.Id} has been has been finished successfully", TraceLogStatuses.Debug);
         }
 
+        private void ProcessLinePolygon(ILinePolygonShape linePolygon)
+        {
+            TraceLogger?.AddMessage($"Shape is line polygon", TraceLogStatuses.Debug);
+            linePolygonToDTOConvertStrategy = new DictionaryConvertStrategy<LinePolygonShapeDTO, ILinePolygonShape>(this, new LinePolygonToDTOConvertStrategy(this));
+            NewItem = linePolygonToDTOConvertStrategy.Convert(linePolygon);
+        }
+
         private void ProcessCircle(ICircleShape circle)
         {
             TraceLogger?.AddMessage($"Shape is circle", TraceLogStatuses.Debug);

DataAccess/DTOs/Converters/Shapes/VertexToDTOConvertStrategy.cs

@@ -0,0 +1,26 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
+
+namespace DataAccess.DTOs
+{
+    public class VertexToDTOConvertStrategy : ConvertStrategy<VertexDTO, IVertex>
+    {
+        private IUpdateStrategy<IVertex> updateStrategy;
+        private IConvertStrategy<Point2DDTO, IPoint2D> pointConvertStrategy;
+
+        public VertexToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override VertexDTO GetNewItem(IVertex source)
+        {
+            ChildClass = this;
+            NewItem = new(source.Id);
+            updateStrategy = new VertexUpdateStrategy() { UpdateChildren = false };
+            pointConvertStrategy = new Point2DToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger};
+            updateStrategy.Update(NewItem, source);
+            NewItem.Point = pointConvertStrategy.Convert(source.Point);
+            return NewItem;
+        }
+    }
+}

DataAccess/DTOs/Converters/VisualPropertyToDTOConvertStrategy.cs

@@ -2,13 +2,8 @@
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Loggers;
 using StructureHelperLogics.NdmCalculations.Primitives;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
-namespace DataAccess.DTOs.Converters
+namespace DataAccess.DTOs
 {
     public class VisualPropertyToDTOConvertStrategy : IConvertStrategy<VisualPropertyDTO, IVisualProperty>
     {

DataAccess/DTOs/DTOEntities/NdmCrossSections/EllipseNdmPrimitiveDTO.cs

@@ -11,6 +11,11 @@ namespace DataAccess.DTOs
     {
         private IRectangleShape shape = new RectangleShapeDTO(Guid.Empty);
 
+        public EllipseNdmPrimitiveDTO(Guid id)
+        {
+            Id = id;
+        }
+
         [JsonProperty("Id")]
         public Guid Id { get; set; }
         [JsonProperty("Name")]
@@ -42,7 +47,7 @@ namespace DataAccess.DTOs
 
         public object Clone()
         {
-            throw new NotImplementedException();
+            return this;
         }
 
         public IEnumerable<INdm> GetNdms(ITriangulationOptions triangulationOptions)

DataAccess/DTOs/DTOEntities/NdmCrossSections/ShapeNdmPrimitiveDTO.cs

@@ -0,0 +1,67 @@
+using LoaderCalculator.Data.Ndms;
+using Newtonsoft.Json;
+using StructureHelperCommon.Models.Shapes;
+using StructureHelperLogics.Models.CrossSections;
+using StructureHelperLogics.NdmCalculations.Primitives;
+using StructureHelperLogics.NdmCalculations.Triangulations;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataAccess.DTOs
+{
+    public class ShapeNdmPrimitiveDTO : IShapeNdmPrimitive
+    {
+        private IShape shape;
+
+        [JsonProperty("Id")]
+        public Guid Id { get; }
+        [JsonProperty("Name")]
+        public string? Name { get; set; }
+        [JsonProperty("Shape")]
+        public IShape Shape => shape;
+        [JsonProperty("NdmElement")]
+        public INdmElement NdmElement { get; set; }
+        [JsonProperty("Center")]
+        public IPoint2D Center { get; set; }
+        [JsonProperty("VisualProperty")]
+        public IVisualProperty VisualProperty { get; set; }
+        [JsonProperty("RotationAngle")]
+        public double RotationAngle { get; set; }
+        [JsonProperty("DivisionSize")]
+        public IDivisionSize DivisionSize { get; set; }
+        [JsonIgnore]
+        public ICrossSection? CrossSection { get; set; }
+        public ShapeNdmPrimitiveDTO(Guid id)
+        {
+            Id = id;
+        }
+
+        public object Clone()
+        {
+            return this;
+        }
+
+        public IEnumerable<INdm> GetNdms(ITriangulationOptions triangulationOptions)
+        {
+            throw new NotImplementedException();
+        }
+
+        public List<INamedAreaPoint> GetValuePoints()
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsPointInside(IPoint2D point)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SetShape(IShape shape)
+        {
+            this.shape = shape;
+        }
+    }
+}

DataAccess/DTOs/DTOEntities/Shapes/CircleShapeDTO.cs

@@ -1,10 +1,5 @@
 using Newtonsoft.Json;
 using StructureHelperCommon.Models.Shapes;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace DataAccess.DTOs
 {

DataAccess/DTOs/DTOEntities/Shapes/LinePolygonShapeDTO.cs

@@ -0,0 +1,53 @@
+using Newtonsoft.Json;
+using StructureHelperCommon.Models.Shapes;
+
+namespace DataAccess.DTOs
+{
+    public class LinePolygonShapeDTO : ILinePolygonShape
+    {
+        private readonly List<IVertex> _vertices = [];
+        [JsonProperty("Id")]
+        public Guid Id { get; }
+        [JsonProperty("Vertices")]
+        public IReadOnlyList<IVertex> Vertices => _vertices;
+        [JsonProperty("IsClosed")]
+        public bool IsClosed { get; set; }
+
+
+        public LinePolygonShapeDTO(Guid id)
+        {
+            Id = id;
+        }
+
+        public IVertex AddVertex(IVertex vertex)
+        {
+            _vertices.Add(vertex);
+            return vertex;
+        }
+
+        public IVertex AddVertexAfter(IVertex existing, IVertex vertex)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IVertex AddVertexBefore(IVertex existing, IVertex vertex)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Clear()
+        {
+            _vertices.Clear();
+        }
+
+        public IVertex InsertVertex(int index, IVertex vertex)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void RemoveVertex(IVertex vertex)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

DataAccess/DTOs/DTOEntities/Shapes/VertexDTO.cs

@@ -0,0 +1,23 @@
+using Newtonsoft.Json;
+using StructureHelperCommon.Models.Shapes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataAccess.DTOs
+{
+    public class VertexDTO : IVertex
+    {
+        [JsonProperty("Id")]
+        public Guid Id { get; }
+        [JsonProperty("Point")]
+        public IPoint2D Point { get; set; }
+
+        public VertexDTO(Guid id)
+        {
+            Id = id;
+        }
+    }
+}