From 018a989ba6e16bfde7d4bb2a812d45dec08a23d5 Mon Sep 17 00:00:00 2001 From: Evgeny Redikultsev Date: Sun, 6 Oct 2024 17:53:49 +0500 Subject: [PATCH] Add Safety FactorConverter --- DataAccess/DTOs/ConcreteLibMaterialDTO.cs | 35 +++++++-- ...ConcreteLibMaterialToDTOConvertStrategy.cs | 20 ++++- .../HeadMaterialToDTOConvertStrategy.cs | 24 +++++- .../HelperMaterialToDTOConvertStrategy.cs | 29 ++++++- .../LibMaterialDTOUpdateStrategy.cs | 55 ++++++++++++++ ...aterialSafetyFactorToDTOConvertStrategy.cs | 28 +++++++ DataAccess/DTOs/MaterialPartialFactorDTO.cs | 24 ++++++ DataAccess/DTOs/MaterialSafetyFactorDTO.cs | 36 +++++++++ DataAccess/DTOs/TypeBinderListFactory.cs | 6 ++ .../Models/Materials/ConcreteCurveLogic.cs | 7 ++ .../Factories/MaterialLogicsFactory.cs | 21 +++++- .../Models/Materials/IMaterialLogic.cs | 3 +- .../MaterialPartialFactorUpdateStrategy.cs | 5 +- .../MaterialSafetyFactorUpdateStrategy.cs | 5 +- .../Libraries/MaterialPartialFactor.cs | 15 ++-- .../Materials/ReinforcementByBuilderLogic.cs | 6 ++ .../Models/Materials/ConcreteLibMaterial.cs | 3 +- .../Logics/ConcreteLibUpdateStrategy.cs | 5 +- .../Logics/HeadMaterialUpdateStrategy.cs | 62 ++------------- .../Logics/HelperMaterialUpdateStrategy.cs | 75 +++++++++++++++++++ .../Logics/LibMaterialUpdateStrategy.cs | 9 ++- 21 files changed, 387 insertions(+), 86 deletions(-) create mode 100644 DataAccess/DTOs/Converters/LibMaterialDTOUpdateStrategy.cs create mode 100644 DataAccess/DTOs/Converters/MaterialSafetyFactorToDTOConvertStrategy.cs create mode 100644 DataAccess/DTOs/MaterialPartialFactorDTO.cs create mode 100644 DataAccess/DTOs/MaterialSafetyFactorDTO.cs create mode 100644 StructureHelperLogics/Models/Materials/Logics/HelperMaterialUpdateStrategy.cs diff --git a/DataAccess/DTOs/ConcreteLibMaterialDTO.cs b/DataAccess/DTOs/ConcreteLibMaterialDTO.cs index 9149740..778634d 100644 --- a/DataAccess/DTOs/ConcreteLibMaterialDTO.cs +++ b/DataAccess/DTOs/ConcreteLibMaterialDTO.cs @@ -1,12 +1,14 @@ using LoaderCalculator.Data.Materials; using Newtonsoft.Json; using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Settings; using StructureHelperCommon.Models.Materials; using StructureHelperCommon.Models.Materials.Libraries; using StructureHelperLogics.Models.Materials; using System; using System.Collections.Generic; using System.Linq; +using System.Net.Http.Headers; using System.Text; using System.Threading.Tasks; @@ -14,6 +16,8 @@ namespace DataAccess.DTOs { public class ConcreteLibMaterialDTO : IConcreteLibMaterial { + const MaterialTypes materialType = MaterialTypes.Concrete; + [JsonProperty("Id")] public Guid Id { get; set; } [JsonProperty("RelativeHumidity")] @@ -22,19 +26,36 @@ namespace DataAccess.DTOs public double MinAge { get; set; } [JsonProperty("MaxAge")] public double MaxAge { get; set; } - [JsonProperty("MaterialEntity")] + [JsonProperty("MaterialEntityId")] + public Guid MaterialEntityId + { + get => MaterialEntity.Id; + set + { + MaterialEntity = ProgramSetting.MaterialRepository.Repository.Single(x => x.Id == value); + } + } + [JsonIgnore] public ILibMaterialEntity MaterialEntity { get; set; } [JsonProperty("SafetyFactors")] - public List SafetyFactors { get; set; } + public List SafetyFactors { get; set; } = new(); [JsonProperty("TensionForULS")] public bool TensionForULS { get; set; } [JsonProperty("TensionForSLS")] public bool TensionForSLS { get; set; } - - - public IMaterialLogic MaterialLogic { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } - - public List MaterialLogics => throw new NotImplementedException(); + [JsonProperty("MaterialLogicId")] + public Guid MaterialLogicId + { + get => MaterialLogic.Id; + set + { + MaterialLogic = MaterialLogics.Single(x => x.Id == value); + } + } + [JsonIgnore] + public IMaterialLogic MaterialLogic { get; set; } + [JsonIgnore] + public List MaterialLogics { get; } = ProgramSetting.MaterialLogics.Where(x => x.MaterialType == materialType).ToList(); public object Clone() { diff --git a/DataAccess/DTOs/Converters/ConcreteLibMaterialToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ConcreteLibMaterialToDTOConvertStrategy.cs index 65692b0..4445907 100644 --- a/DataAccess/DTOs/Converters/ConcreteLibMaterialToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ConcreteLibMaterialToDTOConvertStrategy.cs @@ -1,5 +1,6 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Loggers; using StructureHelperLogics.Models.CrossSections; using StructureHelperLogics.Models.Materials; using System; @@ -12,13 +13,30 @@ namespace DataAccess.DTOs.Converters { public class ConcreteLibMaterialToDTOConvertStrategy : IConvertStrategy { + private IUpdateStrategy updateStrategy = new ConcreteLibUpdateStrategy(); + private IUpdateStrategy libMaterialUpdateStrategy = new LibMaterialDTOUpdateStrategy(); public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } public IShiftTraceLogger TraceLogger { get; set; } public ConcreteLibMaterialDTO Convert(IConcreteLibMaterial source) { Check(); - + ConcreteLibMaterialDTO newItem = new() + { + Id = source.Id + }; + try + { + updateStrategy.Update(newItem, source); + libMaterialUpdateStrategy.Update(newItem, source); + } + catch (Exception ex) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + throw; + } + return newItem; } private void Check() diff --git a/DataAccess/DTOs/Converters/HeadMaterialToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/HeadMaterialToDTOConvertStrategy.cs index 50af73a..2991b50 100644 --- a/DataAccess/DTOs/Converters/HeadMaterialToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/HeadMaterialToDTOConvertStrategy.cs @@ -1,6 +1,7 @@ using StructureHelper.Models.Materials; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; +using StructureHelperLogics.Models.CrossSections; using StructureHelperLogics.Models.Materials; using System; using System.Collections.Generic; @@ -13,13 +14,18 @@ namespace DataAccess.DTOs.Converters public class HeadMaterialToDTOConvertStrategy : IConvertStrategy { private IUpdateStrategy updateStrategy; + private IConvertStrategy convertStrategy; - public HeadMaterialToDTOConvertStrategy(IUpdateStrategy updateStrategy) + public HeadMaterialToDTOConvertStrategy(IUpdateStrategy updateStrategy, + IConvertStrategy convertStrategy) { this.updateStrategy = updateStrategy; + this.convertStrategy = convertStrategy; } - public HeadMaterialToDTOConvertStrategy() : this (new HeadMaterialUpdateStrategy()) + public HeadMaterialToDTOConvertStrategy() : this ( + new HeadMaterialUpdateStrategy(), + new HelperMaterialToDTOConvertStrategy()) { } @@ -29,8 +35,20 @@ namespace DataAccess.DTOs.Converters public HeadMaterialDTO Convert(IHeadMaterial source) { - HeadMaterialDTO newItem = new() { Id = source.Id}; + TraceLogger?.AddMessage($"Convert material Id={source.Id}, name is {source.Name}"); + HeadMaterialDTO newItem = new() + { + Id = source.Id + }; updateStrategy.Update(newItem, source); + convertStrategy.ReferenceDictionary = ReferenceDictionary; + var convertLogic = new DictionaryConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + ConvertStrategy = convertStrategy, + TraceLogger = TraceLogger + }; + newItem.HelperMaterial = convertLogic.Convert(source.HelperMaterial); return newItem; } } diff --git a/DataAccess/DTOs/Converters/HelperMaterialToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/HelperMaterialToDTOConvertStrategy.cs index 5e93b93..74efe81 100644 --- a/DataAccess/DTOs/Converters/HelperMaterialToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/HelperMaterialToDTOConvertStrategy.cs @@ -1,4 +1,5 @@ -using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperLogics.Models.CrossSections; using StructureHelperLogics.Models.Materials; @@ -12,12 +13,38 @@ namespace DataAccess.DTOs.Converters { internal class HelperMaterialToDTOConvertStrategy : IConvertStrategy { + private IConvertStrategy concreteConvertStrategy; public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } public IShiftTraceLogger TraceLogger { get; set; } + public HelperMaterialToDTOConvertStrategy( + IConvertStrategy concreteConvertStrategy) + { + this.concreteConvertStrategy = concreteConvertStrategy; + } + + public HelperMaterialToDTOConvertStrategy() : this (new ConcreteLibMaterialToDTOConvertStrategy()) + { + + } + public IHelperMaterial Convert(IHelperMaterial source) { Check(); + if (source is IConcreteLibMaterial concreteLibMaterial) + { + concreteConvertStrategy.ReferenceDictionary = ReferenceDictionary; + concreteConvertStrategy.TraceLogger = TraceLogger; + return concreteConvertStrategy.Convert(concreteLibMaterial); + } + if (source is IReinforcementLibMaterial reinforcementMaterial) + { + return source; + } + else + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source)); + } } private void Check() diff --git a/DataAccess/DTOs/Converters/LibMaterialDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/LibMaterialDTOUpdateStrategy.cs new file mode 100644 index 0000000..9962149 --- /dev/null +++ b/DataAccess/DTOs/Converters/LibMaterialDTOUpdateStrategy.cs @@ -0,0 +1,55 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Materials.Libraries; +using StructureHelperCommon.Services; +using StructureHelperLogics.Models.Materials; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs.Converters +{ + public class LibMaterialDTOUpdateStrategy : IUpdateStrategy + { + private IUpdateStrategy safetyFactorUpdateStrategy; + private IUpdateStrategy partialFactorUpdateStrategy; + + public LibMaterialDTOUpdateStrategy(IUpdateStrategy safetyFactorUpdateStrategy, + IUpdateStrategy partialFactorUpdateStrategy) + { + this.safetyFactorUpdateStrategy = safetyFactorUpdateStrategy; + this.partialFactorUpdateStrategy = partialFactorUpdateStrategy; + } + + public LibMaterialDTOUpdateStrategy() : this (new MaterialSafetyFactorUpdateStrategy(), + new MaterialPartialFactorUpdateStrategy()) + { + + } + + public void Update(ILibMaterial targetObject, ILibMaterial sourceObject) + { + CheckObject.IsNull(sourceObject); + CheckObject.IsNull(targetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + if (sourceObject.SafetyFactors is not null) + { + targetObject.SafetyFactors.Clear(); + foreach (var safetyFactor in sourceObject.SafetyFactors) + { + MaterialSafetyFactorDTO newSafetyFactor = new() { Id = safetyFactor.Id}; + safetyFactorUpdateStrategy.Update(newSafetyFactor, safetyFactor); + newSafetyFactor.PartialFactors.Clear(); + foreach (var partialFactor in safetyFactor.PartialFactors) + { + MaterialPartialFactorDTO newPartialFactor = new() { Id = partialFactor.Id }; + partialFactorUpdateStrategy.Update(newPartialFactor, partialFactor); + newSafetyFactor.PartialFactors.Add(newPartialFactor); + } + targetObject.SafetyFactors.Add(newSafetyFactor); + } + } + } + } +} diff --git a/DataAccess/DTOs/Converters/MaterialSafetyFactorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/MaterialSafetyFactorToDTOConvertStrategy.cs new file mode 100644 index 0000000..4c9252e --- /dev/null +++ b/DataAccess/DTOs/Converters/MaterialSafetyFactorToDTOConvertStrategy.cs @@ -0,0 +1,28 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Materials.Libraries; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class MaterialSafetyFactorToDTOConvertStrategy : IConvertStrategy + { + private IUpdateStrategy updateStrategy; + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public MaterialSafetyFactorToDTOConvertStrategy(IUpdateStrategy updateStrategy) + { + this.updateStrategy = updateStrategy; + } + + public MaterialSafetyFactorDTO Convert(IMaterialSafetyFactor source) + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/MaterialPartialFactorDTO.cs b/DataAccess/DTOs/MaterialPartialFactorDTO.cs new file mode 100644 index 0000000..902f144 --- /dev/null +++ b/DataAccess/DTOs/MaterialPartialFactorDTO.cs @@ -0,0 +1,24 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Materials.Libraries; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class MaterialPartialFactorDTO : IMaterialPartialFactor + { + public Guid Id { get; set; } + public double FactorValue { get; set; } + public StressStates StressState { get; set; } + public CalcTerms CalcTerm { get; set; } + public LimitStates LimitState { get; set; } + + public object Clone() + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/MaterialSafetyFactorDTO.cs b/DataAccess/DTOs/MaterialSafetyFactorDTO.cs new file mode 100644 index 0000000..0657fab --- /dev/null +++ b/DataAccess/DTOs/MaterialSafetyFactorDTO.cs @@ -0,0 +1,36 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Materials.Libraries; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class MaterialSafetyFactorDTO : IMaterialSafetyFactor + { + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("Name")] + public string Name { get; set; } = string.Empty; + [JsonProperty("Take")] + public bool Take { get; set; } + [JsonProperty("Description")] + public string Description { get; set; } = string.Empty; + [JsonProperty("PartialFactors")] + public List PartialFactors { get; } = new(); + + + public object Clone() + { + throw new NotImplementedException(); + } + + public double GetFactor(StressStates stressState, CalcTerms calcTerm, LimitStates limitStates) + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/TypeBinderListFactory.cs b/DataAccess/DTOs/TypeBinderListFactory.cs index 3ce25fb..1c2c141 100644 --- a/DataAccess/DTOs/TypeBinderListFactory.cs +++ b/DataAccess/DTOs/TypeBinderListFactory.cs @@ -3,6 +3,7 @@ using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Models.Analyses; using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Materials.Libraries; using StructureHelperLogics.NdmCalculations.Primitives; using System; using System.Collections.Generic; @@ -43,15 +44,20 @@ namespace DataAccess.DTOs { (typeof(DateVersionDTO), "DateVersion") }, { (typeof(FileVersionDTO), "FileVersion") }, { (typeof(HeadMaterialDTO), "HeadMaterial") }, + { (typeof(MaterialSafetyFactorDTO), "MaterialSafetyFactor") }, { (typeof(NdmPrimitiveDTO), "NdmPrimitive") }, { (typeof(IVisualAnalysis), "IVisualAnalysis") }, { (typeof(List), "ListOfICalculator") }, { (typeof(List), "ListOfIDateVersion") }, { (typeof(List), "ListOfIForceAction") }, { (typeof(List), "ListOfIHeadMaterial") }, + { (typeof(List), "ListOfMaterialSafetyFactor") }, + { (typeof(List), "ListOfMaterialPartialFactor") }, { (typeof(List), "ListOfINdmPrimitive") }, + { (typeof(List), "ListOfPartialFactor") }, { (typeof(List), "ListOfIVisualAnalysis") }, { (typeof(ProjectDTO), "Project") }, + { (typeof(MaterialPartialFactorDTO), "MaterialPartialFactor") }, { (typeof(VersionProcessorDTO), "VersionProcessor") }, { (typeof(VisualAnalysisDTO), "VisualAnalysis") }, }; diff --git a/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs b/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs index 8031064..9745f4b 100644 --- a/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs +++ b/StructureHelperCommon/Models/Materials/ConcreteCurveLogic.cs @@ -2,6 +2,7 @@ using LoaderCalculator.Data.Materials.MaterialBuilders; using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; +using System; namespace StructureHelperCommon.Models.Materials { @@ -12,6 +13,7 @@ namespace StructureHelperCommon.Models.Materials private ConcreteLogicOptions options; + public Guid Id { get; private set; } public string Name { get; set; } public IMaterialLogicOptions Options { @@ -29,6 +31,11 @@ namespace StructureHelperCommon.Models.Materials public MaterialTypes MaterialType { get; set; } public DiagramType DiagramType { get; set; } + public ConcreteCurveLogic(Guid id) + { + Id = id; + } + public IMaterial GetLoaderMaterial() { GetLoaderOptions(); diff --git a/StructureHelperCommon/Models/Materials/Factories/MaterialLogicsFactory.cs b/StructureHelperCommon/Models/Materials/Factories/MaterialLogicsFactory.cs index a9912ff..a736738 100644 --- a/StructureHelperCommon/Models/Materials/Factories/MaterialLogicsFactory.cs +++ b/StructureHelperCommon/Models/Materials/Factories/MaterialLogicsFactory.cs @@ -15,9 +15,24 @@ namespace StructureHelperCommon.Models.Materials { var items = new List() { - new ReinforcementByBuilderLogic() { MaterialType = MaterialTypes.Reinforcement, Name="Bilinear", DiagramType = DiagramType.Bilinear}, - new ReinforcementByBuilderLogic() { MaterialType = MaterialTypes.Reinforcement, Name="Triplelinear", DiagramType = DiagramType.TripleLinear}, - new ConcreteCurveLogic() { MaterialType = MaterialTypes.Concrete, Name = "Curve", DiagramType = DiagramType.Curve}, + new ReinforcementByBuilderLogic(Guid.Parse("54c4fe40-8f82-4995-8930-81e65e97edb9")) + { + MaterialType = MaterialTypes.Reinforcement, + Name="Bilinear", + DiagramType = DiagramType.Bilinear + }, + new ReinforcementByBuilderLogic(Guid.Parse("c658b71d-13b1-458c-a1b0-c93d1324acad")) + { + MaterialType = MaterialTypes.Reinforcement, + Name="Triplelinear", + DiagramType = DiagramType.TripleLinear + }, + new ConcreteCurveLogic(Guid.Parse("b97e8168-76a1-4e24-ae98-9aa38edd1e9a")) + { + MaterialType = MaterialTypes.Concrete, + Name = "Curve", + DiagramType = DiagramType.Curve + }, }; return items; } diff --git a/StructureHelperCommon/Models/Materials/IMaterialLogic.cs b/StructureHelperCommon/Models/Materials/IMaterialLogic.cs index 71e77f8..9c8008d 100644 --- a/StructureHelperCommon/Models/Materials/IMaterialLogic.cs +++ b/StructureHelperCommon/Models/Materials/IMaterialLogic.cs @@ -1,6 +1,7 @@ using LoaderCalculator.Data.Materials; using LoaderCalculator.Data.Materials.MaterialBuilders; using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Interfaces; using System; using System.Collections.Generic; using System.Linq; @@ -9,7 +10,7 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Materials { - public interface IMaterialLogic + public interface IMaterialLogic : ISaveable { string Name { get; set; } IMaterialLogicOptions Options { get; set; } diff --git a/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialPartialFactorUpdateStrategy.cs b/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialPartialFactorUpdateStrategy.cs index d1747cd..6abab67 100644 --- a/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialPartialFactorUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialPartialFactorUpdateStrategy.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; using System; using System.Collections.Generic; using System.Linq; @@ -7,10 +8,12 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Materials.Libraries { - internal class MaterialPartialFactorUpdateStrategy : IUpdateStrategy + public class MaterialPartialFactorUpdateStrategy : IUpdateStrategy { public void Update(IMaterialPartialFactor targetObject, IMaterialPartialFactor sourceObject) { + CheckObject.IsNull(sourceObject); + CheckObject.IsNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.LimitState = sourceObject.LimitState; targetObject.StressState = sourceObject.StressState; diff --git a/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorUpdateStrategy.cs b/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorUpdateStrategy.cs index ae363de..77ae6c3 100644 --- a/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorUpdateStrategy.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; using System; using System.Collections.Generic; using System.Linq; @@ -7,10 +8,12 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Materials.Libraries { - internal class MaterialSafetyFactorUpdateStrategy : IUpdateStrategy + public class MaterialSafetyFactorUpdateStrategy : IUpdateStrategy { public void Update(IMaterialSafetyFactor targetObject, IMaterialSafetyFactor sourceObject) { + CheckObject.IsNull(sourceObject); + CheckObject.IsNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; targetObject.Take = sourceObject.Take; diff --git a/StructureHelperCommon/Models/Materials/Libraries/MaterialPartialFactor.cs b/StructureHelperCommon/Models/Materials/Libraries/MaterialPartialFactor.cs index 960a412..ece4de6 100644 --- a/StructureHelperCommon/Models/Materials/Libraries/MaterialPartialFactor.cs +++ b/StructureHelperCommon/Models/Materials/Libraries/MaterialPartialFactor.cs @@ -1,5 +1,6 @@ using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using System; namespace StructureHelperCommon.Models.Materials.Libraries @@ -7,16 +8,18 @@ namespace StructureHelperCommon.Models.Materials.Libraries public class MaterialPartialFactor : IMaterialPartialFactor { private double factorValue; + private IUpdateStrategy updateStrategy = new MaterialPartialFactorUpdateStrategy(); + public Guid Id { get; } - public StressStates StressState { get; set; } - public CalcTerms CalcTerm { get; set; } - public LimitStates LimitState { get; set; } + public StressStates StressState { get; set; } = StressStates.Compression; + public CalcTerms CalcTerm { get; set; } = CalcTerms.LongTerm; + public LimitStates LimitState { get; set; } = LimitStates.ULS; public double FactorValue { get => factorValue; set { - if (value < 0 ) + if (value < 0) { throw new StructureHelperException(ErrorStrings.FactorMustBeGraterThanZero); } @@ -28,9 +31,6 @@ namespace StructureHelperCommon.Models.Materials.Libraries public MaterialPartialFactor(Guid id) { Id = id; - StressState = StressStates.Compression; - LimitState = LimitStates.ULS; - CalcTerm = CalcTerms.LongTerm; FactorValue = 1d; } @@ -40,7 +40,6 @@ namespace StructureHelperCommon.Models.Materials.Libraries public object Clone() { var newItem = new MaterialPartialFactor(); - var updateStrategy = new MaterialPartialFactorUpdateStrategy(); updateStrategy.Update(newItem, this); return newItem; } diff --git a/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs b/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs index ac246ee..70dd8fb 100644 --- a/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs +++ b/StructureHelperCommon/Models/Materials/ReinforcementByBuilderLogic.cs @@ -3,6 +3,7 @@ using LoaderCalculator.Data.Materials.MaterialBuilders; using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Services; +using System; namespace StructureHelperCommon.Models.Materials { @@ -12,6 +13,7 @@ namespace StructureHelperCommon.Models.Materials private ReinforcementOptions materialOptions; private IMaterialOptionLogic optionLogic; + public Guid Id { get; private set; } public string Name { get; set; } public DiagramType DiagramType { get; set; } public IMaterialLogicOptions Options @@ -26,6 +28,10 @@ namespace StructureHelperCommon.Models.Materials public MaterialTypes MaterialType { get; set; } + public ReinforcementByBuilderLogic(Guid id) + { + Id = id; + } public IMaterial GetLoaderMaterial() { GetLoaderOptions(); diff --git a/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs b/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs index 074b1c7..c6075c7 100644 --- a/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs +++ b/StructureHelperLogics/Models/Materials/ConcreteLibMaterial.cs @@ -1,6 +1,7 @@ using LoaderCalculator.Data.Materials; using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Infrastructures.Settings; using StructureHelperCommon.Models.Materials; using StructureHelperCommon.Models.Materials.Libraries; @@ -18,6 +19,7 @@ namespace StructureHelperLogics.Models.Materials private IMaterialOptionLogic optionLogic; private IFactorLogic factorLogic => new FactorLogic(SafetyFactors); private LMLogic.ITrueStrengthLogic strengthLogic; + private IUpdateStrategy updateStrategy = new ConcreteLibUpdateStrategy(); /// public Guid Id { get; } @@ -64,7 +66,6 @@ namespace StructureHelperLogics.Models.Materials public object Clone() { var newItem = new ConcreteLibMaterial(); - var updateStrategy = new ConcreteLibUpdateStrategy(); updateStrategy.Update(newItem, this); return newItem; } diff --git a/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs index d7baf4d..5e5e721 100644 --- a/StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs +++ b/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; } } } diff --git a/StructureHelperLogics/Models/Materials/Logics/HeadMaterialUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/HeadMaterialUpdateStrategy.cs index aa2a9a1..53feb86 100644 --- a/StructureHelperLogics/Models/Materials/Logics/HeadMaterialUpdateStrategy.cs +++ b/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 { - private IUpdateStrategy elasticStrategy; - private IUpdateStrategy frStrategy; - private IUpdateStrategy concreteStrategy; - private IUpdateStrategy reinforcementStrategy; - public HeadMaterialUpdateStrategy(IUpdateStrategy elasticStrategy, - IUpdateStrategy frStrategy, - IUpdateStrategy concreteStrategy, - IUpdateStrategy reinforcementStrategy - ) + private IUpdateStrategy helperMaterialUpdateStrategy; + + public HeadMaterialUpdateStrategy(IUpdateStrategy 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()); - } - } } } diff --git a/StructureHelperLogics/Models/Materials/Logics/HelperMaterialUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/HelperMaterialUpdateStrategy.cs new file mode 100644 index 0000000..3a3c1a5 --- /dev/null +++ b/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 + { + private IUpdateStrategy elasticStrategy; + private IUpdateStrategy frStrategy; + private IUpdateStrategy concreteStrategy; + private IUpdateStrategy reinforcementStrategy; + public HelperMaterialUpdateStrategy(IUpdateStrategy elasticStrategy, + IUpdateStrategy frStrategy, + IUpdateStrategy concreteStrategy, + IUpdateStrategy 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()); + } + } + } +} diff --git a/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs b/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs index b4281e1..7695258 100644 --- a/StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs +++ b/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) {