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); }