diff --git a/DataAccess/DTOs/Converters/AccuracyFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/AccuracyFromDTOConvertStrategy.cs new file mode 100644 index 0000000..d2600b8 --- /dev/null +++ b/DataAccess/DTOs/Converters/AccuracyFromDTOConvertStrategy.cs @@ -0,0 +1,25 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; + +namespace DataAccess.DTOs +{ + public class AccuracyFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + public override Accuracy GetNewItem(AccuracyDTO source) + { + updateStrategy ??= new AccuracyUpdateStrategy(); + try + { + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + } +} diff --git a/DataAccess/DTOs/Converters/AccuracyToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/AccuracyToDTOConvertStrategy.cs new file mode 100644 index 0000000..2b1abe6 --- /dev/null +++ b/DataAccess/DTOs/Converters/AccuracyToDTOConvertStrategy.cs @@ -0,0 +1,25 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; + +namespace DataAccess.DTOs +{ + public class AccuracyToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + public override AccuracyDTO GetNewItem(IAccuracy source) + { + updateStrategy ??= new AccuracyUpdateStrategy(); + try + { + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + } +} diff --git a/DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs index e4e69d0..15f8ea4 100644 --- a/DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs @@ -61,6 +61,10 @@ namespace DataAccess.DTOs { return ProcessCrackCalculator(crackCalculator); } + if (source is LimitCurvesCalculator limitCalculator) + { + TraceLogger?.AddMessage($"Current version of StructureHelper does not suppurt saving interaction diagram calculator, {limitCalculator.Name} was ignored"); + } string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source); TraceLogger.AddMessage(errorString, TraceLogStatuses.Error); throw new StructureHelperException(errorString); diff --git a/DataAccess/DTOs/Converters/ColumnFilePropertyFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ColumnFilePropertyFromDTOConvertStrategy.cs new file mode 100644 index 0000000..f2a12ee --- /dev/null +++ b/DataAccess/DTOs/Converters/ColumnFilePropertyFromDTOConvertStrategy.cs @@ -0,0 +1,25 @@ +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 +{ + public class ColumnFilePropertyFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + public override ColumnFileProperty GetNewItem(ColumnFilePropertyDTO source) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + updateStrategy ??= new ColumnFilePropertyUpdateStrategy(); + ColumnFileProperty newItem = new(source.Id, source.Name); + updateStrategy.Update(newItem, source); + return newItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/ColumnFilePropertyToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ColumnFilePropertyToDTOConvertStrategy.cs new file mode 100644 index 0000000..80537c1 --- /dev/null +++ b/DataAccess/DTOs/Converters/ColumnFilePropertyToDTOConvertStrategy.cs @@ -0,0 +1,30 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; + +namespace DataAccess.DTOs +{ + public class ColumnFilePropertyToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + + public ColumnFilePropertyToDTOConvertStrategy(IUpdateStrategy updateStrategy) + { + this.updateStrategy = updateStrategy; + } + + public ColumnFilePropertyToDTOConvertStrategy() + { + + } + + public override ColumnFilePropertyDTO GetNewItem(IColumnFileProperty source) + { + TraceLogger?.AddMessage($"Column file property Id={source.Id} converting to {typeof(ColumnFilePropertyDTO)} has been started"); + updateStrategy ??= new ColumnFilePropertyUpdateStrategy(); + ColumnFilePropertyDTO newItem = new(source.Id); + updateStrategy.Update(newItem, source); + TraceLogger?.AddMessage($"Column file property Id={source.Id} converting to {typeof(ColumnFilePropertyDTO)} has been finished"); + return newItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/ColumnedFilePropertyFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ColumnedFilePropertyFromDTOConvertStrategy.cs new file mode 100644 index 0000000..20d0555 --- /dev/null +++ b/DataAccess/DTOs/Converters/ColumnedFilePropertyFromDTOConvertStrategy.cs @@ -0,0 +1,58 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Loggers; + +namespace DataAccess.DTOs +{ + public class ColumnedFilePropertyFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy? updateStrategy; + private IConvertStrategy? columnConvertStrategy; + public override ColumnedFileProperty GetNewItem(ColumnedFilePropertyDTO source) + { + TraceLogger?.AddMessage($"Converting of columned file property Path={source.FilePath} has been started"); + InitializeStrategies(); + try + { + ColumnedFileProperty newItem = GetFilePropertyBySource(source); + TraceLogger?.AddMessage($"Converting of columned file property Path={newItem.FilePath} has been finished successfully"); + return newItem; + } + catch (Exception ex) + { + TraceLogger?.AddMessage($"Logic: {LoggerStrings.LogicType(this)} made error: {ex.Message}", TraceLogStatuses.Error); + throw; + } + } + + private ColumnedFileProperty GetFilePropertyBySource(ColumnedFilePropertyDTO source) + { + ColumnedFileProperty newItem = new(source.Id); + updateStrategy?.Update(newItem, source); + newItem.ColumnProperties.Clear(); + foreach (var item in source.ColumnProperties) + { + if (item is ColumnFilePropertyDTO columnPropertyDTO) + { + ColumnFileProperty columnFileProperty = columnConvertStrategy.Convert(columnPropertyDTO); + newItem.ColumnProperties.Add(columnFileProperty); + } + else + { + string errorString = ErrorStrings.ExpectedWas(typeof(ColumnFilePropertyDTO), item); + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + throw new StructureHelperException(errorString); + } + } + + return newItem; + } + private void InitializeStrategies() + { + updateStrategy ??= new ColumnedFilePropertyUpdateStrategy(); + columnConvertStrategy ??= new ColumnFilePropertyFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + } + } +} diff --git a/DataAccess/DTOs/Converters/ColumnedFilePropertyToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ColumnedFilePropertyToDTOConvertStrategy.cs new file mode 100644 index 0000000..d00e765 --- /dev/null +++ b/DataAccess/DTOs/Converters/ColumnedFilePropertyToDTOConvertStrategy.cs @@ -0,0 +1,52 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Loggers; + +namespace DataAccess.DTOs +{ + /// + public class ColumnedFilePropertyToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy? updateStrategy; + private IConvertStrategy? columnConvertStrategy; + + public override ColumnedFilePropertyDTO GetNewItem(IColumnedFileProperty source) + { + TraceLogger?.AddMessage($"Columned file property Id = {source.Id}, Path = {source.FilePath} converting has been started"); + InitializeStrategies(); + try + { + ColumnedFilePropertyDTO newItem = GetNewItemBySource(source); + TraceLogger?.AddMessage($"Columned file property Id={newItem.Id}, Path = {newItem.FilePath} converting has been finished successfully"); + return newItem; + } + catch (Exception ex) + { + TraceLogger?.AddMessage($"Logic: {LoggerStrings.LogicType(this)} made error: {ex.Message}", TraceLogStatuses.Error); + throw; + } + + } + + private ColumnedFilePropertyDTO GetNewItemBySource(IColumnedFileProperty source) + { + ColumnedFilePropertyDTO newItem = new(source.Id); + updateStrategy?.Update(newItem, source); + newItem.ColumnProperties.Clear(); + foreach (var item in source.ColumnProperties) + { + ColumnFilePropertyDTO columnFilePropertyDTO = columnConvertStrategy.Convert(item); + newItem.ColumnProperties.Add(columnFilePropertyDTO); + } + + return newItem; + } + + private void InitializeStrategies() + { + updateStrategy ??= new ColumnedFilePropertyUpdateStrategy(); + columnConvertStrategy ??= new ColumnFilePropertyToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + } + } +} diff --git a/DataAccess/DTOs/Converters/ConvertDirection.cs b/DataAccess/DTOs/Converters/ConvertDirection.cs new file mode 100644 index 0000000..230f58c --- /dev/null +++ b/DataAccess/DTOs/Converters/ConvertDirection.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public enum ConvertDirection + { + FromDTO, + ToDTO + } +} diff --git a/DataAccess/DTOs/Converters/CrackCalculatorInputDataFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrackCalculatorInputDataFromDTOConvertStrategy.cs index c85c680..9b7893f 100644 --- a/DataAccess/DTOs/Converters/CrackCalculatorInputDataFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CrackCalculatorInputDataFromDTOConvertStrategy.cs @@ -12,35 +12,50 @@ namespace DataAccess.DTOs { public class CrackCalculatorInputDataFromDTOConvertStrategy : ConvertStrategy { - private IUpdateStrategy userDataUpdateStrategy = new UserCrackInputDataUpdateStrategy(); - private IHasPrimitivesProcessLogic primitivesProcessLogic = new HasPrimitivesProcessLogic(); - private IHasForceActionsProcessLogic actionsProcessLogic = new HasForceActionsProcessLogic(); + private IUpdateStrategy userDataUpdateStrategy; + private IHasPrimitivesProcessLogic primitivesProcessLogic; + private IHasForceActionsProcessLogic actionsProcessLogic; + private IConvertStrategy userDataConvertStrategy; public override CrackCalculatorInputData GetNewItem(CrackCalculatorInputDataDTO source) + { + InitializeStrategies(); + try + { + GetNewItemBySource(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + private void GetNewItemBySource(CrackCalculatorInputDataDTO source) { NewItem = new(source.Id); ProcessPrimitives(source); ProcessActions(source); NewItem.UserCrackInputData = new UserCrackInputData(source.UserCrackInputData.Id); userDataUpdateStrategy.Update(NewItem.UserCrackInputData, source.UserCrackInputData); - return NewItem; } - + private void InitializeStrategies() + { + userDataUpdateStrategy ??= new UserCrackInputDataUpdateStrategy(); + primitivesProcessLogic ??= new HasPrimitivesProcessLogic(ConvertDirection.FromDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + actionsProcessLogic ??= new HasForceActionsProcessLogic(ConvertDirection.FromDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + userDataConvertStrategy ??= new UserCrackInputDataFromDTOConvertStrategy(ReferenceDictionary, TraceLogger); + } private void ProcessPrimitives(IHasPrimitives source) { primitivesProcessLogic.Source = source; primitivesProcessLogic.Target = NewItem; - primitivesProcessLogic.ReferenceDictionary = ReferenceDictionary; - primitivesProcessLogic.TraceLogger = TraceLogger; primitivesProcessLogic.Process(); } - private void ProcessActions(IHasForceActions source) { actionsProcessLogic.Source = source; actionsProcessLogic.Target = NewItem; - actionsProcessLogic.ReferenceDictionary = ReferenceDictionary; - actionsProcessLogic.TraceLogger = TraceLogger; actionsProcessLogic.Process(); } } diff --git a/DataAccess/DTOs/Converters/CrackCalculatorInputDataToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrackCalculatorInputDataToDTOConvertStrategy.cs new file mode 100644 index 0000000..21d4725 --- /dev/null +++ b/DataAccess/DTOs/Converters/CrackCalculatorInputDataToDTOConvertStrategy.cs @@ -0,0 +1,64 @@ +using DataAccess.DTOs.Converters; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperLogics.NdmCalculations.Cracking; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class CrackCalculatorInputDataToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy userDataUpdateStrategy; + private IHasPrimitivesProcessLogic primitivesProcessLogic; + private IHasForceActionsProcessLogic actionsProcessLogic; + private IConvertStrategy userDataConvertStrategy; + + public override CrackCalculatorInputDataDTO GetNewItem(ICrackCalculatorInputData source) + { + InitializeStrategies(); + try + { + GetNewItemBySource(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewItemBySource(ICrackCalculatorInputData source) + { + NewItem = new(source.Id); + ProcessPrimitives(source); + ProcessActions(source); + NewItem.UserCrackInputData = userDataConvertStrategy.Convert(source.UserCrackInputData); + userDataUpdateStrategy.Update(NewItem.UserCrackInputData, source.UserCrackInputData); + } + private void InitializeStrategies() + { + userDataUpdateStrategy ??= new UserCrackInputDataUpdateStrategy(); + primitivesProcessLogic ??= new HasPrimitivesProcessLogic(ConvertDirection.ToDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + actionsProcessLogic ??= new HasForceActionsProcessLogic(ConvertDirection.ToDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + userDataConvertStrategy ??= new UserCrackInputDataToDTOConvertStrategy(ReferenceDictionary, TraceLogger); + } + private void ProcessPrimitives(IHasPrimitives source) + { + primitivesProcessLogic.Source = source; + primitivesProcessLogic.Target = NewItem; + primitivesProcessLogic.Process(); + } + private void ProcessActions(IHasForceActions source) + { + actionsProcessLogic.Source = source; + actionsProcessLogic.Target = NewItem; + actionsProcessLogic.Process(); + } + + } +} diff --git a/DataAccess/DTOs/Converters/CrackCalculatorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrackCalculatorToDTOConvertStrategy.cs index 704760b..05755cb 100644 --- a/DataAccess/DTOs/Converters/CrackCalculatorToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CrackCalculatorToDTOConvertStrategy.cs @@ -1,85 +1,51 @@ using DataAccess.DTOs.Converters; -using DataAccess.DTOs.DTOEntities; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Loggers; -using StructureHelperLogics.Models.Materials; using StructureHelperLogics.NdmCalculations.Analyses.ByForces; using StructureHelperLogics.NdmCalculations.Cracking; using StructureHelperLogics.NdmCalculations.Primitives; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace DataAccess.DTOs { - public class CrackCalculatorToDTOConvertStrategy : IConvertStrategy + public class CrackCalculatorToDTOConvertStrategy : ConvertStrategy { - private readonly IUpdateStrategy updateStrategy; + private IUpdateStrategy updateStrategy; + private IConvertStrategy inputDataConvertStrategy; public CrackCalculatorToDTOConvertStrategy(IUpdateStrategy updateStrategy) { this.updateStrategy = updateStrategy; } - public CrackCalculatorToDTOConvertStrategy() : this (new CrackCalculatorUpdateStrategy()) - { - - } - - public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } - public IShiftTraceLogger TraceLogger { get; set; } - - public CrackCalculatorDTO Convert(ICrackCalculator source) + public CrackCalculatorToDTOConvertStrategy() { } + public override CrackCalculatorDTO GetNewItem(ICrackCalculator source) { + InitializeStrategies(); try { - Check(); - return GetNewItem(source); + GetNewItemBySource(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 CrackCalculatorDTO GetNewItem(ICrackCalculator source) + private void InitializeStrategies() { - CrackCalculatorDTO newItem = new() { Id = source.Id}; - updateStrategy.Update(newItem, source); - ProcessForceActions(newItem.InputData, source.InputData); - ProcessPrimitives(newItem.InputData, source.InputData); - return newItem; + updateStrategy ??= new CrackCalculatorUpdateStrategy(); + inputDataConvertStrategy ??= new CrackCalculatorInputDataToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; } - private void ProcessPrimitives(IHasPrimitives target, IHasPrimitives source) + private void GetNewItemBySource(ICrackCalculator source) { - HasPrimitivesToDTOUpdateStrategy updateStrategy = new() - { - ReferenceDictionary = ReferenceDictionary, - TraceLogger = TraceLogger - }; - updateStrategy.Update(target, source); + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + NewItem.InputData = inputDataConvertStrategy.Convert(source.InputData); } - private void ProcessForceActions(IHasForceActions target, IHasForceActions source) - { - HasForceActionToDTOUpdateStrategy updateStrategy = new() - { - ReferenceDictionary = ReferenceDictionary, - TraceLogger = TraceLogger - }; - updateStrategy.Update(target, source); - } - - private void Check() - { - var checkLogic = new CheckConvertLogic(this); - checkLogic.Check(); - } } } diff --git a/DataAccess/DTOs/Converters/CrossSectionRepositoryFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrossSectionRepositoryFromDTOConvertStrategy.cs index 61a79cc..aa0a57f 100644 --- a/DataAccess/DTOs/Converters/CrossSectionRepositoryFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CrossSectionRepositoryFromDTOConvertStrategy.cs @@ -23,8 +23,8 @@ namespace DataAccess.DTOs private const string convertFinished = " converting has been finished successfully"; private CrossSectionRepository newRepository; - private IHasPrimitivesProcessLogic primitivesProcessLogic = new HasPrimitivesProcessLogic(); - private IHasForceActionsProcessLogic actionsProcessLogic = new HasForceActionsProcessLogic(); + private IHasPrimitivesProcessLogic primitivesProcessLogic = new HasPrimitivesProcessLogic(ConvertDirection.FromDTO); + private IHasForceActionsProcessLogic actionsProcessLogic = new HasForceActionsProcessLogic(ConvertDirection.FromDTO); public override CrossSectionRepository GetNewItem(ICrossSectionRepository source) { diff --git a/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs index 1045b8c..ca4b489 100644 --- a/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs @@ -1,23 +1,11 @@ using DataAccess.DTOs.Converters; -using NLog.Targets; using StructureHelper.Models.Materials; -using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; -using StructureHelperCommon.Infrastructures.Settings; using StructureHelperCommon.Models; -using StructureHelperCommon.Models.Analyses; using StructureHelperCommon.Models.Calculators; -using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Loggers; using StructureHelperLogics.Models.CrossSections; -using StructureHelperLogics.Models.Materials; -using StructureHelperLogics.NdmCalculations.Analyses.ByForces; using StructureHelperLogics.NdmCalculations.Primitives; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace DataAccess.DTOs { @@ -58,8 +46,6 @@ namespace DataAccess.DTOs private CrossSectionRepositoryDTO GetNewRepository(ICrossSectionRepository source) { - var project = ProgramSetting.CurrentProject; - CrossSectionRepositoryDTO newItem = new() { Id = source.Id diff --git a/DataAccess/DTOs/Converters/DesignForceTupleFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/DesignForceTupleFromDTOConvertStrategy.cs index d26159b..f6c1098 100644 --- a/DataAccess/DTOs/Converters/DesignForceTupleFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/DesignForceTupleFromDTOConvertStrategy.cs @@ -1,11 +1,8 @@ using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Forces.Logics; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; +using StructureHelperCommon.Models.Loggers; namespace DataAccess.DTOs { @@ -31,14 +28,28 @@ namespace DataAccess.DTOs public override DesignForceTuple GetNewItem(DesignForceTupleDTO source) { - TraceLogger?.AddMessage("Design force tuple converting is started"); + TraceLogger?.AddMessage("Design force tuple converting has been started"); + try + { + DesignForceTuple newItem = GetNewItemBySource(source); + TraceLogger?.AddMessage("Design force tuple converting has been finished"); + return newItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private DesignForceTuple GetNewItemBySource(DesignForceTupleDTO source) + { DesignForceTuple newItem = new(source.Id); updateStrategy.Update(newItem, source); forceTupleConvertStrategy.ReferenceDictionary = ReferenceDictionary; forceTupleConvertStrategy.TraceLogger = TraceLogger; var convertLogic = new DictionaryConvertStrategy(this, forceTupleConvertStrategy); newItem.ForceTuple = convertLogic.Convert((ForceTupleDTO)source.ForceTuple); - TraceLogger?.AddMessage("Design force tuple converting has been finished"); return newItem; } } diff --git a/DataAccess/DTOs/Converters/DesignForceTupleToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/DesignForceTupleToDTOConvertStrategy.cs index cd33d18..209970b 100644 --- a/DataAccess/DTOs/Converters/DesignForceTupleToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/DesignForceTupleToDTOConvertStrategy.cs @@ -10,7 +10,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -namespace DataAccess.DTOs.Converters +namespace DataAccess.DTOs { public class DesignForceTupleToDTOConvertStrategy : IConvertStrategy { diff --git a/DataAccess/DTOs/Converters/FactoredCombinationPropertyFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/FactoredCombinationPropertyFromDTOConvertStrategy.cs new file mode 100644 index 0000000..3714db2 --- /dev/null +++ b/DataAccess/DTOs/Converters/FactoredCombinationPropertyFromDTOConvertStrategy.cs @@ -0,0 +1,24 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.Logics; + +namespace DataAccess.DTOs +{ + public class FactoredCombinationPropertyFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + public override FactoredCombinationProperty GetNewItem(FactoredCombinationPropertyDTO source) + { + InitializeStrategies(); + TraceLogger.AddMessage($"Force factored combination property Id={source.Id} converting has been started"); + FactoredCombinationProperty newItem = new(source.Id); + updateStrategy.Update(newItem, source); + TraceLogger.AddMessage($"Force factored combination property Id={newItem.Id} converting has been finished"); + return newItem; + } + private void InitializeStrategies() + { + updateStrategy ??= new FactoredCombinationPropertyUpdateStrategy(); + } + } +} diff --git a/DataAccess/DTOs/Converters/FactoredCombinationPropertyToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/FactoredCombinationPropertyToDTOConvertStrategy.cs new file mode 100644 index 0000000..cab1cbc --- /dev/null +++ b/DataAccess/DTOs/Converters/FactoredCombinationPropertyToDTOConvertStrategy.cs @@ -0,0 +1,40 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.Logics; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class FactoredCombinationPropertyToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + + public FactoredCombinationPropertyToDTOConvertStrategy(IUpdateStrategy updateStrategy) + { + this.updateStrategy = updateStrategy; + } + + public FactoredCombinationPropertyToDTOConvertStrategy() + { + + } + public override FactoredCombinationPropertyDTO GetNewItem(IFactoredCombinationProperty source) + { + InitializeStrategies(); + TraceLogger.AddMessage($"Force factored combination property Id={source.Id} converting has been started"); + FactoredCombinationPropertyDTO newItem = new(source.Id); + updateStrategy.Update(newItem, source); + TraceLogger.AddMessage($"Force factored combination property Id={newItem.Id} converting has been finished"); + return newItem; + } + + private void InitializeStrategies() + { + updateStrategy ??= new FactoredCombinationPropertyUpdateStrategy(); + } + } +} diff --git a/DataAccess/DTOs/Converters/ForceActionFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceActionFromDTOConvertStrategy.cs new file mode 100644 index 0000000..6ef48da --- /dev/null +++ b/DataAccess/DTOs/Converters/ForceActionFromDTOConvertStrategy.cs @@ -0,0 +1,103 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Loggers; + +namespace DataAccess.DTOs +{ + public class ForceActionFromDTOConvertStrategy : ConvertStrategy + { + private IConvertStrategy listConvertStrategy; + private IConvertStrategy factorConvertStrategy_v1_0; + private IConvertStrategy factorConvertStrategy; + private IConvertStrategy fileConvertStrategy; + + public ForceActionFromDTOConvertStrategy( + IConvertStrategy listConvertStrategy, + IConvertStrategy factorConvertStrategy_v1_0, + IConvertStrategy factorConvertStrategy, + IConvertStrategy fileConvertStrategy) + { + this.listConvertStrategy = listConvertStrategy; + this.factorConvertStrategy_v1_0 = factorConvertStrategy_v1_0; + this.factorConvertStrategy = factorConvertStrategy; + this.fileConvertStrategy = fileConvertStrategy; + } + + public ForceActionFromDTOConvertStrategy() { } + + public override IForceAction GetNewItem(IForceAction source) + { + InitializeStrategies(); + try + { + NewItem = GetNewItemBySource(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void InitializeStrategies() + { + listConvertStrategy ??= new ForceCombinationListFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + factorConvertStrategy ??= new ForceFactoredListFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + fileConvertStrategy ??= new ForceCombinationFromFileFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + } + private IForceAction GetNewItemBySource(IForceAction source) + { + if (source is ForceFactoredListDTO combination) + { + return GetFactoredCombination(combination); + } + if (source is ForceCombinationListDTO forceList) + { + return GetForceList(forceList); + } + if (source is ForceCombinationFromFileDTO fileCombination) + { + return GetFileCombination(fileCombination); + } + if (source is ForceCombinationByFactorV1_0DTO combination_v1_0) + { + return Obsolete_GetForceCombination_V1_0(combination_v1_0); + } + string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source); + TraceLogger.AddMessage(errorString, TraceLogStatuses.Error); + throw new StructureHelperException(errorString); + } + private ForceCombinationFromFile GetFileCombination(ForceCombinationFromFileDTO source) + { + TraceLogger?.AddMessage("Force action is combination by factors"); + ForceCombinationFromFile newItem = fileConvertStrategy.Convert(source); + return newItem; + } + private ForceFactoredList Obsolete_GetForceCombination_V1_0(ForceCombinationByFactorV1_0DTO source) + { + TraceLogger?.AddMessage("Force action is combination by factors version 1.0 (obsolete)", TraceLogStatuses.Warning); + factorConvertStrategy_v1_0 ??= new ForceCombinationByFactorV1_0FromDTOConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + ForceFactoredList newItem = factorConvertStrategy_v1_0.Convert(source); + return newItem; + } + private IForceAction GetFactoredCombination(ForceFactoredListDTO source) + { + TraceLogger?.AddMessage("Force action is combination by factors"); + ForceFactoredList newItem = factorConvertStrategy.Convert(source); + return newItem; + } + private IForceAction GetForceList(ForceCombinationListDTO forceList) + { + TraceLogger?.AddMessage("Force action is combination by list"); + ForceCombinationList newItem = listConvertStrategy.Convert(forceList); + return newItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/ForceActionToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceActionToDTOConvertStrategy.cs index be2b13c..5ce4168 100644 --- a/DataAccess/DTOs/Converters/ForceActionToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceActionToDTOConvertStrategy.cs @@ -4,61 +4,75 @@ using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Loggers; -namespace DataAccess.DTOs.Converters +namespace DataAccess.DTOs { public class ForceActionToDTOConvertStrategy : ConvertStrategy { - private IConvertStrategy forceCombinationByFactorConvertStrategy; + private IConvertStrategy forceFactoredListConvertStrategy; private IConvertStrategy forceCombinationListConvertStrategy; + private IConvertStrategy forceCombinationFromFileConvertStrategy; public ForceActionToDTOConvertStrategy( - IConvertStrategy forceCombinationByFactorConvertStrategy, - IConvertStrategy forceCombinationListConvertStrategy) + IConvertStrategy forceFactoredListConvertStrategy, + IConvertStrategy forceCombinationListConvertStrategy, + IConvertStrategy forceCombinationFromFileConvertStrategy) { - this.forceCombinationByFactorConvertStrategy = forceCombinationByFactorConvertStrategy; + this.forceFactoredListConvertStrategy = forceFactoredListConvertStrategy; this.forceCombinationListConvertStrategy = forceCombinationListConvertStrategy; + this.forceCombinationFromFileConvertStrategy = forceCombinationFromFileConvertStrategy; } - public ForceActionToDTOConvertStrategy() : this( - new ForceCombinationByFactorToDTOConvertStrategy(), - new ForceCombinationListToDTOConvertStrategy()) - { - - } + public ForceActionToDTOConvertStrategy() { } public override IForceAction GetNewItem(IForceAction source) { - if (source is IForceFactoredList forceCombinationByFactor) + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger?.AddMessage($"Force action converting has been started"); + InitializeStrategies(); + if (source is IForceFactoredList forceFactoredList) { - return GetForceCombinationByFactor(forceCombinationByFactor); + return GetForceCombinationByFactor(forceFactoredList); } else if (source is IForceCombinationList forceCombinationList) { return GetForceCombinationList(forceCombinationList); } + else if (source is IForceCombinationFromFile forceCombinationFile) + { + return GetForceCombinationFile(forceCombinationFile); + } else { - string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source); TraceLogger.AddMessage(errorString, TraceLogStatuses.Error); throw new StructureHelperException(errorString); } } + private IForceAction GetForceCombinationFile(IForceCombinationFromFile forceCombinationFile) + { + var convertLogic = new DictionaryConvertStrategy(this, forceCombinationFromFileConvertStrategy); + var forceCombination = convertLogic.Convert(forceCombinationFile); + return forceCombination; + } + + private void InitializeStrategies() + { + forceFactoredListConvertStrategy ??= new ForceFactoredListToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + forceCombinationListConvertStrategy ??= new ForceCombinationListToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; ; + forceCombinationFromFileConvertStrategy ??= new ForceCombinaionFromFileToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; ; + } + private ForceCombinationListDTO GetForceCombinationList(IForceCombinationList forceCombinationList) { - forceCombinationListConvertStrategy.ReferenceDictionary = ReferenceDictionary; - forceCombinationListConvertStrategy.TraceLogger = TraceLogger; var convertLogic = new DictionaryConvertStrategy(this, forceCombinationListConvertStrategy); var forceCombination = convertLogic.Convert(forceCombinationList); return forceCombination; } - private ForceCombinationByFactorDTO GetForceCombinationByFactor(IForceFactoredList forceCombinationByFactor) + private ForceFactoredListDTO GetForceCombinationByFactor(IForceFactoredList forceCombinationByFactor) { - forceCombinationByFactorConvertStrategy.ReferenceDictionary = ReferenceDictionary; - forceCombinationByFactorConvertStrategy.TraceLogger = TraceLogger; - var convertLogic = new DictionaryConvertStrategy(this, forceCombinationByFactorConvertStrategy); + var convertLogic = new DictionaryConvertStrategy(this, forceFactoredListConvertStrategy); var forceCombination = convertLogic.Convert(forceCombinationByFactor); return forceCombination; } diff --git a/DataAccess/DTOs/Converters/ForceActionsFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceActionsFromDTOConvertStrategy.cs deleted file mode 100644 index 4c7812b..0000000 --- a/DataAccess/DTOs/Converters/ForceActionsFromDTOConvertStrategy.cs +++ /dev/null @@ -1,84 +0,0 @@ -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 ForceActionsFromDTOConvertStrategy : ConvertStrategy - { - private IConvertStrategy listConvertStrategy; - private IConvertStrategy factorConvertStrategy_v1_0; - private IConvertStrategy factorConvertStrategy; - - public ForceActionsFromDTOConvertStrategy( - IConvertStrategy listConvertStrategy, - IConvertStrategy factorConvertStrategy_v1_0, - IConvertStrategy factorConvertStrategy) - { - this.listConvertStrategy = listConvertStrategy; - this.factorConvertStrategy_v1_0 = factorConvertStrategy_v1_0; - this.factorConvertStrategy = factorConvertStrategy; - } - - public ForceActionsFromDTOConvertStrategy() : this ( - new ForceCombinationListFromDTOConvertStrategy(), - new ForceCombinationByFactorV1_0FromDTOConvertStrategy(), - new ForceCombinationByFactorFromDTOConvertStrategy()) - { - - } - - public override IForceAction GetNewItem(IForceAction source) - { - if (source is ForceCombinationByFactorV1_0DTO combination_v1_0) - { - return Obsolete_GetForceCombination_V1_0(combination_v1_0); - } - if (source is ForceCombinationByFactorDTO combination) - { - return GetForceCombination(combination); - } - if (source is ForceCombinationListDTO forceList) - { - return GetForceList(forceList); - } - string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source); - TraceLogger.AddMessage(errorString, TraceLogStatuses.Error); - throw new StructureHelperException(errorString); - } - - private ForceFactoredList Obsolete_GetForceCombination_V1_0(ForceCombinationByFactorV1_0DTO source) - { - TraceLogger?.AddMessage("Force action is combination by factors version 1.0 (obsolete)", TraceLogStatuses.Warning); - factorConvertStrategy_v1_0.ReferenceDictionary = ReferenceDictionary; - factorConvertStrategy_v1_0.TraceLogger = TraceLogger; - ForceFactoredList newItem = factorConvertStrategy_v1_0.Convert(source); - return newItem; - } - - private IForceAction GetForceCombination(ForceCombinationByFactorDTO source) - { - TraceLogger?.AddMessage("Force action is combination by factors"); - factorConvertStrategy.ReferenceDictionary = ReferenceDictionary; - factorConvertStrategy.TraceLogger = TraceLogger; - ForceFactoredList newItem = factorConvertStrategy.Convert(source); - return newItem; - } - - - private IForceAction GetForceList(ForceCombinationListDTO forceList) - { - TraceLogger?.AddMessage("Force action is combination by list"); - listConvertStrategy.ReferenceDictionary = ReferenceDictionary; - listConvertStrategy.TraceLogger = TraceLogger; - ForceCombinationList newItem = listConvertStrategy.Convert(forceList); - return newItem; - } - } -} diff --git a/DataAccess/DTOs/Converters/ForceCalculatorFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCalculatorFromDTOConvertStrategy.cs index 39f113c..a4f37fd 100644 --- a/DataAccess/DTOs/Converters/ForceCalculatorFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceCalculatorFromDTOConvertStrategy.cs @@ -1,25 +1,37 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperLogics.NdmCalculations.Analyses.ByForces; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace DataAccess.DTOs { public class ForceCalculatorFromDTOConvertStrategy : ConvertStrategy { - - private IConvertStrategy inputDataConvertStrategy = new ForceCalculatorInputDataFromDTOConvertStrategy(); + + private IConvertStrategy inputDataConvertStrategy; public override ForceCalculator GetNewItem(ForceCalculatorDTO source) + { + InitializeStrategies(); + try + { + GetNewItemBySource(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void InitializeStrategies() + { + inputDataConvertStrategy ??= new ForceCalculatorInputDataFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + } + + private void GetNewItemBySource(ForceCalculatorDTO source) { NewItem = new(source.Id); NewItem.Name = source.Name; - inputDataConvertStrategy.ReferenceDictionary = ReferenceDictionary; - inputDataConvertStrategy.TraceLogger = TraceLogger; NewItem.InputData = inputDataConvertStrategy.Convert(source.InputData as ForceCalculatorInputDataDTO); - return NewItem; } } } diff --git a/DataAccess/DTOs/Converters/ForceCalculatorInputDataFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCalculatorInputDataFromDTOConvertStrategy.cs index f786db4..a88cd49 100644 --- a/DataAccess/DTOs/Converters/ForceCalculatorInputDataFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceCalculatorInputDataFromDTOConvertStrategy.cs @@ -1,28 +1,40 @@ using DataAccess.DTOs.Converters; using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; using StructureHelperLogics.NdmCalculations.Analyses.ByForces; using StructureHelperLogics.NdmCalculations.Primitives; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace DataAccess.DTOs { public class ForceCalculatorInputDataFromDTOConvertStrategy : ConvertStrategy { - private IUpdateStrategy updateStrategy = new ForceCalculatorInputDataUpdateStrategy(); - private IHasPrimitivesProcessLogic primitivesProcessLogic = new HasPrimitivesProcessLogic(); - private IHasForceActionsProcessLogic actionsProcessLogic = new HasForceActionsProcessLogic(); + private IUpdateStrategy updateStrategy; + private IHasPrimitivesProcessLogic primitivesProcessLogic; + private IHasForceActionsProcessLogic actionsProcessLogic; + private IConvertStrategy accuracyConvertStrategy; public override ForceCalculatorInputData GetNewItem(ForceCalculatorInputDataDTO source) + { + InitializeStrategies(); + try + { + GetNewItemBySource(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewItemBySource(ForceCalculatorInputDataDTO source) { NewItem = new(source.Id); updateStrategy.Update(NewItem, source); + NewItem.Accuracy = accuracyConvertStrategy.Convert((AccuracyDTO)source.Accuracy); ProcessPrimitives(source); ProcessActions(source); - return NewItem; } private void ProcessPrimitives(IHasPrimitives source) @@ -33,7 +45,6 @@ namespace DataAccess.DTOs primitivesProcessLogic.TraceLogger = TraceLogger; primitivesProcessLogic.Process(); } - private void ProcessActions(IHasForceActions source) { actionsProcessLogic.Source = source; @@ -42,5 +53,12 @@ namespace DataAccess.DTOs actionsProcessLogic.TraceLogger = TraceLogger; actionsProcessLogic.Process(); } + private void InitializeStrategies() + { + updateStrategy ??= new ForceCalculatorInputDataUpdateStrategy(); + primitivesProcessLogic ??= new HasPrimitivesProcessLogic(ConvertDirection.FromDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + actionsProcessLogic ??= new HasForceActionsProcessLogic(ConvertDirection.FromDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + accuracyConvertStrategy ??= new AccuracyFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + } } } diff --git a/DataAccess/DTOs/Converters/ForceCalculatorInputDataToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCalculatorInputDataToDTOConvertStrategy.cs new file mode 100644 index 0000000..cd46309 --- /dev/null +++ b/DataAccess/DTOs/Converters/ForceCalculatorInputDataToDTOConvertStrategy.cs @@ -0,0 +1,69 @@ +using DataAccess.DTOs.Converters; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class ForceCalculatorInputDataToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IHasPrimitivesProcessLogic primitivesProcessLogic; + private IHasForceActionsProcessLogic actionsProcessLogic; + private IConvertStrategy accuracyConvertStrategy; + + public override ForceCalculatorInputDataDTO GetNewItem(IForceCalculatorInputData source) + { + InitializeStrategies(); + try + { + GetNewItemBySource(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewItemBySource(IForceCalculatorInputData source) + { + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + NewItem.Accuracy = accuracyConvertStrategy.Convert(source.Accuracy); + ProcessPrimitives(source); + ProcessActions(source); + } + + private void ProcessPrimitives(IHasPrimitives source) + { + primitivesProcessLogic.Source = source; + primitivesProcessLogic.Target = NewItem; + primitivesProcessLogic.ReferenceDictionary = ReferenceDictionary; + primitivesProcessLogic.TraceLogger = TraceLogger; + primitivesProcessLogic.Process(); + } + private void ProcessActions(IHasForceActions source) + { + actionsProcessLogic.Source = source; + actionsProcessLogic.Target = NewItem; + actionsProcessLogic.ReferenceDictionary = ReferenceDictionary; + actionsProcessLogic.TraceLogger = TraceLogger; + actionsProcessLogic.Process(); + } + private void InitializeStrategies() + { + updateStrategy ??= new ForceCalculatorInputDataUpdateStrategy(); + primitivesProcessLogic ??= new HasPrimitivesProcessLogic(ConvertDirection.ToDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + actionsProcessLogic ??= new HasForceActionsProcessLogic(ConvertDirection.ToDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + accuracyConvertStrategy ??= new AccuracyToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + } + } +} diff --git a/DataAccess/DTOs/Converters/ForceCalculatorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCalculatorToDTOConvertStrategy.cs index 777d653..4c4430f 100644 --- a/DataAccess/DTOs/Converters/ForceCalculatorToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceCalculatorToDTOConvertStrategy.cs @@ -14,73 +14,37 @@ using System.Threading.Tasks; namespace DataAccess.DTOs { - public class ForceCalculatorToDTOConvertStrategy : IConvertStrategy + public class ForceCalculatorToDTOConvertStrategy : ConvertStrategy { - private readonly IUpdateStrategy updateStrategy; + private IUpdateStrategy updateStrategy; + private IConvertStrategy inputDataConvertStrategy; - public ForceCalculatorToDTOConvertStrategy(IUpdateStrategy updateStrategy) - { - this.updateStrategy = updateStrategy; - } - - public ForceCalculatorToDTOConvertStrategy() : this ( - new ForceCalculatorUpdateStrategy() - ) - { - - } - - public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } - public IShiftTraceLogger TraceLogger { get; set; } - - public ForceCalculatorDTO Convert(IForceCalculator source) + public override ForceCalculatorDTO GetNewItem(IForceCalculator source) { + InitializeStrategies(); try { - Check(); - return GetNewItem(source); + GetNewItemBySource(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 ForceCalculatorDTO GetNewItem(IForceCalculator source) + private void InitializeStrategies() { - ForceCalculatorDTO newItem = new() { Id = source.Id}; - updateStrategy.Update(newItem, source); - ProcessForceActions(newItem.InputData, source.InputData); - ProcessPrimitives(newItem.InputData, source.InputData); - return newItem; + updateStrategy ??= new ForceCalculatorUpdateStrategy(); + inputDataConvertStrategy ??= new ForceCalculatorInputDataToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; } - private void ProcessPrimitives(IHasPrimitives target, IHasPrimitives source) + private void GetNewItemBySource(IForceCalculator source) { - HasPrimitivesToDTOUpdateStrategy updateStrategy = new() - { - ReferenceDictionary = ReferenceDictionary, - TraceLogger = TraceLogger - }; - updateStrategy.Update(target, source); - } - - private void ProcessForceActions(IHasForceActions target, IHasForceActions source) - { - HasForceActionToDTOUpdateStrategy updateStrategy = new() - { - ReferenceDictionary = ReferenceDictionary, - TraceLogger = TraceLogger - }; - updateStrategy.Update(target, source); - } - - private void Check() - { - var checkLogic = new CheckConvertLogic(this); - checkLogic.Check(); + NewItem = new() { Id = source.Id}; + updateStrategy.Update(NewItem, source); + NewItem.InputData = inputDataConvertStrategy.Convert(source.InputData); } } } diff --git a/DataAccess/DTOs/Converters/ForceCombinaionFromFileToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCombinaionFromFileToDTOConvertStrategy.cs new file mode 100644 index 0000000..423f73e --- /dev/null +++ b/DataAccess/DTOs/Converters/ForceCombinaionFromFileToDTOConvertStrategy.cs @@ -0,0 +1,76 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Models.Shapes; + +namespace DataAccess.DTOs +{ + public class ForceCombinaionFromFileToDTOConvertStrategy : ConvertStrategy + { + + private IUpdateStrategy updateStrategy; + private IConvertStrategy pointConvertStrategy; + private IConvertStrategy combinationPropertyConvertStrategy; + private IConvertStrategy filePropertyConvertStrategy; + + + + public override ForceCombinationFromFileDTO GetNewItem(IForceCombinationFromFile source) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger.AddMessage($"Force combination from file, name = {source.Name} converting has been started"); + InitializeStrategies(); + ForceCombinationFromFileDTO newItem = new(source.Id); + updateStrategy.Update(newItem, source); + newItem.ForceFiles.Clear(); + foreach (var item in source.ForceFiles) + { + ColumnedFilePropertyDTO columnedFilePropertyDTO = filePropertyConvertStrategy.Convert(item); + newItem.ForceFiles.Add(columnedFilePropertyDTO); + } + SetPoint(source, newItem); + SetCombinationProperty(source, newItem); + TraceLogger.AddMessage($"Force combination from file, name = {source.Name} converting has been finished successfully"); + return newItem; + } + + private void InitializeStrategies() + { + updateStrategy ??= new ForceCombinationFromFileUpdateStrategy(); + pointConvertStrategy ??= new Point2DToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + combinationPropertyConvertStrategy ??= new FactoredCombinationPropertyToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + filePropertyConvertStrategy ??= new ColumnedFilePropertyToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + } + + private void SetPoint(IForceCombinationFromFile source, ForceCombinationFromFileDTO newItem) + { + if (source.ForcePoint is not null) + { + var convertLogic = new DictionaryConvertStrategy(this, pointConvertStrategy); + newItem.ForcePoint = convertLogic.Convert(source.ForcePoint); + } + else + { + string errorMessage = ErrorStrings.NullReference + $"File combination {source.Name} Id={source.Id} does not have force point"; + TraceLogger.AddMessage(errorMessage, TraceLogStatuses.Error); + throw new StructureHelperException(errorMessage); + } + } + private void SetCombinationProperty(IForceCombinationFromFile source, ForceCombinationFromFileDTO newItem) + { + if (source.CombinationProperty is not null) + { + var convertLogic = new DictionaryConvertStrategy(this, combinationPropertyConvertStrategy); + newItem.CombinationProperty = convertLogic.Convert(source.CombinationProperty); + } + else + { + string errorMessage = ErrorStrings.NullReference + $"Factored combination {source.Name} Id={source.Id} does not have combination properties"; + TraceLogger.AddMessage(errorMessage, TraceLogStatuses.Error); + throw new StructureHelperException(errorMessage); + } + } + } +} diff --git a/DataAccess/DTOs/Converters/ForceCombinationByFactorFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCombinationByFactorFromDTOConvertStrategy.cs deleted file mode 100644 index 73a56fc..0000000 --- a/DataAccess/DTOs/Converters/ForceCombinationByFactorFromDTOConvertStrategy.cs +++ /dev/null @@ -1,60 +0,0 @@ -using StructureHelperCommon.Infrastructures.Interfaces; -using StructureHelperCommon.Models; -using StructureHelperCommon.Models.Forces; -using StructureHelperCommon.Models.Forces.Logics; -using StructureHelperCommon.Models.Shapes; -using StructureHelperCommon.Services; - -namespace DataAccess.DTOs -{ - public class ForceCombinationByFactorFromDTOConvertStrategy : ConvertStrategy - { - private IUpdateStrategy baseUpdateStrategy; - private IUpdateStrategy updateStrategy; - private IConvertStrategy pointConvertStrategy; - private IConvertStrategy forceTupleConvertStrategy; - - public ForceCombinationByFactorFromDTOConvertStrategy( - IUpdateStrategy baseUpdateStrategy, - IUpdateStrategy updateStrategy, - IConvertStrategy pointConvertStrategy, - IConvertStrategy forceTupleConvertStrategy) - { - this.baseUpdateStrategy = baseUpdateStrategy; - this.updateStrategy = updateStrategy; - this.pointConvertStrategy = pointConvertStrategy; - this.forceTupleConvertStrategy = forceTupleConvertStrategy; - } - - public ForceCombinationByFactorFromDTOConvertStrategy() : this( - new ForceActionBaseUpdateStrategy(), - new ForceFactoredListUpdateStrategy(), - new Point2DFromDTOConvertStrategy(), - new ForceTupleFromDTOConvertStrategy()) - { - - } - - public override ForceFactoredList GetNewItem(ForceCombinationByFactorDTO source) - { - TraceLogger.AddMessage($"Force combination by factor name = {source.Name} is starting"); - ForceFactoredList newItem = new(source.Id); - baseUpdateStrategy.Update(newItem, source); - updateStrategy.Update(newItem, source); - pointConvertStrategy.ReferenceDictionary = ReferenceDictionary; - pointConvertStrategy.TraceLogger = TraceLogger; - newItem.ForcePoint = pointConvertStrategy.Convert((Point2DDTO)source.ForcePoint); - forceTupleConvertStrategy.ReferenceDictionary = ReferenceDictionary; - forceTupleConvertStrategy.TraceLogger = TraceLogger; - CheckObject.IsNull(newItem.ForceTuples, nameof(newItem.ForceTuples)); - newItem.ForceTuples.Clear(); - foreach (var item in source.ForceTuples) - { - var newTuple = forceTupleConvertStrategy.Convert((ForceTupleDTO)item); - newItem.ForceTuples.Add(newTuple); - } - TraceLogger.AddMessage($"Force combination by factor name = {newItem.Name} has been finished"); - return newItem; - } - } -} diff --git a/DataAccess/DTOs/Converters/ForceCombinationByFactorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCombinationByFactorToDTOConvertStrategy.cs deleted file mode 100644 index f3c8c04..0000000 --- a/DataAccess/DTOs/Converters/ForceCombinationByFactorToDTOConvertStrategy.cs +++ /dev/null @@ -1,107 +0,0 @@ -using StructureHelperCommon.Infrastructures.Interfaces; -using StructureHelperCommon.Models; -using StructureHelperCommon.Models.Forces; -using StructureHelperCommon.Models.Forces.Logics; -using StructureHelperCommon.Models.Loggers; -using StructureHelperCommon.Models.Shapes; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace DataAccess.DTOs.Converters -{ - public class ForceCombinationByFactorToDTOConvertStrategy : IConvertStrategy - { - private IUpdateStrategy updateStrategy; - private IConvertStrategy pointUpdateStrategy; - - private IConvertStrategy forceTupleConvertStrategy; - private IUpdateStrategy baseUpdateStrategy; - - public ForceCombinationByFactorToDTOConvertStrategy(IUpdateStrategy updateStrategy, - IConvertStrategy pointUpdateStrategy, - IConvertStrategy convertStrategy, - IUpdateStrategy baseUpdateStrategy) - { - this.baseUpdateStrategy = baseUpdateStrategy; - this.updateStrategy = updateStrategy; - this.forceTupleConvertStrategy = convertStrategy; - this.pointUpdateStrategy = pointUpdateStrategy; - } - - public ForceCombinationByFactorToDTOConvertStrategy() : this ( - new ForceFactoredListUpdateStrategy(), - new Point2DToDTOConvertStrategy(), - new ForceTupleToDTOConvertStrategy(), - new ForceActionBaseUpdateStrategy()) - { - - } - - public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } - public IShiftTraceLogger TraceLogger { get; set; } - - public ForceCombinationByFactorDTO Convert(IForceFactoredList source) - { - Check(); - try - { - ForceCombinationByFactorDTO newItem = GetNewForceTuple(source); - TraceLogger.AddMessage($"Force combination by factor, name = {newItem.Name} was converted", TraceLogStatuses.Debug); - return newItem; - } - catch (Exception ex) - { - TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); - TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); - throw; - } - - } - - private ForceCombinationByFactorDTO GetNewForceTuple(IForceFactoredList source) - { - ForceCombinationByFactorDTO newItem = new() { Id = source.Id }; - baseUpdateStrategy.Update(newItem, source); - updateStrategy.Update(newItem, source); - GetNewForcePoint(source, newItem); - GetNewFullSLSForces(source, newItem); - return newItem; - } - - private void GetNewFullSLSForces(IForceFactoredList source, ForceCombinationByFactorDTO newItem) - { - if (source.ForceTuples[0] is not null) - { - forceTupleConvertStrategy.ReferenceDictionary = ReferenceDictionary; - forceTupleConvertStrategy.TraceLogger = TraceLogger; - var convertForceTupleLogic = new DictionaryConvertStrategy(this, forceTupleConvertStrategy); - newItem.ForceTuples.Clear(); - foreach (var item in source.ForceTuples) - { - var forceTuple = convertForceTupleLogic.Convert(item); - newItem.ForceTuples.Add(forceTuple); - } - } - } - - private void GetNewForcePoint(IForceFactoredList source, ForceCombinationByFactorDTO newItem) - { - if (source.ForcePoint is not null) - { - pointUpdateStrategy.ReferenceDictionary = ReferenceDictionary; - pointUpdateStrategy.TraceLogger = TraceLogger; - var convertLogic = new DictionaryConvertStrategy(this, pointUpdateStrategy); - newItem.ForcePoint = convertLogic.Convert(source.ForcePoint); - } - } - - private void Check() - { - var checkLogic = new CheckConvertLogic(this); - checkLogic.Check(); - } - } -} diff --git a/DataAccess/DTOs/Converters/ForceCombinationFromFileFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCombinationFromFileFromDTOConvertStrategy.cs new file mode 100644 index 0000000..6b14ee2 --- /dev/null +++ b/DataAccess/DTOs/Converters/ForceCombinationFromFileFromDTOConvertStrategy.cs @@ -0,0 +1,112 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Models.Shapes; + +namespace DataAccess.DTOs +{ + public class ForceCombinationFromFileFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy pointConvertStrategy; + private IConvertStrategy combinationPropertyConvertStrategy; + private IConvertStrategy fileConvertStrategy; + + public ForceCombinationFromFileFromDTOConvertStrategy( + IUpdateStrategy updateStrategy, + IConvertStrategy pointConvertStrategy, + IConvertStrategy combinationPropertyConvertStrategy, + IConvertStrategy fileConvertStrategy) + { + this.updateStrategy = updateStrategy; + this.pointConvertStrategy = pointConvertStrategy; + this.combinationPropertyConvertStrategy = combinationPropertyConvertStrategy; + this.fileConvertStrategy = fileConvertStrategy; + } + + public ForceCombinationFromFileFromDTOConvertStrategy() { } + + public override ForceCombinationFromFile GetNewItem(ForceCombinationFromFileDTO source) + { + TraceLogger?.AddMessage($"Force combination from file Name = {source.Name} converting has been started"); + InitializeStrategies(); + try + { + ForceCombinationFromFile newItem = GetForceCombination(source); + TraceLogger?.AddMessage($"Force combination from file Name = {newItem.Name} converting has been finished successfully"); + return newItem; + } + catch (Exception ex) + { + TraceLogger?.AddMessage($"Logic: {LoggerStrings.LogicType(this)} made error: {ex.Message}", TraceLogStatuses.Error); + throw; + } + } + + private ForceCombinationFromFile GetForceCombination(ForceCombinationFromFileDTO source) + { + ForceCombinationFromFile newItem = new(source.Id); + updateStrategy.Update(newItem, source); + SetForceFiles(source, newItem); + SetPoint(source, newItem); + SetCombinationProperty(source, newItem); + return newItem; + } + + private void SetForceFiles(ForceCombinationFromFileDTO source, ForceCombinationFromFile newItem) + { + newItem.ForceFiles.Clear(); + foreach (var item in source.ForceFiles) + { + if (item is ColumnedFilePropertyDTO filePropertyDTO) + { + ColumnedFileProperty columnFileProperty = fileConvertStrategy.Convert(filePropertyDTO); + newItem.ForceFiles.Add(columnFileProperty); + } + else + { + string errorString = ErrorStrings.ExpectedWas(typeof(ColumnFilePropertyDTO), item); + TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); + throw new StructureHelperException(errorString); + } + } + } + + private void SetPoint(IForceAction source, IForceAction newItem) + { + if (source.ForcePoint is Point2DDTO pointDTO) + { + newItem.ForcePoint = pointConvertStrategy.Convert(pointDTO); + } + else + { + string errorMessage = ErrorStrings.ExpectedWas(typeof(Point2DDTO), source.ForcePoint); + TraceLogger.AddMessage(errorMessage, TraceLogStatuses.Error); + throw new StructureHelperException(errorMessage); + } + } + private void SetCombinationProperty(IForceFactoredCombination source, IForceFactoredCombination newItem) + { + if (source.CombinationProperty is FactoredCombinationPropertyDTO factoredPropertyDTO) + { + newItem.CombinationProperty = combinationPropertyConvertStrategy.Convert(factoredPropertyDTO); + } + else + { + string errorMessage = ErrorStrings.ExpectedWas(typeof(FactoredCombinationPropertyDTO), source.CombinationProperty); + TraceLogger.AddMessage(errorMessage, TraceLogStatuses.Error); + throw new StructureHelperException(errorMessage); + } + } + + private void InitializeStrategies() + { + updateStrategy ??= new ForceCombinationFromFileUpdateStrategy(); + pointConvertStrategy = new Point2DFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + combinationPropertyConvertStrategy = new FactoredCombinationPropertyFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + fileConvertStrategy ??= new ColumnedFilePropertyFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + } + } +} diff --git a/DataAccess/DTOs/Converters/ForceCombinationListFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCombinationListFromDTOConvertStrategy.cs index 552720b..56dd934 100644 --- a/DataAccess/DTOs/Converters/ForceCombinationListFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceCombinationListFromDTOConvertStrategy.cs @@ -1,6 +1,8 @@ using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Forces.Logics; +using StructureHelperCommon.Models.Loggers; using StructureHelperCommon.Models.Shapes; using System; using System.Collections.Generic; @@ -29,26 +31,31 @@ namespace DataAccess.DTOs this.designTupleConvertStrategy = designTupleConvertStrategy; } - public ForceCombinationListFromDTOConvertStrategy() : this( - new ForceActionBaseUpdateStrategy(), - new ForceCombinationListUpdateStrategy(), - new Point2DFromDTOConvertStrategy(), - new DesignForceTupleFromDTOConvertStrategy()) - { - - } + public ForceCombinationListFromDTOConvertStrategy() { } public override ForceCombinationList GetNewItem(ForceCombinationListDTO source) { - TraceLogger?.AddMessage($"Force combination list name = {source.Name} is starting"); + TraceLogger?.AddMessage($"Force combination list Id = {source.Id}, Name = {source.Name} converting has been started"); + InitializeStrategies(); + try + { + ForceCombinationList newItem = GetNewItemBySource(source); + TraceLogger?.AddMessage($"Force combination list Id = {source.Id}, Name = {source.Name} has been finished successfully"); + return newItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private ForceCombinationList GetNewItemBySource(ForceCombinationListDTO source) + { ForceCombinationList newItem = new(source.Id); baseUpdateStrategy.Update(newItem, source); //updateStrategy.Update(newItem, source); - pointConvertStrategy.ReferenceDictionary = ReferenceDictionary; - pointConvertStrategy.TraceLogger = TraceLogger; newItem.ForcePoint = pointConvertStrategy.Convert((Point2DDTO)source.ForcePoint); - designTupleConvertStrategy.ReferenceDictionary = ReferenceDictionary; - designTupleConvertStrategy.TraceLogger = TraceLogger; newItem.DesignForces.Clear(); foreach (var item in source.DesignForces) { @@ -57,8 +64,16 @@ namespace DataAccess.DTOs TraceLogger?.AddMessage($"Mx = {newDesignTuple.ForceTuple.Mx}, My = {newDesignTuple.ForceTuple.My}, Nz = {newDesignTuple.ForceTuple.Nz}"); newItem.DesignForces.Add(newDesignTuple); } - TraceLogger?.AddMessage($"Force combination list name = {newItem.Name} has been finished successfully"); + return newItem; } + + private void InitializeStrategies() + { + baseUpdateStrategy ??= new ForceActionBaseUpdateStrategy(); + updateStrategy ??= new ForceCombinationListUpdateStrategy(); + pointConvertStrategy ??= new Point2DFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + designTupleConvertStrategy ??= new DesignForceTupleFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + } } } diff --git a/DataAccess/DTOs/Converters/ForceCombinationListToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCombinationListToDTOConvertStrategy.cs index abff0c9..be121d4 100644 --- a/DataAccess/DTOs/Converters/ForceCombinationListToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceCombinationListToDTOConvertStrategy.cs @@ -1,19 +1,12 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; -using StructureHelperCommon.Models.Forces.Logics; using StructureHelperCommon.Models.Loggers; using StructureHelperCommon.Models.Shapes; -using StructureHelperLogics.Models.CrossSections; -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 ForceCombinationListToDTOConvertStrategy : IConvertStrategy + public class ForceCombinationListToDTOConvertStrategy : ConvertStrategy { private IUpdateStrategy updateStrategy; private IConvertStrategy convertStrategy; @@ -32,37 +25,20 @@ namespace DataAccess.DTOs.Converters this.pointUpdateStrategy = pointUpdateStrategy; } - public ForceCombinationListToDTOConvertStrategy() : this ( - new ForceCombinationListUpdateStrategy(), - new DesignForceTupleToDTOConvertStrategy(), - new ForceActionBaseUpdateStrategy(), - new Point2DToDTOConvertStrategy()) + public ForceCombinationListToDTOConvertStrategy() { } + + public override ForceCombinationListDTO GetNewItem(IForceCombinationList source) { - - } - - - public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } - public IShiftTraceLogger TraceLogger { get; set; } - - public ForceCombinationListDTO Convert(IForceCombinationList source) - { - try - { - Check(); - return GetNewForceCombinationList(source); - } - catch (Exception ex) - { - TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); - TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); - throw; - } + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger?.AddMessage($"Factored combination list Name: {source.Name} has been started"); + ForceCombinationListDTO forceCombinationListDTO = GetNewForceCombinationList(source); + TraceLogger?.AddMessage($"Factored combination list Name: {source.Name} has been finished"); + return forceCombinationListDTO; } private ForceCombinationListDTO GetNewForceCombinationList(IForceCombinationList source) { - + InitializeStrategies(); ForceCombinationListDTO newItem = new() { Id = source.Id}; baseUpdateStrategy.Update(newItem, source); updateStrategy.Update(newItem, source); @@ -78,6 +54,14 @@ namespace DataAccess.DTOs.Converters return newItem; } + private void InitializeStrategies() + { + updateStrategy ??= new ForceCombinationListUpdateStrategy(); + convertStrategy ??= new DesignForceTupleToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + baseUpdateStrategy ??= new ForceActionBaseUpdateStrategy(); + pointUpdateStrategy ??= new Point2DToDTOConvertStrategy(); + } + private void GetNewForcePoint(ForceCombinationListDTO newItem, IForceCombinationList source) { if (source.ForcePoint is not null) diff --git a/DataAccess/DTOs/Converters/ForceFactoredListFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceFactoredListFromDTOConvertStrategy.cs new file mode 100644 index 0000000..0cf9c0f --- /dev/null +++ b/DataAccess/DTOs/Converters/ForceFactoredListFromDTOConvertStrategy.cs @@ -0,0 +1,93 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Shapes; +using StructureHelperCommon.Services; + +namespace DataAccess.DTOs +{ + public class ForceFactoredListFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy baseUpdateStrategy; + private IUpdateStrategy updateStrategy; + private IConvertStrategy pointConvertStrategy; + private IConvertStrategy forceTupleConvertStrategy; + private IConvertStrategy combinationPropertyConvertStrategy; + + public ForceFactoredListFromDTOConvertStrategy( + IUpdateStrategy baseUpdateStrategy, + IUpdateStrategy updateStrategy, + IConvertStrategy pointConvertStrategy, + IConvertStrategy forceTupleConvertStrategy, + IConvertStrategy combinationPropertyConvertStrategy) + { + this.baseUpdateStrategy = baseUpdateStrategy; + this.updateStrategy = updateStrategy; + this.pointConvertStrategy = pointConvertStrategy; + this.forceTupleConvertStrategy = forceTupleConvertStrategy; + this.combinationPropertyConvertStrategy = combinationPropertyConvertStrategy; + } + + public ForceFactoredListFromDTOConvertStrategy() { } + + public override ForceFactoredList GetNewItem(ForceFactoredListDTO source) + { + InitializeStrategies(); + TraceLogger.AddMessage($"Force combination by factor name = {source.Name} converting is starting"); + ForceFactoredList newItem = new(source.Id); + baseUpdateStrategy.Update(newItem, source); + updateStrategy.Update(newItem, source); + SetPoint(source, newItem); + SetCombinationProperty(source, newItem); + SetForceTuples(source, newItem); + TraceLogger.AddMessage($"Force combination by factor name = {newItem.Name} converting has been finished"); + return newItem; + } + + private void SetForceTuples(ForceFactoredListDTO source, ForceFactoredList newItem) + { + CheckObject.IsNull(newItem.ForceTuples, nameof(newItem.ForceTuples)); + newItem.ForceTuples.Clear(); + foreach (var item in source.ForceTuples) + { + var newTuple = forceTupleConvertStrategy.Convert((ForceTupleDTO)item); + newItem.ForceTuples.Add(newTuple); + } + } + private void SetPoint(ForceFactoredListDTO source, ForceFactoredList newItem) + { + if (source.ForcePoint is Point2DDTO pointDTO) + { + newItem.ForcePoint = pointConvertStrategy.Convert(pointDTO); + } + else + { + string errorMessage = ErrorStrings.ExpectedWas(typeof(Point2DDTO), source.ForcePoint); + TraceLogger.AddMessage(errorMessage, TraceLogStatuses.Error); + throw new StructureHelperException(errorMessage); + } + } + private void SetCombinationProperty(ForceFactoredListDTO source, ForceFactoredList newItem) + { + if (source.CombinationProperty is FactoredCombinationPropertyDTO factoredPropertyDTO) + { + newItem.CombinationProperty = combinationPropertyConvertStrategy.Convert(factoredPropertyDTO); + } + else + { + string errorMessage = ErrorStrings.ExpectedWas(typeof(FactoredCombinationPropertyDTO), source.CombinationProperty); + TraceLogger.AddMessage(errorMessage, TraceLogStatuses.Error); + throw new StructureHelperException(errorMessage); + } + } + private void InitializeStrategies() + { + baseUpdateStrategy ??= new ForceActionBaseUpdateStrategy(); + updateStrategy ??= new ForceFactoredListUpdateStrategy(); + pointConvertStrategy ??= new Point2DFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + forceTupleConvertStrategy ??= new ForceTupleFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + combinationPropertyConvertStrategy ??= new FactoredCombinationPropertyFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + } + } +} diff --git a/DataAccess/DTOs/Converters/ForceFactoredListToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceFactoredListToDTOConvertStrategy.cs new file mode 100644 index 0000000..d5b7ab5 --- /dev/null +++ b/DataAccess/DTOs/Converters/ForceFactoredListToDTOConvertStrategy.cs @@ -0,0 +1,109 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Models.Shapes; + +namespace DataAccess.DTOs +{ + public class ForceFactoredListToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy pointConvertStrategy; + private IConvertStrategy forceTupleConvertStrategy; + private IUpdateStrategy baseUpdateStrategy; + private IConvertStrategy combinationPropertyConvertStrategy; + + public ForceFactoredListToDTOConvertStrategy(IUpdateStrategy updateStrategy, + IConvertStrategy pointConvertStrategy, + IConvertStrategy forceTupleConvertStrategy, + IUpdateStrategy baseUpdateStrategy) + { + this.updateStrategy = updateStrategy; + this.pointConvertStrategy = pointConvertStrategy; + this.forceTupleConvertStrategy = forceTupleConvertStrategy; + this.baseUpdateStrategy = baseUpdateStrategy; + } + + public ForceFactoredListToDTOConvertStrategy() { } + + public override ForceFactoredListDTO GetNewItem(IForceFactoredList source) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger?.AddMessage($"Force combination by factor, name = {source.Name} converting has been started"); + InitializeStrategies(); + ForceFactoredListDTO newItem = GetNewForceTuple(source); + TraceLogger?.AddMessage($"Force combination by factor, name = {newItem.Name} converting has been finished successfully"); + return newItem; + + } + private void InitializeStrategies() + { + baseUpdateStrategy ??= new ForceActionBaseUpdateStrategy(); + updateStrategy ??= new ForceFactoredListUpdateStrategy(); + forceTupleConvertStrategy ??= new ForceTupleToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + pointConvertStrategy ??= new Point2DToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + combinationPropertyConvertStrategy ??= new FactoredCombinationPropertyToDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + } + + private ForceFactoredListDTO GetNewForceTuple(IForceFactoredList source) + { + ForceFactoredListDTO newItem = new(source.Id); + baseUpdateStrategy.Update(newItem, source); + updateStrategy.Update(newItem, source); + SetPoint(source, newItem); + SetForces(source, newItem); + SetCombinationProperty(source, newItem); + return newItem; + } + private void SetForces(IForceFactoredList source, ForceFactoredListDTO newItem) + { + if (source.ForceTuples is not null) + { + var convertForceTupleLogic = new DictionaryConvertStrategy(this, forceTupleConvertStrategy); + newItem.ForceTuples.Clear(); + foreach (var item in source.ForceTuples) + { + var forceTuple = convertForceTupleLogic.Convert(item); + newItem.ForceTuples.Add(forceTuple); + } + } + else + { + string errorMessage = ErrorStrings.NullReference + $"Factored combination {source.Name} Id={source.Id} does not have list of forces"; + TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error); + throw new StructureHelperException(errorMessage); + } + } + private void SetPoint(IForceFactoredList source, ForceFactoredListDTO newItem) + { + if (source.ForcePoint is not null) + { + var convertLogic = new DictionaryConvertStrategy(this, pointConvertStrategy); + newItem.ForcePoint = convertLogic.Convert(source.ForcePoint); + } + else + { + string errorMessage = ErrorStrings.NullReference + $"Factored combination {source.Name} Id={source.Id} does not have force point"; + TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error); + throw new StructureHelperException(errorMessage); + } + } + private void SetCombinationProperty(IForceFactoredList source, ForceFactoredListDTO newItem) + { + if (source.CombinationProperty is not null) + { + var convertLogic = new DictionaryConvertStrategy(this, combinationPropertyConvertStrategy); + newItem.CombinationProperty = convertLogic.Convert(source.CombinationProperty); + } + else + { + string errorMessage = ErrorStrings.NullReference + $"Factored combination {source.Name} Id={source.Id} does not have combination properties"; + TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error); + throw new StructureHelperException(errorMessage); + } + } + + } +} diff --git a/DataAccess/DTOs/Converters/ForceTupleToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceTupleToDTOConvertStrategy.cs index c0ceaac..ef49142 100644 --- a/DataAccess/DTOs/Converters/ForceTupleToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceTupleToDTOConvertStrategy.cs @@ -14,9 +14,6 @@ namespace DataAccess.DTOs { private IUpdateStrategy updateStrategy; - public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } - public IShiftTraceLogger TraceLogger { get; set; } - public ForceTupleToDTOConvertStrategy(IUpdateStrategy updateStrategy) { this.updateStrategy = updateStrategy; @@ -29,7 +26,7 @@ namespace DataAccess.DTOs public override ForceTupleDTO GetNewItem(IForceTuple source) { - ForceTupleDTO newItem = new() { Id = source.Id}; + ForceTupleDTO newItem = new(source.Id); updateStrategy.Update(newItem, source); return newItem; } diff --git a/DataAccess/DTOs/Converters/HasForceActionsProcessLogic.cs b/DataAccess/DTOs/Converters/HasForceActionsProcessLogic.cs index e3b72a7..e7e0592 100644 --- a/DataAccess/DTOs/Converters/HasForceActionsProcessLogic.cs +++ b/DataAccess/DTOs/Converters/HasForceActionsProcessLogic.cs @@ -6,6 +6,7 @@ using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; +using StructureHelperCommon.Infrastructures.Exceptions; namespace DataAccess.DTOs { @@ -13,6 +14,14 @@ namespace DataAccess.DTOs { private const string convertStarted = " converting is started"; private const string convertFinished = " converting has been finished successfully"; + private IConvertStrategy convertStrategy; + private DictionaryConvertStrategy convertLogic; + private ConvertDirection convertDirection; + + public HasForceActionsProcessLogic(ConvertDirection convertDirection) + { + this.convertDirection = convertDirection; + } public IShiftTraceLogger TraceLogger { get; set; } public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } @@ -22,20 +31,41 @@ namespace DataAccess.DTOs public void Process() { TraceLogger?.AddMessage("Actions" + convertStarted); - ForceActionsFromDTOConvertStrategy convertStrategy = new() + HasForceActionsFromDTOUpdateStrategy updateStrategy = GetUpdateStrategyFactory(); + updateStrategy.Update(Target, Source); + TraceLogger?.AddMessage("Actions" + convertFinished); + } + + private HasForceActionsFromDTOUpdateStrategy GetUpdateStrategyFactory() + { + if (convertDirection == ConvertDirection.FromDTO) { - ReferenceDictionary = ReferenceDictionary, - TraceLogger = TraceLogger - }; - DictionaryConvertStrategy convertLogic = new() + convertStrategy ??= new ForceActionFromDTOConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + } + else if (convertDirection == ConvertDirection.ToDTO) + { + convertStrategy ??= new ForceActionToDTOConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + } + else + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(convertDirection)); + } + convertLogic ??= new() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger, ConvertStrategy = convertStrategy }; HasForceActionsFromDTOUpdateStrategy updateStrategy = new(convertLogic); - updateStrategy.Update(Target, Source); - TraceLogger?.AddMessage("Actions" + convertFinished); + return updateStrategy; } } } diff --git a/DataAccess/DTOs/Converters/HasPrimitivesProcessLogic.cs b/DataAccess/DTOs/Converters/HasPrimitivesProcessLogic.cs index e411ef9..7a8f9d8 100644 --- a/DataAccess/DTOs/Converters/HasPrimitivesProcessLogic.cs +++ b/DataAccess/DTOs/Converters/HasPrimitivesProcessLogic.cs @@ -1,18 +1,20 @@ -using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperLogics.NdmCalculations.Primitives; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace DataAccess.DTOs.Converters { public class HasPrimitivesProcessLogic : IHasPrimitivesProcessLogic { - private const string convertStarted = " converting is started"; + private const string convertStarted = " converting has been started"; private const string convertFinished = " converting has been finished successfully"; + private ConvertDirection convertDirection; + + public HasPrimitivesProcessLogic(ConvertDirection convertDirection) + { + this.convertDirection = convertDirection; + } public IHasPrimitives Source { get; set; } public IHasPrimitives Target { get; set; } @@ -22,11 +24,40 @@ namespace DataAccess.DTOs.Converters public void Process() { TraceLogger?.AddMessage("Primitives" + convertStarted); - NdmPrimitiveFromDTOConvertStrategy convertStrategy = new() + IUpdateStrategy updateStrategy = GetUpdateStrategyFactory(); + updateStrategy.Update(Target, Source); + TraceLogger?.AddMessage($"Primitives {convertFinished}, totally {Target.Primitives.Count} have been obtained"); + } + + private IUpdateStrategy GetUpdateStrategyFactory() + { + if (convertDirection == ConvertDirection.FromDTO) { - ReferenceDictionary = ReferenceDictionary, - TraceLogger = TraceLogger - }; + NdmPrimitiveFromDTOConvertStrategy convertStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + return GetUpdateStrategy(convertStrategy); + } + else if (convertDirection == ConvertDirection.ToDTO) + { + NdmPrimitiveToDTOConvertStrategy convertStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + return GetUpdateStrategy(convertStrategy); + } + else + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(convertDirection)); + } + } + + private IUpdateStrategy GetUpdateStrategy(IConvertStrategy convertStrategy) + { + DictionaryConvertStrategy convertLogic = new() { ReferenceDictionary = ReferenceDictionary, @@ -34,8 +65,7 @@ namespace DataAccess.DTOs.Converters ConvertStrategy = convertStrategy }; HasPrimitivesFromDTOUpdateStrategy updateStrategy = new(convertLogic); - updateStrategy.Update(Target, Source); - TraceLogger?.AddMessage($"Primitives {convertFinished}, totally {Target.Primitives.Count} have been obtained"); + return updateStrategy; } } } diff --git a/DataAccess/DTOs/Converters/IHasForceActionsProcessLogic.cs b/DataAccess/DTOs/Converters/IHasForceActionsProcessLogic.cs index 8ecceed..bbff949 100644 --- a/DataAccess/DTOs/Converters/IHasForceActionsProcessLogic.cs +++ b/DataAccess/DTOs/Converters/IHasForceActionsProcessLogic.cs @@ -3,13 +3,15 @@ using StructureHelperCommon.Models; namespace DataAccess.DTOs { + /// + /// Logic for antities which have force actions + /// public interface IHasForceActionsProcessLogic { Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } IHasForceActions Source { get; set; } IHasForceActions Target { get; set; } IShiftTraceLogger TraceLogger { get; set; } - void Process(); } } \ No newline at end of file diff --git a/DataAccess/DTOs/Converters/NdmPrimitiveToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/NdmPrimitiveToDTOConvertStrategy.cs index 4225843..dd2b034 100644 --- a/DataAccess/DTOs/Converters/NdmPrimitiveToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/NdmPrimitiveToDTOConvertStrategy.cs @@ -1,10 +1,7 @@ -using DataAccess.DTOs.DTOEntities; -using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; -using StructureHelperCommon.Models.Forces; using StructureHelperLogics.NdmCalculations.Primitives; -using static System.Windows.Forms.VisualStyles.VisualStyleElement; namespace DataAccess.DTOs.Converters { diff --git a/DataAccess/DTOs/Converters/Point2DFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Point2DFromDTOConvertStrategy.cs index 36da054..0569170 100644 --- a/DataAccess/DTOs/Converters/Point2DFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/Point2DFromDTOConvertStrategy.cs @@ -1,4 +1,6 @@ using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Models; using StructureHelperCommon.Models.Shapes; using System; using System.Collections.Generic; @@ -24,10 +26,24 @@ namespace DataAccess.DTOs public override Point2D GetNewItem(Point2DDTO source) { - TraceLogger?.AddMessage("Point 2D converting is started"); + TraceLogger?.AddMessage("Point 2D converting has been started"); + try + { + Point2D newItem = GetNewItemBySource(source); + TraceLogger?.AddMessage("Point 2D converting has been finished"); + return newItem; + } + catch (Exception ex) + { + TraceLogger?.AddMessage($"Logic: {LoggerStrings.LogicType(this)} made error: {ex.Message}", TraceLogStatuses.Error); + throw; + } + } + + private Point2D GetNewItemBySource(Point2DDTO source) + { Point2D newItem = new(source.Id); updateStrategy.Update(newItem, source); - TraceLogger?.AddMessage("Point 2D converting has been finished"); return newItem; } } diff --git a/DataAccess/DTOs/Converters/Point2DToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Point2DToDTOConvertStrategy.cs index 4cfd87e..623eaa7 100644 --- a/DataAccess/DTOs/Converters/Point2DToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/Point2DToDTOConvertStrategy.cs @@ -8,7 +8,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -namespace DataAccess.DTOs.Converters +namespace DataAccess.DTOs { public class Point2DToDTOConvertStrategy : IConvertStrategy { diff --git a/DataAccess/DTOs/Converters/RebarNdmPrimitiveToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/RebarNdmPrimitiveToDTOConvertStrategy.cs index 87ded6d..01fb5b4 100644 --- a/DataAccess/DTOs/Converters/RebarNdmPrimitiveToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/RebarNdmPrimitiveToDTOConvertStrategy.cs @@ -1,15 +1,9 @@ using DataAccess.DTOs.Converters; -using DataAccess.DTOs.DTOEntities; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Loggers; using StructureHelperCommon.Models.Shapes; using StructureHelperLogics.NdmCalculations.Primitives; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace DataAccess.DTOs { diff --git a/DataAccess/DTOs/Converters/UserCrackInputDataFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/UserCrackInputDataFromDTOConvertStrategy.cs new file mode 100644 index 0000000..ca8bdec --- /dev/null +++ b/DataAccess/DTOs/Converters/UserCrackInputDataFromDTOConvertStrategy.cs @@ -0,0 +1,43 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperLogics.NdmCalculations.Cracking; + +namespace DataAccess.DTOs +{ + public class UserCrackInputDataFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + + public UserCrackInputDataFromDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) + { + ReferenceDictionary = referenceDictionary; + TraceLogger = traceLogger; + } + + public override UserCrackInputData GetNewItem(UserCrackInputDataDTO source) + { + InitializeStrategies(); + try + { + GetNewItemBySource(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewItemBySource(IUserCrackInputData source) + { + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + } + + private void InitializeStrategies() + { + updateStrategy ??= new UserCrackInputDataUpdateStrategy(); + } + } +} diff --git a/DataAccess/DTOs/Converters/UserCrackInputDataToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/UserCrackInputDataToDTOConvertStrategy.cs new file mode 100644 index 0000000..fb8d67d --- /dev/null +++ b/DataAccess/DTOs/Converters/UserCrackInputDataToDTOConvertStrategy.cs @@ -0,0 +1,48 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperLogics.NdmCalculations.Cracking; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class UserCrackInputDataToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + + public UserCrackInputDataToDTOConvertStrategy(Dictionary<(Guid id, Type type), ISaveable> referenceDictionary, IShiftTraceLogger traceLogger) + { + ReferenceDictionary = referenceDictionary; + TraceLogger = traceLogger; + } + + public override UserCrackInputDataDTO GetNewItem(IUserCrackInputData source) + { + InitializeStrategies(); + try + { + GetNewItemBySource(source); + return NewItem; + } + catch (Exception ex) + { + TraceErrorByEntity(this, ex.Message); + throw; + } + } + + private void GetNewItemBySource(IUserCrackInputData source) + { + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + } + + private void InitializeStrategies() + { + updateStrategy ??= new UserCrackInputDataUpdateStrategy(); + } + } +} diff --git a/DataAccess/DTOs/Converters/VisualAnalysisToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/VisualAnalysisToDTOConvertStrategy.cs index 83b6ebf..a350d3a 100644 --- a/DataAccess/DTOs/Converters/VisualAnalysisToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/VisualAnalysisToDTOConvertStrategy.cs @@ -17,11 +17,9 @@ using System.Threading.Tasks; namespace DataAccess.DTOs { - internal class VisualAnalysisToDTOConvertStrategy : IConvertStrategy + internal class VisualAnalysisToDTOConvertStrategy : ConvertStrategy { private IConvertStrategy convertStrategy; - public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } - public IShiftTraceLogger TraceLogger { get; set; } public VisualAnalysisToDTOConvertStrategy(IConvertStrategy convertStrategy) { @@ -33,20 +31,13 @@ namespace DataAccess.DTOs } - public VisualAnalysisDTO Convert(IVisualAnalysis source) + public override VisualAnalysisDTO GetNewItem(IVisualAnalysis source) { - Check(); - try - { - VisualAnalysisDTO visualAnalysisDTO = GetNewAnalysis(source); - return visualAnalysisDTO; - } - catch (Exception ex) - { - TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); - TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); - throw; - } + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger?.AddMessage($"Visual analysis Id = {source.Id} converting has been started"); + VisualAnalysisDTO visualAnalysisDTO = GetNewAnalysis(source); + TraceLogger?.AddMessage($"Visual analysis Id = {visualAnalysisDTO.Id} converting has been finished successfully"); + return visualAnalysisDTO; } private VisualAnalysisDTO GetNewAnalysis(IVisualAnalysis source) diff --git a/DataAccess/DTOs/DTOEntities/AccuracyDTO.cs b/DataAccess/DTOs/DTOEntities/AccuracyDTO.cs index 250bf18..8b834e9 100644 --- a/DataAccess/DTOs/DTOEntities/AccuracyDTO.cs +++ b/DataAccess/DTOs/DTOEntities/AccuracyDTO.cs @@ -6,16 +6,19 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -namespace DataAccess.DTOs.DTOEntities +namespace DataAccess.DTOs { public class AccuracyDTO : IAccuracy { [JsonProperty("Id")] - public Guid Id { get; set; } = Guid.NewGuid(); + public Guid Id { get;} [JsonProperty("IterationAccuracy")] public double IterationAccuracy { get; set; } [JsonProperty("MaxIterationCount")] public int MaxIterationCount { get; set; } - + public AccuracyDTO(Guid id) + { + Id = id; + } } } diff --git a/DataAccess/DTOs/DTOEntities/ColumnFilePropertyDTO.cs b/DataAccess/DTOs/DTOEntities/ColumnFilePropertyDTO.cs new file mode 100644 index 0000000..f8616ba --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/ColumnFilePropertyDTO.cs @@ -0,0 +1,30 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Forces; + +namespace DataAccess.DTOs +{ + public class ColumnFilePropertyDTO : IColumnFileProperty + { + [JsonProperty("Id")] + public Guid Id { get; } + [JsonProperty("Name")] + public string Name { get; set; } + [JsonProperty("SearchingName")] + public string SearchingName { get; set; } + [JsonProperty("Index")] + public int Index { get; set; } + [JsonProperty("Factor")] + public double Factor { get; set; } + + + public ColumnFilePropertyDTO(Guid id) + { + Id = id; + } + + public object Clone() + { + return this; + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/ColumnedFilePropertyDTO.cs b/DataAccess/DTOs/DTOEntities/ColumnedFilePropertyDTO.cs new file mode 100644 index 0000000..9ff4b90 --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/ColumnedFilePropertyDTO.cs @@ -0,0 +1,33 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Forces; + +namespace DataAccess.DTOs +{ + public class ColumnedFilePropertyDTO : IColumnedFileProperty + { + [JsonProperty("Id")] + public Guid Id { get; } + [JsonProperty("FilePath")] + public string FilePath { get; set; } = string.Empty; + [JsonProperty("SkipRowBeforeHeaderCount")] + public int SkipRowBeforeHeaderCount { get; set; } + [JsonProperty("SkipRowHeaderCount")] + public int SkipRowHeaderCount { get; set; } + [JsonProperty("GlobalFactor")] + public double GlobalFactor { get; set; } + [JsonProperty("ColumnProperties")] + public List ColumnProperties { get; } = new(); + + + public ColumnedFilePropertyDTO(Guid id) + { + Id = id; + } + + + public object Clone() + { + return this; + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/CrackCalculatorDTO.cs b/DataAccess/DTOs/DTOEntities/CrackCalculatorDTO.cs index 42149db..7122890 100644 --- a/DataAccess/DTOs/DTOEntities/CrackCalculatorDTO.cs +++ b/DataAccess/DTOs/DTOEntities/CrackCalculatorDTO.cs @@ -13,16 +13,20 @@ namespace DataAccess.DTOs public class CrackCalculatorDTO : ICrackCalculator { [JsonProperty("Id")] - public Guid Id { get; set; } + public Guid Id { get;} [JsonProperty("Name")] public string Name { get; set; } [JsonProperty("InputData")] - public ICrackCalculatorInputData InputData { get; set; } = new CrackCalculatorInputDataDTO(); + public ICrackCalculatorInputData InputData { get; set; } [JsonIgnore] public IResult Result { get; } [JsonIgnore] public IShiftTraceLogger? TraceLogger { get; set; } + public CrackCalculatorDTO(Guid id) + { + Id = id; + } public object Clone() { diff --git a/DataAccess/DTOs/DTOEntities/CrackCalculatorInputDataDTO.cs b/DataAccess/DTOs/DTOEntities/CrackCalculatorInputDataDTO.cs index a9c2343..2f0c794 100644 --- a/DataAccess/DTOs/DTOEntities/CrackCalculatorInputDataDTO.cs +++ b/DataAccess/DTOs/DTOEntities/CrackCalculatorInputDataDTO.cs @@ -8,13 +8,17 @@ namespace DataAccess.DTOs public class CrackCalculatorInputDataDTO : ICrackCalculatorInputData { [JsonProperty("Id")] - public Guid Id { get; set; } = Guid.NewGuid(); + public Guid Id { get; } [JsonProperty("ForceActions")] public List ForceActions { get; set; } = new(); [JsonProperty("ForcePrimitives")] public List Primitives { get; set; } = new(); [JsonProperty("UserCrackInputData")] - public IUserCrackInputData UserCrackInputData { get; set; } = new UserCrackInputDataDTO(); + public IUserCrackInputData UserCrackInputData { get; set; } + public CrackCalculatorInputDataDTO(Guid id) + { + Id = id; + } } } diff --git a/DataAccess/DTOs/DTOEntities/DesignForceTupleDTO.cs b/DataAccess/DTOs/DTOEntities/DesignForceTupleDTO.cs index 36d1f49..301d494 100644 --- a/DataAccess/DTOs/DTOEntities/DesignForceTupleDTO.cs +++ b/DataAccess/DTOs/DTOEntities/DesignForceTupleDTO.cs @@ -16,7 +16,7 @@ namespace DataAccess.DTOs [JsonProperty("CalcTerm")] public CalcTerms CalcTerm { get; set; } [JsonProperty("ForceTuple")] - public IForceTuple ForceTuple { get; set; } = new ForceTupleDTO(); + public IForceTuple ForceTuple { get; set; } = new ForceTupleDTO(Guid.NewGuid()); public object Clone() diff --git a/DataAccess/DTOs/DTOEntities/ForceFactoredCombinationPropertyDTO.cs b/DataAccess/DTOs/DTOEntities/FactoredCombinationPropertyDTO.cs similarity index 68% rename from DataAccess/DTOs/DTOEntities/ForceFactoredCombinationPropertyDTO.cs rename to DataAccess/DTOs/DTOEntities/FactoredCombinationPropertyDTO.cs index 772e5e5..8bb4c3b 100644 --- a/DataAccess/DTOs/DTOEntities/ForceFactoredCombinationPropertyDTO.cs +++ b/DataAccess/DTOs/DTOEntities/FactoredCombinationPropertyDTO.cs @@ -4,8 +4,10 @@ using StructureHelperCommon.Models.Forces; namespace DataAccess.DTOs { - public class ForceFactoredCombinationPropertyDTO : IFactoredCombinationProperty + public class FactoredCombinationPropertyDTO : IFactoredCombinationProperty { + [JsonProperty("Id")] + public Guid Id { get; } [JsonProperty("CalctTerm")] public CalcTerms CalcTerm { get; set; } [JsonProperty("LimitState")] @@ -14,5 +16,9 @@ namespace DataAccess.DTOs public double LongTermFactor { get; set; } [JsonProperty("ULSFactor")] public double ULSFactor { get; set; } + public FactoredCombinationPropertyDTO(Guid id) + { + Id = id; + } } } diff --git a/DataAccess/DTOs/DTOEntities/ForceCalculatorDTO.cs b/DataAccess/DTOs/DTOEntities/ForceCalculatorDTO.cs index 216766f..35af86a 100644 --- a/DataAccess/DTOs/DTOEntities/ForceCalculatorDTO.cs +++ b/DataAccess/DTOs/DTOEntities/ForceCalculatorDTO.cs @@ -17,7 +17,7 @@ namespace DataAccess.DTOs [JsonProperty("Name")] public string Name { get; set; } [JsonProperty("InputData")] - public IForceCalculatorInputData InputData { get; set; } = new ForceCalculatorInputDataDTO(); + public IForceCalculatorInputData InputData { get; set; } [JsonIgnore] public IShiftTraceLogger? TraceLogger { get; set; } [JsonIgnore] diff --git a/DataAccess/DTOs/DTOEntities/ForceCalculatorInputDataDTO.cs b/DataAccess/DTOs/DTOEntities/ForceCalculatorInputDataDTO.cs index 91884f7..0448737 100644 --- a/DataAccess/DTOs/DTOEntities/ForceCalculatorInputDataDTO.cs +++ b/DataAccess/DTOs/DTOEntities/ForceCalculatorInputDataDTO.cs @@ -1,23 +1,17 @@ -using DataAccess.DTOs.DTOEntities; -using Newtonsoft.Json; +using Newtonsoft.Json; using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Sections; using StructureHelperLogics.NdmCalculations.Analyses.ByForces; using StructureHelperLogics.NdmCalculations.Primitives; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace DataAccess.DTOs { public class ForceCalculatorInputDataDTO : IForceCalculatorInputData { [JsonProperty("Id")] - public Guid Id { get; set; } = Guid.NewGuid(); + public Guid Id { get; } [JsonProperty("ForceActions")] public List ForceActions { get; set; } = new(); [JsonProperty("Primitives")] @@ -27,11 +21,14 @@ namespace DataAccess.DTOs [JsonProperty("CalcTermList")] public List CalcTermsList { get; set; } = new(); [JsonProperty("Accuracy")] - public IAccuracy Accuracy { get; set; } = new AccuracyDTO(); + public IAccuracy Accuracy { get; set; } [JsonProperty("CompressedMember")] public ICompressedMember CompressedMember { get; set; } = new CompressedMemberDTO(); - //[JsonIgnore] - //public List ForceCombinationLists { get; set; } = new(); + + public ForceCalculatorInputDataDTO(Guid id) + { + Id = id; + } } } diff --git a/DataAccess/DTOs/DTOEntities/ForceCombinationFromFileDTO.cs b/DataAccess/DTOs/DTOEntities/ForceCombinationFromFileDTO.cs new file mode 100644 index 0000000..5dfce4c --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/ForceCombinationFromFileDTO.cs @@ -0,0 +1,42 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Shapes; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class ForceCombinationFromFileDTO : IForceCombinationFromFile + { + [JsonProperty("Id")] + public Guid Id { get; } + [JsonProperty("Name")] + public string Name { get; set; } + [JsonProperty("ForceFiles")] + public List ForceFiles { get; set; } = new(); + [JsonProperty("CombinationProperty")] + public IFactoredCombinationProperty CombinationProperty { get; set; } = new FactoredCombinationPropertyDTO(Guid.NewGuid()); + [JsonProperty("SetInGravityCenter")] + public bool SetInGravityCenter { get; set; } + [JsonProperty("ForcePoint")] + public IPoint2D ForcePoint { get; set; } = new Point2DDTO(); + + public ForceCombinationFromFileDTO(Guid id) + { + Id = id; + } + + public object Clone() + { + return this; + } + + public List GetCombinations() + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/ForceCombinationByFactorDTO.cs b/DataAccess/DTOs/DTOEntities/ForceFactoredListDTO.cs similarity index 83% rename from DataAccess/DTOs/DTOEntities/ForceCombinationByFactorDTO.cs rename to DataAccess/DTOs/DTOEntities/ForceFactoredListDTO.cs index c2a56cf..3713109 100644 --- a/DataAccess/DTOs/DTOEntities/ForceCombinationByFactorDTO.cs +++ b/DataAccess/DTOs/DTOEntities/ForceFactoredListDTO.cs @@ -10,10 +10,10 @@ using System.Threading.Tasks; namespace DataAccess.DTOs { - public class ForceCombinationByFactorDTO : IForceFactoredList + public class ForceFactoredListDTO : IForceFactoredList { [JsonProperty("Id")] - public Guid Id { get; set; } + public Guid Id { get;} [JsonProperty("Name")] public string Name { get; set; } [JsonProperty("ForceTuples")] @@ -23,8 +23,12 @@ namespace DataAccess.DTOs [JsonProperty("ForcePoint")] public IPoint2D ForcePoint { get; set; } = new Point2DDTO(); [JsonProperty("CombinationProperty")] - public IFactoredCombinationProperty CombinationProperty { get; } = new ForceFactoredCombinationPropertyDTO(); + public IFactoredCombinationProperty CombinationProperty { get; set; } = new FactoredCombinationPropertyDTO(Guid.NewGuid()); + public ForceFactoredListDTO(Guid id) + { + Id = id; + } public object Clone() { diff --git a/DataAccess/DTOs/DTOEntities/ForceTupleDTO.cs b/DataAccess/DTOs/DTOEntities/ForceTupleDTO.cs index 3dbe8bd..49f11f5 100644 --- a/DataAccess/DTOs/DTOEntities/ForceTupleDTO.cs +++ b/DataAccess/DTOs/DTOEntities/ForceTupleDTO.cs @@ -25,6 +25,10 @@ namespace DataAccess.DTOs [JsonProperty("Mz")] public double Mz { get; set; } + public ForceTupleDTO(Guid id) + { + Id = id; + } public void Clear() { diff --git a/DataAccess/DTOs/DTOEntities/NdmElementDTO.cs b/DataAccess/DTOs/DTOEntities/NdmElementDTO.cs index 2f2c7f8..47be68d 100644 --- a/DataAccess/DTOs/DTOEntities/NdmElementDTO.cs +++ b/DataAccess/DTOs/DTOEntities/NdmElementDTO.cs @@ -19,9 +19,9 @@ namespace DataAccess.DTOs [JsonProperty("Triangulate")] public bool Triangulate { get; set; } [JsonProperty("UsersPrestrain")] - public IForceTuple UsersPrestrain { get; set; } = new ForceTupleDTO(); + public IForceTuple UsersPrestrain { get; set; } = new ForceTupleDTO(Guid.NewGuid()); [JsonProperty("AutoPrestrain")] - public IForceTuple AutoPrestrain { get; set; } = new ForceTupleDTO(); + public IForceTuple AutoPrestrain { get; set; } = new ForceTupleDTO(Guid.NewGuid()); public object Clone() diff --git a/DataAccess/DTOs/DTOEntities/Obsolete/ForceCombinationByFactorV1_0DTO.cs b/DataAccess/DTOs/DTOEntities/Obsolete/ForceCombinationByFactorV1_0DTO.cs index b6af6d1..c7c3ad6 100644 --- a/DataAccess/DTOs/DTOEntities/Obsolete/ForceCombinationByFactorV1_0DTO.cs +++ b/DataAccess/DTOs/DTOEntities/Obsolete/ForceCombinationByFactorV1_0DTO.cs @@ -21,7 +21,7 @@ namespace DataAccess.DTOs [JsonProperty("CalcTerm")] public CalcTerms CalcTerm { get; set; } = CalcTerms.ShortTerm; [JsonProperty("FullSLSForces")] - public IForceTuple ForceTuple { get; set; } = new ForceTupleDTO(); + public IForceTuple ForceTuple { get; set; } = new ForceTupleDTO(Guid.NewGuid()); [JsonProperty("ULSFactor")] public double ULSFactor { get; set; } [JsonProperty("LongTermFactor")] @@ -31,13 +31,23 @@ namespace DataAccess.DTOs [JsonProperty("ForcePoint")] public IPoint2D ForcePoint { get; set; } = new Point2DDTO(); [JsonIgnore] - public IFactoredCombinationProperty CombinationProperty => new FactoredCombinationProperty() + public IFactoredCombinationProperty CombinationProperty { - CalcTerm = CalcTerm, - LimitState = LimitState, - LongTermFactor = LongTermFactor, - ULSFactor = ULSFactor, - }; + get + { + return new FactoredCombinationProperty() + { + CalcTerm = CalcTerm, + LimitState = LimitState, + LongTermFactor = LongTermFactor, + ULSFactor = ULSFactor, + }; + } + set + { + throw new NotImplementedException(); + } + } [JsonIgnore] public List ForceTuples => new() { ForceTuple}; diff --git a/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs b/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs index 40c4c52..0121b0a 100644 --- a/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs +++ b/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs @@ -1,5 +1,4 @@ -using DataAccess.DTOs.DTOEntities; -using StructureHelper.Models.Materials; +using StructureHelper.Models.Materials; using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Models.Analyses; @@ -7,11 +6,6 @@ using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Materials.Libraries; using StructureHelperLogics.NdmCalculations.Primitives; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace DataAccess.DTOs { @@ -40,6 +34,8 @@ namespace DataAccess.DTOs { { (typeof(AccuracyDTO), "Accuracy") }, { (typeof(ConcreteLibMaterialDTO), "ConcreteLibMaterial") }, + { (typeof(ColumnFilePropertyDTO), "ColumnFileProperty") }, + { (typeof(ColumnedFilePropertyDTO), "ColumnedFileProperty") }, { (typeof(CompressedMemberDTO), "CompressedMember") }, { (typeof(CrackCalculatorDTO), "CrackCalculator") }, { (typeof(CrackCalculatorInputDataDTO), "CrackCalculatorInputData") }, @@ -55,9 +51,10 @@ namespace DataAccess.DTOs { (typeof(ForceCalculatorDTO), "ForceCalculator") }, { (typeof(ForceCalculatorInputDataDTO), "ForceCalculatorInputData") }, { (typeof(ForceCombinationByFactorV1_0DTO), "ForceCombinationByFactor") }, - { (typeof(ForceCombinationByFactorDTO), "ForceCombinationByFactor_v1_1") }, + { (typeof(ForceFactoredListDTO), "ForceCombinationByFactor_v1_1") }, + { (typeof(ForceCombinationFromFileDTO), "ForceCombinationFromFile") }, { (typeof(ForceCombinationListDTO), "ForceCombinationList") }, - { (typeof(ForceFactoredCombinationPropertyDTO), "ForceFactoredCombinationProperty") }, + { (typeof(FactoredCombinationPropertyDTO), "ForceFactoredCombinationProperty") }, { (typeof(ForceTupleDTO), "ForceTuple") }, { (typeof(FRMaterialDTO), "FRMaterial") }, { (typeof(HeadMaterialDTO), "HeadMaterial") }, @@ -65,6 +62,8 @@ namespace DataAccess.DTOs { (typeof(NdmElementDTO), "NdmElement") }, { (typeof(IVisualAnalysis), "IVisualAnalysis") }, { (typeof(List), "ListOfCalcTerms") }, + { (typeof(List), "ColumnFileProperties") }, + { (typeof(List), "ColumnedFileProperties") }, { (typeof(List), "ListOfICalculator") }, { (typeof(List), "ListOfIDateVersion") }, { (typeof(List), "ListOfIDesignForceTuple") }, diff --git a/DataAccess/DTOs/DTOEntities/UserCrackInputDataDTO.cs b/DataAccess/DTOs/DTOEntities/UserCrackInputDataDTO.cs index b479af3..95dd52f 100644 --- a/DataAccess/DTOs/DTOEntities/UserCrackInputDataDTO.cs +++ b/DataAccess/DTOs/DTOEntities/UserCrackInputDataDTO.cs @@ -11,7 +11,7 @@ namespace DataAccess.DTOs public class UserCrackInputDataDTO : IUserCrackInputData { [JsonProperty("Id")] - public Guid Id { get; set; } = Guid.NewGuid(); + public Guid Id { get;} [JsonProperty("LengthBetweenCracks")] public double LengthBetweenCracks { get; set; } [JsonProperty("SetLengthBetweenCracks")] @@ -25,5 +25,9 @@ namespace DataAccess.DTOs [JsonProperty("UltimateShortCrackWidths")] public double UltimateShortCrackWidth { get; set; } + public UserCrackInputDataDTO(Guid id) + { + Id = id; + } } } diff --git a/DataAccess/Infrastructures/FileSaveLogic.cs b/DataAccess/Infrastructures/FileSaveLogic.cs index 6c8ed14..84394fb 100644 --- a/DataAccess/Infrastructures/FileSaveLogic.cs +++ b/DataAccess/Infrastructures/FileSaveLogic.cs @@ -1,10 +1,4 @@ -using DataAccess.DTOs; -using DataAccess.DTOs.DTOEntities; -using DataAccess.JsonConverters; -using Newtonsoft.Json; -using StructureHelperCommon.Infrastructures.Interfaces; -using StructureHelperCommon.Infrastructures.Settings; -using StructureHelperCommon.Models; +using StructureHelperCommon.Models; using StructureHelperCommon.Models.Projects; using StructureHelperCommon.Services.FileServices; diff --git a/StructureHelper/Windows/Forces/ColumnPropertyVM.cs b/StructureHelper/Windows/Forces/ColumnFilePropertyVM.cs similarity index 90% rename from StructureHelper/Windows/Forces/ColumnPropertyVM.cs rename to StructureHelper/Windows/Forces/ColumnFilePropertyVM.cs index 009a1c1..74460f2 100644 --- a/StructureHelper/Windows/Forces/ColumnPropertyVM.cs +++ b/StructureHelper/Windows/Forces/ColumnFilePropertyVM.cs @@ -9,11 +9,11 @@ using System.Threading.Tasks; namespace StructureHelper.Windows.Forces { - public class ColumnPropertyVM : ViewModelBase, IDataErrorInfo + public class ColumnFilePropertyVM : ViewModelBase, IDataErrorInfo { - private IColumnProperty model; + private IColumnFileProperty model; - public ColumnPropertyVM(IColumnProperty model) + public ColumnFilePropertyVM(IColumnFileProperty model) { this.model = model; } diff --git a/StructureHelper/Windows/Forces/ForceFilePropertyVM.cs b/StructureHelper/Windows/Forces/ForceFilePropertyVM.cs index 807c0d6..adc8802 100644 --- a/StructureHelper/Windows/Forces/ForceFilePropertyVM.cs +++ b/StructureHelper/Windows/Forces/ForceFilePropertyVM.cs @@ -18,7 +18,7 @@ namespace StructureHelper.Windows.Forces this.model = model; foreach (var item in model.ColumnProperties) { - ColumnProperties.Add(new ColumnPropertyVM(item)); + ColumnProperties.Add(new ColumnFilePropertyVM(item)); } } @@ -59,7 +59,7 @@ namespace StructureHelper.Windows.Forces } } - public ObservableCollection ColumnProperties { get; set; } = new(); + public ObservableCollection ColumnProperties { get; set; } = new(); public IColumnedFileProperty Model { diff --git a/StructureHelperCommon/Infrastructures/Interfaces/ConvertStrategy.cs b/StructureHelperCommon/Infrastructures/Interfaces/ConvertStrategy.cs index decb1a1..a91e391 100644 --- a/StructureHelperCommon/Infrastructures/Interfaces/ConvertStrategy.cs +++ b/StructureHelperCommon/Infrastructures/Interfaces/ConvertStrategy.cs @@ -8,6 +8,7 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Infrastructures.Interfaces { + /// public abstract class ConvertStrategy : IConvertStrategy where T : ISaveable where V : ISaveable @@ -22,7 +23,10 @@ namespace StructureHelperCommon.Infrastructures.Interfaces try { Check(); - return GetNewItem(source); + TraceStartOfConverting(source); + T target = GetNewItem(source); + TraceFinishOfConverting(target); + return target; } catch (Exception ex) { @@ -38,5 +42,18 @@ namespace StructureHelperCommon.Infrastructures.Interfaces var checkLogic = new CheckConvertLogic(this); checkLogic.Check(); } + + public void TraceErrorByEntity(object obj, string message) + { + TraceLogger?.AddMessage($"Logic: {LoggerStrings.LogicType(obj)} made error: {message}", TraceLogStatuses.Error); + } + private void TraceStartOfConverting(ISaveable saveable) + { + TraceLogger?.AddMessage($"Converting {saveable.GetType()} Id = {saveable.Id} has been started"); + } + private void TraceFinishOfConverting(ISaveable saveable) + { + TraceLogger?.AddMessage($"Converting {saveable.GetType()} Id = {saveable.Id} has been started"); + } } } diff --git a/StructureHelperCommon/Models/Forces/ColumnProperty.cs b/StructureHelperCommon/Models/Forces/ColumnFileProperty.cs similarity index 71% rename from StructureHelperCommon/Models/Forces/ColumnProperty.cs rename to StructureHelperCommon/Models/Forces/ColumnFileProperty.cs index 15c7bc2..9c7244d 100644 --- a/StructureHelperCommon/Models/Forces/ColumnProperty.cs +++ b/StructureHelperCommon/Models/Forces/ColumnFileProperty.cs @@ -7,7 +7,7 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Forces { /// - public class ColumnProperty : IColumnProperty + public class ColumnFileProperty : IColumnFileProperty { /// public Guid Id { get; private set; } @@ -20,19 +20,19 @@ namespace StructureHelperCommon.Models.Forces /// public double Factor { get; set; } = 1d; - public ColumnProperty(Guid id, string columnName) + public ColumnFileProperty(Guid id, string name) { Id = id; - Name = columnName; + Name = name; } - public ColumnProperty(string columnName) : this(Guid.NewGuid(), columnName) + public ColumnFileProperty(string columnName) : this(Guid.NewGuid(), columnName) { } public object Clone() { - var cloneLogic = new ColumnPropertyCloningStrategy(); + var cloneLogic = new ColumnFilePropertyCloningStrategy(); return cloneLogic.GetClone(this); } } diff --git a/StructureHelperCommon/Models/Forces/ColumnedFileProperty.cs b/StructureHelperCommon/Models/Forces/ColumnedFileProperty.cs index ca62d0f..78e15d2 100644 --- a/StructureHelperCommon/Models/Forces/ColumnedFileProperty.cs +++ b/StructureHelperCommon/Models/Forces/ColumnedFileProperty.cs @@ -23,7 +23,7 @@ namespace StructureHelperCommon.Models.Forces /// public double GlobalFactor { get; set; } = 1d; /// - public List ColumnProperties { get; } = new(); + public List ColumnProperties { get; } = new(); public ColumnedFileProperty(Guid id) { diff --git a/StructureHelperCommon/Models/Forces/FactoredCombinationProperty.cs b/StructureHelperCommon/Models/Forces/FactoredCombinationProperty.cs index 5addcd2..a1df9f4 100644 --- a/StructureHelperCommon/Models/Forces/FactoredCombinationProperty.cs +++ b/StructureHelperCommon/Models/Forces/FactoredCombinationProperty.cs @@ -7,11 +7,27 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Forces { + /// public class FactoredCombinationProperty : IFactoredCombinationProperty { + /// + public Guid Id { get; } + /// public CalcTerms CalcTerm { get; set; } = CalcTerms.ShortTerm; + /// public LimitStates LimitState { get; set; } = LimitStates.SLS; + /// public double LongTermFactor { get; set; } = 1d; + /// public double ULSFactor { get; set; } = 1.2d; + + public FactoredCombinationProperty(Guid id) + { + Id = id; + } + public FactoredCombinationProperty() : this(Guid.NewGuid()) + { + + } } } diff --git a/StructureHelperCommon/Models/Forces/FilePropertyFactory.cs b/StructureHelperCommon/Models/Forces/FilePropertyFactory.cs index 8347378..0216e0e 100644 --- a/StructureHelperCommon/Models/Forces/FilePropertyFactory.cs +++ b/StructureHelperCommon/Models/Forces/FilePropertyFactory.cs @@ -18,7 +18,7 @@ namespace StructureHelperCommon.Models.Forces if (propertyType == FilePropertyType.Forces) { ColumnedFileProperty fileProperty = new(); - List columnProperties = GetForceColumns(); + List columnProperties = GetForceColumns(); fileProperty.ColumnProperties.AddRange(columnProperties); return fileProperty; } @@ -28,12 +28,12 @@ namespace StructureHelperCommon.Models.Forces } } - private static List GetForceColumns() + private static List GetForceColumns() { - List columnProperties = new(); - columnProperties.Add(new ColumnProperty("Nz") { SearchingName = "N", Index = 6 }); - columnProperties.Add(new ColumnProperty("Mx") { SearchingName = "My", Index = 8 }); - columnProperties.Add(new ColumnProperty("My") { SearchingName = "Mz", Index = 10 }); + List columnProperties = new(); + columnProperties.Add(new ColumnFileProperty("Nz") { SearchingName = "N", Index = 6 }); + columnProperties.Add(new ColumnFileProperty("Mx") { SearchingName = "My", Index = 8 }); + columnProperties.Add(new ColumnFileProperty("My") { SearchingName = "Mz", Index = 10 }); return columnProperties; } } diff --git a/StructureHelperCommon/Models/Forces/ForceCombinationFromFile.cs b/StructureHelperCommon/Models/Forces/ForceCombinationFromFile.cs index 108e51e..aa915b7 100644 --- a/StructureHelperCommon/Models/Forces/ForceCombinationFromFile.cs +++ b/StructureHelperCommon/Models/Forces/ForceCombinationFromFile.cs @@ -17,13 +17,24 @@ namespace StructureHelperCommon.Models.Forces IGetTuplesFromFileLogic getTupleFromFileLogic; private IForceFactoredList factoredCombination; - public Guid Id { get; set; } + public Guid Id { get; } + + public ForceCombinationFromFile(Guid id) + { + Id = id; + } + + public ForceCombinationFromFile() : this(Guid.NewGuid()) + { + + } + public string Name { get; set; } = string.Empty; public List ForceFiles { get; set; } = new(); public bool SetInGravityCenter { get; set; } = true; public IPoint2D ForcePoint { get; set; } = new Point2D(); - public IFactoredCombinationProperty CombinationProperty { get; } = new FactoredCombinationProperty(); + public IFactoredCombinationProperty CombinationProperty { get; set; } = new FactoredCombinationProperty(); public object Clone() { diff --git a/StructureHelperCommon/Models/Forces/ForceFactoredList.cs b/StructureHelperCommon/Models/Forces/ForceFactoredList.cs index 4a14a58..e5891e0 100644 --- a/StructureHelperCommon/Models/Forces/ForceFactoredList.cs +++ b/StructureHelperCommon/Models/Forces/ForceFactoredList.cs @@ -23,7 +23,7 @@ namespace StructureHelperCommon.Models.Forces /// public List ForceTuples { get; } = new() { new ForceTuple()}; /// - public IFactoredCombinationProperty CombinationProperty { get; } = new FactoredCombinationProperty(); + public IFactoredCombinationProperty CombinationProperty { get; set; }= new FactoredCombinationProperty(); public ForceFactoredList(Guid id) diff --git a/StructureHelperCommon/Models/Forces/IColumnProperty.cs b/StructureHelperCommon/Models/Forces/IColumnFileProperty.cs similarity index 92% rename from StructureHelperCommon/Models/Forces/IColumnProperty.cs rename to StructureHelperCommon/Models/Forces/IColumnFileProperty.cs index 9ff4800..a4f58b1 100644 --- a/StructureHelperCommon/Models/Forces/IColumnProperty.cs +++ b/StructureHelperCommon/Models/Forces/IColumnFileProperty.cs @@ -10,7 +10,7 @@ namespace StructureHelperCommon.Models.Forces /// /// Settingth for column reading from MSExcel file /// - public interface IColumnProperty : ISaveable, ICloneable + public interface IColumnFileProperty : ISaveable, ICloneable { /// /// Name of column diff --git a/StructureHelperCommon/Models/Forces/IColumnedFileProperty.cs b/StructureHelperCommon/Models/Forces/IColumnedFileProperty.cs index 8943eab..aad6a8f 100644 --- a/StructureHelperCommon/Models/Forces/IColumnedFileProperty.cs +++ b/StructureHelperCommon/Models/Forces/IColumnedFileProperty.cs @@ -28,6 +28,6 @@ namespace StructureHelperCommon.Models.Forces /// /// Collection of column's properties which will be imported /// - List ColumnProperties { get; } + List ColumnProperties { get; } } } diff --git a/StructureHelperCommon/Models/Forces/IFactoredCombinationProperty.cs b/StructureHelperCommon/Models/Forces/IFactoredCombinationProperty.cs index 7060cc3..9cc437a 100644 --- a/StructureHelperCommon/Models/Forces/IFactoredCombinationProperty.cs +++ b/StructureHelperCommon/Models/Forces/IFactoredCombinationProperty.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Interfaces; using System; using System.Collections.Generic; using System.Linq; @@ -10,7 +11,7 @@ namespace StructureHelperCommon.Models.Forces /// /// Properties of factored combination of forces /// - public interface IFactoredCombinationProperty + public interface IFactoredCombinationProperty : ISaveable { /// /// Term of calculation for assigned combination diff --git a/StructureHelperCommon/Models/Forces/IForceFactoredCombination.cs b/StructureHelperCommon/Models/Forces/IForceFactoredCombination.cs index 75e42a1..2855fde 100644 --- a/StructureHelperCommon/Models/Forces/IForceFactoredCombination.cs +++ b/StructureHelperCommon/Models/Forces/IForceFactoredCombination.cs @@ -10,6 +10,6 @@ namespace StructureHelperCommon.Models.Forces /// /// Properties of factored combination of forces /// - IFactoredCombinationProperty CombinationProperty { get; } + IFactoredCombinationProperty CombinationProperty { get; set; } } } \ No newline at end of file diff --git a/StructureHelperCommon/Models/Forces/Logics/ColumnPropertyCloningStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyCloningStrategy.cs similarity index 53% rename from StructureHelperCommon/Models/Forces/Logics/ColumnPropertyCloningStrategy.cs rename to StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyCloningStrategy.cs index 1f966c9..7e4bcbb 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ColumnPropertyCloningStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyCloningStrategy.cs @@ -8,28 +8,28 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Forces { - public class ColumnPropertyCloningStrategy : ICloneStrategy + public class ColumnFilePropertyCloningStrategy : ICloneStrategy { - private IUpdateStrategy updateStrategy; + private IUpdateStrategy updateStrategy; - public ColumnPropertyCloningStrategy(IUpdateStrategy updateStrategy) + public ColumnFilePropertyCloningStrategy(IUpdateStrategy updateStrategy) { this.updateStrategy = updateStrategy; } - public ColumnPropertyCloningStrategy() + public ColumnFilePropertyCloningStrategy() { } - public IColumnProperty GetClone(IColumnProperty sourceObject) + public IColumnFileProperty GetClone(IColumnFileProperty sourceObject) { CheckObject.IsNull(sourceObject); if (updateStrategy is null) { - updateStrategy = new ColumnPropertyUpdateStrategy(); + updateStrategy = new ColumnFilePropertyUpdateStrategy(); } - ColumnProperty newItem = new(sourceObject.Name); + ColumnFileProperty newItem = new(sourceObject.Name); updateStrategy.Update(newItem, sourceObject); return newItem; } diff --git a/StructureHelperCommon/Models/Forces/Logics/ColumnPropertyUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyUpdateStrategy.cs similarity index 78% rename from StructureHelperCommon/Models/Forces/Logics/ColumnPropertyUpdateStrategy.cs rename to StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyUpdateStrategy.cs index d6c1853..1508e2f 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ColumnPropertyUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyUpdateStrategy.cs @@ -8,9 +8,9 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Forces { - public class ColumnPropertyUpdateStrategy : IUpdateStrategy + public class ColumnFilePropertyUpdateStrategy : IUpdateStrategy { - public void Update(IColumnProperty targetObject, IColumnProperty sourceObject) + public void Update(IColumnFileProperty targetObject, IColumnFileProperty sourceObject) { CheckObject.IsNull(targetObject); CheckObject.IsNull(sourceObject); diff --git a/StructureHelperCommon/Models/Forces/Logics/ColumnedFilePropertyUpdateStrategy.cs b/StructureHelperCommon/Models/Forces/Logics/ColumnedFilePropertyUpdateStrategy.cs index 4359396..184f9e8 100644 --- a/StructureHelperCommon/Models/Forces/Logics/ColumnedFilePropertyUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Forces/Logics/ColumnedFilePropertyUpdateStrategy.cs @@ -31,7 +31,7 @@ namespace StructureHelperCommon.Models.Forces targetObject.ColumnProperties.Clear(); foreach (var item in sourceObject.ColumnProperties) { - IColumnProperty clone = (IColumnProperty)item.Clone(); + IColumnFileProperty clone = (IColumnFileProperty)item.Clone(); targetObject.ColumnProperties.Add(clone); } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs index 62fa76e..99b25a7 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs @@ -15,7 +15,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking CheckObject.IsNull(targetObject); CheckObject.IsNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - targetObject.SetSofteningFactor = sourceObject.SetSofteningFactor; targetObject.SofteningFactor = sourceObject.SofteningFactor; targetObject.SetLengthBetweenCracks = sourceObject.SetLengthBetweenCracks; diff --git a/StructureHelperTests/UnitTests/ForcesTests/GetTupleByExcelReaderLogicTests.cs b/StructureHelperTests/UnitTests/ForcesTests/GetTupleByExcelReaderLogicTests.cs index 36c9a13..1fd1fe1 100644 --- a/StructureHelperTests/UnitTests/ForcesTests/GetTupleByExcelReaderLogicTests.cs +++ b/StructureHelperTests/UnitTests/ForcesTests/GetTupleByExcelReaderLogicTests.cs @@ -37,9 +37,9 @@ namespace StructureHelperTests.UnitTests.ForcesTests public void GetForceTuple_ShouldReturnForceTuple_WhenDataIsValid() { // Arrange - var columnProperties = new List + var columnProperties = new List { - new Mock().SetupAllProperties().Object + new Mock().SetupAllProperties().Object }; _mockFileProperty.Setup(x => x.ColumnProperties).Returns(columnProperties); diff --git a/StructureHelperTests/ViewModelTests/ColumnPropertyVMTests.cs b/StructureHelperTests/ViewModelTests/ColumnPropertyVMTests.cs new file mode 100644 index 0000000..a0620d6 --- /dev/null +++ b/StructureHelperTests/ViewModelTests/ColumnPropertyVMTests.cs @@ -0,0 +1,38 @@ +using Moq; +using NUnit.Framework; +using StructureHelper.Windows.Forces; +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperTests.ViewModelTests +{ + [TestFixture] + public class ColumnPropertyVMTests + { + private Mock _mockColumnProperty; + + [SetUp] + public void SetUp() + { + _mockColumnProperty = new Mock(); + } + + [Test] + public void CheckViewModelCreating_RunShouldPass() + { + //Arrange + _mockColumnProperty.Setup(x => x.Name).Returns("TestName"); + _mockColumnProperty.Setup(x => x.SearchingName).Returns("TestSearchName"); + _mockColumnProperty.Setup(x => x.Index).Returns(0); + _mockColumnProperty.Setup(x => x.Factor).Returns(1); + //Act + ColumnFilePropertyVM viewModel = new(_mockColumnProperty.Object); + //Assert + Assert.That(viewModel, !Is.Null); + } + } +} diff --git a/StructureHelperTests/ViewModelTests/FactoreCombinationPropertyVMTests.cs b/StructureHelperTests/ViewModelTests/FactoreCombinationPropertyVMTests.cs new file mode 100644 index 0000000..0373aee --- /dev/null +++ b/StructureHelperTests/ViewModelTests/FactoreCombinationPropertyVMTests.cs @@ -0,0 +1,46 @@ + +using Moq; +using NUnit.Framework; +using StructureHelper.Windows.Forces; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperTests.ViewModelTests +{ + [TestFixture] + public class FactoreCombinationPropertyVMTests + { + private Mock _mockModel; + + [SetUp] + public void SetUp() + { + _mockModel = new Mock(); + } + + [TestCase(LimitStates.SLS, CalcTerms.ShortTerm, 0.9, 1.2)] + [TestCase(LimitStates.ULS, CalcTerms.ShortTerm, 0.9, 1.2)] + [TestCase(LimitStates.ULS, CalcTerms.LongTerm, 0.9, 1.2)] + public void CreateViewModel_RunShouldPass(LimitStates limitStates, CalcTerms calcTerms, double longTermFactor, double ulsFactor) + { + //Arrange + _mockModel.Setup(x => x.LimitState).Returns(limitStates); + _mockModel.Setup(x => x.CalcTerm).Returns(calcTerms); + _mockModel.Setup(x => x.LongTermFactor).Returns(longTermFactor); + _mockModel.Setup(x => x.ULSFactor).Returns(ulsFactor); + //Act + FactoredCombinationPropertyVM viewModel = new(_mockModel.Object); + //Assert + Assert.That(viewModel, !Is.Null); + Assert.That(viewModel.LimitState, Is.EqualTo(limitStates)); + Assert.That(viewModel.CalcTerm, Is.EqualTo(calcTerms)); + Assert.That(viewModel.LongTermFactor, Is.EqualTo(longTermFactor)); + Assert.That(viewModel.ULSFactor, Is.EqualTo(ulsFactor)); + } + } +}