public override bool TryHandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
ObjectFieldNode node,
[NotNullWhen(true)] out Expression?result)
{
IValueNode value = node.Value;
IExtendedType runtimeType = context.RuntimeTypes.Peek();
Type type = field.Type.IsListType()
? runtimeType.Source.MakeArrayType()
: runtimeType.Source;
object?parsedValue = InputParser.ParseLiteral(value, field, type);
if ((!runtimeType.IsNullable || !CanBeNull) && parsedValue is null)
{
IError error = ErrorHelper.CreateNonNullError(field, value, context);
context.ReportError(error);
result = null !;
return(false);
}
result = HandleOperation(context, field, value, parsedValue);
return(true);
}
/// <inheritdoc />
public override MongoDbFilterDefinition HandleOperation(
MongoDbFilterVisitorContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
if (parsedValue is {})
/// <inheritdoc/>
public override bool TryHandleOperation(
MongoDbFilterVisitorContext context,
IFilterOperationField field,
ObjectFieldNode node,
[NotNullWhen(true)] out MongoDbFilterDefinition result)
{
IValueNode value = node.Value;
object? parsedValue = field.Type.ParseLiteral(value);
if ((!context.RuntimeTypes.Peek().IsNullable || !CanBeNull) &&
parsedValue is null)
{
context.ReportError(ErrorHelper.CreateNonNullError(field, value, context));
result = null !;
return(false);
}
if (field.Type.IsInstanceOfType(value))
{
result = HandleOperation(
context,
field,
value,
parsedValue);
return(true);
}
throw new InvalidOperationException();
}
public override Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
if (context.RuntimeTypes.Count > 0 &&
context.RuntimeTypes.Peek().TypeArguments is { Count : > 0 } args&&
parsedValue is bool parsedBool)
{
Expression?property = context.GetInstance();
Expression expression;
if (parsedBool)
{
expression = FilterExpressionBuilder.Any(args[0].Source, property);
}
else
{
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Any(args[0].Source, property));
}
if (context.InMemory)
{
expression = FilterExpressionBuilder.NotNullAndAlso(property, expression);
}
return(expression);
}
throw ThrowHelper.Filtering_CouldNotParseValue(this, value, field.Type, field);
}
public override Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object parsedValue)
{
// We get the instance of the context. This is the expression path to the propert
// e.g. ~> y.Street
Expression property = context.GetInstance();
// the parsed value is what was specified in the query
// e.g. ~> eq: "221B Baker Street"
if (parsedValue is string str)
{
// Creates and returnes the operation
// e.g. ~> y.Street.ToLower().Contains("221b baker street")
// return Expression.Lambda<Func<string, bool>>(
// Expression.Call(Expression.Call(property, _toLower), _contains, Expression.Constant(str.ToLower()))
// );
return(Expression.Equal(
property, Expression.Constant(str.ToLower())
));
}
// Something went wrong 😱
throw new InvalidOperationException();
}
/// <inheritdoc />
public override MongoDbFilterDefinition HandleOperation(
MongoDbFilterVisitorContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
if (context.RuntimeTypes.Count > 0 &&
context.RuntimeTypes.Peek().TypeArguments is { Count : > 0 } &&
public override Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object parsedValue)
{
throw new System.NotImplementedException();
}
public override Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
Expression property = context.GetInstance();
return(FilterExpressionBuilder.Contains(property, parsedValue));
}
/// <inheritdoc />
public override MongoDbFilterDefinition HandleOperation(
MongoDbFilterVisitorContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
var doc = new MongoDbFilterOperation("$eq", parsedValue);
return(new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc));
}
public override Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
Expression property = context.GetInstance();
parsedValue = ParseValue(value, parsedValue, field.Type, context);
return(FilterExpressionBuilder.NotEquals(property, parsedValue));
}
public override Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object parsedValue)
{
Expression property = context.GetInstance();
return(FilterExpressionBuilder.In(
property,
context.RuntimeTypes.Peek().Source,
parsedValue));
}
public override Expression HandleOperation(QueryableFilterContext context, IFilterOperationField field, IValueNode value, object?parsedValue)
{
Expression property = context.GetInstance();
if (parsedValue is string fieldValue)
{
//Compiles to:
//false == property.ToLower().Contains(input.ToLower());
return(Expression.Equal(Expression.Constant(false), Expression.Call(Expression.Call(property, Expressions.ToLower), Expressions.Contains, Expression.Constant(fieldValue.ToLower()))));
}
throw new InvalidOperationException();
}
public override Condition HandleOperation(
Neo4JFilterVisitorContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
if (parsedValue is not string str)
{
throw new InvalidOperationException();
}
return(context
.GetNode()
.Property(context.GetNeo4JFilterScope().GetPath())
.EndsWith(Cypher.LiteralOf(str)));
}
public override Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
Expression property = context.GetInstance();
parsedValue = ParseValue(value, parsedValue, field.Type, context);
if (parsedValue is null)
{
throw new InvalidOperationException();
}
return(FilterExpressionBuilder.GreaterThan(property, parsedValue));
}
public override Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
Expression property = context.GetInstance();
parsedValue = ParseValue(value, parsedValue, field.Type, context);
if (parsedValue is null)
{
throw ThrowHelper.Filtering_CouldNotParseValue(this, value, field.Type, field);
}
return(FilterExpressionBuilder.LowerThanOrEqual(property, parsedValue));
}
/// <inheritdoc />
public override Condition HandleOperation(
Neo4JFilterVisitorContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
if (parsedValue is null)
{
throw new InvalidOperationException();
}
return(context
.GetNode()
.Property(context.GetNeo4JFilterScope().GetPath())
.GreaterThanOEqualTo(Cypher.LiteralOf(parsedValue))
.Not());
}
public override MongoDbFilterDefinition HandleOperation(
MongoDbFilterVisitorContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
if (parsedValue is string str)
{
var doc = new MongoDbFilterOperation(
"$regex",
new BsonRegularExpression($"/^{Regex.Escape(str)}/"));
return(new MongoDbFilterOperation(context.GetMongoFilterScope().GetPath(), doc));
}
throw new InvalidOperationException();
}
public override Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object parsedValue)
{
// We get the instance of the context. This is the expression path to the propert
// e.g. ~> y.Street
Expression property = context.GetInstance();
// the parsed value is what was specified in the query
// e.g. ~> eq: "221B Baker Street"
if (parsedValue is string str)
{
// Creates and returns the operation
// e.g. ~> y.Street.ToLower() == "221b baker street"
//MethodInfo contains = typeof(string).GetMethod("Contains");
//var bodyLike = Expression.Call(expressionParameter, contains, Expression.Constant(fieldValue, prop.PropertyType));
//return Expression.Lambda<Func<T, bool>>(bodyLike, parameter);
//var lowerString = Expression.Call(property, _toLower).ToString();
//var lowerSearchTerm = str.ToLower();
// return lowerString.Contains(lowerSearchTerm, StringComparison.InvariantCultureIgnoreCase);
return(Expression.Call(
Expression.Call(property, _toLower),
"Contains",
Type.EmptyTypes,
Expression.Constant(str.ToLower())
));
//return Expression.Equal(
// Expression.Call(property, _toLower),
// Expression.Constant(str.ToLower()));
}
// Something went wrong 😱
throw new InvalidOperationException();
}
protected override bool TryHandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
ObjectFieldNode node,
[NotNullWhen(true)] out Expression?result)
{
if (TryGetParameter(field, node.Value, GeometryFieldName, out Geometry g))
{
if (TryGetParameter(field, node.Value, BufferFieldName, out double buffer))
{
result = ExpressionBuilder.Overlaps(
context.GetInstance(),
ExpressionBuilder.Buffer(g, buffer));
return(true);
}
result = ExpressionBuilder.Overlaps(context.GetInstance(), g);
return(true);
}
result = null;
return(false);
}
/// <summary>
/// Maps a operation field to a provider specific result.
/// This method is called when the <see cref="FilterVisitor{TContext,T}"/> enters a
/// field
/// </summary>
/// <param name="context">The <see cref="IFilterVisitorContext{T}"/> of the visitor</param>
/// <param name="field">The field that is currently being visited</param>
/// <param name="value">The value node of this field</param>
/// <param name="parsedValue">The value of the value node</param>
/// <returns>If <c>true</c> is returned the action is used for further processing</returns>
public abstract MongoDbFilterDefinition HandleOperation(
MongoDbFilterVisitorContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue);
/// <summary>
/// Maps a operation field to a provider specific result.
/// This method is called when the <see cref="FilterVisitor{TContext,T}"/> enters a
/// field
/// </summary>
/// <param name="context">The <see cref="IFilterVisitorContext{T}"/> of the visitor</param>
/// <param name="field">The field that is currently being visited</param>
/// <param name="value">The value node of this field</param>
/// <param name="parsedValue">The value of the value node</param>
/// <returns>If <c>true</c> is returned the action is used for further processing</returns>
public abstract Condition HandleOperation(
Neo4JFilterVisitorContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue);
protected abstract bool TryHandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
ObjectFieldNode node,
[NotNullWhen(true)] out Expression?result);
public abstract Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue);
