private bool TryCreateImplicitSorting(
PropertyInfo property,
[NotNullWhen(true)] out SortOperationDefintion?definition)
{
Type type = property.PropertyType;
if (type.IsGenericType &&
System.Nullable.GetUnderlyingType(type) is { } nullableType)
{
type = nullableType;
}
if (typeof(IComparable).IsAssignableFrom(type))
{
definition = SortOperationDescriptor
.CreateOperation(property, Context)
.CreateDefinition();
return(true);
}
if (Context.TypeInspector.TryCreateTypeInfo(type, out ITypeInfo? typeInfo) &&
typeInfo.GetExtendedType()?.IsList is {} isList)
{
if (type.IsClass && !isList)
{
definition = SortObjectOperationDescriptor
.CreateOperation(property, Context)
.CreateDefinition();
return(true);
}
}
definition = null;
return(false);
}
private bool TryCreateImplicitSorting(
PropertyInfo property,
out SortOperationDefintion definition)
{
Type type = property.PropertyType;
if (type.IsGenericType &&
System.Nullable.GetUnderlyingType(type) is Type nullableType)
{
type = nullableType;
}
if (typeof(IComparable).IsAssignableFrom(type))
{
definition = SortOperationDescriptor
.CreateOperation(property, Context)
.CreateDefinition();
return(true);
}
if (type.IsClass && !DotNetTypeInfoFactory.IsListType(type))
{
definition = SortObjectOperationDescriptor
.CreateOperation(property, Context)
.CreateDefinition();
return(true);
}
definition = null;
return(false);
}
protected override void OnCreateDefinition(
SortFieldDefinition definition)
{
SortOperationDescriptor field =
CreateOperation(
new[] { SortOperationKind.Asc, SortOperationKind.Desc });
SortOperations.Add(field);
var fields = new Dictionary<NameString, SortOperationDefintion>();
AddImplicitSorters(fields);
Definition.SortableFields.AddRange(fields.Values);
}
public void GetOrAddDescriptor_Argument_PropertyInfo()
{
//arrange
Func <SortOperationDescriptor> factory =
() => SortOperationDescriptor.CreateOperation(_propertyInfo, _descriptorContext);
IList <SortOperationDescriptorBase> list = new List <SortOperationDescriptorBase>();
//act
//assert
ArgumentNullException assertNullException =
Assert.Throws <ArgumentNullException>(() => list.GetOrAddDescriptor(null, factory));
Assert.Equal("propertyInfo", assertNullException.ParamName);
}
public ISortOperationDescriptor Sortable(
Expression <Func <T, IComparable> > property)
{
if (property.ExtractMember() is PropertyInfo p)
{
return(Fields.GetOrAddDescriptor(p,
() => SortOperationDescriptor.CreateOperation(p, Context)));
}
// TODO : resources
throw new ArgumentException(
"Only properties are allowed for input types.",
nameof(property));
}
public ISortOperationDescriptor Sortable(
Expression <Func <T, IComparable> > property)
{
if (property.ExtractMember() is PropertyInfo p)
{
return(Fields.GetOrAddDescriptor(p,
() => SortOperationDescriptor.CreateOperation(p, Context)));
}
// TODO : resources
throw new ArgumentException(
SortingResources.SortInputTypeDescriptor_Ignore_OnlyPopertiesAreAllowed,
nameof(property));
}
public void GetOrAddDescriptor_Argument_Fields()
{
//arrange
Func <SortOperationDescriptor> factory =
() => SortOperationDescriptor.CreateOperation(_propertyInfo, _descriptorContext);
//act
//assert
ArgumentNullException assertNullException =
Assert.Throws <ArgumentNullException>(
() => SortingFieldCollectionExtensions.GetOrAddDescriptor(
null, _propertyInfo, factory));
Assert.Equal("fields", assertNullException.ParamName);
}
private SortOperationDescriptor CreateOperation(
IEnumerable<SortOperationKind> allowedSorts)
{
var operation = new SortOperation(
allowedSorts,
Definition.Property);
var typeReference = new ClrTypeReference(
typeof(SortOperationKindType),
TypeContext.Input);
return SortOperationDescriptor.New(
Context,
Definition.Name,
typeReference,
operation);
}
public void GetOrAddDescriptor_Should_AddDescriptorIfNotExists()
{
//arrange
IList <SortOperationDescriptorBase> list = new List <SortOperationDescriptorBase>();
var descriptor =
SortOperationDescriptor.CreateOperation(_propertyInfo, _descriptorContext);
Func <SortOperationDescriptor> valueFactory = () => descriptor;
//act
SortOperationDescriptor result =
list.GetOrAddDescriptor(_propertyInfo, valueFactory);
//assert
Assert.Single(list);
Assert.Same(descriptor, list[0]);
Assert.Same(descriptor, result);
}
public static SortOperationDescriptor CreateOperation(
PropertyInfo property,
IDescriptorContext context)
{
var operation = new SortOperation(property);
var typeReference = new ClrTypeReference(
typeof(SortOperationKindType),
TypeContext.Input);
NameString name = context.Naming.GetMemberName(
property, MemberKind.InputObjectField);
return(SortOperationDescriptor.New(
context,
name,
typeReference,
operation
));
}
public void GetOrAddDescriptor_Should_ReturnDescriptorIfAlreadyExists()
{
//arrange
IList <SortOperationDescriptorBase> list = new List <SortOperationDescriptorBase>();
var descriptorShouldNotBeRemoved =
SortOperationDescriptor.CreateOperation(_propertyInfo, _descriptorContext);
var newDescriptorShouldNotHaveAnyEffect =
SortOperationDescriptor.CreateOperation(_propertyInfo, _descriptorContext);
Func <SortOperationDescriptor> valueFactory = () => newDescriptorShouldNotHaveAnyEffect;
list.Add(descriptorShouldNotBeRemoved);
//act
SortOperationDescriptor result =
list.GetOrAddDescriptor(_propertyInfo, valueFactory);
//assert
Assert.Single(list);
Assert.Same(descriptorShouldNotBeRemoved, list[0]);
Assert.Same(descriptorShouldNotBeRemoved, result);
Assert.NotSame(newDescriptorShouldNotHaveAnyEffect, result);
}
public void GetOrAddDescriptor_Should_ReplaceDescriptorIfDifferentType()
{
//arrange
IList <SortOperationDescriptorBase> list = new List <SortOperationDescriptorBase>();
var descriptorToRemove =
IgnoredSortingFieldDescriptor.CreateOperation(_propertyInfo, _descriptorContext);
var descriptorToAdd =
SortOperationDescriptor.CreateOperation(_propertyInfo, _descriptorContext);
Func <SortOperationDescriptor> valueFactory = () => descriptorToAdd;
list.Add(descriptorToRemove);
//act
SortOperationDescriptor result =
list.GetOrAddDescriptor(_propertyInfo, valueFactory);
//assert
Assert.Single(list);
Assert.Same(descriptorToAdd, list[0]);
Assert.Same(descriptorToAdd, result);
Assert.NotSame(descriptorToRemove, result);
}
private bool TryCreateImplicitSorting(
PropertyInfo property,
out SortOperationDefintion definition)
{
if (typeof(IComparable).IsAssignableFrom(property.PropertyType))
{
definition = SortOperationDescriptor
.CreateOperation(property, Context)
.CreateDefinition();
return(true);
}
if (
property.PropertyType.IsClass &&
!typeof(IEnumerable <>).IsAssignableFrom(property.PropertyType))
{
definition = SortObjectOperationDescriptor
.CreateOperation(property, Context)
.CreateDefinition();
return(true);
}
definition = null;
return(false);
}
