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

Add beam shear analysis converting from DTO

Browse Source
This commit is contained in:
Evgeny Redikultsev
2025-06-08 20:02:56 +05:00
parent 0d7f47653b
commit 4845a35ba5
28 changed files with 166 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
DataAccess/DTOs/Converters/AnalysisFromDTOConvertStrategy.cs
View File

@@ -1,47 +1,32 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using DataAccess.DTOs.Converters;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Analyses;
using StructureHelperCommon.Models.Loggers;
using StructureHelperLogic.Models.Analyses;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using StructureHelperLogics.Models.Analyses;
namespace DataAccess.DTOs.Converters
namespace DataAccess.DTOs
{
public class AnalysisFromDTOConvertStrategy : IConvertStrategy<IAnalysis, IAnalysis>
public class AnalysisFromDTOConvertStrategy : ConvertStrategy<IAnalysis, IAnalysis>
{
private const string AnalysisIs = "Analysis type is";
private IConvertStrategy<ICrossSectionNdmAnalysis, ICrossSectionNdmAnalysis> convertCrossSectionNdmAnalysisStrategy;
private IConvertStrategy<IVersionProcessor, IVersionProcessor> versionProcessorConvertStrategy;
public AnalysisFromDTOConvertStrategy(IConvertStrategy<ICrossSectionNdmAnalysis, ICrossSectionNdmAnalysis> convertCrossSectionNdmAnalysisStrategy,
IConvertStrategy<IVersionProcessor, IVersionProcessor> versionProcessorConvertStrategy)
public AnalysisFromDTOConvertStrategy()
{
this.convertCrossSectionNdmAnalysisStrategy = convertCrossSectionNdmAnalysisStrategy;
this.versionProcessorConvertStrategy = versionProcessorConvertStrategy;
}
public AnalysisFromDTOConvertStrategy() : this (new CrossSectionNdmAnalysisFromDTOConvertStrategy(),
new VersionProcessorFromDTOConvertStrategy())
public AnalysisFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; }
public IShiftTraceLogger TraceLogger { get; set; }
public IAnalysis Convert(IAnalysis source)
public override IAnalysis GetNewItem(IAnalysis source)
{
try
{
Check();
IAnalysis analysis = GetAnalysis(source);
return analysis;
}
@@ -51,29 +36,51 @@ namespace DataAccess.DTOs.Converters
TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error);
throw;
}
}
private IAnalysis GetAnalysis(IAnalysis source)
{
IAnalysis newItem;
if (source is ICrossSectionNdmAnalysis crossSectionNdmAnalysis)
{
newItem = GetCrossSectionNdmAnalysis(crossSectionNdmAnalysis);
GetCrossSectionNdmAnalysis(crossSectionNdmAnalysis);
}
else if (source is IBeamShearAnalysis beamShearAnalysis)
{
GetBeamShearAnalysis(beamShearAnalysis);
}
else
{
string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source);
TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error);
throw new StructureHelperException(errorString);
}
newItem.VersionProcessor = GetVersionProcessor(source.VersionProcessor);
return newItem;
NewItem.VersionProcessor = GetVersionProcessor(source.VersionProcessor);
return NewItem;
}
private void GetBeamShearAnalysis(IBeamShearAnalysis beamShearAnalysis)
{
TraceLogger?.AddMessage(AnalysisIs + " beam shear Analysis", TraceLogStatuses.Debug);
TraceLogger?.AddMessage("Beam shear analysis converting has been started", TraceLogStatuses.Debug);
var convertStrategy = new DictionaryConvertStrategy<IBeamShearAnalysis, IBeamShearAnalysis>
(this, new BeamShearAnalysisFromDTOConvertStrategy(this));
NewItem = convertStrategy.Convert(beamShearAnalysis);
TraceLogger?.AddMessage("Beam shear analysis converting has been finished succesfully", TraceLogStatuses.Debug);
}
private void GetCrossSectionNdmAnalysis(ICrossSectionNdmAnalysis source)
{
TraceLogger?.AddMessage(AnalysisIs + " Cross-Section Ndm Analysis", TraceLogStatuses.Debug);
TraceLogger?.AddMessage("Cross-Section Ndm Analysis converting has been started", TraceLogStatuses.Debug);
var convertStrategy = new DictionaryConvertStrategy<ICrossSectionNdmAnalysis, ICrossSectionNdmAnalysis>
(this, new CrossSectionNdmAnalysisFromDTOConvertStrategy(this));
NewItem = convertStrategy.Convert(source);
TraceLogger?.AddMessage("Cross-Section Ndm Analysis converting has been finished successfully", TraceLogStatuses.Debug);
}
private IVersionProcessor GetVersionProcessor(IVersionProcessor source)
{
TraceLogger?.AddMessage("Version processor converting is started", TraceLogStatuses.Service);
versionProcessorConvertStrategy ??= new VersionProcessorFromDTOConvertStrategy();
versionProcessorConvertStrategy.ReferenceDictionary = ReferenceDictionary;
versionProcessorConvertStrategy.TraceLogger = TraceLogger;
IVersionProcessor versionProcessor = versionProcessorConvertStrategy.Convert(source);
@@ -81,22 +88,5 @@ namespace DataAccess.DTOs.Converters
return versionProcessor;
}
private ICrossSectionNdmAnalysis GetCrossSectionNdmAnalysis(ICrossSectionNdmAnalysis source)
{
TraceLogger?.AddMessage(AnalysisIs + " Cross-Section Ndm Analysis", TraceLogStatuses.Service);
TraceLogger?.AddMessage("Cross-Section Ndm Analysis converting is started", TraceLogStatuses.Service);
convertCrossSectionNdmAnalysisStrategy.ReferenceDictionary = ReferenceDictionary;
convertCrossSectionNdmAnalysisStrategy.TraceLogger = TraceLogger;
var convertLogic = new DictionaryConvertStrategy<ICrossSectionNdmAnalysis, ICrossSectionNdmAnalysis>(this, convertCrossSectionNdmAnalysisStrategy);
ICrossSectionNdmAnalysis crossSectionNdmAnalysis = convertLogic.Convert(source);
TraceLogger?.AddMessage("Cross-Section Ndm Analysis converting has been finished successfully", TraceLogStatuses.Service);
return crossSectionNdmAnalysis;
}
private void Check()
{
var checkLogic = new CheckConvertLogic<IAnalysis, IAnalysis>(this);
checkLogic.Check();
}
}
}

29
DataAccess/DTOs/Converters/BeamShears/BeamShearAnalysisFromDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,29 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.Models.Analyses;
namespace DataAccess.DTOs
{
public class BeamShearAnalysisFromDTOConvertStrategy : ConvertStrategy<IBeamShearAnalysis, IBeamShearAnalysis>
{
private IUpdateStrategy<IBeamShearAnalysis> updateStrategy;
public BeamShearAnalysisFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
public override IBeamShearAnalysis GetNewItem(IBeamShearAnalysis source)
{
ChildClass = this;
GetAnalysis(source);
return NewItem;
}
private void GetAnalysis(IBeamShearAnalysis source)
{
updateStrategy ??= new BeamShearAnalysisUpdateStrategy();
BeamShearAnalysis beamShearAnalysis = new(source.Id);
updateStrategy.Update(beamShearAnalysis, source);
NewItem = beamShearAnalysis;
}
}
}

48
DataAccess/DTOs/Converters/DateVersionFromDTOConvertStrategy.cs
View File

@@ -10,62 +10,34 @@ using System.Threading.Tasks;
namespace DataAccess.DTOs
{
public class DateVersionFromDTOConvertStrategy : IConvertStrategy<IDateVersion, IDateVersion>
public class DateVersionFromDTOConvertStrategy : ConvertStrategy<IDateVersion, IDateVersion>
{
private IUpdateStrategy<IDateVersion> updateStrategy;
private IConvertStrategy<ISaveable, ISaveable> convertStrategy;
private DictionaryConvertStrategy<ISaveable, ISaveable> convertLogic;
private IConvertStrategy<ISaveable, ISaveable> convertLogic;
public DateVersionFromDTOConvertStrategy(IUpdateStrategy<IDateVersion> updateStrategy,
IConvertStrategy<ISaveable, ISaveable> convertStrategy)
public override IDateVersion GetNewItem(IDateVersion source)
{
this.updateStrategy = updateStrategy;
this.convertStrategy = convertStrategy;
}
public DateVersionFromDTOConvertStrategy() : this (
new DateVersionUpdateStrategy(),
new VersionItemFromDTOConvertStrategy())
{
}
public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; }
public IShiftTraceLogger TraceLogger { get; set; }
public IDateVersion Convert(IDateVersion source)
{
try
{
Check();
return GetDateVersion(source);
}
catch (Exception ex)
{
TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error);
TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error);
throw;
}
ChildClass = this;
return GetDateVersion(source);
}
private DateVersion GetDateVersion(IDateVersion source)
{
TraceLogger?.AddMessage("Date version converting is started", TraceLogStatuses.Service);
InitializeStrategies();
DateVersion newItem = new(source.Id);
updateStrategy.Update(newItem, source);
convertStrategy.ReferenceDictionary = ReferenceDictionary;
convertStrategy.TraceLogger = TraceLogger;
convertLogic = new DictionaryConvertStrategy<ISaveable, ISaveable>(this, convertStrategy);
newItem.AnalysisVersion = convertLogic.Convert(source.AnalysisVersion);
TraceLogger?.AddMessage($"Date version date = {newItem.DateTime} converting has been finished", TraceLogStatuses.Service);
return newItem;
}
private void Check()
private void InitializeStrategies()
{
var checkLogic = new CheckConvertLogic<IDateVersion, IDateVersion>(this);
checkLogic.Check();
updateStrategy ??= new DateVersionUpdateStrategy();
convertLogic = new DictionaryConvertStrategy<ISaveable, ISaveable>
(this, new VersionItemFromDTOConvertStrategy(this));
}
}
}

0
DataAccess/DTOs/Converters/FRMaterialFromDTOConvertStrategy.cs → DataAccess/DTOs/Converters/Materials/FRMaterialFromDTOConvertStrategy.cs
View File

0
DataAccess/DTOs/Converters/FRMaterialToDTOConvertStrategy.cs → DataAccess/DTOs/Converters/Materials/FRMaterialToDTOConvertStrategy.cs
View File

0
DataAccess/DTOs/Converters/IMaterialSafetyFactorDTOLogic.cs → DataAccess/DTOs/Converters/Materials/IMaterialSafetyFactorDTOLogic.cs
View File

0
DataAccess/DTOs/Converters/LibMaterialDTOUpdateStrategy.cs → DataAccess/DTOs/Converters/Materials/LibMaterialDTOUpdateStrategy.cs
View File

0
DataAccess/DTOs/Converters/LibMaterialToDTOConvertStrategy.cs → DataAccess/DTOs/Converters/Materials/LibMaterialToDTOConvertStrategy.cs
View File

0
DataAccess/DTOs/Converters/MaterialSafetyFactorsFromDTOLogic.cs → DataAccess/DTOs/Converters/Materials/MaterialSafetyFactorsFromDTOLogic.cs
View File

54
DataAccess/DTOs/Converters/NdmCrossSections/CrossSectionNdmAnalysisFromDTOConvertStrategy.cs
View File

@@ -1,64 +1,34 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Analyses;
using StructureHelperCommon.Models.Loggers;
using StructureHelperLogic.Models.Analyses;
using StructureHelperLogics.Models.Analyses;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataAccess.DTOs.Converters
{
public class CrossSectionNdmAnalysisFromDTOConvertStrategy : IConvertStrategy<ICrossSectionNdmAnalysis, ICrossSectionNdmAnalysis>
public class CrossSectionNdmAnalysisFromDTOConvertStrategy : ConvertStrategy<ICrossSectionNdmAnalysis, ICrossSectionNdmAnalysis>
{
private IUpdateStrategy<ICrossSectionNdmAnalysis> updateStrategy;
public CrossSectionNdmAnalysisFromDTOConvertStrategy(IUpdateStrategy<ICrossSectionNdmAnalysis> updateStrategy)
public CrossSectionNdmAnalysisFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
this.updateStrategy = updateStrategy;
}
public CrossSectionNdmAnalysisFromDTOConvertStrategy() : this(new CrossSectionNdmAnalysisUpdateStrategy())
public override ICrossSectionNdmAnalysis GetNewItem(ICrossSectionNdmAnalysis source)
{
ChildClass = this;
GetAnalysis(source);
return NewItem;
}
public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; }
public IShiftTraceLogger TraceLogger { get; set; }
public ICrossSectionNdmAnalysis Convert(ICrossSectionNdmAnalysis source)
private void GetAnalysis(ICrossSectionNdmAnalysis source)
{
try
{
Check();
ICrossSectionNdmAnalysis newItem = GetCrossSectionNDMAnalysis(source);
return newItem;
}
catch (Exception ex)
{
TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error);
TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error);
throw;
}
TraceLogger?.AddMessage("Cross-section analysis converting has been started");
updateStrategy ??= new CrossSectionNdmAnalysisUpdateStrategy();
NewItem = new CrossSectionNdmAnalysis(source.Id);
updateStrategy.Update(NewItem, source);
TraceLogger?.AddMessage("Cross-section analysis has been finished successfully");
}
private ICrossSectionNdmAnalysis GetCrossSectionNDMAnalysis(ICrossSectionNdmAnalysis source)
{
TraceLogger?.AddMessage("Cross-section sonverting is started");
CrossSectionNdmAnalysis newItem = new(source.Id);
updateStrategy.Update(newItem, source);
TraceLogger?.AddMessage("Cross-section analysis was obtained successfully");
return newItem;
}
private void Check()
{
var checkLogic = new CheckConvertLogic<ICrossSectionNdmAnalysis, ICrossSectionNdmAnalysis>(this);
checkLogic.Check();
}
}
}

0
DataAccess/DTOs/Converters/HasPrimitivesFromDTOUpdateStrategy.cs → DataAccess/DTOs/Converters/NdmCrossSections/HasPrimitivesFromDTOUpdateStrategy.cs
View File

0
DataAccess/DTOs/Converters/HasPrimitivesProcessLogic.cs → DataAccess/DTOs/Converters/NdmCrossSections/HasPrimitivesProcessLogic.cs
View File

0
DataAccess/DTOs/Converters/HasPrimitivesToDTOUpdateStrategy.cs → DataAccess/DTOs/Converters/NdmCrossSections/HasPrimitivesToDTOUpdateStrategy.cs
View File

0
DataAccess/DTOs/Converters/UserCrackInputDataFromDTOConvertStrategy.cs → DataAccess/DTOs/Converters/NdmCrossSections/UserCrackInputDataFromDTOConvertStrategy.cs
View File

0
DataAccess/DTOs/Converters/UserCrackInputDataToDTOConvertStrategy.cs → DataAccess/DTOs/Converters/NdmCrossSections/UserCrackInputDataToDTOConvertStrategy.cs
View File

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

@@ -36,7 +36,7 @@ namespace DataAccess.DTOs
public override Project GetNewItem(ProjectDTO source)
{
TraceLogger?.AddMessage("Converting of project is started");
TraceLogger?.AddMessage("Converting of project has been started");
Project newItem = new(source.Id);
List<IVisualAnalysis> analyses = GetAnalyses(source, newItem);
newItem.VisualAnalyses.Clear();

8
DataAccess/DTOs/Converters/ProjectToDTOConvertStrategy.cs
View File

@@ -7,7 +7,7 @@ namespace DataAccess.DTOs
public class ProjectToDTOConvertStrategy : ConvertStrategy<ProjectDTO, IProject>
{
private IUpdateStrategy<IProject> updateStrategy;
private DictionaryConvertStrategy<VisualAnalysisDTO, IVisualAnalysis> convertLogic;
private IConvertStrategy<VisualAnalysisDTO, IVisualAnalysis> convertLogic;
public ProjectToDTOConvertStrategy()
@@ -17,7 +17,7 @@ namespace DataAccess.DTOs
public ProjectToDTOConvertStrategy(
IUpdateStrategy<IProject> updateStrategy,
DictionaryConvertStrategy<VisualAnalysisDTO, IVisualAnalysis> convertLogic)
IConvertStrategy<VisualAnalysisDTO, IVisualAnalysis> convertLogic)
{
this.updateStrategy = updateStrategy;
this.convertLogic = convertLogic;
@@ -41,9 +41,7 @@ namespace DataAccess.DTOs
{
updateStrategy ??= new ProjectUpdateStrategy();
convertLogic ??= new DictionaryConvertStrategy<VisualAnalysisDTO, IVisualAnalysis>
(this,
new VisualAnalysisToDTOConvertStrategy(ReferenceDictionary, TraceLogger)
);
(this, new VisualAnalysisToDTOConvertStrategy(this));
}
}
}

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

@@ -1,42 +1,24 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Loggers;
using StructureHelperLogics.Models.BeamShears;
using StructureHelperLogics.Models.CrossSections;
namespace DataAccess.DTOs
{
public class VersionItemFromDTOConvertStrategy : IConvertStrategy<ISaveable, ISaveable>
public class VersionItemFromDTOConvertStrategy : ConvertStrategy<ISaveable, ISaveable>
{
private const string AnalysisIs = "Analysis type is";
private IConvertStrategy<ICrossSection, ICrossSection> crossSectionConvertStrategy;
public VersionItemFromDTOConvertStrategy(IConvertStrategy<ICrossSection, ICrossSection> crossSectionConvertStrategy)
public VersionItemFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
this.crossSectionConvertStrategy = crossSectionConvertStrategy;
}
public VersionItemFromDTOConvertStrategy() : this (new CrossSectionFromDTOConvertStrategy())
public override ISaveable GetNewItem(ISaveable source)
{
}
public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; }
public IShiftTraceLogger TraceLogger { get; set; }
public ISaveable Convert(ISaveable source)
{
try
{
Check();
return GetNewAnalysis(source);
}
catch (Exception ex)
{
TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error);
TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error);
throw;
}
ChildClass = this;
return GetNewAnalysis(source);
}
private ISaveable GetNewAnalysis(ISaveable source)
@@ -46,6 +28,10 @@ namespace DataAccess.DTOs
{
newItem = ProcessCrossSection(crossSection);
}
else if (source is IBeamShear beamShear)
{
newItem = ProcessBeamShear(beamShear);
}
else
{
string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source);
@@ -56,10 +42,16 @@ namespace DataAccess.DTOs
return newItem;
}
private ISaveable ProcessBeamShear(IBeamShear beamShear)
{
throw new NotImplementedException();
}
private ICrossSection ProcessCrossSection(ICrossSection source)
{
TraceLogger?.AddMessage(AnalysisIs + " Cross-Section", TraceLogStatuses.Service);
TraceLogger?.AddMessage("Cross-Section converting is started", TraceLogStatuses.Service);
crossSectionConvertStrategy ??= new CrossSectionFromDTOConvertStrategy();
crossSectionConvertStrategy.ReferenceDictionary = ReferenceDictionary;
crossSectionConvertStrategy.TraceLogger = TraceLogger;
var convertLogic = new DictionaryConvertStrategy<ICrossSection, ICrossSection>(this, crossSectionConvertStrategy);
@@ -67,11 +59,5 @@ namespace DataAccess.DTOs
TraceLogger?.AddMessage("Cross-Section converting has been finished successfully", TraceLogStatuses.Service);
return newItem;
}
private void Check()
{
var checkLogic = new CheckConvertLogic<ISaveable, ISaveable>(this);
checkLogic.Check();
}
}
}

41
DataAccess/DTOs/Converters/VersionProcessorFromDTOConvertStrategy.cs
View File

@@ -10,45 +10,20 @@ using System.Threading.Tasks;
namespace DataAccess.DTOs
{
public class VersionProcessorFromDTOConvertStrategy : IConvertStrategy<IVersionProcessor, IVersionProcessor>
public class VersionProcessorFromDTOConvertStrategy : ConvertStrategy<IVersionProcessor, IVersionProcessor>
{
private IConvertStrategy<IDateVersion, IDateVersion> dateVersionConvertStrategy;
private ICheckConvertLogic<IVersionProcessor, IVersionProcessor> checkLogic;
public VersionProcessorFromDTOConvertStrategy(
IConvertStrategy<IDateVersion, IDateVersion> dateVersionConvertStrategy)
public override IVersionProcessor GetNewItem(IVersionProcessor source)
{
this.dateVersionConvertStrategy = dateVersionConvertStrategy;
this.checkLogic = checkLogic;
}
public VersionProcessorFromDTOConvertStrategy() : this(new DateVersionFromDTOConvertStrategy())
{
}
public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; }
public IShiftTraceLogger TraceLogger { get; set; }
public IVersionProcessor Convert(IVersionProcessor source)
{
try
{
Check();
IVersionProcessor versionProcessor = GetVersionProcessor(source);
return versionProcessor;
}
catch (Exception ex)
{
TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error);
TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error);
throw;
}
ChildClass = this;
return GetVersionProcessor(source);
}
private IVersionProcessor GetVersionProcessor(IVersionProcessor source)
{
TraceLogger?.AddMessage("Version processor converting is started", TraceLogStatuses.Debug);
dateVersionConvertStrategy ??= new DateVersionFromDTOConvertStrategy();
IVersionProcessor newItem = new VersionProcessor(source.Id);
TraceLogger?.AddMessage($"Source version processor has {source.Versions.Count} version(s)", TraceLogStatuses.Service);
dateVersionConvertStrategy.ReferenceDictionary = ReferenceDictionary;
@@ -62,11 +37,5 @@ namespace DataAccess.DTOs
TraceLogger?.AddMessage("Version processor has been converted successfully", TraceLogStatuses.Service);
return newItem;
}
private void Check()
{
var checkLogic = new CheckConvertLogic<IVersionProcessor, IVersionProcessor>(this);
checkLogic.Check();
}
}
}

4
DataAccess/DTOs/Converters/VisualAnalysisToDTOConvertStrategy.cs
View File

@@ -28,6 +28,10 @@ namespace DataAccess.DTOs
{
}
public VisualAnalysisToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
private VisualAnalysisDTO GetNewAnalysis(IVisualAnalysis source)
{
InitializeStrategies();