public static Expression Visit(
ParameterExpression param,
IFilterDescriptor ex,
FilterCompositionLogicalOperator connector = FilterCompositionLogicalOperator.And)
{
Expression expression = Expression.Constant(true);
Expression expr = null;
if (ex is CompositeFilterDescriptor)
{
int counter = 0;
var compositeFilter = ex as CompositeFilterDescriptor;
var left = compositeFilter.FilterDescriptors.FirstOrDefault();
var right = compositeFilter.FilterDescriptors.LastOrDefault();
var expr1 = Visit(param, left);
var expr2 = Visit(param, right);
expr = CombineExpressions(expr1, expr2, compositeFilter.LogicalOperator);
}
else if (ex is FilterDescriptor)
{
var filter = ex as FilterDescriptor;
expr = GetExpression(param, filter);
}
expression = CombineExpressions(expression, expr, connector);
return(expression);
}
/// <summary>
/// Creates a WhereTerm which represents SQL NOT IN clause
/// </summary>
/// <param name="expr">Expression to be looked up</param>
/// <param name="values"></param>
/// <returns></returns>
public static WhereTerm CreateNotIn(FilterCompositionLogicalOperator relationship, SqlExpression expr, SqlConstantCollection values)
{
WhereTerm term = CreateNotIn(expr, values);
term._Relationship = relationship;
return(term);
}
public FilterDescriptorCollectionExpressionBuilder(ParameterExpression parameterExpression,
IEnumerable <IFilterDescriptor> filterDescriptors, FilterCompositionLogicalOperator logicalOperator)
: base(parameterExpression)
{
this.filterDescriptors = filterDescriptors;
this.logicalOperator = logicalOperator;
}
/// <summary>
/// Creates a WhereTerm which encapsulates SQL NOT EXISTS clause
/// </summary>
/// <param name="sql">Sub query for the NOT EXISTS clause</param>
/// <returns></returns>
public static WhereTerm CreateNotExists(FilterCompositionLogicalOperator relationship, string sql)
{
WhereTerm term = CreateNotExists(sql);
term._Relationship = relationship;
return(term);
}
/// <summary>
/// Creates a WhereTerm which returns TRUE if an expression is NOT NULL
/// </summary>
/// <param name="expr"></param>
/// <returns></returns>
public static WhereTerm CreateIsNotNull(FilterCompositionLogicalOperator relationship, SqlExpression expr)
{
WhereTerm term = CreateIsNotNull(expr);
term._Relationship = relationship;
return(term);
}
/// <summary>
/// Creates a WhereTerm which represents SQL NOT IN clause
/// </summary>
/// <param name="expr">Expression to be looked up</param>
/// <param name="sql">Sub query</param>
/// <returns></returns>
public static WhereTerm CreateNotIn(FilterCompositionLogicalOperator relationship, SqlExpression expr, string sql)
{
WhereTerm term = CreateNotIn(expr, sql);
term._Relationship = relationship;
return(term);
}
/// <summary>
/// Creates a comparison WhereTerm.
/// </summary>
/// <param name="expr1">Expression on the left side of the operator</param>
/// <param name="expr2">Expression on the right side of the operator</param>
/// <param name="op">Conditional operator to be applied on the expressions</param>
/// <returns>A new conditional WhereTerm</returns>
/// <remarks>
/// A comparison term compares two expression on the basis of their values. Expressions can be of any type but their results must be of comparible types.
/// For instance, you can not compare a database OtherData of type 'date' and a static value of type 'int'.
/// </remarks>
/// <example>
/// <code>
/// ...
/// query.WherePhrase.Terms.Add(WhereTerm.CreateCompare(SqlExpression.Field("name", tCustomers), SqlExpression.String("J%"), CompareOperator.Like));
/// </code>
/// </example>
public static WhereTerm CreateCompare(FilterCompositionLogicalOperator relationship, SqlExpression expr1, SqlExpression expr2, FilterOperator op)
{
WhereTerm term = CreateCompare(expr1, expr2, op);
term._Relationship = relationship;
return(term);
}
public FilterDescriptorCollectionExpressionBuilder(
ParameterExpression parameterExpression, IEnumerable<IFilterDescriptor> filterDescriptors, FilterCompositionLogicalOperator logicalOperator)
: base(parameterExpression)
{
this.filterDescriptors = filterDescriptors;
this.logicalOperator = logicalOperator;
}
/// <summary>
/// Creates a WhereTerm which checks weather a value is in a specifed range.
/// </summary>
/// <param name="expr">Expression which yeilds the value to be checked</param>
/// <param name="lowBound">Expression which yeilds the low bound of the range</param>
/// <param name="highBound">Expression which yeilds the high bound of the range</param>
/// <returns>A new WhereTerm</returns>
/// <remarks>
/// CreateBetween only accepts expressions which yeild a 'Date' or 'Number' values.
/// All expressions must be of compatible types.
/// </remarks>
public static WhereTerm CreateBetween(FilterCompositionLogicalOperator relationship, SqlExpression expr, SqlExpression lowBound, SqlExpression highBound)
{
WhereTerm term = CreateBetween(expr, lowBound, highBound);
term._Relationship = relationship;
return(term);
}
private static Expression ComposeExpressions(Expression left, Expression right,
FilterCompositionLogicalOperator logicalOperator)
{
switch (logicalOperator)
{
case FilterCompositionLogicalOperator.Or:
return(Expression.OrElse(left, right));
default:
return(Expression.AndAlso(left, right));
}
}
/// <summary>
/// Creates the filter expression.
/// </summary>
/// <param name="parameter">The parameter.</param>
/// <param name="compositeFilterDescriptor">The composite filter descriptor.</param>
/// <param name="columnNamesForFilterClean">The column names for filter clean.</param>
/// <returns>The created expression</returns>
private Expression CreateFilterExpression(
ParameterExpression parameter,
CompositeFilterDescriptor compositeFilterDescriptor,
params string[] columnNamesForFilterClean)
{
FilterCompositionLogicalOperator logicalOperator = compositeFilterDescriptor.LogicalOperator;
Expression parametreInit;
switch (logicalOperator)
{
case FilterCompositionLogicalOperator.And:
parametreInit = Expression.Constant(true);
break;
case FilterCompositionLogicalOperator.Or:
parametreInit = Expression.Constant(false);
break;
default:
throw new ArgumentOutOfRangeException();
}
return(compositeFilterDescriptor.FilterDescriptors.Aggregate(
parametreInit,
(previous, descriptor) =>
{
Expression newFilter = this.CreateFilterExpression(parameter, descriptor);
if (previous == null)
{
return newFilter;
}
if (newFilter == null)
{
return Expression.AndAlso(previous, Expression.Constant(true));
}
switch (logicalOperator)
{
case FilterCompositionLogicalOperator.And:
return Expression.AndAlso(previous, newFilter);
case FilterCompositionLogicalOperator.Or:
return Expression.OrElse(previous, newFilter);
default:
throw new ArgumentOutOfRangeException();
}
}));
}
private static Expression ComposeExpressions(Expression left, Expression right, FilterCompositionLogicalOperator logicalOperator)
{
switch (logicalOperator)
{
case FilterCompositionLogicalOperator.Or:
{
return Expression.OrElse(left, right);
}
case FilterCompositionLogicalOperator.And:
default:
{
return Expression.AndAlso(left, right);
}
}
}
public override string ToString()
{
var result = "";
FilterCompositionLogicalOperator lastConector = FilterCompositionLogicalOperator.And;
foreach (var statement in _statements)
{
if (!string.IsNullOrWhiteSpace(result))
{
result += " " + lastConector + " ";
}
result += statement.ToString();
lastConector = statement.Connector;
}
return(result.Trim());
}
public FilterStatement(string propertyName, FilterOperator operation, TPropertyType value, FilterCompositionLogicalOperator connector = FilterCompositionLogicalOperator.And)
{
PropertyName = propertyName;
Connector = connector;
Operation = operation;
if (typeof(TPropertyType).IsArray)
{
if (operation != FilterOperator.Contains)
{
throw new ArgumentException("Only 'Operacao.Contains' supports arrays as parameters.");
}
var listType = typeof(List <>);
var constructedListType = listType.MakeGenericType(typeof(TPropertyType).GetElementType());
Value = Activator.CreateInstance(constructedListType, value);
}
else
{
Value = value;
}
}
private static Expression CombineExpressions(Expression expr1, Expression expr2, FilterCompositionLogicalOperator connector)
{
return(connector == FilterCompositionLogicalOperator.And ? Expression.AndAlso(expr1, expr2) : Expression.OrElse(expr1, expr2));
}
/// <summary>
/// Renders a relationship operator
/// </summary>
/// <param name="builder"></param>
/// <param name="relationship"></param>
protected virtual void RelationshipOperator(StringBuilder builder, FilterCompositionLogicalOperator relationship)
{
builder.AppendFormat(" {0} ", relationship.ToString().ToLower());
}
public static Expression <Func <T, bool> > GetExpression <T>(IList <IFilterDescriptor> filter, FilterCompositionLogicalOperator connector = FilterCompositionLogicalOperator.And) where T : class
{
var param = Expression.Parameter(typeof(T), "x");
Expression expression = Expression.Constant(true);
foreach (var statement in filter)
{
Expression expr = Visit(param, statement);
expression = CombineExpressions(expression, expr, connector);
}
return(Expression.Lambda <Func <T, bool> >(expression, param));
}
public static void IterateIFilterDescriptors(List <Expression> equalExpressions, ParameterExpression item, IList <IFilterDescriptor> filterDescriptors, FilterCompositionLogicalOperator logicalOperator = FilterCompositionLogicalOperator.And)
{
Expression expression = null;
if (filterDescriptors.Any(x => x is CompositeFilterDescriptor) && filterDescriptors.Count > 1)
{
List <Expression> tempEqualExpressions = filterDescriptors.Select(x => (x as FilterDescriptor).GetEqualityExpression(item)).ToList();
Expression compositeExpression = null;
if (tempEqualExpressions.Count == 2)
{
if (logicalOperator == FilterCompositionLogicalOperator.And)
{
compositeExpression = Expression.And(tempEqualExpressions[0], tempEqualExpressions[1]);
}
else if (logicalOperator == FilterCompositionLogicalOperator.Or)
{
compositeExpression = Expression.Or(tempEqualExpressions[0], tempEqualExpressions[1]);
}
}
else if (tempEqualExpressions.Count > 2)
{
if (logicalOperator == FilterCompositionLogicalOperator.And)
{
compositeExpression = Expression.And(tempEqualExpressions[0], tempEqualExpressions[1]);
}
else if (logicalOperator == FilterCompositionLogicalOperator.Or)
{
compositeExpression = Expression.Or(tempEqualExpressions[0], tempEqualExpressions[1]);
}
for (int i = 2; i < tempEqualExpressions.Count; i++)
{
if (logicalOperator == FilterCompositionLogicalOperator.And)
{
compositeExpression = Expression.And(compositeExpression, tempEqualExpressions[i]);
}
else if (logicalOperator == FilterCompositionLogicalOperator.Or)
{
compositeExpression = Expression.Or(compositeExpression, tempEqualExpressions[i]);
}
}
}
if (compositeExpression != null)
{
equalExpressions.Add(compositeExpression);
}
}
foreach (IFilterDescriptor iFilterDescriptor in filterDescriptors)
{
if (iFilterDescriptor is FilterDescriptor)
{
expression = (iFilterDescriptor as FilterDescriptor).GetEqualityExpression(item);
if (expression != null)
{
equalExpressions.Add(expression);
}
}
else if (iFilterDescriptor is CompositeFilterDescriptor)
{
IterateIFilterDescriptors(equalExpressions, item, (iFilterDescriptor as CompositeFilterDescriptor).FilterDescriptors, (iFilterDescriptor as CompositeFilterDescriptor).LogicalOperator);
}
}
}
public static string GetExperssion <T>(this IQueryable <T> items, IList <IFilterDescriptor> filter, FilterCompositionLogicalOperator opr = FilterCompositionLogicalOperator.And)
{
string q = "";
if (filter.Is(typeof(FilterDescriptor)))
{
var list = filter.Cast <FilterDescriptor>();
foreach (var i in list)
{
q += i.Operator.getOerationToString().Replace("y", i.Member).Replace("x", i.Value.ToString()) + " " + (list.Last().Value == i.Value ? " " : " " + opr.ToString() + " ");
}
}
else if (filter.Is(typeof(CompositeFilterDescriptor)))
{
foreach (var i in filter.Cast <IFilterDescriptor>())
{
if (i.GetType() == typeof(CompositeFilterDescriptor))
{
q +=
"(" +
items.GetExperssion(((CompositeFilterDescriptor)i).FilterDescriptors, ((CompositeFilterDescriptor)i).LogicalOperator)
+ " ) " +
(filter.Cast <IFilterDescriptor>().Last() == ((CompositeFilterDescriptor)i) ? " " : " And ");
}
else if (i.GetType() == typeof(FilterDescriptor))
{
q += ((FilterDescriptor)i).Operator.getOerationToString().Replace("y", ((FilterDescriptor)i).Member).Replace("x", ((FilterDescriptor)i).Value.ToString()) + " " + (filter.Cast <IFilterDescriptor>().Last() == ((FilterDescriptor)i) ? " " : " " + opr.ToString() + " ");
}
}
}
return(q);
}
protected virtual Expression VisitFilterList(IList<IFilterDescriptor> filters, FilterCompositionLogicalOperator op)
{
if (filters == null || filters.Count == 0) return Expression.Constant(true);
var expr = Visit(filters.First());
foreach (var filter in filters.Skip(1))
{
var filterExpr = Visit(filter);
switch (op)
{
case FilterCompositionLogicalOperator.And:
expr = Expression.AndAlso(expr, filterExpr); break;
case FilterCompositionLogicalOperator.Or:
expr = Expression.OrElse(expr, filterExpr); break;
}
}
return expr;
}
public void OnFilterChanged(string columnName, IEnumerable<object> distinctFilterValues, OperatorValueFilterDescriptorBase filter1, OperatorValueFilterDescriptorBase filter2, FilterCompositionLogicalOperator logicalOperator)
{
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() => { UserFunctions.SaveUserDefaultFilterSettingsAsync("Groups", columnName, distinctFilterValues, filter1, filter2, logicalOperator); }));
}
public static string LogicalOperatorToString(FilterCompositionLogicalOperator op)
{
return(op == FilterCompositionLogicalOperator.And ? "AND" : "OR");
}
public IFilterStatementConnection <TClass> By <TPropertyType>(string propertyName, FilterOperator operation, TPropertyType value, FilterCompositionLogicalOperator connector = FilterCompositionLogicalOperator.And)
{
IFilterStatement statement = null;
statement = new FilterStatement <TPropertyType>(propertyName, operation, value, connector);
_statements.Add(statement);
return(new FilterStatementConnection <TClass>(this, statement));
}
/// <summary>
/// Filters a sequence of values based on a collection of <see cref="IFilterDescriptor"/>.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="filterDescriptors">The filter descriptors.</param>
/// <param name="logicalOperator">And or Or?.</param>
/// <returns>
/// An <see cref="IQueryable" /> that contains elements from the input sequence
/// that satisfy the conditions specified by each filter descriptor in <paramref name="filterDescriptors" />.
/// </returns>
public static IQueryable Where(this IQueryable source, IEnumerable <IFilterDescriptor> filterDescriptors, FilterCompositionLogicalOperator logicalOperator = FilterCompositionLogicalOperator.And)
{
if (filterDescriptors.Any())
{
var parameterExpression = Expression.Parameter(source.ElementType, "item");
var expressionBuilder = new FilterDescriptorCollectionExpressionBuilder(parameterExpression, filterDescriptors, logicalOperator);//Modified By Moravej
expressionBuilder.Options.LiftMemberAccessToNull = source.Provider.IsLinqToObjectsProvider();
var predicate = expressionBuilder.CreateFilterExpression();
return(source.Where(predicate));
}
return(source);
}
/// <summary>
/// Creates a new WhereClause
/// </summary>
/// <param name="relationship">Relationship between all the terms and sub clauses of this clause</param>
/// <example>
/// <code>
/// SelectQuery query = new SelectQuery();
/// ...
/// query.WherePhrase.Terms.Add(WhereTerm.CreateCompare(SqlExpression.Field("name", tCustomers), SqlExpression.String("John"), CompareOperator.Equal));
/// WhereClause group = new WhereClause(WhereClauseRelationship.Or);
/// group.Terms.Add(WhereTerm.CreateBetween(SqlExpression.Field("price", tProducts), SqlExpression.Number(1), SqlExpression.Number(10)));
/// group.Terms.Add(WhereTerm.CreateIn(SqlExpression.Field("name", tProducts), new string[] {"Nail", "Hamer", "Skrewdriver"}));
/// query.WherePhrase.SubClauses.Add(group);
/// </code>
/// </example>
public WhereClause(FilterCompositionLogicalOperator relationship)
{
this.relationship = relationship;
}
