Add Safety FactorConverter

StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs

@@ -21,12 +21,15 @@ namespace StructureHelperLogics.Models.Materials
         }
         public void Update(IConcreteLibMaterial targetObject, IConcreteLibMaterial sourceObject)
         {
-            CheckObject.CompareTypes(targetObject, sourceObject);
+            CheckObject.IsNull(sourceObject);
+            CheckObject.IsNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             libUpdateStrategy.Update(targetObject, sourceObject);
             targetObject.TensionForULS = sourceObject.TensionForULS;
             targetObject.TensionForSLS = sourceObject.TensionForSLS;
             targetObject.RelativeHumidity = sourceObject.RelativeHumidity;
+            targetObject.MinAge = sourceObject.MinAge;
+            targetObject.MaxAge = sourceObject.MaxAge;
         }
     }
 }

StructureHelperLogics/Models/Materials/Logics/HeadMaterialUpdateStrategy.cs

@@ -1,5 +1,4 @@
 using StructureHelper.Models.Materials;
-using StructureHelperCommon.Infrastructures.Exceptions;
 using StructureHelperCommon.Infrastructures.Interfaces;
 using StructureHelperCommon.Services;
 
@@ -7,27 +6,13 @@ namespace StructureHelperLogics.Models.Materials
 {
     public class HeadMaterialUpdateStrategy : IUpdateStrategy<IHeadMaterial>
     {
-        private IUpdateStrategy<IElasticMaterial> elasticStrategy;
-        private IUpdateStrategy<IFRMaterial> frStrategy;
-        private IUpdateStrategy<IConcreteLibMaterial> concreteStrategy;
-        private IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy;
-        public HeadMaterialUpdateStrategy(IUpdateStrategy<IElasticMaterial> elasticStrategy,
-            IUpdateStrategy<IFRMaterial> frStrategy,
-            IUpdateStrategy<IConcreteLibMaterial> concreteStrategy,
-            IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy
-            )
+        private IUpdateStrategy<IHelperMaterial> helperMaterialUpdateStrategy;
+
+        public HeadMaterialUpdateStrategy(IUpdateStrategy<IHelperMaterial> helperMaterialUpdateStrategy)
         {
-            this.elasticStrategy = elasticStrategy;
-            this.frStrategy = frStrategy;
-            this.concreteStrategy = concreteStrategy;
-            this.reinforcementStrategy= reinforcementStrategy;
+            this.helperMaterialUpdateStrategy = helperMaterialUpdateStrategy;
         }
-        public HeadMaterialUpdateStrategy() : this(
-            new ElasticUpdateStrategy(),
-            new FRUpdateStrategy(),
-            new ConcreteLibUpdateStrategy(),
-            new ReinforcementLibUpdateStrategy()
-        )  {         }
+        public HeadMaterialUpdateStrategy() : this(new HelperMaterialUpdateStrategy())  {         }
 
         public void Update(IHeadMaterial targetObject, IHeadMaterial sourceObject)
         {
@@ -37,44 +22,9 @@ namespace StructureHelperLogics.Models.Materials
             targetObject.Name = sourceObject.Name;
             targetObject.Color = sourceObject.Color;
             targetObject.HelperMaterial = sourceObject.HelperMaterial.Clone() as IHelperMaterial;
-            UpdateHelperMaterial(targetObject.HelperMaterial, sourceObject.HelperMaterial);
+            helperMaterialUpdateStrategy.Update(targetObject.HelperMaterial, sourceObject.HelperMaterial);
         }
 
-        private void UpdateHelperMaterial(IHelperMaterial targetObject, IHelperMaterial sourceObject)
-        {
-            CheckObject.CompareTypes(targetObject, sourceObject);
-            if (sourceObject is ILibMaterial)
-            {
-                UpdateLibMaterial(targetObject, sourceObject);
-            }
-            else if (sourceObject is IElasticMaterial)
-            {
-                elasticStrategy.Update(targetObject as IElasticMaterial, sourceObject as IElasticMaterial);
-            }
-            else if (sourceObject is IFRMaterial)
-            {
-                frStrategy.Update(targetObject as IFRMaterial, sourceObject as IFRMaterial);
-            }
-            else
-            {
-                ErrorCommonProcessor.ObjectTypeIsUnknown(typeof(IHelperMaterial), sourceObject.GetType());
-            }
-        }
 
-        private void UpdateLibMaterial(IHelperMaterial targetObject, IHelperMaterial sourceObject)
-        {
-            if (sourceObject is IConcreteLibMaterial)
-            {
-                concreteStrategy.Update(targetObject as IConcreteLibMaterial, sourceObject as IConcreteLibMaterial);
-            }
-            else if (sourceObject is IReinforcementLibMaterial)
-            {
-                reinforcementStrategy.Update(targetObject as IReinforcementLibMaterial, sourceObject as IReinforcementLibMaterial);
-            }
-            else
-            {
-                ErrorCommonProcessor.ObjectTypeIsUnknown(typeof(ILibMaterial), sourceObject.GetType());
-            }
-        }
     }
 }

StructureHelperLogics/Models/Materials/Logics/HelperMaterialUpdateStrategy.cs

@@ -0,0 +1,75 @@
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Services;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StructureHelperLogics.Models.Materials
+{
+    public class HelperMaterialUpdateStrategy : IUpdateStrategy<IHelperMaterial>
+    {
+        private IUpdateStrategy<IElasticMaterial> elasticStrategy;
+        private IUpdateStrategy<IFRMaterial> frStrategy;
+        private IUpdateStrategy<IConcreteLibMaterial> concreteStrategy;
+        private IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy;
+        public HelperMaterialUpdateStrategy(IUpdateStrategy<IElasticMaterial> elasticStrategy,
+            IUpdateStrategy<IFRMaterial> frStrategy,
+            IUpdateStrategy<IConcreteLibMaterial> concreteStrategy,
+            IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy
+            )
+        {
+            this.elasticStrategy = elasticStrategy;
+            this.frStrategy = frStrategy;
+            this.concreteStrategy = concreteStrategy;
+            this.reinforcementStrategy = reinforcementStrategy;
+        }
+        public HelperMaterialUpdateStrategy() : this(
+            new ElasticUpdateStrategy(),
+            new FRUpdateStrategy(),
+            new ConcreteLibUpdateStrategy(),
+            new ReinforcementLibUpdateStrategy()
+        )
+        { }
+
+        public void Update(IHelperMaterial targetObject, IHelperMaterial sourceObject)
+        {
+            CheckObject.IsNull(sourceObject);
+            CheckObject.IsNull(targetObject);
+            if (sourceObject is ILibMaterial)
+            {
+                UpdateLibMaterial(targetObject, sourceObject);
+            }
+            else if (sourceObject is IElasticMaterial)
+            {
+                elasticStrategy.Update(targetObject as IElasticMaterial, sourceObject as IElasticMaterial);
+            }
+            else if (sourceObject is IFRMaterial)
+            {
+                frStrategy.Update(targetObject as IFRMaterial, sourceObject as IFRMaterial);
+            }
+            else
+            {
+                ErrorCommonProcessor.ObjectTypeIsUnknown(typeof(IHelperMaterial), sourceObject.GetType());
+            }
+        }
+
+        private void UpdateLibMaterial(IHelperMaterial targetObject, IHelperMaterial sourceObject)
+        {
+            if (sourceObject is IConcreteLibMaterial)
+            {
+                concreteStrategy.Update(targetObject as IConcreteLibMaterial, sourceObject as IConcreteLibMaterial);
+            }
+            else if (sourceObject is IReinforcementLibMaterial)
+            {
+                reinforcementStrategy.Update(targetObject as IReinforcementLibMaterial, sourceObject as IReinforcementLibMaterial);
+            }
+            else
+            {
+                ErrorCommonProcessor.ObjectTypeIsUnknown(typeof(ILibMaterial), sourceObject.GetType());
+            }
+        }
+    }
+}

StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs

@@ -13,11 +13,16 @@ namespace StructureHelperLogics.Models.Materials
     {
         public void Update(ILibMaterial targetObject, ILibMaterial sourceObject)
         {
-            CheckObject.CompareTypes(targetObject, sourceObject);
+            CheckObject.IsNull(sourceObject);
+            CheckObject.IsNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.MaterialEntity = sourceObject.MaterialEntity;
-            if (targetObject.SafetyFactors is not null & sourceObject.SafetyFactors is not null)
+            if (sourceObject.SafetyFactors is not null)
             {
+                if (targetObject.SafetyFactors is null)
+                {
+                    targetObject.SafetyFactors = new();
+                }
                 targetObject.SafetyFactors.Clear();
                 foreach (var item in sourceObject.SafetyFactors)
                 {