private void TranslateOrderBy(OrderByExpression node)
{
Translate(node.Source);
BsonDocument sort = new BsonDocument();
foreach (var clause in node.Clauses)
{
var field = FieldExpressionFlattener.FlattenFields(clause.Expression) as IFieldExpression;
if (field == null)
{
throw new NotSupportedException("Only fields are allowed in a $sort.");
}
var direction = clause.Direction == SortDirection.Ascending ? 1 : -1;
if (sort.Contains(field.FieldName))
{
var message = string.Format("Redundant ordering fields are not supported: {0}.", field.FieldName);
throw new NotSupportedException(message);
}
sort.Add(field.FieldName, direction);
}
_stages.Add(new BsonDocument("$sort", sort));
}
/// <summary>
/// Returns an entities response based on custom filtering function applied to the query, as well as
/// optional select and expand arguments, checking the user permissions along the way
/// </summary>
/// <param name="filterFunc">Allows you to apply any filteration you like to the query,</param>
/// <param name="expand">Optional expand argument</param>
/// <param name="select">Optional select argument</param>
protected async Task <EntitiesResponse <TEntity> > GetByCustomQuery(Func <Query <TEntity>, Query <TEntity> > filterFunc, ExpandExpression expand, SelectExpression select, OrderByExpression orderby = null)
{
// Prepare a query of the result, and clone it
var repo = GetRepository();
var query = repo.Query <TEntity>();
// Apply custom filter function
query = filterFunc(query);
// Expand the result as specified in the OData agruments and load into memory
var expandedQuery = query.Expand(expand);
expandedQuery = expandedQuery.Select(select);
expandedQuery = expandedQuery.OrderBy(orderby ?? OrderByExpression.Parse("Id")); // Required
var result = await expandedQuery.ToListAsync(); // this is potentially unordered, should that be a concern?
// Apply the permissions on the result
var permissions = await UserPermissions(Constants.Read);
var defaultMask = GetDefaultMask();
await ApplyReadPermissionsMask(result, query, permissions, defaultMask);
// Flatten and Trim
var relatedEntities = FlattenAndTrim(result, expand);
// Prepare the result in a response object
return(new EntitiesResponse <TEntity>
{
Result = result,
RelatedEntities = relatedEntities,
CollectionName = GetCollectionName(typeof(TEntity))
});
}
/// <summary>
/// Visits the order by.
/// </summary>
/// <param name="orderByExpression">The order by expression.</param>
/// <returns>
/// Expression
/// </returns>
public virtual Expression VisitOrderBy(OrderByExpression orderByExpression)
{
SqlBuilder.Append(" ");
SqlBuilder.Append(CreateOrderByString(orderByExpression));
return(orderByExpression);
}
/// <summary>
/// The SetOrderBy.
/// </summary>
/// <param name="outputQuery"> The outputQuery <see cref="IQueryable{ClassType}"/>.</param>
/// <param name="specification">The specification <see cref="ISpecification{ClassType}"/>.</param>
/// <returns>The <see cref="IQueryable{ClassType}"/>.</returns>
private static IQueryable <TEntity> SetOrderBy(IQueryable <TEntity> outputQuery, ISpecification <TEntity> specification)
{
if (specification.OrderByExpressions == null || !specification.OrderByExpressions.Any())
{
return(outputQuery);
}
OrderByExpression <TEntity> firstOrderByExpression = specification.OrderByExpressions.First();
IOrderedQueryable <TEntity> orderedQuery = firstOrderByExpression.OrderByDirection.Equals(OrderByDirection.Ascending)
? outputQuery.OrderBy(firstOrderByExpression.Expression)
: outputQuery.OrderByDescending(firstOrderByExpression.Expression);
foreach (OrderByExpression <TEntity> orderByExpression in specification.OrderByExpressions)
{
if (orderByExpression.Equals(firstOrderByExpression))
{
continue;
}
orderedQuery = orderByExpression.OrderByDirection.Equals(OrderByDirection.Ascending)
? orderedQuery.ThenBy(orderByExpression.Expression)
: orderedQuery.ThenByDescending(orderByExpression.Expression);
}
return(orderedQuery);
}
public ActionResult Groups_Select(GridCommand command)
{
var groupManager = new GroupManager();
try
{
var groups = new List <GroupGridRowModel>();
int count = groupManager.Groups.Count();
if (command != null)// filter subjects based on grid filter settings
{
FilterExpression filter = TelerikGridHelper.Convert(command.FilterDescriptors.ToList());
OrderByExpression orderBy = TelerikGridHelper.Convert(command.SortDescriptors.ToList());
groups = groupManager.GetGroups(filter, orderBy, command.Page, command.PageSize, out count).Select(GroupGridRowModel.Convert).ToList();
}
else
{
groups = groupManager.Groups.Select(GroupGridRowModel.Convert).ToList();
count = groupManager.Groups.Count();
}
return(View(new GridModel <GroupGridRowModel> {
Data = groups, Total = count
}));
}
finally
{
groupManager.Dispose();
}
}
private void VisitOrderBy(OrderByExpression node)
{
Visit(node.Source);
BsonDocument sort = new BsonDocument();
foreach (var clause in node.Clauses)
{
var serializationExpression = (SerializationExpression)clause.Expression;
var info = serializationExpression.SerializationInfo;
var name = info.ElementName;
var direction = clause.Direction == SortDirection.Ascending ? 1 : -1;
if (!sort.Contains(name))
{
sort.Add(name, direction);
}
else if (sort[name] != direction)
{
sort.Remove(name);
sort.Add(name, direction);
}
}
_stages.Add(new BsonDocument("$sort", sort));
}
/// <summary>
/// Format Order By expressions within the top ordering context
/// </summary>
/// <param name="node">order by expression</param>
/// <returns>the same expression</returns>
protected override Expression VisitOrderBy(OrderByExpression node)
{
if (node.OrderColumn is MeasureExpression)
{
this.Builder.Append(node.OrderColumn.Name);
}
else
{
this.Builder.Append(node.OrderColumn.DbName);
}
this.Builder.Append(",");
switch (node.OrderType)
{
case OrderType.Asc:
this.Builder.Append("1");
break;
case OrderType.Desc:
this.Builder.Append("0");
break;
}
return(node);
}
private string Base(Expression exp)
{
var cached = (CachedExpression)exp;
if (cached.Sql != null)
{
return(cached.Sql);
}
cached.Sql = exp switch
{
UnionExpression e => Union(e),
SelectExpression e => Select(e),
WhereExpression e => Where(e),
MaxExpression e => Max(e),
MinExpression e => Min(e),
SumExpression e => Sum(e),
CountExpression e => Count(e),
TakeExpression e => Take(e),
SkipExpression e => Skip(e),
FirstExpression e => First(e),
DistinctExpression e => Distinct(e),
OrderByExpression e => OrderBy(e),
OrderByDescendingExpression e => OrderByDescending(e),
_ => throw new InvalidEnumArgumentException()
};
return(cached.Sql);
}
private IQueryable <TQuery> AddOrderByToQuery(IQueryable <TQuery> query, OrderByExpression orderBy, string columnName, bool inReverseOrder)
{
if (orderBy == null)
{
throw new ArgumentNullException("orderBy");
}
var stack = new Stack <OrderByExpression>();
// create the global parameter reference all expressions need to use
var itemParam = Expression.Parameter(typeof(TQuery), "x");
for (var item = orderBy; item != null; item = item.Parent)
{
LambdaExpression lambda = item.KeySelector;
// if no expression was specified in the filter, create a convention-based property access expression using the column name
if (lambda == null)
{
lambda = ExpressionBuilder.CreateLambdaToProperty(typeof(TQuery), columnName);
}
// verify the lambda has exactly one parameter
if (lambda.Parameters.Count != 1)
{
throw new ArgumentException("Expected lambda expression to have exactly one parameter, not " + lambda.Parameters.Count + ".");
}
// verify the lambda's parameter is the correct type
if (lambda.Parameters[0].Type != typeof(TQuery))
{
throw new ArgumentException("Expected lambda expression parameter to be of type '" + typeof(TQuery) + "', not '" + lambda.Parameters[0].Type + "'.");
}
// pull out the body replace all parameter references with our instance, and put back into lambda
Expression newBody = ExpressionBuilder.ReplaceParameter(lambda.Body, lambda.Parameters[0], itemParam);
lambda = Expression.Lambda(newBody, itemParam);
// push this lambda on the stack
stack.Push(new OrderByExpression(lambda, item.InDescendingOrder));
}
// build the query sort expression: query.OrderBy().ThenBy().ThenByDescending()...
bool isFirstColumn = true;
foreach (OrderByExpression order in stack)
{
Type keyType = order.KeySelector.Body.Type;
var methodDelegate = s_orderByDelegateByType.GetOrAdd(keyType, (key) => BuildOrderByDelegate(key));
var useDecendingMethod = (order.InDescendingOrder ^ inReverseOrder);
query = methodDelegate(query, order.KeySelector, isFirstColumn, useDecendingMethod);
isFirstColumn = false;
}
return(query);
}
private static void ParseOrderBy(TranslatorContext context, OrderByExpression orderBy)
{
if (orderBy != null)
{
var sortOption = context.DirectorySearcher.Sort;
sortOption.Direction = (SortDirection)orderBy.Direction;
sortOption.PropertyName = GetName(orderBy.OrderByProperty.Member);
}
}
public DataTable Retrieve(long datasetId, FilterExpression filter, OrderByExpression orderBy, ProjectionExpression projection, int pageNumber = 0, int pageSize = 0)
{
// Would be better to additionally have a ToHQL() method.
var projectionClause = projection?.ToSQL();
var orderbyClause = orderBy?.ToSQL();
var whereClause = filter?.ToSQL();
return(Retrieve(datasetId, whereClause, orderbyClause, projectionClause, pageNumber, pageSize));
}
public IQueryable<Board> Get()
{
var orderBy = new OrderByExpression<Board, DateTime>(p => p.CreateDate, OrderMode.DESC);
var data = Query.Message.GetAll(Int32.MaxValue, orderBy);
if (!WebMasterCookie.IsLogin)
{
data = data.Where(p => !p.IsDeleted);
}
return data;
}
public override SqlFragment BuildOrderByMember(OrderByExpression obExpr)
{
var baseFr = base.BuildOrderByMember(obExpr);
if (obExpr.ColumnExpression.Type == typeof(string))
{
return(new CompositeSqlFragment(baseFr, _dialect.SqlCollateNoCase));
}
return(baseFr);
}
public ActionResult Subjects_Select(GridCommand command, long entityId, long instanceId)
{
var subjectManager = new SubjectManager();
var entityPermissionManager = new EntityPermissionManager();
try
{
var subjectsDb = new List <Subject>();
var count = 0;
if (command != null)// filter subjects based on grid filter settings
{
FilterExpression filter = TelerikGridHelper.Convert(command.FilterDescriptors.ToList());
OrderByExpression orderBy = TelerikGridHelper.Convert(command.SortDescriptors.ToList());
subjectsDb = subjectManager.GetSubjects(filter, orderBy, command.Page, command.PageSize, out count);
}
else
{
subjectsDb = subjectManager.Subjects.ToList();
count = subjectsDb.Count();
}
var subjects = new List <EntityPermissionGridRowModel>();
//using (PartyManager partyManager = new PartyManager())
//foreach (var subject in subjectsDb)
//{
// var rights = entityPermissionManager.GetRights(subject.Id, entityId, instanceId);
// var effectiveRights = entityPermissionManager.GetEffectiveRights(subject.Id, entityId, instanceId);
// subjects.Add(EntityPermissionGridRowModel.Convert(subject, rights, effectiveRights));
//}
var rightsDic = entityPermissionManager.GetRights(subjectsDb, entityId, instanceId);
var effectiveRightsDic = entityPermissionManager.GetEffectiveRights(subjectsDb, entityId, instanceId);
foreach (var item in rightsDic)
{
var subject = subjectsDb.Where(s => s.Id.Equals(item.Key)).FirstOrDefault();
var rights = item.Value;
var effectiveRights = effectiveRightsDic[item.Key];
subjects.Add(EntityPermissionGridRowModel.Convert(subject, rights, effectiveRights));
}
return(View(new GridModel <EntityPermissionGridRowModel> {
Data = subjects, Total = count
}));
}
finally
{
subjectManager.Dispose();
entityPermissionManager.Dispose();
}
}
public void SetOrderByExpression()
{
var tableInfo = new DatabaseMapper(new ConventionModelMapper()).GetTableInfo <Person>();
var selectExpression = new SelectExpression(tableInfo);
var expression = new OrderByExpression("FirstName");
selectExpression.SetOrderByExpression(expression);
selectExpression.OrderByExpression.Should().Be(expression);
}
/// <summary>
/// Returns a single entity as per the ID and specifications in the get request
/// </summary>
protected virtual async Task <EntitiesResponse <TEntity> > GetChildrenOfAsync(GetChildrenArguments <TKey> args)
{
// Parse the parameters
var expand = ExpandExpression.Parse(args.Expand);
var select = SelectExpression.Parse(args.Select);
var filter = FilterExpression.Parse(args.Filter);
var orderby = OrderByExpression.Parse("Node");
var ids = args.I ?? new List <TKey>();
return(await GetByCustomQuery(q => q.FilterByParentIds(ids, args.Roots).Filter(filter), expand, select, orderby));
}
/// <inheritdoc/>
public override Expression VisitOrderBy(OrderByExpression orderByExpression)
{
if (Skip == 0)
{
_orderByString = string.Empty;
return(base.VisitOrderBy(orderByExpression));
}
else
{
_orderByString = CreateOrderByString(orderByExpression);
return(orderByExpression);
}
}
private MaskTree UpdateUserMaskAsPerOrderBy(OrderByExpression orderby, MaskTree userMask)
{
if (orderby != null)
{
var orderbyPaths = orderby.Select(e => string.Join("/", e.Path.Union(new string[] { e.Property })));
var orderbyMask = MaskTree.GetMaskTree(orderbyPaths);
var orderbyAccess = Normalize(orderbyMask);
userMask = userMask.UnionWith(orderbyAccess);
}
return(userMask);
}
private void AppendOrdering(Func <ExpressionBuilder, SparqlExpression> orderExpression, bool descending)
{
_buildOrderings.Add(prefixes =>
{
var expressionBuilder = new ExpressionBuilder(prefixes);
var sparqlExpression = orderExpression.Invoke(expressionBuilder).Expression;
var orderBy = new OrderByExpression(sparqlExpression)
{
Descending = descending
};
return(orderBy);
});
}
}//method
public virtual SqlFragment BuildOrderByMember(OrderByExpression obExpr)
{
var colPart = BuildLinqExpressionSql(obExpr.ColumnExpression);
if (obExpr.Descending)
{
return(new CompositeSqlFragment(colPart, SqlTerms.Desc));
}
else
{
return(colPart);
}
}
public override IJqlClause VisitOrderBy(OrderByExpression clause)
{
var result = base.VisitOrderBy(clause);
foreach (var field in clause.Fields)
{
var fieldName = ExtractFieldName(field.Field);
var fieldType = metadataProvider.GetFieldType(fieldName);
var direction = field.Order == JqlOrderType.Asc ? JqlOrderingDirection.Asc : JqlOrderingDirection.Desc;
ordering.Add(new JqlOrdering(fieldName, fieldType, direction));
}
return(result);
}
public List <T> FindAll(OrderByExpression orderBy, LimitExpression limit)
{
List <T> ret = new List <T> (this.recordList);
if (null != orderBy)
{
ret = this.OrderBy(orderBy.orderFieldName, ret, orderBy.orderType);
}
if (null != limit)
{
ret = this.Limit(ret, limit.limit);
}
return(ret);
}
public Criteria(string path, IQueryCollection query)
{
Path = path;
Paginate = PaginateExpression.Extract(query);
Slice = SliceExpression.Extract(query);
FullTextSearch = FullTextSearchExpression <TIn> .Extract(query);
Sort = OrderByExpression <TIn> .Extract(query);
Filters = FilterCollectionExpression <TIn> .Extract(query);
Operators = OperatorCollectionExpression <TIn> .Extract(query);
Embeds = EmbedCollectionExpression <TIn> .Extract(query);
}
public override void EnterOrderByExpression(MySqlParser.OrderByExpressionContext context)
{
if (_isOtherListener == 1)
{
if (context.ChildCount > 1)
{
Rules.Remove(Rules[Rules.Count - 1]);
}
OrderByExpression OrderByExpression =
new OrderByExpression(context.SourceInterval, context, context.GetText());
Rules.Add(OrderByExpression);
}
_isOtherListener++;
}
internal Expression VisitOrderBy(OrderByExpression node)
{
string translatedFieldName = null;
if (!this.fieldNameTranslator.TryGetValue(node.FieldName, out translatedFieldName))
{
throw new NotSupportedException($"{node.FieldName} is not a supported field.");
}
this.Model.OrderByTerms.Add(new OrderByTerm()
{
FieldName = translatedFieldName,
Direction = node.Direction
});
return(node);
}
private string Translate()
{
var sb = new StringBuilder();
string selectString;
#if NETSTANDARD2_1
if (QueryType == QueryTypeEnum.AnyAsync || QueryType == QueryTypeEnum.CountAsync)
{
selectString = "COUNT()";
}
#else
if (QueryType == QueryTypeEnum.Any || QueryType == QueryTypeEnum.Count)
{
selectString = "COUNT()";
}
#endif
else
{
TranslateSelect();
selectString = string.Join(",", SelectByExpression.ToArray());
}
sb.AppendFormat("SELECT {0} FROM {1}", selectString, ObjectTypeName);
if (WhereExpression.Any())
{
sb.AppendFormat(" WHERE {0}", string.Join(" AND ", WhereExpression.ToArray()));
}
if (OrderByExpression.Any())
{
sb.AppendFormat(" ORDER BY {0}", string.Join(",", OrderByExpression.ToArray()));
}
if (Take != null)
{
sb.AppendFormat(" LIMIT {0}", Take.Value.ToString(CultureInfo.InvariantCulture));
}
if (Skip != null)
{
sb.AppendFormat(" SKIP {0}", Skip.Value.ToString(CultureInfo.InvariantCulture));
}
return(sb.ToString());
}
protected override OrderByExpression DefaultOrderBy()
{
// By default: Order currencies by name
var tenantInfo = _repo.GetTenantInfo();
string nameProperty = nameof(Currency.Name);
if (tenantInfo.SecondaryLanguageId == CultureInfo.CurrentUICulture.Name)
{
nameProperty = $"{nameof(Currency.Name2)},{nameof(Currency.Name)}";
}
else if (tenantInfo.TernaryLanguageId == CultureInfo.CurrentUICulture.Name)
{
nameProperty = $"{nameof(Currency.Name3)},{nameof(Currency.Name)}";
}
return(OrderByExpression.Parse(nameProperty));
}
/// <summary>
/// returns subset of users based on the parameters
/// and also count of filtered list
/// </summary>
/// <param name="filter"></param>
/// <param name="orderBy"></param>
/// <param name="pageNumber"></param>
/// <param name="pageSize"></param>
/// <param name="count"></param>
/// <returns></returns>
public List <User> GetUsers(FilterExpression filter, OrderByExpression orderBy, int pageNumber, int pageSize, out int count)
{
var orderbyClause = orderBy?.ToLINQ();
var whereClause = filter?.ToLINQ();
count = 0;
try
{
using (IUnitOfWork uow = this.GetUnitOfWork())
{
if (whereClause != null && orderBy != null)
{
var l = Users.Where(whereClause);
var x = l.OrderBy(orderbyClause);
var y = x.Skip((pageNumber - 1) * pageSize);
var z = y.Take(pageSize);
count = l.Count();
return(z.ToList());
}
else if (whereClause != null)
{
var filtered = Users.Where(whereClause);
count = filtered.Count();
return(filtered.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList());
}
if (orderBy != null)
{
count = Users.Count();
return(Users.OrderBy(orderbyClause).Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList());
}
count = Users.Count();
return(Users.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList());
}
}
catch (Exception ex)
{
throw new Exception(string.Format("Could not retrieve filtered users."), ex);
}
}
protected override OrderByExpression DefaultOrderBy()
{
// By default: Order report definitions by name
var tenantInfo = _repo.GetTenantInfo();
string orderby = $"{nameof(ReportDefinition.Title)},{nameof(ReportDefinition.Id)}";
if (tenantInfo.SecondaryLanguageId == CultureInfo.CurrentUICulture.Name)
{
orderby = $"{nameof(ReportDefinition.Title2)},{nameof(ReportDefinition.Title)},{nameof(ReportDefinition.Id)}";
}
else if (tenantInfo.TernaryLanguageId == CultureInfo.CurrentUICulture.Name)
{
orderby = $"{nameof(ReportDefinition.Title3)},{nameof(ReportDefinition.Title)},{nameof(ReportDefinition.Id)}";
}
return(OrderByExpression.Parse(orderby));
}
public static IQueryable <T> ApplySorting <T>(this IQueryable <T> query, OrderByExpression orderBy)
{
if (orderBy == null || orderBy.FieldNames.Length == 0)
{
return(query);
}
var condition = new List <string>();
for (int i = 0; i < orderBy.FieldNames.Length; i++)
{
var field = orderBy.FieldNames[i];
var direction = orderBy.OrderAsc[i] ? "ASC" : "DESC";
condition.Add(field + " " + direction);
}
return(query.OrderBy(condition.Join(",")));
}
public List <T> FindAll(BaseExpression expression)
{
if (null == expression)
{
return(this.recordList);
}
List <T> ret = new List <T> (this.recordList);
if (expression is OrderByExpression)
{
OrderByExpression orderByExpression = expression as OrderByExpression;
return(this.OrderBy(orderByExpression.orderFieldName, ret, orderByExpression.orderType));
}
else if (expression is LimitExpression)
{
LimitExpression limitExpression = expression as LimitExpression;
return(this.Limit(ret, limitExpression.limit));
}
return(ret);
}
public IList<Board> GetRecent()
{
var orderBy = new OrderByExpression<Board, DateTime>(p => p.CreateDate, OrderMode.DESC);
return _boardRepository.GetAll(10, p => !p.IsDeleted, orderBy).ToList();
}
public IList<Board> FindAll(int count)
{
var orderBy = new OrderByExpression<Board, DateTime>(p => p.CreateDate, OrderMode.DESC);
return _boardRepository.GetAll(count, orderBy).ToList();
}
