Index: Demo/Ringtoets/src/Demo.Ringtoets/Commands/AddNewDemoAssessmentSectionCommand.cs =================================================================== diff -u -r240fbc1c83da30eae57a9dace4f4a136c8213437 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Demo/Ringtoets/src/Demo.Ringtoets/Commands/AddNewDemoAssessmentSectionCommand.cs (.../AddNewDemoAssessmentSectionCommand.cs) (revision 240fbc1c83da30eae57a9dace4f4a136c8213437) +++ Demo/Ringtoets/src/Demo.Ringtoets/Commands/AddNewDemoAssessmentSectionCommand.cs (.../AddNewDemoAssessmentSectionCommand.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -31,13 +31,13 @@ using Ringtoets.Common.Data.AssessmentSection; using Ringtoets.Common.Data.FailureMechanism; using Ringtoets.Common.Data.Probabilistics; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.Common.IO.ReferenceLines; using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.GrassCoverErosionOutwards.Data; using Ringtoets.HeightStructures.Data; using Ringtoets.HydraRing.Data; using Ringtoets.Integration.Data; -using Ringtoets.Integration.Plugin.FileImporters; using Ringtoets.Piping.Data; using Ringtoets.Piping.Plugin.FileImporter; using Ringtoets.StabilityPointStructures.Data; Index: Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/DikeProfilesImporter.cs =================================================================== diff -u --- Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/DikeProfilesImporter.cs (revision 0) +++ Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/DikeProfilesImporter.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,122 @@ +// 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 System.Collections.Generic; +using System.Linq; +using Core.Common.Base; +using Core.Common.IO.Readers; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.DikeProfiles; +using Ringtoets.Common.IO.DikeProfiles; +using Ringtoets.Common.IO.Properties; + +namespace Ringtoets.Common.IO.FileImporters +{ + /// + /// Imports point shapefiles containing dike profile locations and text files containing dike schematizations. + /// + public class DikeProfilesImporter : ProfilesImporter> + { + private readonly ObservableList importTarget; + + /// + /// Creates a new instance of . + /// + /// The dike profiles to import on. + /// The reference line used to check if the + /// objects found in the file are intersecting it. + /// The path to the file to import from. + /// Thrown when , + /// or is null. + public DikeProfilesImporter(ObservableList importTarget, ReferenceLine referenceLine, string filePath) + : base(referenceLine, filePath, importTarget) + { + this.importTarget = importTarget; + } + + protected override void CreateProfiles(ReadResult importProfileLocationResult, + ReadResult importDikeProfileDataResult) + { + IEnumerable importedDikeProfiles = CreateDikeProfiles(importProfileLocationResult.ImportedItems, + importDikeProfileDataResult.ImportedItems); + + foreach (DikeProfile dikeProfile in importedDikeProfiles) + { + importTarget.Add(dikeProfile); + } + } + + protected override void HandleUserCancellingImport() + { + log.Info(Resources.DikeProfilesImporter_HandleUserCancellingImport_dikeprofile_import_aborted); + base.HandleUserCancellingImport(); + } + + protected override bool DikeProfileDataIsValid(DikeProfileData data, string prflFilePath) + { + if (data.DikeGeometry.Any()) + { + return true; + } + log.WarnFormat(Resources.DikeProfilesImporter_No_dike_geometry_file_0_skipped, prflFilePath); + return false; + } + + private IEnumerable CreateDikeProfiles(IEnumerable dikeProfileLocationCollection, + ICollection dikeProfileDataCollection) + { + var dikeProfiles = new List(); + foreach (ProfileLocation dikeProfileLocation in dikeProfileLocationCollection) + { + string id = dikeProfileLocation.Id; + + var dikeProfileData = GetMatchingDikeProfileData(dikeProfileDataCollection, id); + if (dikeProfileData == null) + { + log.ErrorFormat(Resources.DikeProfilesImporter_GetMatchingDikeProfileData_no_dikeprofiledata_for_location_0_, id); + } + else + { + DikeProfile dikeProfile = CreateDikeProfile(dikeProfileLocation, dikeProfileData); + dikeProfiles.Add(dikeProfile); + } + } + return dikeProfiles; + } + + private static DikeProfile CreateDikeProfile(ProfileLocation dikeProfileLocation, DikeProfileData dikeProfileData) + { + var dikeProfile = new DikeProfile(dikeProfileLocation.Point, dikeProfileData.DikeGeometry, + dikeProfileData.ForeshoreGeometry.Select(fg => fg.Point).ToArray(), + CreateBreakWater(dikeProfileData), + new DikeProfile.ConstructionProperties + { + Name = dikeProfileData.Id, + X0 = dikeProfileLocation.Offset, + Orientation = dikeProfileData.Orientation, + DikeHeight = dikeProfileData.DikeHeight + }); + + return dikeProfile; + } + } +} \ No newline at end of file Index: Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/FailureMechanismSectionsImporter.cs =================================================================== diff -u --- Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/FailureMechanismSectionsImporter.cs (revision 0) +++ Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/FailureMechanismSectionsImporter.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,349 @@ +// 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 System.Collections.Generic; +using System.Linq; +using Core.Common.Base.Geometry; +using Core.Common.Base.IO; +using Core.Common.IO.Exceptions; +using Core.Common.IO.Readers; +using log4net; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.IO.Properties; + +namespace Ringtoets.Common.IO.FileImporters +{ + /// + /// Imports instances from a shapefile that contains + /// one or more polylines and stores them in a . + /// + public class FailureMechanismSectionsImporter : FileImporterBase + { + /// + /// The snapping tolerance in meters. + /// + private const double snappingTolerance = 1; + + /// + /// The length tolerance between the reference line and the imported FailureMechanismSections in meters. + /// + private const double lengthDifferenceTolerance = 1; + + private static readonly ILog log = LogManager.GetLogger(typeof(FailureMechanismSectionsImporter)); + + private readonly ReferenceLine referenceLine; + + /// + /// Initializes a new instance of the class. + /// + /// The failure mechanism to update. + /// The reference line used to check correspondence with. + /// The path to the file to import from. + /// When any input argument is null. + /// + public FailureMechanismSectionsImporter(IFailureMechanism importTarget, ReferenceLine referenceLine, string filePath) : base(filePath, importTarget) + { + if (referenceLine == null) + { + throw new ArgumentNullException("referenceLine"); + } + + this.referenceLine = referenceLine; + } + + public override bool Import() + { + NotifyProgress(Resources.FailureMechanismSectionsImporter_ProgressText_Reading_file, 1, 3); + ReadResult readResults = ReadFailureMechanismSections(); + if (readResults.CriticalErrorOccurred) + { + return false; + } + + if (Canceled) + { + HandleUserCancellingImport(); + return false; + } + + NotifyProgress(Resources.FailureMechanismSectionsImporter_ProgressText_Validating_imported_sections, 2, 3); + ICollection readFailureMechanismSections = readResults.ImportedItems; + if (!SectionsCorrespondToReferenceLine(referenceLine, readFailureMechanismSections)) + { + LogCriticalFileReadError(Resources.FailureMechanismSectionsImporter_Import_Imported_sections_do_not_correspond_to_current_referenceline); + return false; + } + + if (Canceled) + { + HandleUserCancellingImport(); + return false; + } + + NotifyProgress(Resources.FailureMechanismSectionsImporter_ProgressText_Adding_imported_data_to_failureMechanism, 3, 3); + AddImportedDataToModel(readFailureMechanismSections); + return true; + } + + private void HandleUserCancellingImport() + { + log.Info(Resources.FailureMechanismSectionsImporter_Import_cancelled_no_data_read); + Canceled = false; + } + + private ReadResult ReadFailureMechanismSections() + { + using (FailureMechanismSectionReader reader = CreateFileReader()) + { + if (reader == null) + { + return new ReadResult(true); + } + + return ReadFile(reader); + } + } + + private FailureMechanismSectionReader CreateFileReader() + { + try + { + return new FailureMechanismSectionReader(FilePath); + } + catch (ArgumentException e) + { + LogCriticalFileReadError(e); + } + catch (CriticalFileReadException e) + { + LogCriticalFileReadError(e); + } + return null; + } + + private ReadResult ReadFile(FailureMechanismSectionReader reader) + { + try + { + var count = reader.GetFailureMechanismSectionCount(); + if (count == 0) + { + LogCriticalFileReadError(Resources.FailureMechanismSectionsImporter_ReadFile_File_is_empty); + return new ReadResult(true); + } + + var importedSections = new FailureMechanismSection[count]; + for (int i = 0; i < count; i++) + { + importedSections[i] = reader.ReadFailureMechanismSection(); + } + + return new ReadResult(false) + { + ImportedItems = importedSections + }; + } + catch (CriticalFileReadException e) + { + LogCriticalFileReadError(e); + return new ReadResult(true); + } + } + + private void LogCriticalFileReadError(Exception exception) + { + LogCriticalFileReadError(exception.Message); + } + + private void LogCriticalFileReadError(string message) + { + var errorMessage = string.Format(Resources.FailureMechanismSectionsImporter_CriticalErrorMessage_0_No_sections_imported, + message); + log.Error(errorMessage); + } + + private static bool SectionsCorrespondToReferenceLine(ReferenceLine referenceLine, ICollection mechanismSections) + { + if (HasStartOrEndPointsTooFarFromReferenceLine(referenceLine, mechanismSections)) + { + return false; + } + + if (IsTotalLengthOfSectionsTooDifferentFromReferenceLineLength(referenceLine, mechanismSections)) + { + return false; + } + + return true; + } + + private static bool HasStartOrEndPointsTooFarFromReferenceLine(ReferenceLine referenceLine, ICollection mechanismSections) + { + foreach (var failureMechanismSection in mechanismSections) + { + if (GetDistanceToReferenceLine(failureMechanismSection.GetStart(), referenceLine) > snappingTolerance) + { + return true; + } + if (GetDistanceToReferenceLine(failureMechanismSection.GetLast(), referenceLine) > snappingTolerance) + { + return true; + } + } + return false; + } + + private static double GetDistanceToReferenceLine(Point2D point, ReferenceLine referenceLine) + { + return GetLineSegments(referenceLine.Points) + .Min(segment => segment.GetEuclideanDistanceToPoint(point)); + } + + private static bool IsTotalLengthOfSectionsTooDifferentFromReferenceLineLength(ReferenceLine referenceLine, ICollection mechanismSections) + { + var totalSectionsLength = mechanismSections.Sum(s => GetSectionLength(s)); + var referenceLineLength = GetLengthOfLine(referenceLine.Points); + return Math.Abs(totalSectionsLength - referenceLineLength) > lengthDifferenceTolerance; + } + + private void AddImportedDataToModel(IEnumerable failureMechanismSections) + { + IEnumerable snappedSections = SnapReadSectionsToReferenceLine(failureMechanismSections, referenceLine); + + ImportTarget.ClearAllSections(); + foreach (FailureMechanismSection section in snappedSections) + { + ImportTarget.AddSection(section); + } + } + + private static IEnumerable SnapReadSectionsToReferenceLine(IEnumerable readSections, ReferenceLine referenceLine) + { + IList orderedReadSections = OrderSections(readSections, referenceLine); + + double[] orderedSectionLengths = GetReferenceLineCutoffLengths(referenceLine, orderedReadSections); + + Point2D[][] splitResults = Math2D.SplitLineAtLengths(referenceLine.Points, orderedSectionLengths); + + return CreateFailureMechanismSectionsSnappedOnReferenceLine(orderedReadSections, splitResults); + } + + private static IList OrderSections(IEnumerable unorderedSections, ReferenceLine referenceLine) + { + List sourceList = unorderedSections.ToList(); + + var startSection = GetStart(sourceList, referenceLine); + + var resultList = new List(sourceList.Count) + { + startSection + }; + + sourceList.Remove(startSection); + GrowTowardsEnd(resultList, sourceList); + + return resultList; + } + + private static FailureMechanismSection GetStart(List sourceList, ReferenceLine referenceLine) + { + var shortestDistance = double.MaxValue; + FailureMechanismSection closestSectionToReferenceLineStart = null; + Dictionary sectionReferenceLineDistances = sourceList.ToDictionary(s => referenceLine.Points.First().GetEuclideanDistanceTo(s.GetStart()), s => s); + + foreach (var sectionReferenceLineDistance in sectionReferenceLineDistances) + { + double distance = sectionReferenceLineDistance.Key; + if (distance < shortestDistance && distance <= snappingTolerance) + { + shortestDistance = sectionReferenceLineDistance.Key; + closestSectionToReferenceLineStart = sectionReferenceLineDistance.Value; + } + } + + return closestSectionToReferenceLineStart; + } + + private static void GrowTowardsEnd(List resultList, List sourceList) + { + bool doneGrowingToEnd = false; + while (!doneGrowingToEnd) + { + Point2D endPointToConnect = resultList[resultList.Count - 1].GetLast(); + + var shortestDistance = double.MaxValue; + FailureMechanismSection closestSectionToConnectWith = null; + Dictionary sectionConnectionDistances = sourceList.ToDictionary(s => endPointToConnect.GetEuclideanDistanceTo(s.GetStart()), s => s); + foreach (var sectionConnectionDistance in sectionConnectionDistances) + { + double distance = sectionConnectionDistance.Key; + if (distance < shortestDistance && distance <= snappingTolerance) + { + shortestDistance = sectionConnectionDistance.Key; + closestSectionToConnectWith = sectionConnectionDistance.Value; + } + } + if (closestSectionToConnectWith == null) + { + doneGrowingToEnd = true; + } + else + { + resultList.Add(closestSectionToConnectWith); + sourceList.Remove(closestSectionToConnectWith); + } + } + } + + private static double[] GetReferenceLineCutoffLengths(ReferenceLine referenceLine, IList orderedReadSections) + { + double[] orderedSectionLengths = orderedReadSections.Select(GetSectionLength).ToArray(); + + // Correct last section to fully match referenceLine length: + double difference = GetLengthOfLine(referenceLine.Points) - orderedSectionLengths.Sum(l => l); + orderedSectionLengths[orderedSectionLengths.Length - 1] += difference; + + return orderedSectionLengths; + } + + private static double GetSectionLength(FailureMechanismSection section) + { + return GetLengthOfLine(section.Points); + } + + private static double GetLengthOfLine(IEnumerable linePoints) + { + return GetLineSegments(linePoints).Sum(segment => segment.Length); + } + + private static IEnumerable GetLineSegments(IEnumerable linePoints) + { + return Math2D.ConvertLinePointsToLineSegments(linePoints); + } + + private static List CreateFailureMechanismSectionsSnappedOnReferenceLine(IList orderedReadSections, Point2D[][] splitResults) + { + return orderedReadSections.Select((t, i) => new FailureMechanismSection(t.Name, splitResults[i])).ToList(); + } + } +} \ No newline at end of file Index: Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/ForeshoreProfilesImporter.cs =================================================================== diff -u --- Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/ForeshoreProfilesImporter.cs (revision 0) +++ Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/ForeshoreProfilesImporter.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,120 @@ +// 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 System.Collections.Generic; +using System.Linq; +using Core.Common.Base; +using Core.Common.IO.Readers; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.DikeProfiles; +using Ringtoets.Common.IO.DikeProfiles; +using Ringtoets.Common.IO.Properties; + +namespace Ringtoets.Common.IO.FileImporters +{ + /// + /// Imports point shapefiles containing foreshore locations and text file containing the foreshore schematizations. + /// + public class ForeshoreProfilesImporter : ProfilesImporter> + { + private readonly ObservableList importTarget; + + /// + /// Creates a new instance of . + /// + /// The foreshore profiles to import on. + /// The reference line used to check if the + /// objects found in the file are intersecting it. + /// The path to the file to import from. + /// Thrown when , + /// or is null. + public ForeshoreProfilesImporter(ObservableList importTarget, ReferenceLine referenceLine, string filePath) + : base(referenceLine, filePath, importTarget) + { + this.importTarget = importTarget; + } + + protected override void CreateProfiles(ReadResult importProfileLocationResult, + ReadResult importDikeProfileDataResult) + { + IEnumerable importedForeshoreProfiles = + CreateForeshoreProfiles(importProfileLocationResult.ImportedItems, importDikeProfileDataResult.ImportedItems); + + foreach (ForeshoreProfile foreshoreProfile in importedForeshoreProfiles) + { + importTarget.Add(foreshoreProfile); + } + } + + protected override void HandleUserCancellingImport() + { + log.Info(Resources.ForeshoreProfilesImporter_HandleUserCancellingImport_foreshoreprofile_import_aborted); + base.HandleUserCancellingImport(); + } + + protected override bool DikeProfileDataIsValid(DikeProfileData data, string prflFilePath) + { + if (data.DamType != DamType.None || data.ForeshoreGeometry.Any()) + { + return true; + } + log.WarnFormat(Resources.ForeshoreProfilesImporter_No_dam_no_foreshore_geometry_file_0_skipped, prflFilePath); + return false; + } + + private IEnumerable CreateForeshoreProfiles(ICollection dikeProfileLocationCollection, + ICollection dikeProfileDataCollection) + { + var foreshoreProfiles = new List(); + foreach (ProfileLocation dikeProfileLocation in dikeProfileLocationCollection) + { + string id = dikeProfileLocation.Id; + + var dikeProfileData = GetMatchingDikeProfileData(dikeProfileDataCollection, id); + if (dikeProfileData == null) + { + log.ErrorFormat(Resources.ForeshoreProfilesImporter_GetMatchingForeshoreProfileData_no_foreshoreprofiledata_for_location_0_, id); + } + else + { + ForeshoreProfile foreshoreProfile = CreateForeshoreProfile(dikeProfileLocation, dikeProfileData); + foreshoreProfiles.Add(foreshoreProfile); + } + } + return foreshoreProfiles; + } + + private static ForeshoreProfile CreateForeshoreProfile(ProfileLocation dikeProfileLocation, DikeProfileData dikeProfileData) + { + var foreshoreProfile = new ForeshoreProfile(dikeProfileLocation.Point, + dikeProfileData.ForeshoreGeometry.Select(fg => fg.Point).ToArray(), + CreateBreakWater(dikeProfileData), + new ForeshoreProfile.ConstructionProperties + { + Name = dikeProfileData.Id, + X0 = dikeProfileLocation.Offset, + Orientation = dikeProfileData.Orientation + }); + return foreshoreProfile; + } + } +} \ No newline at end of file Index: Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/HydraulicBoundaryDatabaseImporter.cs =================================================================== diff -u --- Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/HydraulicBoundaryDatabaseImporter.cs (revision 0) +++ Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/HydraulicBoundaryDatabaseImporter.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,216 @@ +// 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 System.IO; +using Core.Common.IO.Exceptions; +using Core.Common.Utils.Builders; +using log4net; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.IO.Properties; +using Ringtoets.HydraRing.Data; +using Ringtoets.HydraRing.IO.HydraulicBoundaryDatabaseContext; +using Ringtoets.HydraRing.IO.HydraulicLocationConfigurationDatabaseContext; + +namespace Ringtoets.Common.IO.FileImporters +{ + /// + /// Imports locations read from an Hydraulic boundary .sqlite file (SqlLite database file) to a + /// collection of in a . + /// + public class HydraulicBoundaryDatabaseImporter : IDisposable + { + private readonly ILog log = LogManager.GetLogger(typeof(HydraulicBoundaryDatabaseImporter)); + private HydraulicBoundarySqLiteDatabaseReader hydraulicBoundaryDatabaseReader; + private HydraulicLocationConfigurationSqLiteDatabaseReader hydraulicLocationConfigurationDatabaseReader; + + /// + /// Creates a new instance of , based upon the data read from + /// the hydraulic boundary database file, and saved into . + /// + /// to set the newly + /// created . + /// The path of the hydraulic boundary database file to import from. + /// True if the import was successful, false otherwise. + /// Thrown when: + /// + /// The given file at cannot be read. + /// The file 'HLCD.sqlite' in the same folder as cannot be read. + /// + /// + public bool Import(IAssessmentSection targetItem, string filePath) + { + ValidateAndConnectTo(filePath); + + var hydraulicBoundaryDatabase = targetItem.HydraulicBoundaryDatabase; + if (!IsImportRequired(hydraulicBoundaryDatabase)) + { + var isNotificationRequired = hydraulicBoundaryDatabase.FilePath != filePath; + hydraulicBoundaryDatabase.FilePath = filePath; + if (isNotificationRequired) + { + targetItem.NotifyObservers(); + } + } + else + { + var importResult = GetHydraulicBoundaryDatabase(); + + if (importResult == null) + { + return false; + } + + AddImportedDataToModel(targetItem, importResult); + log.Info(Resources.HydraulicBoundaryDatabaseImporter_Import_All_hydraulic_locations_read); + } + + return true; + } + + public void Dispose() + { + if (hydraulicBoundaryDatabaseReader != null) + { + hydraulicBoundaryDatabaseReader.Dispose(); + hydraulicBoundaryDatabaseReader = null; + } + if (hydraulicLocationConfigurationDatabaseReader != null) + { + hydraulicLocationConfigurationDatabaseReader.Dispose(); + hydraulicLocationConfigurationDatabaseReader = null; + } + } + + /// + /// Validates the file and opens a connection. + /// + /// The path to the file to read. + /// Thrown when: + /// + /// The given file at cannot be read. + /// The file 'HLCD.sqlite' in the same folder as cannot be read. + /// + /// + private void ValidateAndConnectTo(string filePath) + { + hydraulicBoundaryDatabaseReader = new HydraulicBoundarySqLiteDatabaseReader(filePath); + + string hlcdFilePath = Path.Combine(Path.GetDirectoryName(filePath), "hlcd.sqlite"); + try + { + hydraulicLocationConfigurationDatabaseReader = new HydraulicLocationConfigurationSqLiteDatabaseReader(hlcdFilePath); + } + catch (CriticalFileReadException) + { + var message = new FileReaderErrorMessageBuilder(filePath).Build(Resources.HydraulicBoundaryDatabaseImporter_HLCD_sqlite_Not_Found); + throw new CriticalFileReadException(message); + } + } + + private bool IsImportRequired(HydraulicBoundaryDatabase hydraulicBoundaryDatabase) + { + return hydraulicBoundaryDatabase == null || hydraulicBoundaryDatabaseReader.GetVersion() != hydraulicBoundaryDatabase.Version; + } + + private void HandleException(Exception e) + { + var message = string.Format(Resources.HydraulicBoundaryDatabaseImporter_ErrorMessage_0_file_skipped, e.Message); + log.Error(message); + } + + private HydraulicBoundaryDatabase GetHydraulicBoundaryDatabase() + { + var trackId = GetTrackId(); + if (trackId == 0) + { + return null; + } + + try + { + var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase + { + FilePath = hydraulicBoundaryDatabaseReader.Path, + Version = hydraulicBoundaryDatabaseReader.GetVersion() + }; + + // Locations directory of HLCD location ids and HRD location ids + var locationidsDictionary = hydraulicLocationConfigurationDatabaseReader.GetLocationsIdByTrackId(trackId); + + var filter = new HydraulicBoundaryLocationFilter(); + + // Prepare query to fetch hrd locations + hydraulicBoundaryDatabaseReader.PrepareReadLocation(); + while (hydraulicBoundaryDatabaseReader.HasNext) + { + HrdLocation hrdLocation = hydraulicBoundaryDatabaseReader.ReadLocation(); + + long locationId; + locationidsDictionary.TryGetValue(hrdLocation.HrdLocationId, out locationId); + + if (filter.ShouldInclude(locationId)) + { + var hydraulicBoundaryLocation = new HydraulicBoundaryLocation( + locationId, + hrdLocation.Name, + hrdLocation.LocationX, + hrdLocation.LocationY); + hydraulicBoundaryDatabase.Locations.Add(hydraulicBoundaryLocation); + } + } + return hydraulicBoundaryDatabase; + } + catch (Exception e) + { + if (e is LineParseException || e is CriticalFileReadException) + { + HandleException(e); + return null; + } + throw; + } + } + + private long GetTrackId() + { + try + { + return hydraulicBoundaryDatabaseReader.GetTrackId(); + } + catch (Exception e) + { + if (e is LineParseException || e is CriticalFileReadException) + { + HandleException(e); + return 0; + } + throw; + } + } + + private static void AddImportedDataToModel(IAssessmentSection assessmentSection, HydraulicBoundaryDatabase importedData) + { + assessmentSection.HydraulicBoundaryDatabase = importedData; + assessmentSection.NotifyObservers(); + } + } +} \ No newline at end of file Index: Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/HydraulicBoundaryLocationFilter.cs =================================================================== diff -u --- Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/HydraulicBoundaryLocationFilter.cs (revision 0) +++ Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/HydraulicBoundaryLocationFilter.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,63 @@ +// 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 System.Collections.Generic; +using System.Linq; +using Ringtoets.Common.IO.Properties; +using Ringtoets.HydraRing.Data; + +namespace Ringtoets.Common.IO.FileImporters +{ + /// + /// This class allows for filtering out based + /// on their name. + /// + public class HydraulicBoundaryLocationFilter + { + private readonly List locationsToFilterOut; + + public HydraulicBoundaryLocationFilter() + { + string[] idsAsText = Resources.HydraulicBoundaryLocationsFilterList.Split(new[] + { + Environment.NewLine, + "\n" + }, StringSplitOptions.RemoveEmptyEntries); + var filterList = new List(idsAsText.Skip(1).Select(long.Parse)); // Skip the header, parse the remainder + filterList.Sort(); + + locationsToFilterOut = filterList; + } + + /// + /// Indicates if the with + /// should be imported. + /// + /// The name of the location. + /// True if the location should be imported, false otherwise. + public bool ShouldInclude(long locationId) + { + int matchingIndex = locationsToFilterOut.BinarySearch(locationId); + return matchingIndex < 0; + } + } +} \ No newline at end of file Index: Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/ProfilesImporter.cs =================================================================== diff -u --- Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/ProfilesImporter.cs (revision 0) +++ Ringtoets/Common/src/Ringtoets.Common.IO/FileImporters/ProfilesImporter.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,317 @@ +// 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 System.Collections.Generic; +using System.Collections.ObjectModel; +using System.IO; +using System.Linq; +using Core.Common.Base.Geometry; +using Core.Common.Base.IO; +using Core.Common.IO.Exceptions; +using Core.Common.IO.Readers; +using log4net; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.DikeProfiles; +using Ringtoets.Common.IO.DikeProfiles; +using Ringtoets.Common.IO.Properties; + +namespace Ringtoets.Common.IO.FileImporters +{ + /// + /// Abstact class for profile importers, providing an implementation of importing point shapefiles + /// containing dike profile locations and text files containing dike schematizations. + /// + /// + public abstract class ProfilesImporter : FileImporterBase + { + protected readonly ILog log = LogManager.GetLogger(typeof(ProfilesImporter)); + private readonly ReferenceLine referenceLine; + + /// + /// Initializes a new instance of . + /// + /// The reference line used to check if the imported profiles are intersecting it. + /// The path to the file to import from. + /// The import target. + /// Thrown when , + /// or is null. + protected ProfilesImporter(ReferenceLine referenceLine, string filePath, T importTarget) : base(filePath, importTarget) + { + if (referenceLine == null) + { + throw new ArgumentNullException("referenceLine"); + } + + this.referenceLine = referenceLine; + } + + public override bool Import() + { + ReadResult importDikeProfilesResult = ReadProfileLocations(); + if (importDikeProfilesResult.CriticalErrorOccurred) + { + return false; + } + + if (Canceled) + { + HandleUserCancellingImport(); + return false; + } + + string folderPath = Path.GetDirectoryName(FilePath); + ReadResult importDikeProfileDataResult = ReadDikeProfileData(folderPath); + if (importDikeProfileDataResult.CriticalErrorOccurred) + { + return false; + } + + if (Canceled) + { + HandleUserCancellingImport(); + return false; + } + + CreateProfiles(importDikeProfilesResult, importDikeProfileDataResult); + + return true; + } + + /// + /// Create profile objects from location and geometry data. + /// + /// The read profile locations. + /// The read dike profile geometries. + protected abstract void CreateProfiles(ReadResult importProfileLocationResult, + ReadResult importDikeProfileDataResult); + + /// + /// Construct a from a dike profile geometry. + /// + /// The dike profile geometry. + /// A new . + protected static BreakWater CreateBreakWater(DikeProfileData dikeProfileData) + { + switch (dikeProfileData.DamType) + { + case DamType.Caisson: + return new BreakWater(BreakWaterType.Caisson, dikeProfileData.DamHeight); + case DamType.HarborDam: + return new BreakWater(BreakWaterType.Dam, dikeProfileData.DamHeight); + case DamType.Vertical: + return new BreakWater(BreakWaterType.Wall, dikeProfileData.DamHeight); + } + return null; + } + + /// + /// Obtain the dike profile geometry object matching a given . + /// + /// The available dike profile geometry objects. + /// The id on which to match. + /// The matching . + protected static DikeProfileData GetMatchingDikeProfileData(IEnumerable dikeProfileDataCollection, string id) + { + return dikeProfileDataCollection.FirstOrDefault(d => d.Id.Equals(id)); + } + + /// + /// Act upon the user cancelling the import operation. + /// + protected virtual void HandleUserCancellingImport() + { + Canceled = false; + } + + /// + /// Validate the consistency of a object. + /// + /// The to validate. + /// Filepath of the profile data file. + /// Value indicating whether the is valid. + protected abstract bool DikeProfileDataIsValid(DikeProfileData data, string prflFilePath); + + private ReadResult ReadProfileLocations() + { + NotifyProgress(Resources.ProfilesImporter_ReadProfileLocations_reading_profilelocations, 1, 1); + try + { + using (var profileLocationReader = new ProfileLocationReader(FilePath)) + { + return GetProfileLocationReadResult(profileLocationReader); + } + } + catch (CriticalFileReadException exception) + { + log.Error(exception.Message); + } + catch (ArgumentException exception) + { + log.Error(exception.Message); + } + return new ReadResult(true); + } + + private ReadResult GetProfileLocationReadResult(ProfileLocationReader profileLocationReader) + { + var profileLocations = new Collection(); + + int totalNumberOfSteps = profileLocationReader.GetLocationCount; + for (int i = 0; i < totalNumberOfSteps; i++) + { + if (Canceled) + { + return new ReadResult(false); + } + + try + { + NotifyProgress(Resources.ProfilesImporter_GetProfileLocationReadResult_reading_profilelocation, i + 1, totalNumberOfSteps); + AddNextProfileLocation(profileLocationReader, profileLocations); + } + catch (LineParseException exception) + { + var message = string.Format( + Resources.ProfilesImporter_GetProfileLocationReadResult_Error_reading_Profile_LineNumber_0_Error_1_The_Profile_is_skipped, + i + 1, + exception.Message); + log.Warn(message); + } + catch (CriticalFileReadException exception) + { + log.Error(exception.Message); + return new ReadResult(true); + } + } + return new ReadResult(false) + { + ImportedItems = profileLocations + }; + } + + /// + /// Get the next from + /// and add to in case it is close enough to the . + /// + /// Reader reading objects from a shapefile. + /// Collection of objects + /// to which the new is to be added. + /// + /// The shapefile misses a value for a required attribute. + /// The shapefile has an attribute whose type is incorrect. + /// + private void AddNextProfileLocation(ProfileLocationReader profileLocationReader, ICollection profileLocations) + { + ProfileLocation profileLocation = profileLocationReader.GetNextProfileLocation(); + double distanceToReferenceLine = GetDistanceToReferenceLine(profileLocation.Point); + if (distanceToReferenceLine > 1.0) + { + log.ErrorFormat(Resources.ProfilesImporter_AddNextProfileLocation_0_skipping_location_outside_referenceline, profileLocation.Id); + return; + } + if (profileLocations.Any(dpl => dpl.Id.Equals(profileLocation.Id))) + { + log.WarnFormat(Resources.ProfilesImporter_AddNextProfileLocation_Location_with_id_0_already_read, profileLocation.Id); + } + profileLocations.Add(profileLocation); + } + + private ReadResult ReadDikeProfileData(string folderPath) + { + NotifyProgress(Resources.ProfilesImporter_ReadDikeProfileData_reading_profile_data, 1, 1); + + // No exception handling for GetFiles, as folderPath is derived from an existing, read file. + string[] prflFilePaths = Directory.GetFiles(folderPath, "*.prfl"); + + int totalNumberOfSteps = prflFilePaths.Length; + + var dikeProfileData = new Collection(); + var dikeProfileDataReader = new DikeProfileDataReader(); + + for (int i = 0; i < totalNumberOfSteps; i++) + { + if (Canceled) + { + return new ReadResult(false); + } + + string prflFilePath = prflFilePaths[i]; + + try + { + NotifyProgress(Resources.ProfilesImporter_ReadDikeProfileData_reading_profiledata, i + 1, totalNumberOfSteps); + + DikeProfileData data = dikeProfileDataReader.ReadDikeProfileData(prflFilePath); + + if (!DikeProfileDataIsValid(data, prflFilePath)) + { + continue; + } + + if (data.SheetPileType != SheetPileType.Coordinates) + { + log.Error(String.Format(Resources.ProfilesImporter_ReadDikeProfileData_sheet_piling_not_zero_skipping_0_, prflFilePath)); + continue; + } + + if (dikeProfileData.Any(d => d.Id.Equals(data.Id))) + { + LogDuplicate(data, prflFilePath); + } + else + { + dikeProfileData.Add(data); + } + } + // No need to catch ArgumentException, as prflFilePaths are valid by construction. + catch (CriticalFileReadException exception) + { + log.Error(exception.Message); + } + } + + return new ReadResult(false) + { + ImportedItems = dikeProfileData + }; + } + + private void LogDuplicate(DikeProfileData data, string prflFilePath) + { + var message = String.Format( + Resources.ProfilesImporter_LogDuplicateDikeProfileData_Multiple_DikeProfileData_found_for_DikeProfile_0_File_1_skipped, + data.Id, + prflFilePath); + log.Error(message); + } + + private double GetDistanceToReferenceLine(Point2D point) + { + return GetLineSegments(referenceLine.Points).Min(segment => segment.GetEuclideanDistanceToPoint(point)); + } + + private static IEnumerable GetLineSegments(IEnumerable linePoints) + { + return Math2D.ConvertLinePointsToLineSegments(linePoints); + } + } +} \ No newline at end of file Index: Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.Designer.cs =================================================================== diff -u -r1d6be87de63acfac543d4b90aaf0618d3203b0c3 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.Designer.cs (.../Resources.Designer.cs) (revision 1d6be87de63acfac543d4b90aaf0618d3203b0c3) +++ Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.Designer.cs (.../Resources.Designer.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -387,6 +387,34 @@ } /// + /// Looks up a localized string similar to Kan geen geldige gegevens vinden voor dijkprofiellocatie met ID '{0}'.. + /// + public static string DikeProfilesImporter_GetMatchingDikeProfileData_no_dikeprofiledata_for_location_0_ { + get { + return ResourceManager.GetString("DikeProfilesImporter_GetMatchingDikeProfileData_no_dikeprofiledata_for_location_0" + + "_", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Dijkprofielen importeren is afgebroken. Geen gegevens ingelezen.. + /// + public static string DikeProfilesImporter_HandleUserCancellingImport_dikeprofile_import_aborted { + get { + return ResourceManager.GetString("DikeProfilesImporter_HandleUserCancellingImport_dikeprofile_import_aborted", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Profielgegevens definiëren geen dijkgeometrie. Bestand '{0}' wordt overgeslagen.. + /// + public static string DikeProfilesImporter_No_dike_geometry_file_0_skipped { + get { + return ResourceManager.GetString("DikeProfilesImporter_No_dike_geometry_file_0_skipped", resourceCulture); + } + } + + /// /// Looks up a localized string similar to Het bestand bevat een of meerdere multi-polylijnen. Multi-polylijnen worden niet ondersteund.. /// public static string FailureMechanismSectionReader_File_has_unsupported_multiPolyline { @@ -405,6 +433,128 @@ } /// + /// Looks up a localized string similar to {0} + ///Er is geen vakindeling geïmporteerd.. + /// + public static string FailureMechanismSectionsImporter_CriticalErrorMessage_0_No_sections_imported { + get { + return ResourceManager.GetString("FailureMechanismSectionsImporter_CriticalErrorMessage_0_No_sections_imported", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Vakindeling importeren afgebroken. Geen gegevens ingelezen.. + /// + public static string FailureMechanismSectionsImporter_Import_cancelled_no_data_read { + get { + return ResourceManager.GetString("FailureMechanismSectionsImporter_Import_cancelled_no_data_read", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Vakindeling komt niet overeen met de huidige referentielijn.. + /// + public static string FailureMechanismSectionsImporter_Import_Imported_sections_do_not_correspond_to_current_referenceline { + get { + return ResourceManager.GetString("FailureMechanismSectionsImporter_Import_Imported_sections_do_not_correspond_to_cu" + + "rrent_referenceline", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Geïmporteerde gegevens toevoegen aan het toetsspoor.. + /// + public static string FailureMechanismSectionsImporter_ProgressText_Adding_imported_data_to_failureMechanism { + get { + return ResourceManager.GetString("FailureMechanismSectionsImporter_ProgressText_Adding_imported_data_to_failureMech" + + "anism", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Inlezen vakindeling.. + /// + public static string FailureMechanismSectionsImporter_ProgressText_Reading_file { + get { + return ResourceManager.GetString("FailureMechanismSectionsImporter_ProgressText_Reading_file", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Valideren ingelezen vakindeling.. + /// + public static string FailureMechanismSectionsImporter_ProgressText_Validating_imported_sections { + get { + return ResourceManager.GetString("FailureMechanismSectionsImporter_ProgressText_Validating_imported_sections", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Het bestand heeft geen vakindeling.. + /// + public static string FailureMechanismSectionsImporter_ReadFile_File_is_empty { + get { + return ResourceManager.GetString("FailureMechanismSectionsImporter_ReadFile_File_is_empty", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Kan geen geldige gegevens vinden voor voorlandprofiellocatie met ID '{0}'.. + /// + public static string ForeshoreProfilesImporter_GetMatchingForeshoreProfileData_no_foreshoreprofiledata_for_location_0_ { + get { + return ResourceManager.GetString("ForeshoreProfilesImporter_GetMatchingForeshoreProfileData_no_foreshoreprofiledata" + + "_for_location_0_", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Voorlandprofielen importeren is afgebroken. Geen gegevens ingelezen.. + /// + public static string ForeshoreProfilesImporter_HandleUserCancellingImport_foreshoreprofile_import_aborted { + get { + return ResourceManager.GetString("ForeshoreProfilesImporter_HandleUserCancellingImport_foreshoreprofile_import_abor" + + "ted", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Profielgegevens definiëren geen dam en geen voorlandgeometrie. Bestand '{0}' wordt overgeslagen.. + /// + public static string ForeshoreProfilesImporter_No_dam_no_foreshore_geometry_file_0_skipped { + get { + return ResourceManager.GetString("ForeshoreProfilesImporter_No_dam_no_foreshore_geometry_file_0_skipped", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to {0} Het bestand wordt overgeslagen.. + /// + public static string HydraulicBoundaryDatabaseImporter_ErrorMessage_0_file_skipped { + get { + return ResourceManager.GetString("HydraulicBoundaryDatabaseImporter_ErrorMessage_0_file_skipped", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Het bijbehorende HLCD bestand is niet gevonden in dezelfde map als het HRD bestand.. + /// + public static string HydraulicBoundaryDatabaseImporter_HLCD_sqlite_Not_Found { + get { + return ResourceManager.GetString("HydraulicBoundaryDatabaseImporter_HLCD_sqlite_Not_Found", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to De hydraulische randvoorwaardenlocaties zijn ingelezen.. + /// + public static string HydraulicBoundaryDatabaseImporter_Import_All_hydraulic_locations_read { + get { + return ResourceManager.GetString("HydraulicBoundaryDatabaseImporter_Import_All_hydraulic_locations_read", resourceCulture); + } + } + + /// /// Looks up a localized string similar to {0} Er zijn geen hydraulische randvoorwaarden locaties geëxporteerd.. /// public static string HydraulicBoundaryLocationsExporter_Error_Exception_0_no_HydraulicBoundaryLocations_exported { @@ -415,6 +565,87 @@ } /// + /// Looks up a localized string similar to LocationID + ///300130 + ///300131 + ///300189 + ///300353 + ///300354 + ///300355 + ///300357 + ///300358 + ///300359 + ///300360 + ///300361 + ///300362 + ///300363 + ///300364 + ///300365 + ///300366 + ///300367 + ///300368 + ///300369 + ///300370 + ///300371 + ///300372 + ///300373 + ///300374 + ///300375 + ///300376 + ///300608 + ///300609 + ///300610 + ///300611 + ///300612 + ///300633 + ///300634 + ///300635 + ///300636 + ///300637 + ///300657 + ///300658 + ///300659 + ///300660 + ///300661 + ///300662 + ///300663 + ///300664 + ///300665 + ///300703 + ///300704 + ///300745 + ///300748 + ///300761 + ///300762 + ///300765 + ///300766 + ///300767 + ///300824 + ///300825 + ///300826 + ///300828 + ///300829 + ///300830 + ///300864 + ///300865 + ///301595 + ///301596 + ///301597 + ///301598 + ///301599 + ///301600 + ///301601 + ///301602 + ///301603 + ///3016 [rest of string was truncated]";. + /// + public static string HydraulicBoundaryLocationsFilterList { + get { + return ResourceManager.GetString("HydraulicBoundaryLocationsFilterList", resourceCulture); + } + } + + /// /// Looks up a localized string similar to TRAJECT_ID;N ///1-1;3 ///1-2;2 @@ -550,6 +781,90 @@ } /// + /// Looks up a localized string similar to Een profiellocatie met ID '{0}' ligt niet op de referentielijn. Locatie wordt overgeslagen.. + /// + public static string ProfilesImporter_AddNextProfileLocation_0_skipping_location_outside_referenceline { + get { + return ResourceManager.GetString("ProfilesImporter_AddNextProfileLocation_0_skipping_location_outside_referenceline" + + "", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Profiellocatie met ID '{0}' is opnieuw ingelezen.. + /// + public static string ProfilesImporter_AddNextProfileLocation_Location_with_id_0_already_read { + get { + return ResourceManager.GetString("ProfilesImporter_AddNextProfileLocation_Location_with_id_0_already_read", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Fout bij het lezen van profiel op regel {0}. {1} Dit profiel wordt overgeslagen.. + /// + public static string ProfilesImporter_GetProfileLocationReadResult_Error_reading_Profile_LineNumber_0_Error_1_The_Profile_is_skipped { + get { + return ResourceManager.GetString("ProfilesImporter_GetProfileLocationReadResult_Error_reading_Profile_LineNumber_0_" + + "Error_1_The_Profile_is_skipped", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Inlezen van profiellocatie.. + /// + public static string ProfilesImporter_GetProfileLocationReadResult_reading_profilelocation { + get { + return ResourceManager.GetString("ProfilesImporter_GetProfileLocationReadResult_reading_profilelocation", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Meerdere definities gevonden voor profiel '{0}'. Bestand '{1}' wordt overgeslagen.. + /// + public static string ProfilesImporter_LogDuplicateDikeProfileData_Multiple_DikeProfileData_found_for_DikeProfile_0_File_1_skipped { + get { + return ResourceManager.GetString("ProfilesImporter_LogDuplicateDikeProfileData_Multiple_DikeProfileData_found_for_D" + + "ikeProfile_0_File_1_skipped", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Inlezen van profielgegevens uit een prfl bestand.. + /// + public static string ProfilesImporter_ReadDikeProfileData_reading_profile_data { + get { + return ResourceManager.GetString("ProfilesImporter_ReadDikeProfileData_reading_profile_data", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Inlezen van profielgegevens.. + /// + public static string ProfilesImporter_ReadDikeProfileData_reading_profiledata { + get { + return ResourceManager.GetString("ProfilesImporter_ReadDikeProfileData_reading_profiledata", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Profielgegevens definiëren een damwand waarde ongelijk aan 0. Bestand wordt overgeslagen: {0}. + /// + public static string ProfilesImporter_ReadDikeProfileData_sheet_piling_not_zero_skipping_0_ { + get { + return ResourceManager.GetString("ProfilesImporter_ReadDikeProfileData_sheet_piling_not_zero_skipping_0_", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Inlezen van profiellocaties uit een shapebestand.. + /// + public static string ProfilesImporter_ReadProfileLocations_reading_profilelocations { + get { + return ResourceManager.GetString("ProfilesImporter_ReadProfileLocations_reading_profilelocations", resourceCulture); + } + } + + /// /// Looks up a localized string similar to {0} ///Er is geen referentielijn geëxporteerd.. /// Index: Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.resx =================================================================== diff -u -r1d6be87de63acfac543d4b90aaf0618d3203b0c3 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.resx (.../Resources.resx) (revision 1d6be87de63acfac543d4b90aaf0618d3203b0c3) +++ Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.resx (.../Resources.resx) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -359,4 +359,83 @@ Kan geen geldige gegevens vinden voor kunstwerklocatie met KWKIDENT '{0}'. + + Kan geen geldige gegevens vinden voor dijkprofiellocatie met ID '{0}'. + + + Dijkprofielen importeren is afgebroken. Geen gegevens ingelezen. + + + Profielgegevens definiëren geen dijkgeometrie. Bestand '{0}' wordt overgeslagen. + + + {0} +Er is geen vakindeling geïmporteerd. + + + Vakindeling importeren afgebroken. Geen gegevens ingelezen. + + + Vakindeling komt niet overeen met de huidige referentielijn. + + + Geïmporteerde gegevens toevoegen aan het toetsspoor. + + + Inlezen vakindeling. + + + Valideren ingelezen vakindeling. + + + Het bestand heeft geen vakindeling. + + + Kan geen geldige gegevens vinden voor voorlandprofiellocatie met ID '{0}'. + + + Voorlandprofielen importeren is afgebroken. Geen gegevens ingelezen. + + + Profielgegevens definiëren geen dam en geen voorlandgeometrie. Bestand '{0}' wordt overgeslagen. + + + {0} Het bestand wordt overgeslagen. + + + Het bijbehorende HLCD bestand is niet gevonden in dezelfde map als het HRD bestand. + + + De hydraulische randvoorwaardenlocaties zijn ingelezen. + + + ..\Resources\Exceptions_DoNotCalculate.csv;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + Een profiellocatie met ID '{0}' ligt niet op de referentielijn. Locatie wordt overgeslagen. + + + Profiellocatie met ID '{0}' is opnieuw ingelezen. + + + Fout bij het lezen van profiel op regel {0}. {1} Dit profiel wordt overgeslagen. + + + Inlezen van profiellocatie. + + + Meerdere definities gevonden voor profiel '{0}'. Bestand '{1}' wordt overgeslagen. + + + Inlezen van profielgegevens. + + + Inlezen van profielgegevens uit een prfl bestand. + + + Profielgegevens definiëren een damwand waarde ongelijk aan 0. Bestand wordt overgeslagen: {0} + + + Inlezen van profiellocaties uit een shapebestand. + \ No newline at end of file Index: Ringtoets/Common/src/Ringtoets.Common.IO/Resources/Exceptions_DoNotCalculate.csv =================================================================== diff -u --- Ringtoets/Common/src/Ringtoets.Common.IO/Resources/Exceptions_DoNotCalculate.csv (revision 0) +++ Ringtoets/Common/src/Ringtoets.Common.IO/Resources/Exceptions_DoNotCalculate.csv (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,5695 @@ +LocationID +300130 +300131 +300189 +300353 +300354 +300355 +300357 +300358 +300359 +300360 +300361 +300362 +300363 +300364 +300365 +300366 +300367 +300368 +300369 +300370 +300371 +300372 +300373 +300374 +300375 +300376 +300608 +300609 +300610 +300611 +300612 +300633 +300634 +300635 +300636 +300637 +300657 +300658 +300659 +300660 +300661 +300662 +300663 +300664 +300665 +300703 +300704 +300745 +300748 +300761 +300762 +300765 +300766 +300767 +300824 +300825 +300826 +300828 +300829 +300830 +300864 +300865 +301595 +301596 +301597 +301598 +301599 +301600 +301601 +301602 +301603 +301604 +301605 +301606 +301607 +301609 +301610 +301611 +301656 +301658 +301660 +301676 +301677 +301678 +301680 +301687 +301688 +301689 +301736 +301737 +301738 +301739 +301740 +301771 +301780 +301781 +301785 +301795 +301796 +301797 +301798 +301799 +301800 +301821 +301823 +301824 +301825 +301826 +301827 +301834 +301835 +301867 +301868 +301869 +301870 +301871 +301872 +301873 +301874 +301875 +301876 +301878 +301879 +301880 +301899 +301905 +301906 +301907 +301908 +301909 +301928 +301929 +301930 +301944 +301947 +301948 +301949 +301950 +301951 +301952 +301953 +301954 +301955 +301956 +301958 +301959 +301960 +301961 +301962 +301963 +301999 +302000 +302001 +302006 +302007 +302008 +302014 +302015 +302016 +302017 +302018 +302019 +302021 +302022 +302082 +302083 +302099 +302100 +302102 +302103 +302104 +302105 +302110 +302111 +302149 +302150 +302200 +302201 +302202 +302203 +302204 +302205 +302206 +302629 +302730 +303193 +303194 +303195 +303223 +303231 +303232 +303233 +303236 +303237 +303238 +303239 +303240 +303241 +303242 +303243 +303244 +303246 +303247 +303316 +303324 +303325 +303327 +303328 +303329 +303330 +303331 +303332 +303333 +303336 +303337 +303390 +303394 +303395 +303396 +303397 +303399 +303400 +303402 +303470 +303472 +303473 +303474 +303475 +303476 +303477 +303478 +303479 +303480 +303481 +303483 +303484 +303485 +303486 +303487 +303488 +303489 +303490 +303492 +303494 +303495 +303496 +303497 +303498 +303499 +303500 +303501 +303502 +303504 +303505 +303506 +303507 +303508 +303509 +303510 +303511 +303513 +303514 +303515 +303516 +303517 +303518 +303519 +303520 +303521 +303522 +303524 +303525 +303526 +303527 +303529 +303530 +303531 +303532 +303535 +303536 +303538 +303539 +303540 +303541 +303542 +303543 +303545 +303547 +303550 +303553 +303554 +303566 +303568 +303572 +303575 +303585 +303586 +303588 +303589 +303590 +303591 +303592 +303593 +303594 +303595 +303596 +303598 +303600 +303601 +303602 +303603 +303604 +303605 +303606 +303607 +303609 +303610 +303611 +303612 +303613 +303614 +303615 +303616 +303617 +303618 +303620 +303621 +303622 +303623 +303624 +303625 +303627 +303629 +303648 +303649 +303650 +303651 +303652 +303653 +303655 +303656 +303657 +303658 +303659 +303660 +303708 +303714 +303715 +303716 +303717 +303718 +303719 +303721 +303733 +303734 +303736 +303737 +303738 +303739 +303740 +303741 +303743 +303744 +303745 +303955 +303957 +303960 +303961 +303980 +303982 +303983 +303984 +303986 +304004 +304005 +304006 +304007 +304008 +304009 +304010 +304011 +304012 +304013 +304014 +304015 +304016 +304017 +304018 +304019 +304020 +304021 +304022 +304023 +304024 +304025 +304026 +304027 +304028 +304029 +304030 +304031 +304060 +304061 +304062 +304063 +304064 +304065 +304066 +304067 +304068 +304069 +304070 +304071 +304072 +304073 +304074 +304075 +304076 +304077 +304078 +304079 +304080 +304081 +304082 +304083 +304084 +304085 +304086 +304087 +304088 +304089 +304090 +304091 +304092 +304093 +304094 +304095 +304096 +304097 +304098 +304099 +304100 +304101 +304102 +304103 +304104 +304105 +304106 +304107 +304108 +304109 +304110 +304111 +304112 +304113 +304114 +304115 +304116 +304117 +304118 +304119 +304120 +304121 +304122 +304124 +304125 +304126 +304127 +304128 +304129 +304130 +304131 +304132 +304133 +304136 +304137 +304138 +304139 +304140 +304141 +304142 +304143 +304146 +304147 +304148 +304150 +304151 +304152 +304153 +304154 +304155 +304156 +304157 +304158 +304159 +304160 +304161 +304162 +304163 +304164 +304165 +304166 +304167 +304168 +304169 +304170 +304171 +304172 +304173 +304174 +304175 +304176 +304177 +304178 +304179 +304180 +304181 +304182 +304183 +304184 +304185 +304186 +304187 +304188 +304189 +304190 +304191 +304192 +304193 +304194 +304195 +304196 +304197 +304198 +304199 +304200 +304201 +304202 +304203 +304204 +304205 +304206 +304207 +304208 +304209 +304210 +304211 +304212 +304213 +304214 +304215 +304216 +304217 +304218 +304219 +304220 +304221 +304222 +304223 +304224 +304225 +304226 +304227 +304228 +304229 +304230 +304231 +304232 +304233 +304234 +304235 +304236 +304237 +304238 +304239 +304240 +304241 +304242 +304243 +304244 +304245 +304246 +304247 +304248 +304249 +304250 +304251 +304252 +304253 +304254 +304255 +304256 +304257 +304258 +304259 +304261 +304263 +304264 +304266 +304268 +304271 +304272 +304274 +304275 +304276 +304281 +304282 +304283 +304284 +304287 +304291 +304296 +304298 +304299 +304300 +304301 +304302 +304304 +304306 +304308 +304313 +304314 +304315 +304320 +304321 +304325 +304326 +304327 +304328 +304329 +304330 +304333 +304334 +304337 +304338 +304339 +304340 +304341 +304342 +304343 +304344 +304345 +304346 +304347 +304348 +304349 +304350 +304351 +304352 +304354 +304355 +304357 +304358 +304359 +304360 +304361 +304362 +304363 +304368 +304369 +304370 +304371 +304373 +304374 +304375 +304376 +304377 +304378 +304379 +304380 +304382 +304385 +304386 +304388 +304393 +304395 +304396 +304399 +304400 +304401 +304406 +304408 +304411 +304413 +304418 +304454 +304458 +304459 +304460 +304461 +304462 +304463 +304464 +304465 +304466 +304467 +304468 +304469 +304471 +304472 +304473 +304475 +304477 +304480 +304481 +304496 +304497 +304498 +304499 +304500 +304501 +304502 +304503 +304504 +304602 +304603 +304604 +304605 +304606 +304607 +304608 +304609 +304610 +304612 +304613 +304614 +304615 +304620 +304698 +304721 +304722 +304723 +304724 +304725 +304726 +304727 +304734 +304735 +304736 +304737 +304738 +304739 +304771 +304783 +304785 +304799 +304800 +304801 +304803 +304804 +304805 +304806 +304807 +304808 +304809 +304811 +304812 +304814 +304815 +304816 +304817 +304818 +304871 +304898 +304899 +304900 +304901 +304902 +304903 +304904 +304905 +304906 +304907 +304908 +304909 +304910 +304911 +305114 +305116 +305118 +305119 +305159 +305161 +305162 +305163 +305164 +305165 +305168 +305169 +305170 +305171 +305172 +305173 +305174 +305175 +305176 +305177 +305178 +305179 +305180 +305181 +305183 +305184 +305185 +305186 +305187 +305188 +305189 +305190 +305191 +305192 +305194 +305202 +305204 +305205 +305207 +305211 +305214 +305217 +305220 +305221 +305223 +305224 +305225 +305226 +305227 +305228 +305229 +305230 +305231 +305232 +305233 +305234 +305235 +305236 +305239 +305240 +305241 +305242 +305243 +305244 +305248 +305254 +305257 +305258 +305259 +305260 +305261 +305262 +305263 +305264 +305265 +305266 +305267 +305268 +305269 +305270 +305272 +305273 +305274 +305275 +305276 +305277 +305278 +305279 +305280 +305281 +305282 +305283 +305284 +305285 +305286 +305287 +305289 +305290 +305293 +305295 +305297 +305298 +305300 +305301 +305302 +305303 +305304 +305306 +305307 +305310 +305311 +305312 +305313 +305314 +305315 +305316 +305317 +305318 +305319 +305320 +305321 +305322 +305323 +305324 +305325 +305326 +305327 +305329 +305330 +305332 +305333 +305334 +305335 +305336 +305337 +305338 +305339 +305340 +305341 +305342 +305344 +305345 +305346 +305347 +305348 +305349 +305353 +305361 +305362 +305365 +305369 +305373 +305374 +305377 +305380 +305381 +305382 +305385 +305387 +305389 +305391 +305392 +305393 +305395 +305396 +305397 +305398 +305399 +305400 +305401 +305403 +305404 +305405 +305406 +305407 +305408 +305409 +305410 +305411 +305412 +305413 +305414 +305415 +305416 +305417 +305418 +305419 +305420 +305421 +305422 +305423 +305424 +305425 +305426 +305427 +305430 +305431 +305432 +305433 +305434 +305435 +305436 +305437 +305438 +305439 +305440 +305441 +305443 +305444 +305445 +305446 +305447 +305450 +305452 +305453 +305454 +305455 +305456 +305458 +305459 +305460 +305462 +305463 +305464 +305468 +305469 +305470 +305471 +305472 +305473 +305475 +305478 +305479 +305480 +305481 +305482 +305483 +305485 +305486 +305488 +305489 +305490 +305491 +305492 +305494 +305495 +305496 +305497 +305498 +305499 +305500 +305501 +305505 +305507 +305508 +305509 +305510 +305511 +305512 +305513 +305514 +305516 +305517 +305518 +305519 +305520 +305521 +305522 +305523 +305524 +305525 +305526 +305527 +305528 +305529 +305531 +305532 +305533 +305534 +305535 +305536 +305538 +305539 +305540 +305545 +305546 +305547 +305548 +305549 +305553 +305554 +305555 +305556 +305558 +305563 +305564 +305565 +305566 +305568 +305569 +305570 +305571 +305572 +305573 +305574 +305578 +305588 +305590 +305598 +305600 +305601 +305602 +305603 +305604 +305605 +305609 +305610 +305611 +305612 +305613 +305614 +305615 +305617 +305618 +305619 +305620 +305622 +305624 +305625 +305626 +305628 +305629 +305630 +305633 +305635 +305642 +305645 +305646 +305647 +305648 +305649 +305650 +305651 +305652 +305653 +305654 +305655 +305656 +305657 +305658 +305659 +305660 +305663 +305668 +305669 +305671 +305672 +305673 +305674 +305675 +305676 +305677 +305678 +305679 +305680 +305681 +305682 +305683 +305684 +305685 +305686 +305687 +305688 +305689 +305690 +305691 +305692 +305693 +305694 +305695 +305698 +305699 +305700 +305701 +305702 +305703 +305713 +305716 +305718 +305720 +305722 +305724 +305725 +305726 +305730 +305733 +305739 +305740 +305741 +305742 +305744 +305746 +305747 +305748 +305758 +305759 +305760 +305761 +305762 +305763 +305764 +305765 +305766 +305767 +305768 +305769 +305770 +305771 +305772 +305773 +305774 +305775 +305776 +305782 +305783 +305784 +305789 +305790 +305791 +305792 +305793 +305794 +305795 +305796 +305797 +305798 +305799 +305800 +305801 +305802 +305803 +305804 +305805 +305806 +305807 +305808 +305809 +305810 +305811 +305812 +305813 +305814 +305815 +305816 +305817 +305818 +305819 +305820 +305821 +305822 +305823 +305824 +305825 +305826 +305827 +305828 +305829 +305830 +305831 +305832 +305833 +305834 +305835 +305836 +305837 +305838 +305839 +305840 +305841 +305842 +305843 +305844 +305845 +305846 +305847 +305848 +305849 +305850 +305851 +305852 +305853 +305854 +305855 +305856 +305857 +305858 +305859 +305860 +305861 +305862 +305863 +305864 +305865 +305866 +305867 +305868 +305869 +305870 +305871 +305872 +305873 +305874 +305875 +305876 +305877 +305878 +305879 +305880 +305881 +305882 +305883 +305884 +305885 +305886 +305887 +305888 +305889 +305890 +305891 +305892 +305893 +305894 +305895 +305896 +305897 +305898 +305899 +305900 +305901 +305902 +305903 +305904 +305905 +305906 +305907 +305908 +305909 +305910 +305911 +305912 +305913 +305914 +305915 +305916 +305917 +305918 +305919 +305920 +305921 +305922 +305923 +305924 +305925 +305926 +305927 +305928 +305929 +305930 +305931 +305932 +305933 +305934 +305935 +305936 +305937 +305938 +305939 +305940 +305941 +305942 +305943 +305944 +305945 +305946 +305947 +305948 +305949 +305950 +305951 +305952 +305953 +305954 +305955 +305956 +305957 +305958 +305959 +305960 +305961 +305962 +305963 +305964 +305965 +305966 +305967 +305968 +305969 +305970 +305971 +305972 +305973 +305974 +305975 +305976 +305977 +305978 +305979 +305980 +305981 +305982 +305983 +305984 +305986 +305987 +305988 +305989 +305990 +305991 +305992 +305993 +305994 +305995 +305996 +305997 +306000 +306002 +306006 +306007 +306008 +306009 +306010 +306011 +306012 +306013 +306014 +306015 +306016 +306017 +306018 +306019 +306020 +306021 +306022 +306023 +306024 +306025 +306026 +306027 +306028 +306029 +306030 +306031 +306032 +306033 +306034 +306035 +306036 +306037 +306038 +306039 +306040 +306041 +306042 +306043 +306044 +306045 +306046 +306047 +306048 +306049 +306050 +306051 +306052 +306053 +306054 +306055 +306056 +306057 +306058 +306059 +306060 +306061 +306062 +306063 +306064 +306065 +306066 +306067 +306068 +306069 +306070 +306071 +306072 +306073 +306074 +306075 +306076 +306077 +306078 +306079 +306080 +306081 +306082 +306083 +306084 +306085 +306086 +306087 +306088 +306089 +306090 +306091 +306092 +306093 +306094 +306095 +306096 +306097 +306098 +306099 +306100 +306101 +306102 +306103 +306104 +306105 +306106 +306108 +306109 +306110 +306111 +306112 +306113 +306114 +306115 +306116 +306117 +306118 +306119 +306120 +306121 +306122 +306123 +306124 +306125 +306126 +306127 +306128 +306129 +306130 +306131 +306132 +306133 +306134 +306135 +306136 +306137 +306138 +306139 +306140 +306141 +306142 +306143 +306144 +306145 +306146 +306147 +306148 +306149 +306150 +306151 +306152 +306153 +306154 +306155 +306156 +306157 +306158 +306159 +306160 +306161 +306162 +306163 +306164 +306165 +306166 +306167 +306168 +306169 +306170 +306171 +306172 +306173 +306174 +306175 +306176 +306177 +306178 +306179 +306180 +306181 +306182 +306183 +306184 +306185 +306186 +306187 +306188 +306189 +306190 +306191 +306192 +306193 +306194 +306195 +306196 +306197 +306198 +306199 +306200 +306201 +306202 +306203 +306204 +306209 +306210 +306211 +306212 +306213 +306214 +306215 +306216 +306217 +306218 +306219 +306220 +306221 +306222 +306223 +306224 +306225 +306226 +306227 +306228 +306229 +306230 +306231 +306232 +306233 +306234 +306235 +306236 +306237 +306238 +306239 +306240 +306241 +306242 +306243 +306244 +306248 +306267 +306268 +306269 +306270 +306271 +306272 +306273 +306274 +306275 +306276 +306277 +306278 +306279 +306280 +306281 +306282 +306283 +306284 +306285 +306286 +306287 +306288 +306290 +306291 +306292 +306293 +306294 +306296 +306297 +306298 +306299 +306311 +306314 +306323 +306329 +306330 +306335 +306339 +306340 +306341 +306342 +306343 +306344 +306346 +306351 +306352 +306353 +306354 +306355 +306356 +306357 +306358 +306360 +306361 +306362 +306363 +306364 +306365 +306366 +306367 +306368 +306369 +306370 +306371 +306372 +306373 +306374 +306375 +306376 +306377 +306378 +306379 +306380 +306381 +306382 +306383 +306384 +306385 +306386 +306387 +306388 +306389 +306390 +306391 +306392 +306393 +306394 +306395 +306396 +306397 +306398 +306399 +306400 +306401 +306402 +306403 +306404 +306408 +306413 +306414 +306415 +306416 +306417 +306418 +306419 +306420 +306421 +306422 +306423 +306424 +306425 +306427 +306428 +306429 +306430 +306431 +306432 +306433 +306434 +306435 +306436 +306437 +306438 +306439 +306440 +306441 +306442 +306443 +306444 +306445 +306446 +306447 +306448 +306449 +306450 +306451 +306452 +306453 +306454 +306455 +306456 +306457 +306458 +306459 +306460 +306461 +306462 +306463 +306464 +306465 +306466 +306467 +306468 +306469 +306470 +306471 +306472 +306473 +306474 +306475 +306476 +306477 +306478 +306479 +306480 +306481 +306482 +306483 +306484 +306485 +306486 +306487 +306488 +306489 +306490 +306491 +306492 +306493 +306494 +306495 +306496 +306497 +306498 +306499 +306500 +306501 +306502 +306503 +306504 +306505 +306506 +306507 +306508 +306509 +306511 +306512 +306513 +306514 +306515 +306516 +306517 +306518 +306519 +306520 +306523 +306524 +306525 +306526 +306527 +306528 +306529 +306530 +306531 +306532 +306533 +306534 +306535 +306536 +306537 +306538 +306539 +306540 +306541 +306542 +306543 +306544 +306545 +306546 +306547 +306548 +306549 +306550 +306552 +306553 +306554 +306555 +306558 +306559 +306560 +306561 +306562 +306563 +306564 +306565 +306566 +306567 +306568 +306569 +306570 +306571 +306572 +306573 +306574 +306576 +306577 +306580 +306581 +306582 +306583 +306584 +306585 +306586 +306587 +306588 +306589 +306590 +306591 +306592 +306593 +306594 +306595 +306596 +306597 +306600 +306601 +306603 +306604 +306605 +306606 +306607 +306608 +306610 +306616 +306659 +306660 +306661 +306662 +306663 +307366 +307415 +307416 +307417 +307418 +307419 +307420 +307421 +307422 +307424 +307426 +307427 +307429 +307430 +307432 +307433 +307434 +307436 +307437 +307438 +307439 +307440 +307441 +307442 +307443 +307444 +307445 +307447 +307448 +307450 +307451 +307452 +307453 +307456 +307463 +307464 +307466 +307467 +307468 +307470 +307471 +307474 +307475 +307479 +307481 +307483 +307484 +307485 +307486 +307487 +307488 +307489 +307493 +307495 +307496 +307498 +307499 +307502 +307508 +307510 +307511 +307513 +307514 +307515 +307516 +307517 +307518 +307519 +307520 +307521 +307522 +307523 +307524 +307525 +307526 +307527 +307528 +307529 +307530 +307531 +307532 +307533 +307534 +307535 +307536 +307537 +307538 +307539 +307540 +307541 +307542 +307543 +307544 +307545 +307546 +307547 +307548 +307549 +307550 +307551 +307552 +307553 +307554 +307555 +307556 +307557 +307558 +307559 +307560 +307561 +307562 +307563 +307564 +307565 +307566 +307567 +307568 +307569 +307570 +307571 +307572 +307573 +307574 +307575 +307576 +307577 +307578 +307579 +307580 +307581 +307582 +307583 +307584 +307585 +307586 +307587 +307588 +307589 +307590 +307591 +307592 +307593 +307594 +307595 +307596 +307597 +307598 +307599 +307600 +307601 +307602 +307603 +307604 +307605 +307606 +307607 +307608 +307609 +307610 +307611 +307612 +307613 +307614 +307615 +307616 +307617 +307618 +307619 +307620 +307622 +307623 +307624 +307625 +307627 +307628 +307629 +307630 +307631 +307632 +307633 +307634 +307635 +307636 +307637 +307638 +307639 +307640 +307641 +307642 +307643 +307645 +307646 +307648 +307649 +307650 +307651 +307652 +307653 +307654 +307655 +307656 +307657 +307659 +307660 +307661 +307662 +307663 +307664 +307665 +307666 +307667 +307668 +307670 +307671 +307672 +307673 +307675 +307676 +307678 +307679 +307680 +307681 +307682 +307683 +307686 +307687 +307690 +307691 +307692 +307693 +307694 +307695 +307696 +307697 +307698 +307699 +307700 +307701 +307702 +307704 +307705 +307706 +307707 +307708 +307709 +307710 +307711 +307712 +307713 +307714 +307715 +307716 +307718 +307719 +307722 +307723 +307724 +307726 +307727 +307730 +307732 +307733 +307734 +307735 +307736 +307737 +307738 +307739 +307740 +307741 +307742 +307743 +307744 +307745 +307746 +307747 +307748 +307749 +307750 +307751 +307752 +307753 +307754 +307755 +307756 +307757 +307758 +307759 +307760 +307761 +307762 +307763 +307764 +307765 +307766 +307767 +307768 +307769 +307770 +307771 +307772 +307773 +307774 +307775 +307776 +307777 +307778 +307779 +307780 +307781 +307782 +307783 +307784 +307785 +307786 +307787 +307788 +307789 +307790 +307791 +307792 +307793 +307794 +307795 +307796 +307797 +307798 +307799 +307800 +307801 +307802 +307803 +307804 +307805 +307806 +307807 +307808 +307809 +307810 +307811 +307812 +307813 +307814 +307815 +307816 +307822 +307823 +307824 +307825 +307826 +307827 +307828 +307829 +307830 +307831 +307832 +307833 +307834 +307835 +307836 +307837 +307838 +307839 +307840 +307841 +307842 +307843 +307844 +307845 +307846 +307847 +307848 +307849 +307850 +307851 +307852 +307853 +307854 +307855 +307856 +307857 +307858 +307859 +307860 +307861 +307862 +307863 +307865 +307866 +307867 +307868 +307869 +307870 +307872 +307873 +307874 +307875 +307876 +307877 +307878 +307879 +307880 +307881 +307882 +307883 +307884 +307885 +307886 +307887 +307888 +307889 +307890 +307892 +307893 +307894 +307895 +307896 +307897 +307898 +307899 +307900 +307901 +307902 +307903 +307904 +307905 +307906 +307907 +307908 +307909 +307910 +307911 +307912 +307913 +307914 +307915 +307916 +307917 +307918 +307919 +307920 +307921 +307922 +307923 +307924 +307925 +307926 +307927 +307928 +307929 +307930 +307931 +307932 +307933 +307934 +307935 +307936 +307937 +307938 +307939 +307940 +307941 +307942 +307943 +307945 +307946 +307951 +307953 +307954 +307955 +307956 +307960 +307961 +307962 +307963 +307970 +307971 +307974 +307975 +307979 +307980 +307981 +307982 +307983 +307984 +307985 +307986 +307987 +307988 +307989 +307990 +307991 +307992 +307993 +307994 +307995 +307996 +307997 +307998 +307999 +308000 +308001 +308003 +308004 +308005 +308006 +308007 +308008 +308009 +308010 +308011 +308012 +308013 +308014 +308015 +308016 +308017 +308018 +308021 +308022 +308023 +308024 +308025 +308026 +308027 +308030 +308031 +308032 +308033 +308034 +308035 +308036 +308037 +308040 +308041 +308042 +308043 +308044 +308046 +308047 +308048 +308049 +308050 +308051 +308052 +308054 +308055 +308056 +308058 +308059 +308061 +308062 +308063 +308064 +308065 +308066 +308068 +308069 +308070 +308071 +308072 +308073 +308074 +308075 +308077 +308079 +308081 +308084 +308085 +308086 +308087 +308088 +308089 +308090 +308091 +308092 +308093 +308094 +308095 +308096 +308097 +308098 +308099 +308101 +308102 +308103 +308104 +308105 +308106 +308107 +308108 +308109 +308110 +308111 +308112 +308113 +308114 +308115 +308116 +308117 +308118 +308119 +308120 +308121 +308122 +308123 +308124 +308125 +308126 +308127 +308128 +308129 +308130 +308131 +308132 +308133 +308134 +308135 +308136 +308137 +308138 +308139 +308140 +308141 +308142 +308143 +308144 +308145 +308146 +308147 +308148 +308149 +308150 +308151 +308152 +308153 +308154 +308155 +308156 +308157 +308158 +308159 +308160 +308161 +308162 +308163 +308164 +308165 +308166 +308167 +308168 +308169 +308170 +308171 +308172 +308173 +308174 +308175 +308176 +308177 +308178 +308182 +308183 +308184 +308185 +308186 +308187 +308189 +308190 +308191 +308192 +308193 +308194 +308195 +308196 +308197 +308198 +308199 +308201 +308221 +308222 +308223 +308224 +308225 +308227 +308241 +308245 +308247 +308251 +308252 +308253 +308254 +308255 +308256 +308257 +308258 +308260 +308261 +308262 +308265 +308266 +308267 +308271 +308272 +308273 +308274 +308275 +308276 +308277 +308278 +308279 +308280 +308281 +308282 +308283 +308284 +308285 +308287 +308288 +308289 +308290 +308291 +308311 +308312 +308313 +308314 +308315 +308316 +308318 +308319 +308323 +308325 +308326 +308327 +308328 +308334 +308335 +308336 +308338 +308342 +308343 +308350 +308353 +308354 +308356 +308412 +308415 +308417 +308420 +308422 +308424 +308428 +308429 +308430 +308464 +308465 +308468 +308469 +308470 +308471 +308472 +308473 +308474 +308487 +308488 +308489 +308490 +308491 +308492 +308493 +308494 +308495 +308496 +308497 +308498 +308499 +308500 +308501 +308502 +308503 +308504 +308505 +308506 +308507 +308508 +308509 +308510 +308511 +308512 +308513 +308514 +308515 +308516 +308517 +308518 +308519 +308520 +308521 +308522 +308523 +308524 +308525 +308526 +308527 +308528 +308529 +308530 +308531 +308532 +308533 +308534 +308535 +308536 +308538 +308539 +308540 +308541 +308542 +308543 +308544 +308545 +308547 +308548 +308549 +308550 +308551 +308552 +308553 +308554 +308555 +308556 +308557 +308558 +308559 +308560 +308561 +308562 +308563 +308564 +308565 +308566 +308567 +308568 +308569 +308570 +308571 +308572 +308573 +308574 +308575 +308577 +308578 +308580 +308581 +308582 +308583 +308584 +308585 +308586 +308587 +308588 +308589 +308590 +308591 +308592 +308593 +308594 +308595 +308596 +308597 +308598 +308599 +308600 +308601 +308602 +308603 +308604 +308605 +308606 +308608 +308609 +308610 +308611 +308612 +308613 +308614 +308615 +308616 +308617 +308618 +308619 +308620 +308621 +308622 +308623 +308624 +308625 +308626 +308627 +308628 +308629 +308630 +308631 +308632 +308633 +308634 +308636 +308637 +308638 +308639 +308640 +308641 +308642 +308643 +308644 +308645 +308646 +308647 +308648 +308649 +308650 +308651 +308652 +308653 +308654 +308655 +308656 +308657 +308658 +308659 +308660 +308661 +308662 +308663 +308664 +308665 +308666 +308667 +308668 +308669 +308670 +308671 +308672 +308673 +308674 +308675 +308676 +308677 +308678 +308679 +308680 +308681 +308682 +308683 +308684 +308685 +308686 +308687 +308688 +308689 +308690 +308691 +308692 +308693 +308694 +308695 +308696 +308697 +308698 +308699 +308700 +308702 +308703 +308706 +308707 +308709 +308710 +308711 +308712 +308713 +308715 +308716 +308717 +308718 +308719 +308720 +308721 +308722 +308723 +308724 +308725 +308726 +308727 +308728 +308729 +308730 +308731 +308732 +308733 +308734 +308735 +308736 +308741 +308742 +308745 +308746 +308747 +308748 +308749 +308750 +308752 +308753 +308754 +308755 +308756 +308758 +308760 +308761 +308762 +308763 +308764 +308765 +308766 +308767 +308770 +308784 +308785 +308789 +308790 +308791 +308792 +308793 +308794 +308795 +308796 +308797 +308798 +308800 +308801 +308802 +308803 +308804 +308805 +308806 +308807 +308808 +308809 +308810 +308811 +308812 +308813 +308814 +308815 +308816 +308817 +308818 +308819 +308820 +308821 +308822 +308823 +308824 +308825 +308826 +308827 +308828 +308829 +308830 +308831 +308832 +308833 +308834 +308835 +308836 +308837 +308838 +308839 +308840 +308841 +308842 +308843 +308844 +308845 +308846 +308847 +308848 +308849 +308850 +308851 +308852 +308853 +308854 +308855 +308857 +308858 +308859 +308860 +308861 +308862 +308863 +308864 +308865 +308866 +308867 +308868 +308869 +308870 +308871 +308872 +308873 +308875 +308876 +308877 +308878 +308879 +308880 +308881 +308882 +308883 +308885 +308886 +308887 +308888 +308889 +308890 +308891 +308892 +308893 +308894 +308895 +308896 +308897 +308898 +308899 +308901 +308902 +308903 +308904 +308905 +308906 +308907 +308908 +308910 +308911 +308912 +308913 +308914 +308915 +308916 +308917 +308918 +308919 +308920 +308921 +308922 +308923 +308924 +308925 +308926 +308927 +308928 +308929 +308930 +308931 +308932 +308933 +308934 +308935 +308936 +308937 +308938 +308939 +308940 +308941 +308942 +308943 +308944 +308945 +308946 +308947 +308948 +308949 +308950 +308951 +308952 +308953 +308954 +308955 +308956 +308957 +308958 +308959 +308960 +308961 +308962 +308963 +308964 +308965 +308966 +308967 +308968 +308969 +308970 +308971 +308972 +308973 +308974 +308975 +308976 +308977 +308978 +308979 +308980 +308981 +308982 +308983 +308984 +308985 +308986 +308987 +308988 +308989 +308990 +308991 +308992 +308993 +308994 +308995 +308996 +308997 +308998 +308999 +309000 +309004 +309005 +309007 +309011 +309012 +309013 +309014 +309015 +309016 +309017 +309018 +309019 +309020 +309021 +309022 +309023 +309024 +309025 +309026 +309027 +309048 +309082 +309083 +309084 +309085 +309089 +309094 +309096 +309097 +309098 +309100 +309101 +309102 +309103 +309104 +309105 +309106 +309107 +309108 +309109 +309110 +309111 +309112 +309113 +309114 +309115 +309116 +309118 +309119 +309120 +309121 +309122 +309138 +309139 +309140 +309141 +309142 +309143 +309144 +309145 +309146 +309147 +309148 +309149 +309150 +309151 +309152 +309153 +309154 +309155 +309156 +309157 +309158 +309162 +309163 +309164 +309165 +309166 +309167 +309168 +309169 +309170 +309172 +309173 +309174 +309175 +309176 +309177 +309178 +309179 +309180 +309181 +309182 +309183 +309186 +309187 +309188 +309193 +309194 +309195 +309198 +309199 +309200 +309201 +309204 +309205 +309207 +309208 +309212 +309213 +309214 +309215 +309216 +309217 +309218 +309219 +309220 +309221 +309222 +309225 +309226 +309227 +309228 +309229 +309233 +309238 +309239 +309240 +309241 +309242 +309243 +309244 +309252 +309253 +309254 +309255 +309256 +309257 +309258 +309259 +309260 +309261 +309262 +309263 +309264 +309265 +309266 +309269 +309270 +309271 +309274 +309275 +309276 +309277 +309278 +309279 +309280 +309281 +309282 +309283 +309284 +309285 +309286 +309287 +309288 +309289 +309290 +309291 +309292 +309293 +309294 +309295 +309298 +309300 +309301 +309302 +309303 +309316 +309317 +309318 +309319 +309323 +309328 +309329 +309330 +309331 +309335 +309336 +309337 +309338 +309339 +309340 +309341 +309344 +309346 +309347 +309349 +309350 +309352 +309353 +309354 +309355 +309356 +309357 +309358 +309360 +309361 +309362 +309363 +309364 +309365 +309367 +309368 +309370 +309371 +309372 +309373 +309374 +309375 +309376 +309377 +309380 +309381 +309382 +309383 +309387 +309388 +309389 +309390 +309391 +309392 +309393 +309394 +309395 +309396 +309397 +309398 +309399 +309400 +309401 +309402 +309403 +309404 +309405 +309406 +309407 +309408 +309409 +309410 +309411 +309412 +309413 +309414 +309415 +309416 +309417 +309418 +309419 +309420 +309421 +309429 +309431 +309436 +309437 +309438 +309439 +309440 +309441 +309443 +309444 +309446 +309447 +309448 +309449 +309451 +309457 +309458 +309459 +309460 +309463 +309467 +309468 +309469 +309470 +309471 +309475 +309480 +309483 +309484 +309485 +309486 +309487 +309488 +309489 +309490 +309491 +309492 +309493 +309494 +309495 +309496 +309497 +309498 +309499 +309500 +309501 +309502 +309503 +309504 +309505 +309506 +309507 +309508 +309509 +309510 +309511 +309512 +309513 +309514 +309515 +309516 +309517 +309518 +309519 +309520 +309522 +309523 +309524 +309525 +309526 +309527 +309528 +309529 +309530 +309531 +309532 +309533 +309534 +309535 +309536 +309537 +309538 +309539 +309540 +309541 +309542 +309543 +309544 +309545 +309546 +309547 +309548 +309549 +309550 +309551 +309552 +309553 +309554 +309555 +309556 +309557 +309558 +309559 +309560 +309561 +309563 +309564 +309565 +309566 +309567 +309568 +309569 +309570 +309571 +309586 +309591 +309592 +309777 +309778 +309783 +309788 +309981 +309991 +310003 +310004 +310009 +310016 +310017 +310019 +310020 +310021 +310022 +310023 +310024 +310025 +310026 +310027 +310028 +310029 +310030 +310031 +310032 +310033 +310034 +310035 +310036 +310037 +310038 +310040 +310041 +310044 +310066 +310068 +310083 +310159 +310160 +310164 +310165 +310178 +310212 +310213 +310214 +310215 +310216 +310217 +310218 +310219 +310220 +310246 +310282 +310285 +310286 +310287 +310288 +310289 +310290 +310293 +310319 +310564 +310565 +310566 +310567 +310568 +310570 +310571 +310572 +310573 +310574 +310575 +310576 +310581 +310582 +310583 +310584 +310585 +310586 +310587 +310588 +310589 +310590 +310591 +310592 +310593 +310594 +310595 +310596 +310597 +310598 +310599 +310600 +310601 +310602 +310603 +310604 +310605 +310606 +310607 +310608 +310609 +310610 +310611 +310614 +310615 +310616 +310617 +310618 +310619 +310620 +310621 +310622 +310623 +310625 +310627 +310628 +310630 +310634 +310635 +400382 +400410 +400443 +400454 +400462 +400463 +400476 +400525 +400526 +403119 +403120 +403121 +403122 +403123 +403124 +403125 +403126 +403129 +403131 +403132 +403133 +403134 +403135 +403136 +403137 +403138 +403139 +403140 +403141 +403142 +403143 +403144 +403145 +403147 +403148 +403149 +403150 +403151 +403152 +403153 +403154 +403155 +403156 +403157 +403158 +403159 +403160 +403161 +403163 +403164 +403165 +403166 +403170 +403171 +403172 +403173 +403174 +403175 +403176 +403177 +403178 +403179 +403180 +403181 +403182 +403183 +403184 +403185 +403186 +403187 +403188 +403190 +403191 +403203 +403214 +403245 +403248 +403249 +403250 +403251 +403252 +403253 +403254 +403256 +403257 +403260 +403263 +403266 +403267 +403268 +403269 +403272 +403273 +403274 +403275 +403276 +403279 +403280 +403281 +403282 +403284 +403285 +403286 +403287 +403291 +403292 +403293 +403296 +403301 +403302 +403303 +403307 +403318 +403339 +403340 +403341 +403342 +403344 +403345 +403346 +403347 +403348 +403349 +403351 +403352 +403353 +403354 +403355 +403356 +403357 +403358 +403359 +403360 +403361 +403362 +403363 +403364 +403365 +403366 +403367 +403368 +403370 +403371 +403372 +403373 +403374 +403375 +403376 +403378 +403379 +403381 +403382 +403383 +403384 +403385 +403386 +403387 +403411 +403412 +403413 +403414 +403416 +403417 +403420 +403433 +403434 +403435 +403462 +403463 +403630 +403631 +403633 +403636 +403637 +403638 +403639 +403640 +403641 +403642 +403644 +403645 +403646 +403651 +403652 +403653 +403654 +403655 +403656 +403657 +403658 +403659 +403660 +403661 +403662 +403663 +403664 +403665 +403666 +403667 +403668 +403669 +403670 +403671 +403672 +403673 +403674 +403675 +403676 +403677 +403678 +403679 +403680 +403681 +403682 +403683 +403684 +403685 +403686 +403687 +403688 +403689 +403690 +403691 +403692 +403693 +403694 +403695 +403696 +403697 +403698 +403699 +403700 +403701 +403702 +403703 +403704 +403705 +403706 +403707 +403708 +403709 +403710 +403711 +403712 +403713 +403714 +403715 +403716 +403717 +403718 +403719 +403720 +403721 +403722 +403723 +403728 +403729 +403732 +403734 +403735 +403736 +403737 +403738 +403739 +403740 +403741 +403742 +403743 +403744 +403745 +403747 +403748 +403749 +403750 +403751 +403752 +403754 +403760 +403763 +403814 +403815 +403816 +403881 +403882 +403883 +403884 +403886 +403889 +403890 +403892 +403893 +403974 +403977 +403978 +406664 +406665 +406676 +406681 +406700 +406701 +406703 +406704 +406706 +406707 +406714 +406716 +406806 +406869 +406870 +406871 +406878 +406883 +406954 +406955 +406956 +406957 +406958 +406959 +406960 +406961 +406962 +406979 +406980 +407003 +407004 +407015 +407026 +407037 +407048 +407059 +407070 +407081 +407092 +407103 +407114 +407115 +407122 +407123 +407124 +407131 +407139 +407145 +407147 +407149 +407150 +407152 +407175 +407186 +407197 +407208 +407219 +407230 +407247 +407299 +407314 +407315 +407350 +407351 +407352 +407358 +407362 +407371 +407377 +407378 +407379 +407398 +409069 +409070 +409123 +409124 +409125 +409126 +409127 +409128 +409129 +409130 +409131 +409132 +409133 +409134 +409135 +409136 +409137 +409992 +500662 +500663 +500664 +500665 +500666 +500669 +500670 +500671 +500672 +500673 +500674 +500675 +500676 +500677 +500678 +500679 +500684 +500686 +500687 +500690 +500691 +500692 +500693 +500694 +500696 +500697 +500698 +500699 +500700 +500701 +500702 +500703 +500704 +500705 +500707 +500708 +500709 +500710 +500711 +500712 +500713 +500714 +500715 +500718 +500719 +500720 +500721 +500723 +500724 +500725 +500726 +500727 +500729 +500730 +500731 +500732 +500733 +500734 +500735 +500736 +500737 +500738 +500740 +500744 +500745 +500746 +500747 +500748 +500749 +500751 +500752 +500753 +500754 +500755 +500756 +500757 +500758 +500759 +500760 +500761 +500762 +500765 +500766 +500767 +500768 +500769 +500771 +500772 +500773 +500774 +500775 +500776 +500777 +500778 +500781 +500782 +500783 +500784 +500785 +500786 +500787 +500788 +500791 +500792 +500793 +500794 +500795 +500800 +500801 +500802 +500806 +500807 +500808 +500809 +500810 +500811 +500813 +500814 +500815 +500816 +500817 +500818 +500819 +500820 +500821 +500822 +500824 +500825 +500826 +500827 +500828 +500829 +500830 +500831 +500832 +500836 +500837 +500838 +500839 +500841 +500842 +500843 +500844 +500846 +500847 +500848 +500849 +500850 +500851 +500852 +500853 +500854 +500855 +500858 +500860 +500861 +500862 +500863 +500864 +500866 +500869 +500870 +500871 +500872 +500873 +500874 +500875 +500876 +500877 +500878 +500879 +500880 +500881 +500882 +500883 +500884 +500885 +500886 +500891 +500892 +500893 +500894 +500895 +500896 +500897 +500899 +500900 +500901 +500902 +500903 +500905 +500906 +500907 +500908 +500909 +500920 +500932 +500933 +500934 +500935 +500936 +500937 +500938 +500948 +500949 +500950 +500951 +500953 +500954 +500955 +500956 +500957 +500958 +500959 +500960 +500961 +500962 +500963 +500964 +500973 +500975 +500977 +500978 +500981 +500982 +500983 +500999 +501005 +501006 +501007 +501008 +501009 +501010 +501011 +501012 +501013 +501014 +501015 +501016 +501017 +501018 +501020 +501021 +501023 +501024 +501025 +501026 +501027 +501028 +501029 +501030 +501032 +501033 +501034 +501035 +501036 +501039 +501040 +501041 +501042 +501043 +501044 +501045 +501046 +501047 +501048 +501049 +501050 +501051 +501054 +501057 +501058 +501059 +501060 +501061 +501063 +501067 +501081 +501082 +501083 +501086 +501087 +501088 +501089 +501090 +501091 +501093 +501094 +501095 +501097 +501098 +501102 +501104 +501106 +501107 +501108 +501117 +501120 +501124 +501127 +501128 +501136 +501212 +501214 +501219 +501220 +501221 +501222 +501223 +501225 +501226 +501227 +501228 +501229 +501230 +501231 +501232 +501307 +501310 +501311 +501312 +501313 +501314 +501315 +501316 +501317 +501318 +501321 +501322 +501323 +501324 +501325 +501326 +501327 +501328 +501329 +501331 +501332 +501333 +501334 +501335 +501336 +501337 +501338 +501339 +501340 +501341 +501342 +501343 +501344 +501345 +501346 +501347 +501348 +501349 +501350 +501351 +501352 +501353 +501354 +501355 +501356 +501357 +501358 +501359 +501360 +501361 +501362 +501363 +501364 +501367 +501368 +501369 +501370 +501371 +501372 +501373 +501376 +501377 +501378 +501379 +501380 +501381 +501382 +501383 +501384 +501385 +501386 +501387 +501388 +501389 +501390 +501391 +501392 +501393 +501394 +501395 +501396 +501397 +501398 +501399 +501400 +501401 +501404 +501406 +501409 +501410 +501412 +501414 +501415 +501416 +501417 +501423 +501435 +501437 +501439 +501449 +501461 +501462 +501463 +501464 +501465 +501466 +501469 +501470 +501472 +501480 +501490 +501491 +501492 +501493 +501494 +501495 +501496 +501497 +501498 +501499 +501500 +501501 +501502 +501503 +501504 +501505 +501506 +501507 +501508 +501509 +501510 +501511 +501512 +501513 +501514 +501515 +501516 +501517 +501518 +501519 +501520 +501521 +501522 +501523 +501524 +501525 +501526 +501527 +501528 +501529 +501530 +501531 +501532 +501533 +501534 +501535 +501536 +501537 +501538 +501539 +501540 +501541 +501542 +501546 +501548 +501549 +501550 +501551 +501552 +501555 +501556 +501558 +501559 +501560 +501561 +501562 +501563 +501564 +501566 +501567 +501569 +501570 +501571 +501572 +501575 +501576 +501577 +501578 +501580 +501581 +501582 +501583 +501584 +501585 +501586 +501587 +501588 +501589 +501591 +501592 +501593 +501594 +501595 +501596 +501597 +501600 +501603 +501607 +501608 +501609 +501614 +501615 +501617 +501618 +501619 +501620 +501621 +501622 +501623 +501624 +501625 +501626 +501627 +501628 +501629 +501630 +501631 +501632 +501633 +501634 +501635 +501636 +501637 +501638 +501639 +501640 +501641 +501642 +501643 +501644 +501645 +501646 +501647 +501648 +501649 +501650 +501651 +501652 +501653 +501655 +501656 +501662 +501663 +501664 +501667 +501672 +501673 +501674 +501675 +501676 +501677 +501678 +501679 +501680 +501681 +501682 +501683 +501684 +501685 +501686 +501687 +501688 +501689 +501691 +501693 +501694 +501696 +501697 +501698 +501700 +501701 +501702 +501703 +501704 +501705 +501706 +501707 +501708 +501709 +501711 +501712 +501713 +501714 +501715 +501716 +501717 +501718 +501719 +501720 +501721 +501722 +501723 +501724 +501725 +501726 +501738 +501740 +501742 +501743 +501744 +501745 +501746 +501753 +501765 +501766 +501767 +501768 +501769 +501772 +501774 +501775 +501776 +501777 +501779 +501786 +501790 +501791 +501798 +501799 +501801 +501814 +501817 +501818 +501821 +501823 +501845 +501857 +501858 +501859 +501869 +501870 +501871 +501872 +501874 +501875 +501876 +501902 +501903 +501904 +501905 +501906 +501907 +501908 +501909 +501910 +501916 +501917 +501919 +501922 +501923 +501924 +501925 +501927 +501928 +501931 +501935 +501944 +501945 +501946 +501949 +501950 +501953 +501954 +501956 +501957 +501958 +501959 +501960 +501962 +501963 +501967 +501968 +501969 +501971 +501974 +501975 +501976 +501977 +601979 +601980 +601981 +601982 +601983 +601984 +601985 +601986 +601987 +601988 +601989 +601990 +601991 +601992 +601994 +601995 +601996 +601997 +601998 +601999 +602000 +602001 +602002 +602003 +602004 +602013 +602019 +602020 +602021 +602022 +602023 +602024 +602025 +602026 +602027 +602028 +602029 +602030 +602031 +602032 +602033 +602034 +602035 +602036 +602037 +602038 +602039 +602040 +602041 +602042 +602043 +602044 +602045 +602046 +602047 +602048 +602049 +602050 +602051 +602052 +602053 +602054 +602055 +602056 +602057 +602058 +602059 +602060 +602061 +602062 +602063 +602064 +602065 +602066 +602067 +602068 +602069 +602070 +602071 +602072 +602073 +602074 +602075 +602076 +602077 +602078 +602079 +602080 +602081 +602082 +602083 +602084 +602085 +602086 +602087 +602088 +602089 +602090 +602092 +602093 +602094 +602095 +602096 +602097 +602098 +602099 +602100 +602101 +602103 +602104 +602105 +602106 +602107 +602108 +602109 +602110 +602111 +602112 +602113 +602116 +602117 +602118 +602121 +602124 +602125 +602127 +602128 +602130 +602131 +602132 +602133 +602134 +602136 +602137 +602138 +602139 +602140 +602141 +602142 +602143 +602144 +602145 +602146 +602147 +602148 +602149 +602150 +602151 +602152 +602154 +602155 +602159 +602161 +602164 +602165 +602166 +602170 +602173 +602175 +602176 +602178 +602179 +602180 +602181 +602188 +602189 +602190 +602191 +602192 +602193 +602194 +602195 +602200 +602201 +602202 +602203 +602204 +602205 +602206 +602207 +602208 +602209 +602210 +602211 +602212 +602213 +602214 +602215 +602216 +602217 +602218 +602219 +602220 +602221 +602222 +602223 +602224 +602225 +602226 +602228 +602229 +602230 +602231 +602232 +602233 +602234 +602235 +602236 +602238 +602239 +602240 +602241 +602242 +602243 +602244 +602245 +602246 +602247 +602248 +602249 +602250 +602251 +602252 +602253 +602255 +602256 +602257 +602258 +602259 +602260 +602261 +602262 +602263 +602265 +602266 +602267 +602268 +602269 +602270 +602271 +602272 +602273 +602274 +602275 +602277 +602278 +602279 +602280 +602281 +602282 +602283 +602284 +602285 +602286 +602288 +602289 +602290 +602291 +602292 +602293 +602294 +602295 +602296 +602297 +602298 +602299 +602300 +602301 +602302 +602303 +602304 +602305 +602306 +602307 +602308 +602310 +602311 +602312 +602313 +602314 +602315 +602316 +602317 +602318 +602319 +602320 +602321 +602322 +602323 +602324 +602325 +602326 +602327 +602328 +602329 +602330 +602332 +602333 +602334 +602335 +602336 +602337 +602338 +602339 +602340 +602341 +602342 +602344 +602345 +602346 +602347 +602348 +602349 +602350 +602351 +602352 +602353 +602354 +602355 +602356 +602357 +602358 +602359 +602360 +602361 +602362 +602363 +602364 +602366 +602367 +602368 +602369 +602370 +602371 +602372 +602373 +602374 +602375 +602377 +602378 +602379 +602380 +602381 +602382 +602383 +602384 +602385 +602386 +602387 +602388 +602389 +602390 +602391 +602392 +602393 +602394 +602395 +602396 +602397 +602399 +602400 +602401 +602402 +602403 +602404 +602405 +602406 +602408 +602410 +602411 +602412 +602413 +602414 +602415 +602416 +602417 +602418 +602419 +602421 +602422 +602423 +602424 +602427 +602432 +602433 +602438 +602441 +602442 +602443 +602444 +602446 +602449 +602450 +602451 +602452 +602454 +602456 +602459 +602461 +602462 +602464 +602465 +602466 +602467 +602468 +602469 +602470 +602475 +602476 +602480 +602481 +602482 +602484 +602485 +602486 +602487 +602488 +602489 +602493 +602496 +602497 +602498 +602499 +602500 +602501 +602502 +602505 +602506 +602507 +602508 +602509 +602510 +602511 +602512 +602513 +602514 +602515 +602516 +602517 +602518 +602519 +602520 +602521 +602522 +602523 +602524 +602525 +602526 +602528 +602529 +602530 +602531 +602532 +602533 +602534 +602535 +602536 +602537 +602538 +602539 +602540 +602541 +602542 +602543 +602544 +602545 +602546 +602547 +602548 +602550 +602551 +602552 +602553 +602554 +602555 +602556 +602557 +602558 +602559 +602560 +602561 +602562 +602563 +602564 +602565 +602566 +602568 +602569 +602570 +602571 +602572 +602573 +602574 +602575 +602576 +602577 +602578 +602579 +602581 +602582 +602583 +602584 +602586 +602587 +602588 +602589 +602590 +602591 +602592 +602593 +602594 +602595 +602596 +602597 +602598 +602599 +602600 +602601 +602602 +602603 +602604 +602605 +602606 +602607 +602608 +602609 +602610 +602611 +602612 +602613 +602614 +602615 +602616 +602617 +602618 +602619 +602620 +602621 +602622 +602623 +602624 +602625 +602626 +602627 +602628 +602629 +602630 +602631 +602632 +602633 +602634 +602635 +602636 +602637 +602638 +602639 +602640 +602641 +602642 +602643 +602644 +602645 +602646 +602647 +602648 +602649 +602650 +602651 +602652 +602653 +602654 +602655 +602656 +602657 +602658 +602659 +602660 +602661 +602662 +602663 +602664 +602665 +602666 +602667 +602668 +602669 +602670 +602671 +602672 +602673 +602674 +602675 +602676 +602677 +602678 +602680 +602681 +602682 +602683 +602685 +602686 +602687 +602688 +602689 +602690 +602691 +602692 +602693 +602696 +602697 +602698 +602699 +602700 +602701 +602702 +602703 +602704 +602705 +602706 +602707 +602708 +602709 +602710 +602711 +602712 +602713 +602714 +602715 +602716 +602717 +602718 +602720 +602721 +602722 +602723 +602724 +602725 +602726 +602727 +602728 +602730 +602731 +602732 +602733 +602734 +602735 +602736 +602737 +602738 +602739 +602740 +602741 +602742 +602743 +602744 +602746 +602755 +602757 +602758 +602759 +602760 +602761 +602762 +602763 +602764 +602765 +602767 +602768 +602769 +602770 +602771 +602773 +602775 +602776 +602777 +602778 +602780 +602785 +602786 +602788 +602789 +602791 +602792 +602793 +602795 +602796 +602798 +602799 +602800 +602801 +602803 +602804 +602805 +602807 +602813 +602814 +602815 +602816 +602818 +602819 +602820 +602821 +602822 +602823 +602824 +602825 +602826 +602827 +602830 +602831 +602833 +602834 +602835 +602837 +602838 +602840 +602841 +602842 +602843 +602844 +602845 +602846 +602847 +602848 +602849 +602851 +602852 +602853 +602855 +602856 +602864 +602865 +602866 +602867 +602868 +602869 +602870 +602871 +602874 +602875 +602877 +602878 +602879 +602884 +602885 +602886 +602887 +602888 +602889 +602890 +602891 +602892 +602893 +602894 +602895 +602896 +602897 +602898 +602899 +602900 +602901 +602902 +602903 +602905 +602907 +602908 +602909 +602910 +602911 +602912 +602913 +602914 +602915 +602916 +602917 +602919 +602920 +602921 +602922 +602923 +602924 +602925 +602926 +602927 +602928 +602929 +602930 +602931 +602932 +602933 +602934 +602936 +602937 +602938 +602939 +602940 +602941 +602942 +602943 +602944 +602945 +602946 +602947 +602948 +602949 +602950 +602951 +602952 +602953 +602954 +602955 +602957 +602959 +602960 +602962 +602963 +602964 +602965 +602966 +602967 +602968 +602969 +602970 +602971 +602972 +602973 +602974 +602975 +602976 +602977 +602978 +602979 +602980 +602981 +602982 +602983 +602984 +602985 +602986 +602987 +602988 +602989 +602990 +602991 +602992 +602993 +602994 +602995 +602996 +602997 +602998 +602999 +603000 +603001 +603002 +603003 +603004 +603005 +603006 +603007 +603008 +603009 +603010 +603011 +603012 +603013 +603014 +603015 +603016 +603018 +603019 +603020 +603021 +603023 +603024 +603026 +603027 +603028 +603029 +603030 +603031 +603032 +603033 +603034 +603035 +603037 +603038 +603039 +603040 +603041 +603042 +603043 +603044 +603045 +603046 +603047 +603048 +603049 +603050 +603051 +603052 +603053 +603054 +603055 +603056 +603057 +603058 +603059 +603060 +603061 +603062 +603063 +603064 +603065 +603066 +603067 +603068 +603069 +603070 +603071 +603072 +603073 +603074 +603075 +603076 +603077 +603078 +603079 +603080 +603081 +603082 +603083 +603084 +603085 +603086 +603087 +603088 +603089 +603090 Index: Ringtoets/Common/src/Ringtoets.Common.IO/Ringtoets.Common.IO.csproj =================================================================== diff -u -r1d6be87de63acfac543d4b90aaf0618d3203b0c3 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Common/src/Ringtoets.Common.IO/Ringtoets.Common.IO.csproj (.../Ringtoets.Common.IO.csproj) (revision 1d6be87de63acfac543d4b90aaf0618d3203b0c3) +++ Ringtoets/Common/src/Ringtoets.Common.IO/Ringtoets.Common.IO.csproj (.../Ringtoets.Common.IO.csproj) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -56,6 +56,12 @@ + + + + + + @@ -85,6 +91,7 @@ + Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/DikeProfilesImporterTest.cs =================================================================== diff -u --- Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/DikeProfilesImporterTest.cs (revision 0) +++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/DikeProfilesImporterTest.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,372 @@ +// 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 System.Collections.Generic; +using System.IO; +using System.Linq; +using Core.Common.Base; +using Core.Common.Base.Data; +using Core.Common.Base.Geometry; +using Core.Common.TestUtil; +using NUnit.Framework; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.DikeProfiles; +using Ringtoets.Common.IO.FileImporters; + +namespace Ringtoets.Common.IO.Test.FileImporters +{ + [TestFixture] + public class DikeProfilesImporterTest + { + [Test] + public void Constructor_WithValidParameters_ReturnsNewInstance() + { + // Setup + var importTarget = new ObservableList(); + var referenceLine = new ReferenceLine(); + + // Call + var importer = new DikeProfilesImporter(importTarget, referenceLine, ""); + + // Assert + Assert.IsInstanceOf>>(importer); + } + + [Test] + public void Constructor_ImportTargetNull_ThrowArgumentNullException() + { + // Call + TestDelegate call = () => new DikeProfilesImporter(null, new ReferenceLine(), ""); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("importTarget", exception.ParamName); + } + + [Test] + public void Constructor_ReferenceLineNull_ThrowArgumentNullException() + { + // Call + TestDelegate call = () => new DikeProfilesImporter(new ObservableList(), null, ""); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("referenceLine", exception.ParamName); + } + + [Test] + public void Constructor_FilePathNull_ThrowArgumentNullException() + { + // Call + TestDelegate call = () => new DikeProfilesImporter(new ObservableList(), new ReferenceLine(), null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("filePath", exception.ParamName); + } + + [Test] + public void Import_FromFileWithUnmatchableId_TrueAndLogError() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "IpflWithUnmatchableId", "Voorlanden_12-2_UnmatchableId.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var dikeProfiles = new ObservableList(); + + var dikeProfilesImporter = new DikeProfilesImporter(dikeProfiles, referenceLine, filePath); + var importResult = false; + + // Call + Action call = () => importResult = dikeProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string[] messageArray = messages.ToArray(); + string expectedMessage = "Kan geen geldige gegevens vinden voor dijkprofiellocatie met ID 'unmatchable'."; + Assert.AreEqual(expectedMessage, messageArray[0]); + }); + Assert.IsTrue(importResult); + } + + [Test] + public void Import_FiveDikeProfilesWithoutGeometries_TrueAndLogWarningAndNoDikeProfiles() + { + // Setup + string fileDirectory = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", "NoDikeProfileGeometries")); + string filePath = Path.Combine(fileDirectory, "Voorlanden 12-2.shp"); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + + var dikeProfiles = new ObservableList(); + var dikeProfilesImporter = new DikeProfilesImporter(dikeProfiles, referenceLine, filePath); + + // Call + bool importResult = false; + Action call = () => importResult = dikeProfilesImporter.Import(); + + // Assert + string[] expectedMessages = + { + string.Format("Profielgegevens definiëren geen dijkgeometrie. Bestand '{0}' wordt overgeslagen.", Path.Combine(fileDirectory, "profiel001 - Ringtoets.prfl")), + string.Format("Profielgegevens definiëren geen dijkgeometrie. Bestand '{0}' wordt overgeslagen.", Path.Combine(fileDirectory, "profiel002 - Ringtoets.prfl")), + string.Format("Profielgegevens definiëren geen dijkgeometrie. Bestand '{0}' wordt overgeslagen.", Path.Combine(fileDirectory, "profiel003 - Ringtoets.prfl")), + string.Format("Profielgegevens definiëren geen dijkgeometrie. Bestand '{0}' wordt overgeslagen.", Path.Combine(fileDirectory, "profiel004 - Ringtoets.prfl")), + string.Format("Profielgegevens definiëren geen dijkgeometrie. Bestand '{0}' wordt overgeslagen.", Path.Combine(fileDirectory, "profiel005 - Ringtoets.prfl")) + }; + TestHelper.AssertLogMessagesAreGenerated(call, expectedMessages); + Assert.IsTrue(importResult); + Assert.AreEqual(0, dikeProfiles.Count); + } + + [Test] + public void Import_OneDikeProfileLocationNotCloseEnoughToReferenceLine_TrueAndLogErrorAndFourDikeProfiles() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + var referencePoints = new List + { + new Point2D(131223.2, 548393.4), + new Point2D(133854.3, 545323.1), + new Point2D(135561.0, 541920.3), + new Point2D(136432.1, 538235.2), + new Point2D(146039.4, 533920.2) + }; + var referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(referencePoints); + + var dikeProfiles = new ObservableList(); + var dikeProfilesImporter = new DikeProfilesImporter(dikeProfiles, referenceLine, filePath); + + var importResult = false; + + // Call + Action call = () => importResult = dikeProfilesImporter.Import(); + + // Assert + string expectedMessage = "Een profiellocatie met ID 'profiel005' ligt niet op de referentielijn. Locatie wordt overgeslagen."; + TestHelper.AssertLogMessageIsGenerated(call, expectedMessage); + Assert.IsTrue(importResult); + Assert.AreEqual(4, dikeProfiles.Count); + } + + [Test] + public void Import_AllOkTestData_TrueAndLogMessagesAndFiveDikeProfiles() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + + var progressChangeNotifications = new List(); + + var dikeProfiles = new ObservableList(); + var dikeProfilesImporter = new DikeProfilesImporter(dikeProfiles, referenceLine, filePath) + { + ProgressChanged = (description, step, steps) => { progressChangeNotifications.Add(new ProgressNotification(description, step, steps)); } + }; + + // Call + bool importResult = dikeProfilesImporter.Import(); + + // Assert + Assert.IsTrue(importResult); + List expectedProgressMessages = new List + { + new ProgressNotification("Inlezen van profiellocaties uit een shapebestand.", 1, 1), + new ProgressNotification("Inlezen van profiellocatie.", 1, 5), + new ProgressNotification("Inlezen van profiellocatie.", 2, 5), + new ProgressNotification("Inlezen van profiellocatie.", 3, 5), + new ProgressNotification("Inlezen van profiellocatie.", 4, 5), + new ProgressNotification("Inlezen van profiellocatie.", 5, 5), + new ProgressNotification("Inlezen van profielgegevens uit een prfl bestand.", 1, 1), + new ProgressNotification("Inlezen van profielgegevens.", 1, 5), + new ProgressNotification("Inlezen van profielgegevens.", 2, 5), + new ProgressNotification("Inlezen van profielgegevens.", 3, 5), + new ProgressNotification("Inlezen van profielgegevens.", 4, 5), + new ProgressNotification("Inlezen van profielgegevens.", 5, 5) + }; + ValidateProgressMessages(expectedProgressMessages, progressChangeNotifications); + Assert.AreEqual(5, dikeProfiles.Count); + } + + [Test] + public void Import_AllOkTestData_CorrectDikeProfileProperties() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + + var dikeProfiles = new ObservableList(); + var dikeProfilesImporter = new DikeProfilesImporter(dikeProfiles, referenceLine, filePath); + + // Call + dikeProfilesImporter.Import(); + + // Assert + DikeProfile dikeProfile = dikeProfiles[4]; + Assert.AreEqual(new Point2D(136039.49100000039, 533920.28050000477), dikeProfile.WorldReferencePoint); + Assert.AreEqual("profiel005", dikeProfile.Name); + Assert.AreEqual(15.56165507, dikeProfile.X0); + Assert.AreEqual(new RoundedDouble(2, 330.0), dikeProfile.Orientation); + Assert.IsTrue(dikeProfile.HasBreakWater); + Assert.AreEqual(new RoundedDouble(2, 6.0), dikeProfile.DikeHeight); + } + + [Test] + public void Import_AllDamTypes_TrueAndLogMessagesAndFiveDikeProfiles() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllDamTypes", "Voorlanden 12-2.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + + var progressChangeNotifications = new List(); + + var dikeProfiles = new ObservableList(); + var dikeProfilesImporter = new DikeProfilesImporter(dikeProfiles, referenceLine, filePath) + { + ProgressChanged = (description, step, steps) => progressChangeNotifications.Add(new ProgressNotification(description, step, steps)) + }; + + // Call + bool importResult = dikeProfilesImporter.Import(); + + // Assert + Assert.IsTrue(importResult); + List expectedProgressMessages = new List + { + new ProgressNotification("Inlezen van profiellocaties uit een shapebestand.", 1, 1), + new ProgressNotification("Inlezen van profiellocatie.", 1, 5), + new ProgressNotification("Inlezen van profiellocatie.", 2, 5), + new ProgressNotification("Inlezen van profiellocatie.", 3, 5), + new ProgressNotification("Inlezen van profiellocatie.", 4, 5), + new ProgressNotification("Inlezen van profiellocatie.", 5, 5), + new ProgressNotification("Inlezen van profielgegevens uit een prfl bestand.", 1, 1), + new ProgressNotification("Inlezen van profielgegevens.", 1, 5), + new ProgressNotification("Inlezen van profielgegevens.", 2, 5), + new ProgressNotification("Inlezen van profielgegevens.", 3, 5), + new ProgressNotification("Inlezen van profielgegevens.", 4, 5), + new ProgressNotification("Inlezen van profielgegevens.", 5, 5) + }; + ValidateProgressMessages(expectedProgressMessages, progressChangeNotifications); + Assert.AreEqual(5, dikeProfiles.Count); + } + + [Test] + public void Import_CancelOfImportToValidTargetWithValidFile_CancelImportAndLog() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + + var dikeProfiles = new ObservableList(); + var dikeProfilesImporter = new DikeProfilesImporter(dikeProfiles, referenceLine, filePath); + + dikeProfilesImporter.Cancel(); + bool importResult = true; + + // Call + Action call = () => importResult = dikeProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessageIsGenerated(call, "Dijkprofielen importeren is afgebroken. Geen gegevens ingelezen.", 1); + Assert.IsFalse(importResult); + } + + [Test] + public void Import_ReuseOfCancelledImportToValidTargetWithValidFile_TrueAndLogMessagesAndFiveDikeProfiles() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + + var dikeProfiles = new ObservableList(); + var dikeProfilesImporter = new DikeProfilesImporter(dikeProfiles, referenceLine, filePath); + + dikeProfilesImporter.Cancel(); + bool importResult = dikeProfilesImporter.Import(); + Assert.IsFalse(importResult); + + // Call + importResult = dikeProfilesImporter.Import(); + + // Assert + Assert.IsTrue(importResult); + Assert.AreEqual(5, dikeProfiles.Count); + } + + private ReferenceLine CreateMatchingReferenceLine() + { + var referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(new[] + { + new Point2D(131223.2, 548393.4), + new Point2D(133854.3, 545323.1), + new Point2D(135561.0, 541920.3), + new Point2D(136432.1, 538235.2), + new Point2D(136039.4, 533920.2) + }); + return referenceLine; + } + + private static void ValidateProgressMessages(List expectedProgressMessages, List progressChangeNotifications) + { + Assert.AreEqual(expectedProgressMessages.Count, progressChangeNotifications.Count); + for (var i = 0; i < expectedProgressMessages.Count; i++) + { + var notification = expectedProgressMessages[i]; + var actualNotification = progressChangeNotifications[i]; + Assert.AreEqual(notification.Text, actualNotification.Text); + Assert.AreEqual(notification.CurrentStep, actualNotification.CurrentStep); + Assert.AreEqual(notification.TotalSteps, actualNotification.TotalSteps); + } + } + + private class ProgressNotification + { + public ProgressNotification(string description, int currentStep, int totalSteps) + { + Text = description; + CurrentStep = currentStep; + TotalSteps = totalSteps; + } + + public string Text { get; private set; } + public int CurrentStep { get; private set; } + public int TotalSteps { get; private set; } + } + } +} \ No newline at end of file Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/FailureMechanismSectionsImporterTest.cs =================================================================== diff -u --- Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/FailureMechanismSectionsImporterTest.cs (revision 0) +++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/FailureMechanismSectionsImporterTest.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,601 @@ +// 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 System.Collections.Generic; +using System.IO; +using System.Linq; +using Core.Common.Base.Geometry; +using Core.Common.Base.IO; +using Core.Common.TestUtil; +using NUnit.Framework; +using Rhino.Mocks; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.Calculation; +using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.IO.FileImporters; +using Ringtoets.Common.IO.ReferenceLines; + +namespace Ringtoets.Common.IO.Test.FileImporters +{ + [TestFixture] + public class FailureMechanismSectionsImporterTest + { + [Test] + public void Constructor_FailureMechanismNull_ThrowArgumentNullException() + { + // Setup + var referenceLine = new ReferenceLine(); + + // Call + TestDelegate call = () => new FailureMechanismSectionsImporter(null, referenceLine, ""); + + // Assert + string paramName = Assert.Throws(call).ParamName; + Assert.AreEqual("importTarget", paramName); + } + + [Test] + public void Constructor_ReferenceLineNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var failureMechanism = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate call = () => new FailureMechanismSectionsImporter(failureMechanism, null, ""); + + // Assert + string paramName = Assert.Throws(call).ParamName; + Assert.AreEqual("referenceLine", paramName); + mocks.VerifyAll(); + } + + [Test] + public void Constructor_ExpectedValues() + { + // Setup + var mocks = new MockRepository(); + var failureMechanism = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLine = new ReferenceLine(); + + // Call + var importer = new FailureMechanismSectionsImporter(failureMechanism, referenceLine, ""); + + // Assert + Assert.IsInstanceOf>(importer); + mocks.VerifyAll(); + } + + [Test] + [TestCase("traject_1-1.shp", "traject_1-1_vakken.shp", 62)] + [TestCase("traject_19-1.shp", "traject_19-1_vakken.shp", 17)] + public void Import_ValidFileCorrespondingToReferenceLineAndNoSectionImportedYet_ImportSections(string referenceLineFileName, string sectionsFileName, int sectionCount) + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", referenceLineFileName)); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("FailureMechanismSections", sectionsFileName)); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var failureMechanism = new Simple(); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath); + + // Call + var importSuccessful = importer.Import(); + + // Assert + Assert.IsTrue(importSuccessful); + + FailureMechanismSection[] sections = failureMechanism.Sections.ToArray(); + Assert.AreEqual(sectionCount, sections.Length); + AssertSectionsAreValidForReferenceLine(sections, assessmentSection.ReferenceLine); + mocks.VerifyAll(); + } + + [Test] + public void Import_ValidFileCorrespondingToReferenceLineAndHasSectionImported_ReplaceSections() + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", "traject_1-1.shp")); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("FailureMechanismSections", "traject_1-1_vakken.shp")); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var failureMechanism = new Simple(); + failureMechanism.AddSection(new FailureMechanismSection("A", assessmentSection.ReferenceLine.Points)); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath); + + // Call + var importSuccessful = importer.Import(); + + // Assert + Assert.IsTrue(importSuccessful); + + FailureMechanismSection[] sections = failureMechanism.Sections.ToArray(); + Assert.AreEqual(62, sections.Length); + AssertSectionsAreValidForReferenceLine(sections, assessmentSection.ReferenceLine); + mocks.VerifyAll(); + } + + [Test] + public void Import_ValidArtificialFileImperfectlyCorrespondingToReferenceLineAndNoSectionImportedYet_ImportSections() + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", "Artificial_referencelijn_testA.shp")); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("FailureMechanismSections", "Artificial_referencelijn_testA_ValidVakken.shp")); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var failureMechanism = new Simple(); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath); + + // Call + var importSuccessful = importer.Import(); + + // Assert + Assert.IsTrue(importSuccessful); + + FailureMechanismSection[] sections = failureMechanism.Sections.ToArray(); + Assert.AreEqual(7, sections.Length); + AssertSectionsAreValidForReferenceLine(sections, assessmentSection.ReferenceLine); + mocks.VerifyAll(); + } + + [Test] + public void Import_ValidImport_GenerateExpectedProgressMessages() + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", "Artificial_referencelijn_testA.shp")); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("FailureMechanismSections", "Artificial_referencelijn_testA_ValidVakken.shp")); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var progressChangeNotifications = new List(); + + var failureMechanism = new Simple(); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath) + { + ProgressChanged = (description, step, steps) => { progressChangeNotifications.Add(new ProgressNotification(description, step, steps)); } + }; + + // Call + var importSuccessful = importer.Import(); + + // Assert + Assert.IsTrue(importSuccessful); + var expectedProgressMessages = new[] + { + new ProgressNotification("Inlezen vakindeling.", 1, 3), + new ProgressNotification("Valideren ingelezen vakindeling.", 2, 3), + new ProgressNotification("Geïmporteerde gegevens toevoegen aan het toetsspoor.", 3, 3) + }; + Assert.AreEqual(expectedProgressMessages.Length, progressChangeNotifications.Count); + for (int i = 0; i < expectedProgressMessages.Length; i++) + { + var notification = expectedProgressMessages[i]; + var actualNotification = progressChangeNotifications[i]; + Assert.AreEqual(notification.Text, actualNotification.Text); + Assert.AreEqual(notification.CurrentStep, actualNotification.CurrentStep); + Assert.AreEqual(notification.TotalSteps, actualNotification.TotalSteps); + } + mocks.VerifyAll(); + } + + [Test] + public void Import_FilePathIsDirectory_CancelImportWithErrorMessage() + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", "traject_1-1.shp")); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, Path.DirectorySeparatorChar.ToString()); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var failureMechanism = new Simple(); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath); + + // Call + bool importSuccessful = true; + Action call = () => importSuccessful = importer.Import(); + + // Assert + var expectedMessage = string.Format(@"Fout bij het lezen van bestand '{0}': Bestandspad mag niet verwijzen naar een lege bestandsnaam. ", sectionsFilePath) + Environment.NewLine + + "Er is geen vakindeling geïmporteerd."; + TestHelper.AssertLogMessageIsGenerated(call, expectedMessage, 1); + Assert.IsFalse(importSuccessful); + CollectionAssert.IsEmpty(failureMechanism.Sections); + mocks.VerifyAll(); + } + + [Test] + public void Import_FileDoesNotExist_CancelImportWithErrorMessage() + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", "traject_1-1.shp")); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, "I_dont_exist.shp"); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var failureMechanism = new Simple(); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath); + + // Call + bool importSuccessful = true; + Action call = () => importSuccessful = importer.Import(); + + // Assert + var expectedMessage = string.Format(@"Fout bij het lezen van bestand '{0}': Het bestand bestaat niet. ", sectionsFilePath) + Environment.NewLine + + "Er is geen vakindeling geïmporteerd."; + TestHelper.AssertLogMessageIsGenerated(call, expectedMessage, 1); + Assert.IsFalse(importSuccessful); + CollectionAssert.IsEmpty(failureMechanism.Sections); + mocks.VerifyAll(); + } + + [Test] + public void Import_EmptyArtificialFile_CancelImportWithErrorMessage() + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", "Artificial_referencelijn_testA.shp")); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("FailureMechanismSections", "Artificial_referencelijn_testA_EmptyVakken.shp")); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var failureMechanism = new Simple(); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath); + + // Call + bool importSuccessful = true; + Action call = () => importSuccessful = importer.Import(); + + // Assert + var expectedMessage = "Het bestand heeft geen vakindeling. " + Environment.NewLine + + "Er is geen vakindeling geïmporteerd."; + TestHelper.AssertLogMessageIsGenerated(call, expectedMessage, 1); + Assert.IsFalse(importSuccessful); + CollectionAssert.IsEmpty(failureMechanism.Sections); + mocks.VerifyAll(); + } + + [Test] + [TestCase("StartTooFarFromReferenceline")] + [TestCase("EndTooFarFromReferenceline")] + public void Import_InvalidArtificialFileBecauseOfStartEndPointsTooFarFromReferenceLine_CancelImportWithErrorMessage(string shapeCondition) + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", "Artificial_referencelijn_testA.shp")); + var shapeFileName = string.Format("Artificial_referencelijn_testA_InvalidVakken_Section{0}.shp", shapeCondition); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("FailureMechanismSections", shapeFileName)); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var failureMechanism = new Simple(); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath); + + // Call + bool importSuccessful = true; + Action call = () => importSuccessful = importer.Import(); + + // Assert + var expectedMessage = "Vakindeling komt niet overeen met de huidige referentielijn. " + Environment.NewLine + + "Er is geen vakindeling geïmporteerd."; + TestHelper.AssertLogMessageIsGenerated(call, expectedMessage, 1); + Assert.IsFalse(importSuccessful); + CollectionAssert.IsEmpty(failureMechanism.Sections); + mocks.VerifyAll(); + } + + [Test] + [TestCase("StartTooFarFromReferencelineStart")] + [TestCase("EndTooFarFromReferencelineEnd")] + public void Import_InvalidArtificialFileBecauseOfStartEndPointsTooFarFromStartEndOfReferenceLine_CancelImportWithErrorMessage(string shapeCondition) + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", "Artificial_referencelijn_testA.shp")); + var shapeFileName = string.Format("Artificial_referencelijn_testA_InvalidVakken_{0}.shp", shapeCondition); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("FailureMechanismSections", shapeFileName)); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var failureMechanism = new Simple(); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath); + + // Call + bool importSuccessful = true; + Action call = () => importSuccessful = importer.Import(); + + // Assert + var expectedMessage = "Vakindeling komt niet overeen met de huidige referentielijn. " + Environment.NewLine + + "Er is geen vakindeling geïmporteerd."; + TestHelper.AssertLogMessageIsGenerated(call, expectedMessage, 1); + Assert.IsFalse(importSuccessful); + CollectionAssert.IsEmpty(failureMechanism.Sections); + mocks.VerifyAll(); + } + + [Test] + public void Import_InvalidArtificialFileBecauseSectionsDoNotFullyCoverReferenceLine_CancelImportWithErrorMessage() + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", "Artificial_referencelijn_testA.shp")); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("FailureMechanismSections", "Artificial_referencelijn_testA_InvalidVakken_NotCoveringWholeReferenceLine.shp")); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var failureMechanism = new Simple(); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath); + + // Call + bool importSuccessful = true; + Action call = () => importSuccessful = importer.Import(); + + // Assert + var expectedMessage = "Vakindeling komt niet overeen met de huidige referentielijn. " + Environment.NewLine + + "Er is geen vakindeling geïmporteerd."; + TestHelper.AssertLogMessageIsGenerated(call, expectedMessage, 1); + Assert.IsFalse(importSuccessful); + CollectionAssert.IsEmpty(failureMechanism.Sections); + mocks.VerifyAll(); + } + + [Test] + public void Import_InvalidArtificialFileBecauseSomePointsNotOnReferenceLine_CancelImportWithErrorMessage() + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", "Artificial_referencelijn_testA.shp")); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("FailureMechanismSections", "Artificial_referencelijn_testA_InvalidVakken_PointsTooFarFromReferenceLine.shp")); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var failureMechanism = new Simple(); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath); + + // Call + bool importSuccessful = true; + Action call = () => importSuccessful = importer.Import(); + + // Assert + var expectedMessage = "Vakindeling komt niet overeen met de huidige referentielijn. " + Environment.NewLine + + "Er is geen vakindeling geïmporteerd."; + TestHelper.AssertLogMessageIsGenerated(call, expectedMessage, 1); + Assert.IsFalse(importSuccessful); + CollectionAssert.IsEmpty(failureMechanism.Sections); + mocks.VerifyAll(); + } + + [Test] + public void Import_ValidFileImportBeingCancelled_CancelImportWithInfoMessage() + { + // Setup + var referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("ReferenceLine", "traject_1-1.shp")); + var sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("FailureMechanismSections", "traject_1-1_vakken.shp")); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var referenceLineImporter = new ReferenceLineImporter(assessmentSection, referenceLineFilePath); + referenceLineImporter.Import(); + + var failureMechanism = new Simple(); + + var importer = new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, sectionsFilePath); + + importer.Cancel(); + Assert.IsFalse(importer.Import()); + + // Call + var importSuccessful = importer.Import(); + + // Assert + Assert.IsTrue(importSuccessful); + + FailureMechanismSection[] sections = failureMechanism.Sections.ToArray(); + Assert.AreEqual(62, sections.Length); + AssertSectionsAreValidForReferenceLine(sections, assessmentSection.ReferenceLine); + mocks.VerifyAll(); + } + + private void AssertSectionsAreValidForReferenceLine(FailureMechanismSection[] sections, ReferenceLine referenceLine) + { + Point2D[] referenceLineGeometry = referenceLine.Points.ToArray(); + + // 1. Start & End coherence: + Assert.AreEqual(referenceLineGeometry[0], sections[0].GetStart(), + "Start of the sections should correspond to the Start of the reference line."); + Assert.AreEqual(referenceLineGeometry[referenceLineGeometry.Length - 1], sections[sections.Length - 1].GetLast(), + "End of the sections should correspond to the End of the reference line."); + + // 2. Total length coherence: + var totalLengthOfSections = sections.Sum(s => GetLengthOfLine(s.Points)); + var totalLengthOfReferenceLine = GetLengthOfLine(referenceLineGeometry); + Assert.AreEqual(totalLengthOfReferenceLine, totalLengthOfSections, 1e-6, + "The length of all sections should sum up to the length of the reference line."); + + // 3. Section Start and End coherence + IEnumerable allStartAndEndPoints = sections.Select(s => s.GetStart()).Concat(sections.Select(s => s.GetLast())); + foreach (Point2D point in allStartAndEndPoints) + { + Assert.Less(GetDistanceToReferenceLine(point, referenceLine), 1e-6, + "All start- and end points should be on the reference line."); + } + + // 4. Section Start and End points coherence + FailureMechanismSection sectionTowardsEnd = null; + foreach (FailureMechanismSection section in sections) + { + FailureMechanismSection sectionTowardsStart = sectionTowardsEnd; + sectionTowardsEnd = section; + + if (sectionTowardsStart != null) + { + Assert.AreEqual(sectionTowardsStart.GetLast(), sectionTowardsEnd.GetStart(), + "All sections should be connected and in order of connectedness."); + } + } + } + + private double GetDistanceToReferenceLine(Point2D point, ReferenceLine referenceLine) + { + return GetLineSegments(referenceLine.Points) + .Select(segment => segment.GetEuclideanDistanceToPoint(point)) + .Min(); + } + + private double GetLengthOfLine(IEnumerable linePoints) + { + return GetLineSegments(linePoints).Sum(segment => segment.Length); + } + + private IEnumerable GetLineSegments(IEnumerable linePoints) + { + Point2D endPoint = null; + foreach (Point2D linePoint in linePoints) + { + Point2D startPoint = endPoint; + endPoint = linePoint; + + if (startPoint != null) + { + yield return new Segment2D(startPoint, endPoint); + } + } + } + + private class Simple : FailureMechanismBase + { + public Simple() : base("Stubbed name", "Stubbed code") {} + + public override IEnumerable Calculations + { + get + { + throw new NotImplementedException(); + } + } + } + + private class ProgressNotification + { + public ProgressNotification(string description, int currentStep, int totalSteps) + { + Text = description; + CurrentStep = currentStep; + TotalSteps = totalSteps; + } + + public string Text { get; private set; } + public int CurrentStep { get; private set; } + public int TotalSteps { get; private set; } + } + } +} \ No newline at end of file Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/ForeshoreProfilesImporterTest.cs =================================================================== diff -u --- Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/ForeshoreProfilesImporterTest.cs (revision 0) +++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/ForeshoreProfilesImporterTest.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,413 @@ +// 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 System.Collections.Generic; +using System.IO; +using System.Linq; +using Core.Common.Base; +using Core.Common.Base.Data; +using Core.Common.Base.Geometry; +using Core.Common.TestUtil; +using NUnit.Framework; +using Rhino.Mocks; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.DikeProfiles; +using Ringtoets.Common.Forms.PresentationObjects; +using Ringtoets.Common.IO.FileImporters; + +namespace Ringtoets.Common.IO.Test.FileImporters +{ + [TestFixture] + public class ForeshoreProfilesImporterTest + { + private MockRepository mockRepository; + + [SetUp] + public void SetUp() + { + mockRepository = new MockRepository(); + } + + [Test] + public void ParameterdConstructor_ExpectedValues() + { + // Setup + var importTarget = new ObservableList(); + var referenceLine = new ReferenceLine(); + + // Call + var importer = new ForeshoreProfilesImporter(importTarget, referenceLine, ""); + + // Assert + Assert.IsInstanceOf>>(importer); + } + + [Test] + public void ParameterdConstructor_ImportTargetNull_ThrowArgumentNullException() + { + // Call + TestDelegate call = () => new ForeshoreProfilesImporter(null, new ReferenceLine(), ""); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("importTarget", exception.ParamName); + } + + [Test] + public void ParameterdConstructor_ReferenceLineNull_ThrowArgumentNullException() + { + // Call + TestDelegate call = () => new ForeshoreProfilesImporter(new ObservableList(), null, ""); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("referenceLine", exception.ParamName); + } + + [Test] + public void ParameterdConstructor_FilePathNull_ThrowArgumentNullException() + { + // Call + TestDelegate call = () => new ForeshoreProfilesImporter(new ObservableList(), new ReferenceLine(), null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("filePath", exception.ParamName); + } + + [Test] + public void Import_FromFileWithUnmatchableId_TrueAndLogError() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "IpflWithUnmatchableId", "Voorlanden_12-2_UnmatchableId.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + + var foreshoreProfiles = new ObservableList(); + var assessmentSection = mockRepository.Stub(); + assessmentSection.ReferenceLine = referenceLine; + mockRepository.ReplayAll(); + + var foreshoreProfilesImporter = new ForeshoreProfilesImporter(foreshoreProfiles, referenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = foreshoreProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string[] messageArray = messages.ToArray(); + string expectedMessage = "Kan geen geldige gegevens vinden voor voorlandprofiellocatie met ID 'unmatchable'."; + Assert.AreEqual(expectedMessage, messageArray[0]); + }); + Assert.IsTrue(importResult); + mockRepository.VerifyAll(); + } + + [Test] + public void Import_FiveForeshoreProfilesWithoutDamsAndGeometries_TrueAndLogWarningAndTwoForeshoreProfiles() + { + // Setup + string fileDirectory = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", "NoDamsAndNoForeshoreGeometries")); + string filePath = Path.Combine(fileDirectory, "Voorlanden 12-2.shp"); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var foreshoreProfiles = new ObservableList(); + var foreshoreProfilesImporter = new ForeshoreProfilesImporter(foreshoreProfiles, referenceLine, filePath); + + // Call + bool importResult = false; + Action call = () => importResult = foreshoreProfilesImporter.Import(); + + // Assert + string[] expectedMessages = + { + string.Format("Profielgegevens definiëren geen dam en geen voorlandgeometrie. Bestand '{0}' wordt overgeslagen.", Path.Combine(fileDirectory, "profiel001 - Ringtoets.prfl")), + string.Format("Profielgegevens definiëren geen dam en geen voorlandgeometrie. Bestand '{0}' wordt overgeslagen.", Path.Combine(fileDirectory, "profiel003 - Ringtoets.prfl")), + string.Format("Profielgegevens definiëren geen dam en geen voorlandgeometrie. Bestand '{0}' wordt overgeslagen.", Path.Combine(fileDirectory, "profiel004 - Ringtoets.prfl")), + }; + TestHelper.AssertLogMessagesAreGenerated(call, expectedMessages); + Assert.IsTrue(importResult); + Assert.AreEqual(2, foreshoreProfiles.Count); + } + + [Test] + public void Import_OneDikeProfileLocationNotCloseEnoughToReferenceLine_TrueAndLogErrorAndFourForeshoreProfiles() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + var referencePoints = new List + { + new Point2D(131223.2, 548393.4), + new Point2D(133854.3, 545323.1), + new Point2D(135561.0, 541920.3), + new Point2D(136432.1, 538235.2), + new Point2D(146039.4, 533920.2) + }; + var referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(referencePoints); + + var assessmentSection = mockRepository.Stub(); + assessmentSection.ReferenceLine = referenceLine; + mockRepository.ReplayAll(); + + var foreshoreProfiles = new ObservableList(); + var foreshoreProfilesImporter = new ForeshoreProfilesImporter(foreshoreProfiles, referenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = foreshoreProfilesImporter.Import(); + + // Assert + string expectedMessage = "Een profiellocatie met ID 'profiel005' ligt niet op de referentielijn. Locatie wordt overgeslagen."; + TestHelper.AssertLogMessageIsGenerated(call, expectedMessage); + Assert.IsTrue(importResult); + Assert.AreEqual(4, foreshoreProfiles.Count); + } + + [Test] + public void Import_AllOkTestData_TrueAndLogMessagesAndFiveForeshoreProfiles() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var assessmentSection = mockRepository.Stub(); + assessmentSection.ReferenceLine = referenceLine; + mockRepository.ReplayAll(); + + var progressChangeNotifications = new List(); + var foreshoreProfiles = new ObservableList(); + var foreshoreProfilesImporter = new ForeshoreProfilesImporter(foreshoreProfiles, referenceLine, filePath) + { + ProgressChanged = (description, step, steps) => { progressChangeNotifications.Add(new ProgressNotification(description, step, steps)); } + }; + + // Call + bool importResult = foreshoreProfilesImporter.Import(); + + // Assert + Assert.IsTrue(importResult); + List expectedProgressMessages = new List + { + new ProgressNotification("Inlezen van profiellocaties uit een shapebestand.", 1, 1), + new ProgressNotification("Inlezen van profiellocatie.", 1, 5), + new ProgressNotification("Inlezen van profiellocatie.", 2, 5), + new ProgressNotification("Inlezen van profiellocatie.", 3, 5), + new ProgressNotification("Inlezen van profiellocatie.", 4, 5), + new ProgressNotification("Inlezen van profiellocatie.", 5, 5), + new ProgressNotification("Inlezen van profielgegevens uit een prfl bestand.", 1, 1), + new ProgressNotification("Inlezen van profielgegevens.", 1, 5), + new ProgressNotification("Inlezen van profielgegevens.", 2, 5), + new ProgressNotification("Inlezen van profielgegevens.", 3, 5), + new ProgressNotification("Inlezen van profielgegevens.", 4, 5), + new ProgressNotification("Inlezen van profielgegevens.", 5, 5) + }; + ValidateProgressMessages(expectedProgressMessages, progressChangeNotifications); + Assert.AreEqual(5, foreshoreProfiles.Count); + mockRepository.VerifyAll(); // 'observer' should not be notified + } + + [Test] + public void Import_AllOkTestData_CorrectForeshoreProfileProperties() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + var observer = mockRepository.StrictMock(); + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var assessmentSection = mockRepository.Stub(); + assessmentSection.ReferenceLine = referenceLine; + mockRepository.ReplayAll(); + + var foreshoreProfiles = new ObservableList(); + var foreshoreProfilesImporter = new ForeshoreProfilesImporter(foreshoreProfiles, referenceLine, filePath); + + var targetContext = new ForeshoreProfilesContext(foreshoreProfiles, assessmentSection); + targetContext.Attach(observer); + + // Call + foreshoreProfilesImporter.Import(); + + // Assert + ForeshoreProfile foreshoreProfile = foreshoreProfiles[4]; + Assert.AreEqual(new Point2D(136039.49100000039, 533920.28050000477), foreshoreProfile.WorldReferencePoint); + Assert.AreEqual("profiel005", foreshoreProfile.Name); + Assert.AreEqual(15.56165507, foreshoreProfile.X0); + Assert.AreEqual(new RoundedDouble(2, 330.0), foreshoreProfile.Orientation); + Assert.IsTrue(foreshoreProfile.HasBreakWater); + mockRepository.VerifyAll(); // 'observer' should not be notified + } + + [Test] + public void Import_AllDamTypes_TrueAndLogMessagesAndFiveForeshoreProfiles() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllDamTypes", "Voorlanden 12-2.shp")); + + var observer = mockRepository.StrictMock(); + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var assessmentSection = mockRepository.Stub(); + assessmentSection.ReferenceLine = referenceLine; + mockRepository.ReplayAll(); + + var progressChangeNotifications = new List(); + var foreshoreProfiles = new ObservableList(); + var foreshoreProfilesImporter = new ForeshoreProfilesImporter(foreshoreProfiles, referenceLine, filePath) + { + ProgressChanged = (description, step, steps) => { progressChangeNotifications.Add(new ProgressNotification(description, step, steps)); } + }; + + var targetContext = new ForeshoreProfilesContext(foreshoreProfiles, assessmentSection); + targetContext.Attach(observer); + + // Call + bool importResult = foreshoreProfilesImporter.Import(); + + // Assert + Assert.IsTrue(importResult); + List expectedProgressMessages = new List + { + new ProgressNotification("Inlezen van profiellocaties uit een shapebestand.", 1, 1), + new ProgressNotification("Inlezen van profiellocatie.", 1, 5), + new ProgressNotification("Inlezen van profiellocatie.", 2, 5), + new ProgressNotification("Inlezen van profiellocatie.", 3, 5), + new ProgressNotification("Inlezen van profiellocatie.", 4, 5), + new ProgressNotification("Inlezen van profiellocatie.", 5, 5), + new ProgressNotification("Inlezen van profielgegevens uit een prfl bestand.", 1, 1), + new ProgressNotification("Inlezen van profielgegevens.", 1, 5), + new ProgressNotification("Inlezen van profielgegevens.", 2, 5), + new ProgressNotification("Inlezen van profielgegevens.", 3, 5), + new ProgressNotification("Inlezen van profielgegevens.", 4, 5), + new ProgressNotification("Inlezen van profielgegevens.", 5, 5) + }; + ValidateProgressMessages(expectedProgressMessages, progressChangeNotifications); + Assert.AreEqual(5, foreshoreProfiles.Count); + mockRepository.VerifyAll(); // 'observer' should not be notified + } + + [Test] + public void Import_CancelOfImportToValidTargetWithValidFile_CancelImportAndLog() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var assessmentSection = mockRepository.Stub(); + assessmentSection.ReferenceLine = referenceLine; + mockRepository.ReplayAll(); + + var foreshoreProfiles = new ObservableList(); + var foreshoreProfilesImporter = new ForeshoreProfilesImporter(foreshoreProfiles, referenceLine, filePath); + + // Precondition + foreshoreProfilesImporter.Cancel(); + + // Call + var importResult = true; + Action call = () => importResult = foreshoreProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessageIsGenerated(call, "Voorlandprofielen importeren is afgebroken. Geen gegevens ingelezen.", 1); + Assert.IsFalse(importResult); + mockRepository.VerifyAll(); // 'observer' should not be notified + } + + [Test] + public void Import_ReuseOfCancelledImportToValidTargetWithValidFile_TrueAndLogMessagesAndFiveForeshoreProfiles() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var assessmentSection = mockRepository.Stub(); + assessmentSection.ReferenceLine = referenceLine; + mockRepository.ReplayAll(); + + var foreshoreProfiles = new ObservableList(); + var foreshoreProfilesImporter = new ForeshoreProfilesImporter(foreshoreProfiles, referenceLine, filePath); + + foreshoreProfilesImporter.Cancel(); + bool importResult = foreshoreProfilesImporter.Import(); + Assert.IsFalse(importResult); + + // Call + importResult = foreshoreProfilesImporter.Import(); + + // Assert + Assert.IsTrue(importResult); + Assert.AreEqual(5, foreshoreProfiles.Count); + mockRepository.VerifyAll(); // 'observer' should not be notified + } + + private ReferenceLine CreateMatchingReferenceLine() + { + var referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(new[] + { + new Point2D(131223.2, 548393.4), + new Point2D(133854.3, 545323.1), + new Point2D(135561.0, 541920.3), + new Point2D(136432.1, 538235.2), + new Point2D(136039.4, 533920.2) + }); + return referenceLine; + } + + private static void ValidateProgressMessages(List expectedProgressMessages, List progressChangeNotifications) + { + Assert.AreEqual(expectedProgressMessages.Count, progressChangeNotifications.Count); + for (var i = 0; i < expectedProgressMessages.Count; i++) + { + var notification = expectedProgressMessages[i]; + var actualNotification = progressChangeNotifications[i]; + Assert.AreEqual(notification.Text, actualNotification.Text); + Assert.AreEqual(notification.CurrentStep, actualNotification.CurrentStep); + Assert.AreEqual(notification.TotalSteps, actualNotification.TotalSteps); + } + } + + private class ProgressNotification + { + public ProgressNotification(string description, int currentStep, int totalSteps) + { + Text = description; + CurrentStep = currentStep; + TotalSteps = totalSteps; + } + + public string Text { get; private set; } + public int CurrentStep { get; private set; } + public int TotalSteps { get; private set; } + } + } +} \ No newline at end of file Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/HydraulicBoundaryDatabaseImporterTest.cs =================================================================== diff -u --- Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/HydraulicBoundaryDatabaseImporterTest.cs (revision 0) +++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/HydraulicBoundaryDatabaseImporterTest.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,322 @@ +// 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 System.Collections.Generic; +using System.IO; +using System.Linq; +using Core.Common.IO.Exceptions; +using Core.Common.TestUtil; +using Core.Common.Utils.Builders; +using NUnit.Framework; +using Rhino.Mocks; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.IO.FileImporters; +using Ringtoets.HydraRing.Data; +using UtilsResources = Core.Common.Utils.Properties.Resources; + +namespace Ringtoets.Common.IO.Test.FileImporters +{ + [TestFixture] + public class HydraulicBoundaryDatabaseImporterTest + { + private readonly string testDataPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.HydraRing.IO, "HydraulicBoundaryLocationReader"); + private HydraulicBoundaryDatabaseImporter importer; + + [SetUp] + public void SetUp() + { + importer = new HydraulicBoundaryDatabaseImporter(); + } + + [TearDown] + public void TearDown() + { + importer.Dispose(); + } + + [Test] + public void DefaultConstructor_ExpectedValues() + { + // Call is done in SetUp + + // Assert + Assert.IsInstanceOf(importer); + Assert.IsInstanceOf(importer); + } + + [Test] + public void Import_ExistingFile_DoesNotThrowException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + assessmentSection.Expect(section => section.NotifyObservers()); + mocks.ReplayAll(); + + string validFilePath = Path.Combine(testDataPath, "complete.sqlite"); + + // Call + TestDelegate test = () => importer.Import(assessmentSection, validFilePath); + + // Assert + Assert.DoesNotThrow(test); + + mocks.VerifyAll(); + } + + [Test] + public void Import_NonExistingFile_ThrowsCriticalFileReadException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + assessmentSection.Expect(section => section.NotifyObservers()).Repeat.Never(); + mocks.ReplayAll(); + + string filePath = Path.Combine(testDataPath, "nonexisting.sqlite"); + var expectedExceptionMessage = string.Format("Fout bij het lezen van bestand '{0}': Het bestand bestaat niet.", filePath); + + // Call + TestDelegate test = () => importer.Import(assessmentSection, filePath); + + // Assert + CriticalFileReadException exception = Assert.Throws(test); + Assert.AreEqual(expectedExceptionMessage, exception.Message); + + mocks.VerifyAll(); + } + + [Test] + public void Import_InvalidFile_ThrowsCriticalFileReadException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + assessmentSection.Expect(section => section.NotifyObservers()).Repeat.Never(); + mocks.ReplayAll(); + + var invalidPath = Path.Combine(testDataPath, "complete.sqlite"); + invalidPath = invalidPath.Replace('c', Path.GetInvalidPathChars()[0]); + + // Call + TestDelegate test = () => importer.Import(assessmentSection, invalidPath); + + // Assert + var expectedMessage = new FileReaderErrorMessageBuilder(invalidPath) + .Build(string.Format(UtilsResources.Error_Path_cannot_contain_Characters_0_, + string.Join(", ", Path.GetInvalidFileNameChars()))); + CriticalFileReadException exception = Assert.Throws(test); + Assert.AreEqual(expectedMessage, exception.Message); + Assert.IsInstanceOf(exception.InnerException); + + mocks.VerifyAll(); + } + + [Test] + public void Import_FileIsDirectory_ThrowsCriticalFileReadException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + assessmentSection.Expect(section => section.NotifyObservers()).Repeat.Never(); + mocks.ReplayAll(); + + string filePath = Path.Combine(testDataPath, "/"); + var expectedExceptionMessage = string.Format("Fout bij het lezen van bestand '{0}': Bestandspad mag niet verwijzen naar een lege bestandsnaam.", filePath); + + // Call + TestDelegate test = () => importer.Import(assessmentSection, filePath); + + // Assert + CriticalFileReadException exception = Assert.Throws(test); + Assert.AreEqual(expectedExceptionMessage, exception.Message); + Assert.IsInstanceOf(exception.InnerException); + + mocks.VerifyAll(); + } + + [Test] + public void Import_ExistingFileWithoutHlcd_ThrowCriticalFileReadException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + assessmentSection.Expect(section => section.NotifyObservers()).Repeat.Never(); + mocks.ReplayAll(); + + string validFilePath = Path.Combine(testDataPath, "withoutHLCD", "empty.sqlite"); + + // Call + TestDelegate test = () => importer.Import(assessmentSection, validFilePath); + + // Assert + string expectedMessage = new FileReaderErrorMessageBuilder(validFilePath).Build("Het bijbehorende HLCD bestand is niet gevonden in dezelfde map als het HRD bestand."); + CriticalFileReadException exception = Assert.Throws(test); + Assert.AreEqual(expectedMessage, exception.Message); + + mocks.VerifyAll(); + } + + [Test] + public void Import_ImportingToValidTargetWithValidFile_ImportHydraulicBoundaryLocationsToCollectionAndAssessmentSectionNotified() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + assessmentSection.Expect(section => section.NotifyObservers()); + mocks.ReplayAll(); + + string validFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + "completeWithLocationsToBeFilteredOut.sqlite"); + + // Precondition + Assert.IsTrue(File.Exists(validFilePath), string.Format("Precodition failed. File does not exist: {0}", validFilePath)); + + // Call + var importResult = false; + Action call = () => importResult = importer.Import(assessmentSection, validFilePath); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string[] messageArray = messages.ToArray(); + StringAssert.EndsWith("De hydraulische randvoorwaardenlocaties zijn ingelezen.", messageArray[0]); + }); + Assert.IsTrue(importResult); + ICollection importedLocations = assessmentSection.HydraulicBoundaryDatabase.Locations; + Assert.AreEqual(9, importedLocations.Count); + CollectionAssert.AllItemsAreNotNull(importedLocations); + CollectionAssert.AllItemsAreUnique(importedLocations); + mocks.VerifyAll(); + } + + [Test] + public void Import_ImportingToSameDatabaseOnDifferentPath_FilePathUpdatedAndAssessmentSectionNotified() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + assessmentSection.Expect(section => section.NotifyObservers()).Repeat.Twice(); + mocks.ReplayAll(); + + string validFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + "completeWithLocationsToBeFilteredOut.sqlite"); + string copyValidFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + "copyOfCompleteWithLocationsToBeFilteredOut.sqlite"); + + // Precondition + Assert.IsTrue(File.Exists(validFilePath), string.Format("Precodition failed. File does not exist: {0}", validFilePath)); + + importer.Import(assessmentSection, validFilePath); + + // Call + var importResult = importer.Import(assessmentSection, copyValidFilePath); + + // Assert + Assert.IsTrue(importResult); + Assert.AreEqual(copyValidFilePath, assessmentSection.HydraulicBoundaryDatabase.FilePath); + ICollection importedLocations = assessmentSection.HydraulicBoundaryDatabase.Locations; + Assert.AreEqual(9, importedLocations.Count); + CollectionAssert.AllItemsAreNotNull(importedLocations); + CollectionAssert.AllItemsAreUnique(importedLocations); + mocks.VerifyAll(); + } + + [Test] + public void Import_ImportingToSameDatabaseOnSamePath_AssessmentSectionNotNotified() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + assessmentSection.Expect(section => section.NotifyObservers()); + mocks.ReplayAll(); + + string validFilePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + "completeWithLocationsToBeFilteredOut.sqlite"); + + // Precondition + Assert.IsTrue(File.Exists(validFilePath), string.Format("Precodition failed. File does not exist: {0}", validFilePath)); + + importer.Import(assessmentSection, validFilePath); + + // Call + var importResult = importer.Import(assessmentSection, validFilePath); + + // Assert + Assert.IsTrue(importResult); + Assert.AreEqual(validFilePath, assessmentSection.HydraulicBoundaryDatabase.FilePath); + ICollection importedLocations = assessmentSection.HydraulicBoundaryDatabase.Locations; + Assert.AreEqual(9, importedLocations.Count); + CollectionAssert.AllItemsAreNotNull(importedLocations); + CollectionAssert.AllItemsAreUnique(importedLocations); + mocks.VerifyAll(); + } + + [Test] + public void Import_ImportingFileWithCorruptSchema_AbortAndLog() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + assessmentSection.Expect(section => section.NotifyObservers()).Repeat.Never(); + mocks.ReplayAll(); + + string corruptPath = Path.Combine(testDataPath, "corruptschema.sqlite"); + var expectedLogMessage = string.Format("Fout bij het lezen van bestand '{0}': Kritieke fout opgetreden bij het uitlezen van waardes uit kolommen in de database. Het bestand wordt overgeslagen.", corruptPath); + + var importResult = true; + + // Call + Action call = () => importResult = importer.Import(assessmentSection, corruptPath); + + // Assert + TestHelper.AssertLogMessageIsGenerated(call, expectedLogMessage, 1); + Assert.IsFalse(importResult); + Assert.IsNull(assessmentSection.HydraulicBoundaryDatabase, "No HydraulicBoundaryDatabase object should be created when import from corrupt database."); + + mocks.VerifyAll(); + } + + [Test] + public void Import_CorruptSchemaFile_ReturnsFalse() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + assessmentSection.Expect(section => section.NotifyObservers()).Repeat.Never(); + mocks.ReplayAll(); + + string validFilePath = Path.Combine(testDataPath, "corruptschema.sqlite"); + var importResult = true; + + // Call + Action call = () => importResult = importer.Import(assessmentSection, validFilePath); + + // Assert + string expectedMessage = new FileReaderErrorMessageBuilder(validFilePath) + .Build("Kritieke fout opgetreden bij het uitlezen van waardes uit kolommen in de database. Het bestand wordt overgeslagen."); + TestHelper.AssertLogMessageIsGenerated(call, expectedMessage, 1); + Assert.IsFalse(importResult); + mocks.VerifyAll(); + } + } +} \ No newline at end of file Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/HydraulicBoundaryLocationFilterTest.cs =================================================================== diff -u --- Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/HydraulicBoundaryLocationFilterTest.cs (revision 0) +++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/HydraulicBoundaryLocationFilterTest.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -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 NUnit.Framework; +using Ringtoets.Common.IO.FileImporters; + +namespace Ringtoets.Common.IO.Test.FileImporters +{ + [TestFixture] + public class HydraulicBoundaryLocationFilterTest + { + [Test] + [TestCase(-1)] + [TestCase(long.MinValue)] + [TestCase(303192)] + [TestCase(303196)] + [TestCase(602961)] + [TestCase(603017)] + [TestCase(long.MaxValue)] + public void ShouldInclude_NameNotInFilterSet_ReturnsTrue(long id) + { + // Setup + var filter = new HydraulicBoundaryLocationFilter(); + + // Call + bool shouldBeIncluded = filter.ShouldInclude(id); + + // Assert + Assert.IsTrue(shouldBeIncluded); + } + + [Test] + [TestCase(303193)] + [TestCase(603075)] + public void ShouldInclude_NameInFilterSet_ReturnsFalse(long id) + { + // Setup + var filter = new HydraulicBoundaryLocationFilter(); + + // Call + bool shouldBeIncluded = filter.ShouldInclude(id); + + // Assert + Assert.IsFalse(shouldBeIncluded); + } + } +} \ No newline at end of file Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/ProfilesImporterTest.cs =================================================================== diff -u --- Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/ProfilesImporterTest.cs (revision 0) +++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/FileImporters/ProfilesImporterTest.cs (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -0,0 +1,538 @@ +// 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 System.Collections.Generic; +using System.IO; +using System.Linq; +using Core.Common.Base; +using Core.Common.Base.Geometry; +using Core.Common.Base.IO; +using Core.Common.IO.Readers; +using Core.Common.TestUtil; +using Core.Common.Utils.Builders; +using NUnit.Framework; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.IO.DikeProfiles; +using Ringtoets.Common.IO.FileImporters; +using CoreCommonUtilsResources = Core.Common.Utils.Properties.Resources; + +namespace Ringtoets.Common.IO.Test.FileImporters +{ + [TestFixture] + public class ProfilesImporterTest + { + private readonly ObservableList testImportTarget = new ObservableList(); + private readonly ReferenceLine testReferenceLine = new ReferenceLine(); + private readonly string testFilePath = string.Empty; + + [Test] + public void ParameteredConstructor_ExpectedValues() + { + // Call + var importer = new TestProfilesImporter(testImportTarget, testReferenceLine, testFilePath); + + // Assert + Assert.IsInstanceOf(importer); + } + + [Test] + public void ParameteredConstructor_ImportTargetNull_ThrowArgumentNullException() + { + // Call + TestDelegate call = () => new TestProfilesImporter(null, testReferenceLine, testFilePath); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("importTarget", exception.ParamName); + } + + [Test] + public void ParameteredConstructor_ReferenceLineNull_ThrowArgumentNullException() + { + // Call + TestDelegate call = () => new TestProfilesImporter(testImportTarget, null, testFilePath); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("referenceLine", exception.ParamName); + } + + [Test] + public void ParameteredConstructor_FilePathNull_ThrowArgumentNullException() + { + // Call + TestDelegate call = () => new TestProfilesImporter(testImportTarget, testReferenceLine, null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("filePath", exception.ParamName); + } + + [Test] + [TestCase("")] + [TestCase(" ")] + public void Import_FromInvalidEmptyPath_FalseAndLogError(string filePath) + { + // Setup + var testProfilesImporter = new TestProfilesImporter(testImportTarget, testReferenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string[] messageArray = messages.ToArray(); + string expectedMessage = new FileReaderErrorMessageBuilder(filePath) + .Build(CoreCommonUtilsResources.Error_Path_must_be_specified); + StringAssert.StartsWith(expectedMessage, messageArray[0]); + }); + Assert.IsFalse(importResult); + } + + [Test] + public void Import_FromPathContainingInvalidFileCharacters_FalseAndLogError() + { + // Setup + string filePath = "c:\\Invalid_Characters.shp"; + + var invalidFileNameChars = Path.GetInvalidFileNameChars(); + var invalidPath = filePath.Replace('_', invalidFileNameChars[0]); + + var testProfilesImporter = new TestProfilesImporter(testImportTarget, testReferenceLine, invalidPath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string message = messages.First(); + string expectedMessage = new FileReaderErrorMessageBuilder(invalidPath) + .Build(string.Format(CoreCommonUtilsResources.Error_Path_cannot_contain_Characters_0_, string.Join(", ", Path.GetInvalidFileNameChars()))); + StringAssert.StartsWith(expectedMessage, message); + }); + Assert.IsFalse(importResult); + } + + [Test] + public void Import_FromDirectoryPath_FalseAndLogError() + { + // Setup + string folderPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin) + Path.DirectorySeparatorChar; + + var testProfilesImporter = new TestProfilesImporter(testImportTarget, testReferenceLine, folderPath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string[] messageArray = messages.ToArray(); + string expectedMessage = new FileReaderErrorMessageBuilder(folderPath) + .Build(CoreCommonUtilsResources.Error_Path_must_not_point_to_empty_file_name); + StringAssert.StartsWith(expectedMessage, messageArray[0]); + }); + Assert.IsFalse(importResult); + } + + [Test] + [TestCase("Multiple_Polygon_with_ID.shp")] + [TestCase("Multiple_PolyLine_with_ID.shp")] + [TestCase("Single_Multi-Polygon_with_ID.shp")] + [TestCase("Single_Multi-PolyLine_with_ID.shp")] + [TestCase("Single_Polygon_with_ID.shp")] + [TestCase("Single_PolyLine_with_ID.shp")] + public void Import_FromFileWithNonPointFeatures_FalseAndLogError(string shapeFileName) + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Core.Components.Gis.IO, + shapeFileName); + + var testProfilesImporter = new TestProfilesImporter(testImportTarget, testReferenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string[] messageArray = messages.ToArray(); + string expectedMessage = + string.Format("Fout bij het lezen van bestand '{0}': Kon geen punten vinden in dit bestand.", filePath); + StringAssert.EndsWith(expectedMessage, messageArray[0]); + }); + Assert.IsFalse(importResult); + } + + [Test] + [TestCase("Voorlanden_12-2_WithoutId.shp", "ID")] + [TestCase("Voorlanden_12-2_WithoutName.shp", "Naam")] + [TestCase("Voorlanden_12-2_WithoutX0.shp", "X0")] + public void Import_FromFileMissingAttributeColumn_FalseAndLogError( + string shapeFileName, string missingColumnName) + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", shapeFileName)); + + var testProfilesImporter = new TestProfilesImporter(testImportTarget, testReferenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string[] messageArray = messages.ToArray(); + string expectedMessage = string.Format("Het bestand heeft geen attribuut '{0}'. Dit attribuut is vereist.", + missingColumnName); + Assert.AreEqual(expectedMessage, messageArray[0]); + }); + Assert.IsFalse(importResult); + } + + [Test] + [TestCase("Voorlanden_12-2_IdWithSymbol.shp")] + [TestCase("Voorlanden_12-2_IdWithWhitespace.shp")] + public void Import_FromFileWithIllegalCharactersInId_TrueAndLogError(string fileName) + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", fileName)); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var testProfilesImporter = new TestProfilesImporter(new ObservableList(), referenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string[] messageArray = messages.ToArray(); + string expectedMessage = "Fout bij het lezen van profiel op regel 1. De locatie parameter 'ID' mag uitsluitend uit letters en cijfers bestaan. Dit profiel wordt overgeslagen."; + Assert.AreEqual(expectedMessage, messageArray[0]); + }); + Assert.IsTrue(importResult); + } + + [Test] + public void Import_FromFileWithEmptyEntryForId_TrueAndLogError() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", "Voorlanden_12-2_EmptyId.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var testProfilesImporter = new TestProfilesImporter(new ObservableList(), referenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string[] messageArray = messages.ToArray(); + string message1 = "Fout bij het lezen van profiel op regel 1. De locatie parameter 'ID' heeft geen waarde. Dit profiel wordt overgeslagen."; + string message2 = "Fout bij het lezen van profiel op regel 2. De locatie parameter 'ID' heeft geen waarde. Dit profiel wordt overgeslagen."; + string message3 = "Fout bij het lezen van profiel op regel 4. De locatie parameter 'ID' heeft geen waarde. Dit profiel wordt overgeslagen."; + Assert.AreEqual(message1, messageArray[0]); + Assert.AreEqual(message2, messageArray[1]); + Assert.AreEqual(message3, messageArray[2]); + }); + Assert.IsTrue(importResult); + } + + [Test] + public void Import_FromFileWithEmptyEntryForX0_TrueAndLogError() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", "Voorlanden_12-2_EmptyX0.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var testProfilesImporter = new TestProfilesImporter(new ObservableList(), referenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string[] messageArray = messages.ToArray(); + string expectedMessage = "Fout bij het lezen van profiel op regel 1. Het profiel heeft geen geldige waarde voor attribuut 'X0'. Dit profiel wordt overgeslagen."; + Assert.AreEqual(expectedMessage, messageArray[0]); + }); + Assert.IsTrue(importResult); + } + + [Test] + public void Import_DikeProfileLocationsNotCloseEnoughToReferenceLine_TrueAndLogError() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + var referencePoints = new List + { + new Point2D(141223.2, 548393.4), + new Point2D(143854.3, 545323.1), + new Point2D(145561.0, 541920.3), + new Point2D(146432.1, 538235.2), + new Point2D(146039.4, 533920.2) + }; + ReferenceLine referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(referencePoints); + var testProfilesImporter = new TestProfilesImporter(new ObservableList(), referenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + var expectedMessages = Enumerable.Repeat("Een profiellocatie met ID 'profiel001' ligt niet op de referentielijn. Locatie wordt overgeslagen.", 5).ToArray(); + TestHelper.AssertLogMessagesAreGenerated(call, expectedMessages, expectedMessages.Length); + Assert.IsTrue(importResult); + } + + [Test] + public void Import_InvalidDamType_TrueAndLogMessage() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", "InvalidDamType", "Voorlanden 12-2.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var testProfilesImporter = new TestProfilesImporter(new ObservableList(), referenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + Action> asserts = messages => + { + bool found = messages.Any(message => message.EndsWith(": Het ingelezen damtype ('4') moet 0, 1, 2 of 3 zijn.")); + Assert.IsTrue(found); + }; + TestHelper.AssertLogMessages(call, asserts); + Assert.IsTrue(importResult); + } + + [Test] + public void Import_TwoPrflWithSameId_TrueAndErrorLog() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", "TwoPrflWithSameId", "profiel001.shp")); + + var referencePoints = new List + { + new Point2D(130074.3, 543717.4), + new Point2D(130084.3, 543727.4) + }; + ReferenceLine referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(referencePoints); + var testProfilesImporter = new TestProfilesImporter(new ObservableList(), referenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + Action> asserts = messages => + { + var start = "Meerdere definities gevonden voor profiel 'profiel001'. Bestand '"; + var end = "' wordt overgeslagen."; + bool found = messages.Any(m => m.StartsWith(start) && m.EndsWith(end)); + Assert.IsTrue(found); + }; + TestHelper.AssertLogMessages(call, asserts); + Assert.IsTrue(importResult); + } + + [Test] + public void Import_FromFileWithDupplicateId_TrueAndLogWarnings() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", "Voorlanden_12-2_same_id_3_times.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var testProfilesImporter = new TestProfilesImporter(new ObservableList(), referenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + TestHelper.AssertLogMessages(call, messages => + { + string[] messageArray = messages.ToArray(); + string expectedMessage = "Profiellocatie met ID 'profiel001' is opnieuw ingelezen."; + Assert.AreEqual(expectedMessage, messageArray[0]); + Assert.AreEqual(expectedMessage, messageArray[1]); + }); + Assert.IsTrue(importResult); + } + + [Test] + public void Import_PrflWithProfileNotZero_TrueAndErrorLog() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", "PrflWithProfileNotZero", "Voorland_12-2.shp")); + + ReferenceLine referenceLine = CreateMatchingReferenceLine(); + var testProfilesImporter = new TestProfilesImporter(new ObservableList(), referenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + Action> asserts = messages => + { + bool found = messages.Any(message => message.StartsWith("Profielgegevens definiëren een damwand waarde ongelijk aan 0. Bestand wordt overgeslagen:")); + Assert.IsTrue(found); + }; + TestHelper.AssertLogMessages(call, asserts); + Assert.IsTrue(importResult); + } + + [Test] + public void Import_PrflIsIncomplete_TrueAndErrorLog() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", "PrflIsIncomplete", "Voorland_12-2.shp")); + + var referencePoints = new List + { + new Point2D(130074.3, 543717.4), + new Point2D(130084.3, 543727.4) + }; + ReferenceLine referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(referencePoints); + var testProfilesImporter = new TestProfilesImporter(new ObservableList(), referenceLine, filePath); + + // Call + var importResult = true; + Action call = () => importResult = testProfilesImporter.Import(); + + // Assert + Action> asserts = messages => + { + bool found = messages.First().Contains(": De volgende parameters zijn niet aanwezig in het bestand: VOORLAND, DAMWAND, KRUINHOOGTE, DIJK, MEMO"); + Assert.IsTrue(found); + }; + TestHelper.AssertLogMessages(call, asserts); + Assert.IsTrue(importResult); + } + + [Test] + public void Import_CancelOfImportToValidTargetWithValidFile_CancelImport() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Plugin, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + var testProfilesImporter = new TestProfilesImporter(testImportTarget, testReferenceLine, filePath); + + testProfilesImporter.Cancel(); + + // Call + bool importResult = testProfilesImporter.Import(); + + // Assert + Assert.IsFalse(importResult); + } + + [Test] + public void Import_ReuseOfCancelledImportToValidTargetWithValidFile_True() + { + // Setup + string filePath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Common.IO, + Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); + + var referencePoints = new List + { + new Point2D(130074.3, 543717.4), + new Point2D(130084.3, 543727.4) + }; + ReferenceLine referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(referencePoints); + var testProfilesImporter = new TestProfilesImporter(new ObservableList(), referenceLine, filePath); + + testProfilesImporter.Cancel(); + bool importResult = testProfilesImporter.Import(); + + // Precondition + Assert.IsFalse(importResult); + + // Call + importResult = testProfilesImporter.Import(); + + // Assert + Assert.IsTrue(importResult); + } + + private ReferenceLine CreateMatchingReferenceLine() + { + ReferenceLine referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(new[] + { + new Point2D(131223.2, 548393.4), + new Point2D(133854.3, 545323.1), + new Point2D(135561.0, 541920.3), + new Point2D(136432.1, 538235.2), + new Point2D(136039.4, 533920.2) + }); + return referenceLine; + } + + private class TestProfilesImporter : ProfilesImporter> + { + public TestProfilesImporter(ObservableList importTarget, ReferenceLine referenceLine, string filePath) + : base(referenceLine, filePath, importTarget) {} + + protected override void CreateProfiles(ReadResult importProfileLocationResult, ReadResult importDikeProfileDataResult) {} + + protected override bool DikeProfileDataIsValid(DikeProfileData data, string prflFilePath) + { + return true; + } + } + + private class TestProfile {}; + } +} \ No newline at end of file Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/Ringtoets.Common.IO.Test.csproj =================================================================== diff -u -r1d6be87de63acfac543d4b90aaf0618d3203b0c3 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Common/test/Ringtoets.Common.IO.Test/Ringtoets.Common.IO.Test.csproj (.../Ringtoets.Common.IO.Test.csproj) (revision 1d6be87de63acfac543d4b90aaf0618d3203b0c3) +++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/Ringtoets.Common.IO.Test.csproj (.../Ringtoets.Common.IO.Test.csproj) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -59,6 +59,12 @@ + + + + + + Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs =================================================================== diff -u -r30b8231f92b90ea4b05e98e3d0285368f6dfe2e4 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs (.../GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs) (revision 30b8231f92b90ea4b05e98e3d0285368f6dfe2e4) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs (.../GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -33,12 +33,12 @@ using Ringtoets.Common.Data.DikeProfiles; using Ringtoets.Common.Data.FailureMechanism; using Ringtoets.Common.Data.Probability; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.GrassCoverErosionInwards.Service; using Ringtoets.GrassCoverErosionInwards.Service.Properties; using Ringtoets.HydraRing.Data; using Ringtoets.Integration.Data; -using Ringtoets.Integration.Plugin.FileImporters; namespace Ringtoets.GrassCoverErosionInwards.Integration.Test { Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationServiceIntegrationTest.cs =================================================================== diff -u -r4438e5f52238284921d2f6505b424804ee2e458c -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationServiceIntegrationTest.cs (.../GrassCoverErosionInwardsCalculationServiceIntegrationTest.cs) (revision 4438e5f52238284921d2f6505b424804ee2e458c) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationServiceIntegrationTest.cs (.../GrassCoverErosionInwardsCalculationServiceIntegrationTest.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -28,11 +28,11 @@ using Ringtoets.Common.Data.AssessmentSection; using Ringtoets.Common.Data.DikeProfiles; using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.GrassCoverErosionInwards.Service; using Ringtoets.HydraRing.Data; using Ringtoets.Integration.Data; -using Ringtoets.Integration.Plugin.FileImporters; namespace Ringtoets.GrassCoverErosionInwards.Integration.Test { Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsScenariosViewIntegrationTest.cs =================================================================== diff -u -r2973c5f790a5131e427bd5f73e2a620044199639 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsScenariosViewIntegrationTest.cs (.../GrassCoverErosionInwardsScenariosViewIntegrationTest.cs) (revision 2973c5f790a5131e427bd5f73e2a620044199639) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsScenariosViewIntegrationTest.cs (.../GrassCoverErosionInwardsScenariosViewIntegrationTest.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -28,10 +28,10 @@ using Ringtoets.Common.Data.AssessmentSection; using Ringtoets.Common.Data.Calculation; using Ringtoets.Common.Forms.Helpers; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.GrassCoverErosionInwards.Forms.Views; using Ringtoets.Integration.Data; -using Ringtoets.Integration.Plugin.FileImporters; namespace Ringtoets.GrassCoverErosionInwards.Integration.Test { Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/IntegrationTestHelper.cs =================================================================== diff -u -r4e578730273a943bb02a2861c694a2707c8ef852 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/IntegrationTestHelper.cs (.../IntegrationTestHelper.cs) (revision 4e578730273a943bb02a2861c694a2707c8ef852) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/IntegrationTestHelper.cs (.../IntegrationTestHelper.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -24,9 +24,9 @@ using Core.Common.Utils.IO; using Ringtoets.Common.Data.FailureMechanism; using Ringtoets.Common.IO; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.Common.IO.ReferenceLines; using Ringtoets.Integration.Data; -using Ringtoets.Integration.Plugin.FileImporters; namespace Ringtoets.GrassCoverErosionInwards.Integration.Test { Index: Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Integration.Test/GrassCoverErosionOutwardsWaveConditionsCalculationActivityIntegrationTest.cs =================================================================== diff -u -r1d0754dba6c2a05f96d4ea937cc0d6de62644755 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Integration.Test/GrassCoverErosionOutwardsWaveConditionsCalculationActivityIntegrationTest.cs (.../GrassCoverErosionOutwardsWaveConditionsCalculationActivityIntegrationTest.cs) (revision 1d0754dba6c2a05f96d4ea937cc0d6de62644755) +++ Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Integration.Test/GrassCoverErosionOutwardsWaveConditionsCalculationActivityIntegrationTest.cs (.../GrassCoverErosionOutwardsWaveConditionsCalculationActivityIntegrationTest.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -31,13 +31,13 @@ using Ringtoets.Common.Data.AssessmentSection; using Ringtoets.Common.Data.DikeProfiles; using Ringtoets.Common.Data.TestUtil; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.GrassCoverErosionOutwards.Data; using Ringtoets.GrassCoverErosionOutwards.Service; using Ringtoets.GrassCoverErosionOutwards.Service.Properties; using Ringtoets.HydraRing.Calculation.TestUtil; using Ringtoets.HydraRing.Data; using Ringtoets.Integration.Data; -using Ringtoets.Integration.Plugin.FileImporters; using Ringtoets.Revetment.Data; using Ringtoets.Revetment.Service; using Ringtoets.Revetment.Service.TestUtil; Index: Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Integration.Test/Ringtoets.GrassCoverErosionOutwards.Integration.Test.csproj =================================================================== diff -u -rae93bd6b8ccbffa91f7c5c10e898736b5919b73d -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Integration.Test/Ringtoets.GrassCoverErosionOutwards.Integration.Test.csproj (.../Ringtoets.GrassCoverErosionOutwards.Integration.Test.csproj) (revision ae93bd6b8ccbffa91f7c5c10e898736b5919b73d) +++ Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Integration.Test/Ringtoets.GrassCoverErosionOutwards.Integration.Test.csproj (.../Ringtoets.GrassCoverErosionOutwards.Integration.Test.csproj) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -74,6 +74,10 @@ {d4200f43-3f72-4f42-af0a-8ced416a38ec} Ringtoets.Common.Data + + {52BA7627-CBAB-4209-BE77-3B5F31378277} + Ringtoets.Common.IO + {4843D6E5-066F-4795-94F5-1D53932DD03C} Ringtoets.Common.Data.TestUtil Index: Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/HeightStructuresCalculationActivityIntegrationTest.cs =================================================================== diff -u -r35baeb163866f62a72bccf6438ddc08b41407ecf -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/HeightStructuresCalculationActivityIntegrationTest.cs (.../HeightStructuresCalculationActivityIntegrationTest.cs) (revision 35baeb163866f62a72bccf6438ddc08b41407ecf) +++ Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/HeightStructuresCalculationActivityIntegrationTest.cs (.../HeightStructuresCalculationActivityIntegrationTest.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -30,11 +30,11 @@ using Rhino.Mocks; using Ringtoets.Common.Data.AssessmentSection; using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.HeightStructures.Data; using Ringtoets.HeightStructures.Service; using Ringtoets.HydraRing.Data; using Ringtoets.Integration.Data; -using Ringtoets.Integration.Plugin.FileImporters; namespace Ringtoets.HeightStructures.Integration.Test { Index: Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/HeightStructuresCalculationServiceIntegrationTest.cs =================================================================== diff -u -r35baeb163866f62a72bccf6438ddc08b41407ecf -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/HeightStructuresCalculationServiceIntegrationTest.cs (.../HeightStructuresCalculationServiceIntegrationTest.cs) (revision 35baeb163866f62a72bccf6438ddc08b41407ecf) +++ Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/HeightStructuresCalculationServiceIntegrationTest.cs (.../HeightStructuresCalculationServiceIntegrationTest.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -27,12 +27,12 @@ using NUnit.Framework; using Ringtoets.Common.Data.AssessmentSection; using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.HeightStructures.Data; using Ringtoets.HeightStructures.Service; using Ringtoets.HydraRing.Calculation.Data.Output; using Ringtoets.HydraRing.Data; using Ringtoets.Integration.Data; -using Ringtoets.Integration.Plugin.FileImporters; namespace Ringtoets.HeightStructures.Integration.Test { Index: Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/Ringtoets.HeightStructures.Integration.Test.csproj =================================================================== diff -u -r3d84064b23186da3fb11f19ff0d07f41e1209bbb -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/Ringtoets.HeightStructures.Integration.Test.csproj (.../Ringtoets.HeightStructures.Integration.Test.csproj) (revision 3d84064b23186da3fb11f19ff0d07f41e1209bbb) +++ Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/Ringtoets.HeightStructures.Integration.Test.csproj (.../Ringtoets.HeightStructures.Integration.Test.csproj) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -77,6 +77,10 @@ {D4200F43-3F72-4F42-AF0A-8CED416A38EC} Ringtoets.Common.Data + + {52BA7627-CBAB-4209-BE77-3B5F31378277} + Ringtoets.Common.IO + {888d4097-8bc2-4703-9fb1-8744c94d525e} Ringtoets.HydraRing.Calculation Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/src/Ringtoets.Integration.Plugin/FileImporters/DikeProfilesImporter.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/src/Ringtoets.Integration.Plugin/FileImporters/FailureMechanismSectionsImporter.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/src/Ringtoets.Integration.Plugin/FileImporters/ForeshoreProfilesImporter.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/src/Ringtoets.Integration.Plugin/FileImporters/HydraulicBoundaryDatabaseImporter.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/src/Ringtoets.Integration.Plugin/FileImporters/HydraulicBoundaryLocationFilter.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/src/Ringtoets.Integration.Plugin/FileImporters/ProfilesImporter.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Properties/Resources.Designer.cs =================================================================== diff -u -rffcd131f36f1d349c8fed822cb00059c1cf0adf2 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Properties/Resources.Designer.cs (.../Resources.Designer.cs) (revision ffcd131f36f1d349c8fed822cb00059c1cf0adf2) +++ Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Properties/Resources.Designer.cs (.../Resources.Designer.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -109,25 +109,6 @@ } /// - /// Looks up a localized string similar to Kan geen geldige gegevens vinden voor dijkprofiellocatie met ID '{0}'.. - /// - public static string DikeProfilesImporter_GetMatchingDikeProfileData_no_dikeprofiledata_for_location_0_ { - get { - return ResourceManager.GetString("DikeProfilesImporter_GetMatchingDikeProfileData_no_dikeprofiledata_for_location_0" + - "_", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Dijkprofielen importeren is afgebroken. Geen gegevens ingelezen.. - /// - public static string DikeProfilesImporter_HandleUserCancellingImport_dikeprofile_import_aborted { - get { - return ResourceManager.GetString("DikeProfilesImporter_HandleUserCancellingImport_dikeprofile_import_aborted", resourceCulture); - } - } - - /// /// Looks up a localized string similar to Er is geen referentielijn beschikbaar. Geen gegevens ingelezen.. /// public static string DikeProfilesImporter_Import_no_referenceline_import_aborted { @@ -137,34 +118,6 @@ } /// - /// Looks up a localized string similar to Profielgegevens definiëren geen dijkgeometrie. Bestand '{0}' wordt overgeslagen.. - /// - public static string DikeProfilesImporter_No_dike_geometry_file_0_skipped { - get { - return ResourceManager.GetString("DikeProfilesImporter_No_dike_geometry_file_0_skipped", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to {0} - ///Er is geen vakindeling geïmporteerd.. - /// - public static string FailureMechanismSectionsImporter_CriticalErrorMessage_0_No_sections_imported { - get { - return ResourceManager.GetString("FailureMechanismSectionsImporter_CriticalErrorMessage_0_No_sections_imported", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Vakindeling importeren afgebroken. Geen gegevens ingelezen.. - /// - public static string FailureMechanismSectionsImporter_Import_cancelled_no_data_read { - get { - return ResourceManager.GetString("FailureMechanismSectionsImporter_Import_cancelled_no_data_read", resourceCulture); - } - } - - /// /// Looks up a localized string similar to Vakindeling komt niet overeen met de huidige referentielijn.. /// public static string FailureMechanismSectionsImporter_Import_Imported_sections_do_not_correspond_to_current_referenceline { @@ -175,52 +128,6 @@ } /// - /// Looks up a localized string similar to Er is geen referentielijn beschikbaar om een vakindeling voor te definiëren.. - /// - public static string FailureMechanismSectionsImporter_Import_Required_referenceline_missing { - get { - return ResourceManager.GetString("FailureMechanismSectionsImporter_Import_Required_referenceline_missing", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Geïmporteerde gegevens toevoegen aan het toetsspoor.. - /// - public static string FailureMechanismSectionsImporter_ProgressText_Adding_imported_data_to_failureMechanism { - get { - return ResourceManager.GetString("FailureMechanismSectionsImporter_ProgressText_Adding_imported_data_to_failureMech" + - "anism", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Inlezen vakindeling.. - /// - public static string FailureMechanismSectionsImporter_ProgressText_Reading_file { - get { - return ResourceManager.GetString("FailureMechanismSectionsImporter_ProgressText_Reading_file", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Valideren ingelezen vakindeling.. - /// - public static string FailureMechanismSectionsImporter_ProgressText_Validating_imported_sections { - get { - return ResourceManager.GetString("FailureMechanismSectionsImporter_ProgressText_Validating_imported_sections", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Het bestand heeft geen vakindeling.. - /// - public static string FailureMechanismSectionsImporter_ReadFile_File_is_empty { - get { - return ResourceManager.GetString("FailureMechanismSectionsImporter_ReadFile_File_is_empty", resourceCulture); - } - } - - /// /// Looks up a localized resource of type System.Drawing.Bitmap. /// public static System.Drawing.Bitmap Foreshore { @@ -240,227 +147,6 @@ } /// - /// Looks up a localized string similar to Kan geen geldige gegevens vinden voor voorlandprofiellocatie met ID '{0}'.. - /// - public static string ForeshoreProfilesImporter_GetMatchingForeshoreProfileData_no_foreshoreprofiledata_for_location_0_ { - get { - return ResourceManager.GetString("ForeshoreProfilesImporter_GetMatchingForeshoreProfileData_no_foreshoreprofiledata" + - "_for_location_0_", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Voorlandprofielen importeren is afgebroken. Geen gegevens ingelezen.. - /// - public static string ForeshoreProfilesImporter_HandleUserCancellingImport_foreshoreprofile_import_aborted { - get { - return ResourceManager.GetString("ForeshoreProfilesImporter_HandleUserCancellingImport_foreshoreprofile_import_abor" + - "ted", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Profielgegevens definiëren geen dam en geen voorlandgeometrie. Bestand '{0}' wordt overgeslagen.. - /// - public static string ForeshoreProfilesImporter_No_dam_no_foreshore_geometry_file_0_skipped { - get { - return ResourceManager.GetString("ForeshoreProfilesImporter_No_dam_no_foreshore_geometry_file_0_skipped", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to {0} Het bestand wordt overgeslagen.. - /// - public static string HydraulicBoundaryDatabaseImporter_ErrorMessage_0_file_skipped { - get { - return ResourceManager.GetString("HydraulicBoundaryDatabaseImporter_ErrorMessage_0_file_skipped", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Het bijbehorende HLCD bestand is niet gevonden in dezelfde map als het HRD bestand.. - /// - public static string HydraulicBoundaryDatabaseImporter_HLCD_sqlite_Not_Found { - get { - return ResourceManager.GetString("HydraulicBoundaryDatabaseImporter_HLCD_sqlite_Not_Found", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to De hydraulische randvoorwaardenlocaties zijn ingelezen.. - /// - public static string HydraulicBoundaryDatabaseImporter_Import_All_hydraulic_locations_read { - get { - return ResourceManager.GetString("HydraulicBoundaryDatabaseImporter_Import_All_hydraulic_locations_read", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to LocationID - ///300130 - ///300131 - ///300189 - ///300353 - ///300354 - ///300355 - ///300357 - ///300358 - ///300359 - ///300360 - ///300361 - ///300362 - ///300363 - ///300364 - ///300365 - ///300366 - ///300367 - ///300368 - ///300369 - ///300370 - ///300371 - ///300372 - ///300373 - ///300374 - ///300375 - ///300376 - ///300608 - ///300609 - ///300610 - ///300611 - ///300612 - ///300633 - ///300634 - ///300635 - ///300636 - ///300637 - ///300657 - ///300658 - ///300659 - ///300660 - ///300661 - ///300662 - ///300663 - ///300664 - ///300665 - ///300703 - ///300704 - ///300745 - ///300748 - ///300761 - ///300762 - ///300765 - ///300766 - ///300767 - ///300824 - ///300825 - ///300826 - ///300828 - ///300829 - ///300830 - ///300864 - ///300865 - ///301595 - ///301596 - ///301597 - ///301598 - ///301599 - ///301600 - ///301601 - ///301602 - ///301603 - ///3016 [rest of string was truncated]";. - /// - public static string HydraulicBoundaryLocationsFilterList { - get { - return ResourceManager.GetString("HydraulicBoundaryLocationsFilterList", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Een profiellocatie met ID '{0}' ligt niet op de referentielijn. Locatie wordt overgeslagen.. - /// - public static string ProfilesImporter_AddNextProfileLocation_0_skipping_location_outside_referenceline { - get { - return ResourceManager.GetString("ProfilesImporter_AddNextProfileLocation_0_skipping_location_outside_referenceline" + - "", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Profiellocatie met ID '{0}' is opnieuw ingelezen.. - /// - public static string ProfilesImporter_AddNextProfileLocation_Location_with_id_0_already_read { - get { - return ResourceManager.GetString("ProfilesImporter_AddNextProfileLocation_Location_with_id_0_already_read", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Fout bij het lezen van profiel op regel {0}. {1} Dit profiel wordt overgeslagen.. - /// - public static string ProfilesImporter_GetProfileLocationReadResult_Error_reading_Profile_LineNumber_0_Error_1_The_Profile_is_skipped { - get { - return ResourceManager.GetString("ProfilesImporter_GetProfileLocationReadResult_Error_reading_Profile_LineNumber_0_" + - "Error_1_The_Profile_is_skipped", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Inlezen van profiellocatie.. - /// - public static string ProfilesImporter_GetProfileLocationReadResult_reading_profilelocation { - get { - return ResourceManager.GetString("ProfilesImporter_GetProfileLocationReadResult_reading_profilelocation", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Meerdere definities gevonden voor profiel '{0}'. Bestand '{1}' wordt overgeslagen.. - /// - public static string ProfilesImporter_LogDuplicateDikeProfileData_Multiple_DikeProfileData_found_for_DikeProfile_0_File_1_skipped { - get { - return ResourceManager.GetString("ProfilesImporter_LogDuplicateDikeProfileData_Multiple_DikeProfileData_found_for_D" + - "ikeProfile_0_File_1_skipped", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Inlezen van profielgegevens uit een prfl bestand.. - /// - public static string ProfilesImporter_ReadDikeProfileData_reading_profile_data { - get { - return ResourceManager.GetString("ProfilesImporter_ReadDikeProfileData_reading_profile_data", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Inlezen van profielgegevens.. - /// - public static string ProfilesImporter_ReadDikeProfileData_reading_profiledata { - get { - return ResourceManager.GetString("ProfilesImporter_ReadDikeProfileData_reading_profiledata", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Profielgegevens definiëren een damwand waarde ongelijk aan 0. Bestand wordt overgeslagen: {0}. - /// - public static string ProfilesImporter_ReadDikeProfileData_sheet_piling_not_zero_skipping_0_ { - get { - return ResourceManager.GetString("ProfilesImporter_ReadDikeProfileData_sheet_piling_not_zero_skipping_0_", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Inlezen van profiellocaties uit een shapebestand.. - /// - public static string ProfilesImporter_ReadProfileLocations_reading_profilelocations { - get { - return ResourceManager.GetString("ProfilesImporter_ReadProfileLocations_reading_profilelocations", resourceCulture); - } - } - - /// /// Looks up a localized string similar to Nieuw. /// public static string RingtoetsRibbon_GroupBox_New { Index: Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Properties/Resources.resx =================================================================== diff -u -rffcd131f36f1d349c8fed822cb00059c1cf0adf2 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Properties/Resources.resx (.../Resources.resx) (revision ffcd131f36f1d349c8fed822cb00059c1cf0adf2) +++ Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Properties/Resources.resx (.../Resources.resx) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -117,111 +117,32 @@ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - De hydraulische randvoorwaardenlocaties zijn ingelezen. - - - {0} Het bestand wordt overgeslagen. - - - {0} -Er is geen vakindeling geïmporteerd. - - - Er is geen referentielijn beschikbaar om een vakindeling voor te definiëren. - - - Het bestand heeft geen vakindeling. - Vakindeling komt niet overeen met de huidige referentielijn. - - Vakindeling importeren afgebroken. Geen gegevens ingelezen. - - - Inlezen vakindeling. - - - Valideren ingelezen vakindeling. - - - Geïmporteerde gegevens toevoegen aan het toetsspoor. - - - Het bijbehorende HLCD bestand is niet gevonden in dezelfde map als het HRD bestand. - Opmerkingen Nieuw - - - ..\Resources\Exceptions_DoNotCalculate.csv;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 - Voorlandprofiellocaties + ..\Resources\Foreshore.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a - - Een profiellocatie met ID '{0}' ligt niet op de referentielijn. Locatie wordt overgeslagen. - - - Profiellocatie met ID '{0}' is opnieuw ingelezen. - Dijkprofiellocaties - - Fout bij het lezen van profiel op regel {0}. {1} Dit profiel wordt overgeslagen. - - - Inlezen van profiellocatie. - - - Kan geen geldige gegevens vinden voor dijkprofiellocatie met ID '{0}'. - - - Dijkprofielen importeren is afgebroken. Geen gegevens ingelezen. - Er is geen referentielijn beschikbaar. Geen gegevens ingelezen. - - Meerdere definities gevonden voor profiel '{0}'. Bestand '{1}' wordt overgeslagen. - - - Inlezen van profielgegevens. - - - Inlezen van profielgegevens uit een prfl bestand. - - - Profielgegevens definiëren een damwand waarde ongelijk aan 0. Bestand wordt overgeslagen: {0} - - - Inlezen van profiellocaties uit een shapebestand. - - - Kan geen geldige gegevens vinden voor voorlandprofiellocatie met ID '{0}'. - - - Voorlandprofielen importeren is afgebroken. Geen gegevens ingelezen. - h(norm) Hs(norm) - - Profielgegevens definiëren geen dam en geen voorlandgeometrie. Bestand '{0}' wordt overgeslagen. - - - Profielgegevens definiëren geen dijkgeometrie. Bestand '{0}' wordt overgeslagen. - \ No newline at end of file Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Resources/Exceptions_DoNotCalculate.csv'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Ringtoets.Integration.Plugin.csproj =================================================================== diff -u -r423010168fe01b2373e9be55f047659911e670f5 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Ringtoets.Integration.Plugin.csproj (.../Ringtoets.Integration.Plugin.csproj) (revision 423010168fe01b2373e9be55f047659911e670f5) +++ Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Ringtoets.Integration.Plugin.csproj (.../Ringtoets.Integration.Plugin.csproj) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -54,12 +54,6 @@ Properties\GlobalAssembly.cs - - - - - - True @@ -117,11 +111,6 @@ Ringtoets.ClosingStructures.Forms False - - {D63FCFEC-34E8-4C68-8B4F-99338D2447AC} - Ringtoets.HeightStructures.IO - False - {3D4B9740-8348-4434-8D77-B611FC6EE57F} Ringtoets.StabilityPointStructures.Data @@ -249,7 +238,6 @@ Copying.licenseheader - Index: Ringtoets/Integration/src/Ringtoets.Integration.Plugin/RingtoetsPlugin.cs =================================================================== diff -u -r26c61097587b8bd3d7070c1458cacd03147e4b7c -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Integration/src/Ringtoets.Integration.Plugin/RingtoetsPlugin.cs (.../RingtoetsPlugin.cs) (revision 26c61097587b8bd3d7070c1458cacd03147e4b7c) +++ Ringtoets/Integration/src/Ringtoets.Integration.Plugin/RingtoetsPlugin.cs (.../RingtoetsPlugin.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -50,6 +50,7 @@ using Ringtoets.Common.Forms.TreeNodeInfos; using Ringtoets.Common.Forms.Views; using Ringtoets.Common.IO; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.Common.IO.ReferenceLines; using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.GrassCoverErosionInwards.Forms.PresentationObjects; @@ -67,7 +68,6 @@ using Ringtoets.Integration.Forms.PropertyClasses; using Ringtoets.Integration.Forms.Views; using Ringtoets.Integration.Forms.Views.SectionResultViews; -using Ringtoets.Integration.Plugin.FileImporters; using Ringtoets.Integration.Service; using Ringtoets.Integration.Service.MessageProviders; using Ringtoets.Piping.Data; Index: Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/HydraulicBoundaryDatabaseContextTreeNodeInfoTest.cs =================================================================== diff -u -r26c61097587b8bd3d7070c1458cacd03147e4b7c -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/HydraulicBoundaryDatabaseContextTreeNodeInfoTest.cs (.../HydraulicBoundaryDatabaseContextTreeNodeInfoTest.cs) (revision 26c61097587b8bd3d7070c1458cacd03147e4b7c) +++ Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/HydraulicBoundaryDatabaseContextTreeNodeInfoTest.cs (.../HydraulicBoundaryDatabaseContextTreeNodeInfoTest.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -34,12 +34,12 @@ using NUnit.Framework; using Rhino.Mocks; using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.GrassCoverErosionOutwards.Data; using Ringtoets.HydraRing.Data; using Ringtoets.Integration.Data; using Ringtoets.Integration.Forms.PresentationObjects; using Ringtoets.Integration.Plugin; -using Ringtoets.Integration.Plugin.FileImporters; using Ringtoets.Piping.Data; using RingtoetsFormsResources = Ringtoets.Integration.Forms.Properties.Resources; using RingtoetsCommonFormsResources = Ringtoets.Common.Forms.Properties.Resources; Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/FileImporters/DikeProfilesImporterTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/FileImporters/FailureMechanismSectionsImporterTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/FileImporters/ForeshoreProfilesImporterTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/FileImporters/HydraulicBoundaryDatabaseImporterTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/FileImporters/HydraulicBoundaryLocationFilterTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag f27092df1f897798c4a0b24f6fc91f49c9f294ce refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/FileImporters/ProfilesImporterTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/ImportInfos/DikeProfilesContextImportInfoTest.cs =================================================================== diff -u -r423010168fe01b2373e9be55f047659911e670f5 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/ImportInfos/DikeProfilesContextImportInfoTest.cs (.../DikeProfilesContextImportInfoTest.cs) (revision 423010168fe01b2373e9be55f047659911e670f5) +++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/ImportInfos/DikeProfilesContextImportInfoTest.cs (.../DikeProfilesContextImportInfoTest.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -29,8 +29,8 @@ using Rhino.Mocks; using Ringtoets.Common.Data.AssessmentSection; using Ringtoets.Common.Data.DikeProfiles; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.GrassCoverErosionInwards.Forms.PresentationObjects; -using Ringtoets.Integration.Plugin.FileImporters; using RingtoetsCommonFormsResources = Ringtoets.Common.Forms.Properties.Resources; namespace Ringtoets.Integration.Plugin.Test.ImportInfos Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/ImportInfos/ForeshoreProfilesContextImportInfoTest.cs =================================================================== diff -u -r423010168fe01b2373e9be55f047659911e670f5 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/ImportInfos/ForeshoreProfilesContextImportInfoTest.cs (.../ForeshoreProfilesContextImportInfoTest.cs) (revision 423010168fe01b2373e9be55f047659911e670f5) +++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/ImportInfos/ForeshoreProfilesContextImportInfoTest.cs (.../ForeshoreProfilesContextImportInfoTest.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -30,7 +30,7 @@ using Ringtoets.Common.Data.AssessmentSection; using Ringtoets.Common.Data.DikeProfiles; using Ringtoets.Common.Forms.PresentationObjects; -using Ringtoets.Integration.Plugin.FileImporters; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.Integration.Plugin.Properties; namespace Ringtoets.Integration.Plugin.Test.ImportInfos Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Ringtoets.Integration.Plugin.Test.csproj =================================================================== diff -u -r7a813dee8d40d6bcbcf17ded65418e1800360ac1 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Ringtoets.Integration.Plugin.Test.csproj (.../Ringtoets.Integration.Plugin.Test.csproj) (revision 7a813dee8d40d6bcbcf17ded65418e1800360ac1) +++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Ringtoets.Integration.Plugin.Test.csproj (.../Ringtoets.Integration.Plugin.Test.csproj) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -67,12 +67,6 @@ Properties\GlobalAssembly.cs - - - - - - @@ -113,14 +107,6 @@ {30e4c2ae-719e-4d70-9fa9-668a9767fbfa} Core.Common.Gui - - {e344867e-9ac9-44c8-88a5-8185681679a9} - Core.Common.IO - - - {F49BD8B2-332A-4C91-A196-8CCE0A2C7D98} - Core.Common.Utils - {26214bd0-dafb-4cfc-8eb2-80c5d53c859e} Core.Common.Gui.TestUtil @@ -133,10 +119,6 @@ {4a06df0d-5d75-4bad-a95a-a3db9b7c4ad5} Core.Components.Gis.Forms - - {567E0B69-5280-41CE-ADD6-443725A61C86} - Ringtoets.WaveImpactAsphaltCover.Data - {d4200f43-3f72-4f42-af0a-8ced416a38ec} Ringtoets.Common.Data @@ -153,10 +135,6 @@ {d951d6da-fe83-4920-9fdb-63bf96480b54} Ringtoets.Common.Service - - {90DE728E-48EF-4665-AB38-3D88E41D9F4D} - Ringtoets.GrassCoverErosionInwards.Data - {C540E627-B95B-4CC0-A1B6-A0BDF74936C7} Ringtoets.GrassCoverErosionInwards.Forms Index: Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/IntegrationTestHelper.cs =================================================================== diff -u -r4e578730273a943bb02a2861c694a2707c8ef852 -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/IntegrationTestHelper.cs (.../IntegrationTestHelper.cs) (revision 4e578730273a943bb02a2861c694a2707c8ef852) +++ Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/IntegrationTestHelper.cs (.../IntegrationTestHelper.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -23,9 +23,9 @@ using Core.Common.Base.Service; using Core.Common.Utils.IO; using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.Common.IO.ReferenceLines; using Ringtoets.Integration.Data; -using Ringtoets.Integration.Plugin.FileImporters; using Ringtoets.Piping.Plugin.FileImporter; namespace Ringtoets.Piping.Integration.Test Index: Ringtoets/StabilityStoneCover/test/Ringtoets.StabilityStoneCover.Integration.Test/Ringtoets.StabilityStoneCover.Integration.Test.csproj =================================================================== diff -u -rae93bd6b8ccbffa91f7c5c10e898736b5919b73d -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/StabilityStoneCover/test/Ringtoets.StabilityStoneCover.Integration.Test/Ringtoets.StabilityStoneCover.Integration.Test.csproj (.../Ringtoets.StabilityStoneCover.Integration.Test.csproj) (revision ae93bd6b8ccbffa91f7c5c10e898736b5919b73d) +++ Ringtoets/StabilityStoneCover/test/Ringtoets.StabilityStoneCover.Integration.Test/Ringtoets.StabilityStoneCover.Integration.Test.csproj (.../Ringtoets.StabilityStoneCover.Integration.Test.csproj) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -74,6 +74,10 @@ {d4200f43-3f72-4f42-af0a-8ced416a38ec} Ringtoets.Common.Data + + {52BA7627-CBAB-4209-BE77-3B5F31378277} + Ringtoets.Common.IO + {4843D6E5-066F-4795-94F5-1D53932DD03C} Ringtoets.Common.Data.TestUtil Index: Ringtoets/StabilityStoneCover/test/Ringtoets.StabilityStoneCover.Integration.Test/StabilityStoneCoverWaveConditionsCalculationActivityIntegrationTest.cs =================================================================== diff -u -r4438e5f52238284921d2f6505b424804ee2e458c -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/StabilityStoneCover/test/Ringtoets.StabilityStoneCover.Integration.Test/StabilityStoneCoverWaveConditionsCalculationActivityIntegrationTest.cs (.../StabilityStoneCoverWaveConditionsCalculationActivityIntegrationTest.cs) (revision 4438e5f52238284921d2f6505b424804ee2e458c) +++ Ringtoets/StabilityStoneCover/test/Ringtoets.StabilityStoneCover.Integration.Test/StabilityStoneCoverWaveConditionsCalculationActivityIntegrationTest.cs (.../StabilityStoneCoverWaveConditionsCalculationActivityIntegrationTest.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -31,10 +31,10 @@ using Ringtoets.Common.Data.AssessmentSection; using Ringtoets.Common.Data.DikeProfiles; using Ringtoets.Common.Data.TestUtil; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.HydraRing.Calculation.TestUtil; using Ringtoets.HydraRing.Data; using Ringtoets.Integration.Data; -using Ringtoets.Integration.Plugin.FileImporters; using Ringtoets.Revetment.Data; using Ringtoets.Revetment.Service; using Ringtoets.Revetment.Service.TestUtil; Index: Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Integration.Test/Ringtoets.WaveImpactAsphaltCover.Integration.Test.csproj =================================================================== diff -u -rae93bd6b8ccbffa91f7c5c10e898736b5919b73d -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Integration.Test/Ringtoets.WaveImpactAsphaltCover.Integration.Test.csproj (.../Ringtoets.WaveImpactAsphaltCover.Integration.Test.csproj) (revision ae93bd6b8ccbffa91f7c5c10e898736b5919b73d) +++ Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Integration.Test/Ringtoets.WaveImpactAsphaltCover.Integration.Test.csproj (.../Ringtoets.WaveImpactAsphaltCover.Integration.Test.csproj) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -74,6 +74,10 @@ {d4200f43-3f72-4f42-af0a-8ced416a38ec} Ringtoets.Common.Data + + {52BA7627-CBAB-4209-BE77-3B5F31378277} + Ringtoets.Common.IO + {4843D6E5-066F-4795-94F5-1D53932DD03C} Ringtoets.Common.Data.TestUtil Index: Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Integration.Test/WaveImpactAsphaltCoverWaveConditionsCalculationActivityIntegrationTest.cs =================================================================== diff -u -r4438e5f52238284921d2f6505b424804ee2e458c -rf27092df1f897798c4a0b24f6fc91f49c9f294ce --- Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Integration.Test/WaveImpactAsphaltCoverWaveConditionsCalculationActivityIntegrationTest.cs (.../WaveImpactAsphaltCoverWaveConditionsCalculationActivityIntegrationTest.cs) (revision 4438e5f52238284921d2f6505b424804ee2e458c) +++ Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Integration.Test/WaveImpactAsphaltCoverWaveConditionsCalculationActivityIntegrationTest.cs (.../WaveImpactAsphaltCoverWaveConditionsCalculationActivityIntegrationTest.cs) (revision f27092df1f897798c4a0b24f6fc91f49c9f294ce) @@ -31,10 +31,10 @@ using Ringtoets.Common.Data.AssessmentSection; using Ringtoets.Common.Data.DikeProfiles; using Ringtoets.Common.Data.TestUtil; +using Ringtoets.Common.IO.FileImporters; using Ringtoets.HydraRing.Calculation.TestUtil; using Ringtoets.HydraRing.Data; using Ringtoets.Integration.Data; -using Ringtoets.Integration.Plugin.FileImporters; using Ringtoets.Revetment.Data; using Ringtoets.Revetment.Service; using Ringtoets.Revetment.Service.TestUtil;