/// <summary> /// Gets the component definition as the type specified /// </summary> /// <typeparam name="T">The definition type</typeparam> /// <param name="definition">The definition instance</param> /// <returns>The converted definition</returns> public static T As <T> ( this IReportComponentDefinition definition ) where T : IReportComponentDefinition { var actualType = definition.GetType(); if (actualType != typeof(T)) { if (false == typeof(T).IsAssignableFrom(actualType)) { var message = "The component {0} cannot be converted to {1}."; throw new InvalidCastException ( String.Format ( message, actualType.Name, typeof(T).Name ) ); } else { return((T)definition); } } else { return((T)definition); } }
/// <summary> /// Constructs the report component with the details /// </summary> /// <param name="definition">The component definition</param> protected ReportComponentBase ( IReportComponentDefinition definition ) { Validate.IsNotNull(definition); this.ComponentDefinition = definition; this.Fields = definition.Fields; this.Style = definition.Style; }
/// <summary> /// Asynchronously generates a component from a report definition and filter /// </summary> /// <param name="definition">The component definition</param> /// <param name="sectionType">The report section type</param> /// <param name="filter">The report filter</param> /// <returns>The report component generated</returns> public override async Task <IReportComponent> GenerateAsync ( IReportComponentDefinition definition, ReportSectionType sectionType, ReportFilter filter ) { Validate.IsNotNull(definition); Validate.IsNotNull(filter); var statisticDefinition = definition.As <StatisticDefinition>(); var function = statisticDefinition.Function; var query = statisticDefinition.Query; var defaultParameters = statisticDefinition.DefaultParameterValues; var parameters = filter.GetQueryParameters ( query, defaultParameters.ToArray() ); var task = function.ExecuteAsync ( query, parameters.ToArray() ); var value = await task.ConfigureAwait(false); var statistic = new Statistic ( statisticDefinition, value ); if (statisticDefinition.Action != null) { statistic = statistic.WithAction ( statisticDefinition.Action ); } if (statisticDefinition.HasRange) { statistic = statistic.WithRange ( statisticDefinition.LowerRange, statisticDefinition.UpperRange ); } return(statistic); }
/// <summary> /// Generates a component from a report definition and filter /// </summary> /// <param name="definition">The component definition</param> /// <param name="sectionType">The report section type</param> /// <param name="filter">The report filter</param> /// <returns>The report component generated</returns> public virtual IReportComponent Generate ( IReportComponentDefinition definition, ReportSectionType sectionType, ReportFilter filter ) { var task = GenerateAsync ( definition, sectionType, filter ); return(task.WaitAndUnwrapException()); }
/// <summary> /// Constructs the nested component definition with the details /// </summary> /// <param name="definition">The component definition</param> /// <param name="parameterBindings">The parameter bindings</param> public NestedReportComponentDefinition ( IReportComponentDefinition definition, params ReportParameterBinding[] parameterBindings ) { Validate.IsNotNull(definition); this.Definition = definition; this.ParameterBindings = new Collection <ReportParameterBinding>(); if (parameterBindings != null) { foreach (var binding in parameterBindings) { this.ParameterBindings.Add(binding); } } }
/// <summary> /// Asynchronously generates a component from a report definition and filter /// </summary> /// <param name="definition">The component definition</param> /// <param name="sectionType">The report section type</param> /// <param name="filter">The report filter</param> /// <returns>The report component generated</returns> public override Task <IReportComponent> GenerateAsync ( IReportComponentDefinition definition, ReportSectionType sectionType, ReportFilter filter ) { Validate.IsNotNull(definition); var seperator = new Separator ( (SeparatorDefinition)definition ); return(Task.FromResult <IReportComponent> ( seperator )); }
/// <summary> /// Asynchronously generates a component from a report definition and filter /// </summary> /// <param name="definition">The component definition</param> /// <param name="sectionType">The report section type</param> /// <param name="filter">The report filter</param> /// <returns>The report component generated</returns> public abstract Task <IReportComponent> GenerateAsync ( IReportComponentDefinition definition, ReportSectionType sectionType, ReportFilter filter );
/// <summary> /// Asynchronously generates a component from a report definition and filter /// </summary> /// <param name="definition">The component definition</param> /// <param name="sectionType">The report section type</param> /// <param name="filter">The report filter</param> /// <returns>The report component generated</returns> public override async Task <IReportComponent> GenerateAsync ( IReportComponentDefinition definition, ReportSectionType sectionType, ReportFilter filter ) { Validate.IsNotNull(definition); Validate.IsNotNull(filter); var repeaterDefinition = definition.As <RepeaterDefinition>(); var query = repeaterDefinition.Query; var defaultParameters = repeaterDefinition.DefaultParameterValues; var parameters = filter.GetQueryParameters ( query, defaultParameters.ToArray() ); var queryTask = query.ExecuteAsync ( parameters.ToArray() ); var results = await queryTask.ConfigureAwait ( false ); var generatedItems = new List <RepeaterItem>(); var itemTasks = new List <Task <RepeaterItem> >(); foreach (var row in results.AllRows) { itemTasks.Add ( GenerateItemAsync ( repeaterDefinition, sectionType, filter, row ) ); } await Task.WhenAll ( itemTasks.ToArray() ) .ConfigureAwait ( false ); foreach (var task in itemTasks) { generatedItems.Add ( await task.ConfigureAwait(false) ); } if (false == repeaterDefinition.DisableSorting) { var sortDirection = filter.FindSortDirection ( sectionType, definition.Name, "Item" ); // Apply the sorting direction, if it has been specified if (sortDirection != null) { if (sortDirection.Value == SortDirection.Ascending) { generatedItems = generatedItems.OrderBy ( a => a.Value ) .ToList(); } else { generatedItems = generatedItems.OrderByDescending ( a => a.Value ) .ToList(); } } } var repeater = new Repeater ( repeaterDefinition, generatedItems.ToArray() ); return(repeater); }
/// <summary> /// Asynchronously generates a component from a report definition and filter /// </summary> /// <param name="definition">The component definition</param> /// <param name="sectionType">The report section type</param> /// <param name="filter">The report filter</param> /// <returns>The report component generated</returns> public override async Task <IReportComponent> GenerateAsync ( IReportComponentDefinition definition, ReportSectionType sectionType, ReportFilter filter ) { Validate.IsNotNull(definition); Validate.IsNotNull(filter); Table table; var tableDefinition = definition.As <TableDefinition>(); var query = tableDefinition.Query; var defaultParameters = tableDefinition.DefaultParameterValues; var queryTask = query.ExecuteAsync ( filter, defaultParameters.ToArray() ); var results = await queryTask.ConfigureAwait ( false ); var columnsTask = GetColumnsDynamicallyAsync ( tableDefinition, filter ); var columnDefinitions = await columnsTask.ConfigureAwait ( false ); if (results.HasMultipleGroupings) { var tableGroups = new List <TableGrouping>(); foreach (var queryGroup in results.Groupings) { var groupRows = BuildTableRows ( tableDefinition, sectionType, filter, queryGroup.Rows ); var tableGroup = new TableGrouping ( queryGroup.GroupingValues, groupRows.ToArray() ); if (groupRows.Any() && tableDefinition.HasTotals) { var totals = GenerateTotals ( tableDefinition, filter, queryGroup.Rows ); tableGroup.SetTotals(totals); } tableGroups.Add(tableGroup); } table = new Table ( tableDefinition, columnDefinitions, tableGroups ); } else { var tableRows = BuildTableRows ( tableDefinition, sectionType, filter, results.AllRows ); table = new Table ( tableDefinition, columnDefinitions, tableRows ); } if (table.AllRows.Any() && tableDefinition.HasTotals) { var totals = GenerateTotals ( tableDefinition, filter, results.AllRows ); table.SetTotals(totals); } _columnValueCache.Clear(); return(table); }
/// <summary> /// Asynchronously generates a component from a report definition and filter /// </summary> /// <param name="definition">The component definition</param> /// <param name="sectionType">The report section type</param> /// <param name="filter">The report filter</param> /// <returns>The report component generated</returns> public override async Task <IReportComponent> GenerateAsync ( IReportComponentDefinition definition, ReportSectionType sectionType, ReportFilter filter ) { Validate.IsNotNull(definition); Validate.IsNotNull(filter); var graphicDefinition = definition.As <GraphicDefinition>(); var graphic = new Graphic ( graphicDefinition ); if (graphicDefinition.OverlayStatistics.Any()) { var statisticGenerator = new StatisticGenerator(); var statisticDefinitions = graphicDefinition.OverlayStatistics.SelectMany ( pair => pair.Value.Select ( item => item ) ); var statisticTasks = new List <Task <IReportComponent> >(); foreach (var item in statisticDefinitions) { statisticTasks.Add ( statisticGenerator.GenerateAsync ( item, sectionType, filter ) ); } await Task.WhenAll(statisticTasks).ConfigureAwait ( false ); var taskIndex = 0; foreach (var item in graphicDefinition.OverlayStatistics) { var statisticList = new List <Statistic>(); foreach (var statisticDefinition in item.Value) { var task = statisticTasks.ElementAt ( taskIndex ); var statistic = await task.ConfigureAwait(false) as Statistic; statisticList.Add(statistic); taskIndex++; } graphic.OverlayStatistics.Add ( item.Key, statisticList ); } } return(graphic); }
/// <summary> /// Asynchronously generates a component from a report definition and filter /// </summary> /// <param name="definition">The component definition</param> /// <param name="sectionType">The report section type</param> /// <param name="filter">The report filter</param> /// <returns>The report component generated</returns> public override async Task <IReportComponent> GenerateAsync ( IReportComponentDefinition definition, ReportSectionType sectionType, ReportFilter filter ) { Validate.IsNotNull(definition); Validate.IsNotNull(filter); var chartDefinition = definition.As <ChartDefinition>(); var queryTasks = new Dictionary <ChartDataSetDefinition, Task <QueryResults> >(); var dataSets = new List <ChartDataSet>(); // Build a dictionary of query tasks to execute foreach (var setDefinition in chartDefinition.DataSets) { var query = setDefinition.Query; var defaultParameters = setDefinition.DefaultParameterValues; var parameterValues = filter.GetQueryParameters ( query, defaultParameters.ToArray() ); var task = query.ExecuteAsync ( parameterValues.ToArray() ); queryTasks.Add(setDefinition, task); } await Task.WhenAll ( queryTasks.Select(pair => pair.Value) ) .ConfigureAwait ( false ); var labelList = new List <ChartAxisLabel>(); // Compile and process the results of each query foreach (var item in queryTasks) { var dataPoints = new List <ChartDataPoint>(); var setDefinition = item.Key; var queryResults = await item.Value.ConfigureAwait ( false ); if (queryResults.AllRows.Any()) { var rowNumber = 1; foreach (var row in queryResults.AllRows) { var xLabelValue = default(object); var xValue = setDefinition.XAxisBinding.Resolve <double> ( row ); if (setDefinition.XAxisLabelBinding == null) { xLabelValue = xValue; } else { xLabelValue = setDefinition.XAxisLabelBinding.Resolve ( row ); } var xLabel = GenerateLabel ( xLabelValue, rowNumber, chartDefinition.XAxisLabelTemplate ); var yValue = setDefinition.YAxisBinding.Resolve <double> ( row ); var point = new ChartDataPoint ( xValue, yValue, setDefinition.Color ); dataPoints.Add(point); if (false == labelList.Any(l => l.Text == xLabel.Text)) { labelList.Add(xLabel); } } var set = new ChartDataSet ( setDefinition.Name, dataPoints.ToArray() ); dataSets.Add(set); rowNumber++; } } var chart = new Chart ( chartDefinition, labelList, dataSets.ToArray() ); return(chart); }