/// <inheritdoc /> protected override FilterTerm CreateBasicFilterTerm(string fieldName, FilterOperators op, string valueAsString) { EnsureCanFilter(fieldName); var term = base.CreateBasicFilterTerm(fieldName, op, valueAsString); return(ConvertToTypedTerm(term)); }
public IPFilter() { this._ipTarget = IPTarget.DestinationIP; this._operator = FilterOperators.Equal; this._filterByIp = string.Empty; this._filterStatus = FilterStatus.NotConfirmed; }
public IPFilter(IPTarget ipTarget, FilterOperators fOperator, string filterByIp, FilterStatus status) { this._ipTarget = ipTarget; this._operator = fOperator; this._filterByIp = filterByIp; this._filterStatus = status; }
/// <summary> /// Method to return the symbol value of the enum /// </summary> /// <param name="me"></param> /// <returns></returns> public static string ToSymbol(this FilterOperators me) { switch (me) { case FilterOperators.Equal: return("="); case FilterOperators.NotEqual: return("<>"); case FilterOperators.LessThan: return("<"); case FilterOperators.LessThanOrEqual: return("<="); case FilterOperators.GreaterThan: return(">"); case FilterOperators.GreaterThanOrEqual: return(">="); default: return("?"); } }
public IQueryable <TEntity> ApplyToCollection <TEntity>(IQueryable <TEntity> collection, FilterModel filterModel) { var rootType = typeof(TEntity); Expression summaryExpression = null; foreach (var orderItem in filterModel.FilterItems) { var parsedPath = ParsePath(orderItem.Field, rootType); var partsQueue = CreateExpressionsQueue(parsedPath, rootType); var operation = FilterOperators.ParseOperation(orderItem.Operation); var lambda = BuildLambdaExpression(partsQueue, orderItem.Value, operation); summaryExpression = summaryExpression == null ? (Expression)lambda : Expression.AndAlso(summaryExpression, lambda); } var expressionArgs = new[] { rootType }; var unaryExpression = Expression.Quote(summaryExpression); var resultExpression = Expression.Call(typeof(Queryable), "Where", expressionArgs.ToArray(), collection.Expression, unaryExpression); collection = collection.Provider.CreateQuery <TEntity>(resultExpression); return(collection); }
public static IQueryable <T> FilterColection <T>(this IQueryable <T> list, Filters <T> filters) { if (filters.FiltersModel == null) { return(list); } IQueryable <T> result = list; foreach (var prop in filters.FiltersModel.GetType().GetProperties()) { string propName = prop.Name; Type propType = prop.GetType(); object propValue = prop.GetValue(filters.FiltersModel); if (filters.Comparator == Comparatos.And) { FilterOperators op = filters.Operators != null && filters.Operators.ContainsKey(propName) ? filters.Operators[propName] : FilterOperators.Eq; result = list.Where(x => IsMathFilter(x, propType, propValue, op)); } // TODO Implement Or } return(result); }
public FilterItem(string left, string rigth, FilterOperators @operator) { ExceptionHelper.ThrowIfNullOrWhiteSpace(left, "left"); ExceptionHelper.ThrowIfNullOrWhiteSpace(rigth, "rigth"); Left = left.Trim(); Rigth = rigth.Trim(); Operator = @operator; }
private IEnumerable <string> ProcessFitlerValue( FilterOperators @operator, FilterHelper.FilterItem item, object value, bool useQuote, List <string> ctx) { ctx.Add(_filterHelper.FormatFilterAsDbString(@operator, item.FriendlyName, value, useQuote)); yield break; }
/// <summary> /// Construct a new FilterTerm /// </summary> /// <param name="propertyName">The name of the property the term applies to</param> /// <param name="op">The type of filtering to perform</param> /// <param name="value">The value to filter on</param> public FilterTerm(string propertyName, FilterOperators op, object value) { if (string.IsNullOrWhiteSpace(propertyName)) { throw new ArgumentException("Value cannot be null or whitespace.", nameof(propertyName)); } PropertyName = propertyName; Operator = op; Value = value; }
private void AddCondition(FilterOperators filterOperator, TPropEnum prop, FilterConditions condition, object val) { if (PredicateFilters == null) { PredicateFilters = new QueryFilters <TPropEnum>(); } if (CurrentExpression == null) { PredicateFilters.Add(QueryFilter.New(prop, condition, filterOperator, val)); return; } var filter = QueryFilter.New(prop, condition, CurrentExpression.Operator, val); filter.StartExpressions = CurrentExpression.OpenExpressions; PredicateFilters.Add(filter); CurrentExpression = null; }
public string FormatFilterAsDbString(FilterOperators filterOpeator, string propertyName, object value, bool shouldUseQuotes) { var whereClause = new StringBuilder(propertyName); whereClause.Append(FilterOperatorToString(filterOpeator)); whereClause.Append(filterOpeator == FilterOperators.In ? "(" : string.Empty); foreach (var formatted in FormatValue(value, shouldUseQuotes, filterOpeator == FilterOperators.Like, filterOpeator == FilterOperators.Between)) { whereClause.Append(formatted); } whereClause.Append(filterOpeator == FilterOperators.In ? ")" : string.Empty); var result = whereClause.ToString(); return(result); }
/// <summary> /// Only marked public for testing. Please do not use. /// </summary> /// <param name="firstOperand">Only marked public for testing. Please do not use.</param> /// <param name="filterOperator">Only marked public for testing. Please do not use.</param> /// <param name="secondOperand">Only marked public for testing. Please do not use.</param> /// <returns>Only marked public for testing. Please do not use.</returns> public static bool FilterAcceptsObject(object firstOperand, FilterOperators filterOperator, object secondOperand) { if (filterOperator == FilterOperators.Equals && firstOperand.Equals(secondOperand)) { return(true); } if (filterOperator == FilterOperators.NotEquals && !firstOperand.Equals(secondOperand)) { return(true); } else if (filterOperator == FilterOperators.GreaterThan && firstOperand.GetType().GetInterfaces().Contains(typeof(IComparable)) && ((IComparable)firstOperand).CompareTo(secondOperand) > 0) { return(true); } else if (filterOperator == FilterOperators.GreaterThanOrEqualTo && firstOperand.GetType().GetInterfaces().Contains(typeof(IComparable)) && ((IComparable)firstOperand).CompareTo(secondOperand) >= 0) { return(true); } else if (filterOperator == FilterOperators.LessThan && firstOperand.GetType().GetInterfaces().Contains(typeof(IComparable)) && ((IComparable)firstOperand).CompareTo(secondOperand) < 0) { return(true); } else if (filterOperator == FilterOperators.LessThanOrEqualTo && firstOperand.GetType().GetInterfaces().Contains(typeof(IComparable)) && ((IComparable)firstOperand).CompareTo(secondOperand) <= 0) { return(true); } else if (filterOperator == FilterOperators.Contains) { if (firstOperand is string && ((string)firstOperand).Contains((string)secondOperand)) { return(true); } } else if (filterOperator == FilterOperators.NotContains) { if (firstOperand is string && ((string)firstOperand).Contains((string)secondOperand) == false) { return(true); } } return(false); }
/// <summary> /// Only marked public for testing. Please do not use. /// </summary> /// <param name="firstOperand">Only marked public for testing. Please do not use.</param> /// <param name="filterOperator">Only marked public for testing. Please do not use.</param> /// <param name="secondOperand">Only marked public for testing. Please do not use.</param> /// <returns>Only marked public for testing. Please do not use.</returns> public static bool FilterAcceptsObject(object firstOperand, FilterOperators filterOperator, object secondOperand) { if (filterOperator == FilterOperators.Equals && firstOperand.Equals(secondOperand)) { return true; } if (filterOperator == FilterOperators.NotEquals && !firstOperand.Equals(secondOperand)) { return true; } else if (filterOperator == FilterOperators.GreaterThan && firstOperand.GetType().GetInterfaces().Contains(typeof(IComparable)) && ((IComparable)firstOperand).CompareTo(secondOperand) > 0) { return true; } else if (filterOperator == FilterOperators.GreaterThanOrEqualTo && firstOperand.GetType().GetInterfaces().Contains(typeof(IComparable)) && ((IComparable)firstOperand).CompareTo(secondOperand) >= 0) { return true; } else if (filterOperator == FilterOperators.LessThan && firstOperand.GetType().GetInterfaces().Contains(typeof(IComparable)) && ((IComparable)firstOperand).CompareTo(secondOperand) < 0) { return true; } else if (filterOperator == FilterOperators.LessThanOrEqualTo && firstOperand.GetType().GetInterfaces().Contains(typeof(IComparable)) && ((IComparable)firstOperand).CompareTo(secondOperand) <= 0) { return true; } else if (filterOperator == FilterOperators.Contains) { if (firstOperand is string && ((string)firstOperand).Contains((string)secondOperand)) { return true; } } else if (filterOperator == FilterOperators.NotContains) { if (firstOperand is string && ((string)firstOperand).Contains((string)secondOperand) == false) { return true; } } return false; }
private string GetPredicate(FilterOperators op, string arg) { if (op == FilterOperators.Contains) { return(string.Format("{0}.ToLower().Contains({1}.ToLower())", ValueSource.Expression, arg)); } else if (op == FilterOperators.IsNull) { return(string.Format("{0} = null", ValueSource.Expression)); } else if (op == FilterOperators.IsNotNull) { return(string.Format("{0} != null", ValueSource.Expression)); } else { return(string.Format("{0} {1} {2}", ValueSource.Expression, GetOperatorExpression(op), arg)); } }
public static bool CanApplyOperator(Type type, FilterOperators op) { if (op == FilterOperators.Eq) { return(true); } else if (op == FilterOperators.Gt || op == FilterOperators.GtEq || op == FilterOperators.GtEq || op == FilterOperators.Lt || op == FilterOperators.LtEq) { return(type == typeof(DateTime) || type == typeof(DateTime?) || type.IsValueType); } else if (op == FilterOperators.Contains) { return(type == typeof(string)); } else if (op == FilterOperators.IsNull) { return(Nullable.GetUnderlyingType(type) != null); } return(false); }
public string FilterOperatorToString(FilterOperators op) { switch (op) { case FilterOperators.Eq: return(" = "); case FilterOperators.Neq: return(" <> "); case FilterOperators.Like: return(" like "); case FilterOperators.In: return(" in "); case FilterOperators.Between: return(" between "); } _logger.Warn("Operator {0} is not supported!", op); throw new NotSupportedException(); }
private void EnsureValidOperator(FilterOperators op, Type fieldType) { if (fieldType == typeof(bool)) { if (op != FilterOperators.Equal && op != FilterOperators.NotEqual) { throw new InvalidOperationException($"The '{op}' filter is not compatible with boolean fields"); } } else if (fieldType == typeof(string)) { if (op == FilterOperators.LessThan || op == FilterOperators.LessThanOrEqual || op == FilterOperators.GreaterThan || op == FilterOperators.GreaterThanOrEqual || op == FilterOperators.Range) { throw new InvalidOperationException($"The '{op}' filter is not compatible with string fields"); } } else if (op == FilterOperators.StartsWith || op == FilterOperators.Contains || op == FilterOperators.EndsWith) { throw new InvalidOperationException($"The '{op}' filter is only compatible with string fields"); } }
private static string GetOperators(FilterOperators @operator) { switch (@operator) { case FilterOperators.GT: return("{0}>{1}"); case FilterOperators.GTE: return("{0}>={1}"); case FilterOperators.EQ: return("{0}={1}"); case FilterOperators.LT: return("{0}<{1}"); case FilterOperators.LTE: return("{0}<={1}"); case FilterOperators.NE: return("{0}!={1}"); case FilterOperators.IN: return("in({0},\"{1}\")"); case FilterOperators.NOTIN: return("notin({0},\"{1}\")"); default: throw new Exception("not exists"); } }
public OperatorViewModel() { _Operator = FilterOperators.Equals; Name = FilterViewModelResources.OperatorEquals; }
public EventFilter(string name, string propertyName, FilterOperators filterOperator, string[] filterValue) : base(name, propertyName, filterOperator, filterValue) { FilterAppliesOn = FilterTarget.Events; }
/// <summary> /// Constructor with parameters /// </summary> /// <param name="propName">Name of the property being filtered</param> /// <param name="valToCompare">Value (constant value) used to filter</param> /// <param name="compType">Operator used to filter</param> public EntityFilter(string propName, object valToCompare, FilterOperators compType) { PropertyName = propName; ValueToCompare = valToCompare; ComparisonType = compType; }
/// <summary> /// Initializes a new instance of the Filter class. /// </summary> /// <param name="prop">The property to filter on.</param> /// <param name="condition">The condition.</param> /// <param name="op">The operator to chain conditions. For example And, Or.</param> /// <param name="val">The field value.</param> internal QueryFilter(TPropEnum prop, FilterConditions condition, FilterOperators op, object val) { InitializeFilter(prop, condition, op, val); }
public void Add(TPropEnum prop, FilterConditions condition, FilterOperators op, object val) { Add(QueryFilter.New(prop, condition, op, val)); }
public ProcessFilter(string name, string propertyName, FilterOperators filterOperator, string[] filterValue) : base(name, propertyName, filterOperator, filterValue) { FilterAppliesOn = FilterTarget.Processes; }
private void InitializeFilter(TPropEnum prop, FilterConditions condition, FilterOperators op, object val) { var propertyInt = prop.ToInt32(null); if (!Lookup.PropTypes[_currentType].ContainsKey(propertyInt)) { throw new ArgumentException("Property " + prop.ToString() + " is not supported for this Entity"); } _propertyId = propertyInt; _property = prop; _propName = _property.ToString(); _type = Lookup.PropTypes[_currentType][propertyInt]; _typeCode = Type.GetTypeCode(_type); _typeName = _type.Name; _condition = condition; _isNullable = Lookup.NullableProps[_currentType].Contains(propertyInt); _isDateFilter = _supportedConditions[_dateKey].Contains(_condition); _isYearFilter = _supportedConditions[_yearKey].Contains(_condition); _isMonthFilter = _supportedConditions[_monthKey].Contains(_condition); _isDayFilter = _supportedConditions[_dayKey].Contains(_condition); var isContains = _supportedConditions[_containKey].Contains(_condition); var isDatePart = _isDateFilter || _isYearFilter || _isMonthFilter || _isDayFilter; var requiresInt = _isYearFilter || _isMonthFilter || _isDayFilter; _isBoolean = _type == typeof(bool); _operator = op; _value = val; if (_value == null) { _hasValue = false; if (!_isNullable) { throw new ArgumentException("Property: " + _propName + " is not nullable."); } if (isContains) { throw new ArgumentException("Any Contains or DoesNotContain condition requires a non null value."); } if (isDatePart) { throw new ArgumentException("Condition: " + _condition.ToString() + " cannot be applied to null values."); } if (_condition != FilterConditions.Equals && _condition != FilterConditions.NotEquals) { throw new ArgumentException("When Value is null the property: " + _propName + " supports only Equals, NotEquals."); } _isArray = false; } else { var valType = _value.GetType(); var valTypeName = string.Empty; if (valType.IsArray) { valTypeName = valType.GetElementType().Name; _isArray = true; _hasValue = ((Array)_value).Length > 0; } else { valTypeName = valType.Name; _isArray = false; } if (requiresInt) { if (string.CompareOrdinal(valTypeName, "Int32") != 0) { throw new ArgumentException("Invalid type. Condition: " + _condition.ToString() + " expects int or int[])."); } } else { if (string.CompareOrdinal(_typeName, "Int64") == 0) { if (string.CompareOrdinal(valTypeName, "Int64") != 0 && string.CompareOrdinal(valTypeName, "Int32") != 0) { throw new ArgumentException("Invalid type. Property: " + _propName + " expects " + _typeName + " or " + _typeName + "[])."); } } else { if (string.CompareOrdinal(valTypeName, _typeName) != 0) { throw new ArgumentException("Invalid type. Property: " + _propName + " expects " + _typeName + " or " + _typeName + "[])."); } } } } if (_isArray) { if (Lookup.BinaryProps[_currentType].Contains(propertyInt)) { if (_condition != FilterConditions.Equals && _condition != FilterConditions.NotEquals) { throw new ArgumentException("When Value is byte[] and the property is binary... " + _propName + " supports only Equals, NotEquals."); } } else { if (!isContains) { throw new ArgumentException("When Value is array " + _typeName + "[] the property: " + _propName + " supports only one of the Contains or DoesNotContain condition."); } } } else { if (!GetPropertySupportsCondition(_typeName, _condition)) { throw new ArgumentException("Condition " + _condition.ToString() + " is not supported for type " + _typeName); } } }
public FilterBuilder(TPropEnum property, FilterOperators filterOperator, PredicateBuilder <TPropEnum, TQuery, TQueryBuilder> predicateBuilder) { _property = property; _operator = filterOperator; _predicateBuilder = predicateBuilder; }
public void SetCustomFilterTwo(CustomFilter field, FilterOperators operatorTwo, string value) { UIUtil.DefaultProvider.SelectWithValue("crFilters_customFilters_ddlFieldFilter_1", CustomFilterValueAttribute.GetFilterValue(field), LocateBy.Id); UIUtil.DefaultProvider.SelectWithValue("crFilters_customFilters_ddlFilterOperator_1", CustomStringAttribute.GetCustomString(operatorTwo), LocateBy.Id); UIUtil.DefaultProvider.Type("crFilters_customFilters_tbValue_1", value, LocateBy.Id); }
public ExpressionBuilder(FilterOperators filterOperator) { Operator = filterOperator; }
public OperatorViewModel(FilterOperators op) : this() { Operator = op; }
private static IFilter CollectionHandle <T>(FilterOperators operators, string fieldName, IEnumerable <T> values) where T : struct { return(new FilterItem(fieldName, String.Join("|", values.Select(v => v.ToString())), operators)); }
public static Expression MakePredicate(ParameterExpression expression, string fieldName, FilterOperators operation, object value) { MemberExpression member = Expression.Property(expression, fieldName); ConstantExpression constant = Expression.Constant(value); switch (operation) { case FilterOperators.Equals: return(Expression.Equal(member, constant)); case FilterOperators.GreaterThan: return(Expression.GreaterThan(member, constant)); case FilterOperators.LessThan: return(Expression.LessThan(member, constant)); case FilterOperators.GreaterThanOrEqual: return(Expression.GreaterThanOrEqual(member, constant)); case FilterOperators.LessThanOrEqual: return(Expression.LessThanOrEqual(member, constant)); case FilterOperators.Contains: return(Expression.Call(member, containsMethod, constant)); case FilterOperators.StartsWith: return(Expression.Call(member, startsWithMethod, constant)); case FilterOperators.EndsWith: return(Expression.Call(member, endsWithMethod, constant)); } return(null); }
public string BuildFilterExpression(string fieldName, DataType dataType, FilterOperators op, IEnumerable <string> values) { if (values == null) { values = new string[0]; } var filterExpr = new StringBuilder(); filterExpr.Append($" ( {fieldName} {_operatorStringMap[op]} "); switch (op) { case FilterOperators.EQUALS: case FilterOperators.NUMERIC_GREATER_THAN: case FilterOperators.NUMERIC_GREATER_THAN_OR_EQUAL: case FilterOperators.NUMERIC_LESS_THAN: case FilterOperators.NUMERIC_LESS_THAN_OR_EQUAL: if (dataType == DataType.NUMBER) { filterExpr.Append($" {values.FirstOrDefault()} "); } else { filterExpr.Append($" '{values.FirstOrDefault()}' "); } break; case FilterOperators.CONTAINS: case FilterOperators.REGEXP_PARTIAL_MATCH: case FilterOperators.REGEXP_EXACT_MATCH: var val = values.FirstOrDefault(); if (!string.IsNullOrWhiteSpace(val) && val.StartsWith("^") && val.EndsWith(".*")) { val = val.Substring(1, val.Length - 3); } if (dataType == DataType.NUMBER) { filterExpr.Append($" {val} "); } else { filterExpr.Append($" '%{val}%' "); } break; case FilterOperators.IN_LIST: var k = 0; filterExpr.Append(" ( "); values.ToList().ForEach(v => { if (k != 0) { filterExpr.Append($" , "); } if (dataType == DataType.NUMBER) { filterExpr.Append($" {v} "); } else { filterExpr.Append($" '{v}' "); } k++; }); filterExpr.Append(" ) "); break; case FilterOperators.IS_NULL: filterExpr.Append($" IS NULL "); break; case FilterOperators.BETWEEN: if (dataType == DataType.NUMBER) { filterExpr.Append($" {values.FirstOrDefault()} AND {values.Skip(1).FirstOrDefault()} "); } else { filterExpr.Append($" '{values.FirstOrDefault()}' AND '{values.Skip(1).FirstOrDefault()}' "); } break; default: if (dataType == DataType.NUMBER) { filterExpr.Append($" {values.FirstOrDefault()} "); } else { filterExpr.Append($" '{values.FirstOrDefault()}' "); } break; } filterExpr.Append(" ) "); var exprStr = filterExpr.ToString(); return(exprStr); }
public static bool IsMathFilter <T>(T item, Type filterProp, object filterPropValue, FilterOperators filterOperator) { if (filterPropValue != null) { if (item.GetType().GetProperty(filterProp.Name) != null && item.GetType().GetProperty(filterProp.Name).GetType() == filterProp) { Type itemPropType = item.GetType().GetProperty(filterProp.Name).GetType(); // TODO Check for object type and call method recursivly object itemPropertyValue = item.GetType().GetProperty(filterProp.Name).GetValue(item); if (filterOperator == FilterOperators.Eq && CanApplyOperator(itemPropType, filterOperator)) { return(itemPropertyValue == filterPropValue); } else if (filterOperator == FilterOperators.Gt && CanApplyOperator(itemPropType, filterOperator)) { // DateTime if (itemPropType == typeof(DateTime) && filterProp == typeof(DateTime)) { return((DateTime)itemPropertyValue > (DateTime)filterPropValue); } else if (itemPropType == typeof(DateTime?) && filterProp == typeof(DateTime?)) { return((DateTime)itemPropertyValue > (DateTime)filterPropValue); } // Short else if (itemPropType == typeof(short) && filterProp == typeof(short)) { return((short)itemPropertyValue > (short)filterPropValue); } else if (itemPropType == typeof(short?) && filterProp == typeof(short?)) { return((short)itemPropertyValue > (short)filterPropValue); } // Int else if (itemPropType == typeof(int) && filterProp == typeof(int)) { return((int)itemPropertyValue > (int)filterPropValue); } else if (itemPropType == typeof(int?) && filterProp == typeof(int?)) { return((int)itemPropertyValue > (int)filterPropValue); } // Long else if (itemPropType == typeof(long) && filterProp == typeof(long)) { return((long)itemPropertyValue > (long)filterPropValue); } else if (itemPropType == typeof(long?) && filterProp == typeof(long?)) { return((long)itemPropertyValue > (long)filterPropValue); } // Float else if (itemPropType == typeof(float) && filterProp == typeof(float)) { return((float)itemPropertyValue > (float)filterPropValue); } else if (itemPropType == typeof(float?) && filterProp == typeof(float?)) { return((float)itemPropertyValue > (float)filterPropValue); } // Double else if (itemPropType == typeof(double) && filterProp == typeof(double)) { return((double)itemPropertyValue > (double)filterPropValue); } else if (itemPropType == typeof(double?) && filterProp == typeof(double?)) { return((double)itemPropertyValue > (double)filterPropValue); } // Decimal else if (itemPropType == typeof(decimal) && filterProp == typeof(decimal)) { return((decimal)itemPropertyValue > (decimal)filterPropValue); } else if (itemPropType == typeof(decimal?) && filterProp == typeof(decimal?)) { return((decimal)itemPropertyValue > (decimal)filterPropValue); } } else if (filterOperator == FilterOperators.GtEq && CanApplyOperator(itemPropType, filterOperator)) { // DateTime if (itemPropType == typeof(DateTime) && filterProp == typeof(DateTime)) { return((DateTime)itemPropertyValue >= (DateTime)filterPropValue); } else if (itemPropType == typeof(DateTime?) && filterProp == typeof(DateTime?)) { return((DateTime)itemPropertyValue >= (DateTime)filterPropValue); } // Short else if (itemPropType == typeof(short) && filterProp == typeof(short)) { return((short)itemPropertyValue >= (short)filterPropValue); } else if (itemPropType == typeof(short?) && filterProp == typeof(short?)) { return((short)itemPropertyValue >= (short)filterPropValue); } // Int else if (itemPropType == typeof(int) && filterProp == typeof(int)) { return((int)itemPropertyValue >= (int)filterPropValue); } else if (itemPropType == typeof(int?) && filterProp == typeof(int?)) { return((int)itemPropertyValue >= (int)filterPropValue); } // Long else if (itemPropType == typeof(long) && filterProp == typeof(long)) { return((long)itemPropertyValue >= (long)filterPropValue); } else if (itemPropType == typeof(long?) && filterProp == typeof(long?)) { return((long)itemPropertyValue >= (long)filterPropValue); } // Float else if (itemPropType == typeof(float) && filterProp == typeof(float)) { return((float)itemPropertyValue >= (float)filterPropValue); } else if (itemPropType == typeof(float?) && filterProp == typeof(float?)) { return((float)itemPropertyValue >= (float)filterPropValue); } // Double else if (itemPropType == typeof(double) && filterProp == typeof(double)) { return((double)itemPropertyValue >= (double)filterPropValue); } else if (itemPropType == typeof(double?) && filterProp == typeof(double?)) { return((double)itemPropertyValue >= (double)filterPropValue); } // Decimal else if (itemPropType == typeof(decimal) && filterProp == typeof(decimal)) { return((decimal)itemPropertyValue >= (decimal)filterPropValue); } else if (itemPropType == typeof(decimal?) && filterProp == typeof(decimal?)) { return((decimal)itemPropertyValue >= (decimal)filterPropValue); } } else if (filterOperator == FilterOperators.Lt && CanApplyOperator(itemPropType, filterOperator)) { // DateTime if (itemPropType == typeof(DateTime) && filterProp == typeof(DateTime)) { return((DateTime)itemPropertyValue < (DateTime)filterPropValue); } else if (itemPropType == typeof(DateTime?) && filterProp == typeof(DateTime?)) { return((DateTime)itemPropertyValue < (DateTime)filterPropValue); } // Short else if (itemPropType == typeof(short) && filterProp == typeof(short)) { return((short)itemPropertyValue < (short)filterPropValue); } else if (itemPropType == typeof(short?) && filterProp == typeof(short?)) { return((short)itemPropertyValue < (short)filterPropValue); } // Int else if (itemPropType == typeof(int) && filterProp == typeof(int)) { return((int)itemPropertyValue < (int)filterPropValue); } else if (itemPropType == typeof(int?) && filterProp == typeof(int?)) { return((int)itemPropertyValue < (int)filterPropValue); } // Long else if (itemPropType == typeof(long) && filterProp == typeof(long)) { return((long)itemPropertyValue < (long)filterPropValue); } else if (itemPropType == typeof(long?) && filterProp == typeof(long?)) { return((long)itemPropertyValue < (long)filterPropValue); } // Float else if (itemPropType == typeof(float) && filterProp == typeof(float)) { return((float)itemPropertyValue < (float)filterPropValue); } else if (itemPropType == typeof(float?) && filterProp == typeof(float?)) { return((float)itemPropertyValue < (float)filterPropValue); } // Double else if (itemPropType == typeof(double) && filterProp == typeof(double)) { return((double)itemPropertyValue < (double)filterPropValue); } else if (itemPropType == typeof(double?) && filterProp == typeof(double?)) { return((double)itemPropertyValue < (double)filterPropValue); } // Decimal else if (itemPropType == typeof(decimal) && filterProp == typeof(decimal)) { return((decimal)itemPropertyValue < (decimal)filterPropValue); } else if (itemPropType == typeof(decimal?) && filterProp == typeof(decimal?)) { return((decimal)itemPropertyValue < (decimal)filterPropValue); } } else if (filterOperator == FilterOperators.LtEq && CanApplyOperator(itemPropType, filterOperator)) { // DateTime if (itemPropType == typeof(DateTime) && filterProp == typeof(DateTime)) { return((DateTime)itemPropertyValue <= (DateTime)filterPropValue); } else if (itemPropType == typeof(DateTime?) && filterProp == typeof(DateTime?)) { return((DateTime)itemPropertyValue <= (DateTime)filterPropValue); } // Short else if (itemPropType == typeof(short) && filterProp == typeof(short)) { return((short)itemPropertyValue <= (short)filterPropValue); } else if (itemPropType == typeof(short?) && filterProp == typeof(short?)) { return((short)itemPropertyValue <= (short)filterPropValue); } // Int else if (itemPropType == typeof(int) && filterProp == typeof(int)) { return((int)itemPropertyValue <= (int)filterPropValue); } else if (itemPropType == typeof(int?) && filterProp == typeof(int?)) { return((int)itemPropertyValue <= (int)filterPropValue); } // Long else if (itemPropType == typeof(long) && filterProp == typeof(long)) { return((long)itemPropertyValue <= (long)filterPropValue); } else if (itemPropType == typeof(long?) && filterProp == typeof(long?)) { return((long)itemPropertyValue <= (long)filterPropValue); } // Float else if (itemPropType == typeof(float) && filterProp == typeof(float)) { return((float)itemPropertyValue <= (float)filterPropValue); } else if (itemPropType == typeof(float?) && filterProp == typeof(float?)) { return((float)itemPropertyValue <= (float)filterPropValue); } // Double else if (itemPropType == typeof(double) && filterProp == typeof(double)) { return((double)itemPropertyValue <= (double)filterPropValue); } else if (itemPropType == typeof(double?) && filterProp == typeof(double?)) { return((double)itemPropertyValue <= (double)filterPropValue); } // Decimal else if (itemPropType == typeof(decimal) && filterProp == typeof(decimal)) { return((decimal)itemPropertyValue <= (decimal)filterPropValue); } else if (itemPropType == typeof(decimal?) && filterProp == typeof(decimal?)) { return((decimal)itemPropertyValue <= (decimal)filterPropValue); } } if (filterOperator == FilterOperators.Contains && CanApplyOperator(itemPropType, filterOperator)) { return(itemPropertyValue.ToString().Contains(filterPropValue.ToString())); } else if (filterOperator == FilterOperators.IsNull) { return(itemPropertyValue == null); } } } return(true); }