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