private static IQueryable <T> ApplyOrderBy <T>(IQueryable <T> collection, OrderByInfo orderByInfo)
{
var props = orderByInfo.PropertyName.Split('.');
var type = typeof(T);
var arg = Expression.Parameter(type, "x");
Expression expr = arg;
var type1 = type;
foreach (var pi in props.Select(type1.GetProperty))
{
expr = Expression.Property(expr, pi);
type = pi.PropertyType;
}
var delegateType = typeof(Func <,>).MakeGenericType(typeof(T), type);
var lambda = Expression.Lambda(delegateType, expr, arg);
var methodName = !orderByInfo.Initial && collection is IOrderedQueryable <T>?
(orderByInfo.Direction == SortingDirection.Ascending ? "ThenBy" : "ThenByDescending") :
(orderByInfo.Direction == SortingDirection.Ascending ? "OrderBy" : "OrderByDescending");
//TODO: HH: apply caching to the generic methodsinfos?
return((IOrderedQueryable <T>) typeof(Queryable).GetMethods().Single(
method => method.Name == methodName &&
method.IsGenericMethodDefinition &&
method.GetGenericArguments().Length == 2 &&
method.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] { collection, lambda }));
}
private static IQueryable <T> ApplyOrderBy <T>(IQueryable <T> collection, OrderByInfo orderByInfo)
{
try
{
string[] props = orderByInfo.PropertyName.Split('.');
Type type = typeof(T);
ParameterExpression arg = Expression.Parameter(type, "x");
Expression expr = arg;
foreach (string prop in props)
{
// use reflection (not ComponentModel) to mirror LINQ
PropertyInfo pi = type.GetProperty(prop);
expr = Expression.Property(expr, pi);
type = pi.PropertyType;
}
Type delegateType = typeof(Func <,>).MakeGenericType(typeof(T), type);
LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);
string methodName = String.Empty;
if (!orderByInfo.Initial && collection is IOrderedQueryable <T> )
{
if (orderByInfo.Direction == SortDirection.Ascending)
{
methodName = "ThenBy";
}
else
{
methodName = "ThenByDescending";
}
}
else
{
if (orderByInfo.Direction == SortDirection.Ascending)
{
methodName = "OrderBy";
}
else
{
methodName = "OrderByDescending";
}
}
return((IOrderedQueryable <T>) typeof(Queryable).GetMethods().Single(
method => method.Name == methodName &&
method.IsGenericMethodDefinition &&
method.GetGenericArguments().Length == 2 &&
method.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] { collection, lambda }));
}
catch (Exception ex)
{
String x = ex.Message;
x = "";
}
return(null);
}
/// <summary>
/// Orders the list by the sort clause
/// </summary>
/// <param name="source">List to order</param>
/// <param name="orderByInfo">Sort clause</param>
/// <returns>Ordered list</returns>
protected virtual List <TModel> ApplySort(List <TModel> source, OrderByInfo orderByInfo)
{
if (source == null)
{
return(null);
}
if (orderByInfo == null || !orderByInfo.Items.Any())
{
return(source);
}
var orderByString = new StringBuilder();
var separator = string.Empty;
foreach (var orderInfo in orderByInfo.Items)
{
orderByString.Append(separator);
separator = ", ";
if (orderInfo.Order == SortOrder.Descending)
{
orderByString.Append($"{orderInfo.PropertyName} DESC");
}
else
{
orderByString.Append(orderInfo.PropertyName);
}
}
return(source.AsQueryable().OrderBy(orderByString.ToString()).ToList());
}
public DatasetListModel(int pageSize, int pageNumber, OrderByInfo orderBy, IEnumerable<string> containers, IEnumerable<Func<EntitySet, bool>> filters)
{
_orderBy = orderBy;
_pageSize = pageSize;
_pageNumber = pageNumber;
_containers = containers;
_filters = filters;
}
public RequestListModel()
{
OrderBy = new OrderByInfo {
Direction = SortDirection.Desc, Field = Field.Name
};
PageSize = 15;
PageNumber = 1;
}
private static IQueryable <T> ApplyOrderBy <T>(IQueryable <T> collection, OrderByInfo orderByInfo)
{
string[] props = orderByInfo.PropertyName.Split('.');
Type type = typeof(T);
ParameterExpression arg = Expression.Parameter(type, "x");
Expression expr = arg;
foreach (string prop in props)
{
// Use reflection (not ComponentModel) to mirror LINQ
PropertyInfo pi = type.GetProperty(prop, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
if (pi == null)
{
throw new ArgumentException("Invalid OrderBy field name.");
}
expr = Expression.Property(expr, pi);
type = pi.PropertyType;
}
Type delegateType = typeof(Func <,>).MakeGenericType(typeof(T), type);
LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);
string methodName = String.Empty;
if (!orderByInfo.Initial && collection is IOrderedQueryable <T> )
{
if (orderByInfo.Direction == SortDirection.Ascending)
{
methodName = "ThenBy";
}
else
{
methodName = "ThenByDescending";
}
}
else
{
if (orderByInfo.Direction == SortDirection.Ascending)
{
methodName = "OrderBy";
}
else
{
methodName = "OrderByDescending";
}
}
//TODO: apply caching to the generic methodsinfos?
return((IOrderedQueryable <T>) typeof(Queryable).GetMethods().Single(
method => method.Name == methodName &&
method.IsGenericMethodDefinition &&
method.GetGenericArguments().Length == 2 &&
method.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] { collection, lambda }));
}
private static IQueryable <T> ApplyOrderBy <T>(IQueryable <T> collection, OrderByInfo orderByInfo)
{
var props = orderByInfo.PropertyName.Split('.');
var type = typeof(T);
var arg = Expression.Parameter(type, "x");
Expression expr = arg;
foreach (var prop in props)
{
// use reflection (not ComponentModel) to mirror LINQ
var pi = type.GetProperty(prop);
expr = Expression.Property(expr, pi);
type = pi.PropertyType;
}
var delegateType = typeof(Func <,>).MakeGenericType(typeof(T), type);
var lambda = Expression.Lambda(delegateType, expr, arg);
var methodName = string.Empty;
if (!orderByInfo.Initial && collection is IOrderedQueryable <T> )
{
if (orderByInfo.Direction == SortDirection.Ascending)
{
methodName = "ThenBy";
}
else
{
methodName = "ThenByDescending";
}
}
else
{
if (orderByInfo.Direction == SortDirection.Ascending)
{
methodName = "OrderBy";
}
else
{
methodName = "OrderByDescending";
}
}
//TODO: apply caching to the generic methodsinfos?
return((IOrderedQueryable <T>) typeof(Queryable).GetMethods().Single(
method => method.Name == methodName &&
method.IsGenericMethodDefinition &&
method.GetGenericArguments().Length == 2 &&
method.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] { collection, lambda }));
}
private static IQueryable <T> ApplyOrderBy <T>(IQueryable <T> collection, OrderByInfo orderByInfo)
{
Type type = typeof(T);
ParameterExpression arg = Expression.Parameter(type, "x");
Expression expr = arg;
string prop = orderByInfo.PropertyName;
// use reflection (not ComponentModel) to mirror LINQ
PropertyInfo pi = OrmHelper.GetPropertyInfo <T>(prop);
expr = Expression.Property(expr, pi);
type = pi.PropertyType;
Type delegateType = typeof(Func <,>).MakeGenericType(typeof(T), type);
LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);
string methodName = String.Empty;
if (!orderByInfo.Initial && collection is IOrderedQueryable <T> )
{
methodName = orderByInfo.Direction == SortDirection.Ascending ? "ThenBy" : "ThenByDescending";
}
else
{
methodName = orderByInfo.Direction == SortDirection.Ascending ? "OrderBy" : "OrderByDescending";
}
//TODO: apply caching to the generic methodsinfos?
return((IOrderedQueryable <T>) typeof(Queryable).GetMethods().Single(
method => method.Name == methodName &&
method.IsGenericMethodDefinition &&
method.GetGenericArguments().Length == 2 &&
method.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] { collection, lambda }));
}
private IEnumerable<EntitySetWrapper> GetDataSets(int first, int count, OrderByInfo orderBy, IEnumerable<string> containers, IEnumerable<Func<EntitySet, bool>> filters)
{
var filteredSets = GetEntitySets(containers);
IEnumerable<EntitySetWrapper> result;
if (filters != null)
{
foreach (var filter in filters)
filteredSets = filteredSets.Where(filter);
result = GetDataSetWrappers(filteredSets);
}
else
{
// Cache non filtered list for top lists.
result = _allDataSets ?? (_allDataSets = GetDataSetWrappers(filteredSets));
}
var field = SortingFuncs[orderBy.Field];
var sortedResult = orderBy.Direction == SortDirection.Asc
? result.OrderBy(field).ThenBy(SortingFuncs[Field.Date]).ThenBy(SortingFuncs[Field.Rating]).ThenBy(SortingFuncs[Field.Views]).ThenByDescending(SortingFuncs[Field.Name]).ThenByDescending(SortingFuncs[Field.Category])
: result.OrderByDescending(field).ThenBy(SortingFuncs[Field.Date]).ThenBy(SortingFuncs[Field.Rating]).ThenBy(SortingFuncs[Field.Views]).ThenByDescending(SortingFuncs[Field.Name]).ThenByDescending(SortingFuncs[Field.Category]);
return count > 0
? sortedResult.Skip(first).Take(count)
: sortedResult;
}
public RequestListModel(OrderByInfo orderBy, int pageSize, int pageNumber)
{
OrderBy = orderBy;
PageSize = pageSize;
PageNumber = pageNumber;
}
public RequestListModel()
{
OrderBy = new OrderByInfo { Direction = SortDirection.Desc, Field = Field.Name };
PageSize = 15;
PageNumber = 1;
}
public RequestListModel(OrderByInfo orderBy, int pageSize, int pageNumber)
{
OrderBy = orderBy;
PageSize = pageSize;
PageNumber = pageNumber;
}
