private bool HandleThenByMethod(MethodCallExpression node)
{
OrderByDirection?direction = null;
if (node.Method.Name == "ThenBy")
{
direction = OrderByDirection.Ascending;
}
else if (node.Method.Name == "ThenByDescending")
{
direction = OrderByDirection.Descending;
}
else
{
return(false);
}
if (node.Arguments.Count > 2)
{
throw new NotSupportedException("This overload of ThenBy is not supported.");
}
var field = ((node.Arguments[1] as UnaryExpression)?.Operand as LambdaExpression)?.Body as MemberExpression;
if (field == null)
{
throw new NotSupportedException($"{node.Method.Name} must operate on a supported field.");
}
this.orderByExpressions.Push(new OrderByExpression(field.Member.Name, direction.Value));
return(true);
}
public ScanRequestData(string dataSource, IList <string> intervals, IFilterSpec filter, IContextSpec context,
IEnumerable <string> columns, string resultFormat, int?limit, OrderByDirection?order, int?batchSize)
{
DataSource = dataSource;
Intervals = intervals;
Filter = filter;
Context = context;
Columns = columns;
Limit = limit;
Order = order;
ResultFormat = resultFormat;
BatchSize = batchSize;
}
public dynamic[] FindAllByColumnsByFunc <T>(string columns, Expression <Func <T, bool> > predicate = null, string orderBy = null,
OrderByDirection?orderDirection = null, int?pageNumber = null, int?pageSize = null,
string[] includeExpressions = null) where T : class, IModel
{
IQueryable <T> query = _applicationDbContext.Set <T>().AsQueryable();
if (predicate != null)
{
query = query.Where(predicate);
}
if (includeExpressions != null)
{
query = includeExpressions.Aggregate(query, (current, str) => current.Include(str));
}
var select = query.Select(string.Format("new ({0})", columns));
if (!string.IsNullOrEmpty(orderBy))
{
try
{
select = orderDirection == OrderByDirection.Descending
? select.OrderBy(orderBy + " descending")
: select.OrderBy(orderBy);
}
catch (Exception ex)
{
//
}
}
if (pageNumber.HasValue && pageSize.HasValue)
{
select = select.Skip((pageNumber.Value - 1) * pageSize.Value).Take(pageSize.Value);
}
if (string.IsNullOrEmpty(columns) == false)
{
return(select.ToDynamicArray());
}
return(select.ToDynamicArray());
}
public IEnumerable <T> FindAllByFunc <T>(Expression <Func <T, bool> > predicate = null, string orderBy = null,
OrderByDirection?orderDirection = null, int?top = null, Func <IQueryable <T>, IQueryable <T> > func = null) where T : class, IModel
{
IQueryable <T> query = _applicationDbContext.Set <T>();
if (func != null)
{
query = func(query);
}
if (predicate != null)
{
query = query.Where(predicate);
}
if (top.HasValue)
{
query = query.Take(top.Value);
}
return(query);
}
public SimpleQuery ThenBy(ObjectReference reference, OrderByDirection?direction = null)
{
ThrowIfNoOrderByClause("ThenBy requires an existing OrderBy");
return(new SimpleQuery(this, _clauses.Append(new OrderByClause(reference, direction))));
}
public SimpleQuery OrderBy(ObjectReference reference, OrderByDirection?direction = null)
{
return(new SimpleQuery(this, _clauses.Append(new OrderByClause(reference, direction))));
}
internal static string GetRequestUrl(string baseUri, string id = null, IEnumerable <ISearchFilter> filters = null, string orderByProperty = null, OrderByDirection?orderByDirection = null, int?skip = null, int?limit = null, int?includeLevels = null)
{
if (AreAllNull(id, filters, orderByProperty, skip, limit, includeLevels))
{
return(baseUri);
}
var mergedFilters = filters != null?filters.ToList() : new List <ISearchFilter>();
if (orderByProperty != null)
{
mergedFilters.Add(new OrderBySearchFilter(orderByProperty,
orderByDirection ?? OrderByDirection.Ascending));
}
if (skip.HasValue)
{
mergedFilters.Add(new SkipSearchFilter(skip.Value));
}
if (limit.HasValue)
{
mergedFilters.Add(new LimitSearchFilter(limit.Value));
}
if (includeLevels.HasValue)
{
mergedFilters.Add(new EqualitySearchFilter("include", includeLevels.Value.ToString()));
}
var newBaseUrl = baseUri + id;
if (!mergedFilters.Any())
{
return(newBaseUrl);
}
return(newBaseUrl + "?" + GetQueryStringFromSearchFilters(mergedFilters));
}
public async Task <SearchResult <T> > SearchAsync <T>(CancellationToken cancellationToken, IEnumerable <ISearchFilter> searchFilters = null, string orderByProperty = null, OrderByDirection?orderByDirection = null, int?skip = null, int?limit = null, int?includeLevels = null) where T : IContentfulItem, new()
{
var endpointUrl = RestEndpointResolver.GetEndpointUrl <T>(_space);
var requestUrl = GetRequestUrl(endpointUrl, null, searchFilters, orderByProperty, orderByDirection, skip, limit);
var result = await MakeGetRequestAsync(requestUrl, cancellationToken);
return(await GetItemAsync <SearchResult <T> >(result));
}
public IScanQueryDescriptor Order(OrderByDirection?order)
{
OrderValue = order;
return(this);
}
public OrderByClause(ObjectReference reference, OrderByDirection?direction = null)
{
_reference = reference;
_direction = direction.HasValue ? direction.Value : OrderByDirection.Ascending;
}
public IEnumerable <T> FindAll <T>(Expression <Func <T, bool> > predicate = null, string orderBy = null, OrderByDirection?orderDirection = null,
int?pageNumber = null, int?pageSize = null, params Expression <Func <T, object> >[] includeExpressions) where T : class, IModel
{
IQueryable <T> query = _applicationDbContext.Set <T>().AsNoTracking();
if (predicate != null)
{
query = query.Where(predicate);
}
if (!string.IsNullOrEmpty(orderBy))
{
query = orderDirection == OrderByDirection.Descending
? query.OrderBy(orderBy + " descending")
: query.OrderBy(orderBy);
}
if (pageNumber.HasValue && pageSize.HasValue)
{
query = query.Skip((pageNumber.Value - 1) * pageSize.Value).Take(pageSize.Value);
}
foreach (var include in includeExpressions)
{
query = query.Include(include).AsNoTracking();
}
return(query);
}
public IEnumerable <T> FindAll <T>(Expression <Func <T, bool> > predicate = null, Expression <Func <T, object> > orderBy = null, OrderByDirection?orderDirection = null,
int?top = null, params Expression <Func <T, object> >[] includeExpressions) where T : class, IModel
{
IQueryable <T> query = _applicationDbContext.Set <T>();
if (predicate != null)
{
query = query.Where(predicate);
}
if (orderBy != null)
{
if (orderDirection == OrderByDirection.Descending)
{
query = query.OrderByDescending(orderBy);
}
else
{
query = query.OrderBy(orderBy);
}
}
if (top.HasValue)
{
query = query.Take(top.Value);
}
foreach (var include in includeExpressions)
{
query = query.Include(include);
}
return(query);
}
public List <T> FindAllByFunc <T>(Expression <Func <T, bool> > predicate = null, Expression <Func <T, object> > orderBy = null, OrderByDirection?orderDirection = null,
int?pageNumber = null, int?pageSize = null, Func <IQueryable <T>, IQueryable <T> > func = null) where T : class, IModel
{
IQueryable <T> query = _applicationDbContext.Set <T>();
if (func != null)
{
query = func(query);
}
if (predicate != null)
{
query = query.Where(predicate);
}
if (orderBy != null)
{
if (orderDirection == OrderByDirection.Descending)
{
query = query.OrderByDescending(orderBy);
}
else
{
query = query.OrderBy(orderBy);
}
}
if (pageNumber.HasValue && pageSize.HasValue)
{
query = query.Skip((pageNumber.Value - 1) * pageSize.Value).Take(pageSize.Value);
}
return(query.ToList());
}
public async Task <IEnumerable <T> > FindAllAsync <T>(Expression <Func <T, bool> > predicate = null, Expression <Func <T, object> > orderBy = null, OrderByDirection?orderDirection = null, int?pageNumber = null, int?pageSize = null, params Expression <Func <T, object> >[] includeExpressions) where T : class, IModel
{
IQueryable <T> query = _applicationDbContext.Set <T>();
if (predicate != null)
{
query = query.Where(predicate);
}
if (orderBy != null)
{
if (orderDirection == OrderByDirection.Descending)
{
query = query.OrderByDescending(orderBy);
}
else
{
query = query.OrderBy(orderBy);
}
}
if (pageNumber.HasValue && pageSize.HasValue)
{
query = query.Skip((pageNumber.Value - 1) * pageSize.Value).Take(pageSize.Value);
}
foreach (var include in includeExpressions)
{
query = query.Include(include);
}
return(await query.ToListAsync());
}
