private bool CompareFilter(QueryLogicalFilter filter, LogicalOperator logicalOperator, string field, ComparisonOperator comparisonOperator, string value)
{
return(filter.Operator == logicalOperator &&
filter.Filter.Field == field &&
filter.Filter.Operator == comparisonOperator &&
Enumerable.SequenceEqual(filter.Filter.Values, (value != null ? value.Split(',') : new string[] { })));
}
private Expression BuildInExpression(Expression member, QueryLogicalFilter logicalFilter, bool isIn)
{
var typedList = _listProvider.GetTypedList(logicalFilter.Filter.Values, member.Type, typeof(List <>));
var listExpression = Expression.Constant(typedList);
var containsMethod = typedList.GetType().GetMethod("Contains", new Type[] { member.Type });
return(Expression.Equal(Expression.Call(listExpression, containsMethod, member), Expression.Constant(isIn)));
}
private Expression GetPropertyComparisonExpression(Expression member, QueryLogicalFilter logicalFilter)
{
object value = ConvertValue(member.Type, logicalFilter.Filter.Values.FirstOrDefault());
switch (logicalFilter.Filter.Operator)
{
case ComparisonOperator.Equal:
return(Expression.Equal(member, Expression.Convert(Expression.Constant(value), member.Type)));
case ComparisonOperator.NotEqual:
return(Expression.NotEqual(member, Expression.Convert(Expression.Constant(value), member.Type)));
case ComparisonOperator.Greater:
return(Expression.GreaterThan(member, Expression.Convert(Expression.Constant(value), member.Type)));
case ComparisonOperator.GreaterOrEqual:
return(Expression.GreaterThanOrEqual(member, Expression.Convert(Expression.Constant(value), member.Type)));
case ComparisonOperator.Less:
return(Expression.LessThan(member, Expression.Convert(Expression.Constant(value), member.Type)));
case ComparisonOperator.LessOrEqual:
return(Expression.LessThanOrEqual(member, Expression.Convert(Expression.Constant(value), member.Type)));
case ComparisonOperator.In:
return(BuildInExpression(member, logicalFilter, isIn: true));
case ComparisonOperator.NotIn:
return(BuildInExpression(member, logicalFilter, isIn: false));
case ComparisonOperator.Like:
return(BuildLikeExpression(member, value, isLike: true));
case ComparisonOperator.NotLike:
return(BuildLikeExpression(member, value, isLike: false));
case ComparisonOperator.Null:
return(Expression.Equal(member, Expression.Constant(null)));
case ComparisonOperator.NotNull:
return(Expression.NotEqual(member, Expression.Constant(null)));
}
throw new NotImplementedException(nameof(ComparisonOperator));
}
public void Build_ValidData_PlainFilter()
{
var logicalFilters = new QueryLogicalFilter[]
{
new QueryLogicalFilter
{
Operator = LogicalOperator.And,
Filter = new QueryComparisonFilter
{
Field = "name",
Operator = ComparisonOperator.In,
Values = new List <string>
{
"University of Pennsylvania",
"University of Minnesota"
}
}
},
new QueryLogicalFilter
{
Operator = LogicalOperator.Or,
Filter = new QueryComparisonFilter
{
Field = "yearofestablishment",
Operator = ComparisonOperator.Equal,
Values = new List <string> {
"1891"
}
}
}
};
string expectedPlainFilter = "name" + ComparisonOperator.In.Encoded() + "University of Pennsylvania" + Encoded.COMMA +
"University of Minnesota" + LogicalOperator.Or.Encoded() + "yearofestablishment" + ComparisonOperator.Equal.Encoded() + "1891";
Assert.Equal(expectedPlainFilter, new PlainFilterBuilder().Build(logicalFilters));
}
private Expression AppendExpression(QueryLogicalFilter filter, Expression currentExpression, Expression newExpression)
{
return(currentExpression != null ?
(filter.Operator == LogicalOperator.And ? Expression.AndAlso(currentExpression, newExpression) : Expression.OrElse(currentExpression, newExpression)) :
newExpression);
}