public async Task <Report[]> GenerateFilteredReportResultAsync(WidgetDataSourceContext context)
{
try
{
var result = await OnGenerateFilteredReportResultAsync(context);
if (this.Mapping != null)
{
result?.MapNames(this.Mapping);
}
if (!string.IsNullOrWhiteSpace(this.ExcludePrefix))
{
foreach (var col in result.ColumnsDefinitions ?? Enumerable.Empty <ReportColumnTemplate>())
{
col.Title = col.Title.Replace(this.ExcludePrefix, "");
}
}
return(new Report[] { result });
}
catch (Exception e)
{
Logger.Instance.Error(this, nameof(GenerateFilteredReportResultAsync), e);
return(new Report[] { });
}
}
protected override async Task <Report> OnGenerateFilteredReportResultAsync(WidgetDataSourceContext context)
{
if (this.ReportModelId.HasValue == false)
{
throw new OrionsException($"No {nameof(ReportModelId)} assigned");
}
var reportModelConfig = await context.HyperStore.RetrieveAsync <ReportModelConfig>(this.ReportModelId.Value);
if (context.GroupFilterData?.StartTime.HasValue == true || context.GroupFilterData?.EndTime.HasValue == true)
{
reportModelConfig.TrySetTimeRange(context.GroupFilterData?.StartTime, context.GroupFilterData?.EndTime);
}
if (context.GroupFilterData?.Period != null)
{
reportModelConfig.TrySetPeriod(context.GroupFilterData.Period);
}
if (context.GroupFilterData?.FilterLabels?.Length > 0)
{
reportModelConfig.TrySetLabels(context.GroupFilterData?.FilterLabels, context.GroupFilterData.FilterTarget);
}
if (MetadataSetId.HasValue)
{
var metadataSetStage = reportModelConfig.DataSource as MetadataSetReportDataSourceStageConfig;
if (metadataSetStage != null)
{
metadataSetStage.MetadataSetId = MetadataSetId;
}
else
{
Logger.Instance?.Warning(this, nameof(OnGenerateFilteredReportResultAsync), "Failed to apply MetadataSetId, since source stage is not a metadataset stage");
}
}
var helper = new ReportModelHelper();
if (this.JobMode)
{
return(await helper.ExecuteJobModeAsync(context.HyperStore, reportModelConfig, null, context.CancellationToken, "", this.JobMode_CacheRead, this.JobMode_CacheWrite));
}
else
{
return(await helper.ExecuteLocalModeAsync(context.HyperStore, reportModelConfig, null, "", context.Logger, context.CancellationToken));
}
}
protected override async Task <Report> OnGenerateFilteredReportResultAsync(WidgetDataSourceContext context)
{
var args = new RetrieveHyperDocumentArgs(this.ReportResultId);
var doc = await context.HyperStore.ExecuteAsync(args);
if (args.ExecutionResult.IsNotSuccess)
{
return(null);
}
var result = doc?.GetPayload <Report>();
//if (result != null)
//{
// if (context.DynamicFilter != null)
// result.FilterWith(context.DynamicFilter);
//}
return(result);
}
protected override Task <Report> OnGenerateFilteredReportResultAsync(WidgetDataSourceContext context)
{
var byteArray = this.CSVData;
if (byteArray == null)
{
return(Task.FromResult <Report>(null));
}
var reportData = new Report();
var rowDefList = new List <ReportRowTemplate>();
var colDefList = new List <ReportColumnTemplate>();
var dataMap = new Dictionary <int, List <string> >();
using (var stream = new MemoryStream(byteArray))
{
var reader = new StreamReader(stream);
var lineCount = 0;
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
//System.Diagnostics.Debug.WriteLine(line);
if (!String.IsNullOrWhiteSpace(line))
{
string[] values = line.Split(',');
if (values.Any() && lineCount == 0)
{
// columns header.
for (var i = 0; i < values.Length; i++)
{
if (i == 0)
{
continue;
}
var colDef = new ComputationReportColumnTemplate()
{
Title = values[i]
};
colDefList.Add(colDef);
}
reportData.ColumnsDefinitions = colDefList.ToArray();
}
else
{
var dataList = new List <string>();
for (var i = 0; i < values.Length; i++)
{
if (i == 0)
{
var rowDef = new ComputationReportRowTemplate()
{
Title = values[i]
};
rowDefList.Add(rowDef);
continue;
}
;
dataList.Add(values[i]);
}
dataMap.Add(lineCount, dataList);
}
}
lineCount++;
}
}
reportData.ColumnsDefinitions = colDefList.ToArray();
reportData.RowsDefinitions = rowDefList.ToArray();
var item1 = dataMap.Values;
foreach (KeyValuePair <int, List <string> > item in dataMap)
{
var rowIndex = item.Key;
var columnData = item.Value;
var cells = new List <ReportRowCell>();
var rowTemplate = reportData.RowsDefinitions[rowIndex - 1];
var dataCells = columnData.Select(it => new ReportRowCell()
{
Values = new[] { it }
}).ToArray();
reportData.AddRow(new ReportRow()
{
Cells = dataCells, Template = rowTemplate
});
}
return(Task.FromResult <Report>(reportData));
}
protected abstract Task <Report> OnGenerateFilteredReportResultAsync(WidgetDataSourceContext context);
public async Task RefreshReportResultData()
{
var widget = this.Widget as ReportBaseWidget;
var dataSource = widget?.DataSource;
ReportChartData = null;
OnReportResultChanged?.Invoke();
RaiseNotify(nameof(ReportChartData)); // Refresh UI.
if (dataSource == null)
{
return;
}
IsLoadedReportResult = false;
//OnReportResultChanged?.Invoke();
//RaiseNotify(nameof(ReportChartData)); // Refresh UI - loader.
try
{
var context = new WidgetDataSourceContext();
context.HyperStore = this.HyperStore;
// Only if we are allowed as a active filtering target, do we set the filters.
if (widget is ActiveFilterReportChartWidget activeReportWidget && activeReportWidget.AllowFiltrationTarget)
{
context.GroupFilterData = this.DashboardVm?.ObtainFilterGroup(widget.FilterGroup);
}
var reportResult = await dataSource.GenerateFilteredReportResultAsync(context);
if (reportResult == null)
{
Logger.Instance.Error("Failed to load report result");
return;
}
Report = reportResult.FirstOrDefault();
if (Report == null || Report.ColumnsDefinitions.Length == 0)
{
return;
}
var includeCategoryFilter = widget.DataSource.IncludeCategories?.Split(',', StringSplitOptions.RemoveEmptyEntries).Select(it => it.Trim()).ToArray();
var excludeCategoryFilter = widget.DataSource.ExcludeCategories?.Split(',', StringSplitOptions.RemoveEmptyEntries).Select(it => it.Trim()).ToArray();
ReportChartData = LoadReportChartData(Report, includeCategoryFilter, excludeCategoryFilter, widget.DataSource.Uppercase);
if (ReportChartData != null)
{
ReportChartData.MapIcons(dataSource.IconMapping);
await LoadAllIcons(ReportChartData);
}
}
finally
{
IsLoadedReportResult = true;
OnReportResultChanged?.Invoke();
RaiseNotify(nameof(ReportChartData)); // Refresh UI.
}
}
