public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
out Expression expression)
{
if (operation.Type == typeof(bool) &&
type.IsInstanceOfType(value))
{
MemberExpression property =
Expression.Property(instance, operation.Property);
object parserValue = type.ParseLiteral(value);
switch (operation.Kind)
{
case FilterOperationKind.Equals:
expression = FilterExpressionBuilder.Equals(
property, parserValue);
return(true);
case FilterOperationKind.NotEquals:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Equals(
property, parserValue)
);
return(true);
}
}
expression = null;
return(false);
}
protected override bool TryCreateExpression(
FilterOperation operation,
Expression property,
Func <object> parseValue,
out Expression expression)
{
switch (operation.Kind)
{
case FilterOperationKind.Equals:
expression = FilterExpressionBuilder.Equals(
property, parseValue());
return(true);
case FilterOperationKind.NotEquals:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Equals(
property, parseValue())
);
return(true);
default:
expression = null;
return(false);
}
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
out Expression expression)
{
if (operation.Type == typeof(bool) && value is BooleanValueNode s)
{
MemberExpression property =
Expression.Property(instance, operation.Property);
switch (operation.Kind)
{
case FilterOperationKind.Equals:
expression = FilterExpressionBuilder.Equals(property, s.Value);
return(true);
case FilterOperationKind.NotEquals:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Equals(property, s.Value)
);
return(true);
}
}
expression = null;
return(false);
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out Expression?expression)
{
if (operation.Type == typeof(bool) && type.IsInstanceOfType(value))
{
Expression property = context.GetInstance();
if (!operation.IsSimpleArrayType())
{
property = Expression.Property(context.GetInstance(), operation.Property);
}
object parserValue = type.ParseLiteral(value);
switch (operation.Kind)
{
case FilterOperationKind.Equals:
expression = FilterExpressionBuilder.Equals(
property, parserValue);
return(true);
case FilterOperationKind.NotEquals:
expression = FilterExpressionBuilder.NotEquals(
property, parserValue);
return(true);
}
}
expression = null;
return(false);
}
public static bool Equals(
FilterOperation operation,
IInputType type,
IValueNode value,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out Expression?result)
{
object parsedValue = type.ParseLiteral(value);
if (!operation.IsNullable && parsedValue == null)
{
context.ReportError(
ErrorHelper.CreateNonNullError(operation, type, value, context));
result = null;
return(false);
}
if (operation.Type == typeof(IComparable) &&
type.IsInstanceOfType(value))
{
Expression property = GetProperty(operation, context);
parsedValue = ParseValue(parsedValue, operation, type, context);
result = FilterExpressionBuilder.Equals(property, parsedValue);
return(true);
}
else
{
throw new InvalidOperationException();
}
}
public static bool Enter(
FilterOperationField field,
ObjectFieldNode node,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out ISyntaxVisitorAction?action)
{
if (node.Value.IsNull())
{
if (field.Operation.IsNullable)
{
MemberExpression nestedProperty = Expression.Property(
context.GetInstance(),
field.Operation.Property);
Expression expression =
FilterExpressionBuilder.Equals(nestedProperty, null !);
context.GetLevel().Enqueue(expression);
}
else
{
context.ReportError(
ErrorHelper.CreateNonNullError(field, node, context));
}
action = SyntaxVisitor.Skip;
return(true);
}
if (field.Operation.Kind == FilterOperationKind.Object)
{
MemberExpression nestedProperty = Expression.Property(
context.GetInstance(),
field.Operation.Property);
context.PushInstance(nestedProperty);
action = SyntaxVisitor.Continue;
return(true);
}
action = null;
return(false);
}
protected override bool TryCreateExpression(
FilterOperation operation,
Expression property,
object parsedValue,
[NotNullWhen(true)] out Expression?expression)
{
switch (operation.Kind)
{
case FilterOperationKind.Equals:
expression = FilterExpressionBuilder.Equals(
property, parsedValue);
return(true);
case FilterOperationKind.NotEquals:
expression = FilterExpressionBuilder.NotEquals(
property, parsedValue);
return(true);
default:
expression = null;
return(false);
}
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
out Expression expression)
{
if (operation.Type == typeof(string) && value is StringValueNode s)
{
MemberExpression property =
Expression.Property(instance, operation.Property);
switch (operation.Kind)
{
case FilterOperationKind.Equals:
expression = FilterExpressionBuilder.Equals(
property, s.Value);
return(true);
case FilterOperationKind.NotEquals:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Equals(property, s.Value)
);
return(true);
case FilterOperationKind.StartsWith:
expression = FilterExpressionBuilder.StartsWith(
property, s.Value);
return(true);
case FilterOperationKind.EndsWith:
expression = FilterExpressionBuilder.EndsWith(
property, s.Value);
return(true);
case FilterOperationKind.NotStartsWith:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.StartsWith(
property, s.Value)
);
return(true);
case FilterOperationKind.NotEndsWith:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.EndsWith(property, s.Value)
);
return(true);
case FilterOperationKind.Contains:
expression = FilterExpressionBuilder.Contains(
property, s.Value);
return(true);
case FilterOperationKind.NotContains:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Contains(property, s.Value)
);
return(true);
}
}
if (operation.Type == typeof(string) && value is ListValueNode li)
{
MemberExpression property =
Expression.Property(instance, operation.Property);
var parsedValue = type.ParseLiteral(value);
switch (operation.Kind)
{
case FilterOperationKind.In:
expression = FilterExpressionBuilder.In(
property,
operation.Property.PropertyType,
parsedValue);
return(true);
case FilterOperationKind.NotIn:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.In(
property,
operation.Property.PropertyType,
parsedValue));
return(true);
}
}
expression = null;
return(false);
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
out Expression expression)
{
if (operation.Type == typeof(IComparable) &&
value is IValueNode <IComparable> s)
{
MemberExpression property =
Expression.Property(instance, operation.Property);
var parsedValue = type.ParseLiteral(value);
if (operation.Property.PropertyType
.IsInstanceOfType(parsedValue))
{
parsedValue = converter.Convert(
typeof(object),
operation.Property.PropertyType,
parsedValue);
}
switch (operation.Kind)
{
case FilterOperationKind.Equals:
expression = FilterExpressionBuilder.Equals(
property, parsedValue);
return(true);
case FilterOperationKind.NotEquals:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Equals(
property, parsedValue)
);
return(true);
case FilterOperationKind.GreaterThan:
expression = FilterExpressionBuilder.GreaterThan(
property, parsedValue);
return(true);
case FilterOperationKind.NotGreaterThan:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.GreaterThan(
property, parsedValue)
);
return(true);
case FilterOperationKind.GreaterThanOrEqual:
expression = FilterExpressionBuilder.GreaterThanOrEqual(
property, parsedValue);
return(true);
case FilterOperationKind.NotGreaterThanOrEqual:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.GreaterThanOrEqual(
property, parsedValue)
);
return(true);
case FilterOperationKind.LowerThan:
expression = FilterExpressionBuilder.LowerThan(
property, parsedValue);
return(true);
case FilterOperationKind.NotLowerThan:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.LowerThan(
property, parsedValue));
return(true);
case FilterOperationKind.LowerThanOrEqual:
expression = FilterExpressionBuilder.LowerThanOrEqual(
property, parsedValue);
return(true);
case FilterOperationKind.NotLowerThanOrEqual:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.LowerThanOrEqual(
property, parsedValue));
return(true);
}
}
if (operation.Type == typeof(IComparable) && value is ListValueNode li)
{
MemberExpression property =
Expression.Property(instance, operation.Property);
var parsedValue = type.ParseLiteral(value);
switch (operation.Kind)
{
case FilterOperationKind.In:
expression = FilterExpressionBuilder.In(
property,
operation.Property.PropertyType,
parsedValue);
return(true);
case FilterOperationKind.NotIn:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.In(
property,
operation.Property.PropertyType,
parsedValue)
);
return(true);
}
}
expression = null;
return(false);
}
