public void Select_ArrayOfString_AddsToQuery()
{
// Arrange
var query = new Query <object>("something");
string[] selects =
{
"id",
"name"
};
// Act
foreach (string field in selects)
{
query.AddField(field);
}
// Assert
List <string> shouldEqual = new List <string>()
{
"id",
"name"
};
Assert.Equal(shouldEqual, query.SelectList);
}
public MergedSchema(IServiceProvider provider)
{
///////////////////////////////
//IN CASE OF FIRE BREAK GLASS//
///////////////////////////////
var assem = Assembly.GetExecutingAssembly().GetExportedTypes();
var queryFields = new List <FieldType>();
var mutationFields = new List <FieldType>();
var queryTypes = assem.Where(t => (t.Namespace == ("E_gzamin.GraphQL.Queries")));
foreach (var queryType in queryTypes)
{
var query = (IObjectGraphType)provider.GetRequiredService(queryType);
queryFields.Concat(query.Fields);
Query = query;
}
var mutationTypes = assem.Where(t => (t.Namespace == ("E_gzamin.GraphQL.Mutations")));
foreach (var mutationType in mutationTypes)
{
var mutation = (IObjectGraphType)provider.GetRequiredService(mutationType);
mutationFields.Concat(mutation.Fields);
Mutation = mutation;
}
foreach (var field in queryFields)
{
Query.AddField(field);
}
foreach (var field in mutationFields)
{
Mutation.AddField(field);
}
}
public void TestSubSelectWithCustomName()
{
var query = new Query <Truck>("truck");
query.AddField(t => t.Load, sq => sq);
Assert.Equal("load", (query.SelectList[0] as IQuery <Load>).Name);
}
public void TestSubSelect()
{
var query = new Query <Car>("car");
query.AddField(c => c.Color, sq => sq);
Assert.Equal(nameof(Car.Color), (query.SelectList[0] as IQuery <Color>).Name);
}
public void Select_ChainCombinationOfStringAndList_AddsToQuery()
{
// Arrange
var query = new Query <object>("something");
const string select = "id";
List <string> selectList = new List <string>()
{
"name",
"email"
};
string[] selectStrings =
{
"array",
"cool"
};
// Act
query.AddField(select);
foreach (string field in selectList)
{
query.AddField(field);
}
query.AddField("some").AddField("thing").AddField("else");
foreach (string field in selectStrings)
{
query.AddField(field);
}
// Assert
List <string> shouldEqual = new List <string>()
{
"id",
"name",
"email",
"some",
"thing",
"else",
"array",
"cool"
};
Assert.Equal(shouldEqual, query.SelectList);
}
public void TestSelect()
{
var query = new Query <Car>("car");
query.AddField(c => c.Name);
Assert.Equal(new List <string> {
nameof(Car.Name)
}, query.SelectList);
}
public void TestSelectWithCustomName()
{
var query = new Query <Truck>("truck");
query.AddField(t => t.Name);
Assert.Equal(new List <string> {
"name"
}, query.SelectList);
}
public void TestSubSelectWithCustomFormater()
{
var query = new Query <Car>("car", options: new QueryOptions
{
Formatter = QueryFormatters.CamelCaseFormatter
});
query.AddField(c => c.Color, sq => sq);
Assert.Equal("color", (query.SelectList[0] as IQuery <Color>).Name);
}
public void Select_String_AddsToQuery()
{
// Arrange
var query = new Query <object>("something");
const string select = "id";
// Act
query.AddField(select);
// Assert
Assert.Equal(select, query.SelectList.First());
}
public void TestSelectWithCustomFormater()
{
var query = new Query <Car>("car", options: new QueryOptions
{
Formatter = QueryFormatters.CamelCaseFormatter
});
query.AddField(c => c.Name);
Assert.Equal(new List <string> {
"name"
}, query.SelectList);
}
public void Select_DynamicArguments_AddsToQuery()
{
// Arrange
var query = new Query <object>("something");
// Act
query.AddField("some").AddField("thing").AddField("else");
// Assert
List <string> shouldEqual = new List <string>()
{
"some",
"thing",
"else"
};
Assert.Equal(shouldEqual, query.SelectList);
}
public void Select_StringList_AddsToQuery()
{
// Arrange
var query = new Query <object>("something");
List <string> selectList = new List <string>()
{
"id",
"name"
};
// Act
foreach (string field in selectList)
{
query.AddField(field);
}
// Assert
Assert.Equal(selectList, query.SelectList);
}
public void Where_ClearQueryString_EmptyQueryString()
{
// Arrange
var query = new Query <object>("test1");
List <object> objList = new List <object>(new object[] { "aa", "bb", "cc" });
Dictionary <string, object> fromToMap = new Dictionary <string, object>
{
{ "from", 444.45 },
{ "to", 555.45 },
};
Dictionary <string, object> nestedListMap = new Dictionary <string, object>
{
{ "from", 123 },
{ "to", 454 },
{ "recurse", objList },
{ "map", fromToMap },
{ "name", TestEnum.HAYstack }
};
query
.AddField("name")
.AddArguments(nestedListMap);
var queryString = new QueryStringBuilder();
queryString.AddParams(query);
// Act
queryString.QueryString.Clear();
// Assert
Assert.True(string.IsNullOrEmpty(queryString.QueryString.ToString()));
}
public void Where_QueryString_ParseQueryString()
{
// Arrange
Query <Car> query = new Query <Car>("test1");
List <object> objList = new List <object>(new object[] { "aa", "bb", "cc" });
Dictionary <string, object> fromToMap = new Dictionary <string, object>
{
{ "from", 444.45 },
{ "to", 555.45 },
};
Dictionary <string, object> nestedListMap = new Dictionary <string, object>
{
{ "from", 123 },
{ "to", 454 },
{ "recurse", objList },
{ "map", fromToMap },
{ "name", TestEnum.HAYstack }
};
query
.AddField("name")
.AddArguments(nestedListMap);
QueryStringBuilder queryString = new QueryStringBuilder();
// Act
queryString.AddParams(query);
string addParamStr = queryString.QueryString.ToString();
// Assert
Assert.Equal("from:123,to:454,recurse:[\"aa\",\"bb\",\"cc\"],map:{from:444.45,to:555.45},name:HAYstack", addParamStr);
}
/// <summary>
///
/// </summary>
/// <param name="filters">Key=field name, Value=filter value</param>
/// <param name="sortings">Key=field name, Value=(SortOrder, SortDirection)</param>
/// <param name="maximumRows"></param>
/// <param name="startRowIndex"></param>
/// <returns></returns>
public List <object> GetAll(
Dictionary <string, string> filters,
List <KeyValuePair <string, SortDirection> > sortings,
int maximumRows,
int startRowIndex)
{
var query = new Query <Empleado>();
// Simple text and integer fields. The field names come from the select expression.
query.AddField(x => x.Nombre).AddWhere(x => x.Apellido); // Field name = "Nombre"
query.AddField(x => x.Apellido).AddWhere(x => x.Nombre).CaseSensitive(); // Field name = "Apellido" - case sensitive
query.AddField(x => x.Dni);
// A field that concatenates two properties.
query.AddField("FullName").Select(x => x.Nombre + " " + x.Apellido);
// Date filter with truncated time.
query.AddField(x => x.FechaNacimiento).TruncateTime();
// List filter targeting an enum
query.AddField("EstadoCivil")
.Select(x => x.EstadoCivil_Id) // enums in EF5 for .NET 4.0
// since the select targets an int we need the following to force a list filter instead of an integer filter.
.FilterAsList()
// Return constants for specific values of the target, not necesary but allows us to translates the enum values that will be shown.
.SelectWhen(this.GetEstadoCivilTranslations(), string.Empty)
.FilterWhen(10, x => x.EstadoCivil_Id.Equals((int)EstadoCivil.Casado) || // custom value filter
x.EstadoCivil_Id.Equals((int)EstadoCivil.Separado));
query.AddField(x => x.Edad);
query.AddField(x => x.Salario);
query.AddField("AttachmentCount").Select(x => x.Attachment.Items.Count(item => !item.Deleted && item.Location_Id.Equals((int)AttachmentLocation.Creation)));
query.AddField(x => x.Cuit);
query.AddField(x => x.AverageHourlyWage);
query.AddField("Dynamic").Select(x => x.FechaNacimiento).FilterAsList().FilterWhen(-1, empleado => empleado.Apellido.ToLower().StartsWith("dro"));
using (var db = new SampleContext())
{
var empleados = (IQueryable <Empleado>)db.Set <Empleado>();
// Filtering
empleados = query.Filter(empleados, filters);
// Sorting and pagination
if (maximumRows > 0)
{
empleados = query.OrderBy(empleados, sortings, x => x.Id); // x => x.Id acts as default sort when sortings is empty, required to use Skip and Take on EF
empleados = empleados.Skip(startRowIndex).Take(maximumRows);
}
// Projection. theResult is an untyped IQueryable. The ElementType is an annonymous type based in the defined fields
var theResult = query.Project(empleados);
// Calling ToList on the final IQueryable so the SQL query is performed by EF.
return(Enumerable.Cast <object>(theResult).ToList());
}
}
public virtual void RegisterQueries(IEnumerable <Type> queryHandlerTypes)
{
foreach (var queryHandlerType in queryHandlerTypes)
{
var genericType = queryHandlerType.GetInterfaces().Single(x => x.GetTypeInfo().IsAssignableToGenericType(typeof(IQueryHandler <,>)) ||
x.GetTypeInfo().IsAssignableToGenericType(typeof(IAsyncQueryHandler <,>)));
var genericArguments = genericType.GetGenericArguments();
var queryType = genericArguments[0];
var queryResultType = genericArguments[1];
var resultType = genericArguments[1];
if (queryType.GetCustomAttribute <ExposeGraphQLAttribute>() == null)
{
continue;
}
var isCollection = resultType != typeof(string) && typeof(IEnumerable).IsAssignableFrom(resultType);
if (isCollection)
{
resultType = resultType.GetGenericArguments()[0];
}
var descriptionAttribute = queryType.GetCustomAttribute <DescriptionAttribute>();
var exposeAttribute = queryType.GetCustomAttribute <ExposeGraphQLAttribute>();
var authorizeAttribute = queryType.GetCustomAttribute <AuthorizeAttribute>();
if (exposeAttribute == null)
{
continue;
}
var properties = queryType.GetProperties(BindingFlags.Instance | BindingFlags.Public).Where(x => !typeof(IResolveFieldContext).IsAssignableFrom(x.PropertyType));
IInputObjectGraphType inputGqlType = null;
if (properties.Any())
{
var inputObjectType = typeof(AutoInputGraphType <>).MakeGenericType(queryType);
inputGqlType = (IInputObjectGraphType)_container.GetInstance(inputObjectType);
inputGqlType.Description = descriptionAttribute?.Description;
}
IGraphType resultGqlType = null;
if (!_typeCache.ContainsKey(queryResultType) && !BuiltInTypeMappings.Any(x => x.clrType == resultType) && !TypeMappings.Any(x => x.clrType == resultType))
{
var resultTypeName = GetTypeName(resultType);
var returnObjectType = typeof(AutoObjectGraphType <>).MakeGenericType(resultType);
resultGqlType = (IGraphType)_container.GetInstance(returnObjectType);
resultGqlType.Name = resultTypeName;
//TODO: refactor
ListGraphType listGqlType = null;
if (isCollection)
{
var name = resultGqlType.Name;
listGqlType = (ListGraphType)Activator.CreateInstance(typeof(ListGraphType <>).MakeGenericType(returnObjectType), null);
listGqlType.ResolvedType = resultGqlType;
resultGqlType = (IGraphType)listGqlType;
// resultGqlType.Name = "ListOf" + name;
}
RegisterTypeMapping(resultType, returnObjectType);
_typeCache.TryAdd(queryResultType, resultGqlType);
}
else if (_typeCache.ContainsKey(queryResultType))
{
resultGqlType = _typeCache[queryResultType];
}
var arguments = new List <QueryArgument>();
if (inputGqlType != null)
{
var argument = AllowNullQuery ? new QueryArgument(inputGqlType) : new QueryArgument(new NonNullGraphType(inputGqlType));
argument.Name = "query";
arguments.Add(argument);
}
var queryName = exposeAttribute.IsFieldNameSet ? exposeAttribute.FieldName : _queryNamePrefixRegex.Replace(_queryNameSuffixRegex.Replace(queryType.Name, string.Empty), string.Empty);
if (!Query.HasField(queryName))
{
var type = new FieldType
{
Type = resultGqlType == null?BuiltInTypeMappings.Where(x => x.clrType == resultType).Select(x => x.graphType).SingleOrDefault() ?? TypeMappings.Where(x => x.clrType == resultType).Select(x => x.graphType).SingleOrDefault() : null,
ResolvedType = resultGqlType,
Resolver = new QueryResolver(_container, queryHandlerType, queryType, resultType, GetJsonSerializerSettings()),
Name = GetNormalizedFieldName(queryName),
Description = descriptionAttribute?.Description,
Arguments = new QueryArguments(arguments),
};
type.Metadata[GraphQLExtensions.PermissionsKey] = authorizeAttribute?.Permissions?.ToList();
Query.AddField(type);
}
}
}
public virtual void RegisterQueries(IEnumerable <Type> queryHandlerTypes)
{
foreach (var queryHandlerType in queryHandlerTypes)
{
var genericType = queryHandlerType.GetInterfaces().Single(x => x.GetTypeInfo().IsAssignableToGenericType(typeof(IQueryHandler <,>)) ||
x.GetTypeInfo().IsAssignableToGenericType(typeof(IAsyncQueryHandler <,>)));
var genericArguments = genericType.GetGenericArguments();
var queryType = genericArguments[0];
var resultType = genericArguments[1];
var descriptionAttribute = queryType.GetCustomAttribute <DescriptionAttribute>();
var exposeAttribute = queryType.GetCustomAttribute <ExposeGraphQLAttribute>();
var authorizeAttribute = queryType.GetCustomAttribute <AuthorizeAttribute>();
if (exposeAttribute == null)
{
continue;
}
var properties = queryType.GetProperties(BindingFlags.Instance | BindingFlags.Public);
IInputObjectGraphType?inputGqlType = null;
if (properties.Any())
{
var inputObjectType = typeof(InputObjectGraphType <>).MakeGenericType(queryType);
inputGqlType = (IInputObjectGraphType)Activator.CreateInstance(inputObjectType);
inputGqlType.Name = queryType.Name;
inputGqlType.Description = descriptionAttribute?.Description;
var addFieldMethod = inputGqlType.GetType().GetMethod("AddField");
foreach (var propertyInfo in properties)
{
addFieldMethod.Invoke(inputGqlType, new[]
{
new FieldType()
{
Name = GetNormalizedFieldName(propertyInfo.Name),
Type = propertyInfo.PropertyType.GetGraphTypeFromType(),
Description = propertyInfo.GetCustomAttribute <DescriptionAttribute>()?.Description
}
});
}
}
IGraphType?resultGqlType = null;
if (!GraphTypeTypeRegistry.Contains(resultType))
{
var resultTypeName = resultType.Name;
var returnObjectType = typeof(EntityGraphType <>).MakeGenericType(resultType);
resultGqlType = (IGraphType)Activator.CreateInstance(returnObjectType, null);
resultGqlType.Name = resultTypeName;
if (authorizeAttribute != null)
{
var permissions = resultGqlType.GetMetadata <List <string> >(GraphQLExtensions.PermissionsKey);
if (permissions == null)
{
permissions = new List <string>();
resultGqlType.Metadata[GraphQLExtensions.PermissionsKey] = permissions;
}
if (!string.IsNullOrWhiteSpace(authorizeAttribute.Permission))
{
permissions.Add(authorizeAttribute.Permission);
}
}
}
var arguments = new List <QueryArgument>();
if (inputGqlType != null)
{
var argument = AllowNullQuery ? new QueryArgument(inputGqlType) : new QueryArgument(new NonNullGraphType(inputGqlType));
argument.Name = "query";
arguments.Add(argument);
}
var queryName = exposeAttribute.IsFieldNameSet ? exposeAttribute.FieldName : new Regex("Query").Replace(queryType.Name, "");
if (!Query.HasField(queryName))
{
var type = new FieldType
{
Type = resultGqlType == null?GraphTypeTypeRegistry.Get(resultType) : null,
ResolvedType = resultGqlType,
Resolver = new QueryResolver(_container, queryHandlerType, queryType, GetJsonSerializerSettings()),
Name = GetNormalizedFieldName(queryName),
Description = descriptionAttribute?.Description,
Arguments = new QueryArguments(arguments)
};
Query.AddField(type);
}
}
}
