private static bool ExportCalculationsForTargetProbability( Tuple <IEnumerable <HydraulicBoundaryLocationCalculation>, double> calculationsForTargetProbability, HydraulicBoundaryLocationCalculationsType calculationsType, ICollection <string> exportedCalculationFileNames, string folderPath) { IEnumerable <HydraulicBoundaryLocationCalculation> calculations = calculationsForTargetProbability.Item1; double targetProbability = calculationsForTargetProbability.Item2; string exportType = calculationsType == HydraulicBoundaryLocationCalculationsType.WaterLevel ? Resources.WaterLevels_DisplayName : Resources.WaveHeights_DisplayName; string uniqueName = NamingHelper.GetUniqueName( exportedCalculationFileNames, $"{exportType}_{ReturnPeriodFormattingHelper.FormatFromProbability(targetProbability)}", c => c); exportedCalculationFileNames.Add(uniqueName); string tempFilePath = Path.Combine(folderPath, $"{uniqueName}.{RiskeerCommonIOResources.Shape_file_filter_Extension}"); var exporter = new HydraulicBoundaryLocationCalculationsForTargetProbabilityExporter( calculations, tempFilePath, calculationsType); return(exporter.Export()); }
private static bool ExportLocationCalculationsForTargetProbabilities( IEnumerable <Tuple <IEnumerable <HydraulicBoundaryLocationCalculation>, double> > calculationsForTargetProbabilities, HydraulicBoundaryLocationCalculationsType calculationsType, string folderPath) { return(HydraulicBoundaryLocationCalculationsExportHelper.ExportLocationCalculationsForTargetProbabilities( calculationsForTargetProbabilities, calculationsType, folderPath)); }
/// <summary> /// Creates a new instance of <see cref="HydraulicBoundaryLocationCalculationsForTargetProbabilitiesExporter"/>. /// </summary> /// <param name="locationCalculationsForTargetProbabilities">The collection of calculations to export.</param> /// <param name="calculationsType">The type of the calculations to export.</param> /// <param name="filePath">The path of the file to export to.</param> /// <exception cref="ArgumentNullException">Thrown when <paramref name="locationCalculationsForTargetProbabilities"/> /// is <c>null</c>.</exception> /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="calculationsType"/> /// is invalid.</exception> /// <exception cref="ArgumentException">Thrown when <paramref name="filePath"/> is invalid.</exception> public HydraulicBoundaryLocationCalculationsForTargetProbabilitiesExporter( IEnumerable <Tuple <IEnumerable <HydraulicBoundaryLocationCalculation>, double> > locationCalculationsForTargetProbabilities, HydraulicBoundaryLocationCalculationsType calculationsType, string filePath) { if (locationCalculationsForTargetProbabilities == null) { throw new ArgumentNullException(nameof(locationCalculationsForTargetProbabilities)); } if (!Enum.IsDefined(typeof(HydraulicBoundaryLocationCalculationsType), calculationsType)) { throw new InvalidEnumArgumentException(nameof(calculationsType), (int)calculationsType, typeof(HydraulicBoundaryLocationCalculationsType)); } IOUtils.ValidateFilePath(filePath); this.locationCalculationsForTargetProbabilities = locationCalculationsForTargetProbabilities; this.calculationsType = calculationsType; this.filePath = filePath; string folderPath = Path.GetDirectoryName(filePath); tempFolderPath = Path.Combine(folderPath, "~temp"); }
private static string GetExpectedShapeFileName(HydraulicBoundaryLocationCalculationsType calculationsType, double targetProbability) { string exportType = calculationsType == HydraulicBoundaryLocationCalculationsType.WaterLevel ? "Waterstanden" : "Golfhoogten"; return($"{exportType}_{ReturnPeriodFormattingHelper.FormatFromProbability(targetProbability)}"); }
public void Constructor_InvalidHydraulicBoundaryLocationCalculationsType_ThrowsInvalidEnumArgumentException() { // Setup const HydraulicBoundaryLocationCalculationsType calculationsType = (HydraulicBoundaryLocationCalculationsType)99; // Call void Call() => new HydraulicBoundaryLocationCalculationsForTargetProbabilitiesExporter( Enumerable.Empty <Tuple <IEnumerable <HydraulicBoundaryLocationCalculation>, double> >(), calculationsType, string.Empty); // Assert var expectedMessage = $"The value of argument 'calculationsType' ({calculationsType}) is invalid for Enum type '{nameof(HydraulicBoundaryLocationCalculationsType)}'."; var exception = TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, expectedMessage); Assert.AreEqual("calculationsType", exception.ParamName); }
private static MapPointData CreateCalculationData(HydraulicBoundaryLocationCalculation calculation, HydraulicBoundaryLocationCalculationsType calculationsType) { string metaDataHeader = calculationsType == HydraulicBoundaryLocationCalculationsType.WaterLevel ? Resources.HydraulicBoundaryLocationCalculationsWriter_WaterLevelCalculationType_WaterLevel_DisplayName : Resources.HydraulicBoundaryLocationCalculationsWriter_WaterLevelCalculationType_WaveHeight_DisplayName; return(new MapPointData(calculation.HydraulicBoundaryLocation.Name) { Features = new[] { HydraulicBoundaryLocationMapDataFeaturesFactory.CreateHydraulicBoundaryLocationCalculationFeature( calculation, metaDataHeader) } }); }
public void WriteHydraulicBoundaryLocationCalculations_InvalidHydraulicBoundaryLocationCalculationsType_ThrowsInvalidEnumArgumentException() { // Setup const HydraulicBoundaryLocationCalculationsType hydraulicBoundaryLocationCalculationsType = (HydraulicBoundaryLocationCalculationsType)99; // Call void Call() => HydraulicBoundaryLocationCalculationsForTargetProbabilityWriter.WriteHydraulicBoundaryLocationCalculations( Enumerable.Empty <HydraulicBoundaryLocationCalculation>(), string.Empty, hydraulicBoundaryLocationCalculationsType); // Assert string expectedMessage = $"The value of argument 'calculationsType' ({hydraulicBoundaryLocationCalculationsType}) " + $"is invalid for Enum type '{nameof(HydraulicBoundaryLocationCalculationsType)}'."; var exception = TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, expectedMessage); Assert.AreEqual("calculationsType", exception.ParamName); }
public void Constructor_InvalidHydraulicBoundaryLocationCalculationsType_ThrowsInvalidEnumArgumentException() { // Setup string filePath = TestHelper.GetScratchPadPath(Path.Combine("export", "test.shp")); const HydraulicBoundaryLocationCalculationsType hydraulicBoundaryLocationCalculationsType = (HydraulicBoundaryLocationCalculationsType)99; // Call void Call() => new HydraulicBoundaryLocationCalculationsForTargetProbabilityExporter( Enumerable.Empty <HydraulicBoundaryLocationCalculation>(), filePath, hydraulicBoundaryLocationCalculationsType); // Assert string expectedMessage = $"The value of argument 'calculationsType' ({hydraulicBoundaryLocationCalculationsType}) " + $"is invalid for Enum type '{nameof(HydraulicBoundaryLocationCalculationsType)}'."; var exception = TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, expectedMessage); Assert.AreEqual("calculationsType", exception.ParamName); }
public void Export_WithHydraulicBoundaryLocationCalculationsForTargetProbabilities_WritesFilesAndReturnsTrue( HydraulicBoundaryLocationCalculationsType calculationsType, string expectedCalculationsTypeName) { // Setup string directoryPath = TestHelper.GetScratchPadPath(nameof(Export_WithHydraulicBoundaryLocationCalculationsForTargetProbabilities_WritesFilesAndReturnsTrue)); Directory.CreateDirectory(directoryPath); string filePath = Path.Combine(directoryPath, "export.zip"); var random = new Random(21); var calculationsForTargetProbabilities = new[] { new Tuple <IEnumerable <HydraulicBoundaryLocationCalculation>, double>( new List <HydraulicBoundaryLocationCalculation>(), random.NextDouble(0, 0.1)), new Tuple <IEnumerable <HydraulicBoundaryLocationCalculation>, double>( new List <HydraulicBoundaryLocationCalculation>(), random.NextDouble(0, 0.01)) }; var exporter = new HydraulicBoundaryLocationCalculationsForTargetProbabilitiesExporter( calculationsForTargetProbabilities, calculationsType, filePath); try { // Call bool isExported = exporter.Export(); // Assert Assert.IsTrue(isExported); string[] expectedFiles = { $"{expectedCalculationsTypeName}_{GetReturnPeriodText(calculationsForTargetProbabilities.First().Item2)}.shp", $"{expectedCalculationsTypeName}_{GetReturnPeriodText(calculationsForTargetProbabilities.Last().Item2)}.shp" }; using (ZipArchive zipArchive = ZipFile.OpenRead(filePath)) { CollectionAssert.IsSubsetOf(expectedFiles, zipArchive.Entries.Select(e => e.FullName)); } } finally { DirectoryHelper.TryDelete(directoryPath); } }
/// <summary> /// Creates a new instance of <see cref="HydraulicBoundaryLocationCalculationsForTargetProbabilityExporter"/>. /// </summary> /// <param name="calculations">The calculations to export.</param> /// <param name="filePath">The path of the file to export to.</param> /// <param name="calculationsType">The type of calculations.</param> /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculations"/> is <c>null</c>.</exception> /// <exception cref="ArgumentException">Thrown when <paramref name="filePath"/> is invalid.</exception> /// <exception cref="InvalidEnumArgumentException">Thrown when the <see cref="calculationsType"/> /// is an invalid value.</exception> public HydraulicBoundaryLocationCalculationsForTargetProbabilityExporter(IEnumerable <HydraulicBoundaryLocationCalculation> calculations, string filePath, HydraulicBoundaryLocationCalculationsType calculationsType) { if (calculations == null) { throw new ArgumentNullException(nameof(calculations)); } IOUtils.ValidateFilePath(filePath); if (!Enum.IsDefined(typeof(HydraulicBoundaryLocationCalculationsType), calculationsType)) { throw new InvalidEnumArgumentException(nameof(calculationsType), (int)calculationsType, typeof(HydraulicBoundaryLocationCalculationsType)); } this.calculations = calculations; this.filePath = filePath; this.calculationsType = calculationsType; }
public void Export_ValidData_ReturnsTrueAndWritesCorrectData(HydraulicBoundaryLocationCalculationsType calculationsType, string expectedExportFileName) { // Setup const string fileName = "test"; string directoryPath = TestHelper.GetScratchPadPath(nameof(Export_ValidData_ReturnsTrueAndWritesCorrectData)); Directory.CreateDirectory(directoryPath); string filePath = Path.Combine(directoryPath, $"{fileName}.shp"); var exporter = new HydraulicBoundaryLocationCalculationsForTargetProbabilityExporter(new[] { new HydraulicBoundaryLocationCalculation(new HydraulicBoundaryLocation(123, "aName", 1.1, 2.2)) }, filePath, calculationsType); // Precondition FileTestHelper.AssertEssentialShapefilesExist(directoryPath, fileName, false); try { // Call bool isExported = exporter.Export(); // Assert FileTestHelper.AssertEssentialShapefilesExist(directoryPath, fileName, true); FileTestHelper.AssertEssentialShapefileMd5Hashes( directoryPath, fileName, Path.Combine(TestHelper.GetTestDataPath(TestDataPath.Riskeer.Integration.IO), nameof(HydraulicBoundaryLocationCalculationsForTargetProbabilityExporter)), expectedExportFileName, 28, 8, 628); Assert.IsTrue(isExported); } finally { DirectoryHelper.TryDelete(directoryPath); } }
/// <summary> /// Exports the location calculations for a collection of target probabilities. /// </summary> /// <param name="calculationsForTargetProbabilities">The collection of calculations to export.</param> /// <param name="calculationsType">The type of the calculations.</param> /// <param name="folderPath">The path of the folder to export to.</param> /// <returns><c>true</c> when the export was successful; <c>false</c> otherwise.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationsForTargetProbabilities"/> is <c>null</c>.</exception> /// <exception cref="ArgumentException">Thrown when <paramref name="folderPath"/> is invalid.</exception> /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="calculationsType"/> /// is invalid.</exception> public static bool ExportLocationCalculationsForTargetProbabilities( IEnumerable <Tuple <IEnumerable <HydraulicBoundaryLocationCalculation>, double> > calculationsForTargetProbabilities, HydraulicBoundaryLocationCalculationsType calculationsType, string folderPath) { if (calculationsForTargetProbabilities == null) { throw new ArgumentNullException(nameof(calculationsForTargetProbabilities)); } if (!Enum.IsDefined(typeof(HydraulicBoundaryLocationCalculationsType), calculationsType)) { throw new InvalidEnumArgumentException(nameof(calculationsType), (int)calculationsType, typeof(HydraulicBoundaryLocationCalculationsType)); } IOUtils.ValidateFolderPath(folderPath); var exportedCalculationFileNames = new List <string>(); return(calculationsForTargetProbabilities.All(calculations => ExportCalculationsForTargetProbability( calculations, calculationsType, exportedCalculationFileNames, folderPath))); }
public void ExportLocationCalculationsForTargetProbabilities_ValidData_ReturnsTrueAndWritesCorrectData(HydraulicBoundaryLocationCalculationsType calculationsType, string expectedExportFileName) { // Setup const double targetProbability = 0.05; string directoryPath = TestHelper.GetScratchPadPath(nameof(ExportLocationCalculationsForTargetProbabilities_ValidData_ReturnsTrueAndWritesCorrectData)); Directory.CreateDirectory(directoryPath); string shapeFileName = GetExpectedShapeFileName(calculationsType, targetProbability); // Precondition FileTestHelper.AssertEssentialShapefilesExist(directoryPath, $"{shapeFileName}.shp", false); try { // Call bool isExported = HydraulicBoundaryLocationCalculationsExportHelper.ExportLocationCalculationsForTargetProbabilities( new[] { new Tuple <IEnumerable <HydraulicBoundaryLocationCalculation>, double>(new[] { new HydraulicBoundaryLocationCalculation(new HydraulicBoundaryLocation(123, "aName", 1.1, 2.2)) }, targetProbability) }, calculationsType, directoryPath); // Assert Assert.IsTrue(isExported); FileTestHelper.AssertEssentialShapefilesExist(directoryPath, shapeFileName, true); FileTestHelper.AssertEssentialShapefileMd5Hashes( directoryPath, shapeFileName, Path.Combine(TestHelper.GetTestDataPath(TestDataPath.Riskeer.Integration.IO), nameof(HydraulicBoundaryLocationCalculationsExportHelper)), expectedExportFileName, 28, 8, 628); } finally { DirectoryHelper.TryDelete(directoryPath); } }
public void ExportLocationCalculationsForTargetProbabilities_DuplicateTargetProbability_ReturnsTrueAndWritesExpectedFiles(HydraulicBoundaryLocationCalculationsType calculationsType) { // Setup const double targetProbability = 0.00005; string directoryPath = TestHelper.GetScratchPadPath(nameof(ExportLocationCalculationsForTargetProbabilities_DuplicateTargetProbability_ReturnsTrueAndWritesExpectedFiles)); Directory.CreateDirectory(directoryPath); string shapeFileName = GetExpectedShapeFileName(calculationsType, targetProbability); // Precondition FileTestHelper.AssertEssentialShapefilesExist(directoryPath, $"{shapeFileName}.shp", false); try { // Call bool isExported = HydraulicBoundaryLocationCalculationsExportHelper.ExportLocationCalculationsForTargetProbabilities( new[] { new Tuple <IEnumerable <HydraulicBoundaryLocationCalculation>, double>( Enumerable.Empty <HydraulicBoundaryLocationCalculation>(), targetProbability), new Tuple <IEnumerable <HydraulicBoundaryLocationCalculation>, double>( Enumerable.Empty <HydraulicBoundaryLocationCalculation>(), targetProbability) }, calculationsType, directoryPath); // Assert Assert.IsTrue(isExported); FileTestHelper.AssertEssentialShapefilesExist(directoryPath, shapeFileName, true); FileTestHelper.AssertEssentialShapefilesExist(directoryPath, $"{shapeFileName} (1)", true); } finally { DirectoryHelper.TryDelete(directoryPath); } }
/// <summary> /// Writes the collection of <see cref="HydraulicBoundaryLocationCalculation"/> as point features in a shapefile. /// </summary> /// <param name="calculations">The hydraulic boundary locations calculations to be written to file.</param> /// <param name="filePath">The path to the shapefile.</param> /// <param name="calculationsType">The type of calculations.</param> /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculations"/> or /// <paramref name="filePath"/> is <c>null</c>.</exception> /// <exception cref="ArgumentException">Thrown when <paramref name="filePath"/> is invalid.</exception> /// <exception cref="InvalidEnumArgumentException">Thrown when the <see cref="calculationsType"/> /// is an invalid value.</exception> /// <exception cref="CriticalFileWriteException">Thrown when the shapefile cannot be written.</exception> public static void WriteHydraulicBoundaryLocationCalculations(IEnumerable <HydraulicBoundaryLocationCalculation> calculations, string filePath, HydraulicBoundaryLocationCalculationsType calculationsType) { if (calculations == null) { throw new ArgumentNullException(nameof(calculations)); } if (filePath == null) { throw new ArgumentNullException(nameof(filePath)); } if (!Enum.IsDefined(typeof(HydraulicBoundaryLocationCalculationsType), calculationsType)) { throw new InvalidEnumArgumentException(nameof(calculationsType), (int)calculationsType, typeof(HydraulicBoundaryLocationCalculationsType)); } var pointShapeFileWriter = new PointShapeFileWriter(); foreach (MapPointData mapDataLocation in calculations.Select(c => CreateCalculationData(c, calculationsType))) { pointShapeFileWriter.CopyToFeature(mapDataLocation); } pointShapeFileWriter.SaveAs(filePath); }
public void WriteHydraulicBoundaryLocationCalculations_ValidData_WritesShapeFile(HydraulicBoundaryLocationCalculationsType calculationsType, string expectedExportFileName) { // Setup const string fileName = "test"; string directoryPath = TestHelper.GetScratchPadPath(nameof(WriteHydraulicBoundaryLocationCalculations_ValidData_WritesShapeFile)); string filePath = Path.Combine(directoryPath, $"{fileName}.shp"); // Precondition FileTestHelper.AssertEssentialShapefilesExist(directoryPath, fileName, false); var calculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation("location 1")) { Output = new TestHydraulicBoundaryLocationCalculationOutput(0.1) }; try { // Call HydraulicBoundaryLocationCalculationsForTargetProbabilityWriter.WriteHydraulicBoundaryLocationCalculations(new[] { calculation }, filePath, calculationsType); // Assert FileTestHelper.AssertEssentialShapefilesExist(directoryPath, fileName, true); FileTestHelper.AssertEssentialShapefileMd5Hashes( directoryPath, fileName, Path.Combine(TestHelper.GetTestDataPath(TestDataPath.Riskeer.Integration.IO), nameof(HydraulicBoundaryLocationCalculationsForTargetProbabilityWriter)), expectedExportFileName, 28, 8, 628); } finally { DirectoryHelper.TryDelete(directoryPath); } }