diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearActionFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearActionFromDTOConvertStrategy.cs new file mode 100644 index 0000000..e228194 --- /dev/null +++ b/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 + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy factoredTupleConvertStrategy; + private IConvertStrategy 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 + (this, new FactoredForceTupleFromDTOConvertStrategy(this)); + axisActionConvertStrategy ??= new DictionaryConvertStrategy + (this, new BeamShearAxisActionFromDTOConvertStrategy(this)); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearActionConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearActionToDTOConvertStrategy.cs similarity index 85% rename from DataAccess/DTOs/Converters/BeamShears/BeamShearActionConvertStrategy.cs rename to DataAccess/DTOs/Converters/BeamShears/BeamShearActionToDTOConvertStrategy.cs index ef9a062..c8021b5 100644 --- a/DataAccess/DTOs/Converters/BeamShears/BeamShearActionConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/BeamShearActionToDTOConvertStrategy.cs @@ -5,17 +5,17 @@ using StructureHelperCommon.Models.Forces.BeamShearActions; namespace DataAccess.DTOs { - public class BeamShearActionConvertStrategy : ConvertStrategy + public class BeamShearActionToDTOConvertStrategy : ConvertStrategy { private IUpdateStrategy updateStrategy; private IConvertStrategy factoredTupleConvertStrategy; private IConvertStrategy 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) { } diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearAxisActionFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearAxisActionFromDTOConvertStrategy.cs new file mode 100644 index 0000000..c9a20fb --- /dev/null +++ b/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 + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy factoredTupleConvertStrategy; + private IConvertStrategy 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 beamSpanLoads = GetSpanLoads(source.ShearLoads); + NewItem.ShearLoads.Clear(); + NewItem.ShearLoads.AddRange(beamSpanLoads); + } + + private List GetSpanLoads(IEnumerable shearLoads) + { + List 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 + (this, new FactoredForceTupleFromDTOConvertStrategy(this)); + spanLoadConvertLogic ??= new DictionaryConvertStrategy + (this, new BeamSpanLoadFromDTOConvertStrategy(this)); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorFromDTOConvertStrategy.cs new file mode 100644 index 0000000..1f7a7e1 --- /dev/null +++ b/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 + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy 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 + (this, new BeamShearCalculatorInputDataFromDTOConvertStrategy(this)); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorInputDataFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorInputDataFromDTOConvertStrategy.cs new file mode 100644 index 0000000..398d43d --- /dev/null +++ b/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 + { + private IUpdateStrategy updateStrategy; + private IUpdateStrategy actionUpdateStrategy; + private IUpdateStrategy sectionUpdateStrategy; + private IUpdateStrategy 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); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorInputDataToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorInputDataToDTOConvertStrategy.cs index 119a5f3..342207d 100644 --- a/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorInputDataToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorInputDataToDTOConvertStrategy.cs @@ -42,9 +42,9 @@ namespace DataAccess.DTOs private void InitializeStrategies() { - actionUpdateStrategy ??= new HasBeamShearActionToDTOConvertStrategy(ReferenceDictionary, TraceLogger); - sectionUpdateStrategy ??= new HasBeamShearSectionToDTOConvertStrategy(ReferenceDictionary, TraceLogger); - stirrupUpdateStrategy ??= new HasStirrupToDTOConvertStrategy(ReferenceDictionary, TraceLogger); + actionUpdateStrategy ??= new HasBeamShearActionsToDTOUpdateStrategy(ReferenceDictionary, TraceLogger); + sectionUpdateStrategy ??= new HasBeamShearSectionsToDTORenameStrategy(ReferenceDictionary, TraceLogger); + stirrupUpdateStrategy ??= new HasStirrupsToDTOUpdateStrategy(ReferenceDictionary, TraceLogger); } } } diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearFromDTOConvertStrategy.cs new file mode 100644 index 0000000..9f24310 --- /dev/null +++ b/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 + { + private IUpdateStrategy 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); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearRepositoryFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearRepositoryFromDTOConvertStrategy.cs new file mode 100644 index 0000000..e1330a6 --- /dev/null +++ b/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 + { + private IUpdateStrategy actionUpdateStrategy; + private IUpdateStrategy sectionUpdateStrategy; + private IUpdateStrategy stirrupUpdateStrategy; + private IUpdateStrategy 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); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearRepositoryToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearRepositoryToDTOConvertStrategy.cs index a1abab6..e33a6a8 100644 --- a/DataAccess/DTOs/Converters/BeamShears/BeamShearRepositoryToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/BeamShearRepositoryToDTOConvertStrategy.cs @@ -51,10 +51,10 @@ namespace DataAccess.DTOs private void InitializeStrategies() { - actionUpdateStrategy ??= new HasBeamShearActionToDTOConvertStrategy(ReferenceDictionary, TraceLogger); - sectionUpdateStrategy ??= new HasBeamShearSectionToDTOConvertStrategy(ReferenceDictionary, TraceLogger); - stirrupUpdateStrategy ??= new HasStirrupToDTOConvertStrategy(ReferenceDictionary, TraceLogger); - calculatorUpdateStrategy ??= new HasBeamShearCalculatorToDTOConvertStrategy(ReferenceDictionary, TraceLogger); + actionUpdateStrategy ??= new HasBeamShearActionsToDTOUpdateStrategy(ReferenceDictionary, TraceLogger); + sectionUpdateStrategy ??= new HasBeamShearSectionsToDTORenameStrategy(ReferenceDictionary, TraceLogger); + stirrupUpdateStrategy ??= new HasStirrupsToDTOUpdateStrategy(ReferenceDictionary, TraceLogger); + calculatorUpdateStrategy ??= new HasBeamShearCalculatorsToDTOUpdateStrategy(ReferenceDictionary, TraceLogger); } } } diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearSectionFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearSectionFromDTOConvertStrategy.cs new file mode 100644 index 0000000..b121b84 --- /dev/null +++ b/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 + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy shapeConvertStrategy; + private IConvertStrategy concreteConvertStrategy; + private IUpdateStrategy 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 + (this, new ShapeFromDTOConvertStrategy(this)); + concreteConvertStrategy = new ConcreteLibMaterialFromDTOConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + safetyFactorUpdateStrategy = new HelperMaterialDTOSafetyFactorUpdateStrategy(new MaterialSafetyFactorsFromDTOLogic()); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamShearSectionToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamShearSectionToDTOConvertStrategy.cs index b06092a..af80f0b 100644 --- a/DataAccess/DTOs/Converters/BeamShears/BeamShearSectionToDTOConvertStrategy.cs +++ b/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 updateStrategy; private IConvertStrategy shapeConvertStrategy; - private ConcreteLibMaterialToDTOConvertStrategy concreteConvertStrategy; + private IConvertStrategy concreteConvertStrategy; private IUpdateStrategy safetyFactorUpdateStrategy; public BeamShearSectionToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) diff --git a/DataAccess/DTOs/Converters/BeamShears/BeamSpanLoadFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/BeamSpanLoadFromDTOConvertStrategy.cs new file mode 100644 index 0000000..c92c84f --- /dev/null +++ b/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 + { + 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 + (this, new ConcentratedForceFromDTOConvertStrategy(this)); + NewItem = convertLogic.Convert(concentrated); + } + + private void ProcessDistributed(DistributedLoadDTO distributed) + { + var convertLogic = new DictionaryConvertStrategy + (this, new DistributedLoadFromDTOConvertStrategy(this)); + NewItem = convertLogic.Convert(distributed); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/ConcentratedForceFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/ConcentratedForceFromDTOConvertStrategy.cs new file mode 100644 index 0000000..35b5f2a --- /dev/null +++ b/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 + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy tupleConvertStrategy; + private IConvertStrategy 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 + (this, new ForceTupleFromDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + combinationConvertStrategy = new DictionaryConvertStrategy + (this, new FactoredCombinationPropertyFromDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/DistributedLoadFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/DistributedLoadFromDTOConvertStrategy.cs new file mode 100644 index 0000000..beb01bb --- /dev/null +++ b/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 + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy tupleConvertStrategy; + private IConvertStrategy 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 + (this, new ForceTupleFromDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + combinationConvertStrategy = new DictionaryConvertStrategy + (this, new FactoredCombinationPropertyFromDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsFromDTOUpdateStrategy.cs new file mode 100644 index 0000000..e7b7d9a --- /dev/null +++ b/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 + { + private Dictionary<(Guid id, Type type), ISaveable> referenceDictionary; + private IShiftTraceLogger traceLogger; + private IConvertStrategy 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( + referenceDictionary, traceLogger, + new BeamShearActionFromDTOConvertStrategy(referenceDictionary, traceLogger)); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsToDTOUpdateStrategy.cs similarity index 67% rename from DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionToDTOConvertStrategy.cs rename to DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsToDTOUpdateStrategy.cs index df63ac8..7157445 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsToDTOUpdateStrategy.cs @@ -5,15 +5,15 @@ using StructureHelperCommon.Services; namespace DataAccess.DTOs { - public class HasBeamShearActionToDTOConvertStrategy : IUpdateStrategy + public class HasBeamShearActionsToDTOUpdateStrategy : IUpdateStrategy { - private Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get;} - private IShiftTraceLogger TraceLogger { get;} - public HasBeamShearActionToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) + private Dictionary<(Guid id, Type type), ISaveable> referenceDictionary; + private IShiftTraceLogger traceLogger; + public HasBeamShearActionsToDTOUpdateStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) { - ReferenceDictionary = referenceDictionary; - TraceLogger = traceLogger; + this.referenceDictionary = referenceDictionary; + 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( - ReferenceDictionary, - TraceLogger, - new BeamShearActionConvertStrategy(ReferenceDictionary, TraceLogger)); + referenceDictionary, + traceLogger, + new BeamShearActionToDTOConvertStrategy(referenceDictionary, traceLogger)); var newAction = convertStrategy.Convert(action); targetObject.Actions.Add(newAction); } diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsFromDTOUpdateStrategy.cs new file mode 100644 index 0000000..c40bedb --- /dev/null +++ b/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 + { + 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 calculators = GetCalculators(sourceObject.Calculators); + targetObject.Calculators.AddRange(calculators); + } + + private List GetCalculators(IEnumerable sourceCalculators) + { + List 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 + (referenceDictionary, traceLogger, new BeamShearCalculatorFromDTOConvertStrategy(referenceDictionary, traceLogger)); + return convertStrategy.Convert(shearCalculator); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsToDTOUpdateStrategy.cs similarity index 95% rename from DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorToDTOConvertStrategy.cs rename to DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsToDTOUpdateStrategy.cs index 63b67a3..d4872c7 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsToDTOUpdateStrategy.cs @@ -7,12 +7,12 @@ using StructureHelperLogics.Models.BeamShears; namespace DataAccess.DTOs { - public class HasBeamShearCalculatorToDTOConvertStrategy : IUpdateStrategy + public class HasBeamShearCalculatorsToDTOUpdateStrategy : IUpdateStrategy { 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; diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsFromDTOUpdateStrategy.cs new file mode 100644 index 0000000..55e5a3b --- /dev/null +++ b/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 + { + private Dictionary<(Guid id, Type type), ISaveable> referenceDictionary; + private IShiftTraceLogger traceLogger; + private IConvertStrategy 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 + (referenceDictionary, traceLogger, new BeamShearSectionFromDTOConvertStrategy(referenceDictionary, traceLogger)); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsToDTORenameStrategy.cs similarity index 92% rename from DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionToDTOConvertStrategy.cs rename to DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsToDTORenameStrategy.cs index 34f5e7c..2fdb240 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsToDTORenameStrategy.cs @@ -5,13 +5,13 @@ using StructureHelperLogics.Models.BeamShears; namespace DataAccess.DTOs { - public class HasBeamShearSectionToDTOConvertStrategy : IUpdateStrategy + public class HasBeamShearSectionsToDTORenameStrategy : IUpdateStrategy { private IConvertStrategy 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; diff --git a/DataAccess/DTOs/Converters/BeamShears/HasStirrupsFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasStirrupsFromDTOUpdateStrategy.cs new file mode 100644 index 0000000..d49b25d --- /dev/null +++ b/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 + { + 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 stirrups = GetStirrups(sourceObject.Stirrups); + targetObject.Stirrups.AddRange(stirrups); + } + + private List GetStirrups(IEnumerable sourceStirrups) + { + List 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 + (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 + (referenceDictionary, traceLogger, new StirrupByRebarFromDTOConvertStrategy(referenceDictionary, traceLogger)); + return convertStrategy.Convert(rebar); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/HasStirrupToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/HasStirrupsToDTOUpdateStrategy.cs similarity index 90% rename from DataAccess/DTOs/Converters/BeamShears/HasStirrupToDTOConvertStrategy.cs rename to DataAccess/DTOs/Converters/BeamShears/HasStirrupsToDTOUpdateStrategy.cs index 53413e2..6286cc0 100644 --- a/DataAccess/DTOs/Converters/BeamShears/HasStirrupToDTOConvertStrategy.cs +++ b/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 + public class HasStirrupsToDTOUpdateStrategy : IUpdateStrategy { 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; diff --git a/DataAccess/DTOs/Converters/BeamShears/StirrupByDensityFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/StirrupByDensityFromDTOConvertStrategy.cs new file mode 100644 index 0000000..5306c16 --- /dev/null +++ b/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 + { + private IUpdateStrategy 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; + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/StirrupByRebarFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/StirrupByRebarFromDTOConvertStrategy.cs new file mode 100644 index 0000000..b9431d4 --- /dev/null +++ b/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 + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy 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()); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShears/StirrupByRebarToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShears/StirrupByRebarToDTOConvertStrategy.cs index 4238e1c..fa42a40 100644 --- a/DataAccess/DTOs/Converters/BeamShears/StirrupByRebarToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShears/StirrupByRebarToDTOConvertStrategy.cs @@ -6,7 +6,7 @@ namespace DataAccess.DTOs { public class StirrupByRebarToDTOConvertStrategy : ConvertStrategy { - private StirrupByRebarUpdateStrategy updateStrategy; + private IUpdateStrategy updateStrategy; private ReinforcementLibMaterialToDTOConvertStrategy reinforcementConvertStrategy; private HelperMaterialDTOSafetyFactorUpdateStrategy safetyFactorUpdateStrategy; diff --git a/DataAccess/DTOs/Converters/Forces/FactoredCombinationPropertyFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Forces/FactoredCombinationPropertyFromDTOConvertStrategy.cs index 3714db2..b5cd03a 100644 --- a/DataAccess/DTOs/Converters/Forces/FactoredCombinationPropertyFromDTOConvertStrategy.cs +++ b/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 { private IUpdateStrategy updateStrategy; + + public FactoredCombinationPropertyFromDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) : base(referenceDictionary, traceLogger) + { + } + public override FactoredCombinationProperty GetNewItem(FactoredCombinationPropertyDTO source) { InitializeStrategies(); diff --git a/DataAccess/DTOs/Converters/Forces/FactoredForceTupleFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Forces/FactoredForceTupleFromDTOConvertStrategy.cs new file mode 100644 index 0000000..d08e26f --- /dev/null +++ b/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 + { + private IConvertStrategy tupleConvertStrategy; + private IConvertStrategy 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 + (this, new ForceTupleFromDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + combinationConvertStrategy = new DictionaryConvertStrategy + (this, new FactoredCombinationPropertyFromDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + } + } +} diff --git a/DataAccess/DTOs/Converters/Forces/FactoredForceTupleToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Forces/FactoredForceTupleToDTOConvertStrategy.cs index 0bdd8c4..61aaa27 100644 --- a/DataAccess/DTOs/Converters/Forces/FactoredForceTupleToDTOConvertStrategy.cs +++ b/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 { diff --git a/DataAccess/DTOs/Converters/Forces/ForceCombinationFromFileFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Forces/ForceCombinationFromFileFromDTOConvertStrategy.cs index 6b14ee2..c85c7d7 100644 --- a/DataAccess/DTOs/Converters/Forces/ForceCombinationFromFileFromDTOConvertStrategy.cs +++ b/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 }; } } diff --git a/DataAccess/DTOs/Converters/Forces/ForceFactoredListFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Forces/ForceFactoredListFromDTOConvertStrategy.cs index 0cf9c0f..4bd8a3b 100644 --- a/DataAccess/DTOs/Converters/Forces/ForceFactoredListFromDTOConvertStrategy.cs +++ b/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); } } } diff --git a/DataAccess/DTOs/Converters/Forces/ForceTupleFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Forces/ForceTupleFromDTOConvertStrategy.cs index f69d28d..3b7cdcf 100644 --- a/DataAccess/DTOs/Converters/Forces/ForceTupleFromDTOConvertStrategy.cs +++ b/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 { - private readonly IUpdateStrategy updateStrategy; + private IUpdateStrategy updateStrategy; - public ForceTupleFromDTOConvertStrategy(IUpdateStrategy 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; diff --git a/DataAccess/DTOs/Converters/Materials/HelperMaterialFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Materials/HelperMaterialFromDTOConvertStrategy.cs index 03a478d..02d29f4 100644 --- a/DataAccess/DTOs/Converters/Materials/HelperMaterialFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/Materials/HelperMaterialFromDTOConvertStrategy.cs @@ -1,16 +1,8 @@ -using DataAccess.DTOs.Converters; -using StructureHelper.Models.Materials; -using StructureHelperCommon.Infrastructures.Exceptions; +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 { diff --git a/DataAccess/DTOs/Converters/Materials/MaterialSafetyFactorsFromDTOLogic.cs b/DataAccess/DTOs/Converters/Materials/MaterialSafetyFactorsFromDTOLogic.cs index 5cf18d6..454a669 100644 --- a/DataAccess/DTOs/Converters/Materials/MaterialSafetyFactorsFromDTOLogic.cs +++ b/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 { diff --git a/DataAccess/DTOs/Converters/NdmCrossSections/CrossSectionFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/NdmCrossSections/CrossSectionFromDTOConvertStrategy.cs index 1c9f0b1..815dc7e 100644 --- a/DataAccess/DTOs/Converters/NdmCrossSections/CrossSectionFromDTOConvertStrategy.cs +++ b/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 repositoryConvertStrategy; private IConvertStrategy workPlaneConvertStrategy; - public CrossSectionFromDTOConvertStrategy(IConvertStrategy repositoryConvertStrategy, - IConvertStrategy workPlaneConvertStrategy) + public CrossSectionFromDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger? traceLogger) { - this.repositoryConvertStrategy = repositoryConvertStrategy; - this.workPlaneConvertStrategy = workPlaneConvertStrategy; + ReferenceDictionary = referenceDictionary; + TraceLogger = traceLogger; } - public CrossSectionFromDTOConvertStrategy() { } - public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } public IShiftTraceLogger TraceLogger { get; set; } diff --git a/DataAccess/DTOs/Converters/RectangleShapeFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/RectangleShapeFromDTOConvertStrategy.cs new file mode 100644 index 0000000..9b80f4b --- /dev/null +++ b/DataAccess/DTOs/Converters/RectangleShapeFromDTOConvertStrategy.cs @@ -0,0 +1,27 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Shapes; + +namespace DataAccess.DTOs +{ + internal class RectangleShapeFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy 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(); + } + } +} diff --git a/DataAccess/DTOs/Converters/ShapeFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ShapeFromDTOConvertStrategy.cs new file mode 100644 index 0000000..d8dbacd --- /dev/null +++ b/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 + { + private IConvertStrategy rectangleConvertStrategy; + + public ShapeFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy) + { + } + + public override IShape GetNewItem(IShape source) + { + if (source is RectangleShapeDTO rectangleShapeDTO) + { + rectangleConvertStrategy ??= new DictionaryConvertStrategy + (this, new RectangleShapeFromDTOConvertStrategy(this)); + NewItem = rectangleConvertStrategy.Convert(rectangleShapeDTO); + } + else + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source) + ": shape is unknown"); + } + return NewItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/ShapeToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ShapeToDTOConvertStrategy.cs index 77ee4fc..7011323 100644 --- a/DataAccess/DTOs/Converters/ShapeToDTOConvertStrategy.cs +++ b/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 { diff --git a/DataAccess/DTOs/Converters/VersionItemFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/VersionItemFromDTOConvertStrategy.cs index 8341584..84344b7 100644 --- a/DataAccess/DTOs/Converters/VersionItemFromDTOConvertStrategy.cs +++ b/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 + (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); - crossSectionConvertStrategy ??= new CrossSectionFromDTOConvertStrategy(); - crossSectionConvertStrategy.ReferenceDictionary = ReferenceDictionary; - crossSectionConvertStrategy.TraceLogger = TraceLogger; + TraceLogger?.AddMessage("Cross-Section converting has been started", TraceLogStatuses.Service); + crossSectionConvertStrategy ??= new CrossSectionFromDTOConvertStrategy(ReferenceDictionary, TraceLogger); var convertLogic = new DictionaryConvertStrategy(this, crossSectionConvertStrategy); ICrossSection newItem = convertLogic.Convert(source); TraceLogger?.AddMessage("Cross-Section converting has been finished successfully", TraceLogStatuses.Service); diff --git a/DataAccess/DTOs/Converters/WorkPlanePropertyFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/WorkPlanePropertyFromDTOConvertStrategy.cs index d3c6ae0..19487a0 100644 --- a/DataAccess/DTOs/Converters/WorkPlanePropertyFromDTOConvertStrategy.cs +++ b/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 { diff --git a/DataAccess/DTOs/DTOEntities/Forces/ForceTupleDTO.cs b/DataAccess/DTOs/DTOEntities/Forces/ForceTupleDTO.cs index 49f11f5..5e1d904 100644 --- a/DataAccess/DTOs/DTOEntities/Forces/ForceTupleDTO.cs +++ b/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; } } } diff --git a/DataAccess/DTOs/DTOEntities/Materials/ConcreteLibMaterialDTO.cs b/DataAccess/DTOs/DTOEntities/Materials/ConcreteLibMaterialDTO.cs index 9e6e77a..dff5853 100644 --- a/DataAccess/DTOs/DTOEntities/Materials/ConcreteLibMaterialDTO.cs +++ b/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) diff --git a/DataAccess/DTOs/DTOEntities/Materials/ReinforcementLibMaterialDTO.cs b/DataAccess/DTOs/DTOEntities/Materials/ReinforcementLibMaterialDTO.cs index d6de36a..c3a4043 100644 --- a/DataAccess/DTOs/DTOEntities/Materials/ReinforcementLibMaterialDTO.cs +++ b/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) diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs b/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs index a528f1b..4946198 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs @@ -73,13 +73,18 @@ namespace StructureHelperLogics.Models.BeamShears private void GetSections() { actionResults = new(); + List 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 inclinedSections = GetInclinedSections(section); List sectionInputDatas = GetSectionInputDatas(beamShearAction, calcTerm, section, stirrup, inclinedSections); diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearSection.cs b/StructureHelperLogics/Models/BeamShears/BeamShearSection.cs index d36dcc4..3f9e95c 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearSection.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearSection.cs @@ -12,7 +12,7 @@ namespace StructureHelperLogics.Models.BeamShears /// public IConcreteLibMaterial Material { get; set; } /// - 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; diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs index 7733904..a21cf88 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs +++ b/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(); } } } diff --git a/StructureHelperLogics/Models/BeamShears/IBeamShearSection.cs b/StructureHelperLogics/Models/BeamShears/IBeamShearSection.cs index fa09a47..69866ad 100644 --- a/StructureHelperLogics/Models/BeamShears/IBeamShearSection.cs +++ b/StructureHelperLogics/Models/BeamShears/IBeamShearSection.cs @@ -17,7 +17,7 @@ namespace StructureHelperLogics.Models.BeamShears /// /// Shape of cross-section /// - IShape Shape { get; } + IShape Shape { get; set; } /// /// Distance from edge of tension zone to center of the nearest reinforcement bar /// diff --git a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorInputDataUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorInputDataUpdateStrategy.cs index 87aa8a8..e6f8819 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorInputDataUpdateStrategy.cs @@ -4,7 +4,7 @@ using StructureHelperCommon.Services; namespace StructureHelperLogics.Models.BeamShears { - internal class BeamShearCalculatorInputDataUpdateStrategy : IUpdateStrategy + public class BeamShearCalculatorInputDataUpdateStrategy : IUpdateStrategy { private IUpdateStrategy? hasActionUpdateStrategy; private IUpdateStrategy? hasStirrupsUpdateStrategy; diff --git a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs index 78813c9..b2e1a3c 100644 --- a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs @@ -4,6 +4,9 @@ using StructureHelperCommon.Services; namespace StructureHelperLogics.Models.BeamShears { + /// + /// Add objects from one repository to another one without deleting previous objects + /// public class BeamShearRepositoryAddUpdateStrategy : IUpdateStrategy { public void Update(IBeamShearRepository targetObject, IBeamShearRepository sourceObject)