public void SeparateSeriesCategory()
{
if (ReportChartData.Series.Count != 1)
{
return;
}
var ser = ReportChartData.Series.FirstOrDefault();
var series = ser.Data.Select(it => new ReportSeriesChartData()
{
Data = new List <ReportSeriesChartDataItem> {
it
}, Name = it.Label
}).ToList();
//var series = ser.Data.Select(it => new ReportSeriesChartData() { Data = ser.Data.Select(d => new ReportSeriesChartDataItem() {
// Label = d.Label,
// Value = d.Label == it.Label ? d.Value : String.Empty,
// ColumnTemplate = d.ColumnTemplate,
// RowTemplate = d.RowTemplate
//}).ToList(), Name = it.Label }).ToList();
ReportChartData.Clean();
ReportChartData.Series.AddRange(series);
//ReportChartData.AddCategoryRange(series.Select(it => it.Name).ToArray());
}
private async Task LoadAllIcons(ReportChartData data)
{
var docsIds = data.Series?.Where(it => it.IconDocument != null)
.Select(it => it.IconDocument.Value).ToArray();
if (docsIds.Length == 0)
{
return;
}
var args = new RetrieveHyperDocumentsArgs();
args.DocumentsIds = docsIds;
var results = await this.HyperStore.ExecuteAsync(args);
if (args.ExecutionResult.IsNotSuccess)
{
return;
}
foreach (var item in results)
{
var icon = item?.GetPayload <UniIconResource>();
if (icon != null)
{
var chartData = data.Series.FirstOrDefault(it => it.IconDocument.GetValueOrDefault().Equals(item.Id));
chartData.Icon = icon;
}
}
}
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.
}
}
ReportChartData LoadReportChartData(Report report,
string[] includeCategoryFilters,
string[] excludeCategoryFilters,
bool toUpper = false)
{
var result = new ReportChartData();
if (report == null)
{
return(result);
}
try
{
if (report.ColumnsDefinitions == null)
{
return(result);
}
var columns = report.ColumnsDefinitions;
var rowData = report.Rows;
var resultCategoryRange = new List <string>();
for (var columnIndex = 0; columnIndex < columns.Length; columnIndex++)
{
var columnTemplate = columns[columnIndex];
var columnTitle = columnTemplate.Title;
if (includeCategoryFilters?.Any() == true && !includeCategoryFilters.Contains(columnTitle))
{
continue;
}
if (excludeCategoryFilters?.Any() == true && excludeCategoryFilters.Contains(columnTitle))
{
continue;
}
if (toUpper)
{
columnTitle = columnTitle.ToUpper();
}
var chartSeries = new ReportSeriesChartData();
var existingSeries = result.Series.FirstOrDefault(it => it.Name == columnTitle);
if (existingSeries != null)
{
chartSeries = existingSeries;
}
else
{
chartSeries.Name = columnTitle;
resultCategoryRange.Add(columnTitle);
}
for (var rowIndex = 0; rowIndex < rowData.Length; rowIndex++)
{
var row = rowData[rowIndex];
var label = report.RowsDefinitions[rowIndex].Title;
if (string.IsNullOrWhiteSpace(label))
{
label = row.Template.Title;
}
var cell = row.Cells[columnIndex];
var data = cell.Values.FirstOrDefault();
ReportSeriesChartDataItem chartItem = null;
var existingChartItem = chartSeries.Data.FirstOrDefault(it => it.Label == label);
if (chartItem == null)
{
chartItem = new ReportSeriesChartDataItem
{
CategoryName = columnTitle,
Value = FormatData(data),
Label = label,
RowTemplate = row.Template,
ColumnTemplate = columnTemplate,
Cell = cell,
};
if (result.IsDateAxis)
{
try
{
result.IsDateAxis = row.Template?.StartDateTime.HasValue == true;
//var position = Report.ParseTimePosition(label);
//if (!position.HasValue)
//{
// result.IsDateAxis = false;
//}
//else
//{
// chartItem.DatePosition = position.Value;
// chartItem.StreamPosition = Report.ParseStreamPosition(label);
//}
}
catch (Exception ex)
{
result.IsDateAxis = false;
}
}
chartSeries.Data.Add(chartItem);
}
else
{
chartItem.Value += Convert.ToUInt16(data.ToString());
}
}
result.AddCategoryRange(resultCategoryRange.ToArray());
result.Series.Add(chartSeries);
}
}
catch (Exception ex)
{
Logger.Instance.Error(typeof(ReportWidgetVm <>), nameof(LoadReportChartData), ex);
System.Diagnostics.Debug.Assert(false, ex.Message);
}
return(result);
}
