private bool TryCreateImplicitFilter(
PropertyInfo property,
out FilterFieldDefintion definition)
{
if (property.PropertyType == typeof(string))
{
var field = new StringFilterFieldDescriptor(Context, property);
definition = field.CreateDefinition();
return(true);
}
if (property.PropertyType == typeof(bool) ||
property.PropertyType == typeof(bool?))
{
var field = new BooleanFilterFieldDescriptor(
Context, property);
definition = field.CreateDefinition();
return(true);
}
if (typeof(IComparable).IsAssignableFrom(property.PropertyType))
{
var field = new ComparableFilterFieldDescriptor(
Context, property);
definition = field.CreateDefinition();
return(true);
}
definition = null;
return(false);
}
private string GetNameForDefintion(FilterFieldDefintion definition)
{
var name = definition.Name.Value;
if (name.Length > 1)
{
return(name.Substring(0, 1).ToUpperInvariant() +
name.Substring(1));
}
return(name.ToUpperInvariant());
}
public abstract NameString CreateFieldName(FilterFieldDefintion definition, FilterOperationKind kind);
public NameString CreateFieldName(FilterFieldDefintion definition, FilterOperationKind kind)
{
switch (kind)
{
case FilterOperationKind.Equals:
return(GetNameForDefintion(definition));
case FilterOperationKind.NotEquals:
return(GetNameForDefintion(definition) + "_Not");
case FilterOperationKind.Contains:
return(GetNameForDefintion(definition) + "_Contains");
case FilterOperationKind.NotContains:
return(GetNameForDefintion(definition) + "_Not_Contains");
case FilterOperationKind.In:
return(GetNameForDefintion(definition) + "_In");
case FilterOperationKind.NotIn:
return(GetNameForDefintion(definition) + "_Not_In");
case FilterOperationKind.StartsWith:
return(GetNameForDefintion(definition) + "_StartsWith");
case FilterOperationKind.NotStartsWith:
return(GetNameForDefintion(definition) + "_Not_StartsWith");
case FilterOperationKind.EndsWith:
return(GetNameForDefintion(definition) + "_EndsWith");
case FilterOperationKind.NotEndsWith:
return(GetNameForDefintion(definition) + "_Not_EndsWith");
case FilterOperationKind.GreaterThan:
return(GetNameForDefintion(definition) + "_Gt");
case FilterOperationKind.NotGreaterThan:
return(GetNameForDefintion(definition) + "_Not_Gt");
case FilterOperationKind.GreaterThanOrEquals:
return(GetNameForDefintion(definition) + "_Gte");
case FilterOperationKind.NotGreaterThanOrEquals:
return(GetNameForDefintion(definition) + "_Not_Gte");
case FilterOperationKind.LowerThan:
return(GetNameForDefintion(definition) + "_Lt");
case FilterOperationKind.NotLowerThan:
return(GetNameForDefintion(definition) + "_Not_Lt");
case FilterOperationKind.LowerThanOrEquals:
return(GetNameForDefintion(definition) + "_Lte");
case FilterOperationKind.NotLowerThanOrEquals:
return(GetNameForDefintion(definition) + "_Not_Lte");
case FilterOperationKind.Object:
return(GetNameForDefintion(definition));
case FilterOperationKind.ArraySome:
return(definition.Name + "_Some");
case FilterOperationKind.ArrayNone:
return(definition.Name + "_None");
case FilterOperationKind.ArrayAll:
return(definition.Name + "_All");
case FilterOperationKind.ArrayAny:
return(definition.Name + "_Any");
default:
throw new NotSupportedException();
}
}
private bool TryCreateImplicitFilter(
PropertyInfo property,
out FilterFieldDefintion definition)
{
Type type = property.PropertyType;
if (type.IsGenericType && Nullable.GetUnderlyingType(type) is Type nullableType)
{
type = nullableType;
}
if (type == typeof(string))
{
var field = new StringFilterFieldDescriptor(Context, property);
definition = field.CreateDefinition();
return(true);
}
if (type == typeof(bool))
{
var field = new BooleanFilterFieldDescriptor(
Context, property);
definition = field.CreateDefinition();
return(true);
}
if (IsComparable(property.PropertyType))
{
var field = new ComparableFilterFieldDescriptor(
Context, property);
definition = field.CreateDefinition();
return(true);
}
if (DotNetTypeInfoFactory.IsListType(type))
{
if (!TypeInspector.Default.TryCreate(type, out Utilities.TypeInfo typeInfo))
{
throw new ArgumentException(
FilterResources.FilterArrayFieldDescriptor_InvalidType,
nameof(property));
}
Type elementType = typeInfo.ClrType;
ArrayFilterFieldDescriptor field;
if (elementType == typeof(string) ||
elementType == typeof(bool) ||
typeof(IComparable).IsAssignableFrom(elementType))
{
field = new ArrayFilterFieldDescriptor(
Context,
property,
typeof(ISingleFilter <>).MakeGenericType(elementType));
}
else
{
field = new ArrayFilterFieldDescriptor(Context, property, elementType);
}
definition = field.CreateDefinition();
return(true);
}
if (type.IsClass)
{
var field = new ObjectFilterFieldDescriptor(
Context, property, property.PropertyType);
definition = field.CreateDefinition();
return(true);
}
definition = null;
return(false);
}
public override NameString CreateFieldName(
FilterFieldDefintion definition,
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);
case FilterOperationKind.ArraySome:
return(definition.Name + "_some");
case FilterOperationKind.ArrayNone:
return(definition.Name + "_none");
case FilterOperationKind.ArrayAll:
return(definition.Name + "_all");
case FilterOperationKind.ArrayAny:
return(definition.Name + "_any");
default:
throw new NotSupportedException();
}
}
private static string GetNameForDefinition(FilterFieldDefintion definition) =>
definition.Name.Value is
{
private bool TryCreateImplicitFilter(
PropertyInfo property,
out FilterFieldDefintion definition)
{
var type = property.PropertyType;
if (type.IsGenericType && Nullable.GetUnderlyingType(type) is Type nullableType)
{
type = nullableType;
}
if (type == typeof(string))
{
var field = new StringFilterFieldDescriptor(Context, property);
definition = field.CreateDefinition();
return(true);
}
if (type == typeof(bool))
{
var field = new BooleanFilterFieldDescriptor(
Context, property);
definition = field.CreateDefinition();
return(true);
}
if (IsComparable(property.PropertyType))
{
var field = new ComparableFilterFieldDescriptor(
Context, property);
definition = field.CreateDefinition();
return(true);
}
if (typeof(IEnumerable).IsAssignableFrom(type))
{
ArrayFilterFieldDescriptor field;
var genericTypeArgument = type.GetGenericArguments()[0];
if (genericTypeArgument.IsGenericType &&
Nullable.GetUnderlyingType(genericTypeArgument) is Type nullableEnumerableType)
{
genericTypeArgument = nullableEnumerableType;
}
if (genericTypeArgument == typeof(string) ||
genericTypeArgument == typeof(bool) ||
genericTypeArgument == typeof(bool?) ||
typeof(IComparable).IsAssignableFrom(genericTypeArgument))
{
field = new ArrayFilterFieldDescriptor(
Context,
property,
typeof(ISingleFilter <>).MakeGenericType(genericTypeArgument)
);
}
else
{
field = new ArrayFilterFieldDescriptor(Context, property, genericTypeArgument);
}
definition = field.CreateDefinition();
return(true);
}
if (type.IsClass)
{
var field = new ObjectFilterFieldDescriptor(
Context, property, property.PropertyType);
definition = field.CreateDefinition();
return(true);
}
definition = null;
return(false);
}
