public static IQueryable <T> OrderBy <T>(this IQueryable <T> data,
OrderExpressions <T> mapper, params string[] arguments)
{
if (arguments.Length == 0)
{
throw new ArgumentException(@"You need at least one argument!", "arguments");
}
List <SortArgument> sorting = arguments.Select(a => new SortArgument(a)).ToList();
IQueryable <T> result = null;
for (int i = 0; i < sorting.Count; i++)
{
SortArgument sort = sorting[i];
LambdaExpression lambda = mapper[sort.Keyword];
if (i == 0)
{
result = InvokeQueryableMethod(sort.Ascending ?
OrderbyMethod : OrderbyDescendingMethod, data, lambda);
}
else
{
result = InvokeQueryableMethod(sort.Ascending ?
ThenByMethod : ThenByDescendingMethod, result, lambda);
}
}
return(result);
}
public static IOrderedEnumerable <T> OrderBy <T>(this IEnumerable <T> data,
OrderExpressions <T> mapper, params string[] arguments)
{
if (arguments.Length == 0)
{
throw new ArgumentException(@"You need at least one argument!", "arguments");
}
List <SortArgument> sorting = arguments.Select(a => new SortArgument(a)).ToList();
IOrderedEnumerable <T> result = null;
for (int i = 0; i < sorting.Count; i++)
{
SortArgument sort = sorting[i];
Func <T, object> lambda = mapper[sort.Keyword];
if (i == 0)
{
result = sorting[i].Ascending ?
data.OrderBy(lambda) :
data.OrderByDescending(lambda);
}
else
{
result = sorting[i].Ascending ?
result.ThenBy(lambda) :
result.ThenByDescending(lambda);
}
}
return(result);
}
public SelectQuery <T> OrderByDescending <F>(Expression <Func <T, F> > expression)
{
OrderExpressions.Add(new OrderExpressionContainer {
Expression = expression, IsDescending = true
});
return(this);
}
protected override void VisitOrder(Query.Expressions.OrderExpression expression)
{
OrderExpressions.Add(new OrderExpression()
{
OrderExprssion = it => it[expression.FieldName], Descending = expression.Descending
});
base.VisitOrder(expression);
}
public P OrderByDesc(params string[] columns)
{
foreach (var c in columns)
{
OrderExpressions.Add(new OrderExpression(c, OrderType.Descending));
}
return((P)Parent);
}
public SelectQuery <T> Using(IEnumerable <OrderExpressionContainer> expressions)
{
if (expressions.IsEmpty())
{
return(this);
}
OrderExpressions.AddRange(expressions);
return(this);
}
public void Test_ExtractOrderId(int orderId)
{
var order = new Order()
{
OrderId = orderId,
};
var actualOrderId = OrderExpressions.ExtractOrderId(order);
Assert.Equal(orderId, actualOrderId);
}
public void Test_AddOrderCosts(decimal cost1, decimal cost2, decimal expected)
{
var order1 = new Order()
{
Cost = cost1
};
var order2 = new Order()
{
Cost = cost2
};
var sumOfOrderCosts = OrderExpressions.SumOrderCosts(order1, order2);
Assert.Equal(expected, sumOfOrderCosts);
}
