private void FillArgs(string columnName)
{
var dataType = ReflectionHelper.GetPropertyType(_type, columnName);
if (TableArgs == null)
{
TableArgs = new QueryArguments();
TableArgs.Add(new QueryArgument <IntGraphType> {
Name = "first"
});
TableArgs.Add(new QueryArgument <IntGraphType> {
Name = "offset"
});
}
if (dataType != null)
{
switch (dataType.Name)
{
case "Int32":
TableArgs.Add(new QueryArgument <IntGraphType> {
Name = columnName
});
break;
case "DateTime":
TableArgs.Add(new QueryArgument <DateGraphType> {
Name = columnName
});
break;
case "Boolean":
TableArgs.Add(new QueryArgument <BooleanGraphType> {
Name = columnName
});
break;
default:
TableArgs.Add(new QueryArgument <StringGraphType> {
Name = columnName
});
break;
}
}
//TableArgs.Add(new QueryArgument<IntGraphType> { Name = "id" });
//TableArgs.Add(new QueryArgument<IntGraphType> { Name = "first" });
//TableArgs.Add(new QueryArgument<IntGraphType> { Name = "offset" });
}
public static QueryArguments GetQueryArguments(IEnumerable <QueryArgument>?extra, bool hasId, bool applyOrder)
{
var arguments = new QueryArguments();
if (hasId)
{
arguments.Add(idArgument());
arguments.Add(idsArgument());
}
arguments.Add(whereArgument());
if (applyOrder)
{
arguments.Add(orderByArgument());
arguments.Add(skipArgument());
arguments.Add(takeArgument());
}
if (extra is not null)
{
foreach (var argument in extra)
{
arguments.Add(argument);
}
}
return(arguments);
}
public static QueryArguments AddRange(this QueryArguments queryArguments, IEnumerable <QueryArgument> arguments)
{
foreach (var queryArgument in arguments)
{
queryArguments.Add(queryArgument);
}
return(queryArguments);
}
public QueryArguments Build <TEntity>() where TEntity : class
{
var queryArguments = new QueryArguments();
foreach (var queryArgumnetBuilder in EntityGraphQueryArgumentBuilders)
{
queryArguments.Add(queryArgumnetBuilder.Build <TEntity>());
}
return(queryArguments);
}
private void AddField(Field field, Func <ResolveFieldContext, object> resolveFunc, string description = null)
{
if (NameConverter.TryConvertToGraphQLName(field.Name, out string graphQLFieldName))
{
// Create type from Field
var arguments = new QueryArguments();
if (field.IsLocalizable)
{
arguments.Add(new QueryArgument <StringGraphType>()
{
Name = "language"
});
}
this.Field(graphQLFieldName, field.FieldType.GraphQLType, resolve: resolveFunc, description: description, arguments: arguments);
}
}
public static QueryArguments GetQueryArguments(
this IGraphQLQueryResolver resolver,
string methodName)
{
var type = resolver.GetType();
var method = type.GetMethod(methodName);
var arguments = new QueryArguments();
foreach (var p in method.GetParameters())
{
arguments.Add(new QueryArgument(GetGraphQLType(p.ParameterType))
{
Name = p.Name
});
}
return(arguments);
}
private void GetInternalInstances(ColumnMetadata mainTableColumn)
{
string key = $"Internal_{mainTableColumn.Type.Name}";
var queryArguments = new QueryArguments();
queryArguments.Add(new QueryArgument <StringGraphType> {
Name = "all"
});
var metaTable = _dbMetadata.GetTableMetadatas().FirstOrDefault(x => x.Type.Name == mainTableColumn.Type.Name);
var tableType = GetSecondGraphType(mainTableColumn, queryArguments, metaTable);
// Field<StateType>(nameof(City.state));
AddField(new FieldType
{
Name = $"{mainTableColumn.ColumnName}",
ResolvedType = tableType,
Arguments = queryArguments
});
}
public static QueryArguments GetQueryArguments(IEnumerable <QueryArgument> extra)
{
var arguments = new QueryArguments
{
idArgument,
orderByArgument,
whereArgument,
skipArgument,
takeArgument
};
if (extra != null)
{
foreach (var argument in extra)
{
arguments.Add(argument);
}
}
return(arguments);
}
/// <summary>
/// Register Managers
/// </summary>
/// <param name="services"></param>
/// <param name="query"></param>
private static void RegisterManagers(IServiceCollection services, ObjectGraphType query, ObjectGraphType mutation)
{
Type[] managerTypes = null;
try
{
managerTypes = Assembly.Load("ProfileLocation.Managers").GetTypes();
}
catch (Exception ex)
{
_logger.Warn(ex, $"Cannot load managers dll");
return;
}
XElement[] xmlMemberComments = null;
var managersXmlLocation = Path.ChangeExtension(Assembly.Load("ProfileLocation.Managers").Location, ".xml");
if (File.Exists(managersXmlLocation))
{
xmlMemberComments = XDocument.Load(managersXmlLocation).Root.Element("members").Elements().ToArray();
}
//Reflect on all Managers
foreach (var managerType in managerTypes.Where(w => w.IsClass && w.Name.EndsWith("Manager")))
{
if (managerType.GetCustomAttribute <QLIgnoreAttribute>() != null)
{
_logger.Info($"Manager: {managerType.Name} is ignored due to QLIgnore Attribute");
continue;
}
var managerObsoleteAtt = (ObsoleteAttribute)managerType.GetCustomAttribute(typeof(ObsoleteAttribute));
var deprecationReason = managerObsoleteAtt != null ? managerObsoleteAtt.Message ?? "Marked Obsolete" : null;
//Add type to DI
services.AddTransient(managerType);
//Reflect on each method exposed and add as a field to QL Context
foreach (var method in managerType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
//If method returns void then ignore as not supported
if (method.ReturnType == typeof(void) || method.ReturnType == typeof(Task))
{
_logger.Warn($"Manager {managerType.Name} has method({method.Name}) which returns {method.ReturnType.Name} and is not currently supported");
continue;
}
var isAsync = method.ReturnType.IsGenericType && method.ReturnType.GetGenericTypeDefinition() == typeof(Task <>);
var methodReturnType = isAsync ? method.ReturnType.GetGenericArguments()[0] : method.ReturnType;
if (method.GetCustomAttribute <QLIgnoreAttribute>() != null)
{
_logger.Info($"Manager: {managerType.Name} has method({method.Name}) that is ignored due to QLIgnore Attribute");
continue;
}
string memberXmlComment = null;
var memberXml = xmlMemberComments?.FirstOrDefault(f => f.Attribute("name")?.Value.StartsWith($"M:{method.DeclaringType.FullName}.{method.Name}") ?? false);
if (memberXml != null)
{
memberXmlComment = memberXml.Element("summary")?.Value?.Trim();
}
var methodObsoleteAtt = (ObsoleteAttribute)managerType.GetCustomAttribute(typeof(ObsoleteAttribute));
var methodDeprecationReason = methodObsoleteAtt != null ? methodObsoleteAtt.Message ?? "Marked Obsolete" : null;
if (!string.IsNullOrWhiteSpace(methodDeprecationReason))
{
deprecationReason = methodDeprecationReason;
}
QueryArguments queryArgs = new QueryArguments();
foreach (var inputParam in method.GetParameters())
{
var qlInputType = GraphQLUtilities.GenerateQlInputType(inputParam.ParameterType, services, out _);
var paramXml = memberXml?.Elements().FirstOrDefault(f => f.Attribute("name")?.Value == inputParam.Name)?.Value?.Trim();
queryArgs.Add(GraphQLUtilities.GetQLInputQueryArgument(inputParam, qlInputType, paramXml));
}
var fieldName = $"{managerType.Name}_{method.Name}";
// If the method is marked with a qlquery attribute then attach it to the query object if not default to mutation
var qlQueryAttr = method.GetCustomAttribute <QLQueryAttribute>();
var destinationQLObject = qlQueryAttr == null ? mutation : query;
//Check if method has been overloaded
if (destinationQLObject.Fields.Any(a => a.Name == fieldName))
{
_logger.Debug($"Manager {managerType.Name} has method({method.Name}) overloads which is not supported");
fieldName = fieldName + "_" + (destinationQLObject.Fields.Count(a => a.Name == fieldName) + 1);
}
//Add field to QL
if (isAsync)
{
destinationQLObject.FieldAsync(
GraphQLUtilities.GenerateQLOutputType(methodReturnType, services),
fieldName,
memberXmlComment,
queryArgs,
async context =>
{
var serviceProv = ((QLUserContext)context.UserContext).ServiceProvider;
var logger = (ILogManager)serviceProv.GetService(typeof(ILogManager));
try
{
GetMethodManagerAndMethodParameters(method, context, serviceProv, out var manager, out var parameters);
logger.Debug($"Invoking Async {managerType.Name}.{method.Name}");
var methodTask = (Task)method.Invoke(manager, parameters);
await methodTask.ConfigureAwait(false);
var resultPropertyInfo = methodTask.GetType().GetProperty("Result");
return(resultPropertyInfo.GetValue(methodTask));
}
catch (Exception ex)
{
logger.Fatal($"Error during manager call, {managerType.Name}.{method.Name}", ex);
throw;
}
},
deprecationReason);
}
else
{
destinationQLObject.Field(
GraphQLUtilities.GenerateQLOutputType(methodReturnType, services),
fieldName,
memberXmlComment,
queryArgs,
context =>
{
var serviceProv = ((QLUserContext)context.UserContext).ServiceProvider;
var logger = (ILogManager)serviceProv.GetService(typeof(ILogManager));
try
{
GetMethodManagerAndMethodParameters(method, context, serviceProv, out var manager, out var parameters);
logger.Debug($"Invoking {managerType.Name}.{method.Name}");
return(method.Invoke(manager, parameters));
}
private void FillArguments(QueryArguments queryArguments, string columnName, Type type)
{
if (queryArguments == null)
{
return;
}
if (type.IsArray)
{
queryArguments.Add(new QueryArgument <StringGraphType> {
Name = $"{columnName}_ext"
});
}
if (columnName == "id")
{
queryArguments.Add(new QueryArgument <IdGraphType> {
Name = "id"
});
queryArguments.Add(new QueryArgument <StringGraphType> {
Name = "id_iext"
});
queryArguments.Add(new QueryArgument <StringGraphType> {
Name = "id_iext_or"
});
queryArguments.Add(new QueryArgument <IdGraphType> {
Name = $"{columnName}_exclude"
});
}
else
{
var queryArgument = new QueryArgument(GraphUtils.ResolveGraphType(type))
{
Name = columnName
};
queryArguments.Add(queryArgument);
queryArguments.Add(new QueryArgument(GraphUtils.ResolveGraphType(type))
{
Name = $"{columnName}_exclude"
});
if (type == typeof(DateTime?) || type == typeof(DateTime))
{
queryArguments.Add(new QueryArgument <MyDateTimeGraphType> {
Name = $"{columnName}_gt"
});
queryArguments.Add(new QueryArgument <MyDateTimeGraphType> {
Name = $"{columnName}_gte"
});
queryArguments.Add(new QueryArgument <MyDateTimeGraphType> {
Name = $"{columnName}_lt"
});
queryArguments.Add(new QueryArgument <MyDateTimeGraphType> {
Name = $"{columnName}_lte"
});
queryArguments.Add(new QueryArgument <BooleanGraphType> {
Name = $"{columnName}_isnull"
});
}
else if (type == typeof(int?) || type == typeof(int) || type == typeof(decimal?) || type == typeof(decimal) ||
type == typeof(double?) || type == typeof(double) || type == typeof(float?) || type == typeof(float))
{
queryArguments.Add(new QueryArgument <MyIntGraphType> {
Name = $"{columnName}_gt"
});
queryArguments.Add(new QueryArgument <MyIntGraphType> {
Name = $"{columnName}_gte"
});
queryArguments.Add(new QueryArgument <MyIntGraphType> {
Name = $"{columnName}_lt"
});
queryArguments.Add(new QueryArgument <MyIntGraphType> {
Name = $"{columnName}_lte"
});
queryArguments.Add(new QueryArgument <StringGraphType> {
Name = $"{columnName}_iext"
});
queryArguments.Add(new QueryArgument <StringGraphType> {
Name = $"{columnName}_iext_or"
});
queryArguments.Add(new QueryArgument <BooleanGraphType> {
Name = $"{columnName}_isnull"
});
}
else if (type != typeof(bool))
{
queryArguments.Add(new QueryArgument <StringGraphType> {
Name = $"{columnName}_iext"
});
queryArguments.Add(new QueryArgument <StringGraphType> {
Name = $"{columnName}_iext_or"
});
queryArguments.Add(new QueryArgument <BooleanGraphType> {
Name = $"{columnName}_isnull"
});
}
}
}
private void FillArgs(string columnName, Type type, string parentModel = "", bool isList = false)
{
if (!string.IsNullOrEmpty(parentModel))
{
if (isList)
{
columnName = $"{parentModel}__list__{columnName}";
}
else
{
columnName = $"{parentModel}__model__{columnName}";
}
}
if (TableArgs == null)
{
TableArgs = new QueryArguments();
TableArgs.Add(new QueryArgument <MyIntGraphType> {
Name = "first"
});
TableArgs.Add(new QueryArgument <MyIntGraphType> {
Name = "page"
});
TableArgs.Add(new QueryArgument <StringGraphType> {
Name = "orderBy"
});
TableArgs.Add(new QueryArgument <StringGraphType> {
Name = "all"
});
}
if (type.IsArray)
{
TableArgs.Add(new QueryArgument <StringGraphType> {
Name = $"{columnName}_ext"
});
}
if (columnName == "id")
{
TableArgs.Add(new QueryArgument <IdGraphType> {
Name = "id"
});
TableArgs.Add(new QueryArgument <StringGraphType> {
Name = "id_iext"
});
TableArgs.Add(new QueryArgument <StringGraphType> {
Name = "id_iext_or"
});
TableArgs.Add(new QueryArgument <IdGraphType> {
Name = $"{columnName}_exclude"
});
}
else
{
var queryArgument = new QueryArgument(GraphUtils.ResolveGraphType(type))
{
Name = columnName
};
TableArgs.Add(queryArgument);
TableArgs.Add(new QueryArgument(GraphUtils.ResolveGraphType(type))
{
Name = $"{columnName}_exclude"
});
if (type == typeof(DateTime?) || type == typeof(DateTime))
{
TableArgs.Add(new QueryArgument <MyDateTimeGraphType> {
Name = $"{columnName}_gt"
});
TableArgs.Add(new QueryArgument <MyDateTimeGraphType> {
Name = $"{columnName}_gte"
});
TableArgs.Add(new QueryArgument <MyDateTimeGraphType> {
Name = $"{columnName}_lt"
});
TableArgs.Add(new QueryArgument <MyDateTimeGraphType> {
Name = $"{columnName}_lte"
});
TableArgs.Add(new QueryArgument <BooleanGraphType> {
Name = $"{columnName}_isnull"
});
}
else if (type == typeof(int?) || type == typeof(int) || type == typeof(decimal?) || type == typeof(decimal) ||
type == typeof(double?) || type == typeof(double) || type == typeof(float?) || type == typeof(float))
{
TableArgs.Add(new QueryArgument <MyIntGraphType> {
Name = $"{columnName}_gt"
});
TableArgs.Add(new QueryArgument <MyIntGraphType> {
Name = $"{columnName}_gte"
});
TableArgs.Add(new QueryArgument <MyIntGraphType> {
Name = $"{columnName}_lt"
});
TableArgs.Add(new QueryArgument <MyIntGraphType> {
Name = $"{columnName}_lte"
});
TableArgs.Add(new QueryArgument <StringGraphType> {
Name = $"{columnName}_iext"
});
TableArgs.Add(new QueryArgument <StringGraphType> {
Name = $"{columnName}_iext_or"
});
TableArgs.Add(new QueryArgument <BooleanGraphType> {
Name = $"{columnName}_isnull"
});
}
else if (type != typeof(bool))
{
TableArgs.Add(new QueryArgument <StringGraphType> {
Name = $"{columnName}_iext"
});
TableArgs.Add(new QueryArgument <StringGraphType> {
Name = $"{columnName}_iext_or"
});
TableArgs.Add(new QueryArgument <BooleanGraphType> {
Name = $"{columnName}_isnull"
});
}
}
}
/// <summary>
/// Adds a connection field.
/// Example usage:
/// <code>
/// this.AddConnectionField<Order, ObjectType<Order>>(context =>
/// {
/// return new Connection<Order>(orderRepository.GetOrders());
/// });
/// </code>
/// </summary>
/// <typeparam name="T">The type of the model.</typeparam>
/// <typeparam name="TT">The type of the GraphQL type (i.e. ObjectType<Model>)</typeparam>
/// <param name="type"></param>
/// <param name="resolve">The resolving func that retuns a connection model.</param>
/// <param name="name">The name of the field.</param>
public static FieldType AddConnectionField <T, TT>(this ComplexGraphType <object> type, Func <ResolveFieldContext <object>, object> resolve, string name = null, QueryArgument[] arguments = null) where T : class where TT : ComplexGraphType <object>, IGraphType <T>
{
// create name if non is given
var lowerCaseName = name != null ? name : $"{typeof(T).Name.ToFirstLower()}s";
// build argument list... first default ones
var args = new QueryArguments(
new QueryArgument <IdGraphType> {
Name = "after"
},
new QueryArgument <IntGraphType> {
Name = "first"
},
new QueryArgument <IdGraphType> {
Name = "before"
},
new QueryArgument <IntGraphType> {
Name = "last"
});
// construct order by type
// create a class type "additionsType" and add a property for each item in "arguments"
// if any custom arguments are set
if (arguments != null)
{
var additionsType = TypeExtensions.CreateAdditionsTypeForType(typeof(T), arguments.Select(a => a.Name).ToArray());
// create a type like OrderByType<T, additionsType> and use it below
var orderByType = typeof(OrderByType <,>).MakeGenericType(new[] { typeof(T), additionsType });
args.Add(new QueryArgument(orderByType)
{
Name = "orderBy"
});
}
else
{
args.Add(new QueryArgument <OrderByType <T> > {
Name = "orderBy"
});
}
// ... then add an optional argument for each property of T
var properties = typeof(T).GetExactProperies();
foreach (var property in properties.Where(p => p.PropertyType.IsSimpleType()))
{
var propertyName = property.Name.ToFirstLower();
args.Add(new QueryArgument(property.PropertyType.MapToGraphType())
{
Name = propertyName
});
}
// .. then add custom added arguments
if (arguments != null)
{
args.AddRange(arguments);
}
// create field
return(type.Field <ConnectionType <T, TT> >(lowerCaseName, $"The {lowerCaseName} connection.", args, resolve));
}
