|
public static Or ( |
||
| left | An |
|
| right | An |
|
| return | ||
public override Expression<Func<Unbrickable.Models.Post, bool>> filterPosts(Expression<Func<Unbrickable.Models.Post, bool>> predicate)
{
if (operation != 1 && operation != 2 && operation != 3)
{
return predicate;
}
if (this.isOr)
{
Debug.WriteLine("Or " + this.operation + " on " + this.date.Date);
switch (operation)
{
case 1: return predicate.Or(x => DbFunctions.TruncateTime(x.date_posted) >= this.date);
case 2: return predicate.Or(x => DbFunctions.TruncateTime(x.date_posted) <= this.date);
case 3: return predicate.Or(x => DbFunctions.TruncateTime(x.date_posted) == this.date);
default: return predicate;
}
}
else
{
Debug.WriteLine("And " + this.operation + " on " + this.date.Date);
switch (operation)
{
case 1: return predicate.And(x => DbFunctions.TruncateTime(x.date_posted) >= this.date);
case 2: return predicate.And(x => DbFunctions.TruncateTime(x.date_posted) <= this.date);
case 3: return predicate.And(x => DbFunctions.TruncateTime(x.date_posted) == this.date);
default: return predicate;
}
}
}
public static async Task <QueryResultResource <T> > ApplyQueryObject <T>(this IQueryable <T> query,
QueryObject queryObject)
{
QueryResultResource <T> queryResult = new QueryResultResource <T>();
if (queryObject != null)
{
queryResult.MultiSelectColumns = ApplyMultiSelectColumns(query, queryObject);
if (queryObject.Filters != null && queryObject.Filters.Length > 0)
{
foreach (KeyValuePairResource filter in queryObject.Filters)
{
Expression <Func <T, bool> > allPredicates = null;
foreach (var filterValue in filter.Values)
{
string comparison = String.Empty;
if (
filterValue is long ||
filterValue is double ||
filterValue is decimal ||
filterValue == null)
{
comparison = "==";
}
else if (filterValue is string)
{
comparison = "Contains";
}
string stringFilterValue = filterValue?.ToString().ToLower();
var predicate =
ExpressionUtils.BuildPredicate <T>(
filter.Key,
comparison,
stringFilterValue
);
allPredicates = allPredicates == null ? predicate : allPredicates.Or(predicate);
}
query = query.Where(allPredicates);
}
}
if (!string.IsNullOrEmpty(queryObject.SortBy))
{
query = query.OrderBy(queryObject.SortBy, queryObject.IsSortAscending.GetValueOrDefault(true));
}
queryResult.TotalItems = query.Count();
query = query.ApplyPaging(queryObject);
}
queryResult.Items = await query.ToListAsync();
return(queryResult);
}
/// <summary>
/// Or condition join
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exp_left"></param>
/// <param name="exp_right"></param>
/// <returns></returns>
public static Expression <Func <T, bool> > Or <T>(this Expression <Func <T, bool> > exp_left, Expression <Func <T, bool> > exp_right)
{
var candidateExpr = Expression.Parameter(typeof(T), "candidate");
var parameterReplacer = new ParameterReplacer(candidateExpr);
var left = parameterReplacer.Replace(exp_left.Body);
var right = parameterReplacer.Replace(exp_right.Body);
var body = Expression.Or(left, right);
return(Expression.Lambda <Func <T, bool> >(body, candidateExpr));
}
public override Expression<Func<Unbrickable.Models.Post, bool>> filterPosts(Expression<Func<Unbrickable.Models.Post, bool>> predicate)
{
if (this.isOr)
{
Debug.WriteLine("Or " + this.min_date.Date + " to " + this.max_date.Date);
return predicate.Or(x => DbFunctions.TruncateTime(x.date_posted) >= min_date && DbFunctions.TruncateTime(x.date_posted) <= max_date);
}
else
{
Debug.WriteLine("And " + this.min_date.Date + " to " + this.max_date.Date);
return predicate.And(x => DbFunctions.TruncateTime(x.date_posted) >= min_date && DbFunctions.TruncateTime(x.date_posted) <= max_date);
}
}
public override Expression<Func<Unbrickable.Models.Post, bool>> filterPosts(Expression<Func<Unbrickable.Models.Post, bool>> predicate)
{
this.username = this.username ?? "";
if (this.isOr)
{
Debug.WriteLine("Or " + this.username);
return predicate.Or(x => x.Account.username.Equals(this.username));
}
else
{
Debug.WriteLine("And " + this.username);
return predicate.And(x => x.Account.username.Equals(this.username));
}
}
public override Expression<Func<Unbrickable.Models.Post, bool>> filterPosts(Expression<Func<Unbrickable.Models.Post, bool>> predicate)
{
this.search_contents = this.search_contents ?? "";
if (this.isOr)
{
Debug.WriteLine("Or " + this.search_contents);
return predicate.Or(x => x.entry.Contains(this.search_contents));
}
else
{
Debug.WriteLine("And " + this.search_contents);
return predicate.And(x => x.entry.Contains(this.search_contents));
}
}
private BinaryExpression BinaryExpression(
ExpressionType nodeType, System.Type type, JObject obj)
{
var left = this.Prop(obj, "left", this.Expression);
var right = this.Prop(obj, "right", this.Expression);
var method = this.Prop(obj, "method", this.Method);
var conversion = this.Prop(obj, "conversion", this.LambdaExpression);
var liftToNull = this.Prop(obj, "liftToNull").Value <bool>();
switch (nodeType)
{
case ExpressionType.Add: return(Expr.Add(left, right, method));
case ExpressionType.AddAssign: return(Expr.AddAssign(left, right, method, conversion));
case ExpressionType.AddAssignChecked: return(Expr.AddAssignChecked(left, right, method, conversion));
case ExpressionType.AddChecked: return(Expr.AddChecked(left, right, method));
case ExpressionType.And: return(Expr.And(left, right, method));
case ExpressionType.AndAlso: return(Expr.AndAlso(left, right, method));
case ExpressionType.AndAssign: return(Expr.AndAssign(left, right, method, conversion));
case ExpressionType.ArrayIndex: return(Expr.ArrayIndex(left, right));
case ExpressionType.Assign: return(Expr.Assign(left, right));
case ExpressionType.Coalesce: return(Expr.Coalesce(left, right, conversion));
case ExpressionType.Divide: return(Expr.Divide(left, right, method));
case ExpressionType.DivideAssign: return(Expr.DivideAssign(left, right, method, conversion));
case ExpressionType.Equal: return(Expr.Equal(left, right, liftToNull, method));
case ExpressionType.ExclusiveOr: return(Expr.ExclusiveOr(left, right, method));
case ExpressionType.ExclusiveOrAssign: return(Expr.ExclusiveOrAssign(left, right, method, conversion));
case ExpressionType.GreaterThan: return(Expr.GreaterThan(left, right, liftToNull, method));
case ExpressionType.GreaterThanOrEqual: return(Expr.GreaterThanOrEqual(left, right, liftToNull, method));
case ExpressionType.LeftShift: return(Expr.LeftShift(left, right, method));
case ExpressionType.LeftShiftAssign: return(Expr.LeftShiftAssign(left, right, method, conversion));
case ExpressionType.LessThan: return(Expr.LessThan(left, right, liftToNull, method));
case ExpressionType.LessThanOrEqual: return(Expr.LessThanOrEqual(left, right, liftToNull, method));
case ExpressionType.Modulo: return(Expr.Modulo(left, right, method));
case ExpressionType.ModuloAssign: return(Expr.ModuloAssign(left, right, method, conversion));
case ExpressionType.Multiply: return(Expr.Multiply(left, right, method));
case ExpressionType.MultiplyAssign: return(Expr.MultiplyAssign(left, right, method, conversion));
case ExpressionType.MultiplyAssignChecked: return(Expr.MultiplyAssignChecked(left, right, method, conversion));
case ExpressionType.MultiplyChecked: return(Expr.MultiplyChecked(left, right, method));
case ExpressionType.NotEqual: return(Expr.NotEqual(left, right, liftToNull, method));
case ExpressionType.Or: return(Expr.Or(left, right, method));
case ExpressionType.OrAssign: return(Expr.OrAssign(left, right, method, conversion));
case ExpressionType.OrElse: return(Expr.OrElse(left, right, method));
case ExpressionType.Power: return(Expr.Power(left, right, method));
case ExpressionType.PowerAssign: return(Expr.PowerAssign(left, right, method, conversion));
case ExpressionType.RightShift: return(Expr.RightShift(left, right, method));
case ExpressionType.RightShiftAssign: return(Expr.RightShiftAssign(left, right, method, conversion));
case ExpressionType.Subtract: return(Expr.Subtract(left, right, method));
case ExpressionType.SubtractAssign: return(Expr.SubtractAssign(left, right, method, conversion));
case ExpressionType.SubtractAssignChecked: return(Expr.SubtractAssignChecked(left, right, method, conversion));
case ExpressionType.SubtractChecked: return(Expr.SubtractChecked(left, right, method));
default: throw new NotSupportedException();
}
}
public void TestOr_LeftIsNull() {
_expression1 = null;
var andExpression = _expression1.Or( _expression2 ).ToLambda<Func<Person, bool>>( _parameterExpression );
Expression<Func<Person, bool>> expected = t => t.Birthday.Value.Year > 2000;
Assert.AreEqual( expected.ToString(), andExpression.ToString() );
}
// Returns true if x is not NaN or Inf
private static LinqExpr IsNotReal(LinqExpr x)
{
return(LinqExpr.Or(
LinqExpr.Call(GetMethod(x.Type, "IsNaN", x.Type), x),
LinqExpr.Call(GetMethod(x.Type, "IsInfinity", x.Type), x)));
}
public static BinaryExpression Or(Expression left, Expression right, MethodInfo method) => Expression.Or(left, right, method);
public static BinaryExpression Or(Expression left, Expression right) => Expression.Or(left, right);
public static Expression Or(Expression arg0, Expression arg1)
{
return(new Expression(LinqExpression.Or(arg0, arg1)));
}
public static Expression <Func <T, bool> > Or <T>(this Expression <Func <T, bool> > expr1, Expression <Func <T, bool> > expr2)
{
var invokedExpr = Expression.Invoke(expr2, expr1.Parameters);
return(Expression.Lambda <Func <T, bool> >(Expression.Or(expr1.Body, invokedExpr), expr1.Parameters));
}
