diff --git a/DataAccess/DTOs/Converters/CalculatorsFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CalculatorsFromDTOConvertStrategy.cs new file mode 100644 index 0000000..be7344b --- /dev/null +++ b/DataAccess/DTOs/Converters/CalculatorsFromDTOConvertStrategy.cs @@ -0,0 +1,63 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +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 CalculatorsFromDTOConvertStrategy : ConvertStrategy + { + private const string CalculatorIs = "Calculator is"; + private IConvertStrategy forceConvertStrategy = new ForceCalculatorFromDTOConvertStrategy(); + private IConvertStrategy crackConvertStrategy = new CrackCalculatorFromDTOConvertStrategy(); + + public override ICalculator GetNewItem(ICalculator source) + { + NewItem = GetNewCalculator(source); + TraceLogger?.AddMessage($"Calculator Id = {NewItem.Id}, Name = {NewItem.Name} has been obtained"); + return NewItem; + } + + private ICalculator GetNewCalculator(ICalculator source) + { + if (source is IForceCalculator forceCalculator) + { + TraceLogger?.AddMessage($"{CalculatorIs} force calculator"); + IForceCalculator calculator = GetForcCalculator(forceCalculator); + return calculator; + } + if (source is ICrackCalculator crackCalculator) + { + TraceLogger?.AddMessage($"{CalculatorIs} crack calculator"); + ICrackCalculator calculator = GetCrackCalculator(crackCalculator); + return calculator; + } + string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source); + TraceLogger.AddMessage(errorString, TraceLogStatuses.Error); + throw new StructureHelperException(errorString); + } + + private ICrackCalculator GetCrackCalculator(ICrackCalculator crackCalculator) + { + crackConvertStrategy.ReferenceDictionary = ReferenceDictionary; + crackConvertStrategy.TraceLogger = TraceLogger; + CrackCalculator newItem = crackConvertStrategy.Convert(crackCalculator as CrackCalculatorDTO); + return newItem; + } + + private IForceCalculator GetForcCalculator(IForceCalculator forceCalculator) + { + forceConvertStrategy.ReferenceDictionary = ReferenceDictionary; + forceConvertStrategy.TraceLogger = TraceLogger; + ForceCalculator newItem = forceConvertStrategy.Convert(forceCalculator as ForceCalculatorDTO); + return newItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/CrackCalculatorFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrackCalculatorFromDTOConvertStrategy.cs new file mode 100644 index 0000000..afb4249 --- /dev/null +++ b/DataAccess/DTOs/Converters/CrackCalculatorFromDTOConvertStrategy.cs @@ -0,0 +1,26 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +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 CrackCalculatorFromDTOConvertStrategy : ConvertStrategy + { + private IConvertStrategy convertStrategy = new CrackCalculatorInputDataFromDTOConvertStrategy(); + + public override CrackCalculator GetNewItem(CrackCalculatorDTO source) + { + NewItem = new(source.Id); + NewItem.Name = source.Name; + convertStrategy.ReferenceDictionary = ReferenceDictionary; + convertStrategy.TraceLogger = TraceLogger; + NewItem.InputData = convertStrategy.Convert(source.InputData as CrackCalculatorInputDataDTO); + return NewItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/CrackCalculatorInputDataFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrackCalculatorInputDataFromDTOConvertStrategy.cs new file mode 100644 index 0000000..c85c680 --- /dev/null +++ b/DataAccess/DTOs/Converters/CrackCalculatorInputDataFromDTOConvertStrategy.cs @@ -0,0 +1,47 @@ +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 CrackCalculatorInputDataFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy userDataUpdateStrategy = new UserCrackInputDataUpdateStrategy(); + private IHasPrimitivesProcessLogic primitivesProcessLogic = new HasPrimitivesProcessLogic(); + private IHasForceActionsProcessLogic actionsProcessLogic = new HasForceActionsProcessLogic(); + + public override CrackCalculatorInputData GetNewItem(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 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/CrackCalculatorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrackCalculatorToDTOConvertStrategy.cs index 4aff9c6..704760b 100644 --- a/DataAccess/DTOs/Converters/CrackCalculatorToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CrackCalculatorToDTOConvertStrategy.cs @@ -66,7 +66,7 @@ namespace DataAccess.DTOs updateStrategy.Update(target, source); } - private void ProcessForceActions(IHasForceCombinations target, IHasForceCombinations source) + private void ProcessForceActions(IHasForceActions target, IHasForceActions source) { HasForceActionToDTOUpdateStrategy updateStrategy = new() { diff --git a/DataAccess/DTOs/Converters/CrossSectionRepositoryFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrossSectionRepositoryFromDTOConvertStrategy.cs index 561f890..7b11c07 100644 --- a/DataAccess/DTOs/Converters/CrossSectionRepositoryFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CrossSectionRepositoryFromDTOConvertStrategy.cs @@ -1,9 +1,14 @@ -using StructureHelper.Models.Materials; +using DataAccess.DTOs.Converters; +using StructureHelper.Models.Materials; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Loggers; using StructureHelperLogics.Models.CrossSections; using StructureHelperLogics.Models.Materials; +using StructureHelperLogics.NdmCalculations.Cracking; +using StructureHelperLogics.NdmCalculations.Primitives; using System; using System.Collections.Generic; using System.Linq; @@ -18,27 +23,57 @@ namespace DataAccess.DTOs private const string convertFinished = " converting has been finished succesfully"; private CrossSectionRepository newRepository; + private IHasPrimitivesProcessLogic primitivesProcessLogic = new HasPrimitivesProcessLogic(); + private IHasForceActionsProcessLogic actionsProcessLogic = new HasForceActionsProcessLogic(); + public override CrossSectionRepository GetNewItem(ICrossSectionRepository source) { - TraceLogger?.AddMessage("Cross-Section repository" + convertStarted, TraceLogStatuses.Service); + TraceLogger?.AddMessage("Cross-Section repository" + convertStarted); newRepository = new(source.Id); ProcessMaterials(source); ProcessActions(source); - TraceLogger?.AddMessage("Cross-Section repository" + convertFinished, TraceLogStatuses.Service); + ProcessPrimitives(source); + ProcessCalculators(source); + TraceLogger?.AddMessage("Cross-Section repository" + convertFinished); return newRepository; } - private void ProcessActions(ICrossSectionRepository source) + private void ProcessCalculators(ICrossSectionRepository source) { - TraceLogger?.AddMessage("Actions"+ convertStarted, TraceLogStatuses.Service); - TraceLogger?.AddMessage("Actions" + convertFinished, TraceLogStatuses.Service); - throw new NotImplementedException(); + TraceLogger?.AddMessage("Calculators" + convertStarted); + var convertStrategy = new CalculatorsFromDTOConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + var convertLogic = new DictionaryConvertStrategy(this, convertStrategy); + var updateStrategy = new HasCalculatorsFromDTOUpdateStrategy(convertLogic); + updateStrategy.Update(newRepository, source); + TraceLogger?.AddMessage("Calculators" + convertFinished); + } + + private void ProcessPrimitives(IHasPrimitives source) + { + primitivesProcessLogic.Source = source; + primitivesProcessLogic.Target = newRepository; + primitivesProcessLogic.ReferenceDictionary = ReferenceDictionary; + primitivesProcessLogic.TraceLogger = TraceLogger; + primitivesProcessLogic.Process(); + } + + private void ProcessActions(IHasForceActions source) + { + actionsProcessLogic.Source = source; + actionsProcessLogic.Target = newRepository; + actionsProcessLogic.ReferenceDictionary = ReferenceDictionary; + actionsProcessLogic.TraceLogger = TraceLogger; + actionsProcessLogic.Process(); } private void ProcessMaterials(IHasHeadMaterials source) { - TraceLogger?.AddMessage("Materials" + convertStarted, TraceLogStatuses.Service); - var convertStrategy = new HeadMaterialFromDTOConvertStrategy + TraceLogger?.AddMessage("Materials" + convertStarted); + var convertStrategy = new HeadMaterialFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger @@ -46,7 +81,7 @@ namespace DataAccess.DTOs var convertLogic = new DictionaryConvertStrategy(this, convertStrategy); var updateStrategy = new HasMaterialFromDTOUpdateStrategy(convertLogic); updateStrategy.Update(newRepository, source); - TraceLogger?.AddMessage("Materials" + convertFinished, TraceLogStatuses.Service); + TraceLogger?.AddMessage("Materials" + convertFinished); } } } diff --git a/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs index e114964..5fb2484 100644 --- a/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs @@ -88,7 +88,7 @@ namespace DataAccess.DTOs updateStrategy.Update(target, source); } - private void ProcessForceActions(IHasForceCombinations target, IHasForceCombinations source) + private void ProcessForceActions(IHasForceActions target, IHasForceActions source) { HasForceActionToDTOUpdateStrategy updateStrategy = new() { diff --git a/DataAccess/DTOs/Converters/EllipseNdmPrimitiveFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/EllipseNdmPrimitiveFromDTOConvertStrategy.cs new file mode 100644 index 0000000..a8a328e --- /dev/null +++ b/DataAccess/DTOs/Converters/EllipseNdmPrimitiveFromDTOConvertStrategy.cs @@ -0,0 +1,21 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +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 EllipseNdmPrimitiveFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy = new EllipsePrimitiveUpdateStrategy(); + public override EllipseNdmPrimitive GetNewItem(EllipseNdmPrimitiveDTO source) + { + EllipseNdmPrimitive newItem = new(source.Id); + updateStrategy.Update(newItem, source); + return newItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/ForceCalculatorFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCalculatorFromDTOConvertStrategy.cs new file mode 100644 index 0000000..39f113c --- /dev/null +++ b/DataAccess/DTOs/Converters/ForceCalculatorFromDTOConvertStrategy.cs @@ -0,0 +1,25 @@ +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(); + public override ForceCalculator GetNewItem(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 new file mode 100644 index 0000000..f786db4 --- /dev/null +++ b/DataAccess/DTOs/Converters/ForceCalculatorInputDataFromDTOConvertStrategy.cs @@ -0,0 +1,46 @@ +using DataAccess.DTOs.Converters; +using StructureHelperCommon.Infrastructures.Interfaces; +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(); + + public override ForceCalculatorInputData GetNewItem(ForceCalculatorInputDataDTO source) + { + NewItem = new(source.Id); + updateStrategy.Update(NewItem, source); + ProcessPrimitives(source); + ProcessActions(source); + return NewItem; + } + + 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/ForceCalculatorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCalculatorToDTOConvertStrategy.cs index dc4e0ea..777d653 100644 --- a/DataAccess/DTOs/Converters/ForceCalculatorToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceCalculatorToDTOConvertStrategy.cs @@ -67,7 +67,7 @@ namespace DataAccess.DTOs updateStrategy.Update(target, source); } - private void ProcessForceActions(IHasForceCombinations target, IHasForceCombinations source) + private void ProcessForceActions(IHasForceActions target, IHasForceActions source) { HasForceActionToDTOUpdateStrategy updateStrategy = new() { diff --git a/DataAccess/DTOs/Converters/ForceCombinationListFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCombinationListFromDTOConvertStrategy.cs index 509fb81..f02c79e 100644 --- a/DataAccess/DTOs/Converters/ForceCombinationListFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceCombinationListFromDTOConvertStrategy.cs @@ -43,15 +43,18 @@ namespace DataAccess.DTOs TraceLogger?.AddMessage($"Force combination list name = {source.Name} is starting"); ForceCombinationList newItem = new(source.Id); baseUpdateStrategy.Update(newItem, source); - updateStrategy.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) { DesignForceTuple newDesignTuple = designTupleConvertStrategy.Convert((DesignForceTupleDTO)item); + TraceLogger?.AddMessage($"New Design Tuple Limit state = {newDesignTuple.LimitState}, Calc term = {newDesignTuple.CalcTerm}"); + 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 succesfully"); diff --git a/DataAccess/DTOs/Converters/HasCalculatorsFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/HasCalculatorsFromDTOUpdateStrategy.cs new file mode 100644 index 0000000..1620a34 --- /dev/null +++ b/DataAccess/DTOs/Converters/HasCalculatorsFromDTOUpdateStrategy.cs @@ -0,0 +1,30 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs.Converters +{ + public class HasCalculatorsFromDTOUpdateStrategy : IUpdateStrategy + { + private IConvertStrategy convertStrategy; + + public HasCalculatorsFromDTOUpdateStrategy(IConvertStrategy convertStrategy) + { + this.convertStrategy = convertStrategy; + } + + public void Update(IHasCalculators targetObject, IHasCalculators sourceObject) + { + targetObject.Calculators.Clear(); + foreach (var item in sourceObject.Calculators) + { + var newItem = convertStrategy.Convert(item); + targetObject.Calculators.Add(newItem); + } + } + } +} diff --git a/DataAccess/DTOs/Converters/HasForceActionToDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/HasForceActionToDTOUpdateStrategy.cs index 17c705d..3c4e0b3 100644 --- a/DataAccess/DTOs/Converters/HasForceActionToDTOUpdateStrategy.cs +++ b/DataAccess/DTOs/Converters/HasForceActionToDTOUpdateStrategy.cs @@ -13,7 +13,7 @@ using System.Threading.Tasks; namespace DataAccess.DTOs { - public class HasForceActionToDTOUpdateStrategy : IUpdateStrategy + public class HasForceActionToDTOUpdateStrategy : IUpdateStrategy { private readonly IConvertStrategy forceActionStrategy; @@ -30,7 +30,7 @@ namespace DataAccess.DTOs public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } public IShiftTraceLogger TraceLogger { get; set; } - public void Update(IHasForceCombinations targetObject, IHasForceCombinations sourceObject) + public void Update(IHasForceActions targetObject, IHasForceActions sourceObject) { if (sourceObject.ForceActions is null) { diff --git a/DataAccess/DTOs/Converters/HasForceActionsFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/HasForceActionsFromDTOUpdateStrategy.cs new file mode 100644 index 0000000..dfadc88 --- /dev/null +++ b/DataAccess/DTOs/Converters/HasForceActionsFromDTOUpdateStrategy.cs @@ -0,0 +1,34 @@ +using StructureHelper.Models.Materials; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Services; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class HasForceActionsFromDTOUpdateStrategy : IUpdateStrategy + { + private readonly IConvertStrategy convertStrategy; + + public HasForceActionsFromDTOUpdateStrategy(IConvertStrategy convertStrategy) + { + this.convertStrategy = convertStrategy; + } + + public void Update(IHasForceActions targetObject, IHasForceActions sourceObject) + { + CheckObject.IsNull(targetObject, sourceObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + targetObject.ForceActions.Clear(); + foreach (var item in sourceObject.ForceActions) + { + var newItem = convertStrategy.Convert(item); + targetObject.ForceActions.Add(newItem); + } + } + } +} diff --git a/DataAccess/DTOs/Converters/HasForceActionsProcessLogic.cs b/DataAccess/DTOs/Converters/HasForceActionsProcessLogic.cs new file mode 100644 index 0000000..b076c9d --- /dev/null +++ b/DataAccess/DTOs/Converters/HasForceActionsProcessLogic.cs @@ -0,0 +1,41 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class HasForceActionsProcessLogic : IHasForceActionsProcessLogic + { + private const string convertStarted = " converting is started"; + private const string convertFinished = " converting has been finished succesfully"; + + public IShiftTraceLogger TraceLogger { get; set; } + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + + public IHasForceActions Source { get; set; } + public IHasForceActions Target { get; set; } + public void Process() + { + TraceLogger?.AddMessage("Actions" + convertStarted); + ForceActionsFromDTOConvertStrategy convertStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + DictionaryConvertStrategy convertLogic = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger, + ConvertStrategy = convertStrategy + }; + HasForceActionsFromDTOUpdateStrategy updateStrategy = new(convertLogic); + updateStrategy.Update(Target, Source); + TraceLogger?.AddMessage("Actions" + convertFinished); + } + } +} diff --git a/DataAccess/DTOs/Converters/HasPrimitivesFromDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/HasPrimitivesFromDTOUpdateStrategy.cs new file mode 100644 index 0000000..6d9b1b7 --- /dev/null +++ b/DataAccess/DTOs/Converters/HasPrimitivesFromDTOUpdateStrategy.cs @@ -0,0 +1,33 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; +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 HasPrimitivesFromDTOUpdateStrategy : IUpdateStrategy + { + private IConvertStrategy convertStrategy; + + public HasPrimitivesFromDTOUpdateStrategy(IConvertStrategy convertStrategy) + { + this.convertStrategy = convertStrategy; + } + + public void Update(IHasPrimitives targetObject, IHasPrimitives sourceObject) + { + CheckObject.IsNull(targetObject, sourceObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + targetObject.Primitives.Clear(); + foreach (var item in sourceObject.Primitives) + { + var newItem = convertStrategy.Convert(item); + targetObject.Primitives.Add(newItem); + } + } + } +} diff --git a/DataAccess/DTOs/Converters/HasPrimitivesProcessLogic.cs b/DataAccess/DTOs/Converters/HasPrimitivesProcessLogic.cs new file mode 100644 index 0000000..4f14efb --- /dev/null +++ b/DataAccess/DTOs/Converters/HasPrimitivesProcessLogic.cs @@ -0,0 +1,41 @@ +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 convertFinished = " converting has been finished succesfully"; + + public IHasPrimitives Source { get; set; } + public IHasPrimitives Target { get; set; } + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public void Process() + { + TraceLogger?.AddMessage("Primitives" + convertStarted); + NdmPrimitiveFromDTOConvertStrategy convertStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + DictionaryConvertStrategy convertLogic = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger, + ConvertStrategy = convertStrategy + }; + HasPrimitivesFromDTOUpdateStrategy updateStrategy = new(convertLogic); + updateStrategy.Update(Target, Source); + TraceLogger?.AddMessage($"Primitives {convertFinished}, totally {Target.Primitives.Count} have been obtained"); + } + } +} diff --git a/DataAccess/DTOs/Converters/IHasForceActionsProcessLogic.cs b/DataAccess/DTOs/Converters/IHasForceActionsProcessLogic.cs new file mode 100644 index 0000000..8ecceed --- /dev/null +++ b/DataAccess/DTOs/Converters/IHasForceActionsProcessLogic.cs @@ -0,0 +1,15 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; + +namespace DataAccess.DTOs +{ + 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/IHasPrimitivesProcessLogic.cs b/DataAccess/DTOs/Converters/IHasPrimitivesProcessLogic.cs new file mode 100644 index 0000000..5c8c3da --- /dev/null +++ b/DataAccess/DTOs/Converters/IHasPrimitivesProcessLogic.cs @@ -0,0 +1,16 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperLogics.NdmCalculations.Primitives; + +namespace DataAccess.DTOs.Converters +{ + public interface IHasPrimitivesProcessLogic + { + Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + IHasPrimitives Source { get; set; } + IHasPrimitives Target { get; set; } + IShiftTraceLogger TraceLogger { get; set; } + + void Process(); + } +} \ No newline at end of file diff --git a/DataAccess/DTOs/Converters/NdmPrimitiveFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/NdmPrimitiveFromDTOConvertStrategy.cs new file mode 100644 index 0000000..776638d --- /dev/null +++ b/DataAccess/DTOs/Converters/NdmPrimitiveFromDTOConvertStrategy.cs @@ -0,0 +1,142 @@ +using StructureHelper.Models.Materials; +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; +using System.Windows.Shapes; + +namespace DataAccess.DTOs +{ + public class NdmPrimitiveFromDTOConvertStrategy : ConvertStrategy + { + private const string PrimitiveIs = "Primtive is"; + private IConvertStrategy rebarConvertStrategy; + private IConvertStrategy pointConvertStrategy; + private IConvertStrategy ellipseConvertStrategy; + private IConvertStrategy rectangleConvertStrategy; + + private IHeadMaterial headMaterial; + + public NdmPrimitiveFromDTOConvertStrategy( + IConvertStrategy rebarConvertStrategy, + IConvertStrategy pointConvertStrategy, + IConvertStrategy ellipseConvertStrategy, + IConvertStrategy rectangleConvertStrategy) + { + this.rebarConvertStrategy = rebarConvertStrategy; + this.pointConvertStrategy = pointConvertStrategy; + this.ellipseConvertStrategy = ellipseConvertStrategy; + this.rectangleConvertStrategy = rectangleConvertStrategy; + } + + public NdmPrimitiveFromDTOConvertStrategy() : this( + new RebarNdmPrimitiveFromDTOConvertStrategy(), + new PointNdmPrimitiveFromDTOConvertStrategy(), + new EllipseNdmPrimitiveFromDTOConvertStrategy(), + new RectanglePrimitiveFromDTOConvertStrategy()) + { + + } + + public override INdmPrimitive GetNewItem(INdmPrimitive source) + { + GetMaterial(source.NdmElement.HeadMaterial); + INdmPrimitive newItem = GetNewPrimitive(source); + newItem.NdmElement.HeadMaterial = headMaterial; + return newItem; + } + + private INdmPrimitive GetNewPrimitive(INdmPrimitive source) + { + if (source is RebarNdmPrimitiveDTO rebar) + { + return GetRebar(rebar); + } + if (source is PointNdmPrimitiveDTO point) + { + return GetPoint(point); + } + if (source is EllipseNdmPrimitiveDTO ellipse) + { + return GetEllipse(ellipse); + } + if (source is RectangleNdmPrimitiveDTO rectangle) + { + return GetRectangle(rectangle); + } + string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source); + TraceLogger.AddMessage(errorString, TraceLogStatuses.Error); + throw new StructureHelperException(errorString); + } + + private void GetMaterial(IHeadMaterial source) + { + HeadMaterialFromDTOConvertStrategy convertStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + DictionaryConvertStrategy convertLogic = new(this, convertStrategy); + headMaterial = convertLogic.Convert(source); + } + + private INdmPrimitive GetRebar(RebarNdmPrimitiveDTO rebar) + { + TraceLogger?.AddMessage($"{PrimitiveIs} rebar ndm primitive"); + rebarConvertStrategy.ReferenceDictionary = ReferenceDictionary; + rebarConvertStrategy.TraceLogger = TraceLogger; + RebarNdmPrimitive newItem = rebarConvertStrategy.Convert(rebar); + TraceLogger?.AddMessage($"Primtive has been obtained succesfully, Name = {newItem.Name}"); + newItem.HostPrimitive = GetHostPrimitive(rebar); + return newItem; + } + + private INdmPrimitive GetHostPrimitive(RebarNdmPrimitiveDTO rebar) + { + NdmPrimitiveFromDTOConvertStrategy convertStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + DictionaryConvertStrategy convertLogic = new(this, convertStrategy); + INdmPrimitive hostPrimitive = convertLogic.Convert(rebar.HostPrimitive); + TraceLogger?.AddMessage($"Host primitive Id = {hostPrimitive.Id}, Name = {hostPrimitive.Name}"); + return hostPrimitive; + } + + private INdmPrimitive GetPoint(PointNdmPrimitiveDTO point) + { + TraceLogger?.AddMessage($"{PrimitiveIs} point ndm primitive"); + pointConvertStrategy.ReferenceDictionary = ReferenceDictionary; + pointConvertStrategy.TraceLogger = TraceLogger; + PointNdmPrimitive newItem = pointConvertStrategy.Convert(point); + TraceLogger?.AddMessage($"Primtive has been obtained succesfully, Name = {newItem.Name}"); + return newItem; + } + + private INdmPrimitive GetEllipse(EllipseNdmPrimitiveDTO ellipse) + { + TraceLogger?.AddMessage($"{PrimitiveIs} ellipse ndm primitive"); + ellipseConvertStrategy.ReferenceDictionary = ReferenceDictionary; + ellipseConvertStrategy.TraceLogger = TraceLogger; + EllipseNdmPrimitive newItem = ellipseConvertStrategy.Convert(ellipse); + TraceLogger?.AddMessage($"Primtive has been obtained succesfully, Name = {newItem.Name}"); + return newItem; + } + + private INdmPrimitive GetRectangle(RectangleNdmPrimitiveDTO rectangle) + { + TraceLogger?.AddMessage($"{PrimitiveIs} rectangle ndm primitive"); + rectangleConvertStrategy.ReferenceDictionary = ReferenceDictionary; + rectangleConvertStrategy.TraceLogger = TraceLogger; + RectangleNdmPrimitive newItem = rectangleConvertStrategy.Convert(rectangle); + TraceLogger?.AddMessage($"Primtive has been obtained succesfully, Name = {newItem.Name}"); + return newItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/PointNdmPrimitiveFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/PointNdmPrimitiveFromDTOConvertStrategy.cs new file mode 100644 index 0000000..ce6e503 --- /dev/null +++ b/DataAccess/DTOs/Converters/PointNdmPrimitiveFromDTOConvertStrategy.cs @@ -0,0 +1,23 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +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 PointNdmPrimitiveFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy = new PointNdmPrimitiveUpdateStrategy(); + + + public override PointNdmPrimitive GetNewItem(PointNdmPrimitiveDTO source) + { + PointNdmPrimitive newItem = new(source.Id); + updateStrategy.Update(newItem, source); + return newItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/PointNdmPrimitiveToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/PointNdmPrimitiveToDTOConvertStrategy.cs index 961e7c6..5858100 100644 --- a/DataAccess/DTOs/Converters/PointNdmPrimitiveToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/PointNdmPrimitiveToDTOConvertStrategy.cs @@ -32,7 +32,7 @@ namespace DataAccess.DTOs } public PointNdmPrimitiveToDTOConvertStrategy() : this( - new PointPrimitiveUpdateStrategy(), + new PointNdmPrimitiveUpdateStrategy(), new NdmElementDTOConvertStrategy(), new Point2DToDTOConvertStrategy(), new VisualPropertyToDTOConvertStrategy() diff --git a/DataAccess/DTOs/Converters/RebarNdmPrimitiveFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/RebarNdmPrimitiveFromDTOConvertStrategy.cs new file mode 100644 index 0000000..2a46a4f --- /dev/null +++ b/DataAccess/DTOs/Converters/RebarNdmPrimitiveFromDTOConvertStrategy.cs @@ -0,0 +1,22 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +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 RebarNdmPrimitiveFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy = new RebarNdmPrimitiveUpdateStrategy(); + + public override RebarNdmPrimitive GetNewItem(RebarNdmPrimitiveDTO source) + { + RebarNdmPrimitive newItem = new(source.Id); + updateStrategy.Update(newItem, source); + return newItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/RebarNdmPrimitiveToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/RebarNdmPrimitiveToDTOConvertStrategy.cs index 32ff0bd..87ded6d 100644 --- a/DataAccess/DTOs/Converters/RebarNdmPrimitiveToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/RebarNdmPrimitiveToDTOConvertStrategy.cs @@ -62,7 +62,7 @@ namespace DataAccess.DTOs private RebarNdmPrimitiveDTO GetNewPrimitive(IRebarNdmPrimitive source) { RebarNdmPrimitiveDTO newItem = new() { Id = source.Id }; - //updateStrategy.Update(newItem, source); + updateStrategy.Update(newItem, source); newItem.NdmElement = ndmElementConvertStrategy.Convert(source.NdmElement); newItem.Center = pointConvertStrategy.Convert(source.Center); newItem.VisualProperty = visualPropsConvertStrategy.Convert(source.VisualProperty); diff --git a/DataAccess/DTOs/Converters/RectanglePrimitiveFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/RectanglePrimitiveFromDTOConvertStrategy.cs new file mode 100644 index 0000000..a9b2644 --- /dev/null +++ b/DataAccess/DTOs/Converters/RectanglePrimitiveFromDTOConvertStrategy.cs @@ -0,0 +1,32 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +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 RectanglePrimitiveFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + + public RectanglePrimitiveFromDTOConvertStrategy(IUpdateStrategy updateStrategy) + { + this.updateStrategy = updateStrategy; + } + + public RectanglePrimitiveFromDTOConvertStrategy() : this (new RectanglePrimitiveUpdateStrategy()) + { + + } + + public override RectangleNdmPrimitive GetNewItem(RectangleNdmPrimitiveDTO source) + { + RectangleNdmPrimitive newItem = new(source.Id); + updateStrategy.Update(newItem, source); + return newItem; + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/ProjectDTO.cs b/DataAccess/DTOs/DTOEntities/ProjectDTO.cs index 2c5d22b..95abbe6 100644 --- a/DataAccess/DTOs/DTOEntities/ProjectDTO.cs +++ b/DataAccess/DTOs/DTOEntities/ProjectDTO.cs @@ -17,8 +17,6 @@ namespace DataAccess.DTOs [JsonIgnore] public string FullFileName { get; set; } [JsonIgnore] - public bool IsNewFile { get; set; } - [JsonIgnore] public bool IsActual { get; set; } [JsonProperty("VisualAnalyses")] diff --git a/DataAccess/DTOs/DTOEntities/RebarNdmPrimitiveDTO.cs b/DataAccess/DTOs/DTOEntities/RebarNdmPrimitiveDTO.cs index 9a7817b..eb0baa8 100644 --- a/DataAccess/DTOs/DTOEntities/RebarNdmPrimitiveDTO.cs +++ b/DataAccess/DTOs/DTOEntities/RebarNdmPrimitiveDTO.cs @@ -10,7 +10,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -namespace DataAccess.DTOs.DTOEntities +namespace DataAccess.DTOs { public class RebarNdmPrimitiveDTO : IRebarNdmPrimitive { diff --git a/DataAccess/Infrastructures/FileOpenLogic.cs b/DataAccess/Infrastructures/FileOpenLogic.cs index dedc2ba..a40b67a 100644 --- a/DataAccess/Infrastructures/FileOpenLogic.cs +++ b/DataAccess/Infrastructures/FileOpenLogic.cs @@ -3,6 +3,7 @@ using DataAccess.JsonConverters; using Newtonsoft.Json; using Newtonsoft.Json.Linq; using NLog; +using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Infrastructures.Settings; using StructureHelperCommon.Models; @@ -55,6 +56,13 @@ namespace DataAccess.Infrastructures } string jsonData = File.ReadAllText(fileName); RootObjectDTO? rootObject = GetRootObject(jsonData); + if (rootObject.FileVersion is null) + { + var errorString = "Section of file version is damaged"; + result.Description += errorString; + result.IsValid = false; + return result; + } var fileVersion = rootObject.FileVersion; var checkLogic = new CheckFileVersionLogic() { @@ -69,6 +77,13 @@ namespace DataAccess.Infrastructures } else { + if (rootObject.Project is null) + { + var errorString = "Section of project is damaged"; + result.Description += errorString; + result.IsValid = false; + return result; + } Project project = GetProject(rootObject); project.FullFileName = fileName; result.Project = project; @@ -78,6 +93,10 @@ namespace DataAccess.Infrastructures private Project GetProject(RootObjectDTO? rootObject) { + if (rootObject.Project is null) + { + + } var currentVersion = ProgramSetting.GetCurrentFileVersion(); IFileVersion fileVersion = rootObject.FileVersion; TraceLogger?.AddMessage($"File version is {fileVersion.VersionNumber}.{fileVersion.SubVersionNumber}, current version is {currentVersion.VersionNumber}.{currentVersion.SubVersionNumber}"); @@ -94,7 +113,7 @@ namespace DataAccess.Infrastructures private RootObjectDTO? GetRootObject(string jsonData) { JsonSerializerSettings settings = GetSettings(); - var rootObject = JsonConvert.DeserializeObject(jsonData, settings); + RootObjectDTO rootObject = JsonConvert.DeserializeObject(jsonData, settings); return rootObject; } diff --git a/DataAccess/Infrastructures/FileSaveLogic.cs b/DataAccess/Infrastructures/FileSaveLogic.cs index 549a5a8..b74beee 100644 --- a/DataAccess/Infrastructures/FileSaveLogic.cs +++ b/DataAccess/Infrastructures/FileSaveLogic.cs @@ -19,7 +19,7 @@ namespace DataAccess.Infrastructures public void SaveFile(IProject project) { - if (project.IsNewFile == true) + if (project.FullFileName == string.Empty || project.FullFileName == "") { var result = SelectFileName(project); if (result.IsValid == false) @@ -28,7 +28,6 @@ namespace DataAccess.Infrastructures return; } project.FullFileName = result.FileName; - project.IsNewFile = false; } SaveToFile(project); } @@ -40,7 +39,6 @@ namespace DataAccess.Infrastructures { FilterString = "StructureHelper project file (*.shpj)|*.shpj|All Files (*.*)|*.*", InitialDirectory = project.FullFileName, - }; saver.TraceLogger = TraceLogger; var saveResult = saver.SaveFile(); @@ -58,7 +56,11 @@ namespace DataAccess.Infrastructures File.Delete(project.FullFileName); refDictinary = new Dictionary<(Guid id, Type type), ISaveable>(); ProjectDTO projectDTO = GetProjectDTO(project); - RootObjectDTO rootObject = new() { FileVersion = versionDTO, Project = projectDTO }; + RootObjectDTO rootObject = new() + { + FileVersion = versionDTO, + Project = projectDTO + }; var rootString = Serialize(rootObject, TraceLogger); SaveStringToFile(project, rootString); } @@ -95,7 +97,8 @@ namespace DataAccess.Infrastructures ReferenceDictionary = refDictinary, TraceLogger = TraceLogger }; - return dictionaryConvertStrategy.Convert(project); + ProjectDTO projectDTO = dictionaryConvertStrategy.Convert(project); + return projectDTO; } private FileVersionDTO GetVersionDTO() @@ -116,17 +119,25 @@ namespace DataAccess.Infrastructures } private static string Serialize(object obj, IShiftTraceLogger logger) + { + JsonSerializerSettings settings = GetSerializingSettings(logger); + string serializedObject = JsonConvert.SerializeObject(obj, settings); + return serializedObject; + } + + private static JsonSerializerSettings GetSerializingSettings(IShiftTraceLogger logger) { List<(Type type, string name)> typesNames = TypeBinderListFactory.GetTypeNameList(TypeFileVersion.version_v1); TypeBinder typeBinder = new(typesNames); + List jsonConverters = new List + { + new FileVersionDTOJsonConverter(logger), + new ProjectDTOJsonConverter(logger) + }; + var settings = new JsonSerializerSettings { - Converters = new List - { - // Add other converters if needed - new FileVersionDTOJsonConverter(logger), // Add the specific converter - new ProjectDTOJsonConverter(logger) - }, + Converters = jsonConverters, SerializationBinder = typeBinder, Formatting = Formatting.Indented, PreserveReferencesHandling = PreserveReferencesHandling.All, @@ -134,19 +145,15 @@ namespace DataAccess.Infrastructures TypeNameHandling = TypeNameHandling.All, NullValueHandling = NullValueHandling.Include }; - - return JsonConvert.SerializeObject(obj, settings); + return settings; } public void SaveFileAs(IProject project) { - var tmpIsNew = project.IsNewFile; var tmpFullFileName = project.FullFileName; - project.IsNewFile = true; SaveFile(project); - if (project.IsNewFile == true) + if (project.FullFileName == string.Empty) { - project.IsNewFile = tmpIsNew; project.FullFileName = tmpFullFileName; } } diff --git a/StructureHelper/Windows/MainWindow/Analyses/AnalysesLogic.cs b/StructureHelper/Windows/MainWindow/Analyses/AnalysesLogic.cs index 7336241..7eff43b 100644 --- a/StructureHelper/Windows/MainWindow/Analyses/AnalysesLogic.cs +++ b/StructureHelper/Windows/MainWindow/Analyses/AnalysesLogic.cs @@ -127,6 +127,7 @@ namespace StructureHelper.Windows.MainWindow analysis.Tags = "#New group"; var visualAnalysis = new VisualAnalysis(analysis); ProgramSetting.CurrentProject.VisualAnalyses.Add(visualAnalysis); + //ProgramSetting.SetCurrentProjectToNotActual(); } private void ActionToRun() diff --git a/StructureHelper/Windows/MainWindow/Analyses/FileLogic.cs b/StructureHelper/Windows/MainWindow/Analyses/FileLogic.cs index 2a5eebd..e914866 100644 --- a/StructureHelper/Windows/MainWindow/Analyses/FileLogic.cs +++ b/StructureHelper/Windows/MainWindow/Analyses/FileLogic.cs @@ -58,7 +58,6 @@ namespace StructureHelper.Windows.MainWindow { var newProject = new Project() { - IsNewFile = true, IsActual = true }; ProgramSetting.Projects.Add(newProject); @@ -79,15 +78,19 @@ namespace StructureHelper.Windows.MainWindow CloseFile(project); } } - private bool CloseFile() + public bool CloseFile() { var project = ProgramSetting.CurrentProject; - if (project is null) { return false; } - return CloseFile(project); + if (project is null) + { + return false; + } + bool closingResult = CloseFile(project); + return closingResult; } private bool CloseFile(IProject project) { - if (project.IsActual == true & project.IsNewFile == false) + if (project.IsActual == true) { ProgramSetting.Projects.Remove(project); return true; @@ -97,12 +100,11 @@ namespace StructureHelper.Windows.MainWindow { SaveFile(project); } - if (dialogResult == DialogResult.Cancel) + else if (dialogResult == DialogResult.Cancel) { return false; } project.IsActual = true; - project.IsNewFile = false; CloseFile(project); return true; } @@ -134,7 +136,6 @@ namespace StructureHelper.Windows.MainWindow if (result.IsValid == true) { result.Project.IsActual = true; - result.Project.IsNewFile = false; ProgramSetting.Projects.Clear(); ProgramSetting.Projects.Add(result.Project); } diff --git a/StructureHelper/Windows/MainWindow/AnalysesManagerView.xaml b/StructureHelper/Windows/MainWindow/AnalysesManagerView.xaml index 3ca9f66..a84b9a4 100644 --- a/StructureHelper/Windows/MainWindow/AnalysesManagerView.xaml +++ b/StructureHelper/Windows/MainWindow/AnalysesManagerView.xaml @@ -32,7 +32,7 @@ - +