public void Create_StringPropertiesDoNotShareReference() { // Setup const string originalName = "name"; const string originalComments = "comments"; var section = new AssessmentSection(AssessmentSectionComposition.Dike) { Name = originalName, Comments = { Body = originalComments } }; var registry = new PersistenceRegistry(); // Call AssessmentSectionEntity entity = section.Create(registry); // Assert Assert.AreNotSame(originalName, entity.Name, "To create stable binary representations/fingerprints, it's really important that strings are not shared."); Assert.AreNotSame(originalComments, entity.Comments, "To create stable binary representations/fingerprints, it's really important that strings are not shared."); Assert.AreEqual(originalName, entity.Name); Assert.AreEqual(originalComments, entity.Comments); }
private static void AddEntityForReferenceLine(AssessmentSection section, AssessmentSectionEntity entity) { if (section.ReferenceLine.Points.Any()) { entity.ReferenceLinePointXml = new Point2DCollectionXmlSerializer().ToXml(section.ReferenceLine.Points); } }
private static void ReadHydraulicBoundaryLocationCalculations(this AssessmentSectionEntity entity, IAssessmentSection assessmentSection, ReadConversionCollector collector) { entity.HydraulicLocationCalculationCollectionEntity1.Read(assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, collector); entity.HydraulicLocationCalculationCollectionEntity.Read(assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability, collector); }
private static void AddHydraulicLocationCalculationEntities(AssessmentSection assessmentSection, AssessmentSectionEntity entity, PersistenceRegistry registry) { entity.HydraulicLocationCalculationCollectionEntity1 = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Create(registry); entity.HydraulicLocationCalculationCollectionEntity = assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.Create(registry); }
private static void ReadReferenceLine(this AssessmentSectionEntity entity, IAssessmentSection assessmentSection) { if (entity.ReferenceLinePointXml != null) { Point2D[] points = new Point2DCollectionXmlSerializer().FromXml(entity.ReferenceLinePointXml); assessmentSection.ReferenceLine.SetGeometry(points); } }
private static void ReadSpecificFailureMechanisms(this AssessmentSectionEntity entity, IAssessmentSection assessmentSection, ReadConversionCollector collector) { IEnumerable <SpecificFailureMechanismEntity> specificFailureMechanismEntities = entity.SpecificFailureMechanismEntities .OrderBy(e => e.Order); assessmentSection.SpecificFailureMechanisms.AddRange(specificFailureMechanismEntities.Select(e => e.Read(collector)).ToArray()); }
private static void ReadBackgroundData(this AssessmentSectionEntity entity, IAssessmentSection assessmentSection) { BackgroundData readBackgroundData = entity.BackgroundDataEntities.Single().Read(); BackgroundData backgroundData = assessmentSection.BackgroundData; backgroundData.IsVisible = readBackgroundData.IsVisible; backgroundData.Transparency = readBackgroundData.Transparency; backgroundData.Name = readBackgroundData.Name; backgroundData.Configuration = readBackgroundData.Configuration; }
private static void AddHydraulicLocationCalculationForTargetProbabilityCollectionEntities( List <HydraulicBoundaryLocationCalculationsForTargetProbability> hydraulicBoundaryLocationCalculationsForTargetProbabilities, HydraulicBoundaryLocationCalculationType calculationType, AssessmentSectionEntity entity, PersistenceRegistry registry) { for (int i = 0; i < hydraulicBoundaryLocationCalculationsForTargetProbabilities.Count; i++) { entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities.Add( hydraulicBoundaryLocationCalculationsForTargetProbabilities[i].Create(calculationType, i, registry)); } }
/// <summary> /// Read the <see cref="AssessmentSectionEntity"/> and use the information to construct a <see cref="AssessmentSection"/>. /// </summary> /// <param name="entity">The <see cref="AssessmentSectionEntity"/> to create <see cref="AssessmentSection"/> for.</param> /// <param name="collector">The object keeping track of read operations.</param> /// <returns>A new <see cref="AssessmentSection"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="collector"/> is <c>null</c>.</exception> internal static AssessmentSection Read(this AssessmentSectionEntity entity, ReadConversionCollector collector) { if (collector == null) { throw new ArgumentNullException(nameof(collector)); } var assessmentSection = new AssessmentSection((AssessmentSectionComposition)entity.Composition, entity.MaximumAllowableFloodingProbability, entity.SignalFloodingProbability) { Id = entity.Id, Name = entity.Name, Comments = { Body = entity.Comments }, FailureMechanismContribution = { NormativeProbabilityType = (NormativeProbabilityType)entity.NormativeProbabilityType } }; entity.ReadBackgroundData(assessmentSection); entity.ReadHydraulicDatabase(assessmentSection, collector); entity.ReadHydraulicLocationCalculationsForTargetProbabilities(assessmentSection, collector); entity.ReadReferenceLine(assessmentSection); entity.ReadPipingFailureMechanism(assessmentSection, collector); entity.ReadGrassCoverErosionInwardsFailureMechanism(assessmentSection, collector); entity.ReadHeightStructuresFailureMechanism(assessmentSection, collector); entity.ReadWaterPressureAsphaltCoverFailureMechanism(assessmentSection, collector); entity.ReadClosingStructuresFailureMechanism(assessmentSection, collector); entity.ReadMacroStabilityInwardsFailureMechanism(assessmentSection, collector); entity.ReadWaveImpactAsphaltCoverFailureMechanism(assessmentSection, collector); entity.ReadGrassCoverErosionOutwardsFailureMechanism(assessmentSection, collector); entity.ReadGrassCoverSlipOffInwardsFailureMechanism(assessmentSection, collector); entity.ReadGrassCoverSlipOffOutwardsFailureMechanism(assessmentSection, collector); entity.ReadMicrostabilityFailureMechanism(assessmentSection, collector); entity.ReadPipingStructureFailureMechanism(assessmentSection, collector); entity.ReadDuneErosionFailureMechanism(assessmentSection, collector); entity.ReadStabilityStoneCoverFailureMechanism(assessmentSection, collector); entity.ReadStabilityPointStructuresFailureMechanism(assessmentSection, collector); entity.ReadSpecificFailureMechanisms(assessmentSection, collector); return(assessmentSection); }
/// <summary> /// Creates a <see cref="AssessmentSectionEntity"/> based on the information of the <see cref="AssessmentSection"/>. /// </summary> /// <param name="section">The section to create a database entity for.</param> /// <param name="registry">The object keeping track of create operations.</param> /// <returns>A new <see cref="AssessmentSectionEntity"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception> internal static AssessmentSectionEntity Create(this AssessmentSection section, PersistenceRegistry registry) { if (registry == null) { throw new ArgumentNullException(nameof(registry)); } FailureMechanismContribution contribution = section.FailureMechanismContribution; var entity = new AssessmentSectionEntity { Id = section.Id.DeepClone(), Name = section.Name.DeepClone(), Composition = Convert.ToByte(section.Composition), Comments = section.Comments.Body.DeepClone(), MaximumAllowableFloodingProbability = contribution.MaximumAllowableFloodingProbability, SignalFloodingProbability = contribution.SignalFloodingProbability, NormativeProbabilityType = Convert.ToByte(contribution.NormativeProbabilityType) }; AddEntityForHydraulicDatabase(section.HydraulicBoundaryDatabase, entity, registry); AddHydraulicLocationCalculationEntities(section, entity, registry); AddHydraulicLocationCalculationForTargetProbabilityCollectionEntities(section, entity, registry); AddEntityForReferenceLine(section, entity); entity.BackgroundDataEntities.Add(section.BackgroundData.Create()); entity.FailureMechanismEntities.Add(section.Piping.Create(registry)); entity.FailureMechanismEntities.Add(section.GrassCoverErosionInwards.Create(registry)); entity.FailureMechanismEntities.Add(section.HeightStructures.Create(registry)); entity.FailureMechanismEntities.Add(section.WaterPressureAsphaltCover.Create(registry)); entity.FailureMechanismEntities.Add(section.ClosingStructures.Create(registry)); entity.FailureMechanismEntities.Add(section.MacroStabilityInwards.Create(registry)); entity.FailureMechanismEntities.Add(section.WaveImpactAsphaltCover.Create(registry)); entity.FailureMechanismEntities.Add(section.GrassCoverErosionOutwards.Create(registry)); entity.FailureMechanismEntities.Add(section.GrassCoverSlipOffInwards.Create(registry)); entity.FailureMechanismEntities.Add(section.GrassCoverSlipOffOutwards.Create(registry)); entity.FailureMechanismEntities.Add(section.Microstability.Create(registry)); entity.FailureMechanismEntities.Add(section.PipingStructure.Create(registry)); entity.FailureMechanismEntities.Add(section.StabilityStoneCover.Create(registry)); entity.FailureMechanismEntities.Add(section.DuneErosion.Create(registry)); entity.FailureMechanismEntities.Add(section.StabilityPointStructures.Create(registry)); AddSpecificFailureMechanismEntities(section, entity, registry); return(entity); }
public void Create_HydraulicBoundaryDatabaseNotLinked_SetsExpectedPropertiesToEntity() { // Setup var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); assessmentSection.SetHydraulicBoundaryLocationCalculations(assessmentSection.HydraulicBoundaryDatabase.Locations); var registry = new PersistenceRegistry(); // Call AssessmentSectionEntity entity = assessmentSection.Create(registry); // Assert CollectionAssert.IsEmpty(entity.HydraulicBoundaryDatabaseEntities); CollectionAssert.IsEmpty(entity.HydraulicLocationEntities); AssertHydraulicLocationCalculationCollectionEntities(assessmentSection, entity); }
private static void ReadHydraulicDatabase(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector) { HydraulicBoundaryDatabaseEntity hydraulicBoundaryDatabaseEntity = entity.HydraulicBoundaryDatabaseEntities.SingleOrDefault(); if (hydraulicBoundaryDatabaseEntity != null) { HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase; hydraulicBoundaryDatabaseEntity.Read(hydraulicBoundaryDatabase); HydraulicBoundaryLocation[] readHydraulicBoundaryLocations = entity.HydraulicLocationEntities .OrderBy(hl => hl.Order) .Select(hle => hle.Read(collector)) .ToArray(); hydraulicBoundaryDatabase.Locations.AddRange(readHydraulicBoundaryLocations); assessmentSection.SetHydraulicBoundaryLocationCalculations(readHydraulicBoundaryLocations); entity.ReadHydraulicBoundaryLocationCalculations(assessmentSection, collector); } }
private static void ReadHydraulicLocationCalculationsForTargetProbabilities(this AssessmentSectionEntity entity, IAssessmentSection assessmentSection, ReadConversionCollector collector) { IEnumerable <HydraulicLocationCalculationForTargetProbabilityCollectionEntity> waterLevelHydraulicLocationCalculationForTargetProbabilityCollectionEntities = entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities .Where(e => e.HydraulicBoundaryLocationCalculationType == (short)HydraulicBoundaryLocationCalculationType.WaterLevel) .OrderBy(e => e.Order); assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.AddRange(waterLevelHydraulicLocationCalculationForTargetProbabilityCollectionEntities.Select(e => e.Read(collector)) .ToArray()); IEnumerable <HydraulicLocationCalculationForTargetProbabilityCollectionEntity> waveHeightHydraulicLocationCalculationForTargetProbabilityCollectionEntities = entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities .Where(e => e.HydraulicBoundaryLocationCalculationType == (short)HydraulicBoundaryLocationCalculationType.WaveHeight) .OrderBy(e => e.Order); assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.AddRange(waveHeightHydraulicLocationCalculationForTargetProbabilityCollectionEntities.Select(e => e.Read(collector)) .ToArray()); }
public void Read_WithAssessmentSection_ReturnsNewProjectWithAssessmentSection() { // Setup AssessmentSectionEntity assessmentSectionEntity = CreateAssessmentSectionEntity(1); var entity = new ProjectEntity { Description = "testName", AssessmentSectionEntities = { assessmentSectionEntity } }; // Call RiskeerProject project = entity.Read(new ReadConversionCollector()); // Assert Assert.AreEqual(entity.Description, project.Description); Assert.AreEqual(assessmentSectionEntity.Name, project.AssessmentSection.Name); }
public void Create_WithReferenceLine_AddsReferenceLinePointEntities() { // Setup var points = new[] { new Point2D(1, 0), new Point2D(2, 3), new Point2D(5, 3) }; var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); assessmentSection.ReferenceLine.SetGeometry(points); var registry = new PersistenceRegistry(); // Call AssessmentSectionEntity entity = assessmentSection.Create(registry); // Assert string expectedXml = new Point2DCollectionXmlSerializer().ToXml(points); Assert.AreEqual(expectedXml, entity.ReferenceLinePointXml); }
private static void AddEntityForHydraulicDatabase(HydraulicBoundaryDatabase hydraulicBoundaryDatabase, AssessmentSectionEntity entity, PersistenceRegistry registry) { if (hydraulicBoundaryDatabase.IsLinked()) { entity.HydraulicBoundaryDatabaseEntities.Add(hydraulicBoundaryDatabase.Create()); for (var i = 0; i < hydraulicBoundaryDatabase.Locations.Count; i++) { HydraulicBoundaryLocation hydraulicBoundaryLocation = hydraulicBoundaryDatabase.Locations[i]; entity.HydraulicLocationEntities.Add(hydraulicBoundaryLocation.Create(registry, i)); } } }
private static void ReadMacroStabilityInwardsFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector) { FailureMechanismEntity macroStabilityInwardsFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.MacroStabilityInwards); macroStabilityInwardsFailureMechanismEntity?.ReadAsMacroStabilityInwardsFailureMechanism(assessmentSection.MacroStabilityInwards, collector); }
private static void AddSpecificFailureMechanismEntities(AssessmentSection section, AssessmentSectionEntity entity, PersistenceRegistry registry) { var i = 0; foreach (SpecificFailureMechanism specificFailureMechanism in section.SpecificFailureMechanisms) { entity.SpecificFailureMechanismEntities.Add(specificFailureMechanism.Create(registry, i++)); } }
public void Create_WithCollector_ReturnsAssessmentSectionEntityWithCompositionAndFailureMechanisms(AssessmentSectionComposition assessmentSectionComposition) { // Setup const string testId = "testId"; const string testName = "testName"; const string comments = "Some text"; const double maximumAllowableFloodingProbability = 0.05; const double signalFloodingProbability = 0.02; var random = new Random(65); const string mapDataName = "map data name"; const double transparency = 0.3; const bool isVisible = true; const BackgroundDataType backgroundType = BackgroundDataType.Wmts; var normativeProbabilityType = random.NextEnumValue <NormativeProbabilityType>(); IEnumerable <SpecificFailureMechanism> specificFailureMechanisms = Enumerable.Repeat(new SpecificFailureMechanism(), random.Next(1, 10)) .ToArray(); var assessmentSection = new AssessmentSection(assessmentSectionComposition) { Id = testId, Name = testName, Comments = { Body = comments }, FailureMechanismContribution = { MaximumAllowableFloodingProbability = maximumAllowableFloodingProbability, SignalFloodingProbability = signalFloodingProbability, NormativeProbabilityType = normativeProbabilityType }, BackgroundData = { Name = mapDataName, Transparency = (RoundedDouble)transparency, IsVisible = isVisible, Configuration = new WmtsBackgroundDataConfiguration(false,null, null, null) } }; assessmentSection.SpecificFailureMechanisms.AddRange(specificFailureMechanisms); var registry = new PersistenceRegistry(); // Call AssessmentSectionEntity entity = assessmentSection.Create(registry); // Assert Assert.IsNotNull(entity); Assert.AreEqual(Convert.ToByte(assessmentSectionComposition), entity.Composition); Assert.AreEqual(testId, entity.Id); Assert.AreEqual(testName, entity.Name); Assert.AreEqual(comments, entity.Comments); Assert.AreEqual(maximumAllowableFloodingProbability, entity.MaximumAllowableFloodingProbability); Assert.AreEqual(signalFloodingProbability, entity.SignalFloodingProbability); Assert.AreEqual(Convert.ToByte(normativeProbabilityType), entity.NormativeProbabilityType); Assert.AreEqual(15, entity.FailureMechanismEntities.Count); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.Piping)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.GrassRevetmentTopErosionAndInwards)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.MacroStabilityInwards)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.Microstability)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.StabilityStoneRevetment)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.WaveImpactOnAsphaltRevetment)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.WaterOverpressureAsphaltRevetment)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.GrassRevetmentErosionOutwards)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.GrassRevetmentSlidingOutwards)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.GrassRevetmentSlidingInwards)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.StructureHeight)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.ReliabilityClosingOfStructure)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.PipingAtStructure)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.StabilityPointStructures)); Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.DuneErosion)); Assert.AreEqual(assessmentSection.SpecificFailureMechanisms.Count, entity.SpecificFailureMechanismEntities.Count); Assert.IsNull(entity.ReferenceLinePointXml); Assert.AreEqual(1, entity.BackgroundDataEntities.Count); BackgroundDataEntity backgroundDataEntity = entity.BackgroundDataEntities.Single(); Assert.IsNotNull(backgroundDataEntity); Assert.AreEqual(mapDataName, backgroundDataEntity.Name); Assert.AreEqual(transparency, backgroundDataEntity.Transparency); Assert.AreEqual(Convert.ToByte(isVisible), backgroundDataEntity.IsVisible); Assert.AreEqual(Convert.ToByte(backgroundType), backgroundDataEntity.BackgroundDataType); Assert.AreEqual(1, backgroundDataEntity.BackgroundDataMetaEntities.Count); BackgroundDataMetaEntity isConfiguredMetaEntity = backgroundDataEntity.BackgroundDataMetaEntities.Single(); Assert.AreEqual("IsConfigured", isConfiguredMetaEntity.Key); Assert.AreEqual("0", isConfiguredMetaEntity.Value); }
private static void AssertHydraulicLocationCalculationCollectionEntities(AssessmentSection assessmentSection, AssessmentSectionEntity entity) { AssertHydraulicLocationCalculationCollectionEntity(assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, entity.HydraulicLocationCalculationCollectionEntity1.HydraulicLocationCalculationEntities); AssertHydraulicLocationCalculationCollectionEntity(assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability, entity.HydraulicLocationCalculationCollectionEntity.HydraulicLocationCalculationEntities); AssertHydraulicLocationCalculationForTargetProbabilityCollectionEntity(assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities, entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities .Where(e => e.HydraulicBoundaryLocationCalculationType == (short)HydraulicBoundaryLocationCalculationType.WaveHeight)); AssertHydraulicLocationCalculationForTargetProbabilityCollectionEntity(assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities, entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities .Where(e => e.HydraulicBoundaryLocationCalculationType == (short)HydraulicBoundaryLocationCalculationType.WaterLevel)); }
private static FailureMechanismEntity GetFailureMechanismEntityOfType(AssessmentSectionEntity entity, FailureMechanismType type) { return(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (int)type)); }
private static void ReadDuneErosionFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector) { FailureMechanismEntity duneErosionFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.DuneErosion); duneErosionFailureMechanismEntity?.ReadAsDuneErosionFailureMechanism(assessmentSection.DuneErosion, collector); }
private static void ReadPipingStructureFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector) { FailureMechanismEntity pipingStructureFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.PipingAtStructure); pipingStructureFailureMechanismEntity?.ReadAsPipingStructureFailureMechanism(assessmentSection.PipingStructure, collector); }
private static void ReadWaveImpactAsphaltCoverFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector) { FailureMechanismEntity waveImpactAsphaltCoverFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.WaveImpactOnAsphaltRevetment); waveImpactAsphaltCoverFailureMechanismEntity?.ReadAsWaveImpactAsphaltCoverFailureMechanism(assessmentSection.WaveImpactAsphaltCover, collector); }
private static void ReadStabilityStoneCoverFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector) { FailureMechanismEntity stabilityStoneCoverFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.StabilityStoneRevetment); stabilityStoneCoverFailureMechanismEntity?.ReadAsStabilityStoneCoverFailureMechanism(assessmentSection.StabilityStoneCover, collector); }
private static void ReadGrassCoverSlipOffOutwardsFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector) { FailureMechanismEntity grassCoverSlipOffOutwardsFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.GrassRevetmentSlidingOutwards); grassCoverSlipOffOutwardsFailureMechanismEntity?.ReadAsGrassCoverSlipOffOutwardsFailureMechanism(assessmentSection.GrassCoverSlipOffOutwards, collector); }
private static void AddHydraulicLocationCalculationForTargetProbabilityCollectionEntities(AssessmentSection assessmentSection, AssessmentSectionEntity entity, PersistenceRegistry registry) { AddHydraulicLocationCalculationForTargetProbabilityCollectionEntities(assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities, HydraulicBoundaryLocationCalculationType.WaterLevel, entity, registry); AddHydraulicLocationCalculationForTargetProbabilityCollectionEntities(assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities, HydraulicBoundaryLocationCalculationType.WaveHeight, entity, registry); }
public void Create_HydraulicBoundaryDatabaseLinked_SetsExpectedPropertiesToEntity() { // Setup var random = new Random(21); const string testFilePath = "path"; const string testVersion = "1"; var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike) { HydraulicBoundaryDatabase = { FilePath = testFilePath, Version = testVersion, Locations = { new HydraulicBoundaryLocation(-1, "name", 1, 2) } }, WaveHeightCalculationsForUserDefinedTargetProbabilities = { new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)), new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)), new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)) }, WaterLevelCalculationsForUserDefinedTargetProbabilities = { new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)), new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)) } }; assessmentSection.SetHydraulicBoundaryLocationCalculations(assessmentSection.HydraulicBoundaryDatabase.Locations); SetHydraulicBoundaryLocationCalculationInputsOfAssessmentSection(assessmentSection); var registry = new PersistenceRegistry(); // Call AssessmentSectionEntity entity = assessmentSection.Create(registry); // Assert HydraulicBoundaryDatabaseEntity hydraulicBoundaryDatabaseEntity = entity.HydraulicBoundaryDatabaseEntities.Single(); HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase; Assert.AreEqual(hydraulicBoundaryDatabase.FilePath, hydraulicBoundaryDatabaseEntity.FilePath); Assert.AreEqual(hydraulicBoundaryDatabase.Version, hydraulicBoundaryDatabaseEntity.Version); HydraulicLocationConfigurationSettings settings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings; Assert.AreEqual(settings.FilePath, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsFilePath); Assert.AreEqual(settings.ScenarioName, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsScenarioName); Assert.AreEqual(settings.Year, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsYear); Assert.AreEqual(settings.Scope, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsScope); Assert.AreEqual(settings.SeaLevel, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsSeaLevel); Assert.AreEqual(settings.RiverDischarge, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsRiverDischarge); Assert.AreEqual(settings.LakeLevel, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsLakeLevel); Assert.AreEqual(settings.WindDirection, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsWindDirection); Assert.AreEqual(settings.WindSpeed, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsWindSpeed); Assert.AreEqual(settings.Comment, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsComment); int expectedNrOfHydraulicBoundaryLocations = hydraulicBoundaryDatabase.Locations.Count; Assert.AreEqual(expectedNrOfHydraulicBoundaryLocations, entity.HydraulicLocationEntities.Count); AssertHydraulicLocationCalculationCollectionEntities(assessmentSection, entity); }
private static void ReadMicrostabilityFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector) { FailureMechanismEntity microstabilityFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.Microstability); microstabilityFailureMechanismEntity?.ReadAsMicrostabilityFailureMechanism(assessmentSection.Microstability, collector); }
private static void ReadStabilityPointStructuresFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector) { FailureMechanismEntity stabilityPointStructuresFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.StabilityPointStructures); stabilityPointStructuresFailureMechanismEntity?.ReadAsStabilityPointStructuresFailureMechanism(assessmentSection.StabilityPointStructures, collector); }