public static FilterFieldMetaInfo[] GetFilterFields(IDataFilter filter) { var filterUniqueName = TypeHelper.GetGenericTypeUniqueName(filter.GetType()); var propExprMappings = FieldExprNameMappingFactory.Get(filterUniqueName, () => { return(InternalExprNameMappingUtil.CreateFilterExprNameMappings(filter).ToList()); }); var exprNames = propExprMappings.Select(p => p.Property.Name); var properties = GetFieldPropertiesFromFilter(filter).Where(p => exprNames.Contains(p.Name)); var fieldFilterIndex = 0; var FilterFieldMetaInfos = new FilterFieldMetaInfo[properties.Count()]; foreach (var property in properties) { var map = propExprMappings.FirstOrDefault(p => p.Property.Name == property.Name); var objValue = property.GetValue(filter, null); var sortValue = objValue as IHasSortField; if (sortValue != null && sortValue.SortMode == SortMode.Disable) { if (map.ExprNameAttribute != null) { sortValue.SortMode = map.ExprNameAttribute.SortMode; sortValue.SortPriority = map.ExprNameAttribute.SortPriority; } objValue = sortValue; } FilterFieldMetaInfos[fieldFilterIndex++] = CreateFilterFieldMetaInfoByType( property.PropertyType, objValue, map.ExprName, property.GetCustomAttributes <Attribute>(true)); } return(FilterFieldMetaInfos); }
public Expression Handle(Expression node, FilterFieldMetaInfo metaData) { if (node.NodeType != ExpressionType.Lambda) { throw new ArgumentException($"invalid node.NodeType {node.NodeType}. It's should be ExpressionType.Lambda"); } var method = GetType().GetTypeInfo().GetMethod(filterName); var genericMethod = method.MakeGenericMethod(metaData.PrimitiveType, metaData.FilterFieldType); var lambdaExpr = node as LambdaExpression; var parameter = lambdaExpr.Parameters[0]; Expression memberAccess = null; foreach (var property in metaData.FilterFieldExprName.Split('.')) { memberAccess = Expression.Property(memberAccess ?? (parameter as Expression), property); } return((Expression)genericMethod.Invoke(this, new object[] { lambdaExpr, memberAccess, parameter, metaData })); }
protected virtual Expression InternalHandleWhere <TPrimitive, TFiledOfPrimitive>(LambdaExpression node, Expression memberAccessExpr, Expression parameterExpr, FilterFieldMetaInfo metaData) where TPrimitive : struct, IConvertible, IComparable { var field = metaData.FilterFieldInstace as FreeDomRangeField <TPrimitive>; if (field == null) { throw new ArgumentException($"field should be {typeof(FreeDomRangeField<TPrimitive>)}"); } Expression left = null; Expression right = null; #region min (left) if (field.Min != null) { var expr = ExpressionType.Default; var body = Expression.Constant(field.Min.Value); if (field.MinCompareMode == CompareMode.GreaterThan) { expr = ExpressionType.GreaterThan; } else if (field.MinCompareMode == CompareMode.GreaterThanOrEqual) { expr = ExpressionType.GreaterThanOrEqual; } if (expr == ExpressionType.Default) { throw new ArgumentException($"invalid MinCompareMode {field.MinCompareMode.ToString()}"); } left = Expression.MakeBinary(expr, memberAccessExpr, body); } #endregion #region max (right) if (field.Max != null) { var expr = ExpressionType.Default; var body = Expression.Constant(field.Max.Value); if (field.MaxCompareMode == CompareMode.LessThan) { expr = ExpressionType.LessThan; } else if (field.MaxCompareMode == CompareMode.LessThanOrEqual) { expr = ExpressionType.LessThanOrEqual; } if (expr == ExpressionType.Default) { throw new ArgumentException($"invalid MaxCompareMode {field.MaxCompareMode.ToString()}"); } right = Expression.MakeBinary(expr, memberAccessExpr, body); } #endregion return(MakeExpr(node, left, right)); }
public override Expression HandleWhere <TPrimitive, TFiledOfPrimitive>(LambdaExpression node, Expression memberAccessExpr, Expression parameterExpr, FilterFieldMetaInfo metaData) { var method = GetType().GetTypeInfo().GetMethod(nameof(InternalHandleWhere), BindingFlags.Instance | BindingFlags.NonPublic); return((Expression)method.MakeGenericMethod(typeof(TPrimitive), typeof(TFiledOfPrimitive)).Invoke(this, new object[] { node, memberAccessExpr, parameterExpr, metaData })); }
public override Expression HandleWhere <TPrimitive, TFiledOfPrimitive>(LambdaExpression node, Expression memberAccessExpr, Expression parameterExpr, FilterFieldMetaInfo metaData) { var field = metaData.FilterFieldInstace as ContainsField <TPrimitive>; if (field == null) { throw new ArgumentException($"field should be {typeof(ContainsField<TPrimitive>)}"); } if (!(field.Values.IsEmpty())) { var body = Expression.Constant(field.Values); var method = EnumableMethods.Contains.MakeGenericMethod(typeof(TPrimitive)); var methodExpr = Expression.Call(method, body, memberAccessExpr); if (field.CompareMode == CompareMode.Contains) { return(Expression.Lambda(Expression.AndAlso(node.Body, methodExpr), node.Parameters)); } if (field.CompareMode == CompareMode.NotContains) { return(Expression.Lambda(Expression.AndAlso(node.Body, Expression.Not(methodExpr)), node.Parameters)); } throw new ArgumentException($"invalid CompareMode {field.CompareMode.ToString()}"); } return(base.HandleWhere <TPrimitive, TFiledOfPrimitive>(node, memberAccessExpr, parameterExpr, metaData)); }
public override Expression HandleWhere <TPrimitive, TFiledOfPrimitive>(LambdaExpression node, Expression memberAccessExpr, Expression parameterExpr, FilterFieldMetaInfo metaData) { return(base.HandleWhere <TPrimitive, TFiledOfPrimitive>(node, memberAccessExpr, parameterExpr, metaData)); }
public override Expression HandleWhere <TPrimitive, TFiledOfPrimitive>(LambdaExpression node, Expression memberAccessExpr, Expression parameterExpr, FilterFieldMetaInfo metaData) { var field = metaData.FilterFieldInstace as LikeField; if (field == null) { throw new ArgumentException($"field should be {typeof(LikeField)}"); } if (String.IsNullOrEmpty(field.Value)) { return(base.HandleWhere <TPrimitive, TFiledOfPrimitive>(node, memberAccessExpr, parameterExpr, metaData)); } // p => !String.IsNullOrEmpty(p) && p.StartsWith(Value) // p => !String.IsNullOrEmpty(p) && p.EndsWith(Value) // p => !String.IsNullOrEmpty(p) && p.IndexOf(Value)>-1 var exprArg = Expression.Constant(field.Value); var exprIsNotNullChecker = Expression.Not(Expression.Call(StringMethods.IsNullOrEmpty, memberAccessExpr)); Expression exprBody = null; if (field.CompareMode == CompareMode.LeftLike) { exprBody = Expression.AndAlso(exprIsNotNullChecker, Expression.Call(memberAccessExpr, StringMethods.StartsWith, exprArg)); } else if (field.CompareMode == CompareMode.RightLike) { exprBody = Expression.AndAlso(exprIsNotNullChecker, Expression.Call(memberAccessExpr, StringMethods.EndsWith, exprArg)); } else if (field.CompareMode == CompareMode.FullSearchLike) { exprBody = Expression.AndAlso(exprIsNotNullChecker, Expression.GreaterThan(Expression.Call(memberAccessExpr, StringMethods.IndexOf, exprArg), Expression.Constant(-1))); } if (exprBody != null) { return(Expression.Lambda(Expression.AndAlso(node.Body, exprBody), node.Parameters)); } throw new ArgumentException($"invalid CompareMode {field.CompareMode.ToString()}"); }
public override Expression HandleWhere <TPrimitive, TFiledOfPrimitive>(LambdaExpression node, Expression memberAccessExpr, Expression parameterExpr, FilterFieldMetaInfo metaData) { var field = metaData.FilterFieldInstace as CompareField <TPrimitive>; if (field == null) { throw new ArgumentException($"field should be {typeof(CompareField<TPrimitive>)}"); } var predicateBody = Expression.Constant(field.Value); var expressionType = ExpressionType.Default; if (field.CompareMode == CompareMode.Equal) { expressionType = ExpressionType.Equal; } else if (field.CompareMode == CompareMode.NotEqual) { expressionType = ExpressionType.NotEqual; } else if (field.CompareMode == CompareMode.LessThan) { expressionType = ExpressionType.LessThan; } else if (field.CompareMode == CompareMode.LessThanOrEqual) { expressionType = ExpressionType.LessThanOrEqual; } else if (field.CompareMode == CompareMode.GreaterThan) { expressionType = ExpressionType.GreaterThan; } else if (field.CompareMode == CompareMode.GreaterThanOrEqual) { expressionType = ExpressionType.GreaterThanOrEqual; } if (expressionType == ExpressionType.Default) { throw new ArgumentException($"invalid CompareMode {field.CompareMode.ToString()}"); } return(Expression.Lambda(Expression.AndAlso(node.Body, Expression.MakeBinary(expressionType, memberAccessExpr, predicateBody)), node.Parameters)); }
public virtual Expression HandleWhere <TPrimitive, TFluentFilterFiled>(LambdaExpression node, Expression memberAccessExpr, Expression parameterExpr, FilterFieldMetaInfo metaData) where TPrimitive : IConvertible, IComparable where TFluentFilterFiled : class, IField <TPrimitive> { return(node); }
public override Expression HandleWhere <TPrimitive, TFiledOfPrimitive>(LambdaExpression node, Expression memberAccessExpr, Expression parameterExpr, FilterFieldMetaInfo metaData) { var field = metaData.FilterFieldInstace as EqualsField <TPrimitive>; if (field == null) { throw new ArgumentException($"field should be {typeof(EqualsField<TPrimitive>)}"); } if (!(field.Value.IsEmpty())) { if (field.CompareMode == CompareMode.Equal) { var value = Expression.Constant(field.Value); return(Expression.Lambda(Expression.AndAlso(node.Body, Expression.Equal(memberAccessExpr, value)), node.Parameters)); } throw new ArgumentException($"invalid CompareMode {field.CompareMode.ToString()}"); } return(base.HandleWhere <TPrimitive, TFiledOfPrimitive>(node, memberAccessExpr, parameterExpr, metaData)); }