public async Task <ListResponse <TelemetryReportData> > GetForDeviceTypeAsync(DeviceRepository deviceRepo, string deviceTypeId, string recordType, ListRequest request, EntityHeader org, EntityHeader user)
{
if (deviceRepo.Instance == null)
{
return(ListResponse <TelemetryReportData> .FromError("No associated instance."));
}
await base.AuthorizeOrgAccessAsync(user, org, typeof(TelemetryReportData));
var instance = await _deploymentInstanceRepo.GetInstanceAsync(deviceRepo.Instance.Id);
if (instance.LogStorage.Value == LogStorage.Local)
{
var proxy = _proxyFactory.Create <ITelemetryService>(new ProxySettings {
OrganizationId = org.Id, InstanceId = deviceRepo.Instance.Id
});
return(await proxy.GetForDeviceTypeAsync(deviceTypeId, recordType, request));
}
else
{
return(await _telemetryService.GetForDeviceTypeAsync(deviceTypeId, recordType, request));
}
}
public async Task <LagoVista.Core.Models.UIMetaData.ListResponse <DataStreamResult> > GetItemsAsync(string deviceId, LagoVista.Core.Models.UIMetaData.ListRequest request)
{
//TODO: Next chunk of code sux, likely much better way but will probably want to build a more robust filtering system at some point.
ISearchResponse <Dictionary <string, object> > result = null;
if (String.IsNullOrEmpty(request.StartDate) && String.IsNullOrEmpty(request.EndDate))
{
result = await _client.SearchAsync <Dictionary <string, object> >(src => src.From(0)
.Index(_stream.ESIndexName)
.Type(_stream.ESTypeName)
.From(request.PageIndex *request.PageSize)
.Size(request.PageSize)
.Sort(srt => srt.Descending(new Field("sortOrder"))));
}
else if (String.IsNullOrEmpty(request.StartDate))
{
var endTicks = request.EndDate.ToDateTime().Ticks;
result = await _client.SearchAsync <Dictionary <string, object> >(src => src.From(0)
.Index(_stream.ESIndexName)
.Type(_stream.ESTypeName)
.Query(qry =>
qry.Range(rng => rng
.Field("sortOrder")
.LessThanOrEquals(endTicks)
))
.From(request.PageIndex *request.PageSize)
.Size(request.PageSize)
.Sort(srt => srt.Descending(new Field("sortOrder"))));
}
else if (String.IsNullOrEmpty(request.EndDate))
{
var startTicks = request.StartDate.ToDateTime().Ticks;
result = await _client.SearchAsync <Dictionary <string, object> >(src => src.From(0)
.Index(_stream.ESIndexName)
.Type(_stream.ESTypeName)
.Query(qry =>
qry.Range(rng => rng
.Field("sortOrder")
.GreaterThanOrEquals(startTicks)
))
.From(request.PageIndex *request.PageSize)
.Size(request.PageSize)
.Sort(srt => srt.Descending(new Field("sortOrder"))));
}
else
{
var startTicks = request.StartDate.ToDateTime().Ticks;
var endTicks = request.EndDate.ToDateTime().Ticks;
result = await _client.SearchAsync <Dictionary <string, object> >(src => src.From(0)
.Index(_stream.ESIndexName)
.Type(_stream.ESTypeName)
.Query(qry =>
qry.Range(rng => rng
.Field("sortOrder")
.GreaterThanOrEquals(startTicks)
.LessThanOrEquals(endTicks)
))
.From(request.PageIndex *request.PageSize)
.Size(request.PageSize)
.Sort(srt => srt.Descending(new Field("sortOrder"))));
}
if (result.IsValid)
{
var records = new List <DataStreamResult>();
foreach (var record in result.Documents)
{
records.Add(new DataStreamResult()
{
/* Newtonsoft assumes the value is date time for something that looks like a date, time this dual conversion gets our standard ISO8601 date string */
Timestamp = record[_stream.TimeStampFieldName].ToString().ToDateTime().ToJSONString(),
Fields = record
});
}
var response = Core.Models.UIMetaData.ListResponse <DataStreamResult> .Create(records);
response.PageIndex = request.PageIndex;
response.PageSize = records.Count;
response.HasMoreRecords = response.PageSize == request.PageSize;
return(response);
}
else
{
if (result.OriginalException != null)
{
return(ListResponse <DataStreamResult> .FromError(result.OriginalException.Message));
}
else
{
return(ListResponse <DataStreamResult> .FromError(result.DebugInformation));
}
}
}
public async Task <ListResponse <DataStreamResult> > GetItemsAsync(string deviceId, LagoVista.Core.Models.UIMetaData.ListRequest request)
{
var filter = TableQuery.GenerateFilterCondition(nameof(Models.DataStreamTSEntity.PartitionKey), QueryComparisons.Equal, deviceId);
var dateFilter = String.Empty;
/* FYI - less than and greater than are reversed because the data is inserted wiht row keys in descending order */
if (!String.IsNullOrEmpty(request.StartDate) && !String.IsNullOrEmpty(request.EndDate))
{
var startRowKey = request.StartDate.ToDateTime().ToInverseTicksRowKey();
var endRowKey = request.EndDate.ToDateTime().ToInverseTicksRowKey();
dateFilter = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition(nameof(Models.DataStreamTSEntity.RowKey), QueryComparisons.LessThanOrEqual, startRowKey.ToString()),
TableOperators.And,
TableQuery.GenerateFilterCondition(nameof(Models.DataStreamTSEntity.RowKey), QueryComparisons.GreaterThanOrEqual, endRowKey.ToString())
);
}
else if (String.IsNullOrEmpty(request.StartDate) && !String.IsNullOrEmpty(request.EndDate))
{
var endRowKey = request.EndDate.ToDateTime().ToInverseTicksRowKey();
dateFilter = TableQuery.GenerateFilterCondition(nameof(Models.DataStreamTSEntity.RowKey), QueryComparisons.GreaterThanOrEqual, endRowKey.ToString());
}
else if (String.IsNullOrEmpty(request.EndDate) && !String.IsNullOrEmpty(request.StartDate))
{
var startRowKey = request.StartDate.ToDateTime().ToInverseTicksRowKey();
dateFilter = TableQuery.GenerateFilterCondition(nameof(Models.DataStreamTSEntity.RowKey), QueryComparisons.LessThanOrEqual, startRowKey.ToString());
}
if (!String.IsNullOrEmpty(dateFilter))
{
filter = TableQuery.CombineFilters(filter, TableOperators.And, dateFilter);
}
var query = new TableQuery <DynamicTableEntity>().Where(filter).Take(request.PageSize);
var numberRetries = 5;
var retryCount = 0;
var completed = false;
while (retryCount++ < numberRetries && !completed)
{
try
{
TableQuerySegment <DynamicTableEntity> results;
if (!String.IsNullOrEmpty(request.NextPartitionKey) && !String.IsNullOrEmpty(request.NextRowKey))
{
var token = new TableContinuationToken()
{
NextPartitionKey = request.NextPartitionKey,
NextRowKey = request.NextRowKey
};
results = await _cloudTable.ExecuteQuerySegmentedAsync <DynamicTableEntity>(query, token);
}
else
{
results = await _cloudTable.ExecuteQuerySegmentedAsync <DynamicTableEntity>(query, new TableContinuationToken());
}
var listResponse = new ListResponse <DataStreamResult>
{
NextRowKey = results.ContinuationToken?.NextRowKey,
NextPartitionKey = results.ContinuationToken?.NextPartitionKey,
PageSize = results.Count(),
HasMoreRecords = results.ContinuationToken != null,
};
var resultSet = new List <DataStreamResult>();
foreach (var item in results)
{
var result = new DataStreamResult();
foreach (var property in item.Properties)
{
result.Add(property.Key, property.Value.PropertyAsObject);
}
switch (_stream.DateStorageFormat.Value)
{
case DateStorageFormats.Epoch:
long epoch = Convert.ToInt64(item.Properties[_stream.TimestampFieldName]);
result.Timestamp = DateTimeOffset.FromUnixTimeSeconds(epoch).DateTime.ToJSONString();
break;
case DateStorageFormats.ISO8601:
result.Timestamp = item.Properties[_stream.TimestampFieldName].StringValue.ToDateTime().ToJSONString();
break;
}
resultSet.Add(result);
}
listResponse.Model = resultSet;
return(listResponse);
}
catch (Exception ex)
{
if (retryCount == numberRetries)
{
_logger.AddException("AzureTableStorageConnector_GetItemsAsync", ex);
return(ListResponse <DataStreamResult> .FromError(ex.Message));
}
else
{
_logger.AddCustomEvent(LagoVista.Core.PlatformSupport.LogLevel.Warning, "AzureTableStorageConnector_GetItemsAsync", "", ex.Message.ToKVP("exceptionMessage"), ex.GetType().Name.ToKVP("exceptionType"), retryCount.ToString().ToKVP("retryCount"));
}
await Task.Delay(retryCount * 250);
}
finally
{
}
}
_logger.AddException("AzureTableStorageConnector_GetItemsAsync", new Exception("Unexpected end of method"));
return(ListResponse <DataStreamResult> .FromError("Unexpected end of method."));
}
