public static LambdaExpression BuildPredicate(this FilterGroup filterGroup, Type type, VariableResolver variableResolver = null, IEnumerable <string> validProperties = null, IDictionary <string, string> propertyMapping = null)
{
if (filterGroup == null)
{
throw new ArgumentNullException(nameof(filterGroup));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var arg = new BuildArgument
{
ValidProperties = validProperties,
EvaluationType = type,
VariableResolver = variableResolver,
PropertyMapping = propertyMapping
};
if (!IsValid(filterGroup, arg))
{
throw new InvalidOperationException("The operator or property name is not valid");
}
return(FilterExtensions.BuildPredicateInternal(filterGroup.Filters, type, arg));
}
public static LambdaExpression BuildPredicate(this Filter filter, Type type, VariableResolver variableResolver = null, IEnumerable <string> validProperties = null, IDictionary <string, string> propertyMapping = null)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var arg = new BuildArgument
{
ValidProperties = validProperties,
EvaluationType = type,
VariableResolver = variableResolver,
PropertyMapping = propertyMapping
};
if (!IsValid(filter, arg))
{
throw new InvalidOperationException("The operator or property name is not valid");
}
return(Interpreter.BuildPredicate(filter.Operator.GetComparisonOperator(), arg.MapProperty(filter.Property), filter.Value, type, arg.VariableResolver));
}
public static EvaluationResult <T, bool> TryBuildPredicate <T>(this FilterGroup filterGroup, VariableResolver variableResolver = null, IEnumerable <string> validProperties = null, IDictionary <string, string> propertyMapping = null)
{
if (filterGroup == null)
{
throw new ArgumentNullException(nameof(filterGroup));
}
;
var arg = new BuildArgument
{
ValidProperties = validProperties,
EvaluationType = typeof(T),
VariableResolver = variableResolver,
PropertyMapping = propertyMapping
};
return(TryBuildPredicate <T>(filterGroup, arg));
}
public static EvaluationResult TryBuildPredicate(this Filter filter, Type type, VariableResolver variableResolver = null, IEnumerable <string> validProperties = null, IDictionary <string, string> propertyMapping = null)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var arg = new BuildArgument
{
ValidProperties = validProperties,
EvaluationType = type,
VariableResolver = variableResolver,
PropertyMapping = propertyMapping
};
return(TryBuildPredicate(filter, type, arg));
}
public static EvaluationResult <OrderByClause> TryBuildOrderByClause(this OrderByInfo orderByInfo, Type type, IEnumerable <string> validProperties = null, IDictionary <string, string> propertyMapping = null)
{
if (orderByInfo is null)
{
throw new ArgumentNullException(nameof(orderByInfo));
}
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
var arg = new BuildArgument
{
ValidProperties = validProperties,
EvaluationType = type,
PropertyMapping = propertyMapping
};
return(OrderByParser.Parse(new[] { orderByInfo }, arg));
}
public static EvaluationResult <OrderByClause> TryBuildOrderByClause(this string expression, Type type, IEnumerable <string> validProperties = null, IDictionary <string, string> propertyMapping = null)
{
if (string.IsNullOrWhiteSpace(expression))
{
throw new ArgumentException($"{nameof(expression)} is required", nameof(expression));
}
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
var arg = new BuildArgument
{
ValidProperties = validProperties,
EvaluationType = type,
PropertyMapping = propertyMapping
};
return(OrderByParser.Parse(expression, arg));
}
public static LambdaExpression BuildPredicate(this IEnumerable <Filter> filters, Type type, VariableResolver variableResolver = null, IEnumerable <string> validProperties = null, IDictionary <string, string> propertyMapping = null)
{
if (filters == null)
{
throw new ArgumentNullException(nameof(filters));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var arg = new BuildArgument
{
ValidProperties = validProperties,
EvaluationType = type,
VariableResolver = variableResolver,
PropertyMapping = propertyMapping
};
return(BuildPredicateInternal(filters, type, arg));
}
public static LambdaExpression BuildPredicate(this IEnumerable <FilterGroup> filterGroups, Type type, VariableResolver variableResolver = null, IEnumerable <string> validProperties = null, IDictionary <string, string> propertyMapping = null)
{
if (filterGroups == null)
{
throw new ArgumentNullException(nameof(filterGroups));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var arg = new BuildArgument
{
ValidProperties = validProperties,
EvaluationType = type,
VariableResolver = variableResolver,
PropertyMapping = propertyMapping
};
if (!IsValid(filterGroups, arg))
{
throw new InvalidOperationException("The operator or property name is not valid");
}
var allFilterGroups = filterGroups as FilterGroup[] ?? filterGroups.ToArray();
allFilterGroups = allFilterGroups.Where(p => p?.Filters?.Any() == true).ToArray();
if (!allFilterGroups.Any())
{
return(FilterExtensions.AlwaysTruePredicate(type));
}
var param = type.CreateParameterExpression();
var body = allFilterGroups.Aggregate((Expression)null, (current, next) => current == null
? FilterExtensions.BuildBody(next.Filters.ToArray(), param, arg)
: Expression.OrElse(current, FilterExtensions.BuildBody(next.Filters.ToArray(), param, arg)));
return(Expression.Lambda(body, param));
}
public virtual Condition BuildCondition(Type type, VariableResolver variableResolver = null, IEnumerable <string> validProperties = null, IDictionary <string, string> propertyMapping = null)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var arg = new BuildArgument
{
ValidProperties = validProperties,
VariableResolver = variableResolver,
EvaluationType = type,
PropertyMapping = propertyMapping
};
var error = new ConditionBase.ErrorInfo();
var result = new Condition();
var predicates = new List <LambdaExpression>();
var exceptions = new List <Exception>();
OrderByClause orderByClause = null;
if (Filters != null && Filters.Any())
{
var filtersResult = Filters.TryBuildPredicate(type, arg);
if (filtersResult.Succeeded)
{
predicates.Add(filtersResult.Result);
}
else
{
if (filtersResult.Exception != null)
{
exceptions.Add(filtersResult.Exception);
}
}
}
if (FilterGroups != null && FilterGroups.Any())
{
var filterGroupsResult = FilterGroups.TryBuildPredicate(type, arg);
if (filterGroupsResult.Succeeded)
{
predicates.Add(filterGroupsResult.Result);
}
else
{
if (filterGroupsResult.Exception != null)
{
exceptions.Add(filterGroupsResult.Exception);
}
}
}
if (!string.IsNullOrEmpty(Where))
{
var whereResult = ExpressionParser.Parse(Where, type, arg);
if (whereResult.Succeeded)
{
predicates.Add(whereResult.Result);
}
else
{
if (whereResult.Exception != null)
{
exceptions.Add(whereResult.Exception);
}
}
}
if (!string.IsNullOrWhiteSpace(OrderBy))
{
var orderByResult = OrderByParser.Parse(OrderBy, arg);
if (orderByResult.Succeeded)
{
orderByClause = orderByResult.Result;
}
else
{
if (orderByResult.Exception != null)
{
exceptions.Add(orderByResult.Exception);
}
}
}
else if (OrderBys != null && OrderBys.Any())
{
var orderBysResult = OrderByParser.Parse(OrderBys.ToArray(), arg);
if (orderBysResult.Succeeded)
{
orderByClause = orderBysResult.Result;
}
else
{
if (orderBysResult.Exception != null)
{
exceptions.Add(orderBysResult.Exception);
}
}
}
var isInvalid = arg.InvalidProperties.Any() || arg.InvalidOperators.Any() || arg.InvalidVariables.Any() || exceptions.Any();
result.IsValid = !isInvalid;
if (isInvalid)
{
error.EvaluationResult = new EvaluationResultBase
{
InvalidProperties = arg.InvalidProperties,
InvalidValues = arg.InvalidValues,
InvalidOperators = arg.InvalidOperators,
InvalidVariables = arg.InvalidVariables,
InvalidOrderByDirections = arg.InvalidOrderByDirections
};
error.Exceptions = exceptions;
result.Error = error;
}
else
{
result.Predicates = predicates;
result.OrderByClause = orderByClause;
}
return(result);
}
internal static Expression BuildCondition(ParameterExpression param, Filter filter, BuildArgument arg)
{
var prop = param.CreatePropertyExpression(arg.MapProperty(filter.Property));
return(Interpreter.BuildBody(filter.Operator.GetComparisonOperator(), prop, filter.Value, arg.VariableResolver));
}
internal static Expression BuildBody(Filter[] filters, ParameterExpression param, BuildArgument arg)
{
if (!filters.Any())
{
return(AlwaysTruePredicate(param.Type));
}
var condition = filters.Aggregate((Expression)null, (current, next) => current == null ? BuildCondition(param, next, arg) : Expression.AndAlso(current, BuildCondition(param, next, arg)));
return(condition);
}
internal static bool IsValid(this IEnumerable <Filter> filters, BuildArgument arg)
{
return(filters != null && filters.All(p => IsValid(p, arg)));
}
internal static bool IsValid(this Filter filter, BuildArgument arg)
{
return(arg.IsValidProperty(filter.Property) &&
!string.IsNullOrWhiteSpace(filter?.Operator) &&
Interpreter.ComparisonOperators.Contains(filter.Operator.ToLower()));
}
internal static EvaluationResult TryBuildPredicate(this IEnumerable <Filter> filters, Type type, BuildArgument arg)
{
if (filters == null)
{
throw new ArgumentNullException(nameof(filters));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (!filters.Any())
{
return new EvaluationResult
{
Succeeded = true,
Result = AlwaysTruePredicate(type)
}
}
;
var allFilters = filters as Filter[] ?? filters.ToArray();
foreach (var filter in allFilters)
{
arg.IsValidProperty(filter?.Property);
arg.IsValidOperator(filter?.Operator);
}
if (arg.InvalidOperators.Any() || arg.InvalidProperties.Any())
{
return(new EvaluationResult
{
InvalidProperties = arg.InvalidProperties,
InvalidOperators = arg.InvalidOperators
});
}
try
{
var param = type.CreateParameterExpression();
var body = BuildBody(allFilters, param, arg);
return(new EvaluationResult
{
Succeeded = true,
Result = Expression.Lambda(body, param)
});
}
catch (Exception ex)
{
return(new EvaluationResult
{
Exception = ex
});
}
}
internal static EvaluationResult TryBuildPredicate(this Filter filter, Type type, BuildArgument arg)
{
var isInvalid = !arg.IsValidProperty(filter.Property);
isInvalid |= !arg.IsValidOperator(filter.Operator);
if (isInvalid)
{
return(new EvaluationResult
{
InvalidProperties = arg.InvalidProperties,
InvalidOperators = arg.InvalidOperators
});
}
try
{
var expression = Interpreter.BuildPredicate(filter.Operator.GetComparisonOperator(), arg.MapProperty(filter.Property), filter.Value, type, arg.VariableResolver);
return(new EvaluationResult
{
Result = expression,
Succeeded = true
});
}
catch (Exception ex)
{
return(new EvaluationResult
{
Exception = ex
});
}
}
internal static EvaluationResult <IOrderedQueryable> TryOrderBy(this IQueryable source, IEnumerable <OrderByInfo> orderByInfos, BuildArgument arg)
{
var evaluationResult = OrderByParser.Parse(orderByInfos.ToArray(), arg);
if (!evaluationResult.Succeeded)
{
return(new EvaluationResult <IOrderedQueryable>
{
InvalidProperties = evaluationResult.InvalidProperties,
InvalidOrderByDirections = evaluationResult.InvalidOrderByDirections,
Exception = evaluationResult.Exception,
});
}
return(new EvaluationResult <IOrderedQueryable>
{
Result = evaluationResult.Result.Sort(source),
Succeeded = true
});
}
internal static LambdaExpression BuildPredicateInternal(this IEnumerable <Filter> filters, Type type, BuildArgument arg)
{
if (!IsValid(filters, arg))
{
throw new InvalidOperationException("The operator or property name is not valid");
}
var allFilters = filters as Filter[] ?? filters.ToArray();
if (allFilters.Length == 0)
{
return(AlwaysTruePredicate(type));
}
var param = type.CreateParameterExpression();
var body = BuildBody(allFilters, param, arg);
return(Expression.Lambda(body, param));
}
internal static EvaluationResult <IOrderedQueryable> TryOrderBy(this IQueryable source, string expression, BuildArgument arg)
{
var evaluationResult = OrderByParser.Parse(expression, arg);
if (!evaluationResult.Succeeded)
{
return(new EvaluationResult <IOrderedQueryable>
{
InvalidProperties = evaluationResult.InvalidProperties,
InvalidOrderByDirections = evaluationResult.InvalidOrderByDirections,
Exception = evaluationResult.Exception,
});
}
return(new EvaluationResult <IOrderedQueryable>
{
Result = evaluationResult.Result.Sort(source),
Succeeded = true
});
}
internal static EvaluationResult <T, bool> TryBuildPredicate <T>(this FilterGroup filterGroup, BuildArgument arg)
{
filterGroup.Filters.ForEach(f => { arg.IsValidProperty(f.Property); arg.IsValidOperator(f.Operator); });
if (arg.InvalidProperties.Any() || arg.InvalidOperators.Any())
{
return(new EvaluationResult <T, bool>
{
InvalidProperties = arg.InvalidProperties,
InvalidOperators = arg.InvalidOperators
});
}
try
{
var expression = (Expression <Func <T, bool> >)FilterExtensions.BuildPredicateInternal(filterGroup.Filters, typeof(T), arg);
return(new EvaluationResult <T, bool>
{
Result = expression,
Succeeded = true
});
}
catch (Exception ex)
{
return(new EvaluationResult <T, bool>
{
Exception = ex
});
}
}
internal static bool IsValid(FilterGroup filterGroup, BuildArgument arg)
{
return(filterGroup != null &&
filterGroup.Filters != null &&
filterGroup.Filters.All(p => p.IsValid(arg)));
}
internal static EvaluationResult TryBuildPredicate(this IEnumerable <FilterGroup> filterGroups, Type type, BuildArgument arg)
{
if (!filterGroups.Any())
{
return new EvaluationResult
{
Succeeded = true,
Result = FilterExtensions.AlwaysTruePredicate(type)
}
}
;
var allFilterGroups = filterGroups as FilterGroup[] ?? filterGroups.ToArray();
foreach (var filterGroup in allFilterGroups)
{
if (filterGroup is null)
{
throw new InvalidOperationException("FilterGroup can not be null");
}
if (filterGroup.Filters is null)
{
throw new InvalidOperationException("Filters of FilterGroup can not be null");
}
foreach (var filter in filterGroup.Filters)
{
arg.IsValidProperty(filter.Property);
arg.IsValidOperator(filter.Operator);
}
}
if (arg.InvalidOperators.Any() || arg.InvalidProperties.Any())
{
return(new EvaluationResult
{
InvalidProperties = arg.InvalidProperties,
InvalidOperators = arg.InvalidOperators
});
}
try
{
var param = type.CreateParameterExpression();
var body = allFilterGroups.Aggregate((Expression)null, (current, next) => current == null
? FilterExtensions.BuildBody(next.Filters.ToArray(), param, arg)
: Expression.OrElse(current, FilterExtensions.BuildBody(next.Filters.ToArray(), param, arg)));
return(new EvaluationResult
{
Succeeded = true,
Result = Expression.Lambda(body, param)
});
}
catch (Exception ex)
{
return(new EvaluationResult
{
Exception = ex
});
}
}
