public static IQueryProvider<TSource> HasWhere<TSource>(this IQueryProvider<TSource> query, object target,
Expression<Func<TSource, bool>> whExpression)
{
if (target != null)
{
query = query.Where(whExpression);
}
return query;
}
private static IQueryProvider <T> Contains <T>(
this IQueryProvider <T> query,
string property,
IEnumerable values)
{
if (values == null || !values.Cast <object>().Any())
{
return(query);
}
var parameterExpression = Expression.Parameter(typeof(T), "x");
var propertyExpression = (Expression)Expression.Property(parameterExpression, property);
var constantExpression = Expression.Constant(values);
var propertyExpressionIsNullable = propertyExpression.Type.IsGenericType &&
propertyExpression.Type.GetGenericTypeDefinition() == typeof(Nullable <>) &&
constantExpression.Type.GetElementType() != propertyExpression.Type;
if (propertyExpressionIsNullable)
{
propertyExpression = Expression.Property(propertyExpression, "Value");
}
Expression callExpression = Expression.Call(
typeof(Enumerable),
"Contains",
new[] { propertyExpression.Type },
constantExpression,
propertyExpression);
if (propertyExpressionIsNullable)
{
var nullablePropertyExpression = Expression.Property(parameterExpression, property);
var notEqual = Expression.NotEqual(nullablePropertyExpression, Expression.Constant(null, nullablePropertyExpression.Type));
callExpression = Expression.AndAlso(notEqual, callExpression);
}
var lambda = Expression.Lambda <Func <T, bool> >(callExpression, parameterExpression);
return(query.Where(lambda));
}
private static IQueryProvider <T> Where <T>(
this IQueryProvider <T> query,
string property,
Type valueType,
object value)
{
var parameterExpression = Expression.Parameter(typeof(T), "x");
var propertyExpression = Expression.Property(parameterExpression, property);
var method = typeof(ExpressionHelper).GetMethod("WrappedConstant");
var genericMethod = method.MakeGenericMethod(valueType);
var constantExpression = (MemberExpression)genericMethod.Invoke(null, new[] { value });
var comparandExpression = Nullable.GetUnderlyingType(propertyExpression.Type) != null
? Expression.Convert(constantExpression, propertyExpression.Type)
: (Expression)constantExpression;
var equalExpression = Expression.Equal(propertyExpression, comparandExpression);
var lambdaExpression = Expression.Lambda <Func <T, bool> >(equalExpression, parameterExpression);
return(query.Where(lambdaExpression));
}
private IQueryProvider <T> FilterData <T>(IQueryProvider <T> objectList, string search, string sortBy, string sortOrder, bool searchStartOnly, bool caseSensitive)
{
string query = "";
if (!objectList.Any())
{
return(objectList);
}
//Dynamic Search
if (!search.IsNullOrWhiteSpace())
{
search = search.ToLower();
query = SearchQueryGenerator(objectList, search, searchStartOnly, caseSensitive);
objectList = objectList.Where(query);
}
//Dynamic Order By
if (!sortBy.IsNullOrWhiteSpace() && !sortOrder.IsNullOrWhiteSpace())
{
var isAscending = sortOrder.ToLower() == "asc" ? true : false;
objectList = objectList.OrderByField(sortBy, isAscending);
}
return(objectList);
}
public static IQueryProvider <RecursionUser> IncludeSecurity(this IQueryProvider <RecursionUser> query)
{
return(query.Where(x => new Sql(string.Format("exists (select 1 from {1} where Id = {0}.Id)", x.DatabaseType.EscapeTableName(x.GetAliasFor(z => z.CreatedBy)), x.GetPocoDataFor <RecursionUser>().TableInfo.TableName))));
}
public static HashSet <TReturn> ToHashSet <TReturn>(this IQueryProvider <TReturn> enumerable,
Expression <Func <TReturn, bool> > expression)
{
return(enumerable.Where(expression).ToEnumerable().ToHashSet());
}
public virtual IFluentQueryable <T> Where(System.Linq.Expressions.Expression <Func <T, bool> > predicate)
{
_queryProvider = _queryProvider.Where(predicate);
return(this);
}
private static IQueryProvider <T> Range <T, TRange>(
this IQueryProvider <T> query,
string property,
IRange <TRange> range)
where TRange : struct
{
var parameterExpression = Expression.Parameter(typeof(T), "x");
var propertyExpression = Expression.Property(parameterExpression, property);
Expression minConstantExpression = null;
if (range.MinValue.HasValue)
{
var minValueExpression = Expression.Constant(range.MinValue);
minConstantExpression = minValueExpression.Type != propertyExpression.Type
? Expression.Convert(minValueExpression, propertyExpression.Type)
: (Expression)minValueExpression;
}
BinaryExpression minGreaterExpression = null;
if (minConstantExpression != null)
{
minGreaterExpression = range.IsMinInclusive
? Expression.GreaterThanOrEqual(propertyExpression, minConstantExpression)
: Expression.GreaterThan(propertyExpression, minConstantExpression);
}
Expression maxConstantExpression = null;
if (range.MaxValue.HasValue)
{
var maxValueExpression = Expression.Constant(range.MaxValue);
maxConstantExpression = maxValueExpression.Type != propertyExpression.Type
? Expression.Convert(maxValueExpression, propertyExpression.Type)
: (Expression)maxValueExpression;
}
BinaryExpression maxLessExpression = null;
if (maxConstantExpression != null)
{
maxLessExpression = range.IsMaxInclusive
? Expression.LessThanOrEqual(propertyExpression, maxConstantExpression)
: Expression.LessThan(propertyExpression, maxConstantExpression);
}
Expression logicExpression;
if (minGreaterExpression != null && maxLessExpression != null)
{
logicExpression = Expression.AndAlso(minGreaterExpression, maxLessExpression);
}
else if (minGreaterExpression != null)
{
logicExpression = minGreaterExpression;
}
else
{
logicExpression = maxLessExpression;
}
var lambdaExpression = Expression.Lambda <Func <T, bool> >(logicExpression, parameterExpression);
return(query.Where(lambdaExpression));
}