/// <summary>
/// Search
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
//[AbpAuthorize(PermissionNames.GlobalConfiguration_Users_Read)]
public List <DeviceDto> QueryInfoSearch(QueryInfo input)
{
var obj = new QueryInfo();
var skipNum = input.Skip;
var takeNum = input.Take;
var query = _deviceRepository.GetAll();
var sorters = input.Sorters;
var rules = input.Filter.Rules;
var condition = input.Filter.Condition;
var parameterEx = Expression.Parameter(typeof(Device), "x");
Expression containsExpression = Expression.Constant(false);
Expression currentContainsExpression;
Expression result;
foreach (var property in input.SearchProperties)
{
currentContainsExpression = obj.GetBinaryExpression(parameterEx, "ct", property, input.SearchText);
containsExpression = Expression.OrElse(containsExpression, currentContainsExpression);
}
result = obj.GetFilteredList <Device>(parameterEx, rules, condition);
result = Expression.AndAlso(containsExpression, result);
var whereEx = obj.GetWhere <Device>(result, parameterEx);
query = query.Where(whereEx);
var sortedFirst = false;
foreach (var sort in sorters)
{
var sortProperty = sort.Property;
var sortDirection = sort.Direction;
switch (sortDirection)
{
case "asc":
if (!sortedFirst)
{
query = query.OrderBy(obj.GetOrderByExpression <Device>(sortProperty));
sortedFirst = true;
}
else
{
query = ((IOrderedQueryable <Device>)query).ThenBy(
obj.GetOrderByExpression <Device>(sortProperty));
}
break;
case "desc":
if (!sortedFirst)
{
query = query.OrderByDescending(obj.GetOrderByExpression <Device>(sortProperty));
sortedFirst = true;
}
else
{
query = ((IOrderedQueryable <Device>)query).ThenByDescending(
obj.GetOrderByExpression <Device>(sortProperty));
}
break;
default:
throw new InvalidOperationException();
}
}
query = query.Skip(skipNum).Take(takeNum);
var queryToReturn = ObjectMapper.Map <List <DeviceDto> >(query);
return(queryToReturn.ToList());
}
// -------EXPRESSION SAMPLE------- //
public IQueryable <Usage> QueryInfo(QueryInfo input)
{
var obj = new QueryInfo();
var query = _context.Usages.Include(p => p.Person).Include(d => d.Device).AsQueryable();
var rules = input.Filter.Rules;
var sorters = input.Sorters;
var condition = input.Filter.Condition;
var skipNum = input.Skip;
var takeNum = input.Take > 0 ? input.Take : 1;
ParameterExpression parameterEx = Expression.Parameter(typeof(Usage), "x");
Expression result;
if (condition == "and")
{
Expression <Func <Usage, bool> > trueExp = x => true;
result = trueExp.Body;
}
else
{
Expression <Func <Usage, bool> > falseExp = x => false;
result = falseExp.Body;
}
foreach (var rule in rules)
{
var property = rule.Property;
var binOperator = rule.Operator;
var value = rule.Value;
var binaryExpression = obj.GetBinaryExpression(parameterEx, binOperator, property, value);
switch (condition)
{
case "and":
result = Expression.AndAlso(result, binaryExpression);
break;
case "or":
result = Expression.OrElse(result, binaryExpression);
break;
default:
throw new InvalidOperationException();
}
}
var whereEx = obj.GetWhere <Usage>(result, parameterEx);
query = query.Where(whereEx);
bool sortedFirst = false;
foreach (var sort in sorters)
{
var sortProperty = sort.Property;
var sortDirection = sort.SortDirection;
switch (sortDirection)
{
case "asc":
if (!sortedFirst)
{
query = query.OrderBy(obj.GetOrderByExpression <Usage>(sortProperty));
sortedFirst = true;
}
else
{
query = ((IOrderedQueryable <Usage>)query).ThenBy(obj.GetOrderByExpression <Usage>(sortProperty));
}
break;
case "desc":
if (!sortedFirst)
{
query = query.OrderByDescending(obj.GetOrderByExpression <Usage>(sortProperty));
sortedFirst = true;
}
else
{
query = ((IOrderedQueryable <Usage>)query).ThenByDescending(obj.GetOrderByExpression <Usage>(sortProperty));
}
break;
default:
throw new InvalidOperationException();
}
}
query = query.Skip(skipNum).Take(takeNum);
return(query);
//var op = input.Filter.Rules[0].Operator;
//var prop = input.Filter.Rules[0].Property;
//var src = input.Filter.Rules[0].Value;
//var ob = input.Sorters[0].Property;
//var qu = new QueryInfo();
//var whereExFilter = qu.GetWhereExpression<Usage>(op, prop, src);
//var orderByFilter = qu.GetOrderByExpression<Usage>(ob);
//query = query.OrderBy(x => x.UsedFrom);
//query = ((IOrderedQueryable<Usage>) query).ThenBy(x => x.Id);
//return query.Where(whereExFilter).OrderBy(orderByFilter);
}