public async Task RefreshAsync()
{
var serviceCollection = new ServiceCollection();
var updateService = NSubstitute.Substitute.For <IUpdateService>();
serviceCollection.AddSingleton <IUpdateService>(updateService);
var dumpService = NSubstitute.Substitute.For <IDumpService>();
serviceCollection.AddSingleton <IDumpService>(dumpService);
var serviceProvider = serviceCollection.BuildServiceProvider();
var logger = NSubstitute.Substitute.For <ILogger <DataRefreshService> >();
var documentLoader = new TestDocumentLoader();
var options = NSubstitute.Substitute.For <IOptions <DataRefreshSettings> >();
options.Value.Returns(new DataRefreshSettings());
var dataRefreshService = new DataRefreshService(serviceProvider, logger, documentLoader, options);
var cancellationToken = new CancellationTokenSource().Token;
var dataRefreshStatus = new DataRefreshStatus();
await dataRefreshService.RefreshAsync(dataRefreshStatus, cancellationToken).ConfigureAwait(false);
await updateService.Received().UpdateAsync(
Arg.Is <List <Town> >(towns => this.CheckTowns(towns)),
Arg.Is <List <CollectionEvent> >(events => this.CheckEvents(events)),
Arg.Is <DataRefreshStatus>(status => this.CheckStatus(status))).ConfigureAwait(false);
}
public async Task RefreshAsync(DataRefreshStatus refreshStatus, CancellationToken cancellationToken)
{
var daysSinceLastCheck = (DateTime.Now - refreshStatus.LatestCheck).Days;
var specifiedDays = this.dataRefreshSettings.Value.IntervalInDays;
if (daysSinceLastCheck < specifiedDays)
{
this.logger.LogWarning($"daysSinceLastCheck < specifiedDays ({daysSinceLastCheck} < {specifiedDays})");
return;
}
var towns = await this.LoadTownsAsync(cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
await this.LoadStreetsAsync(towns, cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
await this.LoadStreetDetailsAsync(towns, cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
var events = await this.LoadEventsAsync(towns, cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
var latestLoadedStamp = events.Max(e => e.Stamp);
refreshStatus.LatestCheck = DateTime.Now;
if (refreshStatus.LatestStamp.Equals(latestLoadedStamp))
{
this.logger.LogWarning($"refreshStatus.LatestStamp == latestLoadedStamp ({refreshStatus.LatestStamp} < {latestLoadedStamp})");
using (var scope = this.services.CreateScope())
{
var updateService = scope.ServiceProvider.GetRequiredService <IUpdateService>();
await updateService.UpdateStatusAsync(refreshStatus).ConfigureAwait(false);
}
return;
}
this.logger.LogWarning($"Loaded {towns.Count} towns and {events.Count} events");
refreshStatus.LatestStamp = latestLoadedStamp;
refreshStatus.LatestRefresh = refreshStatus.LatestCheck;
using (var scope = this.services.CreateScope())
{
var updateService = scope.ServiceProvider.GetRequiredService <IUpdateService>();
await updateService.UpdateAsync(towns, events, refreshStatus).ConfigureAwait(false);
var dumpService = scope.ServiceProvider.GetRequiredService <IDumpService>();
await dumpService.DumpAsync(towns, events, refreshStatus).ConfigureAwait(false);
}
this.logger.LogWarning($"Updated {towns.Count} towns and {events.Count} events");
}
public async Task <DataRefreshStatus> GetStatusAsync()
{
var refreshStatus = await this.statusCollection.Find(_ => true).FirstOrDefaultAsync().ConfigureAwait(false);
if (refreshStatus == null)
{
refreshStatus = new DataRefreshStatus
{
LatestStamp = DateTime.MinValue,
LatestRefresh = DateTime.MinValue,
};
await this.statusCollection.InsertOneAsync(refreshStatus).ConfigureAwait(false);
}
return(refreshStatus);
}
private bool CheckStatus(DataRefreshStatus status)
{
return(status.LatestStamp.Equals(DateTimeUtils.Utc(2019, 1, 8)));
}
private static DataContracts.DumpData CreateDumpData(List <Town> towns, List <CollectionEvent> events, DataRefreshStatus refreshStatus)
{
var dumpStatus = new DataContracts.DataRefreshStatus
{
LatestRefresh = refreshStatus.LatestRefresh,
LatestStamp = refreshStatus.LatestStamp,
LatestCheck = refreshStatus.LatestCheck,
};
var dumpData = new DataContracts.DumpData {
RefreshStatus = dumpStatus
};
foreach (var town in towns)
{
var dumpTown = new DataContracts.TownWithStreets {
Id = town.Id, Name = town.Name
};
dumpData.Towns.Add(dumpTown);
foreach (var street in town.Streets)
{
var dumpStreet = new DataContracts.StreetWithEvents {
Id = street.Id, Name = street.Name
};
dumpTown.Streets.Add(dumpStreet);
foreach (var category in street.Categories)
{
var dumpCategory = new DataContracts.Category {
Id = category.Id, Name = category.Name
};
dumpStreet.Categories.Add(dumpCategory);
}
var eventsInStreet = events.Where(e => e.TownId == town.Id && e.StreetId == street.Id);
foreach (var eventInStreet in eventsInStreet)
{
var dumpEvent = new DataContracts.CollectionEvent
{
Id = eventInStreet.Id,
Category = new DataContracts.Category {
Id = eventInStreet.Category.Id, Name = eventInStreet.Category.Name
},
Date = eventInStreet.Start,
Stamp = eventInStreet.Stamp,
};
dumpStreet.Events.Add(dumpEvent);
}
}
}
return(dumpData);
}
public async Task DumpAsync(List <Town> towns, List <CollectionEvent> events, DataRefreshStatus refreshStatus)
{
var dumpData = CreateDumpData(towns, events, refreshStatus);
await this.SaveToStorageAsync(dumpData).ConfigureAwait(false);
}
public async Task UpdateStatusAsync(DataRefreshStatus refreshStatus)
{
await this.statusCollection.ReplaceOneAsync(status => status.Id == refreshStatus.Id, refreshStatus).ConfigureAwait(false);
}
/// <inheritdoc />
public async Task UpdateAsync(List <Town> towns, List <CollectionEvent> events, DataRefreshStatus refreshStatus)
{
await this.Database.DropCollectionAsync(MongoConnectionSettings.TownsCollectionName).ConfigureAwait(false);
await this.towns.InsertManyAsync(towns).ConfigureAwait(false);
await this.Database.DropCollectionAsync(MongoConnectionSettings.EventsCollectionName).ConfigureAwait(false);
await this.CreateEventIndex().ConfigureAwait(false);
await this.events.InsertManyAsync(events).ConfigureAwait(false);
await this.statusCollection.ReplaceOneAsync(status => status.Id == refreshStatus.Id, refreshStatus).ConfigureAwait(false);
}
