avpon/StructureHelper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add converting beam shear analysis from DTOs

Browse Source
This commit is contained in:
Evgeny Redikultsev
2025-06-15 21:11:02 +05:00
parent 4845a35ba5
commit 87996cf37b
48 changed files with 992 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
DataAccess/DTOs/Converters/BeamShears/BeamShearActionFromDTOConvertStrategy.cs Normal file
View File

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

6
DataAccess/DTOs/Converters/BeamShears/BeamShearActionConvertStrategy.cs → DataAccess/DTOs/Converters/BeamShears/BeamShearActionToDTOConvertStrategy.cs
View File

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

67
DataAccess/DTOs/Converters/BeamShears/BeamShearAxisActionFromDTOConvertStrategy.cs Normal file
View File

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

46
DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorFromDTOConvertStrategy.cs Normal file
View File

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

36
DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorInputDataFromDTOConvertStrategy.cs Normal file
View File

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

6
DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorInputDataToDTOConvertStrategy.cs
View File

@@ -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);
}
}
}

38
DataAccess/DTOs/Converters/BeamShears/BeamShearFromDTOConvertStrategy.cs Normal file
View File

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

43
DataAccess/DTOs/Converters/BeamShears/BeamShearRepositoryFromDTOConvertStrategy.cs Normal file
View File

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

8
DataAccess/DTOs/Converters/BeamShears/BeamShearRepositoryToDTOConvertStrategy.cs
View File

@@ -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);
}
}
}

51
DataAccess/DTOs/Converters/BeamShears/BeamShearSectionFromDTOConvertStrategy.cs Normal file
View File

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

3
DataAccess/DTOs/Converters/BeamShears/BeamShearSectionToDTOConvertStrategy.cs
View File

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

46
DataAccess/DTOs/Converters/BeamShears/BeamSpanLoadFromDTOConvertStrategy.cs Normal file
View File

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

45
DataAccess/DTOs/Converters/BeamShears/ConcentratedForceFromDTOConvertStrategy.cs Normal file
View File

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

45
DataAccess/DTOs/Converters/BeamShears/DistributedLoadFromDTOConvertStrategy.cs Normal file
View File

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

55
DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsFromDTOUpdateStrategy.cs Normal file
View File

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

18
DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionToDTOConvertStrategy.cs → DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsToDTOUpdateStrategy.cs
View File

@@ -5,15 +5,15 @@ using StructureHelperCommon.Services;
namespace DataAccess.DTOs
{
public class HasBeamShearActionToDTOConvertStrategy : IUpdateStrategy<IHasBeamShearActions>
public class HasBeamShearActionsToDTOUpdateStrategy : IUpdateStrategy<IHasBeamShearActions>
{
private Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get;}
private 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<BeamShearActionDTO, IBeamShearAction>(
ReferenceDictionary,
TraceLogger,
new BeamShearActionConvertStrategy(ReferenceDictionary, TraceLogger));
referenceDictionary,
traceLogger,
new BeamShearActionToDTOConvertStrategy(referenceDictionary, traceLogger));
var newAction = convertStrategy.Convert(action);
targetObject.Actions.Add(newAction);
}

64
DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsFromDTOUpdateStrategy.cs Normal file
View File

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

4
DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorToDTOConvertStrategy.cs → DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsToDTOUpdateStrategy.cs
View File

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

51
DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsFromDTOUpdateStrategy.cs Normal file
View File

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

4
DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionToDTOConvertStrategy.cs → DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsToDTORenameStrategy.cs
View File

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

78
DataAccess/DTOs/Converters/BeamShears/HasStirrupsFromDTOUpdateStrategy.cs Normal file
View File

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

10
DataAccess/DTOs/Converters/BeamShears/HasStirrupToDTOConvertStrategy.cs → DataAccess/DTOs/Converters/BeamShears/HasStirrupsToDTOUpdateStrategy.cs
View File

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

24
DataAccess/DTOs/Converters/BeamShears/StirrupByDensityFromDTOConvertStrategy.cs Normal file
View File

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

45
DataAccess/DTOs/Converters/BeamShears/StirrupByRebarFromDTOConvertStrategy.cs Normal file
View File

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

2
DataAccess/DTOs/Converters/BeamShears/StirrupByRebarToDTOConvertStrategy.cs
View File

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

6
DataAccess/DTOs/Converters/Forces/FactoredCombinationPropertyFromDTOConvertStrategy.cs
View File

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

59
DataAccess/DTOs/Converters/Forces/FactoredForceTupleFromDTOConvertStrategy.cs Normal file
View File

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

5
DataAccess/DTOs/Converters/Forces/FactoredForceTupleToDTOConvertStrategy.cs
View File

@@ -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
{

2
DataAccess/DTOs/Converters/Forces/ForceCombinationFromFileFromDTOConvertStrategy.cs
View File

@@ -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 };
}
}

2
DataAccess/DTOs/Converters/Forces/ForceFactoredListFromDTOConvertStrategy.cs
View File

@@ -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);
}
}
}

16
DataAccess/DTOs/Converters/Forces/ForceTupleFromDTOConvertStrategy.cs
View File

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

10
DataAccess/DTOs/Converters/Materials/HelperMaterialFromDTOConvertStrategy.cs
View File

@@ -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
{

5
DataAccess/DTOs/Converters/Materials/MaterialSafetyFactorsFromDTOLogic.cs
View File

@@ -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
{

17
DataAccess/DTOs/Converters/NdmCrossSections/CrossSectionFromDTOConvertStrategy.cs
View File

@@ -1,15 +1,9 @@
using DataAccess.DTOs.Converters;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Models.WorkPlanes;
using StructureHelperLogics.Models.CrossSections;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataAccess.DTOs
{
@@ -18,15 +12,12 @@ namespace DataAccess.DTOs
private IConvertStrategy<ICrossSectionRepository, ICrossSectionRepository> repositoryConvertStrategy;
private IConvertStrategy<WorkPlaneProperty, WorkPlanePropertyDTO> workPlaneConvertStrategy;
public CrossSectionFromDTOConvertStrategy(IConvertStrategy<ICrossSectionRepository, ICrossSectionRepository> repositoryConvertStrategy,
IConvertStrategy<WorkPlaneProperty, WorkPlanePropertyDTO> 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; }

27
DataAccess/DTOs/Converters/RectangleShapeFromDTOConvertStrategy.cs Normal file
View File

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

30
DataAccess/DTOs/Converters/ShapeFromDTOConvertStrategy.cs Normal file
View File

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

2
DataAccess/DTOs/Converters/ShapeToDTOConvertStrategy.cs
View File

@@ -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
{

23
DataAccess/DTOs/Converters/VersionItemFromDTOConvertStrategy.cs
View File

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

7
DataAccess/DTOs/Converters/WorkPlanePropertyFromDTOConvertStrategy.cs
View File

@@ -1,13 +1,8 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.WorkPlanes;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataAccess.DTOs.Converters
namespace DataAccess.DTOs
{
public class WorkPlanePropertyFromDTOConvertStrategy : ConvertStrategy<WorkPlaneProperty, WorkPlanePropertyDTO>
{

7
DataAccess/DTOs/DTOEntities/Forces/ForceTupleDTO.cs
View File

@@ -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;
}
}
}

2
DataAccess/DTOs/DTOEntities/Materials/ConcreteLibMaterialDTO.cs
View File

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

2
DataAccess/DTOs/DTOEntities/Materials/ReinforcementLibMaterialDTO.cs
View File

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

7
StructureHelperLogics/Models/BeamShears/BeamShearCalculatorLogic.cs
View File

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

2
StructureHelperLogics/Models/BeamShears/BeamShearSection.cs
View File

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

2
StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs
View File

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

2
StructureHelperLogics/Models/BeamShears/IBeamShearSection.cs
View File

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

2
StructureHelperLogics/Models/BeamShears/Logics/BeamShearCalculatorInputDataUpdateStrategy.cs
View File

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

3
StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs
View File

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