/// <summary>
/// Builds an <c>AggregateCriteria</c> object.
/// </summary>
/// <param name="aggregateDefinitions">The collection of aggregate definitions.</param>
/// <param name="sourceQueryCriteria">The data source query criteria.</param>
/// <returns>Cebos.Veyron.SharedTypes.AggregateCriteria</returns>
private static AggregateCriteria BuildAggregateCriteria(IEnumerable<AggregateDefinition> aggregateDefinitions, AggregateDataSourceQueryCriteria sourceQueryCriteria)
{
var criteria =
new AggregateCriteria
{
ProcessName = sourceQueryCriteria.ProcessName,
PageNumber = sourceQueryCriteria.PageNumber,
PageSize = sourceQueryCriteria.PageSize,
GroupColumn = sourceQueryCriteria.GroupColumn,
SecurityColumns = sourceQueryCriteria.SecurityColumns != null
? new MobileList<SecurityColumnDescriptor>(sourceQueryCriteria.SecurityColumns)
: null,
Sortings = sourceQueryCriteria.Sortings,
FilterId = sourceQueryCriteria.FilterId,
FilterDefinition = sourceQueryCriteria.FilterDefinition,
QuickFilterString = sourceQueryCriteria.QuickFilterString
};
var definitionsByColumn = new Dictionary<string, List<AggregateDefinition>>();
foreach (var def in aggregateDefinitions)
{
List<AggregateDefinition> defList;
if (!definitionsByColumn.TryGetValue(def.ColumnName, out defList))
definitionsByColumn[def.ColumnName] = defList = new List<AggregateDefinition>();
defList.Add(def);
}
foreach (var columnInfo in definitionsByColumn)
{
var aggregates = columnInfo.Value;
var columnItem = new AggregateColumnItem
{
ColumnName = columnInfo.Key,
CustomConverter = aggregates[0].CustomConverter,
TargetType = aggregates[0].TargetType,
TypeName = aggregates[0].TypeName,
ConverterParameter = aggregates[0].ConverterParameter
};
foreach (var aggrDef in aggregates)
{
columnItem.AggregatesEnabled.Add(
new AggregateTypeInfo
{
SummaryType = aggrDef.SummaryType
});
}
criteria.Columns.Add(columnItem);
}
return criteria;
}
public static void CalculateAggregats(bool isClient, GridViewDataControl grid, AggregateCriteria criteria, IColumnItem currentColumn, string result)
{
var f = new AggregateFunction<object, object>
{
Caption = string.Format(CultureInfo.InvariantCulture, "{0}:", AggregateHelper.GetAttribute(criteria.SummaryType).FullName),
FunctionName = string.Format(CultureInfo.InvariantCulture, "{0}{1}", criteria.SelectedColumn, criteria.SummaryType)
};
if (isClient)
f.AggregationExpression = x => x.ClientCalculateAggregates(criteria);
else
f.AggregationExpression = x => result;
if (currentColumn != null)
{
if (grid != null)
{
grid.Columns[currentColumn.FullyQualifiedName].AggregateFunctions.Add(f);
var ordered = grid.Columns[currentColumn.FullyQualifiedName].AggregateFunctions.OrderBy(x => AggregateHelper.GetAttribute(AggregateHelper.GetTypeByFullName(x.Caption.Replace(":", null))).Order).ToList();
grid.Columns[currentColumn.FullyQualifiedName].AggregateFunctions.Clear();
grid.Columns[currentColumn.FullyQualifiedName].AggregateFunctions.AddRange(ordered);
}
currentColumn.AggregateCriteriaList.Add(criteria);
}
if (!isClient)
if (grid != null)
grid.CalculateAggregates();
}
/// <summary>
/// Reads data retrieved from database and converts
/// it into the collection of <c>AggregateResult</c> objects.
/// </summary>
/// <param name="reader">The data reader.</param>
/// <param name="criteria">The aggregate critetia.</param>
/// <returns>The collection of aggregate results.</returns>
public static IList<AggregateResult> ProcessResultData(SqlDataReader reader, AggregateCriteria criteria)
{
var list = new List<AggregateResult>();
if (reader == null || criteria == null)
return list;
if (reader.FieldCount == 2)
{
while (reader.Read())
{
var aggregationInfo = reader.GetString("AggregationInfo");
var resultValue = reader.GetValue("Result");
if (string.IsNullOrWhiteSpace(aggregationInfo))
continue;
var aggregationInfoParts = aggregationInfo.Split(' ');
var column = criteria.Columns.First(x => x.ColumnName == aggregationInfoParts[0]);
var aggregateType = (SummaryTypes) Enum.Parse(typeof (SummaryTypes), aggregationInfoParts[1]);
list.Add(
new AggregateResult
{
ColumnName = column.ColumnName,
SummaryType = aggregateType,
Value = FormatResult(
resultValue, aggregateType.ToString(),
column.CustomConverter, column.TargetType, column.TypeName, column.ConverterParameter)
.ToString()
});
}
reader.NextResult();
}
if (reader.HasRows)
{
do
{
var columnName = reader.GetName(0);
var blocked = columnName.EndsWith("Blocked", StringComparison.Ordinal);
columnName = columnName.Replace("Blocked", string.Empty);
var column = criteria.Columns.FirstOrDefault(
x => x.ColumnName == columnName.TrimEnd("Page") ||
x.ColumnName == columnName.TrimEnd("All"));
if (column == null)
continue;
var aggregateDefinitions = column.AggregatesEnabled
.Where(x => (x.SummaryType.ToString().StartsWith("Min", StringComparison.Ordinal) ||
x.SummaryType.ToString().StartsWith("Max", StringComparison.Ordinal)) &&
(AggregateHelper.IsPageAggregateType(x.SummaryType)
? columnName.EndsWith("Page", StringComparison.Ordinal)
: columnName.EndsWith("All", StringComparison.Ordinal))
)
.Select(x => AggregateDefinition.Create(
column.ColumnName, x.SummaryType.ToString(),
column.CustomConverter, column.TargetType,
column.TypeName, column.ConverterParameter)
)
.ToList();
if (blocked)
{
list.AddRange(
aggregateDefinitions.Select(
x => AggregateResult.CreateBlocked(x.ColumnName, x.SummaryType)));
continue;
}
var dataSet = new List<object>();
while (reader.Read())
{
dataSet.Add(reader.GetValue(0));
}
dataSet = dataSet
.Select(x =>
PrepareValue(
x, SummaryTypes.Count.ToString(), column.CustomConverter,
column.TargetType, column.TypeName, column.ConverterParameter,
column.ColumnName))
.Where(x => x != null)
.ToList();
list.AddRange(
CalculateAggregates(dataSet, aggregateDefinitions));
}
while (reader.NextResult());
}
return list;
}
