public async Task <TocLookup> UpdateTocsAsync(TocLookup lookup, CancellationToken token)
{
TrainOperatingCompanyList tocs = null;
try
{
tocs = await _knowledgebase.GetTocs(token).ConfigureAwait(false);
}
catch (Exception e)
{
_logger.Warning(e, "Error loading Knowledgebase Tocs.");
}
if (tocs == null)
{
return(lookup);
}
foreach (var toc in tocs.TrainOperatingCompany)
{
try
{
var t = TocMapper.Map(toc);
lookup.AddIfNotExist(toc.AtocCode, t);
}
catch (Exception e)
{
_logger.Warning(e, "Error loading Knowledgebase Toc: {toc}.", toc.AtocCode);
}
}
return(lookup);
}
private static Timetable.Data TestData()
{
var tocs = new TocLookup(Substitute.For <ILogger>(),
new Dictionary <string, Toc>()
{
{ "VT", new Toc("VT")
{
Name = "Avanti"
} }
});
var data = Substitute.For <ILocationData>();
data.Locations.Returns(TestLocations());
return(new Timetable.Data()
{
Tocs = tocs,
Locations = data,
Darwin = new RealtimeData()
{
CancelReasons = CreateReasons("Cancel"),
LateRunningReasons = CreateReasons("Late"),
Sources = new Dictionary <string, string>()
{
{ "AM01", "Southern Metropolitan" },
{ "at02", "Birmingham" },
{ "si01", "St Pancras" },
}
}
});
}
public async Task <Data> LoadAsync(CancellationToken token)
{
var tocs = new TocLookup(_logger);
Data data = new Data()
{
Archive = _cif.ArchiveFile,
Tocs = tocs,
Locations = await LoadLocationsAsync(tocs, token).ConfigureAwait(false)
};
var enrichRefDataTask = Task.Run(async() =>
{
data = await _darwin.EnrichReferenceDataAsync(data, token).ConfigureAwait(false);
data = await _knowledgebase.EnrichReferenceDataAsync(data, token).ConfigureAwait(false);
});
var cifTask = Task.Run(async() =>
{
data = await _cif.LoadCif(data, token).ConfigureAwait(false);
});
if (Task.WaitAll(new Task[] { enrichRefDataTask, cifTask }, Timeout))
{
return(data);
}
return(new Data());
}
public void CreatesNewToc()
{
var lookup = new TocLookup(Substitute.For <ILogger>(), new Dictionary <string, Toc>());
var toc = lookup.FindOrAdd("VT");
Assert.Equal("VT", toc.Code);
}
public void ReturnsSameTocOnSubsequentCalls()
{
var lookup = new TocLookup(Substitute.For <ILogger>(), new Dictionary <string, Toc>());
var toc1 = lookup.FindOrAdd("VT");
var toc2 = lookup.FindOrAdd("VT");
Assert.Same(toc2, toc1);
}
private static TocLookup CreateTocLookup()
{
var lookup = new TocLookup(Substitute.For <ILogger>(),
new Dictionary <string, Toc>()
{
{ "VT", VT }
});
return(lookup);
}
public TocLookupTest()
{
TestTocs = new List <Toc>();
var lookup = new TocLookup(Substitute.For <ILogger>(), new Dictionary <string, Toc>());
TestTocs.Add(lookup.FindOrAdd("VT"));
TestTocs.Add(lookup.FindOrAdd("GR"));
TestTocs.Add(lookup.FindOrAdd("GW"));
TestLookup = lookup;
}
public void AddOrReplaceAddsNewTocWhenNotExist()
{
var avanti = new Toc("VT", "Avanti");
var lookup = new TocLookup(Substitute.For <ILogger>(), new Dictionary <string, Toc>());
lookup.AddOrReplace("VT", avanti);
var toc = lookup["VT"].Single();
Assert.Same(avanti, toc);
}
public async Task UpdateStations()
{
var tocs = new TocLookup(Substitute.For <ILogger>());
var loader = CreateLoader(knowledgebase: MockKnowledgebase);
var locations = Timetable.Test.Data.TestData.Locations;
locations = await loader.UpdateLocationsWithKnowledgebaseStationsAsync(locations, tocs, CancellationToken.None);
locations.TryGetStation("WAT", out Station waterloo);
Assert.Equal("Waterloo", waterloo.Name);
}
public async Task UpdateTocsDoesNotAddIfExists()
{
var loader = CreateLoader(knowledgebase: MockKnowledgebase);
var tocLookup = new TocLookup(Substitute.For <ILogger>());
tocLookup.AddOrReplace("VT", new Toc("VT", "Already added"));
var tocs = await loader.UpdateTocsAsync(tocLookup, CancellationToken.None);
var vt = tocs["VT"].Single();
Assert.Equal("Already added", vt.Name);
}
public async Task <TocLookup> UpdateTocsAsync(TocLookup tocs, CancellationToken token)
{
var refData = await GetReferenceData(token).ConfigureAwait(false);
foreach (var toc in refData.TocRef)
{
var t = TocMapper.Map(toc);
tocs.AddOrReplace(t.Code, t);
}
return(tocs);
}
public async Task UpdateStationsEvenWhenSet()
{
var tocs = new TocLookup(Substitute.For <ILogger>());
var loader = CreateLoader(knowledgebase: MockKnowledgebase);
var locations = Timetable.Test.Data.TestData.Locations;
locations.TryGetStation("SUR", out var surbiton);
surbiton.Name = "Original";
locations = await loader.UpdateLocationsWithKnowledgebaseStationsAsync(locations, tocs, CancellationToken.None);
Assert.Equal("Surbiton", surbiton.Name);
}
public void ReturnsExistingToc()
{
var vt = new Toc("VT");
var lookup = new TocLookup(Substitute.For <ILogger>(),
new Dictionary <string, Toc>()
{
{ "VT", vt }
});
var toc = lookup.FindOrAdd("VT");
Assert.Same(vt, toc);
}
public void AddOrReplaceReplacesExistingToc()
{
var avanti = new Toc("VT", "Avanti");
var lookup = new TocLookup(Substitute.For <ILogger>(),
new Dictionary <string, Toc>()
{
{ "VT", avanti }
});
var virgin = new Toc("VT", "Virgin");
lookup.AddOrReplace("VT", virgin);
var toc = lookup["VT"].Single();
Assert.Same(virgin, toc);
}
public void IgnoresAddingExistingToc()
{
var avanti = new Toc("VT", "Avanti");
var lookup = new TocLookup(Substitute.For <ILogger>(),
new Dictionary <string, Toc>()
{
{ "VT", avanti }
});
var virgin = new Toc("VT", "Virgin");
lookup.AddIfNotExist("VT", virgin);
var toc = lookup["VT"].Single();
Assert.Same(avanti, toc);
}
internal async Task <ILocationData> LoadLocationsAsync(TocLookup lookup, CancellationToken token)
{
return(await _cif.LoadStationMasterListAsync(token).ConfigureAwait(false));
}
public async Task <ILocationData> UpdateLocationsWithKnowledgebaseStationsAsync(ILocationData locations,
TocLookup lookup, CancellationToken token)
{
var mapper = new StationMapper(lookup);
StationList stations = null;
try
{
stations = await _knowledgebase.GetStations(token).ConfigureAwait(false);
}
catch (Exception e)
{
_logger.Warning(e, "Error loading Knowledgebase Stations.");
}
if (stations == null)
{
return(locations);
}
foreach (var station in stations.Station)
{
try
{
if (locations.TryGetStation(station.CrsCode, out var target))
{
mapper.Update(target, station);
}
}
catch (Exception e)
{
_logger.Warning(e, "Error updating station: {station} with knowledgebase.", station.CrsCode);
}
}
return(locations);
}
internal StationMapper(TocLookup lookup, ILocationData locations, ILogger log)
{
_tocLookup = lookup;
_locations = locations;
_log = log;
}
public async Task <ILocationData> EnrichLocationsAsync(ILocationData locations, TocLookup lookup, CancellationToken token)
{
var refData = await GetReferenceData(token).ConfigureAwait(false);
var mapper = new StationMapper(lookup, locations, _logger);
foreach (var location in refData.LocationRef)
{
try
{
if (ShouldUpdate(location) && locations.TryGetStation(location.crs, out var target))
{
mapper.Update(target, location);
}
else
{
_logger.Debug("Darwin Location not loaded: {tpl} : {name}", location.tpl, location.locname);
}
}
catch (Exception e)
{
_logger.Warning(e, "Error updating station: {station} with Darwin data.", location.crs);
}
}
foreach (var viaRule in refData.Via)
{
try
{
if (locations.TryGetStation(viaRule.at, out var target))
{
mapper.AddRule(target, viaRule);
}
}
catch (Exception e)
{
_logger.Warning(e, "Error updating station: {station} with Via rule.", viaRule.at);
}
}
return(locations);
bool ShouldUpdate(LocationRef location)
{
return(!string.IsNullOrEmpty(location.crs));
}
}
internal StationMapper(TocLookup lookup)
{
_tocLookup = lookup;
}
