private FilterViewModel CreateFilterViewModel(string propertyName, string startValue, string endValue = "", Axiom.Common.Enumerations.FilterCondition condition = Axiom.Common.Enumerations.FilterCondition.Equals)
        {
            FilterViewModel filter = new FilterViewModel();
            filter.PropertyName = propertyName;
            filter.StartValue = startValue;
            if (!string.IsNullOrEmpty(endValue))
                filter.EndValue = endValue;
            filter.WhereCondition = Axiom.Common.Enumerations.PredicateCondition.And;
            filter.FilterCondition = condition;

            return filter;
        }
예제 #2
0
        internal static void GetFilterExpression(FilterViewModel filter, Type type, ParameterExpression p, ref Expression predicateBody)
        {
            Expression exp = null, exp2 = null, left = null, right = null;

            var pr = type.GetProperty(filter.PropertyName);
            if (pr == null) return;
            var prType = pr.PropertyType;
            left = Expression.Property(p, pr);
            if (prType == typeof(string))
                left = Expression.Call(left, prType.GetMethod("ToLower", System.Type.EmptyTypes));
            right = Expression.Constant(GetExpressionValue(filter.StartValue, prType), prType);

            switch (filter.FilterCondition)
            {
                case FilterCondition.StartsWith:
                    exp = Expression.Call(left, Ax.GetFilterMethodName(FilterCondition.StartsWith), null, right);
                    break;
                case FilterCondition.EndsWith:
                    exp = Expression.Call(left, Ax.GetFilterMethodName(FilterCondition.EndsWith), null, right);
                    break;
                case FilterCondition.Contains:
                    exp = Expression.Call(left, Ax.GetFilterMethodName(FilterCondition.Contains), null, right);
                    break;
                case FilterCondition.Equals:
                    exp = Expression.Equal(left, right);
                    break;
                case FilterCondition.NotEqual:
                    exp = Expression.NotEqual(left, right);
                    break;
                case FilterCondition.Greater:
                    exp = Expression.GreaterThan(left, right);
                    break;
                case FilterCondition.Less:
                    exp = Expression.LessThan(left, right);
                    break;
                case FilterCondition.Between:
                    exp = Expression.GreaterThan(left, right);
                    exp2 = Expression.LessThan(left, Expression.Constant(GetExpressionValue(filter.EndValue, prType), prType));
                    break;
                default:
                    exp = Expression.Equal(left, right);
                    break;
            }

            if (predicateBody == null)
                predicateBody = exp2 == null ? exp : Expression.And(exp, exp2);
            else
            {
                if (filter.WhereCondition == PredicateCondition.Or)
                {
                    predicateBody = exp2 == null ?
                        Expression.Or(predicateBody, exp) :
                        Expression.Or(predicateBody, Expression.And(exp, exp2));
                }
                else
                {
                    predicateBody = exp2 == null ?
                        Expression.And(predicateBody, exp) :
                        Expression.And(predicateBody, Expression.And(exp, exp2));
                }
            }
        }