internal override ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata)
{
if (!(expression is MethodCallExpression methodCallExpression))
{
throw new ExpressionConvertException();
}
if (methodCallExpression.Object == null &&
TryGetExpressionMethodConverter(methodCallExpression, out var expressionMethodConverter))
{
return(expressionMethodConverter.Convert(methodCallExpression, modelMetadata));
}
if (methodCallExpression.Object != null && IsColumnPathMember(methodCallExpression.Object, modelMetadata) &&
TryGetPropertyMethodConverter(methodCallExpression, out var propertyMethodConverter))
{
return(propertyMethodConverter.Convert(methodCallExpression, modelMetadata));
}
if (methodCallExpression.Object != null && !IsColumnPathMember(methodCallExpression.Object, modelMetadata) &&
TryGetFieldMethodConverter(methodCallExpression, out var fieldMethodConverter))
{
return(fieldMethodConverter.Convert(methodCallExpression, modelMetadata));
}
if (TryDynamicInvoke(expression, out var value))
{
return(GetPropertyMetadata(expression, value));
}
throw new ExpressionConvertException();
}
internal override ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata)
{
if (TryDynamicInvoke(expression, out var value))
{
return(GetPropertyMetadata(expression, value));
}
throw new NotSupportedException();
}
internal override ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata)
{
if (!(expression is LambdaExpression lambdaExpression))
{
throw new ExpressionConvertException();
}
throw new NotImplementedException();
}
internal override ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata)
{
var body = GetExpressionBody(expression);
if (IsColumnPathMember(body, modelMetadata))
{
return(GetColumnPathMetadata(body, modelMetadata));
}
throw new NotSupportedException();
}
internal override ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata)
{
if (!(expression is MethodCallExpression methodCallExpression))
{
throw new ExpressionConvertException();
}
return(methodCallExpression.Arguments.Count > 1
? base.Convert(expression, modelMetadata)
: GenerateGroup(LogicalOperationStrict.And));
}
protected static ExpressionMetadata GetColumnPathMetadata(Expression node, ExpressionModelMetadata modelMetadata)
{
return(new ExpressionMetadata()
{
NodeType = ExpressionMetadataNodeType.Column,
Parameter = new ExpressionMetadataParameter()
{
Type = node.Type,
ColumnPath = GetColumnPath(node, modelMetadata)
}
});
}
internal static ExpressionMetadata GenerateFilterElementExpression(Expression expression,
ExpressionModelMetadata modelMetadata)
{
if (TryDynamicInvoke(expression, out var value))
{
return(GetPropertyMetadata(expression, value));
}
if (IsDetailPathMember(expression, modelMetadata))
{
throw new NotSupportedException();
}
return(ConvertModelQueryExpression(expression, modelMetadata));
}
internal override ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata)
{
if (TryDynamicInvoke(expression, out var value))
{
return(GetPropertyMetadata(expression, value));
}
if (expression is UnaryExpression unaryExpression)
{
var response = ConvertModelQueryExpression(unaryExpression.Operand, modelMetadata);
response.IsNot = true;
return(response);
}
throw new NotImplementedException();
}
internal override ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata)
{
if (TryDynamicInvoke(expression, out var value))
{
return(GetPropertyMetadata(expression, value));
}
if (expression is UnaryExpression unaryExpression)
{
if (IsColumnPathMember(unaryExpression.Operand, modelMetadata))
{
return(GetColumnPathMetadata(unaryExpression.Operand, modelMetadata));
}
}
throw new NotImplementedException();
}
internal override ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata)
{
if (!(expression is MethodCallExpression methodCallExpression) || methodCallExpression.Arguments.Count < 1)
{
throw new ExpressionConvertException();
}
var left = ComparisonExpressionConverter.GenerateFilterElementExpression(
methodCallExpression.Arguments.First(), modelMetadata);
var valueType = left.Parameter.Type;
var valueList = GetRightValuesList(methodCallExpression.Object, GetType(), valueType);
var rightExpressions = valueList.Select(value => GetPropertyMetadata(valueType, value)).ToArray();
return(ComparisonExpressionConverter.GenerateComparisonExpressionMetadata(left, FilterComparisonType.Equal, rightExpressions));
}
internal override ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata)
{
if (!(expression is MethodCallExpression methodCallExpression) || methodCallExpression.Arguments.Count < 2)
{
throw new ExpressionConvertException();
}
var body = methodCallExpression.Arguments.Skip(1).First();
if (TryDynamicInvoke(body, out var value))
{
return(GetPropertyMetadata(body, value));
}
throw new NotSupportedException();
}
protected static bool IsColumnPathMember(Expression node, ExpressionModelMetadata modelMetadata)
{
if (node is MemberExpression memberNode)
{
if (memberNode.Member.DeclaringType == null || !(memberNode.Member.DeclaringType == typeof(BaseModel) || memberNode.Member.DeclaringType.IsSubclassOf(typeof(BaseModel))))
{
return(false);
}
return(IsColumnPathMember(memberNode.Expression, modelMetadata));
}
if (node is ParameterExpression parameterExpression)
{
return(parameterExpression.Name == modelMetadata.Name && parameterExpression.Type == modelMetadata.Type);
}
return(false);
}
internal override ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata)
{
if (!(expression is MemberExpression memberExpression))
{
throw new ExpressionConvertException();
}
if (IsColumnPathMember(memberExpression, modelMetadata))
{
return(GetColumnPathMetadata(memberExpression, modelMetadata));
}
if (TryDynamicInvoke(memberExpression, out var value))
{
return(GetPropertyMetadata(memberExpression, value));
}
return(null);
}
protected static bool IsDetailPathMember(Expression node, ExpressionModelMetadata modelMetadata)
{
if (node is MethodCallExpression methodCallExpression)
{
if (methodCallExpression.Arguments.Count > 0)
{
return(IsDetailPathMember(methodCallExpression.Arguments.First(), modelMetadata));
}
return(false);
}
if (node is MemberExpression memberNode && memberNode.Member.DeclaringType != null &&
(memberNode.Member.DeclaringType == typeof(BaseModel) ||
memberNode.Member.DeclaringType.IsSubclassOf(typeof(BaseModel))) &&
IsColumnPathMember(memberNode.Expression, modelMetadata))
{
return(IsDetailMember(memberNode.Member));
}
return(false);
}
internal override ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata)
{
if (!(expression is MethodCallExpression methodCallExpression) || methodCallExpression.Arguments.Count != 2)
{
throw new ExpressionConvertException();
}
var argumentExpression = methodCallExpression.Arguments.Skip(1).First();
if (!(argumentExpression is UnaryExpression unaryExpression))
{
throw new ExpressionConvertException();
}
if (!(unaryExpression.Operand is LambdaExpression lambdaExpression))
{
throw new ExpressionConvertException();
}
var innerExpression = lambdaExpression.Body;
return(ConvertExpression(innerExpression, modelMetadata));
}
private static ExpressionMetadata ConvertExpression(Expression expression, ExpressionModelMetadata modelMetadata)
{
if (expression is BinaryExpression binaryExpression)
{
return(ConvertBinaryExpressionMetadata(binaryExpression, modelMetadata));
}
if (IsDetailPathMember(expression, modelMetadata))
{
throw new NotSupportedException();
}
if (expression is MethodCallExpression methodCallExpression)
{
var converter = GetExpressionConverter(typeof(MethodCallExpressionConverter));
return(converter.Convert(methodCallExpression, modelMetadata));
}
if (expression is UnaryExpression unaryExpression && unaryExpression.NodeType == ExpressionType.Not)
{
var response = ConvertExpression(unaryExpression.Operand, modelMetadata);
return(ApplyNot(response));
}
return(ConvertUnaryExpressionMetadata(expression, modelMetadata));
}
internal static ExpressionMetadata ConvertModelQueryExpression(Expression expression, ExpressionModelMetadata modelMetadata)
{
ExpressionConverter expressionConverter = null;
if (expression.NodeType == ExpressionType.Call)
{
expressionConverter = GetExpressionConverter <MethodCallExpressionConverter>();
}
if (expression.NodeType == ExpressionType.Lambda)
{
expressionConverter = GetExpressionConverter <LambdaExpressionConverter>();
}
if (expression.NodeType == ExpressionType.MemberAccess)
{
expressionConverter = GetExpressionConverter <MemberAccessExpressionConverter>();
}
if (expression.NodeType == ExpressionType.Constant)
{
expressionConverter = GetExpressionConverter <ConstantExpressionConverter>();
}
if (expression.NodeType == ExpressionType.Convert)
{
expressionConverter = GetExpressionConverter <ConvertExpressionConverter>();
}
if (expression.NodeType == ExpressionType.Not)
{
expressionConverter = GetExpressionConverter <NotExpressionConverter>();
}
if (expressionConverter == null)
{
throw new NotImplementedException();
}
return(expressionConverter.Convert(expression, modelMetadata));
}
internal abstract ExpressionMetadata Convert(Expression expression, ExpressionModelMetadata modelMetadata);
private static string GetColumnPath(Expression node, ExpressionModelMetadata modelMetadata)
{
var chainList = GetColumnPathChainList(node);
return(ModelUtilities.GetColumnPath(modelMetadata.Type, chainList));
}
private static ExpressionMetadata CreateBinaryComparisonExpressionMetadata(BinaryExpression binaryExpression, ExpressionModelMetadata modelMetadata)
{
if (GroupOperations.Contains(binaryExpression.NodeType))
{
return(ConvertExpressionGroup(binaryExpression, modelMetadata));
}
var comparisonType = GetComparisonType(binaryExpression.NodeType);
var leftExpressionMetadata = GenerateFilterElementExpression(binaryExpression.Left, modelMetadata);
var rightExpressionMetadata = GenerateFilterElementExpression(binaryExpression.Right, modelMetadata);
return(CanBeConvertedAsIsNullComparison(leftExpressionMetadata, comparisonType, rightExpressionMetadata)
? GenerateIsNullExpressionMetadata(leftExpressionMetadata, comparisonType)
: GenerateComparisonExpressionMetadata(leftExpressionMetadata, comparisonType,
rightExpressionMetadata));
}
internal static ExpressionMetadata GenerateComparisonExpressionMetadata(Expression left,
FilterComparisonType comparisonType, ExpressionModelMetadata modelMetadata, params Expression[] rights)
{
var leftExpressionMetadata = GenerateFilterElementExpression(left, modelMetadata);
var rightExpressionMetadataList =
rights.Select(right => GenerateFilterElementExpression(right, modelMetadata)).ToArray();
return(GenerateComparisonExpressionMetadata(leftExpressionMetadata, comparisonType,
rightExpressionMetadataList));
}
private static ExpressionMetadata ConvertBinaryExpressionMetadata(BinaryExpression binaryExpression, ExpressionModelMetadata modelMetadata)
{
var nodeType = binaryExpression.NodeType;
return(GroupOperations.Contains(binaryExpression.NodeType)
? ConvertExpressionGroup(binaryExpression, modelMetadata)
: CreateBinaryComparisonExpressionMetadata(binaryExpression, modelMetadata));
}
private static ExpressionMetadata ConvertExpressionGroup(BinaryExpression binaryExpression, ExpressionModelMetadata modelMetadata)
{
var logicalOperation = GetLogicalOperation(binaryExpression.NodeType);
var groupExpressionMetadata = GenerateGroup(logicalOperation);
groupExpressionMetadata.Items.Add(ConvertExpression(binaryExpression.Left, modelMetadata));
groupExpressionMetadata.Items.Add(ConvertExpression(binaryExpression.Right, modelMetadata));
return(groupExpressionMetadata);
}
private static ExpressionMetadata ConvertUnaryExpressionMetadata(Expression left, ExpressionModelMetadata modelMetadata)
{
var leftExpressionMetadata = GenerateFilterElementExpression(left, modelMetadata);
var rightExpressionMetadata = GetPropertyMetadata(typeof(bool), true);
var comparisonType = leftExpressionMetadata.IsNot
? FilterComparisonType.NotEqual
: FilterComparisonType.Equal;
return(GenerateComparisonExpressionMetadata(leftExpressionMetadata, comparisonType,
rightExpressionMetadata));
}
