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)); }