Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Application.Ringtoets.Storage.csproj =================================================================== diff -u -re69abddf5b9c6634b764df231d4e1b290c9e0fb5 -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Application.Ringtoets.Storage.csproj (.../Application.Ringtoets.Storage.csproj) (revision e69abddf5b9c6634b764df231d4e1b290c9e0fb5) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Application.Ringtoets.Storage.csproj (.../Application.Ringtoets.Storage.csproj) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -59,6 +59,7 @@ + @@ -141,7 +142,9 @@ + + Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PersistenceRegistry.cs =================================================================== diff -u -r678685141f0211ca24ce5c03fc5eb05cc99f0f48 -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PersistenceRegistry.cs (.../PersistenceRegistry.cs) (revision 678685141f0211ca24ce5c03fc5eb05cc99f0f48) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PersistenceRegistry.cs (.../PersistenceRegistry.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -54,6 +54,7 @@ private readonly Dictionary calculationGroups = new Dictionary(new ReferenceEqualityComparer()); private readonly Dictionary pipingCalculations = new Dictionary(new ReferenceEqualityComparer()); private readonly Dictionary pipingOutputs = new Dictionary(new ReferenceEqualityComparer()); + private readonly Dictionary pipingSemiProbabilisticOutputs = new Dictionary(new ReferenceEqualityComparer()); private readonly Dictionary stochasticSoilModels = new Dictionary(new ReferenceEqualityComparer()); private readonly Dictionary stochasticSoilProfiles = new Dictionary(new ReferenceEqualityComparer()); private readonly Dictionary soilProfiles = new Dictionary(new ReferenceEqualityComparer()); @@ -131,6 +132,22 @@ /// Registers a create or update operation for and the /// that was constructed with the information. /// + /// The that was registered. + /// The which needed to registered. + /// Thrown when either: + /// + /// is null + /// is null + /// + public void Register(PipingSemiProbabilisticOutputEntity entity, PipingSemiProbabilisticOutput model) + { + Register(pipingSemiProbabilisticOutputs, entity, model); + } + + /// + /// Registers a create or update operation for and the + /// that was constructed with the information. + /// /// The that was registered. /// The which needed to be registered. /// Thrown when either: @@ -525,6 +542,11 @@ pipingOutputs[entity].StorageId = entity.PipingCalculationOutputEntityId; } + foreach (var entity in pipingSemiProbabilisticOutputs.Keys) + { + pipingSemiProbabilisticOutputs[entity].StorageId = entity.PipingSemiProbabilisticOutputEntityId; + } + foreach (var entity in stochasticSoilModels.Keys) { stochasticSoilModels[entity].StorageId = entity.StochasticSoilModelEntityId; @@ -570,7 +592,7 @@ /// The from which to remove the entities. internal void RemoveUntouched(IRingtoetsEntities dbContext) { - IList orphanedProjectEntities = new List(); + var orphanedProjectEntities = new List(); foreach (ProjectEntity projectEntity in dbContext.ProjectEntities .Where(e => e.ProjectEntityId > 0)) { @@ -581,7 +603,7 @@ } dbContext.ProjectEntities.RemoveRange(orphanedProjectEntities); - IList orphanedAssessmentSectionEntities = new List(); + var orphanedAssessmentSectionEntities = new List(); foreach (AssessmentSectionEntity assessmentSectionEntity in dbContext.AssessmentSectionEntities .Where(e => e.AssessmentSectionEntityId > 0)) { @@ -592,7 +614,7 @@ } dbContext.AssessmentSectionEntities.RemoveRange(orphanedAssessmentSectionEntities); - IList orphanedFailureMechanismEntities = new List(); + var orphanedFailureMechanismEntities = new List(); foreach (FailureMechanismEntity failureMechanismEntity in dbContext.FailureMechanismEntities .Where(e => e.FailureMechanismEntityId > 0)) { @@ -603,7 +625,7 @@ } dbContext.FailureMechanismEntities.RemoveRange(orphanedFailureMechanismEntities); - IList orphanedFailureMechanismSectionEntities = new List(); + var orphanedFailureMechanismSectionEntities = new List(); foreach (FailureMechanismSectionEntity failureMechanismSectionEntity in dbContext.FailureMechanismSectionEntities .Where(e => e.FailureMechanismSectionEntityId > 0)) { @@ -614,7 +636,7 @@ } dbContext.FailureMechanismSectionEntities.RemoveRange(orphanedFailureMechanismSectionEntities); - IList orphanedHydraulicLocationEntities = new List(); + var orphanedHydraulicLocationEntities = new List(); foreach (HydraulicLocationEntity hydraulicLocationEntity in dbContext.HydraulicLocationEntities .Where(e => e.HydraulicLocationEntityId > 0)) { @@ -625,7 +647,7 @@ } dbContext.HydraulicLocationEntities.RemoveRange(orphanedHydraulicLocationEntities); - IList orphanedCalculationGroupEntities = new List(); + var orphanedCalculationGroupEntities = new List(); foreach (CalculationGroupEntity calculationGroupEntity in dbContext.CalculationGroupEntities .Where(e => e.CalculationGroupEntityId > 0)) { @@ -636,7 +658,7 @@ } dbContext.CalculationGroupEntities.RemoveRange(orphanedCalculationGroupEntities); - IList orphanedPipingCalculationEntities = new List(); + var orphanedPipingCalculationEntities = new List(); foreach (PipingCalculationEntity pipingCalculationEntity in dbContext.PipingCalculationEntities .Where(e => e.PipingCalculationEntityId > 0)) { @@ -647,7 +669,7 @@ } dbContext.PipingCalculationEntities.RemoveRange(orphanedPipingCalculationEntities); - IList orphanedPipingCalculationOutputEntities = new List(); + var orphanedPipingCalculationOutputEntities = new List(); foreach (PipingCalculationOutputEntity pipingCalculationOutputEntity in dbContext.PipingCalculationOutputEntities .Where(e => e.PipingCalculationOutputEntityId > 0)) { @@ -658,7 +680,18 @@ } dbContext.PipingCalculationOutputEntities.RemoveRange(orphanedPipingCalculationOutputEntities); - IList orphanedStochasticSoilModelEntities = new List(); + var orphanedPipingSemiProbabilisticOutputEntities = new List(); + foreach (PipingSemiProbabilisticOutputEntity pipingSemiProbabilisticOutputEntity in dbContext.PipingSemiProbabilisticOutputEntities + .Where(e => e.PipingSemiProbabilisticOutputEntityId > 0)) + { + if (!pipingSemiProbabilisticOutputs.ContainsKey(pipingSemiProbabilisticOutputEntity)) + { + orphanedPipingSemiProbabilisticOutputEntities.Add(pipingSemiProbabilisticOutputEntity); + } + } + dbContext.PipingSemiProbabilisticOutputEntities.RemoveRange(orphanedPipingSemiProbabilisticOutputEntities); + + var orphanedStochasticSoilModelEntities = new List(); foreach (StochasticSoilModelEntity stochasticSoilModelEntity in dbContext.StochasticSoilModelEntities .Where(e => e.StochasticSoilModelEntityId > 0)) { @@ -669,7 +702,7 @@ } dbContext.StochasticSoilModelEntities.RemoveRange(orphanedStochasticSoilModelEntities); - IList orphanedStochasticSoilProfileEntities = new List(); + var orphanedStochasticSoilProfileEntities = new List(); foreach (StochasticSoilProfileEntity stochasticSoilProfileEntity in dbContext.StochasticSoilProfileEntities .Where(e => e.StochasticSoilProfileEntityId > 0)) { @@ -680,7 +713,7 @@ } dbContext.StochasticSoilProfileEntities.RemoveRange(orphanedStochasticSoilProfileEntities); - IList orphanedSoilProfileEntities = new List(); + var orphanedSoilProfileEntities = new List(); foreach (SoilProfileEntity soilProfileEntity in dbContext.SoilProfileEntities .Where(e => e.SoilProfileEntityId > 0)) { @@ -691,7 +724,7 @@ } dbContext.SoilProfileEntities.RemoveRange(orphanedSoilProfileEntities); - IList orphanedSoilLayerEntities = new List(); + var orphanedSoilLayerEntities = new List(); foreach (SoilLayerEntity soilLayerEntity in dbContext.SoilLayerEntities .Where(e => e.SoilLayerEntityId > 0)) { @@ -702,7 +735,7 @@ } dbContext.SoilLayerEntities.RemoveRange(orphanedSoilLayerEntities); - IList orphanedSurfaceLineEntities = new List(); + var orphanedSurfaceLineEntities = new List(); foreach (SurfaceLineEntity surfaceLineEntity in dbContext.SurfaceLineEntities .Where(e => e.SurfaceLineEntityId > 0)) { @@ -713,7 +746,7 @@ } dbContext.SurfaceLineEntities.RemoveRange(orphanedSurfaceLineEntities); - IList orphanedSurfaceLinePointEntities = new List(); + var orphanedSurfaceLinePointEntities = new List(); foreach (SurfaceLinePointEntity surfaceLinePointEntity in dbContext.SurfaceLinePointEntities .Where(e => e.SurfaceLinePointEntityId > 0)) { @@ -724,7 +757,7 @@ } dbContext.SurfaceLinePointEntities.RemoveRange(orphanedSurfaceLinePointEntities); - IList orphanedCharacteristicPointEntities = new List(); + var orphanedCharacteristicPointEntities = new List(); foreach (CharacteristicPointEntity characteristicPointEntity in dbContext.CharacteristicPointEntities .Where(e => e.CharacteristicPointEntityId > 0)) { @@ -735,7 +768,7 @@ } dbContext.CharacteristicPointEntities.RemoveRange(orphanedCharacteristicPointEntities); - IList orphanedPipingFailureMechanismMetaEntities = new List(); + var orphanedPipingFailureMechanismMetaEntities = new List(); foreach (PipingFailureMechanismMetaEntity pipingFailureMechanismMetaEntity in dbContext.PipingFailureMechanismMetaEntities .Where(e => e.PipingFailureMechanismMetaEntityId > 0)) { Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PipingCalculationScenarioCreateExtensions.cs =================================================================== diff -u -rbba617101367a21a38bf41ad520662058b9012af -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PipingCalculationScenarioCreateExtensions.cs (.../PipingCalculationScenarioCreateExtensions.cs) (revision bba617101367a21a38bf41ad520662058b9012af) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PipingCalculationScenarioCreateExtensions.cs (.../PipingCalculationScenarioCreateExtensions.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -59,6 +59,8 @@ Order = order }; SetInputParametersToEntity(entity, calculation.InputParameters, registry); + CreatePipingOutputEntity(entity, calculation.Output, registry); + CreatePipingSemiProbabilisticOutputEntity(entity, calculation.SemiProbabilisticOutput, registry); registry.Register(entity, calculation); @@ -109,5 +111,21 @@ } return Convert.ToDecimal(parameter); } + + private static void CreatePipingOutputEntity(PipingCalculationEntity entity, PipingOutput output, PersistenceRegistry registry) + { + if (output != null) + { + entity.PipingCalculationOutputEntities.Add(output.Create(registry)); + } + } + + private static void CreatePipingSemiProbabilisticOutputEntity(PipingCalculationEntity entity, PipingSemiProbabilisticOutput output, PersistenceRegistry registry) + { + if (output != null) + { + entity.PipingSemiProbabilisticOutputEntities.Add(output.Create(registry)); + } + } } } \ No newline at end of file Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PipingOutputCreateExtensions.cs =================================================================== diff -u -r678685141f0211ca24ce5c03fc5eb05cc99f0f48 -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PipingOutputCreateExtensions.cs (.../PipingOutputCreateExtensions.cs) (revision 678685141f0211ca24ce5c03fc5eb05cc99f0f48) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PipingOutputCreateExtensions.cs (.../PipingOutputCreateExtensions.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -1,5 +1,26 @@ -using System; +// Copyright (C) Stichting Deltares 2016. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. +using System; + using Application.Ringtoets.Storage.DbContext; using Ringtoets.Piping.Data; @@ -35,6 +56,7 @@ UpliftFactorOfSafety = GetNullableDecimal(output.UpliftFactorOfSafety), UpliftZValue = GetNullableDecimal(output.UpliftZValue) }; + registry.Register(entity, output); return entity; } Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PipingSemiProbabilisticOutputCreateExtensions.cs =================================================================== diff -u --- Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PipingSemiProbabilisticOutputCreateExtensions.cs (revision 0) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Create/PipingSemiProbabilisticOutputCreateExtensions.cs (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -0,0 +1,83 @@ +// Copyright (C) Stichting Deltares 2016. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; + +using Application.Ringtoets.Storage.DbContext; + +using Core.Common.Base.Data; + +using Ringtoets.Piping.Data; + +namespace Application.Ringtoets.Storage.Create +{ + /// + /// Extension methods for related to creating + /// a . + /// + internal static class PipingSemiProbabilisticOutputCreateExtensions + { + /// + /// Creates a based on the information + /// of the . + /// + /// The semi-probabilistic calculation output + /// for piping to create a database entity for. + /// The object keeping track of create operations. + /// A new . + /// Thrown when is null. + internal static PipingSemiProbabilisticOutputEntity Create(this PipingSemiProbabilisticOutput semiProbabilisticOutput, PersistenceRegistry registry) + { + if (registry == null) + { + throw new ArgumentNullException("registry"); + } + var entity = new PipingSemiProbabilisticOutputEntity + { + UpliftFactorOfSafety = GetNullableDecimal(semiProbabilisticOutput.UpliftFactorOfSafety), + UpliftReliability = GetNullableDecimal(semiProbabilisticOutput.UpliftReliability), + UpliftProbability = GetNullableDecimal(semiProbabilisticOutput.UpliftProbability), + HeaveFactorOfSafety = GetNullableDecimal(semiProbabilisticOutput.HeaveFactorOfSafety), + HeaveReliability = GetNullableDecimal(semiProbabilisticOutput.HeaveReliability), + HeaveProbability = GetNullableDecimal(semiProbabilisticOutput.HeaveProbability), + SellmeijerFactorOfSafety = GetNullableDecimal(semiProbabilisticOutput.SellmeijerFactorOfSafety), + SellmeijerReliability = GetNullableDecimal(semiProbabilisticOutput.SellmeijerReliability), + SellmeijerProbability = GetNullableDecimal(semiProbabilisticOutput.SellmeijerProbability), + RequiredProbability = GetNullableDecimal(semiProbabilisticOutput.RequiredProbability), + RequiredReliability = GetNullableDecimal(semiProbabilisticOutput.RequiredReliability), + PipingProbability = GetNullableDecimal(semiProbabilisticOutput.PipingProbability), + PipingReliability = GetNullableDecimal(semiProbabilisticOutput.PipingReliability), + PipingFactorOfSafety = GetNullableDecimal(semiProbabilisticOutput.PipingFactorOfSafety), + }; + registry.Register(entity, semiProbabilisticOutput); + return entity; + } + + private static decimal? GetNullableDecimal(RoundedDouble parameterValue) + { + if (double.IsNaN(parameterValue)) + { + return null; + } + return Convert.ToDecimal(parameterValue); + } + } +} \ No newline at end of file Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Read/PipingCalculationEntityReadExtensions.cs =================================================================== diff -u -rbba617101367a21a38bf41ad520662058b9012af -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Read/PipingCalculationEntityReadExtensions.cs (.../PipingCalculationEntityReadExtensions.cs) (revision bba617101367a21a38bf41ad520662058b9012af) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Read/PipingCalculationEntityReadExtensions.cs (.../PipingCalculationEntityReadExtensions.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Linq; using Application.Ringtoets.Storage.DbContext; @@ -60,10 +61,24 @@ Comments = entity.Comments }; ReadInputParameters(calculation.InputParameters, entity, collector); + ReadCalculationOutputs(calculation, entity); return calculation; } + private static void ReadCalculationOutputs(PipingCalculationScenario calculation, PipingCalculationEntity entity) + { + if (entity.PipingCalculationOutputEntities.Any()) + { + calculation.Output = entity.PipingCalculationOutputEntities.Single().Read(); + } + + if (entity.PipingSemiProbabilisticOutputEntities.Any()) + { + calculation.SemiProbabilisticOutput = entity.PipingSemiProbabilisticOutputEntities.Single().Read(); + } + } + private static void ReadInputParameters(PipingInput inputParameters, PipingCalculationEntity entity, ReadConversionCollector collector) { if (entity.SurfaceLineEntity != null) Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Read/PipingCalculationOutputEntityReadExtensions.cs =================================================================== diff -u --- Application/Ringtoets/src/Application.Ringtoets.Storage/Read/PipingCalculationOutputEntityReadExtensions.cs (revision 0) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Read/PipingCalculationOutputEntityReadExtensions.cs (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -0,0 +1,62 @@ +// Copyright (C) Stichting Deltares 2016. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; + +using Application.Ringtoets.Storage.DbContext; + +using Ringtoets.Piping.Data; + +namespace Application.Ringtoets.Storage.Read +{ + /// + /// This class defines extension methods for read operations for an + /// based on the . + /// + internal static class PipingCalculationOutputEntityReadExtensions + { + /// + /// Read the and use the information to + /// construct a . + /// + /// The to create + /// for. + /// A new . + internal static PipingOutput Read(this PipingCalculationOutputEntity entity) + { + return new PipingOutput(GetNanDouble(entity.UpliftZValue), GetNanDouble(entity.UpliftFactorOfSafety), + GetNanDouble(entity.HeaveZValue), GetNanDouble(entity.HeaveFactorOfSafety), + GetNanDouble(entity.SellmeijerZValue), GetNanDouble(entity.SellmeijerFactorOfSafety)) + { + StorageId = entity.PipingCalculationOutputEntityId + }; + } + + private static double GetNanDouble(decimal? parameterValue) + { + if (parameterValue == null) + { + return double.NaN; + } + return Convert.ToDouble(parameterValue); + } + } +} \ No newline at end of file Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Read/PipingSemiProbabilisticOutputEntityReadExtensions.cs =================================================================== diff -u --- Application/Ringtoets/src/Application.Ringtoets.Storage/Read/PipingSemiProbabilisticOutputEntityReadExtensions.cs (revision 0) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Read/PipingSemiProbabilisticOutputEntityReadExtensions.cs (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -0,0 +1,65 @@ +// Copyright (C) Stichting Deltares 2016. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; + +using Application.Ringtoets.Storage.DbContext; + +using Ringtoets.Piping.Data; + +namespace Application.Ringtoets.Storage.Read +{ + /// + /// This class defines extension methods for read operations for a + /// based on the . + /// + internal static class PipingSemiProbabilisticOutputEntityReadExtensions + { + /// + /// Read the and use the information + /// to construct a . + /// + /// The to + /// create for. + /// A new . + internal static PipingSemiProbabilisticOutput Read(this PipingSemiProbabilisticOutputEntity entity) + { + return new PipingSemiProbabilisticOutput( + GetNanDouble(entity.UpliftFactorOfSafety), GetNanDouble(entity.UpliftReliability), GetNanDouble(entity.UpliftProbability), + GetNanDouble(entity.HeaveFactorOfSafety), GetNanDouble(entity.HeaveReliability), GetNanDouble(entity.HeaveProbability), + GetNanDouble(entity.SellmeijerFactorOfSafety), GetNanDouble(entity.SellmeijerReliability), GetNanDouble(entity.SellmeijerProbability), + GetNanDouble(entity.RequiredProbability), GetNanDouble(entity.RequiredReliability), + GetNanDouble(entity.PipingProbability), GetNanDouble(entity.PipingReliability), GetNanDouble(entity.PipingFactorOfSafety)) + { + StorageId = entity.PipingSemiProbabilisticOutputEntityId + }; + } + + private static double GetNanDouble(decimal? parameterValue) + { + if (parameterValue == null) + { + return double.NaN; + } + return Convert.ToDouble(parameterValue); + } + } +} \ No newline at end of file Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Update/PipingCalculationScenarioUpdateExtensions.cs =================================================================== diff -u -rbba617101367a21a38bf41ad520662058b9012af -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Update/PipingCalculationScenarioUpdateExtensions.cs (.../PipingCalculationScenarioUpdateExtensions.cs) (revision bba617101367a21a38bf41ad520662058b9012af) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Update/PipingCalculationScenarioUpdateExtensions.cs (.../PipingCalculationScenarioUpdateExtensions.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -70,7 +70,7 @@ entity.Name = calculation.Name; entity.Comments = calculation.Comments; SetInputParameters(entity, calculation.InputParameters, registry); - + UpdatePipingCalculationOutputs(entity, calculation, registry); registry.Register(entity, calculation); } @@ -134,5 +134,46 @@ } return Convert.ToDecimal(value); } + + private static void UpdatePipingCalculationOutputs(PipingCalculationEntity entity, PipingCalculationScenario calculation, PersistenceRegistry registry) + { + if (calculation.Output != null) + { + PipingOutput pipingOutput = calculation.Output; + if (pipingOutput.IsNew()) + { + entity.PipingCalculationOutputEntities.Clear(); + entity.PipingCalculationOutputEntities.Add(pipingOutput.Create(registry)); + } + else + { + registry.Register(entity.PipingCalculationOutputEntities.Single(), pipingOutput); + } + + + } + else + { + entity.PipingCalculationOutputEntities.Clear(); + } + + if (calculation.SemiProbabilisticOutput != null) + { + PipingSemiProbabilisticOutput semiProbabilisticOutput = calculation.SemiProbabilisticOutput; + if (semiProbabilisticOutput.IsNew()) + { + entity.PipingSemiProbabilisticOutputEntities.Clear(); + entity.PipingSemiProbabilisticOutputEntities.Add(semiProbabilisticOutput.Create(registry)); + } + else + { + registry.Register(entity.PipingSemiProbabilisticOutputEntities.Single(), semiProbabilisticOutput); + } + } + else + { + entity.PipingSemiProbabilisticOutputEntities.Clear(); + } + } } } \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Application.Ringtoets.Storage.Test.csproj =================================================================== diff -u -r678685141f0211ca24ce5c03fc5eb05cc99f0f48 -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Application.Ringtoets.Storage.Test.csproj (.../Application.Ringtoets.Storage.Test.csproj) (revision 678685141f0211ca24ce5c03fc5eb05cc99f0f48) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Application.Ringtoets.Storage.Test.csproj (.../Application.Ringtoets.Storage.Test.csproj) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -88,6 +88,7 @@ + @@ -107,7 +108,9 @@ + + Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PersistenceRegistryTest.cs =================================================================== diff -u -r678685141f0211ca24ce5c03fc5eb05cc99f0f48 -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PersistenceRegistryTest.cs (.../PersistenceRegistryTest.cs) (revision 678685141f0211ca24ce5c03fc5eb05cc99f0f48) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PersistenceRegistryTest.cs (.../PersistenceRegistryTest.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -872,6 +872,36 @@ } [Test] + public void Register_WithNullPipingSemiProbabilisticOutputEntity_ThrowsArgumentNullException() + { + // Setup + var registry = new PersistenceRegistry(); + + PipingSemiProbabilisticOutput output = new PipingSemiProbabilisticOutput(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1); + + // Call + TestDelegate test = () => registry.Register(null, output); + + // Assert + var paramName = Assert.Throws(test).ParamName; + Assert.AreEqual("entity", paramName); + } + + [Test] + public void Register_WithNullPipingSemiProbabilisticOutput_ThrowsArgumentNullException() + { + // Setup + var registry = new PersistenceRegistry(); + + // Call + TestDelegate test = () => registry.Register(new PipingSemiProbabilisticOutputEntity(), null); + + // Assert + var paramName = Assert.Throws(test).ParamName; + Assert.AreEqual("model", paramName); + } + + [Test] public void Register_WithNullStochasticSoilModelEntity_ThrowsArgumentNullException() { // Setup @@ -1261,6 +1291,27 @@ } [Test] + public void TransferId_WithPipingSemiProbabilisticOutputEntityAdded_EqualPipingSemiProbabilisticOutputEntityIdAndPipingSemiProbabilisticOutputStorageId() + { + // Setup + var registry = new PersistenceRegistry(); + + long storageId = new Random(21).Next(1, 4000); + var entity = new PipingSemiProbabilisticOutputEntity + { + PipingSemiProbabilisticOutputEntityId = storageId + }; + var model = new PipingSemiProbabilisticOutput(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14); + registry.Register(entity, model); + + // Call + registry.TransferIds(); + + // Assert + Assert.AreEqual(storageId, model.StorageId); + } + + [Test] public void TransferId_WithStochasticSoilModelEntityAdded_EqualStochasticSoilModelEntityIdAndStochasticSoilModelStorageId() { // Setup @@ -1683,6 +1734,43 @@ } [Test] + public void RemoveUntouched_PipingSemiProbabilisticOutputEntity_OrphanedEntityIsRemovedFromRingtoetsEntities() + { + // Setup + var mocks = new MockRepository(); + IRingtoetsEntities dbContext = RingtoetsEntitiesHelper.CreateStub(mocks); + mocks.ReplayAll(); + + var orphanedEntity = new PipingSemiProbabilisticOutputEntity + { + PipingSemiProbabilisticOutputEntityId = 1 + }; + var persistentEntity = new PipingSemiProbabilisticOutputEntity + { + PipingSemiProbabilisticOutputEntityId = 2 + }; + dbContext.PipingSemiProbabilisticOutputEntities.Add(orphanedEntity); + dbContext.PipingSemiProbabilisticOutputEntities.Add(persistentEntity); + + var pipingSemiProbabilisticOutput = new PipingSemiProbabilisticOutput(1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14) + { + StorageId = persistentEntity.PipingSemiProbabilisticOutputEntityId + }; + + var registry = new PersistenceRegistry(); + registry.Register(persistentEntity, pipingSemiProbabilisticOutput); + + // Call + registry.RemoveUntouched(dbContext); + + // Assert + Assert.AreEqual(1, dbContext.PipingSemiProbabilisticOutputEntities.Count()); + CollectionAssert.Contains(dbContext.PipingSemiProbabilisticOutputEntities, persistentEntity); + mocks.VerifyAll(); + } + + [Test] public void RemoveUntouched_StochasticSoilModelEntity_OrphanedEntityIsRemovedFromRingtoetsEntities() { // Setup Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PipingCalculationScenarioCreateExtensionsTest.cs =================================================================== diff -u -rbb0aeecc47206f5089ab04ca6c3575a1de8c206f -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PipingCalculationScenarioCreateExtensionsTest.cs (.../PipingCalculationScenarioCreateExtensionsTest.cs) (revision bb0aeecc47206f5089ab04ca6c3575a1de8c206f) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PipingCalculationScenarioCreateExtensionsTest.cs (.../PipingCalculationScenarioCreateExtensionsTest.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -326,6 +326,48 @@ Assert.AreSame(registry.Get(stochasticSoilProfile), entity.StochasticSoilProfileEntity); } + [Test] + public void Create_HasCalculationOutput_EntityHasPipingCalculationOutputEntity() + { + // Setup + var registry = new PersistenceRegistry(); + + var newOutput = new PipingOutput(1,2,3,4,5,6); + var calculation = new PipingCalculationScenario(new GeneralPipingInput()) + { + Output = newOutput + }; + + // Call + PipingCalculationEntity entity = calculation.Create(registry, 0); + + // Assert + Assert.AreEqual(1, entity.PipingCalculationOutputEntities.Count); + } + + [Test] + public void Create_HasPipingSemiProbabilisticOutput_EntityHasPipingSemiProbabilisticOutputEntity() + { + // Setup + var registry = new PersistenceRegistry(); + + var newOutput = new PipingSemiProbabilisticOutput(1, 2, 3, + 4, 5, 6, + 7, 8, 9, + 10, 11, + 12, 13, 14); + var calculation = new PipingCalculationScenario(new GeneralPipingInput()) + { + SemiProbabilisticOutput = newOutput + }; + + // Call + PipingCalculationEntity entity = calculation.Create(registry, 0); + + // Assert + Assert.AreEqual(1, entity.PipingSemiProbabilisticOutputEntities.Count); + } + private static decimal? GetExpectedValueForNullableDecimal(double valueThatCanBeNaN) { decimal? expectedExitPoint = null; Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PipingOutputCreateExtensionsTest.cs =================================================================== diff -u -r678685141f0211ca24ce5c03fc5eb05cc99f0f48 -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PipingOutputCreateExtensionsTest.cs (.../PipingOutputCreateExtensionsTest.cs) (revision 678685141f0211ca24ce5c03fc5eb05cc99f0f48) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PipingOutputCreateExtensionsTest.cs (.../PipingOutputCreateExtensionsTest.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -1,5 +1,26 @@ -using System; +// Copyright (C) Stichting Deltares 2016. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. +using System; + using Application.Ringtoets.Storage.Create; using Application.Ringtoets.Storage.DbContext; @@ -72,5 +93,22 @@ Assert.AreEqual(0, entity.PipingCalculationOutputEntityId); Assert.IsNull(entity.PipingCalculationEntity); } + + [Test] + public void Create_Always_RegisterNewEntityInPersistenceRegistry() + { + // Setup + var pipingOutput = new PipingOutput(1.1, 2.2, 3.3, 4.4, 5.5, 6.6); + + var registry = new PersistenceRegistry(); + + // Call + PipingCalculationOutputEntity entity = pipingOutput.Create(registry); + + // Assert + entity.PipingCalculationOutputEntityId = 39458; + registry.TransferIds(); + Assert.AreEqual(entity.PipingCalculationOutputEntityId, pipingOutput.StorageId); + } } } \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PipingSemiProbabilisticOutputCreateExtensionsTest.cs =================================================================== diff -u --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PipingSemiProbabilisticOutputCreateExtensionsTest.cs (revision 0) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/PipingSemiProbabilisticOutputCreateExtensionsTest.cs (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -0,0 +1,130 @@ +// Copyright (C) Stichting Deltares 2016. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; + +using Application.Ringtoets.Storage.Create; +using Application.Ringtoets.Storage.DbContext; + +using Core.Common.Base.Data; + +using NUnit.Framework; + +using Ringtoets.Common.Data.TestUtil; +using Ringtoets.Piping.Data; + +namespace Application.Ringtoets.Storage.Test.Create +{ + [TestFixture] + public class PipingSemiProbabilisticOutputCreateExtensionsTest + { + [Test] + public void Create_PersistenceRegistryIsNull_ThrowArgumentNullException() + { + // Setup + var output = new PipingSemiProbabilisticOutput(1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, + 8.8, 9.9, 10.10, 11.11, 12.12, + 13.13, 14.14); + + // Call + TestDelegate call = () => output.Create(null); + + // Assert + string paramName = Assert.Throws(call).ParamName; + Assert.AreEqual("registry", paramName); + } + + [Test] + public void Create_WithValidValues_ReturnEntity() + { + // Setup + var output = new PipingSemiProbabilisticOutput(1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, + 8.8, 9.9, 10.10, 11.11, 12.12, + 13.13, 14.14); + var registry = new PersistenceRegistry(); + + // Call + PipingSemiProbabilisticOutputEntity entity = output.Create(registry); + + // Assert + AssertAreEqual(output.UpliftFactorOfSafety, entity.UpliftFactorOfSafety); + AssertAreEqual(output.UpliftReliability, entity.UpliftReliability); + AssertAreEqual(output.UpliftProbability, entity.UpliftProbability); + AssertAreEqual(output.HeaveFactorOfSafety, entity.HeaveFactorOfSafety); + AssertAreEqual(output.HeaveReliability, entity.HeaveReliability); + AssertAreEqual(output.HeaveProbability, entity.HeaveProbability); + AssertAreEqual(output.SellmeijerFactorOfSafety, entity.SellmeijerFactorOfSafety); + AssertAreEqual(output.SellmeijerReliability, entity.SellmeijerReliability); + AssertAreEqual(output.SellmeijerProbability, entity.SellmeijerProbability); + AssertAreEqual(output.RequiredProbability, entity.RequiredProbability); + AssertAreEqual(output.RequiredReliability, entity.RequiredReliability); + AssertAreEqual(output.PipingProbability, entity.PipingProbability); + AssertAreEqual(output.PipingReliability, entity.PipingReliability); + AssertAreEqual(output.PipingFactorOfSafety, entity.PipingFactorOfSafety); + + Assert.AreEqual(0, entity.PipingSemiProbabilisticOutputEntityId); + Assert.IsNull(entity.PipingCalculationEntity); + } + + private static void AssertAreEqual(RoundedDouble expectedValue, decimal? actualValue) + { + if (double.IsNaN(expectedValue)) + { + Assert.IsNull(actualValue); + } + Assert.AreEqual(expectedValue, Convert.ToDouble(actualValue), expectedValue.GetAccuracy()); + } + + [Test] + public void Create_WithNaNValues_ReturnEntityWithNullPropertyValues() + { + // Setup + var output = new PipingSemiProbabilisticOutput(double.NaN, double.NaN, double.NaN, + double.NaN, double.NaN, double.NaN, + double.NaN, double.NaN, double.NaN, + double.NaN, double.NaN, double.NaN, + double.NaN, double.NaN); + var registry = new PersistenceRegistry(); + + // Call + PipingSemiProbabilisticOutputEntity entity = output.Create(registry); + + // Assert + Assert.IsNull(entity.UpliftFactorOfSafety); + Assert.IsNull(entity.UpliftReliability); + Assert.IsNull(entity.UpliftProbability); + Assert.IsNull(entity.HeaveFactorOfSafety); + Assert.IsNull(entity.HeaveReliability); + Assert.IsNull(entity.HeaveProbability); + Assert.IsNull(entity.SellmeijerFactorOfSafety); + Assert.IsNull(entity.SellmeijerReliability); + Assert.IsNull(entity.SellmeijerProbability); + Assert.IsNull(entity.RequiredProbability); + Assert.IsNull(entity.RequiredReliability); + Assert.IsNull(entity.PipingProbability); + Assert.IsNull(entity.PipingReliability); + Assert.IsNull(entity.PipingFactorOfSafety); + + Assert.AreEqual(0, entity.PipingSemiProbabilisticOutputEntityId); + Assert.IsNull(entity.PipingCalculationEntity); + } + } +} \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs =================================================================== diff -u -rf906ba10d1763e14a608bb2629b15893f37e9deb -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs (.../StorageSqLiteIntegrationTest.cs) (revision f906ba10d1763e14a608bb2629b15893f37e9deb) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs (.../StorageSqLiteIntegrationTest.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -441,6 +441,8 @@ Assert.AreEqual(expectedPipingCalculation.Comments, actualPipingCalculation.Comments); AssertPipingInput(expectedPipingCalculation.InputParameters, actualPipingCalculation.InputParameters); + AssertPipingOutput(expectedPipingCalculation.Output, actualPipingCalculation.Output); + AssertPipingSemiProbabilisticOutput(expectedPipingCalculation.SemiProbabilisticOutput, actualPipingCalculation.SemiProbabilisticOutput); } private static void AssertPipingInput(PipingInput expectedPipingInput, PipingInput actualPipingInput) @@ -460,6 +462,52 @@ Assert.AreEqual(expectedPipingInput.DarcyPermeability.StandardDeviation, actualPipingInput.DarcyPermeability.StandardDeviation); } + private void AssertPipingOutput(PipingOutput expectedOutput, PipingOutput actualOutput) + { + if (expectedOutput == null) + { + Assert.IsNull(actualOutput); + } + else + { + Assert.AreEqual(expectedOutput.HeaveFactorOfSafety, actualOutput.HeaveFactorOfSafety); + Assert.AreEqual(expectedOutput.HeaveZValue, actualOutput.HeaveZValue); + Assert.AreEqual(expectedOutput.UpliftFactorOfSafety, actualOutput.UpliftFactorOfSafety); + Assert.AreEqual(expectedOutput.UpliftZValue, actualOutput.UpliftZValue); + Assert.AreEqual(expectedOutput.SellmeijerFactorOfSafety, actualOutput.SellmeijerFactorOfSafety); + Assert.AreEqual(expectedOutput.SellmeijerZValue, actualOutput.SellmeijerZValue); + } + } + + private void AssertPipingSemiProbabilisticOutput(PipingSemiProbabilisticOutput expectedOutput, PipingSemiProbabilisticOutput actualOutput) + { + if (expectedOutput == null) + { + Assert.IsNull(actualOutput); + } + else + { + Assert.AreEqual(expectedOutput.HeaveFactorOfSafety, actualOutput.HeaveFactorOfSafety); + Assert.AreEqual(expectedOutput.HeaveProbability, actualOutput.HeaveProbability); + Assert.AreEqual(expectedOutput.HeaveReliability, actualOutput.HeaveReliability); + + Assert.AreEqual(expectedOutput.SellmeijerFactorOfSafety, actualOutput.SellmeijerFactorOfSafety); + Assert.AreEqual(expectedOutput.SellmeijerProbability, actualOutput.SellmeijerProbability); + Assert.AreEqual(expectedOutput.SellmeijerReliability, actualOutput.SellmeijerReliability); + + Assert.AreEqual(expectedOutput.UpliftFactorOfSafety, actualOutput.UpliftFactorOfSafety); + Assert.AreEqual(expectedOutput.UpliftProbability, actualOutput.UpliftProbability); + Assert.AreEqual(expectedOutput.UpliftReliability, actualOutput.UpliftReliability); + + Assert.AreEqual(expectedOutput.RequiredReliability, actualOutput.RequiredReliability); + Assert.AreEqual(expectedOutput.RequiredProbability, actualOutput.RequiredProbability); + + Assert.AreEqual(expectedOutput.PipingFactorOfSafety, actualOutput.PipingFactorOfSafety); + Assert.AreEqual(expectedOutput.PipingReliability, actualOutput.PipingReliability); + Assert.AreEqual(expectedOutput.PipingProbability, actualOutput.PipingProbability); + } + } + private void TearDownTempRingtoetsFile(string filePath) { GC.Collect(); Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/PipingCalculationEntityReadExtensionsTest.cs =================================================================== diff -u -rbba617101367a21a38bf41ad520662058b9012af -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/PipingCalculationEntityReadExtensionsTest.cs (.../PipingCalculationEntityReadExtensionsTest.cs) (revision bba617101367a21a38bf41ad520662058b9012af) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/PipingCalculationEntityReadExtensionsTest.cs (.../PipingCalculationEntityReadExtensionsTest.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -127,6 +127,7 @@ Assert.IsNull(calculation.InputParameters.HydraulicBoundaryLocation); Assert.IsNull(calculation.InputParameters.StochasticSoilModel); Assert.IsNull(calculation.InputParameters.StochasticSoilProfile); + Assert.IsNull(calculation.Output); } [Test] @@ -361,6 +362,64 @@ Assert.IsTrue(collector.Contains(stochasticSoilModelEntity)); } + [Test] + public void Read_EntityWithPipingCalculationOutputEntity_CalculationWithPipingOutput() + { + // Setup + const int outputId = 4578; + var entity = new PipingCalculationEntity + { + EntryPointL = 1m, + ExitPointL = 2m, + DampingFactorExitMean = 1, + SaturatedVolumicWeightOfCoverageLayerMean = 1, + Diameter70Mean = 1, + DarcyPermeabilityMean = 1 + }; + entity.PipingCalculationOutputEntities.Add(new PipingCalculationOutputEntity + { + PipingCalculationOutputEntityId = outputId + }); + + var collector = new ReadConversionCollector(); + + // Call + PipingCalculationScenario calculation = entity.Read(collector, new GeneralPipingInput()); + + // Assert + Assert.IsNotNull(calculation.Output); + Assert.AreEqual(outputId, calculation.Output.StorageId); + } + + [Test] + public void Read_EntityWithPipingSemiProbabilisticOutputEntity_CalculationWithPipingSemiProbabilisticOutput() + { + // Setup + const int outputId = 675; + var entity = new PipingCalculationEntity + { + EntryPointL = 1m, + ExitPointL = 2m, + DampingFactorExitMean = 1, + SaturatedVolumicWeightOfCoverageLayerMean = 1, + Diameter70Mean = 1, + DarcyPermeabilityMean = 1 + }; + entity.PipingSemiProbabilisticOutputEntities.Add(new PipingSemiProbabilisticOutputEntity + { + PipingSemiProbabilisticOutputEntityId = outputId + }); + + var collector = new ReadConversionCollector(); + + // Call + PipingCalculationScenario calculation = entity.Read(collector, new GeneralPipingInput()); + + // Assert + Assert.IsNotNull(calculation.SemiProbabilisticOutput); + Assert.AreEqual(outputId, calculation.SemiProbabilisticOutput.StorageId); + } + private void AssertRoundedDouble(decimal expectedValue, RoundedDouble actualValue) { Assert.AreEqual(Convert.ToDouble(expectedValue), actualValue, actualValue.GetAccuracy()); Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/PipingCalculationOutputEntityReadExtensionsTest.cs =================================================================== diff -u --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/PipingCalculationOutputEntityReadExtensionsTest.cs (revision 0) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/PipingCalculationOutputEntityReadExtensionsTest.cs (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -0,0 +1,90 @@ +// Copyright (C) Stichting Deltares 2016. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using Application.Ringtoets.Storage.DbContext; +using Application.Ringtoets.Storage.Read; + +using NUnit.Framework; + +using Ringtoets.Piping.Data; + +namespace Application.Ringtoets.Storage.Test.Read +{ + [TestFixture] + public class PipingCalculationOutputEntityReadExtensionsTest + { + [Test] + public void Read_ValidEntity_ReturnPipingOutput() + { + // Setup + var entity = new PipingCalculationOutputEntity + { + PipingCalculationOutputEntityId = 123, + HeaveFactorOfSafety = 9.8m, + HeaveZValue = 7.6m, + UpliftZValue = 5.4m, + UpliftFactorOfSafety = 3.2m, + SellmeijerZValue = 1.9m, + SellmeijerFactorOfSafety = 8.7m + }; + + // Call + PipingOutput output = entity.Read(); + + // Assert + Assert.AreEqual(entity.PipingCalculationOutputEntityId, output.StorageId); + Assert.AreEqual(entity.HeaveFactorOfSafety, output.HeaveFactorOfSafety); + Assert.AreEqual(entity.HeaveZValue, output.HeaveZValue); + Assert.AreEqual(entity.SellmeijerFactorOfSafety, output.SellmeijerFactorOfSafety); + Assert.AreEqual(entity.SellmeijerZValue, output.SellmeijerZValue); + Assert.AreEqual(entity.UpliftZValue, output.UpliftZValue); + Assert.AreEqual(entity.UpliftFactorOfSafety, output.UpliftFactorOfSafety); + } + + [Test] + public void Read_ValidEntityWithNullParameterValues_ReturnPipingOutput() + { + // Setup + var entity = new PipingCalculationOutputEntity + { + PipingCalculationOutputEntityId = 645, + HeaveFactorOfSafety = null, + HeaveZValue = null, + UpliftZValue = null, + UpliftFactorOfSafety = null, + SellmeijerZValue = null, + SellmeijerFactorOfSafety = null + }; + + // Call + PipingOutput output = entity.Read(); + + // Assert + Assert.AreEqual(entity.PipingCalculationOutputEntityId, output.StorageId); + Assert.IsNaN(output.HeaveFactorOfSafety); + Assert.IsNaN(output.HeaveZValue); + Assert.IsNaN(output.SellmeijerFactorOfSafety); + Assert.IsNaN(output.SellmeijerZValue); + Assert.IsNaN(output.UpliftZValue); + Assert.IsNaN(output.UpliftFactorOfSafety); + } + } +} \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/PipingSemiProbabilisticOutputEntityReadExtensionsTest.cs =================================================================== diff -u --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/PipingSemiProbabilisticOutputEntityReadExtensionsTest.cs (revision 0) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/PipingSemiProbabilisticOutputEntityReadExtensionsTest.cs (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -0,0 +1,111 @@ +using System; + +using Application.Ringtoets.Storage.DbContext; +using Application.Ringtoets.Storage.Read; + +using Core.Common.Base.Data; + +using NUnit.Framework; + +using Ringtoets.Common.Data.TestUtil; +using Ringtoets.Piping.Data; + +namespace Application.Ringtoets.Storage.Test.Read +{ + [TestFixture] + public class PipingSemiProbabilisticOutputEntityReadExtensionsTest + { + [Test] + public void Read_EntityWithValues_ReturnPipingSemiProbabilisticOutput() + { + // Setup + var entity = new PipingSemiProbabilisticOutputEntity + { + PipingSemiProbabilisticOutputEntityId = 5867, + HeaveFactorOfSafety = 1.1m, + HeaveProbability = 2.2m, + HeaveReliability = 3.3m, + PipingFactorOfSafety = 4.4m, + PipingProbability = 5.5m, + PipingReliability = 6.6m, + UpliftFactorOfSafety = 7.7m, + UpliftProbability = 8.8m, + UpliftReliability = 9.9m, + SellmeijerFactorOfSafety = 10.10m, + SellmeijerProbability = 11.11m, + SellmeijerReliability = 12.12m, + RequiredProbability = 13.13m, + RequiredReliability = 14.14m + }; + + // Call + PipingSemiProbabilisticOutput pipingSemiProbabilisticOutput = entity.Read(); + + // Assert + Assert.AreEqual(entity.PipingSemiProbabilisticOutputEntityId, pipingSemiProbabilisticOutput.StorageId); + AssertAreEqual(entity.HeaveFactorOfSafety, pipingSemiProbabilisticOutput.HeaveFactorOfSafety); + AssertAreEqual(entity.HeaveProbability, pipingSemiProbabilisticOutput.HeaveProbability); + AssertAreEqual(entity.HeaveReliability, pipingSemiProbabilisticOutput.HeaveReliability); + AssertAreEqual(entity.PipingFactorOfSafety, pipingSemiProbabilisticOutput.PipingFactorOfSafety); + AssertAreEqual(entity.PipingProbability, pipingSemiProbabilisticOutput.PipingProbability); + AssertAreEqual(entity.PipingReliability, pipingSemiProbabilisticOutput.PipingReliability); + AssertAreEqual(entity.UpliftFactorOfSafety, pipingSemiProbabilisticOutput.UpliftFactorOfSafety); + AssertAreEqual(entity.UpliftProbability, pipingSemiProbabilisticOutput.UpliftProbability); + AssertAreEqual(entity.UpliftReliability, pipingSemiProbabilisticOutput.UpliftReliability); + AssertAreEqual(entity.SellmeijerFactorOfSafety, pipingSemiProbabilisticOutput.SellmeijerFactorOfSafety); + AssertAreEqual(entity.SellmeijerProbability, pipingSemiProbabilisticOutput.SellmeijerProbability); + AssertAreEqual(entity.SellmeijerReliability, pipingSemiProbabilisticOutput.SellmeijerReliability); + AssertAreEqual(entity.RequiredProbability, pipingSemiProbabilisticOutput.RequiredProbability); + AssertAreEqual(entity.RequiredReliability, pipingSemiProbabilisticOutput.RequiredReliability); + } + + [Test] + public void Read_EntityWithNullValues_ReturnPipingSemiProbabilisticOutput() + { + // Setup + var entity = new PipingSemiProbabilisticOutputEntity + { + PipingSemiProbabilisticOutputEntityId = 670, + HeaveFactorOfSafety = null, + HeaveProbability = null, + HeaveReliability = null, + PipingFactorOfSafety = null, + PipingProbability = null, + PipingReliability = null, + UpliftFactorOfSafety = null, + UpliftProbability = null, + UpliftReliability = null, + SellmeijerFactorOfSafety = null, + SellmeijerProbability = null, + SellmeijerReliability = null, + RequiredProbability = null, + RequiredReliability = null + }; + + // Call + PipingSemiProbabilisticOutput pipingSemiProbabilisticOutput = entity.Read(); + + // Assert + Assert.AreEqual(entity.PipingSemiProbabilisticOutputEntityId, pipingSemiProbabilisticOutput.StorageId); + Assert.IsNaN(pipingSemiProbabilisticOutput.HeaveFactorOfSafety); + Assert.IsNaN(pipingSemiProbabilisticOutput.HeaveProbability); + Assert.IsNaN(pipingSemiProbabilisticOutput.HeaveReliability); + Assert.IsNaN(pipingSemiProbabilisticOutput.PipingFactorOfSafety); + Assert.IsNaN(pipingSemiProbabilisticOutput.PipingProbability); + Assert.IsNaN(pipingSemiProbabilisticOutput.PipingReliability); + Assert.IsNaN(pipingSemiProbabilisticOutput.UpliftFactorOfSafety); + Assert.IsNaN(pipingSemiProbabilisticOutput.UpliftProbability); + Assert.IsNaN(pipingSemiProbabilisticOutput.UpliftReliability); + Assert.IsNaN(pipingSemiProbabilisticOutput.SellmeijerFactorOfSafety); + Assert.IsNaN(pipingSemiProbabilisticOutput.SellmeijerProbability); + Assert.IsNaN(pipingSemiProbabilisticOutput.SellmeijerReliability); + Assert.IsNaN(pipingSemiProbabilisticOutput.RequiredProbability); + Assert.IsNaN(pipingSemiProbabilisticOutput.RequiredReliability); + } + + private static void AssertAreEqual(decimal? expectedParamterValue, RoundedDouble actualParameterValue) + { + Assert.AreEqual(Convert.ToDouble(expectedParamterValue), actualParameterValue, actualParameterValue.GetAccuracy()); + } + } +} \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Update/PipingCalculationScenarioUpdateExtensionsTest.cs =================================================================== diff -u -rd86b1c6e4ebde1570bec162a9043bbb437de5d9c -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Update/PipingCalculationScenarioUpdateExtensionsTest.cs (.../PipingCalculationScenarioUpdateExtensionsTest.cs) (revision d86b1c6e4ebde1570bec162a9043bbb437de5d9c) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Update/PipingCalculationScenarioUpdateExtensionsTest.cs (.../PipingCalculationScenarioUpdateExtensionsTest.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -1,4 +1,5 @@ using System; +using System.Linq; using Application.Ringtoets.Storage.Create; using Application.Ringtoets.Storage.DbContext; @@ -574,6 +575,373 @@ CollectionAssert.Contains(context.PipingCalculationEntities, entity); mocks.VerifyAll(); } + + [Test] + public void Update_PipingCalculationWithNewPipingOutput_PipingCalculationEntityUpdated() + { + // Setup + var mocks = new MockRepository(); + var context = RingtoetsEntitiesHelper.CreateStub(mocks); + mocks.ReplayAll(); + + var entity = new PipingCalculationEntity + { + PipingCalculationEntityId = 453 + }; + context.PipingCalculationEntities.Add(entity); + + var registry = new PersistenceRegistry(); + + var calculation = new PipingCalculationScenario(new GeneralPipingInput()) + { + StorageId = entity.PipingCalculationEntityId, + Output = new PipingOutput(1,1,1,1,1,1), + InputParameters = + { + EntryPointL = (RoundedDouble)1.1, + ExitPointL = (RoundedDouble)2.2, + DampingFactorExit = + { + Mean = (RoundedDouble)1 + }, + SaturatedVolumicWeightOfCoverageLayer = + { + Mean = (RoundedDouble)1 + }, + Diameter70 = + { + Mean = (RoundedDouble)1 + }, + DarcyPermeability = + { + Mean = (RoundedDouble)1 + } + } + }; + + // Call + calculation.Update(registry, context); + + // Assert + Assert.AreEqual(1, entity.PipingCalculationOutputEntities.Count); + + PipingCalculationOutputEntity pipingCalculationOutputEntity = entity.PipingCalculationOutputEntities.First(); + pipingCalculationOutputEntity.PipingCalculationOutputEntityId = 495876; + registry.TransferIds(); + Assert.AreEqual(pipingCalculationOutputEntity.PipingCalculationOutputEntityId, calculation.Output.StorageId, + "New PipingCalculationOutputEntity should be registered to PersistenceRegistry."); + mocks.VerifyAll(); + } + + [Test] + public void Update_PipingCalculationWithUnchangedPipingOutput_PipingCalculationOutputEntityIsRegistered() + { + // Setup + var mocks = new MockRepository(); + var context = RingtoetsEntitiesHelper.CreateStub(mocks); + mocks.ReplayAll(); + + var calculationOutputEntity = new PipingCalculationOutputEntity + { + PipingCalculationOutputEntityId = 45 + }; + var entity = new PipingCalculationEntity + { + PipingCalculationEntityId = 453 + }; + entity.PipingCalculationOutputEntities.Add(calculationOutputEntity); + context.PipingCalculationEntities.Add(entity); + context.PipingCalculationOutputEntities.Add(calculationOutputEntity); + + var registry = new PersistenceRegistry(); + + var calculation = new PipingCalculationScenario(new GeneralPipingInput()) + { + StorageId = entity.PipingCalculationEntityId, + Output = new PipingOutput(1, 1, 1, 1, 1, 1) + { + StorageId = calculationOutputEntity.PipingCalculationOutputEntityId + }, + InputParameters = + { + EntryPointL = (RoundedDouble)1.1, + ExitPointL = (RoundedDouble)2.2, + DampingFactorExit = + { + Mean = (RoundedDouble)1 + }, + SaturatedVolumicWeightOfCoverageLayer = + { + Mean = (RoundedDouble)1 + }, + Diameter70 = + { + Mean = (RoundedDouble)1 + }, + DarcyPermeability = + { + Mean = (RoundedDouble)1 + } + } + }; + + // Call + calculation.Update(registry, context); + + // Assert + CollectionAssert.Contains(context.PipingCalculationOutputEntities, calculationOutputEntity); + registry.RemoveUntouched(context); + CollectionAssert.Contains(context.PipingCalculationOutputEntities, calculationOutputEntity); + mocks.VerifyAll(); + } + + [Test] + public void Update_PipingCalculationWithRemovedPipingOutput_PipingCalculationEntityUpdated() + { + // Setup + var mocks = new MockRepository(); + var context = RingtoetsEntitiesHelper.CreateStub(mocks); + mocks.ReplayAll(); + + var calculationOutputEntity = new PipingCalculationOutputEntity + { + PipingCalculationOutputEntityId = 45 + }; + var entity = new PipingCalculationEntity + { + PipingCalculationEntityId = 453 + }; + entity.PipingCalculationOutputEntities.Add(calculationOutputEntity); + context.PipingCalculationEntities.Add(entity); + context.PipingCalculationOutputEntities.Add(calculationOutputEntity); + + var registry = new PersistenceRegistry(); + + var calculation = new PipingCalculationScenario(new GeneralPipingInput()) + { + StorageId = entity.PipingCalculationEntityId, + Output = null, + InputParameters = + { + EntryPointL = (RoundedDouble)1.1, + ExitPointL = (RoundedDouble)2.2, + DampingFactorExit = + { + Mean = (RoundedDouble)1 + }, + SaturatedVolumicWeightOfCoverageLayer = + { + Mean = (RoundedDouble)1 + }, + Diameter70 = + { + Mean = (RoundedDouble)1 + }, + DarcyPermeability = + { + Mean = (RoundedDouble)1 + } + } + }; + + // Call + calculation.Update(registry, context); + + // Assert + CollectionAssert.IsEmpty(entity.PipingCalculationOutputEntities); + + registry.RemoveUntouched(context); + CollectionAssert.DoesNotContain(context.PipingCalculationOutputEntities, calculationOutputEntity); + mocks.VerifyAll(); + } + + [Test] + public void Update_PipingCalculationWithNewSemiProbabilisticOutput_PipingCalculationEntityUpdated() + { + // Setup + var mocks = new MockRepository(); + var context = RingtoetsEntitiesHelper.CreateStub(mocks); + mocks.ReplayAll(); + + var entity = new PipingCalculationEntity + { + PipingCalculationEntityId = 453 + }; + context.PipingCalculationEntities.Add(entity); + + var registry = new PersistenceRegistry(); + + var calculation = new PipingCalculationScenario(new GeneralPipingInput()) + { + StorageId = entity.PipingCalculationEntityId, + SemiProbabilisticOutput = new PipingSemiProbabilisticOutput(1, 1, 1, + 1, 1, 1, + 1, 1, 1, + 1, 1, + 1, 1, 1), + InputParameters = + { + EntryPointL = (RoundedDouble)1.1, + ExitPointL = (RoundedDouble)2.2, + DampingFactorExit = + { + Mean = (RoundedDouble)1 + }, + SaturatedVolumicWeightOfCoverageLayer = + { + Mean = (RoundedDouble)1 + }, + Diameter70 = + { + Mean = (RoundedDouble)1 + }, + DarcyPermeability = + { + Mean = (RoundedDouble)1 + } + } + }; + + // Call + calculation.Update(registry, context); + + // Assert + Assert.AreEqual(1, entity.PipingSemiProbabilisticOutputEntities.Count); + + PipingSemiProbabilisticOutputEntity semiProbabilisticOutputEntity = entity.PipingSemiProbabilisticOutputEntities.First(); + semiProbabilisticOutputEntity.PipingSemiProbabilisticOutputEntityId = 546; + registry.TransferIds(); + Assert.AreEqual(semiProbabilisticOutputEntity.PipingSemiProbabilisticOutputEntityId, calculation.SemiProbabilisticOutput.StorageId, + "New PipingSemiProbabilisticOutputEntity should be registered to PersistenceRegistry."); + mocks.VerifyAll(); + } + + [Test] + public void Update_PipingCalculationWithUnchangedSemiProbabilisticOutput_PipingSemiProbabilisticOutputEntityIsRegistered() + { + // Setup + var mocks = new MockRepository(); + var context = RingtoetsEntitiesHelper.CreateStub(mocks); + mocks.ReplayAll(); + + var semiProbabilisticOutputEntity = new PipingSemiProbabilisticOutputEntity + { + PipingSemiProbabilisticOutputEntityId = 549876 + }; + var entity = new PipingCalculationEntity + { + PipingCalculationEntityId = 453 + }; + entity.PipingSemiProbabilisticOutputEntities.Add(semiProbabilisticOutputEntity); + context.PipingCalculationEntities.Add(entity); + context.PipingSemiProbabilisticOutputEntities.Add(semiProbabilisticOutputEntity); + + var registry = new PersistenceRegistry(); + + var calculation = new PipingCalculationScenario(new GeneralPipingInput()) + { + StorageId = entity.PipingCalculationEntityId, + SemiProbabilisticOutput = new PipingSemiProbabilisticOutput(1, 1, 1, + 1, 1, 1, + 1, 1, 1, + 1, 1, + 1, 1, 1) + { + StorageId = semiProbabilisticOutputEntity.PipingSemiProbabilisticOutputEntityId + }, + InputParameters = + { + EntryPointL = (RoundedDouble)1.1, + ExitPointL = (RoundedDouble)2.2, + DampingFactorExit = + { + Mean = (RoundedDouble)1 + }, + SaturatedVolumicWeightOfCoverageLayer = + { + Mean = (RoundedDouble)1 + }, + Diameter70 = + { + Mean = (RoundedDouble)1 + }, + DarcyPermeability = + { + Mean = (RoundedDouble)1 + } + } + }; + + // Call + calculation.Update(registry, context); + + // Assert + CollectionAssert.Contains(context.PipingSemiProbabilisticOutputEntities, semiProbabilisticOutputEntity); + registry.RemoveUntouched(context); + CollectionAssert.Contains(context.PipingSemiProbabilisticOutputEntities, semiProbabilisticOutputEntity); + mocks.VerifyAll(); + } + + [Test] + public void Update_PipingCalculationWithRemovedSemiProbabilisticOutput_PipingCalculationEntityUpdated() + { + // Setup + var mocks = new MockRepository(); + var context = RingtoetsEntitiesHelper.CreateStub(mocks); + mocks.ReplayAll(); + + var semiProbabilisticOutputEntity = new PipingSemiProbabilisticOutputEntity + { + PipingSemiProbabilisticOutputEntityId = 54976 + }; + var entity = new PipingCalculationEntity + { + PipingCalculationEntityId = 453 + }; + entity.PipingSemiProbabilisticOutputEntities.Add(semiProbabilisticOutputEntity); + context.PipingCalculationEntities.Add(entity); + context.PipingSemiProbabilisticOutputEntities.Add(semiProbabilisticOutputEntity); + + var registry = new PersistenceRegistry(); + + var calculation = new PipingCalculationScenario(new GeneralPipingInput()) + { + StorageId = entity.PipingCalculationEntityId, + SemiProbabilisticOutput = null, + InputParameters = + { + EntryPointL = (RoundedDouble)1.1, + ExitPointL = (RoundedDouble)2.2, + DampingFactorExit = + { + Mean = (RoundedDouble)1 + }, + SaturatedVolumicWeightOfCoverageLayer = + { + Mean = (RoundedDouble)1 + }, + Diameter70 = + { + Mean = (RoundedDouble)1 + }, + DarcyPermeability = + { + Mean = (RoundedDouble)1 + } + } + }; + + // Call + calculation.Update(registry, context); + + // Assert + CollectionAssert.IsEmpty(entity.PipingSemiProbabilisticOutputEntities); + + registry.RemoveUntouched(context); + CollectionAssert.DoesNotContain(context.PipingSemiProbabilisticOutputEntities, semiProbabilisticOutputEntity); + mocks.VerifyAll(); + } + private decimal? ToNullableDecimal(RoundedDouble roundedDoubleValue) { if (double.IsNaN(roundedDoubleValue)) Index: Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectHelper.cs =================================================================== diff -u -rbba617101367a21a38bf41ad520662058b9012af -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectHelper.cs (.../RingtoetsProjectHelper.cs) (revision bba617101367a21a38bf41ad520662058b9012af) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectHelper.cs (.../RingtoetsProjectHelper.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -133,7 +133,13 @@ Mean = (RoundedDouble)10.10, StandardDeviation = (RoundedDouble)11.11 } - } + }, + Output = new PipingOutput(1.1, 2.2, 3.3, 4.4, 5.5, 6.6), + SemiProbabilisticOutput = new PipingSemiProbabilisticOutput(7.7, 8.8, 9.9, + 10.10, 11.11, 12.12, + 13.13, 14.14, 15.15, + 16.16, 17.17, + 18.18, 19.19, 20.20) } } }); @@ -182,7 +188,9 @@ Mean = (RoundedDouble)21.21, StandardDeviation = (RoundedDouble)22.22 } - } + }, + Output = null, + SemiProbabilisticOutput = null }); var fullTestProject = new Project Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingSemiProbabilisticOutput.cs =================================================================== diff -u -rfff12e249602fb700b2854c14a3b7cdd0b73c023 -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingSemiProbabilisticOutput.cs (.../PipingSemiProbabilisticOutput.cs) (revision fff12e249602fb700b2854c14a3b7cdd0b73c023) +++ Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingSemiProbabilisticOutput.cs (.../PipingSemiProbabilisticOutput.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -1,12 +1,13 @@ using Core.Common.Base.Data; +using Core.Common.Base.Storage; namespace Ringtoets.Piping.Data { /// /// This class contains the results of a semi-probabilistic assessment of the piping /// failure mechanism. /// - public class PipingSemiProbabilisticOutput + public class PipingSemiProbabilisticOutput : IStorable { /// /// Creates a new instance of . @@ -21,11 +22,15 @@ /// The reliability of the Sellmeijer sub-mechanism. /// The probability of failure due to the Sellmeijer sub-mechanism. /// The required (maximum allowed) probability of failure due to piping. - /// The required (maximum allowed) reliabiality of the piping failure mechanism + /// The required (maximum allowed) reliability of the piping failure mechanism /// The calculated probability of failing due to piping. /// The calculated reliability of the piping failure mechanism. /// The factor of safety for the piping failure mechanism. - public PipingSemiProbabilisticOutput(double upliftFactorOfSafety, double upliftReliability, double upliftProbability, double heaveFactorOfSafety, double heaveReliability, double heaveProbability, double sellmeijerFactorOfSafety, double sellmeijerReliability, double sellmeijerProbability, double requiredProbability, double requiredReliability, double pipingProbability, double pipingReliability, double pipingFactorOfSafety) + public PipingSemiProbabilisticOutput(double upliftFactorOfSafety, double upliftReliability, double upliftProbability, + double heaveFactorOfSafety, double heaveReliability, double heaveProbability, + double sellmeijerFactorOfSafety, double sellmeijerReliability, double sellmeijerProbability, + double requiredProbability, double requiredReliability, + double pipingProbability, double pipingReliability, double pipingFactorOfSafety) { UpliftFactorOfSafety = new RoundedDouble(3, upliftFactorOfSafety); UpliftReliability = new RoundedDouble(3, upliftReliability); @@ -113,5 +118,7 @@ /// Gets the probability of failing due to the Sellmeijer failure sub-mechanism. /// public RoundedDouble SellmeijerProbability { get; private set; } + + public long StorageId { get; set; } } } \ No newline at end of file Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs =================================================================== diff -u -rc196992ccccf32ce0fd55b83a17e3f3574467a1e -r450de34f5b9bea646121b6e101c849f9f78dfc51 --- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs (.../PipingSemiProbabilisticOutputTest.cs) (revision c196992ccccf32ce0fd55b83a17e3f3574467a1e) +++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs (.../PipingSemiProbabilisticOutputTest.cs) (revision 450de34f5b9bea646121b6e101c849f9f78dfc51) @@ -20,6 +20,9 @@ // All rights reserved. using System; + +using Core.Common.Base.Storage; + using NUnit.Framework; using Ringtoets.Common.Data.TestUtil; @@ -65,6 +68,8 @@ pipingFactorOfSafety); // Assert + Assert.IsInstanceOf(output); + Assert.AreEqual(upliftFactorOfSafety, output.UpliftFactorOfSafety, output.UpliftFactorOfSafety.GetAccuracy()); Assert.AreEqual(upliftReliability, output.UpliftReliability, output.UpliftReliability.GetAccuracy()); Assert.AreEqual(upliftProbability, output.UpliftProbability, output.UpliftProbability.GetAccuracy()); @@ -79,6 +84,8 @@ Assert.AreEqual(pipingProbability, output.PipingProbability, output.PipingProbability.GetAccuracy()); Assert.AreEqual(pipingReliability, output.PipingReliability, output.PipingReliability.GetAccuracy()); Assert.AreEqual(pipingFactorOfSafety, output.PipingFactorOfSafety, output.PipingFactorOfSafety.GetAccuracy()); + + Assert.AreEqual(0, output.StorageId); } } } \ No newline at end of file