diff --git a/DataAccess/DTOs/Converters/BeamShearActionConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShearActionConvertStrategy.cs new file mode 100644 index 0000000..36e2b7c --- /dev/null +++ b/DataAccess/DTOs/Converters/BeamShearActionConvertStrategy.cs @@ -0,0 +1,57 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.BeamShearActions; + +namespace DataAccess.DTOs +{ + public class BeamShearActionConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy factoredTupleConvertStrategy; + private IConvertStrategy axisActionConvertStrategy; + + public BeamShearActionConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy) + { + } + + public BeamShearActionConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) + : base(referenceDictionary, traceLogger) + { + } + + public override BeamShearActionDTO GetNewItem(IBeamShearAction source) + { + try + { + GetNewBeamAction(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewBeamAction(IBeamShearAction source) + { + TraceLogger?.AddMessage($"Converting of beam shear action Id = {source.Id} has been started", TraceLogStatuses.Debug); + InitializeStrategies(); + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + NewItem.ExternalForce = factoredTupleConvertStrategy.Convert(source.ExternalForce); + NewItem.SupportAction = axisActionConvertStrategy.Convert(source.SupportAction); + TraceLogger?.AddMessage($"Converting of beam shear action Id = {NewItem.Id} has been finished", TraceLogStatuses.Debug); + } + + private void InitializeStrategies() + { + updateStrategy ??= new BeamShearActionUpdateStrategy(); + factoredTupleConvertStrategy = new DictionaryConvertStrategy + (this, new FactoredForceTupleToDTOConvertStrategy(this)); + axisActionConvertStrategy = new DictionaryConvertStrategy + (this, new BeamShearAxisActionToDTOConvertStrategy(this)); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShearAnalysisToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShearAnalysisToDTOConvertStrategy.cs index 3f03431..4152650 100644 --- a/DataAccess/DTOs/Converters/BeamShearAnalysisToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/BeamShearAnalysisToDTOConvertStrategy.cs @@ -1,12 +1,15 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Analyses; using StructureHelperLogics.Models.Analyses; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve; namespace DataAccess.DTOs { public class BeamShearAnalysisToDTOConvertStrategy : ConvertStrategy { private IUpdateStrategy updateStrategy; + private IConvertStrategy convertStrategy; public BeamShearAnalysisToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) : base(referenceDictionary, traceLogger) { @@ -17,8 +20,7 @@ namespace DataAccess.DTOs updateStrategy ??= new BeamShearAnalysisUpdateStrategy(); try { - NewItem = new(source.Id); - updateStrategy.Update(NewItem, source); + GetNewAnalysis(source); return NewItem; } catch (Exception ex) @@ -27,5 +29,26 @@ namespace DataAccess.DTOs throw; } } + + private void GetNewAnalysis(IBeamShearAnalysis source) + { + TraceLogger?.AddMessage($"Converting beam shear analysis id = {source.Id} has been started"); + InitializeStrategies(); + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + NewItem.VersionProcessor = convertStrategy.Convert(source.VersionProcessor); + TraceLogger?.AddMessage($"Converting beam shear analysis id = {NewItem.Id} has done successfully"); + } + + private void InitializeStrategies() + { + updateStrategy ??= new BeamShearAnalysisUpdateStrategy(); + convertStrategy = new DictionaryConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + ConvertStrategy = new VersionProcessorToDTOConvertStrategy(ReferenceDictionary, TraceLogger), + TraceLogger = TraceLogger + }; + } } } diff --git a/DataAccess/DTOs/Converters/BeamShearAxisActionToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShearAxisActionToDTOConvertStrategy.cs new file mode 100644 index 0000000..4625f02 --- /dev/null +++ b/DataAccess/DTOs/Converters/BeamShearAxisActionToDTOConvertStrategy.cs @@ -0,0 +1,60 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.BeamShearActions; + +//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + +namespace DataAccess.DTOs +{ + public class BeamShearAxisActionToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy factoredTupleConvertStrategy; + private IConvertStrategy spanLoadConvertStrategy; + + public BeamShearAxisActionToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy) + { + } + + public override BeamShearAxisActionDTO GetNewItem(IBeamShearAxisAction source) + { + try + { + GetNewBeamAction(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewBeamAction(IBeamShearAxisAction source) + { + TraceLogger?.AddMessage($"Converting of beam shear action Id = {source.Id} has been started", TraceLogStatuses.Debug); + InitializeStrategies(); + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + NewItem.SupportForce = factoredTupleConvertStrategy.Convert(source.SupportForce); + NewItem.ShearLoads.Clear(); + foreach (var spanLoad in source.ShearLoads) + { + var newSpanLoad = spanLoadConvertStrategy.Convert(spanLoad); + NewItem.ShearLoads.Add(newSpanLoad); + } + TraceLogger?.AddMessage($"Converting of beam shear action Id = {source.Id} has been finished", TraceLogStatuses.Debug); + } + + private void InitializeStrategies() + { + updateStrategy ??= new BeamShearAxisActionUpdateStrategy(); + factoredTupleConvertStrategy = new DictionaryConvertStrategy + (this, new FactoredForceTupleToDTOConvertStrategy(this)); + spanLoadConvertStrategy = new DictionaryConvertStrategy + (this, new BeamSpanLoadToDTOConvertStrategy(this)); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShearRepositoryToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShearRepositoryToDTOConvertStrategy.cs new file mode 100644 index 0000000..49f73f8 --- /dev/null +++ b/DataAccess/DTOs/Converters/BeamShearRepositoryToDTOConvertStrategy.cs @@ -0,0 +1,53 @@ +using DataAccess.DTOs.Converters; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.BeamShearActions; +using StructureHelperLogics.Models.BeamShears; + +//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + +namespace DataAccess.DTOs +{ + public class BeamShearRepositoryToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy actionUpdateStrategy; + private IUpdateStrategy sectionUpdateStrategy; + + public BeamShearRepositoryToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) : base(referenceDictionary, traceLogger) + { + } + + public override BeamShearRepositoryDTO GetNewItem(IBeamShearRepository source) + { + try + { + GetNewBeamRepository(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewBeamRepository(IBeamShearRepository source) + { + TraceLogger?.AddMessage($"Converting of beam shear repository Id = {source.Id} has been started", TraceLogStatuses.Debug); + InitializeStrategies(); + NewItem = new(source.Id); + actionUpdateStrategy.Update(NewItem, source); + sectionUpdateStrategy.Update(NewItem, source); + TraceLogger?.AddMessage($"Converting of beam shear repository Id = {NewItem.Id} has been finished", TraceLogStatuses.Service); + + } + + private void InitializeStrategies() + { + actionUpdateStrategy ??= new HasBeamShearActionToDTOConvertStrategy(ReferenceDictionary, TraceLogger); + sectionUpdateStrategy ??= new HasBeamShearSectionConvertStrategy(ReferenceDictionary, TraceLogger); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamShearToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamShearToDTOConvertStrategy.cs new file mode 100644 index 0000000..068339d --- /dev/null +++ b/DataAccess/DTOs/Converters/BeamShearToDTOConvertStrategy.cs @@ -0,0 +1,53 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperLogics.Models.BeamShears; + +//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + +namespace DataAccess.DTOs +{ + public class BeamShearToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy repositoryConvertStrategy; + public BeamShearToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) + : base(referenceDictionary, traceLogger) + { + } + + public override BeamShearDTO GetNewItem(IBeamShear source) + { + try + { + GetNewBeamShear(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewBeamShear(IBeamShear source) + { + TraceLogger?.AddMessage($"Converting of beam shear Id = {source.Id} has been started"); + InitializeStrategies(); + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + NewItem.Repository = repositoryConvertStrategy.Convert(source.Repository); + TraceLogger?.AddMessage($"Converting of beam shear Id = {NewItem.Id} has been finished successfully"); + } + + private void InitializeStrategies() + { + updateStrategy ??= new BeamShearUpdateStrategy(); + repositoryConvertStrategy = new DictionaryConvertStrategy( + ReferenceDictionary, + TraceLogger, + new BeamShearRepositoryToDTOConvertStrategy(ReferenceDictionary, TraceLogger) + ); + } + } +} diff --git a/DataAccess/DTOs/Converters/BeamSpanLoadToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/BeamSpanLoadToDTOConvertStrategy.cs new file mode 100644 index 0000000..7bde042 --- /dev/null +++ b/DataAccess/DTOs/Converters/BeamSpanLoadToDTOConvertStrategy.cs @@ -0,0 +1,69 @@ +using DataAccess.DTOs.DTOEntities; +using StructureHelperCommon.Infrastructures.Exceptions; +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 BeamSpanLoadToDTOConvertStrategy : ConvertStrategy + { + public BeamSpanLoadToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy) + { + } + + public override IBeamSpanLoad GetNewItem(IBeamSpanLoad source) + { + try + { + GetNewBeamAction(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + + } + + private void GetNewBeamAction(IBeamSpanLoad source) + { + TraceLogger?.AddMessage($"Converting of beam shear action Id = {source.Id} has been started", TraceLogStatuses.Debug); + if (source is IDistributedLoad distributedLoad) + { + ProcessDistributedLoad(distributedLoad); + } + else if (source is IConcentratedForce concentratedForce) + { + ProcessConcentratedForce(concentratedForce); + } + else + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source) + ": type of span load"); + } + TraceLogger?.AddMessage($"Converting of beam shear action Id = {source.Id} has been finished", TraceLogStatuses.Debug); + } + + private void ProcessConcentratedForce(IConcentratedForce concentratedForce) + { + var convertStrategy = new DictionaryConvertStrategy + (this, new ConcentratedForceToDTOConvertStrategy(this)); + ConcentratedForceDTO concentratedForceDTO = convertStrategy.Convert(concentratedForce); + NewItem = concentratedForceDTO; + } + + private void ProcessDistributedLoad(IDistributedLoad distributedLoad) + { + var convertStrategy = new DictionaryConvertStrategy + (this, new DistributedLoadToDTOConvertStrategy(this)); + DistributedLoadDTO distributedLoadDTO = convertStrategy.Convert(distributedLoad); + NewItem = distributedLoadDTO; + } + } +} diff --git a/DataAccess/DTOs/Converters/ConcentratedForceToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ConcentratedForceToDTOConvertStrategy.cs new file mode 100644 index 0000000..074d27d --- /dev/null +++ b/DataAccess/DTOs/Converters/ConcentratedForceToDTOConvertStrategy.cs @@ -0,0 +1,52 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.BeamShearActions; + +namespace DataAccess.DTOs +{ + public class ConcentratedForceToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy tupleConvertStrategy; + private IConvertStrategy combinationConvertStrategy; + + public ConcentratedForceToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy) + { + } + + public override ConcentratedForceDTO GetNewItem(IConcentratedForce source) + { + try + { + GetNewConcentratedForce(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewConcentratedForce(IConcentratedForce source) + { + TraceLogger?.AddMessage($"Concentrated force converting Id = {source.Id} has been started", TraceLogStatuses.Debug); + InitializeStrategies(); + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + NewItem.ForceValue = tupleConvertStrategy.Convert(source.ForceValue); + NewItem.CombinationProperty = combinationConvertStrategy.Convert(source.CombinationProperty); + TraceLogger?.AddMessage($"Concentrated force converting Id = {NewItem.Id} has been finished successfully", TraceLogStatuses.Debug); + } + + private void InitializeStrategies() + { + updateStrategy ??= new ConcentratedForceUpdateStrategy(); + tupleConvertStrategy = new DictionaryConvertStrategy + (this, new ForceTupleToDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + combinationConvertStrategy = new DictionaryConvertStrategy + (this, new FactoredCombinationPropertyToDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + } + } +} diff --git a/DataAccess/DTOs/Converters/CrossSectionNdmAnalysisToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrossSectionNdmAnalysisToDTOConvertStrategy.cs index 484a9e6..f170cae 100644 --- a/DataAccess/DTOs/Converters/CrossSectionNdmAnalysisToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CrossSectionNdmAnalysisToDTOConvertStrategy.cs @@ -7,80 +7,48 @@ using StructureHelperLogics.Models.Analyses; namespace DataAccess.DTOs { - internal class CrossSectionNdmAnalysisToDTOConvertStrategy : IConvertStrategy + internal class CrossSectionNdmAnalysisToDTOConvertStrategy : ConvertStrategy { private IUpdateStrategy updateStrategy; private IConvertStrategy convertStrategy; - public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } - public IShiftTraceLogger TraceLogger { get; set; } - public CrossSectionNdmAnalysisToDTOConvertStrategy( - IUpdateStrategy updateStrategy, - IConvertStrategy convertStrategy, - IShiftTraceLogger traceLogger) + public CrossSectionNdmAnalysisToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) : base(referenceDictionary, traceLogger) { - this.updateStrategy = updateStrategy; - this.convertStrategy = convertStrategy; - this.TraceLogger = traceLogger; } - public CrossSectionNdmAnalysisToDTOConvertStrategy() : this( - new CrossSectionNdmAnalysisUpdateStrategy(), - new VersionProcessorToDTOConvertStrategy(), - null) - { - - } - - public CrossSectionNdmAnalysisToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger? traceLogger) - : this( - new CrossSectionNdmAnalysisUpdateStrategy(), - new VersionProcessorToDTOConvertStrategy(), - null) - { - ReferenceDictionary = referenceDictionary; - TraceLogger = traceLogger; - } - - public CrossSectionNdmAnalysisDTO Convert(ICrossSectionNdmAnalysis source) + public override CrossSectionNdmAnalysisDTO GetNewItem(ICrossSectionNdmAnalysis source) { try { - Check(); - return GetNewAnalysis(source); + GetNewAnalysis(source); + return NewItem; } catch (Exception ex) { - TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); - TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + TraceErrorByEntity(this, ex.Message); throw; } } - - private CrossSectionNdmAnalysisDTO GetNewAnalysis(ICrossSectionNdmAnalysis source) + private void GetNewAnalysis(ICrossSectionNdmAnalysis source) { TraceLogger?.AddMessage("Cross-section ndm analysis converting is started", TraceLogStatuses.Debug); - CrossSectionNdmAnalysisDTO newItem = new(); - newItem.Id = source.Id; - updateStrategy.Update(newItem, source); - convertStrategy.ReferenceDictionary = ReferenceDictionary; - convertStrategy.TraceLogger = TraceLogger; - var convertLogic = new DictionaryConvertStrategy() - { - ReferenceDictionary = ReferenceDictionary, - ConvertStrategy = convertStrategy, - TraceLogger = TraceLogger - }; + InitializeStrategies(); + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); TraceLogger?.AddMessage("Convert version processor is started", TraceLogStatuses.Service); - newItem.VersionProcessor = convertLogic.Convert(source.VersionProcessor); + NewItem.VersionProcessor = convertStrategy.Convert(source.VersionProcessor); TraceLogger?.AddMessage("Cross-section ndm analysis has been converted successfully", TraceLogStatuses.Service); - return newItem; } - private void Check() + private void InitializeStrategies() { - var checkLogic = new CheckConvertLogic(this); - checkLogic.Check(); + updateStrategy ??= new CrossSectionNdmAnalysisUpdateStrategy(); + convertStrategy = new DictionaryConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + ConvertStrategy = new VersionProcessorToDTOConvertStrategy(ReferenceDictionary, TraceLogger), + TraceLogger = TraceLogger + }; } } } diff --git a/DataAccess/DTOs/Converters/DateVersionToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/DateVersionToDTOConvertStrategy.cs index 29ff5d1..d2717a0 100644 --- a/DataAccess/DTOs/Converters/DateVersionToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/DateVersionToDTOConvertStrategy.cs @@ -1,76 +1,58 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Analyses; -using StructureHelperCommon.Models.Loggers; -using StructureHelperLogic.Models.Analyses; -using StructureHelperLogics.Models.CrossSections; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; + +//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. namespace DataAccess.DTOs { - public class DateVersionToDTOConvertStrategy : IConvertStrategy + public class DateVersionToDTOConvertStrategy : ConvertStrategy { private IUpdateStrategy updateStrategy; - private IConvertStrategy convertStrategy; - private DictionaryConvertStrategy convertLogic; + private DictionaryConvertStrategy convertStrategy; - public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } - public IShiftTraceLogger TraceLogger { get; set; } - - public DateVersionToDTOConvertStrategy( - IUpdateStrategy updateStrategy, - IConvertStrategy convertStrategy) + public DateVersionToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) + : base(referenceDictionary, traceLogger) { - this.updateStrategy = updateStrategy; - this.convertStrategy = convertStrategy; } - public DateVersionToDTOConvertStrategy() : this ( - new DateVersionUpdateStrategy(), - new VersionItemToDTOConvertStrategy()) - { - - } - - public DateVersionDTO Convert(IDateVersion source) + public override DateVersionDTO GetNewItem(IDateVersion source) { try { - Check(); - return GetNewDateVersion(source); + GetNewDateVersion(source); + return NewItem; } catch (Exception ex) { - TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); - TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + TraceErrorByEntity(this, ex.Message); throw; } } - private DateVersionDTO GetNewDateVersion(IDateVersion source) + private void GetNewDateVersion(IDateVersion source) { TraceLogger?.AddMessage("Date version converting is started", TraceLogStatuses.Debug); - DateVersionDTO newItem = new() + InitializeStrategies(); + NewItem = new() { Id = source.Id }; - updateStrategy.Update(newItem, source); - convertStrategy.ReferenceDictionary = ReferenceDictionary; - convertStrategy.TraceLogger = TraceLogger; - convertLogic = new DictionaryConvertStrategy(this, convertStrategy); - newItem.AnalysisVersion = convertLogic.Convert(source.AnalysisVersion); + updateStrategy.Update(NewItem, source); + NewItem.AnalysisVersion = convertStrategy.Convert(source.AnalysisVersion); TraceLogger?.AddMessage("Date version converting has been finished", TraceLogStatuses.Service); - return newItem; } - private void Check() + private void InitializeStrategies() { - var checkLogic = new CheckConvertLogic(this); - checkLogic.Check(); + updateStrategy ??= new DateVersionUpdateStrategy(); + convertStrategy = new DictionaryConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger, + ConvertStrategy = new VersionItemToDTOConvertStrategy(ReferenceDictionary, TraceLogger) + }; } } } diff --git a/DataAccess/DTOs/Converters/DistributedLoadToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/DistributedLoadToDTOConvertStrategy.cs new file mode 100644 index 0000000..9611a6e --- /dev/null +++ b/DataAccess/DTOs/Converters/DistributedLoadToDTOConvertStrategy.cs @@ -0,0 +1,55 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.BeamShearActions; + +//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + +namespace DataAccess.DTOs +{ + public class DistributedLoadToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy tupleConvertStrategy; + private IConvertStrategy combinationConvertStrategy; + + public DistributedLoadToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy) + { + } + + public override DistributedLoadDTO GetNewItem(IDistributedLoad source) + { + try + { + GetNewBeamAction(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewBeamAction(IDistributedLoad source) + { + TraceLogger?.AddMessage($"Converting of beam shear action Id = {source.Id} has been started", TraceLogStatuses.Debug); + InitializeStrategies(); + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + NewItem.LoadValue = tupleConvertStrategy.Convert(source.LoadValue); + NewItem.CombinationProperty = combinationConvertStrategy.Convert(source.CombinationProperty); + TraceLogger?.AddMessage($"Converting of beam shear action Id = {source.Id} has been finished", TraceLogStatuses.Debug); + } + + private void InitializeStrategies() + { + updateStrategy ??= new DistributedLoadUpdateStrategy(); + tupleConvertStrategy = new DictionaryConvertStrategy + (this, new ForceTupleToDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + combinationConvertStrategy = new DictionaryConvertStrategy + (this, new FactoredCombinationPropertyToDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + } + } +} diff --git a/DataAccess/DTOs/Converters/FactoredCombinationPropertyToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/FactoredCombinationPropertyToDTOConvertStrategy.cs index 63a4285..72fd9f8 100644 --- a/DataAccess/DTOs/Converters/FactoredCombinationPropertyToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/FactoredCombinationPropertyToDTOConvertStrategy.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Forces.Logics; using System; @@ -22,10 +23,16 @@ namespace DataAccess.DTOs { } + + public FactoredCombinationPropertyToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) + : base(referenceDictionary, traceLogger) + { + } + public override FactoredCombinationPropertyDTO GetNewItem(IFactoredCombinationProperty source) { - InitializeStrategies(); TraceLogger?.AddMessage($"Force factored combination property Id={source.Id} converting has been started"); + InitializeStrategies(); FactoredCombinationPropertyDTO newItem = new(source.Id); updateStrategy.Update(newItem, source); TraceLogger?.AddMessage($"Force factored combination property Id={newItem.Id} converting has been finished"); diff --git a/DataAccess/DTOs/Converters/FactoredForceTupleToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/FactoredForceTupleToDTOConvertStrategy.cs new file mode 100644 index 0000000..0bdd8c4 --- /dev/null +++ b/DataAccess/DTOs/Converters/FactoredForceTupleToDTOConvertStrategy.cs @@ -0,0 +1,53 @@ +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 FactoredForceTupleToDTOConvertStrategy : ConvertStrategy + { + private IConvertStrategy tupleConvertStrategy; + private IConvertStrategy combinationConvertStrategy; + + public FactoredForceTupleToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy) + { + } + + public override FactoredForceTupleDTO GetNewItem(IFactoredForceTuple source) + { + try + { + GetNewFactoredForceTuple(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewFactoredForceTuple(IFactoredForceTuple source) + { + TraceLogger?.AddMessage($"Converting of factored force tuple Id = {source.Id} has been started", TraceLogStatuses.Debug); + InitializeStrategies(); + NewItem = new(source.Id); + NewItem.ForceTuple = tupleConvertStrategy.Convert(source.ForceTuple); + NewItem.CombinationProperty = combinationConvertStrategy.Convert(source.CombinationProperty); + TraceLogger?.AddMessage($"Converting of factored force tuple Id = {NewItem.Id} has been finished", TraceLogStatuses.Debug); + } + + private void InitializeStrategies() + { + tupleConvertStrategy = new DictionaryConvertStrategy + (this, new ForceTupleToDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + combinationConvertStrategy = new DictionaryConvertStrategy + (this, new FactoredCombinationPropertyToDTOConvertStrategy(ReferenceDictionary, TraceLogger)); + } + } +} diff --git a/DataAccess/DTOs/Converters/ForceTupleToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceTupleToDTOConvertStrategy.cs index ef49142..5916fc1 100644 --- a/DataAccess/DTOs/Converters/ForceTupleToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceTupleToDTOConvertStrategy.cs @@ -1,12 +1,6 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; -using StructureHelperCommon.Models.Loggers; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace DataAccess.DTOs { @@ -24,11 +18,33 @@ namespace DataAccess.DTOs } + public ForceTupleToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) + : base(referenceDictionary, traceLogger) + { + } + public override ForceTupleDTO GetNewItem(IForceTuple source) { - ForceTupleDTO newItem = new(source.Id); - updateStrategy.Update(newItem, source); - return newItem; + try + { + GetNewBeamForceTuple(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + + } + + private void GetNewBeamForceTuple(IForceTuple source) + { + TraceLogger?.AddMessage($"Converting of force tuple Id = {source.Id} has been started", TraceLogStatuses.Debug); + updateStrategy ??= new ForceTupleUpdateStrategy(); + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + TraceLogger?.AddMessage($"Converting of force tuple Id = {source.Id} has been finished", TraceLogStatuses.Debug); } } } diff --git a/DataAccess/DTOs/Converters/HasBeamShearActionToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/HasBeamShearActionToDTOConvertStrategy.cs new file mode 100644 index 0000000..d91b579 --- /dev/null +++ b/DataAccess/DTOs/Converters/HasBeamShearActionToDTOConvertStrategy.cs @@ -0,0 +1,43 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Services; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class HasBeamShearActionToDTOConvertStrategy : 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) + { + ReferenceDictionary = referenceDictionary; + 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) + { + var convertStrategy = new DictionaryConvertStrategy( + ReferenceDictionary, + TraceLogger, + new BeamShearActionConvertStrategy(ReferenceDictionary, TraceLogger)); + var newAction = convertStrategy.Convert(action); + targetObject.Actions.Add(newAction); + } + } + } +} diff --git a/DataAccess/DTOs/Converters/HasBeamShearSectionConvertStrategy.cs b/DataAccess/DTOs/Converters/HasBeamShearSectionConvertStrategy.cs new file mode 100644 index 0000000..c6f390f --- /dev/null +++ b/DataAccess/DTOs/Converters/HasBeamShearSectionConvertStrategy.cs @@ -0,0 +1,28 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Services; +using StructureHelperLogics.Models.BeamShears; + +namespace DataAccess.DTOs +{ + public class HasBeamShearSectionConvertStrategy : IUpdateStrategy + { + private Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; } + private IShiftTraceLogger TraceLogger { get; } + public HasBeamShearSectionConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) + { + ReferenceDictionary = referenceDictionary; + 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(); + } + } +} diff --git a/DataAccess/DTOs/Converters/VersionItemToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/VersionItemToDTOConvertStrategy.cs index cad4a30..c4e76cd 100644 --- a/DataAccess/DTOs/Converters/VersionItemToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/VersionItemToDTOConvertStrategy.cs @@ -2,37 +2,18 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Loggers; +using StructureHelperLogics.Models.BeamShears; using StructureHelperLogics.Models.CrossSections; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -using System.Windows.Forms; namespace DataAccess.DTOs { - public class VersionItemToDTOConvertStrategy : IConvertStrategy + public class VersionItemToDTOConvertStrategy : ConvertStrategy { private const string AnalysisIs = "Analysis type is"; - private IConvertStrategy crossSectionConvertStrategy = new CrossSectionToDTOConvertStrategy(); - public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } - public IShiftTraceLogger TraceLogger { get; set; } - - public ISaveable Convert(ISaveable source) + public VersionItemToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) + : base(referenceDictionary, traceLogger) { - try - { - Check(); - return GetNewAnalysis(source); - } - catch (Exception ex) - { - TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); - TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); - throw; - } } private ISaveable GetNewAnalysis(ISaveable source) @@ -42,6 +23,10 @@ namespace DataAccess.DTOs { newItem = ProcessCrossSection(crossSection); } + else if (source is IBeamShear beamShear) + { + newItem = ProcessBeamShear(beamShear); + } else { string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source); @@ -51,12 +36,27 @@ namespace DataAccess.DTOs return newItem; } + private BeamShearDTO ProcessBeamShear(IBeamShear beamShear) + { + TraceLogger?.AddMessage(AnalysisIs + " Beam Shear Analysis", TraceLogStatuses.Debug); + var convertLogic = new DictionaryConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger, + ConvertStrategy = new BeamShearToDTOConvertStrategy(ReferenceDictionary, TraceLogger) + }; + return convertLogic.Convert(beamShear); + } + private ISaveable ProcessCrossSection(ICrossSection crossSection) { TraceLogger?.AddMessage(AnalysisIs + " Cross-Section Ndm Analysis", TraceLogStatuses.Debug); ISaveable saveable; - crossSectionConvertStrategy.ReferenceDictionary = ReferenceDictionary; - crossSectionConvertStrategy.TraceLogger = TraceLogger; + IConvertStrategy crossSectionConvertStrategy = new CrossSectionToDTOConvertStrategy + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; var convertLogic = new DictionaryConvertStrategy() { ReferenceDictionary = ReferenceDictionary, @@ -67,10 +67,18 @@ namespace DataAccess.DTOs return saveable; } - private void Check() + public override ISaveable GetNewItem(ISaveable source) { - var checkLogic = new CheckConvertLogic(this); - checkLogic.Check(); + try + { + return GetNewAnalysis(source); + } + catch (Exception ex) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); + TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + throw; + } } } } diff --git a/DataAccess/DTOs/Converters/VersionProcessorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/VersionProcessorToDTOConvertStrategy.cs index cb389a8..07d8a28 100644 --- a/DataAccess/DTOs/Converters/VersionProcessorToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/VersionProcessorToDTOConvertStrategy.cs @@ -2,69 +2,48 @@ using StructureHelperCommon.Models; using StructureHelperCommon.Models.Analyses; using StructureHelperCommon.Models.Loggers; -using StructureHelperLogics.Models.CrossSections; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace DataAccess.DTOs { - public class VersionProcessorToDTOConvertStrategy : IConvertStrategy + public class VersionProcessorToDTOConvertStrategy : ConvertStrategy { private IConvertStrategy dataVersionConvertStrategy; - private ICheckConvertLogic checkLogic; - public VersionProcessorToDTOConvertStrategy(IConvertStrategy dataVersionConvertStrategy) + public VersionProcessorToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) + : base(referenceDictionary, traceLogger) { - this.dataVersionConvertStrategy = dataVersionConvertStrategy; - } - public VersionProcessorToDTOConvertStrategy() : this( new DateVersionToDTOConvertStrategy()) - { - } - public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } - public IShiftTraceLogger TraceLogger { get; set; } - - - public VersionProcessorDTO Convert(IVersionProcessor source) + public override VersionProcessorDTO GetNewItem(IVersionProcessor source) { - Check(); try { - VersionProcessorDTO versionProcessorDTO = GetNewVersionProcessor(source); - return versionProcessorDTO; + GetNewVersionProcessor(source); + return NewItem; } catch (Exception ex) { - TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); - TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + TraceErrorByEntity(this, ex.Message); throw; - } + } } - private VersionProcessorDTO GetNewVersionProcessor(IVersionProcessor source) + private void GetNewVersionProcessor(IVersionProcessor source) { - VersionProcessorDTO newItem = new() - { - Id = source.Id - }; - dataVersionConvertStrategy.ReferenceDictionary = ReferenceDictionary; - dataVersionConvertStrategy.TraceLogger = TraceLogger; + TraceLogger?.AddMessage($"Converting version processor Id={source.Id} has been started", TraceLogStatuses.Debug); + InitializeStrategies(); + NewItem = new(source.Id); foreach (var item in source.Versions) { var convertLogic = new DictionaryConvertStrategy(this, dataVersionConvertStrategy); - newItem.Versions.Add(convertLogic.Convert(item)); + NewItem.Versions.Add(convertLogic.Convert(item)); } - return newItem; + TraceLogger?.AddMessage($"Converting version processor Id={NewItem.Id} has been done successfully", TraceLogStatuses.Service); } - private void Check() + private void InitializeStrategies() { - checkLogic = new CheckConvertLogic(this); - checkLogic.Check(); + dataVersionConvertStrategy ??= new DateVersionToDTOConvertStrategy(ReferenceDictionary, TraceLogger); } } } diff --git a/DataAccess/DTOs/DTOEntities/BeamShearActionDTO.cs b/DataAccess/DTOs/DTOEntities/BeamShearActionDTO.cs new file mode 100644 index 0000000..3c182f5 --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/BeamShearActionDTO.cs @@ -0,0 +1,30 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Forces; + +//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + +namespace DataAccess.DTOs +{ + public class BeamShearActionDTO : IBeamShearAction + { + [JsonProperty("Id")] + public Guid Id { get; } + [JsonProperty("Name")] + public string Name { get; set; } + [JsonProperty("ExternalForce")] + public IFactoredForceTuple ExternalForce { get; set; } = new FactoredForceTupleDTO(Guid.Empty); + [JsonProperty("SupportAction")] + public IBeamShearAxisAction SupportAction { get; set; } = new BeamShearAxisActionDTO(Guid.Empty); + + public BeamShearActionDTO(Guid id) + { + Id = id; + } + + public object Clone() + { + return this; + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/BeamShearAnalysisDTO.cs b/DataAccess/DTOs/DTOEntities/BeamShearAnalysisDTO.cs index 8529a30..865fda0 100644 --- a/DataAccess/DTOs/DTOEntities/BeamShearAnalysisDTO.cs +++ b/DataAccess/DTOs/DTOEntities/BeamShearAnalysisDTO.cs @@ -17,7 +17,7 @@ namespace DataAccess.DTOs public string Comment { get; set; } = string.Empty; [JsonProperty("Color")] public Color Color { get; set; } - public IVersionProcessor VersionProcessor { get; set; } = new VersionProcessorDTO(); + public IVersionProcessor VersionProcessor { get; set; } = new VersionProcessorDTO(Guid.NewGuid()); public BeamShearAnalysisDTO(Guid id) { Id = id; diff --git a/DataAccess/DTOs/DTOEntities/BeamShearAxisActionDTO.cs b/DataAccess/DTOs/DTOEntities/BeamShearAxisActionDTO.cs new file mode 100644 index 0000000..3b63a76 --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/BeamShearAxisActionDTO.cs @@ -0,0 +1,31 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Forces; + +//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + +namespace DataAccess.DTOs +{ + public class BeamShearAxisActionDTO : IBeamShearAxisAction + { + [JsonProperty("Id")] + public Guid Id { get; } + [JsonProperty("Name")] + public string Name { get; set; } + [JsonProperty("SupportForce")] + public IFactoredForceTuple SupportForce { get; set; } + [JsonProperty("SpanLoads")] + public List ShearLoads { get; } = new(); + + public BeamShearAxisActionDTO(Guid id) + { + Id = id; + } + + + public object Clone() + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/BeamShearDTO.cs b/DataAccess/DTOs/DTOEntities/BeamShearDTO.cs index ada2f50..8bc20bf 100644 --- a/DataAccess/DTOs/DTOEntities/BeamShearDTO.cs +++ b/DataAccess/DTOs/DTOEntities/BeamShearDTO.cs @@ -1,19 +1,23 @@ using Newtonsoft.Json; using StructureHelperLogics.Models.BeamShears; -namespace DataAccess.DTOs.DTOEntities +namespace DataAccess.DTOs { public class BeamShearDTO : IBeamShear { [JsonProperty("Id")] public Guid Id { get; } [JsonProperty("Repository")] - public IBeamShearRepository Repository { get; set; } + public IBeamShearRepository Repository { get; set; } = new BeamShearRepositoryDTO(Guid.NewGuid()); + public BeamShearDTO(Guid id) + { + Id = id; + } public object Clone() { - throw new NotImplementedException(); + return this; } } } diff --git a/DataAccess/DTOs/DTOEntities/BeamShearRepositoryDTO.cs b/DataAccess/DTOs/DTOEntities/BeamShearRepositoryDTO.cs index 21d191e..fcb985a 100644 --- a/DataAccess/DTOs/DTOEntities/BeamShearRepositoryDTO.cs +++ b/DataAccess/DTOs/DTOEntities/BeamShearRepositoryDTO.cs @@ -3,7 +3,7 @@ using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; using StructureHelperLogics.Models.BeamShears; -namespace DataAccess.DTOs.DTOEntities +namespace DataAccess.DTOs { public class BeamShearRepositoryDTO : IBeamShearRepository { diff --git a/DataAccess/DTOs/DTOEntities/ConcentratedForceDTO.cs b/DataAccess/DTOs/DTOEntities/ConcentratedForceDTO.cs index 3fec7e7..894141c 100644 --- a/DataAccess/DTOs/DTOEntities/ConcentratedForceDTO.cs +++ b/DataAccess/DTOs/DTOEntities/ConcentratedForceDTO.cs @@ -1,7 +1,7 @@ using Newtonsoft.Json; using StructureHelperCommon.Models.Forces; -namespace DataAccess.DTOs.DTOEntities +namespace DataAccess.DTOs { public class ConcentratedForceDTO : IConcentratedForce { @@ -10,7 +10,7 @@ namespace DataAccess.DTOs.DTOEntities [JsonProperty("Name")] public string Name { get; set; } = string.Empty; [JsonProperty("ForceValue")] - public IForceTuple ForceValue { get; set; } + public IForceTuple ForceValue { get; set; } = new ForceTupleDTO(Guid.Empty); [JsonProperty("ForceCoordinate")] public double ForceCoordinate { get; set; } [JsonProperty("RelativeLoadLevel")] @@ -18,12 +18,16 @@ namespace DataAccess.DTOs.DTOEntities [JsonProperty("LoadRatio")] public double LoadRatio { get; set; } [JsonProperty("CombinationProperty")] - public IFactoredCombinationProperty CombinationProperty { get; set; } + public IFactoredCombinationProperty CombinationProperty { get; set; } = new FactoredCombinationPropertyDTO(Guid.Empty); + public ConcentratedForceDTO(Guid id) + { + Id = id; + } public object Clone() { - throw new NotImplementedException(); + return this; } } } diff --git a/DataAccess/DTOs/DTOEntities/CrossSectionNdmAnalysisDTO.cs b/DataAccess/DTOs/DTOEntities/CrossSectionNdmAnalysisDTO.cs index 494195f..915ade5 100644 --- a/DataAccess/DTOs/DTOEntities/CrossSectionNdmAnalysisDTO.cs +++ b/DataAccess/DTOs/DTOEntities/CrossSectionNdmAnalysisDTO.cs @@ -8,18 +8,23 @@ namespace DataAccess.DTOs public class CrossSectionNdmAnalysisDTO : ICrossSectionNdmAnalysis { [JsonProperty("Id")] - public Guid Id { get; set;} + public Guid Id { get;} [JsonProperty("Name")] public string Name { get; set; } [JsonProperty("Tags")] public string Tags { get; set; } [JsonProperty("VersionProcessor")] - public IVersionProcessor VersionProcessor { get; set; } = new VersionProcessorDTO(); + public IVersionProcessor VersionProcessor { get; set; } = new VersionProcessorDTO(Guid.NewGuid()); [JsonProperty("Comment")] public string Comment { get; set; } = string.Empty; [JsonProperty("Color")] public Color Color { get; set; } = new(); + public CrossSectionNdmAnalysisDTO(Guid id) + { + Id = id; + } + public object Clone() { return this; diff --git a/DataAccess/DTOs/DTOEntities/DistributedLoadDTO.cs b/DataAccess/DTOs/DTOEntities/DistributedLoadDTO.cs index 3d4d7d9..5647204 100644 --- a/DataAccess/DTOs/DTOEntities/DistributedLoadDTO.cs +++ b/DataAccess/DTOs/DTOEntities/DistributedLoadDTO.cs @@ -1,7 +1,7 @@ using Newtonsoft.Json; using StructureHelperCommon.Models.Forces; -namespace DataAccess.DTOs.DTOEntities +namespace DataAccess.DTOs { public class DistributedLoadDTO : IDistributedLoad { @@ -20,12 +20,15 @@ namespace DataAccess.DTOs.DTOEntities [JsonProperty("LoadRatio")] public double LoadRatio { get; set; } [JsonProperty("CombinationProperty")] - public IFactoredCombinationProperty CombinationProperty { get; set; } - + public IFactoredCombinationProperty CombinationProperty { get; set; } = new FactoredCombinationPropertyDTO(Guid.Empty); + public DistributedLoadDTO(Guid id) + { + Id = id; + } public object Clone() { - throw new NotImplementedException(); + return this; } } } diff --git a/DataAccess/DTOs/DTOEntities/FactoredForceTupleDTO.cs b/DataAccess/DTOs/DTOEntities/FactoredForceTupleDTO.cs new file mode 100644 index 0000000..c95cb52 --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/FactoredForceTupleDTO.cs @@ -0,0 +1,25 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Forces; + +namespace DataAccess.DTOs +{ + public class FactoredForceTupleDTO : IFactoredForceTuple + { + [JsonProperty("Id")] + public Guid Id { get; } + [JsonProperty("ForceTuple")] + public IForceTuple ForceTuple { get; set; } + [JsonProperty("CombinationProperty")] + public IFactoredCombinationProperty CombinationProperty { get; set; } + + public FactoredForceTupleDTO(Guid id) + { + Id = id; + } + + public object Clone() + { + return this; + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs b/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs index c1769c5..b00245f 100644 --- a/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs +++ b/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs @@ -5,6 +5,7 @@ using StructureHelperCommon.Models.Analyses; using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Materials.Libraries; +using StructureHelperLogics.Models.BeamShears; using StructureHelperLogics.NdmCalculations.Primitives; namespace DataAccess.DTOs @@ -50,12 +51,6 @@ namespace DataAccess.DTOs { (typeof(FileVersionDTO), "FileVersion") }, { (typeof(ForceCalculatorDTO), "ForceCalculator") }, { (typeof(ForceCalculatorInputDataDTO), "ForceCalculatorInputData") }, - { (typeof(ForceCombinationByFactorV1_0DTO), "ForceCombinationByFactor") }, - { (typeof(ForceFactoredListDTO), "ForceCombinationByFactor_v1_1") }, - { (typeof(ForceCombinationFromFileDTO), "ForceCombinationFromFile") }, - { (typeof(ForceCombinationListDTO), "ForceCombinationList") }, - { (typeof(FactoredCombinationPropertyDTO), "ForceFactoredCombinationProperty") }, - { (typeof(ForceTupleDTO), "ForceTuple") }, { (typeof(FRMaterialDTO), "FRMaterial") }, { (typeof(HeadMaterialDTO), "HeadMaterial") }, { (typeof(MaterialSafetyFactorDTO), "MaterialSafetyFactor") }, @@ -91,6 +86,42 @@ namespace DataAccess.DTOs { (typeof(UserCrackInputDataDTO), "UserCrackInputData") }, { (typeof(WorkPlanePropertyDTO), "WorkPlanePropertyDTO") }, }; + newList.AddRange(GetForceList()); + newList.AddRange(GetListForBeamShear()); + return newList; + } + + private static List<(Type type, string name)> GetForceList() + { + List<(Type type, string name)> newList = new() + { + { (typeof(ConcentratedForceDTO), "ConcentratedForce") }, + { (typeof(DistributedLoadDTO), "DistributedLoad") }, + { (typeof(FactoredForceTupleDTO), "FactoredForceTuple") }, + { (typeof(ForceCombinationByFactorV1_0DTO), "ForceCombinationByFactor") }, + { (typeof(ForceFactoredListDTO), "ForceCombinationByFactor_v1_1") }, + { (typeof(ForceCombinationFromFileDTO), "ForceCombinationFromFile") }, + { (typeof(ForceCombinationListDTO), "ForceCombinationList") }, + { (typeof(FactoredCombinationPropertyDTO), "ForceFactoredCombinationProperty") }, + { (typeof(ForceTupleDTO), "ForceTuple") }, + }; + return newList; + } + + private static List<(Type type, string name)> GetListForBeamShear() + { + List<(Type type, string name)> newList = new() + { + { (typeof(BeamShearDTO), "BeamShear") }, + { (typeof(BeamShearActionDTO), "BeamShearAction") }, + { (typeof(BeamShearAxisActionDTO), "BeamShearAxisAction") }, + { (typeof(BeamShearAnalysisDTO), "BeamShearAnalysis") }, + { (typeof(BeamShearRepositoryDTO), "BeamShearRepository") }, + { (typeof(List), "ListOfBeamShearActions") }, + { (typeof(List), "ListOfBeamShearSections") }, + { (typeof(List), "ListOfSpanLoads") }, + { (typeof(List), "ListOfStirrups") }, + }; return newList; } } diff --git a/DataAccess/DTOs/DTOEntities/VersionProcessorDTO.cs b/DataAccess/DTOs/DTOEntities/VersionProcessorDTO.cs index 22487fd..6aa3d43 100644 --- a/DataAccess/DTOs/DTOEntities/VersionProcessorDTO.cs +++ b/DataAccess/DTOs/DTOEntities/VersionProcessorDTO.cs @@ -1,22 +1,21 @@ using Newtonsoft.Json; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Analyses; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Text.Json.Serialization; -using System.Threading.Tasks; namespace DataAccess.DTOs { public class VersionProcessorDTO : IVersionProcessor { [JsonProperty("Id")] - public Guid Id { get; set; } + public Guid Id { get;} [JsonProperty("Versions")] public List Versions { get; } = new(); + public VersionProcessorDTO(Guid id) + { + Id = id; + } + public void AddVersion(ISaveable newItem) { throw new NotImplementedException(); diff --git a/StructureHelperCommon/Infrastructures/Interfaces/ConvertStrategy.cs b/StructureHelperCommon/Infrastructures/Interfaces/ConvertStrategy.cs index 0e513b3..e3b7f79 100644 --- a/StructureHelperCommon/Infrastructures/Interfaces/ConvertStrategy.cs +++ b/StructureHelperCommon/Infrastructures/Interfaces/ConvertStrategy.cs @@ -19,6 +19,12 @@ namespace StructureHelperCommon.Infrastructures.Interfaces TraceLogger = traceLogger; } + protected ConvertStrategy(IBaseConvertStrategy baseConvertStrategy) + { + ReferenceDictionary = baseConvertStrategy.ReferenceDictionary; + TraceLogger = baseConvertStrategy.TraceLogger; + } + protected ConvertStrategy(IConvertStrategy convertStrategy) { ReferenceDictionary = convertStrategy.ReferenceDictionary; diff --git a/StructureHelperCommon/Infrastructures/Interfaces/DictionaryConvertStrategy.cs b/StructureHelperCommon/Infrastructures/Interfaces/DictionaryConvertStrategy.cs index d173e49..549776c 100644 --- a/StructureHelperCommon/Infrastructures/Interfaces/DictionaryConvertStrategy.cs +++ b/StructureHelperCommon/Infrastructures/Interfaces/DictionaryConvertStrategy.cs @@ -28,6 +28,12 @@ namespace StructureHelperCommon.Infrastructures.Interfaces TraceLogger = baseConvertStrategy.TraceLogger; ConvertStrategy = convertStrategy; } + public DictionaryConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger? traceLogger, IConvertStrategy convertStrategy) + { + ReferenceDictionary = referenceDictionary; + TraceLogger = traceLogger; + ConvertStrategy = convertStrategy; + } public DictionaryConvertStrategy() { diff --git a/StructureHelperCommon/Infrastructures/Interfaces/IProcessStrategy.cs b/StructureHelperCommon/Infrastructures/Interfaces/IProcessStrategy.cs new file mode 100644 index 0000000..f2efb94 --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Interfaces/IProcessStrategy.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Infrastructures.Interfaces +{ + public interface IProcessStrategy + { + void Process(T entity); + } +} diff --git a/StructureHelperCommon/Infrastructures/Interfaces/IRepository.cs b/StructureHelperCommon/Infrastructures/Interfaces/IRepository.cs new file mode 100644 index 0000000..788bf98 --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Interfaces/IRepository.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Infrastructures.Interfaces +{ + public interface IRepository + { + void ClearRepository(); + } +} diff --git a/StructureHelperCommon/Infrastructures/Settings/ProgramSetting.cs b/StructureHelperCommon/Infrastructures/Settings/ProgramSetting.cs index 5957f5d..7f4ce6d 100644 --- a/StructureHelperCommon/Infrastructures/Settings/ProgramSetting.cs +++ b/StructureHelperCommon/Infrastructures/Settings/ProgramSetting.cs @@ -91,7 +91,7 @@ namespace StructureHelperCommon.Infrastructures.Settings return new FileVersion() { VersionNumber = 1, - SubVersionNumber = 1 + SubVersionNumber = 2 //Add Beam shear analysis }; } } diff --git a/StructureHelperCommon/Models/Analyses/VersionProcessor.cs b/StructureHelperCommon/Models/Analyses/VersionProcessor.cs index c7d9d89..270f1b7 100644 --- a/StructureHelperCommon/Models/Analyses/VersionProcessor.cs +++ b/StructureHelperCommon/Models/Analyses/VersionProcessor.cs @@ -15,14 +15,9 @@ namespace StructureHelperCommon.Models.Analyses public VersionProcessor(Guid id) { - Id = id; Versions = new(); } - public VersionProcessor() : this (Guid.NewGuid()) - { - - } private void AddVersion(IDateVersion version) { diff --git a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs index b25c9b4..d0101d2 100644 --- a/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs @@ -1,15 +1,12 @@ using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces.Logics; using StructureHelperCommon.Services; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelperCommon.Models.Forces.BeamShearActions { public class BeamShearLoadBaseUpdateStrategy : IUpdateStrategy { + private IUpdateStrategy combinationUpdateStrategy; public void Update(IBeamSpanLoad targetObject, IBeamSpanLoad sourceObject) { CheckObject.IsNull(targetObject); @@ -18,6 +15,10 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions targetObject.Name = sourceObject.Name; targetObject.LoadRatio = sourceObject.LoadRatio; targetObject.RelativeLoadLevel = sourceObject.RelativeLoadLevel; + CheckObject.IsNull(sourceObject.CombinationProperty); + CheckObject.IsNull(targetObject.CombinationProperty); + combinationUpdateStrategy ??= new FactoredCombinationPropertyUpdateStrategy(); + combinationUpdateStrategy.Update(targetObject.CombinationProperty, sourceObject.CombinationProperty); } } } diff --git a/StructureHelperCommon/Models/Forces/DesignForceTuple.cs b/StructureHelperCommon/Models/Forces/DesignForceTuple.cs index b7c0636..3c39dab 100644 --- a/StructureHelperCommon/Models/Forces/DesignForceTuple.cs +++ b/StructureHelperCommon/Models/Forces/DesignForceTuple.cs @@ -26,7 +26,7 @@ namespace StructureHelperCommon.Models.Forces public object Clone() { - var newTuple = new DesignForceTuple(); + var newTuple = new DesignForceTuple(Guid.NewGuid()); updateStrategy.Update(newTuple, this); return newTuple; } diff --git a/StructureHelperCommon/Models/Forces/ForceCombinationList.cs b/StructureHelperCommon/Models/Forces/ForceCombinationList.cs index af4268a..a13e3a2 100644 --- a/StructureHelperCommon/Models/Forces/ForceCombinationList.cs +++ b/StructureHelperCommon/Models/Forces/ForceCombinationList.cs @@ -27,7 +27,12 @@ namespace StructureHelperCommon.Models.Forces public ForceCombinationList(Guid id) { Id = id; - DesignForces = new List + DesignForces = AddDefaultForces(); + } + + private static List AddDefaultForces() + { + return new List { new DesignForceTuple() { @@ -51,6 +56,7 @@ namespace StructureHelperCommon.Models.Forces } }; } + public ForceCombinationList() : this (Guid.NewGuid()) { } /// public object Clone() diff --git a/StructureHelperCommon/Models/Forces/Logics/ActionUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ActionUpdateStrategy.cs index 19f5821..b0ecd82 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ActionUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ActionUpdateStrategy.cs @@ -1,11 +1,6 @@ using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Services; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelperCommon.Models.Forces { diff --git a/StructureHelperCommon/Models/Forces/Logics/HasForceCombinationUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/HasForceCombinationUpdateStrategy.cs index 43cf2b6..fb933c3 100644 --- a/StructureHelperCommon/Models/Forces/Logics/HasForceCombinationUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/HasForceCombinationUpdateStrategy.cs @@ -1,10 +1,5 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Services; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelperCommon.Models.Forces.Logics { diff --git a/StructureHelperLogics/Models/Analyses/BeamShearAnalysis.cs b/StructureHelperLogics/Models/Analyses/BeamShearAnalysis.cs index a6c7ffd..eda580d 100644 --- a/StructureHelperLogics/Models/Analyses/BeamShearAnalysis.cs +++ b/StructureHelperLogics/Models/Analyses/BeamShearAnalysis.cs @@ -1,10 +1,6 @@ -using StructureHelperCommon.Models.Analyses; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Analyses; using StructureHelperLogics.Models.BeamShears; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; using System.Windows.Media; namespace StructureHelperLogics.Models.Analyses @@ -12,6 +8,7 @@ namespace StructureHelperLogics.Models.Analyses /// public class BeamShearAnalysis : IBeamShearAnalysis { + private IUpdateStrategy updateStrategy; /// public Guid Id { get; } /// @@ -23,7 +20,7 @@ namespace StructureHelperLogics.Models.Analyses /// public Color Color { get; set; } = Color.FromRgb(128, 0, 0); /// - public IVersionProcessor VersionProcessor { get; set; } = new VersionProcessor(); + public IVersionProcessor VersionProcessor { get; set; } = new VersionProcessor(Guid.NewGuid()); public BeamShearAnalysis(Guid id) { Id = id; @@ -31,10 +28,28 @@ namespace StructureHelperLogics.Models.Analyses VersionProcessor.AddVersion(beamShear); } - + /// public object Clone() { - throw new NotImplementedException(); + InitializeStrategies(); + BeamShearAnalysis newAnalysis = new(Guid.NewGuid()); + updateStrategy.Update(newAnalysis, this); + newAnalysis.VersionProcessor.Versions.Clear(); + IBeamShear newVersion = GetCloneOfCurrentVersion(); + newAnalysis.VersionProcessor.AddVersion(newVersion); + return newAnalysis; + } + + private IBeamShear GetCloneOfCurrentVersion() + { + IBeamShear currentVersionOfSource = VersionProcessor.GetCurrentVersion().AnalysisVersion as IBeamShear; + IBeamShear newVersion = currentVersionOfSource.Clone() as IBeamShear; + return newVersion; + } + + private void InitializeStrategies() + { + updateStrategy ??= new BeamShearAnalysisUpdateStrategy(); } } } diff --git a/StructureHelperLogics/Models/Analyses/BeamShearAnalysisUpdateStrategy.cs b/StructureHelperLogics/Models/Analyses/BeamShearAnalysisUpdateStrategy.cs index a4f09a5..ca7c537 100644 --- a/StructureHelperLogics/Models/Analyses/BeamShearAnalysisUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Analyses/BeamShearAnalysisUpdateStrategy.cs @@ -22,7 +22,7 @@ namespace StructureHelperLogics.Models.Analyses targetObject.VersionProcessor.Versions.Clear(); foreach (var version in sourceObject.VersionProcessor.Versions) { - if (version is IBeamShear beamShear) + if (version.AnalysisVersion is IBeamShear beamShear) { updateVersion(targetObject, version, beamShear); } diff --git a/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysis.cs b/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysis.cs index fcf36d2..ce3a49b 100644 --- a/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysis.cs +++ b/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysis.cs @@ -9,7 +9,7 @@ namespace StructureHelperLogic.Models.Analyses { public class CrossSectionNdmAnalysis : ICrossSectionNdmAnalysis { - private CrossSectionNdmAnalysisUpdateStrategy updateStrategy = new(); + private IUpdateStrategy updateStrategy; public Guid Id { get; private set; } public string Name { get; set; } public string Tags { get; set; } @@ -23,12 +23,12 @@ namespace StructureHelperLogic.Models.Analyses VersionProcessor = versionProcessor; } - public CrossSectionNdmAnalysis(Guid id) : this (id, new VersionProcessor()) + public CrossSectionNdmAnalysis(Guid id) : this (id, new VersionProcessor(Guid.NewGuid())) { } - public CrossSectionNdmAnalysis() : this(Guid.NewGuid(), new VersionProcessor()) + public CrossSectionNdmAnalysis() : this(Guid.NewGuid(), new VersionProcessor(Guid.NewGuid())) { CrossSection crossSection = new(); VersionProcessor.AddVersion(crossSection); @@ -36,11 +36,12 @@ namespace StructureHelperLogic.Models.Analyses public object Clone() { + updateStrategy ??= new CrossSectionNdmAnalysisUpdateStrategy(); CrossSectionNdmAnalysis newAnalysis = new(); updateStrategy.Update(newAnalysis, this); + newAnalysis.VersionProcessor.Versions.Clear(); var currentVersion = VersionProcessor.GetCurrentVersion().AnalysisVersion as ICloneable; ISaveable newCrossSection = currentVersion.Clone() as ISaveable; - newAnalysis.VersionProcessor.Versions.Clear(); newAnalysis.VersionProcessor.AddVersion(newCrossSection); return newAnalysis; } diff --git a/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs b/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs index e719680..52cfb66 100644 --- a/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs +++ b/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs @@ -4,11 +4,6 @@ using StructureHelperCommon.Models.Analyses; using StructureHelperCommon.Services; using StructureHelperLogic.Models.Analyses; using StructureHelperLogics.Models.CrossSections; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelperLogics.Models.Analyses { diff --git a/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs b/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs index 8d4bc83..7733904 100644 --- a/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs +++ b/StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs @@ -1,17 +1,33 @@ -using StructureHelperCommon.Infrastructures.Interfaces; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; +using StructureHelperLogics.Models.BeamShears.Logics; + +//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. namespace StructureHelperLogics.Models.BeamShears { public class BeamShearUpdateStrategy : IUpdateStrategy { + IProcessStrategy clearStrategy; + IUpdateStrategy repositoryUpdateStrategy; public void Update(IBeamShear targetObject, IBeamShear sourceObject) { - throw new NotImplementedException(); + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; }; + CheckObject.IsNull(sourceObject.Repository); + CheckObject.IsNull(targetObject.Repository); + InitializeStrategies(); + clearStrategy.Process(targetObject.Repository); + repositoryUpdateStrategy.Update(targetObject.Repository, sourceObject.Repository); + } + + private void InitializeStrategies() + { + repositoryUpdateStrategy ??= new BeamShearRepositoryAddUpdateStrategy(); + clearStrategy ??= new BeamShearReporitoryClearStrategy(); } } } diff --git a/StructureHelperLogics/Models/BeamShears/Logics/BeamShearReporitoryClearStrategy.cs b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearReporitoryClearStrategy.cs new file mode 100644 index 0000000..3cc81b6 --- /dev/null +++ b/StructureHelperLogics/Models/BeamShears/Logics/BeamShearReporitoryClearStrategy.cs @@ -0,0 +1,23 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; + +//Copyright (c) 2025 Redikultsev Evgeny, Ekaterinburg, Russia +//All rights reserved. + +namespace StructureHelperLogics.Models.BeamShears +{ + public class BeamShearReporitoryClearStrategy : IProcessStrategy + { + public void Process(IBeamShearRepository entity) + { + CheckObject.IsNull(entity.Calculators); + entity.Calculators.Clear(); + CheckObject.IsNull(entity.Actions); + entity.Actions.Clear(); + CheckObject.IsNull(entity.Sections); + entity.Sections.Clear(); + CheckObject.IsNull(entity.Stirrups); + entity.Stirrups.Clear(); + } + } +}