public async Task <IEnumerable <SpeedEntry> > FilterAsync(ClosedPeriod period, Func <SpeedEntry, bool> predicate) // todo: being killed when period.from --> dateTime.min and period.to --> dateTime.max
{
await Task.CompletedTask;
var timer = Stopwatch.StartNew();
var fileNames = GetOverrlappedClusterFileNames(period);
var filePaths = fileNames.Select(n => Path.Combine(Directory, n));
// var existingPaths = filePaths.Where(p => File.Exists(p));
var entries = new ConcurrentBag <SpeedEntry>();
var partitioner = Partitioner.Create(filePaths);
Parallel.ForEach(partitioner, p =>
//foreach (var p in filePaths)
{
if (File.Exists(p))
{
using (var file = new FileStream(p, FileMode.Open, FileAccess.Read))
{
var bytes = new byte[file.Length];
file.Read(bytes, 0, bytes.Length);
var json = Encoding.GetString(bytes);
var jsonEntries = JsonConvert.DeserializeObject <IEnumerable <SpeedEntry> >(json);
foreach (var entry in jsonEntries)
{
entries.Add(entry);
}
}
}
}
);
var result = entries.Where(predicate);
StopTimer(timer);
return(result);
}
public HttpResponseMessage ClosePeriod(HttpRequestMessage request, [FromBody] ClosedPeriod closedPeriodModel)
{
return(GetHttpResponse(request, () =>
{
var closedPeriod = _ExtractionProcessService.ClosePeriod(closedPeriodModel);
return request.CreateResponse <ClosedPeriod>(HttpStatusCode.OK, closedPeriod);
}));
}
private IEnumerable <string> GetOverrlappedClusterFileNames(ClosedPeriod period)
{
var result = new List <string>();
var nowTicks = period.From.Ticks - period.From.Ticks % ClusterSize;
while (nowTicks < period.To.Ticks)
{
result.Add(nowTicks + JsonExtension);
nowTicks += ClusterSize;
}
return(result);
}
public HttpResponseMessage GetClosedPeriod(HttpRequestMessage request, int closedPeriodId)
{
return(GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;
ClosedPeriod closedPeriod = _ExtractionProcessService.GetClosedPeriod(closedPeriodId);
// notice no need to create a seperate model object since ClosedPeriod entity will do just fine
response = request.CreateResponse <ClosedPeriod>(HttpStatusCode.OK, closedPeriod);
return response;
}));
}
public async Task <MinMaxSpeedEntryDto> GetMinMaxSpeedEntriesAsync(ClosedPeriod period)
{
using (var uow = UnitOfWorkFactory.Build())
{
var now = DateTime.UtcNow;
var entries = await uow.SpeedEntryRepository
.FilterAsync(
period,
se => true);
var result = new MinMaxSpeedEntryDto()
{
Min = Mapper.Map <SpeedEntryDto>(entries.Aggregate((min, e) => e.Speed < min.Speed ? e : min)),
Max = Mapper.Map <SpeedEntryDto>(entries.Aggregate((max, e) => e.Speed > max.Speed ? e : max))
};
return(result);
}
}
public HttpResponseMessage DeleteClosedPeriod(HttpRequestMessage request, [FromBody] int closedPeriodId)
{
return(GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;
// not that calling the WCF service here will authenticate access to the data
ClosedPeriod closedPeriod = _ExtractionProcessService.GetClosedPeriod(closedPeriodId);
if (closedPeriod != null)
{
_ExtractionProcessService.DeleteClosedPeriod(closedPeriodId);
response = request.CreateResponse(HttpStatusCode.OK);
}
else
{
response = request.CreateErrorResponse(HttpStatusCode.NotFound, "No closedPeriod found under that ID.");
}
return response;
}));
}
public ClosedPeriod ClosePeriod(ClosedPeriod closedPeriod)
{
return(Channel.ClosePeriod(closedPeriod));
}
public ClosedPeriod UpdateClosedPeriod(ClosedPeriod closedPeriod)
{
return(Channel.UpdateClosedPeriod(closedPeriod));
}
public async Task <ActionResult <MinMaxSpeedEntryDto> > GetMinMaxSpeedEntriesAsync([FromQuery] ClosedPeriod period)
{
var result = await _speedControllerService.GetMinMaxSpeedEntriesAsync(period);
return(Ok(result));
}
