public KendoGridEx(KendoGridBaseRequest request,
IEnumerable <TModel> source,
IEnumerable <string> includes = null,
Dictionary <string, MapExpression <TModel> > mappings = null,
Func <IQueryable <TModel>, IEnumerable <TModel> > conversion = null)
: base(request, source.AsQueryable(), mappings, conversion, includes)
{
}
public KendoGrid(
[NotNull] KendoGridBaseRequest request,
[NotNull] IQueryable <TEntity> query,
[CanBeNull] Dictionary <string, MapExpression <TEntity> > mappings = null,
[CanBeNull] Func <IQueryable <TEntity>, IEnumerable <TViewModel> > conversion = null,
[CanBeNull] IEnumerable <string> includes = null)
{
Guard.NotNull(request, nameof(request));
Guard.NotNull(query, nameof(query));
_mappings = mappings;
_conversion = conversion;
IList <string> includesAsList = null;
if (includes != null)
{
includesAsList = includes.ToList();
}
var tempQuery = request.FilterObjectWrapper != null?ApplyFiltering(query, request.FilterObjectWrapper) : query;
Total = tempQuery.Count();
if (request.AggregateObjects != null)
{
Aggregates = ApplyAggregates(tempQuery, includesAsList, request);
}
if (request.GroupObjects != null)
{
Groups = ApplyGroupingAndSorting(tempQuery, includesAsList, request);
_query = null;
Data = null;
}
else
{
tempQuery = ApplySorting(tempQuery, request.SortObjects);
// Paging
if (request.Skip.HasValue && request.Skip > 0)
{
tempQuery = tempQuery.Skip(request.Skip.Value);
}
if (request.Take.HasValue && request.Take > 0)
{
tempQuery = tempQuery.Take(request.Take.Value);
}
_query = tempQuery;
Data = _conversion?.Invoke(_query).ToList() ?? _query.ToList().OfType <TViewModel>();
Groups = null;
}
}
public KendoGrid(
[NotNull] KendoGridBaseRequest request,
[NotNull] IEnumerable <dynamic> source,
[CanBeNull] Dictionary <string, MapExpression <dynamic> > mappings = null,
[CanBeNull] Func <IQueryable <dynamic>, IEnumerable <dynamic> > conversion = null,
[CanBeNull] IEnumerable <string> includes = null
)
: base(request, source.AsQueryable(), mappings, conversion, includes)
{
}
public IEnumerable <TViewModel> FilterBy <TEntity, TViewModel>([NotNull] IQueryable <TEntity> query,
KendoGridBaseRequest request,
IEnumerable <string> includes = null,
Dictionary <string, MapExpression <TEntity> > mappings = null,
Func <IQueryable <TEntity>, IEnumerable <TViewModel> > conversion = null,
bool canUseAutoMapperProjection = false)
{
var mappings2 = _autoMapperUtils.GetModelMappings <TEntity, TViewModel>(mappings);
var conversion2 = conversion ?? GetAutoMapperConversion <TEntity, TViewModel>(canUseAutoMapperProjection);
return(new KendoGrid <TEntity, TViewModel>(request, query, mappings2, conversion2, includes).Data);
}
protected IEnumerable <KendoGroup> ApplyGroupingAndSorting(IQueryable <TEntity> query, IList <string> includes, KendoGridBaseRequest request)
{
bool hasAggregates = request.GroupObjects.Any(g => g.AggregateObjects.Any());
string aggregatesExpression = string.Empty;
if (hasAggregates)
{
// In case of sum, min or max: convert it to sum(TEntity__.XXX) as sum_XXX
// In case of count, convert it to count() as count_XXX
var convertedAggregateObjects = request.GroupObjects
.SelectMany(g => g.AggregateObjects)
.Select(a => a.GetLinqAggregate(MapFieldfromViewModeltoEntity))
.Distinct()
.ToList();
// , new (sum(TEntity__.EmployeeNumber) as sum__Number) as Aggregates
aggregatesExpression = $", new ({string.Join(", ", convertedAggregateObjects)}) as Aggregates";
}
var sort = request.SortObjects?.ToList() ?? new List <SortObject>();
bool hasSortObjects = sort.Any();
// List[0] = LastName as Last
var groupByFields = request.GroupObjects.Select(s => $"{MapFieldfromViewModeltoEntity(s.Field)} as {s.Field}").ToList();
// new (new (LastName as Last) as GroupByFields)
var groupByExpressionX = $"new (new ({string.Join(",", groupByFields)}) as GroupByFields)";
// new (Key.GroupByFields, it as Grouping, new (sum(TEntity__.EmployeeNumber) as sum__TEntity___EmployeeNumber) as Aggregates)
var selectExpressionBeforeOrderByX = $"new (Key.GroupByFields, it as Grouping {aggregatesExpression})";
var groupSort = string.Join(",", request.GroupObjects.ToList().Select(s => $"{MapFieldfromViewModeltoEntity(s.Field)} {s.Direction}"));
// Adam Downs moved sort to items vs group
var orderByFieldsExpression = hasSortObjects ?
string.Join(",", sort.Select(s => $"{MapFieldfromViewModeltoEntity(s.Field)} {s.Direction}")) :
MapFieldfromViewModeltoEntity(request.GroupObjects.First().Field);
// new (GroupByFields, Grouping, Aggregates)
var selectExpressionAfterOrderByX = $"new (GroupByFields, Grouping{(hasAggregates ? ", Aggregates" : string.Empty)})";
string includesX = string.Empty;
if (includes != null && includes.Any())
{
includesX = ", " + string.Join(", ", includes.Select(i => "it." + i + " as TEntity__" + i.Replace(".", "_")));
}
IOrderedQueryable <TEntity> limitedQueryOrdered = query.OrderBy(string.Join(",", groupSort, orderByFieldsExpression));
IQueryable <TEntity> limitedQuery = limitedQueryOrdered;
// Execute the Dynamic Linq for Paging
if (request.Skip.HasValue && request.Skip > 0)
{
limitedQuery = limitedQueryOrdered.Skip(request.Skip.Value);
}
if (request.Take.HasValue && request.Take > 0)
{
limitedQuery = limitedQueryOrdered.Take(request.Take.Value);
}
// Execute the Dynamic Linq "GroupBy"
var groupByQuery = limitedQuery.GroupBy(groupByExpressionX, $"new (it AS TEntity__{includesX})");
// Execute the Dynamic Linq "Select"
var selectQuery = groupByQuery.Select(selectExpressionBeforeOrderByX);
// Execute the Dynamic Linq "OrderBy"
var orderByQuery = selectQuery.OrderBy(string.Join(",", request.GroupObjects.Select(s => $"GroupByFields.{s.Field} {s.Direction}").ToList()));
// Execute the Dynamic Linq "Select" to get back the TEntity objects
var tempQuery = orderByQuery.Select(selectExpressionAfterOrderByX, typeof(TEntity));
// Create a valid List<KendoGroup> object
var list = new List <KendoGroup>();
foreach (DynamicClass item in tempQuery.ToDynamicList <DynamicClass>())
{
var grouping = item.GetDynamicPropertyValue <IGrouping <object, object> >("Grouping");
var groupByDictionary = item.GetDynamicPropertyValue <object>("GroupByFields").ToDictionary();
var aggregates = item.GetAggregatesAsDictionary();
Process(request.GroupObjects, groupByDictionary, grouping, aggregates, list);
}
return(list);
}
private object ApplyAggregates(IQueryable <TEntity> query, IList <string> includes, KendoGridBaseRequest request)
{
// In case of average, sum, min or max: convert it to sum(TEntity__.XXX) as sum_XXX
// In case of count, convert it to count() as count_XXX
var convertedAggregateObjects = request.AggregateObjects
.Select(a => a.GetLinqAggregate(MapFieldfromViewModeltoEntity))
.Distinct()
.ToList();
string includesX = string.Empty;
if (includes != null && includes.Any())
{
includesX = ", " + string.Join(", ", includes.Select(i => "it." + i + " as TEntity__" + i.Replace(".", "_")));
}
// Execute the Dynamic Linq "Select" to get TEntity__ (and includes if needed). Also add a fake __Key__ property to allow grouping
// Example : new ("__Key__" as __Key__, it AS TEntity__, it.Company as TEntity__Company, it.Company.MainCompany as TEntity__Company_MainCompany, it.Country as TEntity__Country)
var selectTEntityQuery = query.Select($"new (\"__Key__\" as __Key__, it AS TEntity__{includesX})");
// Group by the __Key__ to allow aggregates to be calculated
var groupByQuery = selectTEntityQuery.GroupBy("__Key__");
// Execute the Dynamic Linq "Select" to add the aggregates
// Example : new (new (Sum(TEntity__.Id) as sum__Id, Min(TEntity__.Id) as min__Id, Max(TEntity__.Id) as max__Id, Count() as count__Id, Average(TEntity__.Id) as average__Id) as Aggregates)
string aggregatesExpression = $"new (new ({string.Join(", ", convertedAggregateObjects)}) as Aggregates)";
var aggregatesQuery = groupByQuery.Select(aggregatesExpression);
// Try to get first result, cast to DynamicClass as use helper method to convert this to correct response
var aggregates = (aggregatesQuery.FirstOrDefault() as DynamicClass).GetAggregatesAsDictionary();
return(aggregates);
}