public static bool EndsWith(
FilterOperation operation,
IInputType type,
IValueNode value,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out Expression?result)
{
object parsedValue = type.ParseLiteral(value);
if (parsedValue == null)
{
context.ReportError(
ErrorHelper.CreateNonNullError(operation, type, value, context));
result = null;
return(false);
}
if (operation.Type == typeof(string) &&
type.IsInstanceOfType(value))
{
Expression property = GetProperty(operation, context);
result = FilterExpressionBuilder.EndsWith(property, parsedValue);
return(true);
}
else
{
throw new InvalidOperationException();
}
}
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);
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
out Expression expression)
{
if (operation.Type == typeof(string) &&
(value is StringValueNode || value.IsNull()))
{
object parsedValue = type.ParseLiteral(value);
MemberExpression property =
Expression.Property(instance, operation.Property);
return(TryCreateExpression(
operation,
property,
parsedValue,
out expression));
}
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) &&
type.IsInstanceOfType(value))
{
object parsedValue = type.ParseLiteral(value);
Expression property = instance;
if (!operation.IsSimpleArrayType())
{
property = Expression.Property(instance, operation.Property);
}
return(TryCreateExpression(
operation,
property,
parsedValue,
out expression));
}
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) &&
type.IsInstanceOfType(value))
{
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);
}
return(TryCreateExpression(
operation,
property,
parsedValue,
out expression));
}
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 bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
IQueryableFilterVisitorContext context,
out Expression expression)
{
if (operation.Type == typeof(string) &&
type.IsInstanceOfType(value))
{
object parsedValue = type.ParseLiteral(value);
Expression property = context.GetInstance();
if (!operation.IsSimpleArrayType())
{
property = Expression.Property(
context.GetInstance(), operation.Property);
}
return(TryCreateExpression(
operation,
property,
parsedValue,
out expression));
}
expression = null;
return(false);
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out Expression?expression)
{
if (operation.Type == typeof(IComparable) &&
type.IsInstanceOfType(value))
{
Expression property = context.GetInstance();
if (!operation.IsSimpleArrayType())
{
property = Expression.Property(context.GetInstance(), operation.Property);
}
if (operation.Kind == FilterOperationKind.In)
{
expression = FilterExpressionBuilder.In(
property,
operation.Property.PropertyType,
ParseValue());
return(true);
}
if (operation.Kind == FilterOperationKind.NotIn)
{
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.In(
property,
operation.Property.PropertyType,
ParseValue()));
return(true);
}
}
expression = null;
return(false);
object ParseValue()
{
var parsedValue = type.ParseLiteral(value);
Type elementType = type.ElementType().ToRuntimeType();
if (operation.Property.PropertyType != elementType)
{
Type listType = typeof(List <>).MakeGenericType(
operation.Property.PropertyType);
parsedValue = context.TypeConverter.Convert(
typeof(object),
listType,
parsedValue);
}
return(parsedValue);
}
}
private object ParseLiteral(IInputType argumentType, IValueNode value)
{
IInputType type = (argumentType is NonNullType)
? (IInputType)argumentType.InnerType()
: argumentType;
return(type.ParseLiteral(value));
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
out Expression expression)
{
if (operation.Type == typeof(IComparable) &&
type.IsInstanceOfType(value))
{
MemberExpression property =
Expression.Property(instance, operation.Property);
switch (operation.Kind)
{
case FilterOperationKind.In:
expression = FilterExpressionBuilder.In(
property,
operation.Property.PropertyType,
ParseValue());
return(true);
case FilterOperationKind.NotIn:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.In(
property,
operation.Property.PropertyType,
ParseValue())
);
return(true);
}
}
expression = null;
return(false);
object ParseValue()
{
var parsedValue = type.ParseLiteral(value);
Type elementType = type.ElementType().ToClrType();
if (operation.Property.PropertyType != elementType)
{
Type listType = typeof(List <>).MakeGenericType(
operation.Property.PropertyType);
parsedValue = converter.Convert(
typeof(object),
listType,
parsedValue);
}
return(parsedValue);
}
}
private static object?ParseLiteral(IInputField argument, IValueNode value)
{
IInputType type = argument.Type is NonNullType
? (IInputType)argument.Type.InnerType()
: argument.Type;
object?runtimeValue = type.ParseLiteral(value);
return(argument.Formatter is not null
? argument.Formatter.OnAfterDeserialize(runtimeValue)
: runtimeValue);
}
private static object ParseScalarType(
IInputType sourceType,
Type targetType,
IValueNode literal)
{
object value = sourceType.ParseLiteral(literal.ValueOrNullValue());
if (!sourceType.ClrType.IsAssignableFrom(targetType))
{
value = Convert.ChangeType(value, targetType);
}
return(value);
}
private object CreateArray(ListValueNode listValueLiteral)
{
Type elementType = _inputType.NativeType;
var array = Array.CreateInstance(
elementType,
listValueLiteral.Items.Count);
for (var i = 0; i < listValueLiteral.Items.Count; i++)
{
object element = _inputType.ParseLiteral(listValueLiteral.Items[i]);
array.SetValue(element, i);
}
return(array);
}
private static object?DeserializeScalarResult(IInputType inputType, object?value)
{
switch (value)
{
case IReadOnlyList <object> list:
{
IInputType elementType = inputType;
Type runtimeType = typeof(List <object>);
if (inputType.IsListType())
{
elementType = (IInputType)inputType.ElementType();
runtimeType = inputType.RuntimeType;
}
var deserializedList =
(IList)Activator.CreateInstance(runtimeType) !;
foreach (object?item in list)
{
deserializedList.Add(DeserializeScalarResult(elementType, item));
}
return(deserializedList);
}
case ListValueNode listLiteral:
{
var elementType = (IInputType)inputType.ElementType();
var list = new List <object?>();
foreach (IValueNode item in listLiteral.Items)
{
list.Add(DeserializeScalarResult(elementType, item));
}
return(list);
}
case IValueNode literal:
return(inputType.ParseLiteral(literal));
default:
return(inputType.Deserialize(value));
}
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
bool inMemory,
out Expression expression)
{
if (operation.Kind == FilterOperationKind.ArrayAny &&
type.IsInstanceOfType(value) &&
type.ParseLiteral(value) is bool parsedValue)
{
MemberExpression property =
Expression.Property(instance, operation.Property);
Type propertType = operation.Type;
if (operation.TryGetSimpleFilterBaseType(out Type baseType))
{
propertType = baseType;
}
if (parsedValue)
{
expression = FilterExpressionBuilder.Any(
propertType,
property);
}
else
{
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Any(
propertType,
property));
}
if (inMemory)
{
expression = FilterExpressionBuilder.NotNullAndAlso(property, expression);
}
return(true);
}
expression = null;
return(false);
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out Expression?expression)
{
if (operation.Kind == FilterOperationKind.ArrayAny &&
type.IsInstanceOfType(value) &&
type.ParseLiteral(value) is bool parsedValue)
{
MemberExpression property =
Expression.Property(context.GetInstance(), operation.Property);
Type propertType = operation.Type;
if (operation.TryGetSimpleFilterBaseType(out Type? baseType))
{
propertType = baseType;
}
if (parsedValue)
{
expression = FilterExpressionBuilder.Any(
propertType,
property);
}
else
{
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Any(
propertType,
property));
}
if (context.InMemory)
{
expression =
FilterExpressionBuilder.NotNullAndAlso(property, expression);
}
return(true);
}
expression = null;
return(false);
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
bool inMemory,
out Expression expression)
{
if (operation.Type == typeof(string) && type.IsInstanceOfType(value))
{
Expression property = instance;
if (!operation.IsSimpleArrayType())
{
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,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out Expression?expression)
{
if (operation.Type == typeof(string) && type.IsInstanceOfType(value))
{
Expression property = context.GetInstance();
if (!operation.IsSimpleArrayType())
{
property = Expression.Property(
context.GetInstance(), operation.Property);
}
object?parsedValue = type.ParseLiteral(value);
if (operation.Kind == FilterOperationKind.In)
{
expression = FilterExpressionBuilder.In(
property,
operation.Property.PropertyType,
parsedValue);
return(true);
}
if (operation.Kind == 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,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out Expression?expression)
{
if (operation.Type == typeof(IComparable) &&
type.IsInstanceOfType(value))
{
Expression property = context.GetInstance();
if (!operation.IsSimpleArrayType())
{
property = Expression.Property(context.GetInstance(), operation.Property);
}
return(TryCreateExpression(
operation,
property,
ParseValue,
out expression));
}
expression = null;
return(false);
object ParseValue()
{
var parsedValue = type.ParseLiteral(value);
if (!operation.Property.PropertyType.IsInstanceOfType(parsedValue))
{
parsedValue = context.TypeConverter.Convert(
typeof(object),
operation.Property.PropertyType,
parsedValue);
}
return(parsedValue);
}
}
public object ParseLiteral(IValueNode literal)
{
if (literal == null)
{
throw new ArgumentNullException(nameof(literal));
}
if (_isInputType)
{
if (literal is NullValueNode)
{
throw new ArgumentException(
"A non null type cannot parse null value literals.");
}
return(_inputType.ParseLiteral(literal));
}
throw new InvalidOperationException(
"The specified type is not an input type.");
}
private static object?DeserializeEnumResult(IInputType inputType, object?value)
{
switch (value)
{
case IReadOnlyList <object> list:
{
var elementType = (IInputType)inputType.ElementType();
var deserializedList = (IList)Activator.CreateInstance(inputType.RuntimeType) !;
foreach (object?item in list)
{
deserializedList.Add(DeserializeEnumResult(elementType, item));
}
return(deserializedList);
}
case ListValueNode listLiteral:
{
var elementType = (IInputType)inputType.ElementType();
var list = new List <object?>();
foreach (IValueNode item in listLiteral.Items)
{
list.Add(DeserializeEnumResult(elementType, item));
}
return(list);
}
case StringValueNode stringLiteral:
return(inputType.Deserialize(stringLiteral.Value));
case IValueNode literal:
return(inputType.ParseLiteral(literal));
default:
return(inputType.Deserialize(value));
}
}
public object ParseLiteral(IValueNode literal)
{
if (literal == null)
{
throw new ArgumentNullException(nameof(literal));
}
if (_isInputType)
{
if (literal is NullValueNode)
{
throw new ArgumentException(
TypeResources.NonNullType_ValueIsNull,
nameof(literal));
}
return(_inputType.ParseLiteral(literal));
}
throw new InvalidOperationException(
TypeResources.NonNullType_NotAnInputType);
}
public static bool NotEquals(
FilterOperation operation,
IInputType type,
IValueNode value,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out Expression?result)
{
object parsedValue = type.ParseLiteral(value);
if (parsedValue == null)
{
context.ReportError(
ErrorHelper.CreateNonNullError(operation, type, value, context));
result = null;
return(false);
}
if (operation.Type == typeof(bool) &&
type.IsInstanceOfType(value) &&
parsedValue is bool)
{
Expression property = context.GetInstance();
if (!operation.IsSimpleArrayType())
{
property = Expression.Property(context.GetInstance(), operation.Property);
}
result = FilterExpressionBuilder.NotEquals(property, parsedValue);
return(true);
}
else
{
throw new InvalidOperationException();
}
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
out Expression expression)
{
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);
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
out Expression expression)
{
if (operation.Kind == FilterOperationKind.ArrayAny &&
type.IsInstanceOfType(value) &&
type.ParseLiteral(value) is bool parsedValue)
{
Expression property = instance;
if (!operation.IsSimpleArrayType())
{
property = Expression.Property(instance, operation.Property);
}
if (parsedValue)
{
expression = FilterExpressionBuilder.Any(
operation.Type,
property);
}
else
{
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Any(
operation.Type,
property));
}
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);
}
public static bool ArrayAny(
FilterOperation operation,
IInputType type,
IValueNode value,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out Expression?result)
{
object parsedValue = type.ParseLiteral(value);
if (parsedValue == null)
{
context.ReportError(
ErrorHelper.CreateNonNullError(operation, type, value, context));
result = null;
return(false);
}
if (operation.Kind == FilterOperationKind.ArrayAny &&
type.IsInstanceOfType(value) &&
parsedValue is bool parsedBool)
{
MemberExpression property =
Expression.Property(context.GetInstance(), operation.Property);
Type propertType = operation.Type;
if (operation.TryGetSimpleFilterBaseType(out Type? baseType))
{
propertType = baseType;
}
Expression expression;
if (parsedBool)
{
expression = FilterExpressionBuilder.Any(
propertType,
property);
}
else
{
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Any(
propertType,
property));
}
if (context.InMemory)
{
expression =
FilterExpressionBuilder.NotNullAndAlso(property, expression);
}
result = expression;
return(true);
}
else
{
throw new InvalidOperationException();
}
}
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);
}
