private void AddHydraulicBoundaryDatabaseToDataModel(ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase,
ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase,
IEnumerable <long> excludedLocationIds)
{
NotifyProgress(RiskeerCommonIOResources.Importer_ProgressText_Adding_imported_data_to_AssessmentSection, 4, numberOfSteps);
changedObservables.AddRange(updateHandler.Update(ImportTarget, readHydraulicBoundaryDatabase, readHydraulicLocationConfigurationDatabase,
excludedLocationIds, FilePath, GetHlcdFilePath()));
}
protected override bool OnImport()
{
ReadResult <ReadHydraulicBoundaryDatabase> readHydraulicBoundaryDatabaseResult = ReadHydraulicBoundaryDatabase();
if (readHydraulicBoundaryDatabaseResult.CriticalErrorOccurred || Canceled)
{
return(false);
}
ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase = readHydraulicBoundaryDatabaseResult.Items.Single();
InquireConfirmation(readHydraulicBoundaryDatabase);
if (Canceled)
{
return(false);
}
string hlcdFilePath = GetHlcdFilePath();
ReadResult <ReadHydraulicLocationConfigurationDatabase> readHydraulicLocationConfigurationDatabaseResult = ReadHydraulicLocationConfigurationDatabase(
hlcdFilePath, readHydraulicBoundaryDatabase.TrackId);
if (readHydraulicLocationConfigurationDatabaseResult.CriticalErrorOccurred || Canceled)
{
return(false);
}
ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase = readHydraulicLocationConfigurationDatabaseResult.Items.Single();
IEnumerable <ReadHydraulicLocationConfigurationDatabaseSettings> hydraulicLocationConfigurationDatabaseSettings =
readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings;
if (hydraulicLocationConfigurationDatabaseSettings != null && hydraulicLocationConfigurationDatabaseSettings.Count() != 1)
{
Log.Error(BuildErrorMessage(hlcdFilePath, Resources.HydraulicBoundaryDatabaseImporter_HLCD_Invalid_number_of_ScenarioInformation_entries));
return(false);
}
if (readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure &&
!File.Exists(HydraulicBoundaryDatabaseHelper.GetPreprocessorClosureFilePath(hlcdFilePath)))
{
Log.Error(BuildErrorMessage(hlcdFilePath, Resources.HydraulicBoundaryDatabaseImporter_PreprocessorClosure_sqlite_Not_Found));
return(false);
}
ReadResult <IEnumerable <long> > readExcludedLocationsResult = ReadExcludedLocations();
if (readExcludedLocationsResult.CriticalErrorOccurred || Canceled)
{
return(false);
}
AddHydraulicBoundaryDatabaseToDataModel(readHydraulicBoundaryDatabase, readHydraulicLocationConfigurationDatabase,
readExcludedLocationsResult.Items.Single());
return(true);
}
public void Read_ValidFileWithUsePreprocessClosureColumn_ExpectedValues(int trackId, bool expectedUsePreprocessorClosure)
{
string dbFile = Path.Combine(testDataPath, "hlcdWithPreprocessorClosureColumn.sqlite");
using (var hydraulicBoundaryDatabaseReader = new HydraulicLocationConfigurationDatabaseReader(dbFile))
{
// Call
ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase = hydraulicBoundaryDatabaseReader.Read(trackId);
// Assert
Assert.AreEqual(expectedUsePreprocessorClosure, readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure);
}
}
public void Constructor_ExpectedValues()
{
// Setup
IEnumerable <ReadHydraulicLocationMapping> locationIdMappings = Enumerable.Empty <ReadHydraulicLocationMapping>();
IEnumerable <ReadHydraulicLocationConfigurationDatabaseSettings> databaseSettings = Enumerable.Empty <ReadHydraulicLocationConfigurationDatabaseSettings>();
bool usePreprocessorClosure = new Random(21).NextBoolean();
// Call
var readDatabase = new ReadHydraulicLocationConfigurationDatabase(locationIdMappings, databaseSettings, usePreprocessorClosure);
// Assert
Assert.AreSame(locationIdMappings, readDatabase.LocationIdMappings);
Assert.AreSame(databaseSettings, readDatabase.ReadHydraulicLocationConfigurationDatabaseSettings);
Assert.AreEqual(usePreprocessorClosure, readDatabase.UsePreprocessorClosure);
}
public void Read_ValidFileWithoutScenarioInformation_ExpectedValues(int trackId, int hrdLocationId, int expectedLocationId)
{
// Setup
string dbFile = Path.Combine(testDataPath, "hlcdWithoutScenarioInformation.sqlite");
using (var hydraulicBoundaryDatabaseReader = new HydraulicLocationConfigurationDatabaseReader(dbFile))
{
// Call
ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase = hydraulicBoundaryDatabaseReader.Read(trackId);
// Assert
long actualLocationId = readHydraulicLocationConfigurationDatabase.LocationIdMappings.Where(m => m.HrdLocationId == hrdLocationId)
.Select(m => m.HlcdLocationId)
.SingleOrDefault();
Assert.AreEqual(expectedLocationId, actualLocationId);
Assert.IsFalse(readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure);
Assert.IsNull(readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings);
}
}
public void Read_AmbiguousLocations_ReturnsFirstLocationIdAndLogsWarning()
{
// Setup
string dbFile = Path.Combine(testDataPath, "ambigousLocation.sqlite");
const int trackId = 11;
const int hrdLocationId = 1;
ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase = null;
using (var hydraulicBoundaryDatabaseReader = new HydraulicLocationConfigurationDatabaseReader(dbFile))
{
// Call
Action call = () => readHydraulicLocationConfigurationDatabase = hydraulicBoundaryDatabaseReader.Read(trackId);
// Assert
const int expectedLocationId = 1800001;
const string expectedMessage = "Er zijn meerdere resultaten gevonden, wat niet voor zou mogen komen. Neem contact op met de leverancier. Het eerste resultaat zal worden gebruikt.";
TestHelper.AssertLogMessageIsGenerated(call, expectedMessage, 1);
long actualLocationId = readHydraulicLocationConfigurationDatabase.LocationIdMappings.Where(m => m.HrdLocationId == hrdLocationId)
.Select(m => m.HlcdLocationId)
.Single();
Assert.AreEqual(expectedLocationId, actualLocationId);
}
}
protected override bool OnImport()
{
InquireConfirmation();
if (Canceled)
{
return(false);
}
if (Path.GetDirectoryName(FilePath) != Path.GetDirectoryName(hydraulicBoundaryDatabase.FilePath))
{
Log.Error(BuildErrorMessage(FilePath, Resources.HydraulicLocationConfigurationDatabaseImporter_HLCD_not_in_same_folder_as_HRD));
return(false);
}
ReadResult <long> readTrackIdResult = ReadTrackId();
if (readTrackIdResult.CriticalErrorOccurred || Canceled)
{
return(false);
}
ReadResult <ReadHydraulicLocationConfigurationDatabase> readHydraulicLocationConfigurationDatabaseResult = ReadHydraulicLocationConfigurationDatabase(
readTrackIdResult.Items.Single());
if (readHydraulicLocationConfigurationDatabaseResult.CriticalErrorOccurred || Canceled)
{
return(false);
}
ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase = readHydraulicLocationConfigurationDatabaseResult.Items.Single();
if (readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings != null &&
readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings.Count() != 1)
{
Log.Error(BuildErrorMessage(FilePath, Resources.HydraulicLocationConfigurationDatabaseImporter_Invalid_number_of_ScenarioInformation_entries));
return(false);
}
if (readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure &&
!File.Exists(HydraulicBoundaryDatabaseHelper.GetPreprocessorClosureFilePath(FilePath)))
{
Log.Error(BuildErrorMessage(FilePath, Resources.HydraulicBoundaryDatabaseImporter_PreprocessorClosure_sqlite_Not_Found));
return(false);
}
IEnumerable <long> locationIds = hydraulicBoundaryDatabase.Locations.Select(l => l.Id);
long[] intersect = locationIds.Intersect(readHydraulicLocationConfigurationDatabase.LocationIdMappings.Select(l => l.HlcdLocationId))
.ToArray();
if (intersect.Length != locationIds.Count())
{
Log.Error(BuildErrorMessage(FilePath, Resources.HydraulicLocationConfigurationDatabaseImporter_Invalid_locationIds));
return(false);
}
AddHydraulicLocationConfigurationSettingsToDataModel(
readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings?.Single(),
readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure);
return(true);
}
public void Read_ValidFileWithScenarioInformation_ExpectedValues(int trackId, int hrdLocationId, int expectedLocationId)
{
// Setup
string dbFile = Path.Combine(testDataPath, "hlcdWithScenarioInformation.sqlite");
using (var hydraulicBoundaryDatabaseReader = new HydraulicLocationConfigurationDatabaseReader(dbFile))
{
// Call
ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase = hydraulicBoundaryDatabaseReader.Read(trackId);
// Assert
long actualLocationId = readHydraulicLocationConfigurationDatabase.LocationIdMappings.Where(m => m.HrdLocationId == hrdLocationId)
.Select(m => m.HlcdLocationId)
.SingleOrDefault();
Assert.AreEqual(expectedLocationId, actualLocationId);
Assert.IsFalse(readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure);
IEnumerable <ReadHydraulicLocationConfigurationDatabaseSettings> readHydraulicLocationConfigurationDatabaseSettings =
readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings;
Assert.AreEqual(2, readHydraulicLocationConfigurationDatabaseSettings.Count());
CollectionAssert.AreEqual(new[]
{
"ScenarioName WBI2017",
"ScenarioName WBI2018"
}, readHydraulicLocationConfigurationDatabaseSettings.Select(s => s.ScenarioName));
CollectionAssert.AreEqual(new[]
{
2023,
2024
}, readHydraulicLocationConfigurationDatabaseSettings.Select(s => s.Year));
CollectionAssert.AreEqual(new[]
{
"Scope WBI2017",
"Scope WBI2018"
}, readHydraulicLocationConfigurationDatabaseSettings.Select(s => s.Scope));
CollectionAssert.AreEqual(new[]
{
"SeaLevel WBI2017",
"SeaLevel WBI2018"
}, readHydraulicLocationConfigurationDatabaseSettings.Select(s => s.SeaLevel));
CollectionAssert.AreEqual(new[]
{
"RiverDischarge WBI2017",
"RiverDischarge WBI2018"
}, readHydraulicLocationConfigurationDatabaseSettings.Select(s => s.RiverDischarge));
CollectionAssert.AreEqual(new[]
{
"LakeLevel WBI2017",
"LakeLevel WBI2018"
}, readHydraulicLocationConfigurationDatabaseSettings.Select(s => s.LakeLevel));
CollectionAssert.AreEqual(new[]
{
"WindDirection WBI2017",
"WindDirection WBI2018"
}, readHydraulicLocationConfigurationDatabaseSettings.Select(s => s.WindDirection));
CollectionAssert.AreEqual(new[]
{
"WindSpeed WBI2017",
"WindSpeed WBI2018"
}, readHydraulicLocationConfigurationDatabaseSettings.Select(s => s.WindSpeed));
CollectionAssert.AreEqual(new[]
{
"Comment WBI2017",
"Comment WBI2018"
}, readHydraulicLocationConfigurationDatabaseSettings.Select(s => s.Comment));
}
}
public IEnumerable <IObservable> Update(HydraulicBoundaryDatabase hydraulicBoundaryDatabase, ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase,
ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase,
IEnumerable <long> excludedLocationIds, string hydraulicBoundaryDatabaseFilePath, string hlcdFilePath)
{
if (hydraulicBoundaryDatabase == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryDatabase));
}
if (readHydraulicBoundaryDatabase == null)
{
throw new ArgumentNullException(nameof(readHydraulicBoundaryDatabase));
}
if (readHydraulicLocationConfigurationDatabase == null)
{
throw new ArgumentNullException(nameof(readHydraulicLocationConfigurationDatabase));
}
if (excludedLocationIds == null)
{
throw new ArgumentNullException(nameof(excludedLocationIds));
}
if (hydraulicBoundaryDatabaseFilePath == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryDatabaseFilePath));
}
if (hlcdFilePath == null)
{
throw new ArgumentNullException(nameof(hlcdFilePath));
}
if (!IsValidReadHydraulicLocationConfigurationDatabase(readHydraulicLocationConfigurationDatabase))
{
string errorMessage = $"{nameof(readHydraulicLocationConfigurationDatabase)} must be null or contain exactly one item for " +
"the collection of hydraulic location configuration database settings.";
throw new ArgumentException(errorMessage);
}
var changedObjects = new List <IObservable>();
updateLocations = !hydraulicBoundaryDatabase.IsLinked() || hydraulicBoundaryDatabase.Version != readHydraulicBoundaryDatabase.Version;
if (updateLocations)
{
hydraulicBoundaryDatabase.FilePath = hydraulicBoundaryDatabaseFilePath;
hydraulicBoundaryDatabase.Version = readHydraulicBoundaryDatabase.Version;
SetLocations(hydraulicBoundaryDatabase, readHydraulicBoundaryDatabase.Locations,
readHydraulicLocationConfigurationDatabase.LocationIdMappings,
excludedLocationIds.ToArray());
assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryDatabase.Locations);
duneLocationsReplacementHandler.Replace(hydraulicBoundaryDatabase.Locations);
changedObjects.AddRange(GetLocationsAndCalculationsObservables(hydraulicBoundaryDatabase));
changedObjects.AddRange(RiskeerDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(assessmentSection));
}
else
{
if (hydraulicBoundaryDatabase.FilePath != hydraulicBoundaryDatabaseFilePath)
{
hydraulicBoundaryDatabase.FilePath = hydraulicBoundaryDatabaseFilePath;
}
}
HydraulicLocationConfigurationSettingsUpdateHelper.SetHydraulicLocationConfigurationSettings(
hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings,
readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings?.Single(),
readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure,
hlcdFilePath);
return(changedObjects);
}
private static bool IsValidReadHydraulicLocationConfigurationDatabase(ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase)
{
return(readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings == null ||
readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings.Count() == 1);
}
