public static IEnumerable <TEntity> Order <TEntity, TKey>(
this IEnumerable <TEntity> source, Func <TEntity, TKey> keySelector, OrderDirectionEnum sort)
{
return(sort == OrderDirectionEnum.ASC
? source.OrderBy(keySelector)
: source.OrderByDescending(keySelector));
}
public OrderByItemSegment(int startIndex, int stopIndex, OrderDirectionEnum orderDirection, OrderDirectionEnum nullOrderDirection)
{
_startIndex = startIndex;
_stopIndex = stopIndex;
_orderDirection = orderDirection;
_nullOrderDirection = nullOrderDirection;
}
public override IASTNode VisitOrderByItem(SqlServerCommandParser.OrderByItemContext context)
{
OrderDirectionEnum orderDirection = null != context.DESC() ? OrderDirectionEnum.DESC : OrderDirectionEnum.ASC;
if (null != context.columnName())
{
ColumnSegment column = (ColumnSegment)Visit(context.columnName());
return(new ColumnOrderByItemSegment(column, orderDirection));
}
if (null != context.numberLiterals())
{
return(new IndexOrderByItemSegment(context.numberLiterals().Start.StartIndex, context.numberLiterals().Stop.StopIndex,
(int)SqlUtil.GetExactlyNumber(context.numberLiterals().GetText(), 10), orderDirection));
}
return(new ExpressionOrderByItemSegment(context.expr().Start.StartIndex, context.expr().Stop.StopIndex, context.expr().GetText(), orderDirection));
}
public static int CompareTo(IComparable thisValue, IComparable otherValue, OrderDirectionEnum orderDirection, OrderDirectionEnum nullOrderDirection, bool caseSensitive)
{
if (null == thisValue && null == otherValue)
{
return(0);
}
if (null == thisValue)
{
return(orderDirection == nullOrderDirection ? -1 : 1);
}
if (null == otherValue)
{
return(orderDirection == nullOrderDirection ? 1 : -1);
}
if (!caseSensitive && thisValue is string && otherValue is string)
{
return(CompareToCaseInsensitiveString((string)thisValue, (string)otherValue, orderDirection));
}
return(OrderDirectionEnum.ASC == orderDirection?thisValue.CompareTo(otherValue) : -thisValue.CompareTo(otherValue));
}
/// <summary>
/// Order <see cref="IOrderedQueryable{TSource}"/> then by
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="source"></param>
/// <param name="sortColum">name of the column to sort on</param>
/// <param name="orderDirection"><see cref="OrderDirectionEnum"/></param>
/// <returns></returns>
public static IOrderedQueryable <TSource> ThenBy <TSource>(this IOrderedQueryable <TSource> source, string sortColum, OrderDirectionEnum orderDirection)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
return(OrderByInternal.QueryableOrderThenBy(source, new OrderItem {
SortColum = sortColum, OrderDirection = orderDirection
}));
}
/// <summary>
/// Order an <see cref="IEnumerable{TSource}"/>
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="source"></param>
/// <param name="sortColum">name of the column to sort on</param>
/// <param name="orderDirection"><see cref="OrderDirectionEnum"/></param>
/// <returns></returns>
public static IOrderedEnumerable <TSource> OrderBy <TSource>(this IEnumerable <TSource> source, string sortColum, OrderDirectionEnum orderDirection)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (string.IsNullOrWhiteSpace(sortColum))
{
throw new ArgumentException("Input cannot be null or empty", "sortColum");
}
return(OrderByInternal.EnumerableOrder(source, new OrderItem {
SortColum = sortColum, OrderDirection = orderDirection
}, out _));
}
private static int CompareToCaseInsensitiveString(string thisValue, string otherValue, OrderDirectionEnum orderDirection)
{
int result = String.Compare(thisValue.ToUpper(), otherValue.ToUpper(), StringComparison.Ordinal);
return(OrderDirectionEnum.ASC == orderDirection ? result : -result);
}
protected TextOrderByItemSegment(int startIndex, int stopIndex, OrderDirectionEnum orderDirection, OrderDirectionEnum nullOrderDirection)
: base(startIndex, stopIndex, orderDirection, nullOrderDirection)
{
}
public static List <User> GetUsers(string userTypes, string userName, ActiveStateEnum active, int?pageNumber, int?pageSize,
UserOrderEnum order, OrderDirectionEnum orderDirection)
{
return(usersInMemory);
}
/// <summary>
/// Sort Alphanumeric as Alphanumeric and numeric as numeric
/// </summary>
public NaturalSortComparer()
{
_orderDirection = OrderDirectionEnum.Ascending;
}
public IndexOrderByItemSegment(int startIndex, int stopIndex, int columnIndex, OrderDirectionEnum orderDirection)
: base(startIndex, stopIndex, orderDirection, OrderDirectionEnum.ASC)
{
this._columnIndex = columnIndex;
}
public ColumnOrderByItemSegment(ColumnSegment column, OrderDirectionEnum orderDirection)
: base(column.GetStartIndex(), column.GetStopIndex(), orderDirection, OrderDirectionEnum.ASC)
{
this._column = column;
}
public ExpressionOrderByItemSegment(int startIndex, int stopIndex, string expression, OrderDirectionEnum orderDirection, OrderDirectionEnum nullOrderDirection) : base(startIndex, stopIndex, orderDirection, nullOrderDirection)
{
_expression = expression;
}
public ExpressionOrderByItemSegment(int startIndex, int stopIndex, string expression, OrderDirectionEnum orderDirection) : this(startIndex, stopIndex, expression, orderDirection, OrderDirectionEnum.ASC)
{
}
/// <summary>
/// Order <see cref="IOrderedQueryable{TSource}"/> then by
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TKey"></typeparam>
/// <param name="source"></param>
/// <param name="sortColum"></param>
/// <param name="orderDirection"><see cref="OrderDirectionEnum"/></param>
/// <param name="comparer"><see cref="IComparer{TKey}" /></param>
/// <returns></returns>
public static IOrderedQueryable <TSource> ThenBy <TSource, TKey>(this IOrderedQueryable <TSource> source, string sortColum, OrderDirectionEnum orderDirection, IComparer <TKey> comparer)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (string.IsNullOrWhiteSpace(sortColum))
{
throw new ArgumentException("Input cannot be null or empty", "sortColum");
}
return(OrderByInternal.QueryableOrderThenBy(source, new OrderItem <TKey> {
SortColum = sortColum, OrderDirection = orderDirection, Comparer = comparer
}));
}
public async Task <PagedData <T> > PageAsync(ISpecification <T> specification, int pageIndex, int pageSize, string sortBy = null, OrderDirectionEnum sortDirection = OrderDirectionEnum.OrderBy)
{
var pagedData = new PagedData <T>();
var query = specification.HasPredicate ? specification.Prepare(Query()) : Query();
if (!string.IsNullOrEmpty(sortBy))
{
var parameter = Expression.Parameter(typeof(T), "p");
var property = typeof(T).GetProperty(sortBy);
var propertyAccess = Expression.MakeMemberAccess(parameter, property);
var orderByExpression = Expression.Lambda(propertyAccess, parameter);
Expression resultExpression = Expression.Call(typeof(Queryable), sortDirection.ToString(), new Type[] { typeof(T), property.PropertyType }, query.Expression, Expression.Quote(orderByExpression));
query = query.Provider.CreateQuery <T>(resultExpression);
}
var queryProjected = query.Skip(pageIndex * pageSize).Take(pageSize);
pagedData.TotalCount = await CountAsync(specification);
pagedData.Data = await queryProjected.ToListAsync();
return(pagedData);
}
/// <summary>
/// Sort Alphanumeric as Alphanumeric and numeric as numeric
/// </summary>
/// <param name="isDescending">Is the order direction descending</param>
public NaturalSortComparer(bool isDescending)
{
_orderDirection = Orderby.GetOrderDirection(isDescending);
}
public FilterOrder(string fieldName, OrderDirectionEnum order)
{
FieldName = fieldName;
OrderDirection = order;
}
/// <summary>
/// Sort Alphanumeric as Alphanumeric and numeric as numeric
/// </summary>
/// <param name="orderDirection"><see cref="OrderDirectionEnum"/></param>
public NaturalSortComparer(OrderDirectionEnum orderDirection)
{
_orderDirection = orderDirection;
}
