Add converting beam shear analysis from DTOs

DataAccess/DTOs/Converters/BeamShears/BeamShearActionFromDTOConvertStrategy.cs

@@ -0,0 +1,62 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Models.Forces.BeamShearActions;
+using StructureHelperCommon.Services;
+
+namespace DataAccess.DTOs
+{
+    public class BeamShearActionFromDTOConvertStrategy : ConvertStrategy<BeamShearAction, BeamShearActionDTO>
+    {
+        private IUpdateStrategy<IBeamShearAction> updateStrategy;
+        private IConvertStrategy<FactoredForceTuple, FactoredForceTupleDTO> factoredTupleConvertStrategy;
+        private IConvertStrategy<BeamShearAxisAction, BeamShearAxisActionDTO> axisActionConvertStrategy;
+
+        public BeamShearActionFromDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+            : base(referenceDictionary, traceLogger)
+        {
+        }
+
+        public override BeamShearAction GetNewItem(BeamShearActionDTO source)
+        {
+            ChildClass = this;
+            CheckObjects(source);
+            InitializeStrategies();
+            GetNewAction(source);
+            return NewItem;
+        }
+
+        private void CheckObjects(BeamShearActionDTO source)
+        {
+            CheckObject.IsNull(source);
+            CheckObject.IsNull(source.ExternalForce);
+            CheckObject.IsNull(source.SupportAction);
+        }
+
+        private void GetNewAction(BeamShearActionDTO source)
+        {
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            if (source.ExternalForce is not FactoredForceTupleDTO forceTupleDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.ExternalForce));
+            }
+            NewItem.ExternalForce = factoredTupleConvertStrategy.Convert(forceTupleDTO);
+            if (source.SupportAction is not BeamShearAxisActionDTO axisActionDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.ExternalForce));
+            }
+            NewItem.SupportAction = axisActionConvertStrategy.Convert(axisActionDTO);
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new BeamShearActionUpdateStrategy();
+            factoredTupleConvertStrategy ??= new DictionaryConvertStrategy<FactoredForceTuple, FactoredForceTupleDTO>
+                (this, new FactoredForceTupleFromDTOConvertStrategy(this));
+            axisActionConvertStrategy ??= new DictionaryConvertStrategy<BeamShearAxisAction, BeamShearAxisActionDTO>
+                (this, new BeamShearAxisActionFromDTOConvertStrategy(this));
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/BeamShearActionToDTOConvertStrategy.cs

@@ -5,17 +5,17 @@ using StructureHelperCommon.Models.Forces.BeamShearActions;
 
 namespace DataAccess.DTOs
 {
-    public class BeamShearActionConvertStrategy : ConvertStrategy<BeamShearActionDTO, IBeamShearAction>
+    public class BeamShearActionToDTOConvertStrategy : ConvertStrategy<BeamShearActionDTO, IBeamShearAction>
     {
         private IUpdateStrategy<IBeamShearAction> updateStrategy;
         private IConvertStrategy<FactoredForceTupleDTO, IFactoredForceTuple> factoredTupleConvertStrategy;
         private IConvertStrategy<BeamShearAxisActionDTO, IBeamShearAxisAction> axisActionConvertStrategy;
 
-        public BeamShearActionConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        public BeamShearActionToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
         {
         }
 
-        public BeamShearActionConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+        public BeamShearActionToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
             : base(referenceDictionary, traceLogger)
         {
         }

DataAccess/DTOs/Converters/BeamShears/BeamShearAxisActionFromDTOConvertStrategy.cs

@@ -0,0 +1,67 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Models.Forces.BeamShearActions;
+using StructureHelperCommon.Services;
+
+namespace DataAccess.DTOs
+{
+    internal class BeamShearAxisActionFromDTOConvertStrategy : ConvertStrategy<BeamShearAxisAction, BeamShearAxisActionDTO>
+    {
+        private IUpdateStrategy<IBeamShearAxisAction> updateStrategy;
+        private IConvertStrategy<FactoredForceTuple, FactoredForceTupleDTO> factoredTupleConvertStrategy;
+        private IConvertStrategy<IBeamSpanLoad, IBeamSpanLoad> spanLoadConvertLogic;
+
+        public BeamShearAxisActionFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override BeamShearAxisAction GetNewItem(BeamShearAxisActionDTO source)
+        {
+            CheckObject.IsNull(source);
+            CheckObject.IsNull(source.SupportForce);
+            CheckObject.IsNull(source.ShearLoads);
+            InitializeStrategies();
+            GetNewAction(source);
+            return NewItem;
+        }
+
+        private void GetNewAction(BeamShearAxisActionDTO source)
+        {
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            if (source.SupportForce is not FactoredForceTupleDTO factoredForceTupleDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.SupportForce));
+            }
+            NewItem.SupportForce = factoredTupleConvertStrategy.Convert(factoredForceTupleDTO);
+            List<IBeamSpanLoad> beamSpanLoads = GetSpanLoads(source.ShearLoads);
+            NewItem.ShearLoads.Clear();
+            NewItem.ShearLoads.AddRange(beamSpanLoads);
+        }
+
+        private List<IBeamSpanLoad> GetSpanLoads(IEnumerable<IBeamSpanLoad> shearLoads)
+        {
+            List<IBeamSpanLoad> beamSpanLoads = new();
+            foreach (var spanLoad in shearLoads)
+            {
+                beamSpanLoads.Add(ProcessSpanLoad(spanLoad));
+            }
+            return beamSpanLoads;
+        }
+
+        private IBeamSpanLoad ProcessSpanLoad(IBeamSpanLoad spanLoad)
+        {
+            return spanLoadConvertLogic.Convert(spanLoad);
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new BeamShearAxisActionUpdateStrategy();
+            factoredTupleConvertStrategy ??= new DictionaryConvertStrategy<FactoredForceTuple, FactoredForceTupleDTO>
+                (this, new FactoredForceTupleFromDTOConvertStrategy(this));
+            spanLoadConvertLogic ??= new DictionaryConvertStrategy<IBeamSpanLoad, IBeamSpanLoad>
+                (this, new BeamSpanLoadFromDTOConvertStrategy(this));
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorFromDTOConvertStrategy.cs

@@ -0,0 +1,46 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Services;
+using StructureHelperLogics.Models.BeamShears;
+
+namespace DataAccess.DTOs
+{
+    internal class BeamShearCalculatorFromDTOConvertStrategy : ConvertStrategy<BeamShearCalculator, BeamShearCalculatorDTO>
+    {
+        private IUpdateStrategy<IBeamShearCalculator> updateStrategy;
+        private IConvertStrategy<BeamShearCalculatorInputData, BeamShearCalculatorInputDataDTO> inputDataConvertStrategy;
+
+        public BeamShearCalculatorFromDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+            : base(referenceDictionary, traceLogger)
+        {
+        }
+
+        public override BeamShearCalculator GetNewItem(BeamShearCalculatorDTO source)
+        {
+            CheckObject.IsNull(source);
+            CheckObject.IsNull(source.InputData);
+            GetNewCalculator(source);
+            return NewItem;
+        }
+
+        private void GetNewCalculator(BeamShearCalculatorDTO source)
+        {
+            if (source.InputData is not BeamShearCalculatorInputDataDTO inputDataDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.InputData));
+            }
+            InitializeStrategies();
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            NewItem.InputData = inputDataConvertStrategy.Convert(inputDataDTO);
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new BeamShearCalculatorUpdateStrategy();
+            inputDataConvertStrategy = new DictionaryConvertStrategy<BeamShearCalculatorInputData, BeamShearCalculatorInputDataDTO>
+                (this, new BeamShearCalculatorInputDataFromDTOConvertStrategy(this));
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorInputDataFromDTOConvertStrategy.cs

@@ -0,0 +1,36 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperLogics.Models.BeamShears;
+
+namespace DataAccess.DTOs
+{
+    internal class BeamShearCalculatorInputDataFromDTOConvertStrategy : ConvertStrategy<BeamShearCalculatorInputData, BeamShearCalculatorInputDataDTO>
+    {
+        private IUpdateStrategy<IBeamShearCalculatorInputData> updateStrategy;
+        private IUpdateStrategy<IHasBeamShearActions> actionUpdateStrategy;
+        private IUpdateStrategy<IHasBeamShearSections> sectionUpdateStrategy;
+        private IUpdateStrategy<IHasStirrups> stirrupUpdateStrategy;
+
+        public BeamShearCalculatorInputDataFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override BeamShearCalculatorInputData GetNewItem(BeamShearCalculatorInputDataDTO source)
+        {
+            InitializeStrategies();
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            actionUpdateStrategy.Update(NewItem, source);
+            sectionUpdateStrategy.Update(NewItem, source);
+            stirrupUpdateStrategy.Update(NewItem, source);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new BeamShearCalculatorInputDataUpdateStrategy();
+            actionUpdateStrategy ??= new HasBeamShearActionsFromDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
+            sectionUpdateStrategy ??= new HasBeamShearSectionsFromDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
+            stirrupUpdateStrategy ??= new HasStirrupsFromDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorInputDataToDTOConvertStrategy.cs

@@ -42,9 +42,9 @@ namespace DataAccess.DTOs
 
         private void InitializeStrategies()
         {
-            actionUpdateStrategy ??= new HasBeamShearActionToDTOConvertStrategy(ReferenceDictionary, TraceLogger);
+            actionUpdateStrategy ??= new HasBeamShearActionsToDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
-            sectionUpdateStrategy ??= new HasBeamShearSectionToDTOConvertStrategy(ReferenceDictionary, TraceLogger);
+            sectionUpdateStrategy ??= new HasBeamShearSectionsToDTORenameStrategy(ReferenceDictionary, TraceLogger);
-            stirrupUpdateStrategy ??= new HasStirrupToDTOConvertStrategy(ReferenceDictionary, TraceLogger);
+            stirrupUpdateStrategy ??= new HasStirrupsToDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
         }
     }
 }

DataAccess/DTOs/Converters/BeamShears/BeamShearFromDTOConvertStrategy.cs

@@ -0,0 +1,38 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+using StructureHelperLogics.Models.BeamShears;
+
+namespace DataAccess.DTOs
+{
+    public class BeamShearFromDTOConvertStrategy : ConvertStrategy<BeamShear, BeamShearDTO>
+    {
+        private IUpdateStrategy<IBeamShear> updateStrategy;
+
+        public BeamShearFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override BeamShear GetNewItem(BeamShearDTO source)
+        {
+            ChildClass = this;
+            CheckObject.IsNull(source);
+            CheckObject.IsNull(source.Repository);
+            GetNewBeamShear(source);
+            return NewItem;
+        }
+
+        private void GetNewBeamShear(IBeamShear source)
+        {
+            if (source.Repository is not BeamShearRepositoryDTO repositoryDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.Repository));
+            }
+            updateStrategy ??= new BeamShearUpdateStrategy();
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            BeamShearRepositoryFromDTOConvertStrategy convertStrategy = new(this);
+            NewItem.Repository = convertStrategy.Convert(repositoryDTO);
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/BeamShearRepositoryFromDTOConvertStrategy.cs

@@ -0,0 +1,43 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperLogics.Models.BeamShears;
+
+namespace DataAccess.DTOs
+{
+    public class BeamShearRepositoryFromDTOConvertStrategy : ConvertStrategy<BeamShearRepository, BeamShearRepositoryDTO>
+    {
+        private IUpdateStrategy<IHasBeamShearActions> actionUpdateStrategy;
+        private IUpdateStrategy<IHasBeamShearSections> sectionUpdateStrategy;
+        private IUpdateStrategy<IHasStirrups> stirrupUpdateStrategy;
+        private IUpdateStrategy<IHasCalculators> calculatorUpdateStrategy;
+
+        public BeamShearRepositoryFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override BeamShearRepository GetNewItem(BeamShearRepositoryDTO source)
+        {
+            ChildClass = this;
+            GetNewRepository(source);
+            return NewItem;
+        }
+
+        private void GetNewRepository(BeamShearRepositoryDTO source)
+        {
+            InitializeStrategies();
+            NewItem = new(source.Id);
+            actionUpdateStrategy.Update(NewItem, source);
+            sectionUpdateStrategy.Update(NewItem, source);
+            stirrupUpdateStrategy.Update(NewItem, source);
+            calculatorUpdateStrategy.Update(NewItem, source);
+        }
+
+        private void InitializeStrategies()
+        {
+            actionUpdateStrategy ??= new HasBeamShearActionsFromDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
+            sectionUpdateStrategy ??= new HasBeamShearSectionsFromDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
+            stirrupUpdateStrategy ??= new HasStirrupsFromDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
+            calculatorUpdateStrategy ??= new HasBeamShearCalculatorsFromDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/BeamShearRepositoryToDTOConvertStrategy.cs

@@ -51,10 +51,10 @@ namespace DataAccess.DTOs
 
         private void InitializeStrategies()
         {
-            actionUpdateStrategy ??= new HasBeamShearActionToDTOConvertStrategy(ReferenceDictionary, TraceLogger);
+            actionUpdateStrategy ??= new HasBeamShearActionsToDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
-            sectionUpdateStrategy ??= new HasBeamShearSectionToDTOConvertStrategy(ReferenceDictionary, TraceLogger);
+            sectionUpdateStrategy ??= new HasBeamShearSectionsToDTORenameStrategy(ReferenceDictionary, TraceLogger);
-            stirrupUpdateStrategy ??= new HasStirrupToDTOConvertStrategy(ReferenceDictionary, TraceLogger);
+            stirrupUpdateStrategy ??= new HasStirrupsToDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
-            calculatorUpdateStrategy ??= new HasBeamShearCalculatorToDTOConvertStrategy(ReferenceDictionary, TraceLogger);
+            calculatorUpdateStrategy ??= new HasBeamShearCalculatorsToDTOUpdateStrategy(ReferenceDictionary, TraceLogger);
         }
     }
 }

DataAccess/DTOs/Converters/BeamShears/BeamShearSectionFromDTOConvertStrategy.cs

@@ -0,0 +1,51 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Materials;
+using StructureHelperCommon.Models.Shapes;
+using StructureHelperLogics.Models.BeamShears;
+using StructureHelperLogics.Models.Materials;
+
+namespace DataAccess.DTOs
+{
+    public class BeamShearSectionFromDTOConvertStrategy : ConvertStrategy<BeamShearSection, BeamShearSectionDTO>
+    {
+        private IUpdateStrategy<IBeamShearSection> updateStrategy;
+        private IConvertStrategy<IShape, IShape> shapeConvertStrategy;
+        private IConvertStrategy<ConcreteLibMaterial, ConcreteLibMaterialDTO> concreteConvertStrategy;
+        private IUpdateStrategy<IHelperMaterial> safetyFactorUpdateStrategy;
+
+
+        public BeamShearSectionFromDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) : base(referenceDictionary, traceLogger)
+        {
+        }
+
+        public override BeamShearSection GetNewItem(BeamShearSectionDTO source)
+        {
+            InitializeStrategies();
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            NewItem.Shape = shapeConvertStrategy.Convert(source.Shape);
+            if (source.Material is not ConcreteLibMaterialDTO concreteDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.Material));
+            }
+            NewItem.Material = concreteConvertStrategy.Convert(concreteDTO);
+            safetyFactorUpdateStrategy.Update(NewItem.Material, concreteDTO);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new BeamShearSectionUpdateStrategy();
+            shapeConvertStrategy = new DictionaryConvertStrategy<IShape, IShape>
+                (this, new ShapeFromDTOConvertStrategy(this));
+            concreteConvertStrategy = new ConcreteLibMaterialFromDTOConvertStrategy()
+            {
+                ReferenceDictionary = ReferenceDictionary,
+                TraceLogger = TraceLogger
+            };
+            safetyFactorUpdateStrategy = new HelperMaterialDTOSafetyFactorUpdateStrategy(new MaterialSafetyFactorsFromDTOLogic());
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/BeamShearSectionToDTOConvertStrategy.cs

@@ -3,6 +3,7 @@ using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Materials;
 using StructureHelperCommon.Models.Shapes;
 using StructureHelperLogics.Models.BeamShears;
+using StructureHelperLogics.Models.Materials;
 
 namespace DataAccess.DTOs
 {
@@ -10,7 +11,7 @@ namespace DataAccess.DTOs
     {
         private IUpdateStrategy<IBeamShearSection> updateStrategy;
         private IConvertStrategy<IShape, IShape> shapeConvertStrategy;
-        private ConcreteLibMaterialToDTOConvertStrategy concreteConvertStrategy;
+        private IConvertStrategy<ConcreteLibMaterialDTO, IConcreteLibMaterial> concreteConvertStrategy;
         private IUpdateStrategy<IHelperMaterial> safetyFactorUpdateStrategy;
 
         public BeamShearSectionToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)

DataAccess/DTOs/Converters/BeamShears/BeamSpanLoadFromDTOConvertStrategy.cs

@@ -0,0 +1,46 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Services;
+
+namespace DataAccess.DTOs
+{
+    internal class BeamSpanLoadFromDTOConvertStrategy : ConvertStrategy<IBeamSpanLoad, IBeamSpanLoad>
+    {
+        public BeamSpanLoadFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override IBeamSpanLoad GetNewItem(IBeamSpanLoad source)
+        {
+            CheckObject.IsNull(source);
+            if (source is DistributedLoadDTO distributed)
+            {
+                ProcessDistributed(distributed);
+            }
+            else if (source is ConcentratedForceDTO concentrated)
+            {
+                ProcessConcentrated(concentrated);
+            }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source));
+            }
+            return NewItem;
+        }
+
+        private void ProcessConcentrated(ConcentratedForceDTO concentrated)
+        {
+            var convertLogic = new DictionaryConvertStrategy<ConcentratedForce, ConcentratedForceDTO>
+                (this, new ConcentratedForceFromDTOConvertStrategy(this));
+            NewItem = convertLogic.Convert(concentrated);
+        }
+
+        private void ProcessDistributed(DistributedLoadDTO distributed)
+        {
+            var convertLogic = new DictionaryConvertStrategy<DistributedLoad, DistributedLoadDTO>
+                (this, new DistributedLoadFromDTOConvertStrategy(this));
+            NewItem = convertLogic.Convert(distributed);
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/ConcentratedForceFromDTOConvertStrategy.cs

@@ -0,0 +1,45 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Models.Forces.BeamShearActions;
+
+namespace DataAccess.DTOs
+{
+    internal class ConcentratedForceFromDTOConvertStrategy : ConvertStrategy<ConcentratedForce, ConcentratedForceDTO>
+    {
+        private IUpdateStrategy<IConcentratedForce> updateStrategy;
+        private IConvertStrategy<ForceTuple, ForceTupleDTO> tupleConvertStrategy;
+        private IConvertStrategy<FactoredCombinationProperty, FactoredCombinationPropertyDTO> combinationConvertStrategy;
+
+        public ConcentratedForceFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override ConcentratedForce GetNewItem(ConcentratedForceDTO source)
+        {
+            InitializeStrategies();
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            if (source.ForceValue is not ForceTupleDTO forceTupleDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.ForceValue));
+            }
+            NewItem.ForceValue = tupleConvertStrategy.Convert(forceTupleDTO);
+            if (source.CombinationProperty is not FactoredCombinationPropertyDTO combinationPropertyDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.CombinationProperty));
+            }
+            NewItem.CombinationProperty = combinationConvertStrategy.Convert(combinationPropertyDTO);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new ConcentratedForceUpdateStrategy();
+            tupleConvertStrategy = new DictionaryConvertStrategy<ForceTuple, ForceTupleDTO>
+                (this, new ForceTupleFromDTOConvertStrategy(ReferenceDictionary, TraceLogger));
+            combinationConvertStrategy = new DictionaryConvertStrategy<FactoredCombinationProperty, FactoredCombinationPropertyDTO>
+                (this, new FactoredCombinationPropertyFromDTOConvertStrategy(ReferenceDictionary, TraceLogger));
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/DistributedLoadFromDTOConvertStrategy.cs

@@ -0,0 +1,45 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Models.Forces.BeamShearActions;
+
+namespace DataAccess.DTOs
+{
+    internal class DistributedLoadFromDTOConvertStrategy : ConvertStrategy<DistributedLoad, DistributedLoadDTO>
+    {
+        private IUpdateStrategy<IDistributedLoad> updateStrategy;
+        private IConvertStrategy<ForceTuple, ForceTupleDTO> tupleConvertStrategy;
+        private IConvertStrategy<FactoredCombinationProperty, FactoredCombinationPropertyDTO> combinationConvertStrategy;
+
+        public DistributedLoadFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override DistributedLoad GetNewItem(DistributedLoadDTO source)
+        {
+            InitializeStrategies();
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            if (source.LoadValue is not ForceTupleDTO forceTupleDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.LoadValue));
+            }
+            NewItem.LoadValue = tupleConvertStrategy.Convert(forceTupleDTO);
+            if (source.CombinationProperty is not FactoredCombinationPropertyDTO combinationPropertyDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.CombinationProperty));
+            }
+            NewItem.CombinationProperty = combinationConvertStrategy.Convert(combinationPropertyDTO);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new DistributedLoadUpdateStrategy();
+            tupleConvertStrategy = new DictionaryConvertStrategy<ForceTuple, ForceTupleDTO>
+                (this, new ForceTupleFromDTOConvertStrategy(ReferenceDictionary, TraceLogger));
+            combinationConvertStrategy = new DictionaryConvertStrategy<FactoredCombinationProperty, FactoredCombinationPropertyDTO>
+                (this, new FactoredCombinationPropertyFromDTOConvertStrategy(ReferenceDictionary, TraceLogger));
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsFromDTOUpdateStrategy.cs

@@ -0,0 +1,55 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Models.Forces.BeamShearActions;
+using StructureHelperCommon.Services;
+
+namespace DataAccess.DTOs
+{
+    public class HasBeamShearActionsFromDTOUpdateStrategy : IUpdateStrategy<IHasBeamShearActions>
+    {
+        private Dictionary<(Guid id, Type type), ISaveable> referenceDictionary;
+        private IShiftTraceLogger traceLogger;
+        private IConvertStrategy<BeamShearAction, BeamShearActionDTO> convertStrategy;
+        
+        public HasBeamShearActionsFromDTOUpdateStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+        {
+            this.referenceDictionary = referenceDictionary;
+            this.traceLogger = traceLogger;
+        }
+
+        public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject)
+        {
+            CheckObject.IsNull(targetObject);
+            CheckObject.IsNull(sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            CheckObject.IsNull(sourceObject.Actions);
+            CheckObject.IsNull(targetObject.Actions);
+            targetObject.Actions.Clear();
+            foreach (var action in sourceObject.Actions)
+            {
+                targetObject.Actions.Add(ProcessAction(action));
+
+            }
+        }
+
+        private IBeamShearAction ProcessAction(IBeamShearAction action)
+        {
+            if (action is not BeamShearActionDTO actionDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(action));
+            }
+            InitializeStrategies();
+            var newAction = convertStrategy.Convert(actionDTO);
+            return newAction;
+        }
+
+        private void InitializeStrategies()
+        {
+            convertStrategy ??= new DictionaryConvertStrategy<BeamShearAction, BeamShearActionDTO>(
+            referenceDictionary, traceLogger,
+            new BeamShearActionFromDTOConvertStrategy(referenceDictionary, traceLogger));
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsToDTOUpdateStrategy.cs

@@ -5,15 +5,15 @@ using StructureHelperCommon.Services;
 
 namespace DataAccess.DTOs
 {
-    public class HasBeamShearActionToDTOConvertStrategy : IUpdateStrategy<IHasBeamShearActions>
+    public class HasBeamShearActionsToDTOUpdateStrategy : IUpdateStrategy<IHasBeamShearActions>
     {
 
-        private Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get;}
+        private Dictionary<(Guid id, Type type), ISaveable> referenceDictionary;
-        private IShiftTraceLogger TraceLogger { get;}
+        private IShiftTraceLogger traceLogger;
-        public HasBeamShearActionToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+        public HasBeamShearActionsToDTOUpdateStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
         {
-            ReferenceDictionary = referenceDictionary;
+            this.referenceDictionary = referenceDictionary;
-            TraceLogger = traceLogger;
+            this.traceLogger = traceLogger;
         }
 
         public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject)
@@ -27,9 +27,9 @@ namespace DataAccess.DTOs
             foreach (var action in sourceObject.Actions)
             {
                 var convertStrategy = new DictionaryConvertStrategy<BeamShearActionDTO, IBeamShearAction>(
-                    ReferenceDictionary,
+                    referenceDictionary,
-                    TraceLogger,
+                    traceLogger,
-                    new BeamShearActionConvertStrategy(ReferenceDictionary, TraceLogger));
+                    new BeamShearActionToDTOConvertStrategy(referenceDictionary, traceLogger));
                 var newAction = convertStrategy.Convert(action);
                 targetObject.Actions.Add(newAction);
             }

DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsFromDTOUpdateStrategy.cs

@@ -0,0 +1,64 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperCommon.Services;
+using StructureHelperLogics.Models.BeamShears;
+
+namespace DataAccess.DTOs
+{
+    internal class HasBeamShearCalculatorsFromDTOUpdateStrategy : IUpdateStrategy<IHasCalculators>
+    {
+        private Dictionary<(Guid id, Type type), ISaveable> referenceDictionary;
+        private IShiftTraceLogger traceLogger;
+
+        public HasBeamShearCalculatorsFromDTOUpdateStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+        {
+            this.referenceDictionary = referenceDictionary;
+            this.traceLogger = traceLogger;
+        }
+
+        public void Update(IHasCalculators targetObject, IHasCalculators sourceObject)
+        {
+            CheckObject.IsNull(targetObject);
+            CheckObject.IsNull(sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            CheckObject.IsNull(sourceObject.Calculators);
+            CheckObject.IsNull(targetObject.Calculators);
+            targetObject.Calculators.Clear();
+            List<ICalculator> calculators = GetCalculators(sourceObject.Calculators);
+            targetObject.Calculators.AddRange(calculators);
+        }
+
+        private List<ICalculator> GetCalculators(IEnumerable<ICalculator> sourceCalculators)
+        {
+            List<ICalculator> calculators = new();
+            foreach (var calculator in sourceCalculators)
+            {
+                ICalculator newCalculator = ProcessCalculator(calculator);
+                calculators.Add(newCalculator);
+            }
+            return calculators;
+        }
+
+        private ICalculator ProcessCalculator(ICalculator calculator)
+        {
+            if (calculator is BeamShearCalculatorDTO shearCalculator)
+            {
+                return ProcessShearCalculator(shearCalculator);
+            }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(calculator));
+            }
+        }
+
+        private ICalculator ProcessShearCalculator(BeamShearCalculatorDTO shearCalculator)
+        {
+            traceLogger?.AddMessage("Calcultor is beam shear calculator", TraceLogStatuses.Debug);
+            var convertStrategy = new DictionaryConvertStrategy<BeamShearCalculator, BeamShearCalculatorDTO>
+                (referenceDictionary, traceLogger, new BeamShearCalculatorFromDTOConvertStrategy(referenceDictionary, traceLogger));
+            return convertStrategy.Convert(shearCalculator);
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsToDTOUpdateStrategy.cs

@@ -7,12 +7,12 @@ using StructureHelperLogics.Models.BeamShears;
 
 namespace DataAccess.DTOs
 {
-    public class HasBeamShearCalculatorToDTOConvertStrategy : IUpdateStrategy<IHasCalculators>
+    public class HasBeamShearCalculatorsToDTOUpdateStrategy : IUpdateStrategy<IHasCalculators>
     {
         private Dictionary<(Guid id, Type type), ISaveable> referenceDictionary;
         private IShiftTraceLogger traceLogger;
 
-        public HasBeamShearCalculatorToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+        public HasBeamShearCalculatorsToDTOUpdateStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
         {
             this.referenceDictionary = referenceDictionary;
             this.traceLogger = traceLogger;

DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsFromDTOUpdateStrategy.cs

@@ -0,0 +1,51 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Services;
+using StructureHelperLogics.Models.BeamShears;
+
+namespace DataAccess.DTOs
+{
+    public class HasBeamShearSectionsFromDTOUpdateStrategy : IUpdateStrategy<IHasBeamShearSections>
+    {
+        private Dictionary<(Guid id, Type type), ISaveable> referenceDictionary;
+        private IShiftTraceLogger traceLogger;
+        private IConvertStrategy<BeamShearSection, BeamShearSectionDTO> convertStrategy;
+
+        public HasBeamShearSectionsFromDTOUpdateStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+        {
+            this.referenceDictionary = referenceDictionary;
+            this.traceLogger = traceLogger;
+        }
+
+        public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject)
+        {
+            CheckObject.IsNull(targetObject);
+            CheckObject.IsNull(sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            CheckObject.IsNull(sourceObject.Sections);
+            CheckObject.IsNull(targetObject.Sections);
+            targetObject.Sections.Clear();
+            foreach (var section in sourceObject.Sections)
+            {
+                targetObject.Sections.Add(ProcessSection(section));
+            }
+        }
+
+        private IBeamShearSection ProcessSection(IBeamShearSection section)
+        {
+            if (section is not BeamShearSectionDTO sectionDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(section));
+            }
+            InitializeStrategies();
+            return convertStrategy.Convert(sectionDTO);
+        }
+
+        private void InitializeStrategies()
+        {
+            convertStrategy ??= new DictionaryConvertStrategy<BeamShearSection, BeamShearSectionDTO>
+                (referenceDictionary, traceLogger, new BeamShearSectionFromDTOConvertStrategy(referenceDictionary, traceLogger));
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsToDTORenameStrategy.cs

@@ -5,13 +5,13 @@ using StructureHelperLogics.Models.BeamShears;
 
 namespace DataAccess.DTOs
 {
-    public class HasBeamShearSectionToDTOConvertStrategy : IUpdateStrategy<IHasBeamShearSections>
+    public class HasBeamShearSectionsToDTORenameStrategy : IUpdateStrategy<IHasBeamShearSections>
     {
         private IConvertStrategy<BeamShearSectionDTO, IBeamShearSection> convertStrategy;
         private Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; }
         private IShiftTraceLogger TraceLogger { get; }
 
-        public HasBeamShearSectionToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+        public HasBeamShearSectionsToDTORenameStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
         {
             ReferenceDictionary = referenceDictionary;
             TraceLogger = traceLogger;

DataAccess/DTOs/Converters/BeamShears/HasStirrupsFromDTOUpdateStrategy.cs

@@ -0,0 +1,78 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperCommon.Services;
+using StructureHelperLogics.Models.BeamShears;
+
+namespace DataAccess.DTOs
+{
+    internal class HasStirrupsFromDTOUpdateStrategy : IUpdateStrategy<IHasStirrups>
+    {
+        private Dictionary<(Guid id, Type type), ISaveable> referenceDictionary;
+        private IShiftTraceLogger traceLogger;
+
+        public HasStirrupsFromDTOUpdateStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+        {
+            this.referenceDictionary = referenceDictionary;
+            this.traceLogger = traceLogger;
+        }
+
+        public void Update(IHasStirrups targetObject, IHasStirrups sourceObject)
+        {
+            CheckObject.IsNull(targetObject);
+            CheckObject.IsNull(sourceObject);
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+            CheckObject.IsNull(sourceObject.Stirrups);
+            CheckObject.IsNull(targetObject.Stirrups);
+            targetObject.Stirrups.Clear();
+            List<IStirrup> stirrups = GetStirrups(sourceObject.Stirrups);
+            targetObject.Stirrups.AddRange(stirrups);
+        }
+
+        private List<IStirrup> GetStirrups(IEnumerable<IStirrup> sourceStirrups)
+        {
+            List<IStirrup> stirrups = new();
+            foreach (var stirrup in sourceStirrups)
+            {
+                IStirrup newItem = ProcessStirrup(stirrup);
+                stirrups.Add(newItem);
+            }
+            return stirrups;
+        }
+
+        private IStirrup ProcessStirrup(IStirrup stirrup)
+        {
+            IStirrup newItem;
+            if (stirrup is StirrupByRebarDTO rebar)
+            {
+                newItem = ProcessRebar(rebar);
+            }
+            else if (stirrup is StirrupByDensityDTO density)
+            {
+                newItem = ProcessDensity(density);
+            }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(stirrup));
+            }
+
+            return newItem;
+        }
+
+        private StirrupByDensity ProcessDensity(StirrupByDensityDTO density)
+        {
+            traceLogger?.AddMessage("Stirrup is stirrup by density");
+            var convertStrategy = new DictionaryConvertStrategy<StirrupByDensity, StirrupByDensityDTO>
+                (referenceDictionary, traceLogger, new StirrupByDensityFromDTOConvertStrategy(referenceDictionary, traceLogger));
+            return convertStrategy.Convert(density);
+        }
+
+        private StirrupByRebar ProcessRebar(StirrupByRebarDTO rebar)
+        {
+            traceLogger?.AddMessage("Stirrup is stirrup by rebar");
+            var convertStrategy = new DictionaryConvertStrategy<StirrupByRebar, StirrupByRebarDTO>
+                (referenceDictionary, traceLogger, new StirrupByRebarFromDTOConvertStrategy(referenceDictionary, traceLogger));
+            return convertStrategy.Convert(rebar);
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/HasStirrupsToDTOUpdateStrategy.cs

@@ -3,21 +3,15 @@ using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Services;
 using StructureHelperLogics.Models.BeamShears;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using static System.Windows.Forms.VisualStyles.VisualStyleElement;
 
 namespace DataAccess.DTOs
 {
-    public class HasStirrupToDTOConvertStrategy : IUpdateStrategy<IHasStirrups>
+    public class HasStirrupsToDTOUpdateStrategy : IUpdateStrategy<IHasStirrups>
     {
         private Dictionary<(Guid id, Type type), ISaveable> referenceDictionary;
         private IShiftTraceLogger traceLogger;
 
-        public HasStirrupToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+        public HasStirrupsToDTOUpdateStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
         {
             this.referenceDictionary = referenceDictionary;
             this.traceLogger = traceLogger;

DataAccess/DTOs/Converters/BeamShears/StirrupByDensityFromDTOConvertStrategy.cs

@@ -0,0 +1,24 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperLogics.Models.BeamShears;
+
+namespace DataAccess.DTOs
+{
+    internal class StirrupByDensityFromDTOConvertStrategy : ConvertStrategy<StirrupByDensity, StirrupByDensityDTO>
+    {
+        private IUpdateStrategy<IStirrupByDensity> updateStrategy;
+
+        public StirrupByDensityFromDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+            : base(referenceDictionary, traceLogger)
+        {
+        }
+
+        public override StirrupByDensity GetNewItem(StirrupByDensityDTO source)
+        {
+            updateStrategy ??= new StirrupByDensityUpdateStrategy();
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            return NewItem;
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/StirrupByRebarFromDTOConvertStrategy.cs

@@ -0,0 +1,45 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
+using StructureHelperLogics.Models.BeamShears;
+using StructureHelperLogics.Models.Materials;
+
+namespace DataAccess.DTOs
+{
+    internal class StirrupByRebarFromDTOConvertStrategy : ConvertStrategy<StirrupByRebar, StirrupByRebarDTO>
+    {
+        private IUpdateStrategy<IStirrupByRebar> updateStrategy;
+        private IConvertStrategy<ReinforcementLibMaterial, ReinforcementLibMaterialDTO> reinforcementConvertStrategy;
+        private HelperMaterialDTOSafetyFactorUpdateStrategy safetyFactorUpdateStrategy;
+
+        public StirrupByRebarFromDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+            : base(referenceDictionary, traceLogger)
+        {
+        }
+
+        public override StirrupByRebar GetNewItem(StirrupByRebarDTO source)
+        {
+            InitializeStrategies();
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            if (source.Material is not ReinforcementLibMaterialDTO reinforcement)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.Material));
+            }
+            NewItem.Material = reinforcementConvertStrategy.Convert(reinforcement);
+            safetyFactorUpdateStrategy.Update(NewItem.Material, source.Material);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new StirrupByRebarUpdateStrategy();
+            reinforcementConvertStrategy = new ReinforcementLibMaterialFromDTOConvertStrategy()
+            {
+                ReferenceDictionary = ReferenceDictionary,
+                TraceLogger = TraceLogger
+            };
+            safetyFactorUpdateStrategy = new HelperMaterialDTOSafetyFactorUpdateStrategy(new MaterialSafetyFactorsFromDTOLogic());
+        }
+    }
+}

DataAccess/DTOs/Converters/BeamShears/StirrupByRebarToDTOConvertStrategy.cs

@@ -6,7 +6,7 @@ namespace DataAccess.DTOs
 {
     public class StirrupByRebarToDTOConvertStrategy : ConvertStrategy<StirrupByRebarDTO, IStirrupByRebar>
     {
-        private StirrupByRebarUpdateStrategy updateStrategy;
+        private IUpdateStrategy<IStirrupByRebar> updateStrategy;
         private ReinforcementLibMaterialToDTOConvertStrategy reinforcementConvertStrategy;
         private HelperMaterialDTOSafetyFactorUpdateStrategy safetyFactorUpdateStrategy;
 

DataAccess/DTOs/Converters/Forces/FactoredCombinationPropertyFromDTOConvertStrategy.cs

@@ -1,4 +1,5 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Forces;
 using StructureHelperCommon.Models.Forces.Logics;
 
@@ -7,6 +8,11 @@ namespace DataAccess.DTOs
     public class FactoredCombinationPropertyFromDTOConvertStrategy : ConvertStrategy<FactoredCombinationProperty, FactoredCombinationPropertyDTO>
     {
         private IUpdateStrategy<IFactoredCombinationProperty> updateStrategy;
+
+        public FactoredCombinationPropertyFromDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) : base(referenceDictionary, traceLogger)
+        {
+        }
+
         public override FactoredCombinationProperty GetNewItem(FactoredCombinationPropertyDTO source)
         {
             InitializeStrategies();

DataAccess/DTOs/Converters/Forces/FactoredForceTupleFromDTOConvertStrategy.cs

@@ -0,0 +1,59 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Forces;
+using StructureHelperCommon.Services;
+
+namespace DataAccess.DTOs
+{
+    public class FactoredForceTupleFromDTOConvertStrategy : ConvertStrategy<FactoredForceTuple, FactoredForceTupleDTO>
+    {
+        private IConvertStrategy<ForceTuple, ForceTupleDTO> tupleConvertStrategy;
+        private IConvertStrategy<FactoredCombinationProperty, FactoredCombinationPropertyDTO> combinationConvertStrategy;
+
+        public FactoredForceTupleFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy)
+            : base(baseConvertStrategy)
+        {
+        }
+
+        public override FactoredForceTuple GetNewItem(FactoredForceTupleDTO source)
+        {
+            ChildClass = this;
+            CheckObjects(source);
+            InitializeStrategies();
+            return GetNewFactoredTuple(source);
+        }
+
+        private FactoredForceTuple GetNewFactoredTuple(FactoredForceTupleDTO source)
+        {
+            if (source.ForceTuple is not ForceTupleDTO forceTupleDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.ForceTuple));
+            }
+            if (source.CombinationProperty is not FactoredCombinationPropertyDTO combinationPropertyDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.ForceTuple));
+            }
+            NewItem = new(source.Id)
+            {
+                ForceTuple = tupleConvertStrategy.Convert(forceTupleDTO),
+                CombinationProperty = combinationConvertStrategy.Convert(combinationPropertyDTO)
+            };
+            return NewItem;
+        }
+
+        private static void CheckObjects(FactoredForceTupleDTO source)
+        {
+            CheckObject.IsNull(source);
+            CheckObject.IsNull(source.ForceTuple);
+            CheckObject.IsNull(source.CombinationProperty);
+        }
+
+        private void InitializeStrategies()
+        {
+            tupleConvertStrategy = new DictionaryConvertStrategy<ForceTuple, ForceTupleDTO>
+                (this, new ForceTupleFromDTOConvertStrategy(ReferenceDictionary, TraceLogger));
+            combinationConvertStrategy = new DictionaryConvertStrategy<FactoredCombinationProperty, FactoredCombinationPropertyDTO>
+                (this, new FactoredCombinationPropertyFromDTOConvertStrategy(ReferenceDictionary, TraceLogger));
+        }
+    }
+}

DataAccess/DTOs/Converters/Forces/FactoredForceTupleToDTOConvertStrategy.cs

@@ -1,11 +1,6 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Forces;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace DataAccess.DTOs
 {

DataAccess/DTOs/Converters/Forces/ForceCombinationFromFileFromDTOConvertStrategy.cs

@@ -105,7 +105,7 @@ namespace DataAccess.DTOs
         {
             updateStrategy ??= new ForceCombinationFromFileUpdateStrategy();
             pointConvertStrategy = new Point2DFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger};
-            combinationPropertyConvertStrategy = new FactoredCombinationPropertyFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger};
+            combinationPropertyConvertStrategy = new FactoredCombinationPropertyFromDTOConvertStrategy(ReferenceDictionary, TraceLogger);
             fileConvertStrategy ??= new ColumnedFilePropertyFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
         }
     }

DataAccess/DTOs/Converters/Forces/ForceFactoredListFromDTOConvertStrategy.cs

@@ -87,7 +87,7 @@ namespace DataAccess.DTOs
             updateStrategy ??= new ForceFactoredListUpdateStrategy();
             pointConvertStrategy ??= new Point2DFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger};
             forceTupleConvertStrategy ??= new ForceTupleFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
-            combinationPropertyConvertStrategy ??= new FactoredCombinationPropertyFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
+            combinationPropertyConvertStrategy ??= new FactoredCombinationPropertyFromDTOConvertStrategy(ReferenceDictionary, TraceLogger);
         }
     }
 }

DataAccess/DTOs/Converters/Forces/ForceTupleFromDTOConvertStrategy.cs

@@ -1,29 +1,25 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Forces;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace DataAccess.DTOs
 {
     public class ForceTupleFromDTOConvertStrategy : ConvertStrategy<ForceTuple, ForceTupleDTO>
     {
-        private readonly IUpdateStrategy<IForceTuple> updateStrategy;
+        private IUpdateStrategy<IForceTuple> updateStrategy;
 
-        public ForceTupleFromDTOConvertStrategy(IUpdateStrategy<IForceTuple> updateStrategy)
+        public ForceTupleFromDTOConvertStrategy()
         {
-            this.updateStrategy = updateStrategy;
         }
 
-        public ForceTupleFromDTOConvertStrategy() : this(new ForceTupleUpdateStrategy())
+        public ForceTupleFromDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger)
+            : base(referenceDictionary, traceLogger)
         {
-            
         }
 
         public override ForceTuple GetNewItem(ForceTupleDTO source)
         {
+            updateStrategy ??= new ForceTupleUpdateStrategy();
             ForceTuple newItem = new(source.Id);
             updateStrategy.Update(newItem, source);
             return newItem;

DataAccess/DTOs/Converters/Materials/HelperMaterialFromDTOConvertStrategy.cs

@@ -1,16 +1,8 @@
-using DataAccess.DTOs.Converters;
+using StructureHelperCommon.Infrastructures.Exceptions;
-using StructureHelper.Models.Materials;
-using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Materials;
 using StructureHelperLogics.Models.Materials;
-using System;
-using System.CodeDom;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace DataAccess.DTOs
 {

DataAccess/DTOs/Converters/Materials/MaterialSafetyFactorsFromDTOLogic.cs

@@ -1,9 +1,4 @@
 using StructureHelperCommon.Models.Materials.Libraries;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace DataAccess.DTOs
 {

DataAccess/DTOs/Converters/NdmCrossSections/CrossSectionFromDTOConvertStrategy.cs

@@ -1,15 +1,9 @@
-using DataAccess.DTOs.Converters;
+using StructureHelperCommon.Infrastructures.Exceptions;
-using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.Loggers;
 using StructureHelperCommon.Models.WorkPlanes;
 using StructureHelperLogics.Models.CrossSections;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace DataAccess.DTOs
 {
@@ -18,15 +12,12 @@ namespace DataAccess.DTOs
         private IConvertStrategy<ICrossSectionRepository, ICrossSectionRepository> repositoryConvertStrategy;
         private IConvertStrategy<WorkPlaneProperty, WorkPlanePropertyDTO> workPlaneConvertStrategy;
 
-        public CrossSectionFromDTOConvertStrategy(IConvertStrategy<ICrossSectionRepository, ICrossSectionRepository> repositoryConvertStrategy,
+        public CrossSectionFromDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger? traceLogger)
-            IConvertStrategy<WorkPlaneProperty, WorkPlanePropertyDTO> workPlaneConvertStrategy)
         {
-            this.repositoryConvertStrategy = repositoryConvertStrategy;
+            ReferenceDictionary = referenceDictionary;
-            this.workPlaneConvertStrategy = workPlaneConvertStrategy;
+            TraceLogger = traceLogger;
         }
 
-        public CrossSectionFromDTOConvertStrategy() {  }
-
         public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; }
         public IShiftTraceLogger TraceLogger { get; set; }
 

DataAccess/DTOs/Converters/RectangleShapeFromDTOConvertStrategy.cs

@@ -0,0 +1,27 @@
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
+
+namespace DataAccess.DTOs
+{
+    internal class RectangleShapeFromDTOConvertStrategy : ConvertStrategy<RectangleShape, RectangleShapeDTO>
+    {
+        private IUpdateStrategy<IRectangleShape> updateStrategy;
+
+        public RectangleShapeFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override RectangleShape GetNewItem(RectangleShapeDTO source)
+        {
+            InitializeStrategies();
+            NewItem = new(source.Id);
+            updateStrategy.Update(NewItem, source);
+            return NewItem;
+        }
+
+        private void InitializeStrategies()
+        {
+            updateStrategy ??= new RectangleShapeUpdateStrategy();
+        }
+    }
+}

DataAccess/DTOs/Converters/ShapeFromDTOConvertStrategy.cs

@@ -0,0 +1,30 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Shapes;
+
+namespace DataAccess.DTOs
+{
+    internal class ShapeFromDTOConvertStrategy : ConvertStrategy<IShape, IShape>
+    {
+        private IConvertStrategy<RectangleShape, RectangleShapeDTO> rectangleConvertStrategy;
+
+        public ShapeFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
+        {
+        }
+
+        public override IShape GetNewItem(IShape source)
+        {
+            if (source is RectangleShapeDTO rectangleShapeDTO)
+            {
+                rectangleConvertStrategy ??= new DictionaryConvertStrategy<RectangleShape, RectangleShapeDTO>
+                    (this, new RectangleShapeFromDTOConvertStrategy(this));
+                NewItem = rectangleConvertStrategy.Convert(rectangleShapeDTO);
+            }
+            else
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source) + ": shape is unknown");
+            }
+            return NewItem;
+        }
+    }
+}

DataAccess/DTOs/Converters/ShapeToDTOConvertStrategy.cs

@@ -1,9 +1,7 @@
 using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
-using StructureHelperCommon.Models.Loggers;
 using StructureHelperCommon.Models.Shapes;
-using System.Windows.Forms;
 
 namespace DataAccess.DTOs
 {

DataAccess/DTOs/Converters/VersionItemFromDTOConvertStrategy.cs

@@ -38,22 +38,31 @@ namespace DataAccess.DTOs
                 TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error);
                 throw new StructureHelperException(errorString);
             }
-            TraceLogger?.AddMessage($"Object of type <<{newItem.GetType()}>> was obtained", TraceLogStatuses.Service);
+            TraceLogger?.AddMessage($"Object of type <<{newItem.GetType()}>> was obtained successfully", TraceLogStatuses.Service);
             return newItem;
         }
 
-        private ISaveable ProcessBeamShear(IBeamShear beamShear)
+        private IBeamShear ProcessBeamShear(IBeamShear source)
         {
-            throw new NotImplementedException();
+            if (source is not BeamShearDTO beamShearDTO)
+            {
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source));
+            }
+            TraceLogger?.AddMessage(AnalysisIs + " Beam shear", TraceLogStatuses.Service);
+            TraceLogger?.AddMessage($"Beam shear analysis Id = {source.Id} converting has been started", TraceLogStatuses.Service);
+            var convertLogic = new DictionaryConvertStrategy<BeamShear, BeamShearDTO>
+                (this,
+                new BeamShearFromDTOConvertStrategy(this));
+            IBeamShear newItem = convertLogic.Convert(beamShearDTO);
+            TraceLogger?.AddMessage($"Beam shear analysis Id = {newItem.Id} converting has been finished successfully", TraceLogStatuses.Service);
+            return newItem;
         }
 
         private ICrossSection ProcessCrossSection(ICrossSection source)
         {
             TraceLogger?.AddMessage(AnalysisIs + " Cross-Section", TraceLogStatuses.Service);
-            TraceLogger?.AddMessage("Cross-Section converting is started", TraceLogStatuses.Service);
+            TraceLogger?.AddMessage("Cross-Section converting has been started", TraceLogStatuses.Service);
-            crossSectionConvertStrategy ??= new CrossSectionFromDTOConvertStrategy();
+            crossSectionConvertStrategy ??= new CrossSectionFromDTOConvertStrategy(ReferenceDictionary, TraceLogger);
-            crossSectionConvertStrategy.ReferenceDictionary = ReferenceDictionary;
-            crossSectionConvertStrategy.TraceLogger = TraceLogger;
             var convertLogic = new DictionaryConvertStrategy<ICrossSection, ICrossSection>(this, crossSectionConvertStrategy);
             ICrossSection newItem = convertLogic.Convert(source);
             TraceLogger?.AddMessage("Cross-Section converting has been finished successfully", TraceLogStatuses.Service);

DataAccess/DTOs/Converters/WorkPlanePropertyFromDTOConvertStrategy.cs

@@ -1,13 +1,8 @@
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Models;
 using StructureHelperCommon.Models.WorkPlanes;
-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 WorkPlanePropertyFromDTOConvertStrategy : ConvertStrategy<WorkPlaneProperty, WorkPlanePropertyDTO>
     {

DataAccess/DTOs/DTOEntities/Forces/ForceTupleDTO.cs

@@ -1,10 +1,5 @@
 using Newtonsoft.Json;
 using StructureHelperCommon.Models.Forces;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace DataAccess.DTOs
 {
@@ -37,7 +32,7 @@ namespace DataAccess.DTOs
 
         public object Clone()
         {
-            throw new NotImplementedException();
+            return this;
         }
     }
 }

DataAccess/DTOs/DTOEntities/Materials/ConcreteLibMaterialDTO.cs

@@ -64,7 +64,7 @@ namespace DataAccess.DTOs
 
         public object Clone()
         {
-            throw new NotImplementedException();
+            return this;
         }
 
         public IMaterial GetCrackedLoaderMaterial(LimitStates limitState, CalcTerms calcTerm)

DataAccess/DTOs/DTOEntities/Materials/ReinforcementLibMaterialDTO.cs

@@ -49,7 +49,7 @@ namespace DataAccess.DTOs
 
         public object Clone()
         {
-            throw new NotImplementedException();
+            return this;
         }
 
         public IMaterial GetCrackedLoaderMaterial(LimitStates limitState, CalcTerms calcTerm)

StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs

@@ -73,13 +73,18 @@ namespace StructureHelperLogics.Models.BeamShears
         private void GetSections()
         {
             actionResults = new();
+            List<IStirrup> stirrups = inputData.Stirrups.ToList();
+            if (stirrups.Any() == false)
+            {
+                stirrups.Add(new StirrupByDensity(Guid.NewGuid()) { StirrupDensity = 0 });
+            }
             foreach (var beamShearAction in inputData.Actions)
             {
                 foreach (var calcTerm in calcTerms)
                 {
                     foreach (var section in inputData.Sections)
                     {
-                        foreach (var stirrup in inputData.Stirrups)
+                        foreach (var stirrup in stirrups)
                         {
                             List<IInclinedSection> inclinedSections = GetInclinedSections(section);
                             List<IBeamShearSectionLogicInputData> sectionInputDatas = GetSectionInputDatas(beamShearAction, calcTerm, section, stirrup, inclinedSections);

StructureHelperLogics/Models/BeamShears/BeamShearSection.cs

@@ -12,7 +12,7 @@ namespace StructureHelperLogics.Models.BeamShears
         /// <inheritdoc/>
         public IConcreteLibMaterial Material { get; set; } 
         /// <inheritdoc/>
-        public IShape Shape { get; } = new RectangleShape(Guid.NewGuid()) { Height = 0.6, Width = 0.4};
+        public IShape Shape { get; set; } = new RectangleShape(Guid.NewGuid()) { Height = 0.6, Width = 0.4};
 
         public double CenterCover { get; set; } = 0.05;
 

StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs

@@ -26,8 +26,8 @@ namespace StructureHelperLogics.Models.BeamShears
 
         private void InitializeStrategies()
         {
-            repositoryUpdateStrategy ??= new BeamShearRepositoryAddUpdateStrategy();
             clearStrategy ??= new BeamShearReporitoryClearStrategy();
+            repositoryUpdateStrategy ??= new BeamShearRepositoryAddUpdateStrategy();
         }
     }
 }

StructureHelperLogics/Models/BeamShears/IBeamShearSection.cs

@@ -17,7 +17,7 @@ namespace StructureHelperLogics.Models.BeamShears
         /// <summary>
         /// Shape of cross-section
         /// </summary>
-        IShape Shape { get; }
+        IShape Shape { get; set; }
         /// <summary>
         /// Distance from edge of tension zone to center of the nearest reinforcement bar
         /// </summary>

StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorInputDataUpdateStrategy.cs

@@ -4,7 +4,7 @@ using StructureHelperCommon.Services;
 
 namespace StructureHelperLogics.Models.BeamShears
 {
-    internal class BeamShearCalculatorInputDataUpdateStrategy : IUpdateStrategy<IBeamShearCalculatorInputData>
+    public class BeamShearCalculatorInputDataUpdateStrategy : IUpdateStrategy<IBeamShearCalculatorInputData>
     {
         private IUpdateStrategy<IHasBeamShearActions>? hasActionUpdateStrategy;
         private IUpdateStrategy<IHasStirrups>? hasStirrupsUpdateStrategy;

StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs

@@ -4,6 +4,9 @@ using StructureHelperCommon.Services;
 
 namespace StructureHelperLogics.Models.BeamShears
 {
+    /// <summary>
+    /// Add objects from one repository to another one without deleting previous objects
+    /// </summary>
     public class BeamShearRepositoryAddUpdateStrategy : IUpdateStrategy<IBeamShearRepository>
     {
         public void Update(IBeamShearRepository targetObject, IBeamShearRepository sourceObject)