/// <summary>
/// Requests the feed data, populates feedParams data collections
/// </summary>
/// <param name="feedParams">Contains latest data token and collections to populate during this call.</param>
/// <returns><see cref="FeedResultData"/></returns>
public async Task <FeedResultData> GetAsync(FeedParameters feedParams)
{
FeedResultData feedResults = new FeedResultData(new List <LogRecord>(), new List <StatusData>(), new List <FaultData>(), new List <Trip>(), new List <ExceptionEvent>());
try
{
if (DateTime.UtcNow > repopulateCaches)
{
await PopulateCachesAsync();
repopulateCaches = DateTime.UtcNow.AddHours(RepopulatePeroid);
}
FeedResult <LogRecord> feedLogRecordData = await MakeFeedCallAsync <LogRecord>(feedParams.LastGpsDataToken);
FeedResult <StatusData> feedStatusData = await MakeFeedCallAsync <StatusData>(feedParams.LastStatusDataToken);
FeedResult <FaultData> feedFaultData = await MakeFeedCallAsync <FaultData>(feedParams.LastFaultDataToken);
FeedResult <Trip> feedTripData = await MakeFeedCallAsync <Trip>(feedParams.LastTripToken);
FeedResult <ExceptionEvent> feedExceptionData = await MakeFeedCallAsync <ExceptionEvent>(feedParams.LastExceptionToken);
feedParams.LastGpsDataToken = feedLogRecordData.ToVersion;
foreach (LogRecord log in feedLogRecordData.Data)
{
// Populate relevant LogRecord fields.
log.Device = await GetDeviceAsync(log.Device);
feedResults.GpsRecords.Add(log);
}
feedParams.LastStatusDataToken = feedStatusData.ToVersion;
foreach (StatusData log in feedStatusData.Data)
{
// Populate relevant StatusData fields.
log.Device = await GetDeviceAsync(log.Device);
log.Diagnostic = await GetDiagnosticAsync(log.Diagnostic);
feedResults.StatusData.Add(log);
}
feedParams.LastFaultDataToken = feedFaultData.ToVersion;
foreach (FaultData log in feedFaultData.Data)
{
// Populate relevant FaultData fields.
log.Device = await GetDeviceAsync(log.Device);
log.Diagnostic = await GetDiagnosticAsync(log.Diagnostic);
log.Controller = await GetControllerAsync(log.Controller);
log.FailureMode = await GetFailureModeAsync(log.FailureMode);
feedResults.FaultData.Add(log);
}
feedParams.LastTripToken = feedTripData.ToVersion;
foreach (Trip trip in feedTripData.Data)
{
trip.Device = await GetDeviceAsync(trip.Device);
trip.Driver = await GetDriver(trip.Driver);
feedResults.Trips.Add(trip);
}
feedParams.LastExceptionToken = feedExceptionData.ToVersion;
foreach (ExceptionEvent exceptionEvent in feedExceptionData.Data)
{
exceptionEvent.Device = await GetDeviceAsync(exceptionEvent.Device);
exceptionEvent.Driver = await GetDriver(exceptionEvent.Driver);
exceptionEvent.Diagnostic = await GetDiagnosticAsync(exceptionEvent.Diagnostic);
exceptionEvent.Rule = await GetRuleAsync(exceptionEvent.Rule);
feedResults.ExceptionEvents.Add(exceptionEvent);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
if (e is HttpRequestException)
{
await Task.Delay(5000);
}
if (e is DbUnavailableException)
{
await Task.Delay(TimeSpan.FromMinutes(5));
}
}
return(feedResults);
}
/// <summary>
/// Initializes a new instance of the <see cref="DatabaseWorker" /> class.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="password">The password.</param>
/// <param name="database">The database.</param>
/// <param name="server">The server.</param>
/// <param name="gpsToken">The GPS token.</param>
/// <param name="statusToken">The status token.</param>
/// <param name="faultToken">The fault token.</param>
/// <param name="tripToken">The trip token.</param>
/// <param name="exceptionToken">The exception token.</param>
/// <param name="path">The path.</param>
public DatabaseWorker(string user, string password, string database, string server, long?gpsToken, long?statusToken, long?faultToken, long?tripToken, long?exceptionToken, string path)
: base(path)
{
feedParameters = new FeedParameters(gpsToken, statusToken, faultToken, tripToken, exceptionToken);
feedService = new FeedProcessor(server, database, user, password);
}
