public IFilterConventionDefaultOperationDescriptor Operation(FilterOperationKind kind)
{
return(_defaultOperations.GetOrAdd(
kind,
(FilterOperationKind kind) =>
FilterConventionDefaultOperationDescriptor.New(this, kind)));
}
private ComparableFilterOperationDescriptor CreateComparableOperation(
FilterOperationKind operationKind)
{
var descirptor = new ComparableFilterFieldDescriptor(
_descriptorContext, _propertyInfo);
ExtendedTypeReference typeReference = _descriptorContext.TypeInspector.GetTypeRef(
typeof(Foo),
TypeContext.Input);
var definition = new FilterOperationDefintion()
{
Name = "Foo",
Type = typeReference,
Operation = new FilterOperation(typeof(string), operationKind, _propertyInfo),
Property = _propertyInfo
};
var operation = new FilterOperation(
typeof(bool),
operationKind,
definition.Property);
return(ComparableFilterOperationDescriptor.New(
_descriptorContext,
descirptor,
"Foo",
typeReference,
operation));
}
public void AssertOperation <T>(
ObjectValueNode value,
FilterKind kind,
FilterOperationKind operationKind,
FilterOperationHandler handler)
{
FilterInputType <T> fooType = CreateType(new FilterInputType <T>());
var helper = ExpressionVisitorMock.Create(handler);
FilterExpressionVisitorDefinition convention =
new MockFilterConvention(
x => x.UseDefault()
.UseExpressionVisitor()
.UseDefault()
.Kind(kind)
.Operation(operationKind)
.Handler(helper.FilterOperationHandler))
.GetExpressionDefinition();
// act
var filter = new QueryableFilterVisitorContext(
fooType,
typeof(T),
convention,
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filter);
Func <T, bool> func = filter.CreateOrAssert <T>().Compile();
// assert
Assert.Equal(1, helper.CallCount(handler));
}
protected FilterConventionDefaultOperationDescriptor(
FilterConventionDescriptor descriptor,
FilterOperationKind kind) : base(kind)
{
_descriptor = descriptor ?? throw new ArgumentNullException(nameof(descriptor));
Definition.OperationKind = kind;
}
protected FilterExpressionOperationDescriptor(
FilterExpressionTypeDescriptor descriptor,
FilterOperationKind kind)
{
_descriptor = descriptor ?? throw new ArgumentNullException(nameof(descriptor));
Definition.OperationKind = kind;
}
protected override FilterOperationDefintion CreateOperationDefinition(
FilterOperationKind operationKind)
{
return(FilterOperationKind.ArrayAny == operationKind
? CreateBooleanOperation(operationKind).CreateDefinition()
: CreateOperation(operationKind).CreateDefinition());
}
private ComparableFilterOperationDescriptor CreateComparableOperation(
FilterOperationKind operationKind)
{
var descirptor = new ComparableFilterFieldDescriptor(
_descriptorContext, _propertyInfo, _filterConvention);
var typeReference = new ClrTypeReference(typeof(Foo), TypeContext.Input);
var definition = new FilterOperationDefintion()
{
Name = "Foo",
Type = typeReference,
Operation = new FilterOperation(typeof(string),
FilterKind.Boolean, operationKind, _propertyInfo),
Property = _propertyInfo
};
var operation = new FilterOperation(
typeof(bool),
FilterKind.Boolean,
operationKind,
definition.Property);
return(ComparableFilterOperationDescriptor.New(
_descriptorContext,
descirptor,
"Foo",
typeReference,
operation,
_filterConvention));
}
protected NameString CreateFieldName(FilterOperationKind kind)
{
if (typeof(ISingleFilter).IsAssignableFrom(Definition.Property.DeclaringType))
{
Definition.Name = _namingConvention.ArrayFilterPropertyName;
}
return(_namingConvention.CreateFieldName(Definition, kind));
}
protected FilterOperation GetFilterOperation(
FilterOperationKind operationKind)
{
return(new FilterOperation(
_type,
operationKind,
Definition.Property));
}
public FilterOperation(
Type type,
FilterOperationKind kind,
PropertyInfo property)
{
Type = type ?? throw new ArgumentNullException(nameof(type));
Kind = kind;
Property = property ?? throw new ArgumentNullException(nameof(property));
}
public IFilterConventionTypeDescriptor Ignore(
FilterOperationKind kind,
bool ignore = true)
{
_operations.GetOrAdd(kind, kind => FilterConventionOperationDescriptor.New(this, kind))
.Ignore(true);
return(this);
}
protected virtual ITypeReference RewriteType(
FilterOperationKind operationKind)
{
if (ListOperations.Contains(operationKind))
{
return(RewriteTypeListType());
}
return(RewriteTypeToNullableType());
}
private ArrayFilterOperationDescriptor CreateOperation(
FilterOperationKind operationKind)
{
var operation = GetFilterOperation(operationKind);
var typeReference = GetTypeReference();
return(ArrayFilterOperationDescriptor.New(
Context,
this,
CreateFieldName(operationKind),
typeReference,
operation));
}
public bool TryGetOperation(
FilterKind kind,
FilterOperationKind operationKind,
[NotNullWhen(true)] out FilterOperationHandler?handler)
{
if (Defintion.OperationHandler.TryGetValue(
(kind, operationKind), out FilterOperationHandler? operationHandler))
{
handler = operationHandler;
return(true);
}
handler = null;
return(false);
}
private ArrayFilterOperationDescriptor <TArray> CreateOperation(
FilterOperationKind operationKind)
{
FilterOperation? operation = GetFilterOperation(operationKind);
ClrTypeReference?typeReference = GetTypeReference();
return(ArrayFilterOperationDescriptor <TArray> .New(
Context,
this,
CreateFieldName(operationKind),
typeReference,
operation,
FilterConvention));
}
private ObjectFilterOperationDescriptor <TObject> CreateOperation(
FilterOperationKind operationKind)
{
var operation = new FilterOperation(
typeof(TObject),
operationKind,
Definition.Property);
return(ObjectFilterOperationDescriptor <TObject> .New(
Context,
this,
CreateFieldName(operationKind),
RewriteType(operationKind),
operation));
}
protected virtual void AddImplicitOperation(
IDictionary <NameString, FilterOperationDefintion> fields,
ISet <FilterOperationKind> handledFilterKinds,
FilterOperationKind operationKind)
{
if (handledFilterKinds.Add(operationKind))
{
FilterOperationDefintion definition =
CreateOperationDefinition(operationKind);
if (!fields.ContainsKey(definition.Name))
{
fields.Add(definition.Name, definition);
}
}
}
private ComparableFilterOperationDescriptor CreateOperation(
FilterOperationKind operationKind)
{
var operation = new FilterOperation(
typeof(IComparable),
operationKind,
Definition.Property);
return(ComparableFilterOperationDescriptor.New(
Context,
this,
CreateFieldName(operationKind),
RewriteType(operationKind),
operation));
}
private ArrayBooleanFilterOperationDescriptor CreateBooleanOperation(
FilterOperationKind operationKind)
{
var operation = GetFilterOperation(operationKind);
var typeReference = RewriteTypeToNullableType(
Context.TypeInspector.GetTypeRef(typeof(bool)),
Context.TypeInspector);
return(ArrayBooleanFilterOperationDescriptor.New(
Context,
this,
CreateFieldName(operationKind),
typeReference,
operation));
}
private BooleanFilterOperationDescriptor CreateOperation(
FilterOperationKind operationKind)
{
var operation = new FilterOperation(
typeof(bool),
Definition.Kind,
operationKind,
Definition.Property);
return(BooleanFilterOperationDescriptor.New(
Context,
this,
CreateFieldName(operationKind),
RewriteType(operationKind),
operation,
FilterConvention));
}
public FilterOperation(
Type type,
FilterKind filterKind,
FilterOperationKind kind,
PropertyInfo property)
{
Type = type ?? throw new ArgumentNullException(nameof(type));
FilterKind = filterKind;
Kind = kind;
Property = property ?? throw new ArgumentNullException(nameof(property));
if (Property.DeclaringType != null)
{
IsNullable = new NullableHelper(
Property.DeclaringType).GetPropertyInfo(Property).IsNullable;
}
}
private ArrayBooleanFilterOperationDescriptor CreateBooleanOperation(
FilterOperationKind operationKind)
{
var operation = GetFilterOperation(operationKind);
var typeReference = RewriteTypeToNullableType(
new ClrTypeReference(typeof(bool),
Definition.Type.Context,
true,
true));
return(ArrayBooleanFilterOperationDescriptor.New(
Context,
this,
CreateFieldName(operationKind),
typeReference,
operation));
}
private ObjectFilterOperationDescriptor CreateOperation(
FilterOperationKind operationKind)
{
var operation = new FilterOperation(
_type,
operationKind,
Definition.Property);
return(ObjectFilterOperationDescriptor.New(
Context,
this,
CreateFieldName(operationKind),
new ClrTypeReference(
typeof(FilterInputType <>).MakeGenericType(_type),
Definition.Type.Context,
true,
true),
operation));
}
private ObjectFilterOperationDescriptor CreateOperation(
FilterOperationKind operationKind)
{
var operation = new FilterOperation(
_type,
operationKind,
Definition.Property);
ExtendedTypeReference typeRef = Context.TypeInspector.GetTypeRef(
typeof(FilterInputType <>).MakeGenericType(_type),
Definition.Type.Context);
return(ObjectFilterOperationDescriptor.New(
Context,
this,
CreateFieldName(operationKind),
typeRef,
operation));
}
public IFilterExpressionOperationDescriptor Operation(FilterOperationKind kind) => _operations.GetOrAdd(kind, _ => FilterExpressionOperationDescriptor.New(this, kind));
public abstract NameString CreateFieldName(FilterFieldDefintion definition, FilterOperationKind kind);
private ComparableFilterOperationDescriptor GetOrCreateOperation(
FilterOperationKind operationKind)
{
return(Filters.GetOrAddOperation(operationKind,
() => CreateOperation(operationKind)));
}
protected override FilterOperationDefintion CreateOperationDefinition(
FilterOperationKind operationKind) =>
CreateOperation(operationKind).CreateDefinition();
protected abstract FilterOperationDefintion CreateOperationDefinition(
FilterOperationKind operationKind);
protected NameString CreateFieldName(FilterOperationKind kind)
{
switch (kind)
{
case FilterOperationKind.Equals:
return(Definition.Name);
case FilterOperationKind.NotEquals:
return(Definition.Name + "_not");
case FilterOperationKind.Contains:
return(Definition.Name + "_contains");
case FilterOperationKind.NotContains:
return(Definition.Name + "_not_contains");
case FilterOperationKind.In:
return(Definition.Name + "_in");
case FilterOperationKind.NotIn:
return(Definition.Name + "_not_in");
case FilterOperationKind.StartsWith:
return(Definition.Name + "_starts_with");
case FilterOperationKind.NotStartsWith:
return(Definition.Name + "_not_starts_with");
case FilterOperationKind.EndsWith:
return(Definition.Name + "_ends_with");
case FilterOperationKind.NotEndsWith:
return(Definition.Name + "_not_ends_with");
case FilterOperationKind.GreaterThan:
return(Definition.Name + "_gt");
case FilterOperationKind.NotGreaterThan:
return(Definition.Name + "_not_gt");
case FilterOperationKind.GreaterThanOrEquals:
return(Definition.Name + "_gte");
case FilterOperationKind.NotGreaterThanOrEquals:
return(Definition.Name + "_not_gte");
case FilterOperationKind.LowerThan:
return(Definition.Name + "_lt");
case FilterOperationKind.NotLowerThan:
return(Definition.Name + "_not_lt");
case FilterOperationKind.LowerThanOrEquals:
return(Definition.Name + "_lte");
case FilterOperationKind.NotLowerThanOrEquals:
return(Definition.Name + "_not_lte");
case FilterOperationKind.Object:
return(Definition.Name);
default:
throw new NotSupportedException();
}
}
