private static Expression GetExpressionOperation(FilterOperations operation, MemberExpression member, UnaryExpression valueExpression)
{
switch (operation)
{
case FilterOperations.Equals:
return(Expression.Equal(member, valueExpression));
case FilterOperations.NotEquals:
return(Expression.NotEqual(member, valueExpression));
case FilterOperations.GreaterThan:
return(Expression.GreaterThan(member, valueExpression));
case FilterOperations.GreaterThanOrEqual:
return(Expression.GreaterThanOrEqual(member, valueExpression));
case FilterOperations.LessThan:
return(Expression.LessThan(member, valueExpression));
case FilterOperations.LessThanOrEqual:
return(Expression.LessThanOrEqual(member, valueExpression));
case FilterOperations.Contains:
return(Expression.Call(member, containsMethod, valueExpression));
case FilterOperations.StartsWith:
return(Expression.Call(member, startsWithMethod, valueExpression));
case FilterOperations.EndsWith:
return(Expression.Call(member, endsWithMethod, valueExpression));
}
return(null);
}
//public static Expression FilterByNavigationProperty(
// ParameterExpression source,
// string propName,
// FilterOperations filterOperation,
// object itemValue)
//{
// var s = propName.Split(".");
// Expression propProperty = source;
// foreach (var member in propName.Split('.'))
// {
// propProperty = Expression.PropertyOrField(propProperty, member);
// var t = propProperty.Type;
// if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IDictionary<,>))
// {
// return FilterByDictionayProperty(source, propName, propName.Split('.').Last(), filterOperation, itemValue);
// }
// }
// if (propProperty.Type.IsArray)
// {
// return ArrayContainsValue(propProperty, itemValue);
// }
// return MakePropertyValueComparison(propProperty, filterOperation, itemValue);
//}
/// <summary>
/// ChildrenCountPredicate
/// </summary>
/// <typeparam name="T">T is the type of the Target object the filer acts on</typeparam>
/// <param name="collection">Collection Property Expression.</param>
/// <param name="itemName">Property Name on the Children Object</param>
/// <param name="itemComparison">Comparison Operator: ExpressionType.Equal</param>
/// <param name="itemValue">Comparison Value</param>
/// <param name="countComparison">Count Comparison: ExpressionType.GreaterThan, ExpressionType.LessThan etc.</param>
/// <param name="countValue">Count Comparison Value</param>
/// <returns>Expression</returns>
/// <source>https://www.codesd.com/item/expression-trees-filtered-account-on-navigation-property.html</source>
/// <usage>
/// Usage: db.Event.Where(s => s.Attendees.Count(a => a.CancelledOn == null) > 10);
/// var predicate = MakeCountPredicate<Event>("Attendees","CancelledOn", ExpressionType.Equal, "null", ExpressionType.GreaterThan, 10);
/// </usage>
public static Expression <Func <T, bool> > ChildrenCountPredicate <T>(
string propName,
string itemName,
FilterOperations itemComparison,
object itemValue,
FilterOperations countComparison,
int countValue)
{
var source = Expression.Parameter(typeof(T), "p");
Expression propExpr = source;
foreach (var member in propName.Split('.'))
{
propExpr = Expression.PropertyOrField(propExpr, member);
var t = propExpr.Type;
if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ICollection <>))
{
var expr = ChildrenAggregationFunc(Aggregations.Count, propExpr, itemName, itemComparison, itemValue, countComparison, countValue);
return(Expression.Lambda <Func <T, bool> >(expr, source));
}
}
return(null);
}
public Expression <Func <FilteredClass, bool> > GetFilterPredicateFor(FilterOperations operation, string value)
{
var getExpressionBody = CollectionPropertySelector.Body as MemberExpression;
if (getExpressionBody == null)
{
throw new Exception("getExpressionBody is not MemberExpression: " + CollectionPropertySelector.Body);
}
var propertyParameter = CollectionPropertySelector.Parameters[0];
var collectionParameter = CollectionSelector.Parameters[0];
var left = CollectionPropertySelector.Body;
var right = Expression.Constant(value);
var innerLambda = Expression.Equal(left, right);
var innerFunction = Expression.Lambda <Func <CollectionProperty, bool> >(innerLambda, propertyParameter);
var method = typeof(Enumerable).GetMethods().Where(m => m.Name == "Any" && m.GetParameters().Length == 2).Single().MakeGenericMethod(typeof(CollectionProperty));
var outerLambda = Expression.Call(method, Expression.Property(collectionParameter, (CollectionSelector.Body as MemberExpression).Member as System.Reflection.PropertyInfo), innerFunction);
var result = Expression.Lambda <Func <FilteredClass, bool> >(outerLambda, collectionParameter);
return(result);
}
/// <summary>
/// Convert the FilterOperations To ExpressionType
/// </summary>
/// <returns>The expression.</returns>
/// <param name="fo">Fo.</param>
public static ExpressionType ToExpression(this FilterOperations fo)
{
if (fo == FilterOperations.Eq)
{
return(ExpressionType.Equal);
}
if (fo == FilterOperations.Gt)
{
return(ExpressionType.GreaterThan);
}
if (fo == FilterOperations.Gte)
{
return(ExpressionType.GreaterThanOrEqual);
}
if (fo == FilterOperations.Lt)
{
return(ExpressionType.LessThan);
}
if (fo == FilterOperations.Lte)
{
return(ExpressionType.LessThanOrEqual);
}
if (fo == FilterOperations.Neq)
{
return(ExpressionType.NotEqual);
}
return(ExpressionType.New);
}
/// <summary>
/// ChildrenAny
/// </summary>
/// <typeparam name="T">T is the type of the Target object the filer acts on</typeparam>
/// <param name="propExpr">CollectionNavigation Property Expression</param>
/// <param name="itemName">Property Name on the Children Object</param>
/// <param name="itemComparison">Comparison Operator: ExpressionType.Equal</param>
/// <param name="itemValue">Comparison Value</param>
/// <returns>Expression</returns>
/// <source>https://www.codesd.com/item/expression-trees-filtered-account-on-navigation-property.html</source>
/// <usage>
/// Usage: db.Event.Where(s => s.Attendees.Any(a => a.CancelledOn == null));
/// var predicate = MakeAnyPredicate<Event>("Attendees","CancelledOn", ExpressionType.Equal, "null");
/// </usage>
public static Expression ChildrenHaveAny(
Expression propExpr,
string itemName,
FilterOperations itemComparison,
object itemValue)
{
return(ChildrenAggregationFunc(Aggregations.Any, propExpr, itemName, itemComparison, itemValue, FilterOperations.Eq, true));
}
public static Expression <Func <T, bool> > FilterByProperty <T>(
string propName,
FilterOperations filterOperator,
object itemValue)
{
var source = Expression.Parameter(typeof(T), "p");
return(Expression.Lambda <Func <T, bool> >(FilterByProperty(source, propName, filterOperator, itemValue), source));
}
public static IEnumerable <string> GetOperators(FilterOperations op)
{
switch (op)
{
case FilterOperations.Comparition: return(new string[] { "<", "<=", "=", "!=", ">", ">=" });
case FilterOperations.List: return(new string[] { "in", "not in" });
default: throw new NotSupportedException($"The operation '{op.ToString()}' is not supported and does not have any operators.");
}
}
private void SetFilterInfo(DataGridViewRow row, FilterInfo filterInfo)
{
if (filterInfo.ColumnDescriptor == null)
{
row.Cells[colFilterColumn.Index].Value = filterInfo.FilterSpec.Column;
row.Cells[colFilterColumn.Index].Style.Font = new Font(dataGridViewFilter.Font, FontStyle.Strikeout);
row.Cells[colFilterColumn.Index].ToolTipText = Resources.CustomizeViewForm_SetFilterInfo_This_column_does_not_exist;
}
else
{
row.Cells[colFilterColumn.Index].Value = filterInfo.ColumnDescriptor.GetColumnCaption(ColumnCaptionType.localized);
row.Cells[colFilterColumn.Index].Style.Font = dataGridViewFilter.Font;
row.Cells[colFilterColumn.Index].ToolTipText = null;
row.Cells[colFilterOperand.Index].Value = filterInfo.FilterSpec.Predicate.GetOperandDisplayText(filterInfo.ColumnDescriptor);
}
var filterOpCell = (DataGridViewComboBoxCell)row.Cells[colFilterOperation.Index];
filterOpCell.Value = filterInfo.FilterSpec.Predicate.FilterOperation.DisplayName;
var filterOpItems = FilterOperations.ListOperations()
.Where(filterOp => filterOp == filterInfo.FilterSpec.Predicate.FilterOperation ||
filterInfo.ColumnDescriptor == null ||
filterOp.IsValidFor(filterInfo.ColumnDescriptor))
.Select(filterOp => filterOp.DisplayName)
.ToArray();
filterOpCell.DataSource = filterOpItems;
if (filterInfo.FilterSpec.Operation.GetOperandType(filterInfo.ColumnDescriptor) == null)
{
row.Cells[colFilterOperand.Index].ReadOnly = true;
row.Cells[colFilterOperand.Index].Style.BackColor = Color.DarkGray;
}
else
{
row.Cells[colFilterOperand.Index].ReadOnly = false;
row.Cells[colFilterOperand.Index].Style.BackColor = colFilterOperand.DefaultCellStyle.BackColor;
}
foreach (DataGridViewCell cell in row.Cells)
{
if (filterInfo.Error != null)
{
cell.Style.BackColor = Color.Red;
cell.ToolTipText = filterInfo.Error;
}
else
{
cell.Style.BackColor = dataGridViewFilter.DefaultCellStyle.BackColor;
cell.ToolTipText = null;
}
}
}
public static Expression GetExpression(Expression left, Expression right, FilterOperations operation)
{
Expression exprBody = null;
switch (operation)
{
case FilterOperations.Equal:
exprBody = Expression.Equal(left,
right);
break;
case FilterOperations.NotEqual:
exprBody = Expression.NotEqual(left, right);
break;
case FilterOperations.GreaterThan:
exprBody = Expression.GreaterThan(left, right);
break;
case FilterOperations.LessThan:
exprBody = Expression.LessThan(left, right);
break;
case FilterOperations.GreaterThanOrEqual:
exprBody = Expression.GreaterThanOrEqual(left, right);
break;
case FilterOperations.LessThanOrEqual:
exprBody = Expression.LessThanOrEqual(left, right);
break;
//case FilterOperations.In:
// break;
//case FilterOperations.NotIn:
// break;
//case FilterOperations.Between:
// break;
case FilterOperations.Like:
exprBody = Expression.Equal(
Expression.Call(left,
typeof(String).GetMethod("Contains"),
new Expression[] { (ConstantExpression)right }), Expression.Constant(true));
break;
default:
break;
}
return(exprBody);
}
public static IQueryable <TEntity> ApplyFilters <TEntity, TKey>(
this IQueryable <TEntity> source,
Expression <Func <TEntity, TKey> > selector,
FilterOperations <TKey> filters)
{
var filterExpressions = new List <Expression <Func <TEntity, bool> > >();
filterExpressions.AddRange(CreateFilters <TEntity, TKey>(selector, filters));
foreach (var expression in filterExpressions)
{
source = source.Where(expression);
}
return(source);
}
//public Expression<Func<O, bool>> GetFilterPredicateFor(IList<FilterExpression<O>> filterExpressionList)
//{
// T typedValue;
// Type type = typeof(T);
// bool nullable = Nullable.GetUnderlyingType(type) != null;
// object conversionResult;
// BinaryExpression filterValue= Expression.MakeBinary( ExpressionType.Equal,Expression.Constant(1),Expression.Constant(1));
// ;
// Expression<Func<O, bool>> filterExValue;
// FilterExpression<O> firstElement = new FilterExpression<O>();
// if (filterExpressionList.Count == 0)
// {
// return null;
// }
// if (filterExpressionList.Count == 1)
// {
// firstElement = filterExpressionList.First();
// return GetFilterPredicateFor(firstElement.FilterOperation, firstElement.Value);
// //return filterValue;
// }
// //firstElement = filterExpressionList.First();
// //filterValue = GetFilterPredicateBinary(firstElement.FilterOperation, firstElement.Value);
// foreach (var item in filterExpressionList.Skip(1))
// {
// if (nullable)
// {
// type = Nullable.GetUnderlyingType(type);
// if (item.Value == "NULL")
// {
// conversionResult = null;
// }
// else
// {
// if (type.IsEnum)
// {
// conversionResult = (T)Enum.Parse(type, item.Value);
// }
// else
// {
// conversionResult = Convert.ChangeType(item.Value, type);
// }
// }
// }
// else
// {
// if (type.IsEnum)
// {
// conversionResult = (T)Enum.Parse(type, item.Value);
// }
// else
// {
// conversionResult = Convert.ChangeType(item.Value, type);
// }
// }
// typedValue = (T)conversionResult;
// FilterExpressionHelper<O> test = new FilterExpressionHelper<O>();
// var parameter = Expression.Parameter(typeof(O));
// var memberExpression = Expression.Property(parameter, item.ColumnName);
// var lambdaExpression = (Expression<Func<O, object>>)Expression.Lambda(memberExpression, parameter);
// var predicate = test.GetFilterPredicateBinary(lambdaExpression, item.FilterOperation, item.ColumnType);
// filterValue = Expression.AndAlso(filterValue, predicate);
// }
// return Expression.Lambda<Func<O, bool>>(filterValue);
//}
public Expression <Func <O, bool> > GetFilterPredicateFor(FilterOperations operation, object value)
{
T typedValue;
Type type = typeof(T);
bool nullable = Nullable.GetUnderlyingType(type) != null;
object conversionResult;
if (nullable)
{
type = Nullable.GetUnderlyingType(type);
if (value == "NULL")
{
conversionResult = null;
}
else
{
if (type.IsEnum)
{
conversionResult = (T)Enum.Parse(type, value.ToString());
}
else
{
conversionResult = Convert.ChangeType(value, type);
}
}
}
else
{
if (type.IsEnum)
{
conversionResult = (T)Enum.Parse(type, value.ToString());
}
else
{
conversionResult = Convert.ChangeType(value, type);
}
}
typedValue = (T)conversionResult;
var predicate = GetFilterPredicate(FieldSelector, operation, typedValue);
return(predicate);
}
public static ExpressionType ToExpressionType(this FilterOperations operand)
{
switch (operand)
{
case FilterOperations.Equal: return(ExpressionType.Equal);
case FilterOperations.NotEqual: return(ExpressionType.NotEqual);
case FilterOperations.LessThan: return(ExpressionType.LessThan);
case FilterOperations.LessThanOrEqual: return(ExpressionType.LessThanOrEqual);
case FilterOperations.GreaterThan: return(ExpressionType.GreaterThan);
case FilterOperations.GreaterThanOrEqual: return(ExpressionType.GreaterThanOrEqual);
default: throw new NotSupportedException();
}
}
private void PopulateCombo(ComboBox comboBox, String hasAnyValueCaption, DataSchema dataSchema,
Type propertyType)
{
comboBox.Items.Clear();
foreach (var filterOperation in FilterOperations.ListOperations())
{
if (!filterOperation.IsValidFor(dataSchema, propertyType))
{
continue;
}
string displayName;
if (filterOperation == FilterOperations.OP_HAS_ANY_VALUE)
{
displayName = hasAnyValueCaption;
}
else
{
displayName = filterOperation.DisplayName;
}
comboBox.Items.Add(new FilterItem(displayName, filterOperation));
}
}
/// <summary>
/// Childrens the aggregation func pridicate.
/// </summary>
/// <returns>The aggregation func pridicate.</returns>
/// <param name="agg">Agg.</param>
/// <param name="collection">Collection Property Expression.</param>
/// <param name="itemName">Item name.</param>
/// <param name="itemComparison">Item comparison.</param>
/// <param name="itemValue">Item value.</param>
/// <param name="countComparison">Count comparison.</param>
/// <param name="countValue">Count value.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public static Expression ChildrenAggregationFunc(
Aggregations agg,
Expression collection,
string itemName,
FilterOperations itemComparison,
object itemValue,
FilterOperations countComparison,
object countValue)
{
var itemType = collection.Type.GetInterfaces()
.Single(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable <>))
.GetGenericArguments()[0];
var itemSource = Expression.Parameter(itemType, "e");
var itemProperty = Expression.Property(itemSource, itemName);
Expression itemExpr = MakePropertyValueComparison(itemProperty, itemComparison, itemValue);
var itemPredicate = Expression.Lambda(itemExpr, itemSource);
return(ChildrenAggregationFunc(agg, collection, itemPredicate, countComparison.ToExpression(), countValue));
}
/// <summary>
/// Reset the avl filter operations given the property type. This is called each time the control is configured by calling ResetFilterValues
/// </summary>
private void ConfigureFilterOptions()
{
FilterOperations.Clear();
if (FilterColumnInfo.PropertyType != null)
{
if (TypeHelper.IsStringType(FilterColumnInfo.PropertyType))
{
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.StartsWith, "Starts With", " LIKE", "/Os.Controls;component/Images/StartsWith.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.EndsWith, "Ends With", " LIKE", "/Os.Controls;component/Images/EndsWith.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.Contains, "Contains", " LIKE", "/Os.Controls;component/Images/Contains.png"));
}
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.Equals, "Equals", "==", "/Os.Controls;component/Images/Equal.png"));
//FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation, "Equals", "==", "/Os.Controls;component/Images/Equal.png"));
if (TypeHelper.IsBool(FilterColumnInfo.PropertyType))
{
CmbFilter.Visibility = Visibility.Visible;
DpFilter.Visibility = Visibility.Collapsed;
TxtFilter.Visibility = Visibility.Collapsed;
}
if (TypeHelper.IsDateType(FilterColumnInfo.PropertyType) || TypeHelper.IsNumbericType(FilterColumnInfo.PropertyType))
{
if (TypeHelper.IsDateType(FilterColumnInfo.PropertyType))
{
DpFilter.Visibility = Visibility.Visible;
TxtFilter.Visibility = Visibility.Collapsed;
CmbFilter.Visibility = Visibility.Collapsed;
}
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.GreaterThan, "Greater Than", ">", "/Os.Controls;component/Images/GreaterThan.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.GreaterThanEqual, "Greater Than or Equal", ">=", "/Os.Controls;component/Images/GreaterThanEqual.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.LessThan, "Less Than", "<", "/Os.Controls;component/Images/LessThan.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.LessThanEqual, "Less Than or Equal", "<=", "/Os.Controls;component/Images/LessThanEqual.png"));
}
SelectedFilterOperation = FilterOperations[0];
}
}
public IQueryable <T> Filter(string field, string value, FilterOperations filter, IQueryable <T> query)
{
switch (filter)
{
case FilterOperations.Contains:
return(this.containsFilter.Filter(field, value, query));
case FilterOperations.NotContains:
return(this.notContainsFilter.Filter(field, value, query));
case FilterOperations.StartsWith:
return(this.startsWithFilter.Filter(field, value, query));
case FilterOperations.EndsWith:
return(this.endsWithFilter.Filter(field, value, query));
case FilterOperations.Equals:
return(this.equalFilter.Filter(field, value, query));
case FilterOperations.NotEquals:
return(this.notEqualFilter.Filter(field, value, query));
case FilterOperations.Greater:
return(this.greaterFilter.Filter(field, value, query));
case FilterOperations.GreaterOrEquals:
return(this.greaterOrEqualsFilter.Filter(field, value, query));
case FilterOperations.LessThan:
return(this.lessFilter.Filter(field, value, query));
case FilterOperations.LessThanOrEquals:
return(this.lessOrEqualFilter.Filter(field, value, query));
default:
return(null);
}
}
private void ToFilter(FilterOperations op, object value)
{
if (Filter == null)
{
Filter = new ComparisonFilter
{
Field = _tempField,
Operation = op,
Value = value
};
}
else if (Filter is LogicalFilter lf)
{
lf.Right = new ComparisonFilter
{
Field = _tempField,
Operation = op,
Value = value
};
_tempField = null;
}
}
public static string GetAcroymOperater(FilterOperations type)
{
switch (type)
{
case FilterOperations.NotEquals:
return("neq");
case FilterOperations.GreaterThan:
return("gt");
case FilterOperations.LessThan:
return("lt");
case FilterOperations.GreaterThanOrEqual:
return("gte");
case FilterOperations.LessThanOrEqual:
return("lte");
case FilterOperations.Contains:
return("in");
case FilterOperations.NotContains:
return("not_in");
case FilterOperations.StartsWith:
return("sw");
case FilterOperations.EndsWith:
return("ew");
case FilterOperations.Equals:
default:
return("eq");
}
}
/// <summary>
/// FilterByDictionayProperty
/// Original idea: https://stackoverflow.com/questions/32901989/dynamic-linq-function-using-dictionary-as-a-parameter-to-filter-method
/// </summary>
/// <returns>The by dictionay property.</returns>
/// <param name="propName">Property name.</param>
/// <param name="itemName">Item name.</param>
/// <param name="filterOperation">Filter operation.</param>
/// <param name="itemValue">Item value.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public static Expression FilterByDictionayProperty(
ParameterExpression source,
string propName,
string itemName,
FilterOperations filterOperation,
object itemValue, bool stringSearch = false)
{
Expression propProperty = source;
Expression notNUllExp = null;
foreach (var member in propName.Split('.'))
{
if (member == itemName)
{
break;
}
propProperty = Expression.PropertyOrField(propProperty, member);
// p != null && p.Data != null
if (notNUllExp == null)
{
notNUllExp = Expression.NotEqual(propProperty, Expression.Constant(null));
}
else
{
notNUllExp = Expression.AndAlso(notNUllExp, Expression.NotEqual(propProperty, Expression.Constant(null)));
}
}
var comparison = DictionaryContainsItem(propProperty, itemName, filterOperation, itemValue);
var itemExpr = Expression.AndAlso(notNUllExp, comparison);
return(itemExpr);
}
public FilterAttribute(string name, FilterOperations operations)
{
Operation = operations;
Name = name.ToLower();
}
void ColumnFilterControl_Loaded(object sender, RoutedEventArgs e)
{
DataGridColumn column = null;
DataGridColumnHeader colHeader = null;
UIElement parent = (UIElement)VisualTreeHelper.GetParent(this);
while (parent != null)
{
parent = (UIElement)VisualTreeHelper.GetParent(parent);
if (colHeader == null)
{
colHeader = parent as DataGridColumnHeader;
}
if (Grid == null)
{
Grid = parent as JibGrid;
}
}
if (colHeader != null)
{
column = colHeader.Column;
}
CanUserFilter = Grid.CanUserFilter;
CanUserFreeze = Grid.CanUserFreeze;
CanUserGroup = Grid.CanUserGroup;
CanUserSelectDistinct = Grid.CanUserSelectDistinct;
if (column != null)
{
object oCanUserFilter = column.GetValue(ColumnConfiguration.CanUserFilterProperty);
if (oCanUserFilter != null)
{
CanUserFilter = (bool)oCanUserFilter;
}
object oCanUserFreeze = column.GetValue(ColumnConfiguration.CanUserFreezeProperty);
if (oCanUserFreeze != null)
{
CanUserFreeze = (bool)oCanUserFreeze;
}
object oCanUserGroup = column.GetValue(ColumnConfiguration.CanUserGroupProperty);
if (oCanUserGroup != null)
{
CanUserGroup = (bool)oCanUserGroup;
}
object oCanUserSelectDistinct = column.GetValue(ColumnConfiguration.CanUserSelectDistinctProperty);
if (oCanUserSelectDistinct != null)
{
CanUserSelectDistinct = (bool)oCanUserSelectDistinct;
}
}
if (Grid.FilterType == null)
{
return;
}
FilterColumnInfo = new OptionColumnInfo(column, Grid.FilterType);
Grid.RegisterOptionControl(this);
FilterOperations.Clear();
if (FilterColumnInfo.PropertyType != null)
{
if (TypeHelper.IsStringType(FilterColumnInfo.PropertyType))
{
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.Contains, "Contains", "/Jib.WPF.Controls;component/Images/Contains.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.StartsWith, "Starts With", "/Jib.WPF.Controls;component/Images/StartsWith.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.EndsWith, "Ends With", "/Jib.WPF.Controls;component/Images/EndsWith.png"));
}
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.Equals, "Equals", "/Jib.WPF.Controls;component/Images/Equal.png"));
if (TypeHelper.IsNumbericType(FilterColumnInfo.PropertyType))
{
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.GreaterThan, "Greater Than", "/Jib.WPF.Controls;component/Images/GreaterThan.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.GreaterThanEqual, "Greater Than or Equal", "/Jib.WPF.Controls;component/Images/GreaterThanEqual.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.LessThan, "Less Than", "/Jib.WPF.Controls;component/Images/LessThan.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.LessThanEqual, "Greater Than or Equal", "/Jib.WPF.Controls;component/Images/GreaterThanEqual.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.NotEquals, "Not Equal", "/Jib.WPF.Controls;component/Images/NotEqual.png"));
}
SelectedFilterOperation = FilterOperations[0];
}
if (FilterColumnInfo != null && FilterColumnInfo.IsValid)
{
foreach (var i in DistinctPropertyValues.Where(i => i.IsChecked))
{
i.IsChecked = false;
}
DistinctPropertyValues.Clear();
FilterText = string.Empty;
_boundColumnPropertyAccessor = null;
if (!string.IsNullOrWhiteSpace(FilterColumnInfo.PropertyPath))
{
if (FilterColumnInfo.PropertyPath.Contains('.'))
{
throw new ArgumentException(string.Format("This version of the grid does not support a nested property path such as '{0}'. Please make a first-level property for filtering and bind to that.", FilterColumnInfo.PropertyPath));
}
this.Visibility = System.Windows.Visibility.Visible;
ParameterExpression arg = System.Linq.Expressions.Expression.Parameter(typeof(object), "x");
System.Linq.Expressions.Expression expr = System.Linq.Expressions.Expression.Convert(arg, Grid.FilterType);
expr = System.Linq.Expressions.Expression.Property(expr, Grid.FilterType, FilterColumnInfo.PropertyPath);
System.Linq.Expressions.Expression conversion = System.Linq.Expressions.Expression.Convert(expr, typeof(object));
_boundColumnPropertyAccessor = System.Linq.Expressions.Expression.Lambda <Func <object, object> >(conversion, arg).Compile();
}
else
{
this.Visibility = System.Windows.Visibility.Collapsed;
}
object oDefaultFilter = column.GetValue(ColumnConfiguration.DefaultFilterProperty);
if (oDefaultFilter != null)
{
FilterText = (string)oDefaultFilter;
}
}
CalcControlVisibility();
}
void ColumnFilterControl_Loaded(object sender, RoutedEventArgs e)
{
DataGridColumn column = null;
DataGridColumnHeader colHeader = null;
UIElement parent = (UIElement)VisualTreeHelper.GetParent(this);
while (parent != null)
{
parent = (UIElement)VisualTreeHelper.GetParent(parent);
if (colHeader == null)
{
colHeader = parent as DataGridColumnHeader;
}
if (Grid == null)
{
Grid = parent as ExDataGrid;
}
}
if (colHeader != null)
{
column = colHeader.Column;
}
CanUserFilter = Grid.CanUserFilter;
CanUserFreeze = Grid.CanUserFreeze;
CanUserGroup = Grid.CanUserGroup;
CanUserSelectDistinct = Grid.CanUserSelectDistinct;
if (column != null)
{
object oCanUserFilter = column.GetValue(ColumnConfiguration.CanUserFilterProperty);
if (oCanUserFilter != null)
{
CanUserFilter = (bool)oCanUserFilter;
}
object oCanUserFreeze = column.GetValue(ColumnConfiguration.CanUserFreezeProperty);
if (oCanUserFreeze != null)
{
CanUserFreeze = (bool)oCanUserFreeze;
}
object oCanUserGroup = column.GetValue(ColumnConfiguration.CanUserGroupProperty);
if (oCanUserGroup != null)
{
CanUserGroup = (bool)oCanUserGroup;
}
object oCanUserSelectDistinct = column.GetValue(ColumnConfiguration.CanUserSelectDistinctProperty);
if (oCanUserSelectDistinct != null)
{
CanUserSelectDistinct = (bool)oCanUserSelectDistinct;
}
}
if (Grid.FilterType == null)
{
return;
}
FilterColumnInfo = new OptionColumnInfo(column, Grid.FilterType);
Grid.RegisterOptionControl(this);
FilterOperations.Clear();
if (FilterColumnInfo.PropertyType != null)
{
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.Equals, "Equals", "/Capnode.Wpf;component/Images/Equal.png"));
if (TypeHelper.IsStringType(FilterColumnInfo.PropertyType))
{
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.Contains, "Contains", "/Capnode.Wpf;component/Images/Contains.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.StartsWith, "Starts With", "/Capnode.Wpf;component/Images/StartsWith.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.EndsWith, "Ends With", "/Capnode.Wpf;component/Images/EndsWith.png"));
}
if (TypeHelper.IsNumbericType(FilterColumnInfo.PropertyType))
{
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.NotEquals, "Not Equal", "/Capnode.Wpf;component/Images/NotEqual.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.GreaterThan, "Greater Than", "/Capnode.Wpf;component/Images/GreaterThan.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.GreaterThanEqual, "Greater Than or Equal", "/Capnode.Wpf;component/Images/GreaterThanEqual.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.LessThan, "Less Than", "/Capnode.Wpf;component/Images/LessThan.png"));
FilterOperations.Add(new FilterOperationItem(Enums.FilterOperation.LessThanEqual, "Less Than or Equal", "/Capnode.Wpf;component/Images/LessThanEqual.png"));
}
SelectedFilterOperation = FilterOperations[0];
}
if (FilterColumnInfo != null && FilterColumnInfo.IsValid)
{
foreach (var i in DistinctPropertyValues.Where(i => i.IsChecked))
{
i.IsChecked = false;
}
DistinctPropertyValues.Clear();
FilterText = string.Empty;
_boundColumnPropertyAccessor = null;
if (TypeHelper.IsNumbericType(FilterColumnInfo.PropertyType))
{
CanUserSelectDistinct = false;
Visibility = Visibility.Visible;
}
else if (!string.IsNullOrWhiteSpace(FilterColumnInfo.PropertyPath))
{
Visibility = Visibility.Visible;
ParameterExpression arg = linq.Expression.Parameter(typeof(object), "x");
linq.Expression expr = PropertyExpression(Grid.FilterType, FilterColumnInfo.PropertyPath, arg);
linq.Expression conversion = linq.Expression.Convert(expr, typeof(object));
_boundColumnPropertyAccessor = linq.Expression.Lambda <Func <object, object> >(conversion, arg).Compile();
}
else
{
Visibility = Visibility.Collapsed;
}
object oDefaultFilter = column.GetValue(ColumnConfiguration.DefaultFilterProperty);
if (oDefaultFilter != null)
{
FilterText = (string)oDefaultFilter;
}
}
CalcControlVisibility();
}
private static Expression GetFilterExpressionLambda(Expression left, Expression right, FilterOperations operation)
{
Expression body;
switch (operation)
{
case FilterOperations.eq:
// {model.Id == 1}
body = Expression.Equal(left, right);
break;
case FilterOperations.lt:
// {model.Id < 1}
body = Expression.LessThan(left, right);
break;
case FilterOperations.gt:
// {model.Id > 1}
body = Expression.GreaterThan(left, right);
break;
case FilterOperations.le:
// {model.Id <= 1}
body = Expression.LessThanOrEqual(left, right);
break;
case FilterOperations.ge:
// {model.Id >= 1}
body = Expression.GreaterThanOrEqual(left, right);
break;
case FilterOperations.like:
body = Expression.Call(left, "Contains", null, right);
break;
// {model.Id != 1}
case FilterOperations.ne:
body = Expression.NotEqual(left, right);
break;
case FilterOperations.isnotnull:
// {model.Id != null}
if (left.Type.IsValueType &&
!(left.Type.IsGenericType && left.Type.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
var nullableType = typeof(Nullable <>).MakeGenericType(left.Type);
body = Expression.NotEqual(Expression.Convert(left, nullableType), right);
}
else
{
body = Expression.NotEqual(left, right);
}
break;
case FilterOperations.isnull:
// {model.Id == null}
if (left.Type.IsValueType &&
!(left.Type.IsGenericType && left.Type.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
var nullableType = typeof(Nullable <>).MakeGenericType(left.Type);
body = Expression.Equal(Expression.Convert(left, nullableType), right);
}
else
{
body = Expression.Equal(left, right);
}
break;
default:
throw new JsonApiException(500, $"Unknown filter operation {operation}");
}
return(body);
}
//This one does the heavy work of building a predicate based on a collection,
//it's member property, operation type and a valaue
public System.Linq.Expressions.Expression <Func <Profile.UserProfile, bool> > GetFilterPredicateFor(FilterOperations operation, string value)
{
var getExpressionBody = CollectionPropertySelector.Body as MemberExpression;
if (getExpressionBody == null)
{
throw new Exception("getExpressionBody is not MemberExpression: " + CollectionPropertySelector.Body);
}
var propertyParameter = CollectionPropertySelector.Parameters[0];
var collectionParameter = CollectionSelector.Parameters[0];
var left = CollectionPropertySelector.Body;
var right = Expression.Constant(value);
// this is so far hardcoded, but might be changed later based on operation type
// as well as a "method" below
var innerLambda = Expression.Equal(left, right);
Expression <Func <T, bool> > innerFunction = Expression.Lambda <Func <T, bool> >(innerLambda, propertyParameter);
// this is hadrcoded again, but maybe changed later when other type of operation will be needed
var method = typeof(Enumerable).GetMethods().Where(m => m.Name == "Any" && m.GetParameters().Length == 2).Single().MakeGenericMethod(typeof(T));
var outerLambda = Expression.Call(method, Expression.Property(collectionParameter, (CollectionSelector.Body as MemberExpression).Member as System.Reflection.PropertyInfo), innerFunction);
var result = Expression.Lambda <Func <UserProfile, bool> >(outerLambda, collectionParameter);
return(result);
}
/// <summary>
/// Specifies the comparison operation used in searching.
/// </summary>
public DataSourceOptionsBuilder SearchOperation(FilterOperations operation)
{
base.Options["searchOperation"] = operation;
return(this);
}
private static Expression GetFilterExpressionLambda(Expression left, Expression right, FilterOperations operation)
{
Expression body;
switch (operation)
{
case FilterOperations.eq:
// {model.Id == 1}
body = Expression.Equal(left, right);
break;
case FilterOperations.lt:
// {model.Id < 1}
body = Expression.LessThan(left, right);
break;
case FilterOperations.gt:
// {model.Id > 1}
body = Expression.GreaterThan(left, right);
break;
case FilterOperations.le:
// {model.Id <= 1}
body = Expression.LessThanOrEqual(left, right);
break;
case FilterOperations.ge:
// {model.Id <= 1}
body = Expression.GreaterThanOrEqual(left, right);
break;
case FilterOperations.like:
// {model.Id <= 1}
body = Expression.Call(left, "Contains", null, right);
break;
default:
throw new Exception($"500 - Filtro desconhecido para esta operação {operation}");
}
return(body);
}
public FilterQuery(string key, string value, FilterOperations operation)
{
Key = key;
Value = value;
Operation = operation;
}
public FilterQuery(AttrAttribute filteredAttribute, string propertyValue, FilterOperations filterOperation)
{
FilteredAttribute = filteredAttribute;
PropertyValue = propertyValue;
FilterOperation = filterOperation;
}
private static Expression GetFilterExpressionLambda(Expression left, Expression right, FilterOperations operation)
{
Expression body;
switch (operation)
{
case FilterOperations.eq:
// {model.Id == 1}
body = Expression.Equal(left, right);
break;
case FilterOperations.lt:
// {model.Id < 1}
body = Expression.LessThan(left, right);
break;
case FilterOperations.gt:
// {model.Id > 1}
body = Expression.GreaterThan(left, right);
break;
case FilterOperations.le:
// {model.Id <= 1}
body = Expression.LessThanOrEqual(left, right);
break;
case FilterOperations.ge:
// {model.Id >= 1}
body = Expression.GreaterThanOrEqual(left, right);
break;
case FilterOperations.like:
body = Expression.Call(left, "Contains", null, right);
break;
default:
throw new JsonApiException(500, $"Unknown filter operation {operation}");
}
return(body);
}
/// <summary>
/// Lấy về phép toán quan hệ
/// </summary>
/// <param name="dataType">Kiểu dữ liệu</param>
/// <returns>Lấy về phép toán quan hệ</returns>
/// Create by: dvthang:25.02.2018
private static string GetOperations(DataType dataType, FilterOperations op)
{
string strOperation = "";
if (dataType == DataType.String)
{
switch (op)
{
case FilterOperations.Contains:
case FilterOperations.StartsWith:
case FilterOperations.EndsWith:
strOperation = " LIKE ";
break;
case FilterOperations.NotContains:
strOperation = " NOT LIKE ";
break;
case FilterOperations.NotEquals:
strOperation = " <> ";
break;
case FilterOperations.Equals:
strOperation = " = ";
break;
}
}
else if (dataType == DataType.Boolean)
{
strOperation = " = ";
}
else if (dataType == DataType.Byte || dataType == DataType.Int ||
dataType == DataType.Float ||
dataType == DataType.Double ||
dataType == DataType.Decimal ||
dataType == DataType.Date ||
dataType == DataType.DateTime ||
dataType == DataType.Time)
{
switch (op)
{
case FilterOperations.Equals:
strOperation = " = ";
break;
case FilterOperations.NotEquals:
strOperation = " <> ";
break;
case FilterOperations.Greater:
strOperation = " > ";
break;
case FilterOperations.GreaterOrEquals:
strOperation = " >= ";
break;
case FilterOperations.LessThan:
strOperation = " < ";
break;
case FilterOperations.LessThanOrEquals:
strOperation = " <= ";
break;
}
}
return(strOperation);
}
