public async Task <TelemetryInfoTable> GetPivotTableData(TelemetryItemTypes type, Guid telemetryKey)
{
Program program = await this.portalContext.Programs.FirstOrDefaultAsync(x => x.TelemetryKey == telemetryKey).ConfigureAwait(false);
if (program == null)
{
throw new ArgumentException($"Program with key {telemetryKey} does not exist");
}
List <TelemetryDetail> details = program.GetTelemetryDetails(this.telemetryContext, type).ToList();
List <TelemetryPivotTableRow> rows = new List <TelemetryPivotTableRow>();
foreach (TelemetryDetail detail in details)
{
List <TelemetryUnit> units = detail.GetTelemetryUnits().ToList();
if (units.Any())
{
foreach (TelemetryUnit detailTelemetryUnit in units.Where(x => x.UnitType == TelemetryUnit.UnitTypes.Property))
{
TelemetryPivotTableRow row = new TelemetryPivotTableRow(detail)
{
PropertyValue = detailTelemetryUnit.ValueString,
Key = detailTelemetryUnit.Key,
};
rows.Add(row);
}
foreach (TelemetryUnit detailTelemetryUnit in units.Where(x => x.UnitType == TelemetryUnit.UnitTypes.Metric))
{
TelemetryPivotTableRow row = new TelemetryPivotTableRow(detail)
{
MetricValue = detailTelemetryUnit.ValueDouble,
Key = detailTelemetryUnit.Key,
};
rows.Add(row);
}
}
else
{
TelemetryPivotTableRow row = new TelemetryPivotTableRow(detail);
rows.Add(row);
}
}
TelemetryInfoTableHeader header = new TelemetryInfoTableHeader();
return(new TelemetryInfoTable {
Header = header, Rows = rows
});
}
public async Task <JsonResult> GetPivotTableData(TelemetryItemTypes type, Guid telemetryKey, DateTime startDate, DateTime endDate)
{
var sw = Stopwatch.StartNew();
TelemetryInfoTable result = await this.Work.GetPivotTableData(type, telemetryKey, startDate, endDate).ConfigureAwait(false);
sw.Stop();
this.telemetryClient.TrackEvent("GetPivotTableData", new Dictionary <string, string>()
{
{ "TelemetryKey", telemetryKey.ToString() },
{ "StartDate", startDate.ToString("o") },
{ "EndDate", endDate.ToString("o") },
{ "Elapsed", sw.ElapsedMilliseconds.ToString() },
{ "TimeSpan", (endDate - startDate).TotalDays.ToString(CultureInfo.InvariantCulture) },
});
return(this.Json(result, JsonRequestBehavior.AllowGet));
}
public static IQueryable <TelemetryDetail> GetTelemetryDetails(this Program program, TelimenaTelemetryContext context,
TelemetryItemTypes type, DateTime startDate, DateTime endDate)
{
switch (type)
{
case TelemetryItemTypes.View:
return(context.ViewTelemetryDetails.Where(
x => x.TelemetrySummary.View.ProgramId == program.Id &&
x.Timestamp >= startDate && x.Timestamp <= endDate));
case TelemetryItemTypes.Event:
return(context.EventTelemetryDetails.Where(x => x.TelemetrySummary.Event.ProgramId == program.Id &&
x.Timestamp >= startDate && x.Timestamp <= endDate));
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public async Task <IEnumerable <RawTelemetryUnit> > GetRawData(Guid telemetryKey, TelemetryItemTypes type, DateTime startDate, DateTime endDate)
{
Program program = await this.portalContext.Programs.FirstOrDefaultAsync(x => x.TelemetryKey == telemetryKey).ConfigureAwait(false);
if (program == null)
{
throw new ArgumentException($"Program with key {telemetryKey} does not exist");
}
DataSet set;
if (type == TelemetryItemTypes.Event)
{
set = await this.ExecuteStoredProcedure(program,
StoredProcedureNames.p_GetEventTelemetryUnits
, startDate
, endDate
).ConfigureAwait(false);
}
else if (type == TelemetryItemTypes.View)
{
set = await this.ExecuteStoredProcedure(program,
StoredProcedureNames.p_GetViewTelemetryUnits
, startDate
, endDate
).ConfigureAwait(false);
}
else
{
throw new ArgumentException($"{type} is not allowed as raw data type export." +
$"Supported types: {TelemetryItemTypes.Event}, {TelemetryItemTypes.View}");
}
List <RawTelemetryUnit> list = new List <RawTelemetryUnit>();
DataRowCollection rows = set.Tables[0].Rows;
foreach (DataRow row in rows)
{
RawTelemetryUnit data = new RawTelemetryUnit()
{
ComponentName = row["EntryKey"] as string,
Timestamp = (DateTimeOffset)row["Timestamp"],
User = row["UserIdentifier"] as string,
Sequence = row["Sequence"] as string,
Key = row["Key"] as string,
PropertyValue = row["ValueString"] as string,
MetricValue = (double)row["ValueDouble"],
};
list.Add(data);
}
return(list);
}
public async Task <UsageDataTableResult> GetProgramUsageData(Guid telemetryKey, TelemetryItemTypes itemType
, int skip, int take, IEnumerable <Tuple <string, bool> > sortBy, ISearch requestSearch
, List <string> searchableColumns)
{
Program program = await this.portalContext.Programs.FirstOrDefaultAsync(x => x.TelemetryKey == telemetryKey).ConfigureAwait(false);
if (program == null)
{
throw new ArgumentException($"Program with key {telemetryKey} does not exist");
}
IQueryable <TelemetryDetail> query;
int totalCount;
if (itemType == TelemetryItemTypes.View)
{
query = this.telemetryContext.ViewTelemetryDetails.Where(x => x.TelemetrySummary.View.ProgramId == program.Id);
totalCount = await this.telemetryContext.ViewTelemetryDetails.CountAsync(x => x.TelemetrySummary.View.ProgramId == program.Id).ConfigureAwait(false);
}
else
{
query = this.telemetryContext.EventTelemetryDetails.Where(x => x.TelemetrySummary.Event.ProgramId == program.Id && !string.IsNullOrEmpty(x.TelemetrySummary.Event.Name)); //todo remove this empty string check after dealing with heartbeat data
totalCount = await this.telemetryContext.EventTelemetryDetails.CountAsync(x => x.TelemetrySummary.Event.ProgramId == program.Id && !string.IsNullOrEmpty(x.TelemetrySummary.Event.Name)).ConfigureAwait(false);
}
IQueryable <TelemetryDetail> filteredQuery = EntityFilter.Match(query
, property => property.Contains(requestSearch.Value)
, new List <Expression <Func <TelemetryDetail, string> > >()
{
{ x => x.Sequence },
{ x => x.IpAddress },
{ x => x.UserIdentifier },
{ x => x.EntryKey },
});
if (take == -1)
{
take = totalCount;
}
List <TelemetryDetail> usages = await ApplyOrderingQuery(sortBy, filteredQuery, skip, take).ConfigureAwait(false);
List <DataTableTelemetryData> result = new List <DataTableTelemetryData>();
foreach (TelemetryDetail detail in usages)
{
DataTableTelemetryData data = new DataTableTelemetryData()
{
Timestamp = detail.Timestamp
, UserName = detail.UserIdentifier
, IpAddress = detail.IpAddress
, EntryKey = detail.EntryKey
, ProgramVersion = detail.FileVersion
, Sequence = detail.Sequence
, Properties = detail.GetTelemetryUnits().Where(x => x.UnitType == TelemetryUnit.UnitTypes.Property).ToDictionary(x => x.Key, x => x.ValueString)
, Metrics = detail.GetTelemetryUnits().Where(x => x.UnitType == TelemetryUnit.UnitTypes.Metric).ToDictionary(x => x.Key, x => x.ValueDouble)
};
result.Add(data);
}
return(new UsageDataTableResult {
TotalCount = totalCount, FilteredCount = totalCount, UsageData = result
});
}
private static async Task <ITelemetryAware> GetTrackedComponent(ITelemetryUnitOfWork work, TelemetryItemTypes itemType, string key, TelemetryRootObject program)
{
switch (itemType)
{
case TelemetryItemTypes.Event:
return(await GetEventOrAddIfMissing(work, key, program).ConfigureAwait(false));
case TelemetryItemTypes.View:
return(await GetViewOrAddIfMissing(work, key, program).ConfigureAwait(false));
default:
throw new ArgumentOutOfRangeException(nameof(itemType), itemType, null);
}
}
public async Task <JsonResult> GetPivotTableData(TelemetryItemTypes type, Guid telemetryKey)
{
var result = await this.Work.GetPivotTableData(type, telemetryKey).ConfigureAwait(false);
return(this.Json(result, JsonRequestBehavior.AllowGet));
}
