/// <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 OperatorViewModel(FilterOperators op)
: this()
{
Operator = op;
}
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);
}
