public IncludeDirective() { Name = "include"; Description = "Directs the executor to include this field or fragment only when the 'if' argument is true."; Arguments = new QueryArguments(new [] { new QueryArgument { Name = "if", Type = NonNullGraphType.Boolean} }); OnOperation = false; OnFragment = true; OnField = true; }
public SkipDirective() { Name = "skip"; Description = "Directs the executor to skip this field or fragment when the 'if' argument is true."; Arguments = new QueryArguments(new [] { new QueryArgument<NonNullGraphType<BooleanGraphType>> { Name = "if" } }); OnOperation = false; OnFragment = true; OnField = true; }
public TypeMetaFieldType() { Name = "__type"; Type = typeof(__Type); Description = "Request the type information of a single type."; Arguments = new QueryArguments( new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "name" }); Resolver = new FuncFieldResolver<object>(context => context.Schema.FindType((string) context.Arguments["name"])); }
public void StartSearch(string query) { QueryArguments args = new QueryArguments(NextID++, ""); args.Query = query; BackgroundWorker backgroundWorker1 = new BackgroundWorker(); backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker_Analysis_DoWork); backgroundWorker1.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged); backgroundWorker1.WorkerReportsProgress = true; backgroundWorker1.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted); backgroundWorker1.RunWorkerAsync(args); }
public TypeMetaFieldType() { Name = "__type"; Type = new __Type(); Description = "Request the type information of a single type."; Arguments = new QueryArguments(new[] { new QueryArgument { Name = "name", Type = NonNullGraphType.String } }); Resolve = context => context.Schema.FindType((string) context.Arguments["name"]); }
private void queryWorker_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e) { QueryArguments arguments = (QueryArguments)e.Argument; try { Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); XmlDocument queryPlan; XmlDocument queryStats; if (returnClauses.Any(s => arguments.Query.Trim().EndsWith(s, StringComparison.OrdinalIgnoreCase))) { List <ErrorMessage> errorMessages; arguments.RawXmlResults = arguments.Connection.QueryXml(arguments.Query, out queryPlan, out errorMessages, out queryStats); arguments.Errors = errorMessages; } else { arguments.Results = arguments.Connection.Query(arguments.Query, out queryPlan, out queryStats); if (arguments.Results.ExtendedProperties.Contains("Errors") && arguments.Results.ExtendedProperties["Errors"] != null) { arguments.Errors = (List <ErrorMessage>)arguments.Results.ExtendedProperties["Errors"]; } } arguments.QueryPlan = queryPlan; arguments.QueryStats = queryStats; arguments.Log = LogHeaderMessageInspector.LastReplyLog; stopWatch.Stop(); arguments.QueryTime = stopWatch.Elapsed; e.Result = arguments; } catch (Exception ex) { e.Result = new QueryErrorResult { ErrorMessage = ex.Message, Log = LogHeaderMessageInspector.LastReplyLog }; } }
public HttpResponseMessage GetByArgs(DateTime?fromDate = null, DateTime?toDate = null, string project = null, string customer = null) { try { var args = new QueryArguments { FromDate = fromDate, ToDate = toDate, Project = project, Customer = customer }; var regs = _registrationService.Get(args); return(Request.CreateResponse(HttpStatusCode.OK, regs)); } catch (Exception ex) { return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex)); } }
public int CreateInvoice(QueryArguments args) { var registrations = GetNonInvoicedRegistrations(args); if (registrations.Count() == 0) { throw new ArgumentException("Invalid arguments. Query needs to match at least one non-invoiced registration."); } var price = CalculatePrice(registrations); var invoice = new Invoice { Registrations = new HashSet <Registration>(registrations), Amount = price }; registrations = UpdateRegistrationsWithInvoice(registrations, invoice); SaveOrUpdate(invoice); return(invoice.Id); }
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> /// Queries the details on an item action. /// </summary> /// <param name="urn">The URN to query for actions.</param> /// <param name="arguments">The arguments for the query.</param> /// <returns> /// The allowed actions on the URN. /// </returns> public QueryResult Query(string urn, QueryArguments arguments) { var result = new QueryResult(); arguments = arguments ?? new QueryArguments(); var item = this.LocateItem(urn); if (item == null) { logger.Warn("Request made to unknown URN '{0}'", urn); result.ResultCode = RemoteResultCode.UnknownUrn; return(result); } var itemType = item.GetType(); var actions = new List <RemoteActionDefinition>(); var filterRegex = (arguments == null) || string.IsNullOrEmpty(arguments.FilterPattern) ? null : new Regex(arguments.FilterPattern); var messageFormats = new Dictionary <Type, string>(); var namespaces = new Dictionary <string, string>(); foreach (var method in itemType.GetMethods(BindingFlags.Instance | BindingFlags.Public)) { var actionAttributes = method.GetCustomAttributes( typeof(RemoteActionAttribute), false); if ((actionAttributes.Length > 0) && ((filterRegex == null) || filterRegex.IsMatch(method.Name))) { // TODO: Validate security here var definition = GenerateDefinition(arguments, method, messageFormats, namespaces); actions.Add(definition); } } // Generate the result result.Actions = actions.ToArray(); return(result); }
public SignupMutation() : base("signup", "Sign Up") { var queryArgumentArray = new List <QueryArgument>(); queryArgumentArray.Add(new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "username" }); queryArgumentArray.Add(new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "password" }); queryArgumentArray.Add(new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "email" }); Arguments = new QueryArguments(queryArgumentArray); }
public static FieldType FieldAsync <TGraphType, TSourceType>( this IObjectGraphType obj, string name, string description = null, QueryArguments arguments = null, Func <ResolveFieldContext <TSourceType>, Task <object> > resolve = null, string deprecationReason = null) where TGraphType : IGraphType { return(obj.AddField(new FieldType { Name = name, Description = description, DeprecationReason = deprecationReason, Type = typeof(TGraphType), Arguments = arguments, Resolver = resolve != null ? new AsyncFieldResolver <TSourceType, object>(resolve) : null, })); }
/// <summary> /// Generates the definition. /// </summary> /// <param name="arguments">The arguments.</param> /// <param name="method">The method.</param> /// <param name="messageFormats">The message formats.</param> /// <param name="namespaces">The namespaces.</param> /// <returns> /// The definition for the remote action. /// </returns> private static RemoteActionDefinition GenerateDefinition(QueryArguments arguments, MethodInfo method, Dictionary <Type, string> messageFormats, Dictionary <string, string> namespaces) { var description = ExtractDescription(method); var definition = new RemoteActionDefinition { Name = method.Name, Description = description }; // Generate the message formats switch (arguments.DataToInclude) { case DataDefinitions.InputOnly: definition.InputData = GenerateMessageFormat( messageFormats, namespaces, method.GetParameters()[0].ParameterType); break; case DataDefinitions.OutputOnly: definition.OutputData = GenerateMessageFormat( messageFormats, namespaces, method.ReturnType); break; case DataDefinitions.Both: definition.InputData = GenerateMessageFormat( messageFormats, namespaces, method.GetParameters()[0].ParameterType); definition.OutputData = GenerateMessageFormat( messageFormats, namespaces, method.ReturnType); break; } return(definition); }
public ProductQuery(IRepository <IProduct> repo) { _repo = repo; var productArgs = new QueryArguments( new QueryArgument <NonNullGraphType <StringGraphType> > { Name = idArg }); var productsArgs = new QueryArguments( new QueryArgument <IntGraphType> { Name = firstArg, DefaultValue = -1 }, new QueryArgument <StringGraphType> { Name = nameArg, DefaultValue = null }, new QueryArgument <StringGraphType> { Name = typeArg, DefaultValue = null } ); Field <ProductInterface>("product", arguments: productArgs, resolve: ResolveProduct); Field <ListGraphType <ProductInterface> >("products", arguments: productsArgs, resolve: ResolveProducts); }
public static FieldType CreateDeleteMutation <TId, TEntity, TViewer>(this ObjectGraphType <object> type, Func <ResolveFieldContext <object>, object, object, object> resolve, string mutationName = null) where TEntity : class { // construct DeletePayloadType<Order> var entityType = typeof(TEntity); var deletePayloadType = typeof(DeletePayloadType <,>).MakeGenericType(entityType, typeof(TViewer)); deletePayloadType = deletePayloadType.ConvertToVirtualType(); // construct mutation name (i.e. "deleteOrder") var fieldName = mutationName != null ? mutationName : $"delete{entityType.Name}"; // construct NonNullGraphType<DeleteInputType<Order>> var deleteInputType = typeof(DeleteInputType <>).MakeGenericType(entityType); var nonNullableGraphType = typeof(NonNullGraphType <>); nonNullableGraphType = nonNullableGraphType.MakeGenericType(deleteInputType); // construct arguments var argument = new QueryArgument(nonNullableGraphType) { Name = "input" }; var arguments = new QueryArguments(argument); // construct resolver Func <ResolveFieldContext <object>, object> resolver = (context) => { var input = context.GetArgument <DeleteInput>("input"); var id = GlobalId.ToLocalId <TId>(input.Id); return(resolve(context, id, input)); }; // call Field like type.Field<DeletePayloadType<Order>>("deleteOrder", args, resolve) var method = type.GetType().GetMethods().First(m => m.Name == "Field" && m.IsGenericMethod && m.ReturnType == typeof(FieldType)); method = method.MakeGenericMethod(deletePayloadType); return((FieldType)method.Invoke(type, new object[] { fieldName, null, arguments, resolver, null })); }
public FamilyQuery(FamilyModel dbSample) { _dbSample = dbSample; Name = "Query"; /** * */ Field <ListGraphType <FamilyType> >("AllFamilies", resolve: context => GetAllFamilies()); /** * */ var argument = new QueryArguments( new QueryArgument <IntGraphType> { Name = "Id" } , new QueryArgument <StringGraphType> { Name = "Name" } ); Field <FamilyType>("Family", arguments: argument, resolve: context => GetFamily(context)); /** * */ var memberArg = new QueryArguments(new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "MemberName" }); Field <FamilyType>("SearchByMember", arguments: memberArg, resolve: context => GetByMembers(context)); }
public void QueryFiltersActions() { var testItem = new TestItem("Baby"); var server = new Server("Test", testItem); var invoker = new ActionInvoker(server); var args = new QueryArguments { FilterPattern = "DoSomething", DataToInclude = DataDefinitions.None }; var result = invoker.Query("urn:ccnet:test:baby", args); Assert.IsNotNull(result); Assert.AreEqual(RemoteResultCode.Success, result.ResultCode); var expected = new[] { new RemoteActionDefinition { Name = "DoSomething", Description = "This will do something" } }; CollectionAssert.AreEqual(expected, result.Actions, new DefinitionComparer()); }
private void ConvertPropertyToSimpleField(PropertyInfo field) { var genericArguments = field.PropertyType.GetGenericArguments(); var graphType = genericArguments[0].MapToGraphType(); // get arguments from attributes var arguments = new QueryArguments(field.GetQueryArguments()); // construct resolving method Func <ResolveFieldContext <object>, object> resolve = (context) => { return(((Delegate)(field.GetValue(this))).GetMethodInfo().Invoke(this, new object[] { context })); }; // handle authentication and authorization var isAuthenticationRequired = field.GetAttribute <FieldAttribute>().IsAuthenticationRequired; var requiredRoles = field.GetRequiredRoles(); var graphQLField = this.Field(graphType, field.Name.ToFirstLower(), null, arguments, resolve); graphQLField.RequiresRoles(requiredRoles); graphQLField.RequiresAuthentication(isAuthenticationRequired); }
public ClientType(ALBData data) { Name = "Client"; Description = "A client - person or organisation"; Field <NonNullGraphType <StringGraphType> >("reference", "The reference of the client."); Field <StringGraphType>("name", "The name of the client."); var arguments = new QueryArguments( new[] { new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "reference", Description = "reference of the matter" } }); Field <ListGraphType <MatterType> >("matters", "The matters for the client", arguments, resolve: context => data.GetMattersForClient(context.Source as Client, (string)context.Arguments["reference"])); IsTypeOf = value => value is Client; }
public CreateEventMutation() : base("createEvent", "Creates a new event.") { var queryArgumentArray = new List <QueryArgument>(); queryArgumentArray.Add(new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "name", Description = "The name of the event to create" }); queryArgumentArray.Add(new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "description", Description = "The description of the event." }); queryArgumentArray.Add(new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "date", Description = "The date of the event." }); queryArgumentArray.Add(new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "location", Description = "The location of the event." }); queryArgumentArray.Add(new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "group_id", Description = "The group this event belongs to." }); Arguments = new QueryArguments(queryArgumentArray); }
public FieldType ExtendableField <TGraphType>( string name, string description = null, QueryArguments arguments = null, Func <IResolveFieldContext <TSourceType>, object> resolve = null, string deprecationReason = null) where TGraphType : IGraphType { return(AddField(new FieldType { Name = name, Description = description, DeprecationReason = deprecationReason, Type = GraphTypeExtenstionHelper.GetActualComplexType <TGraphType>(), Arguments = arguments, Resolver = resolve != null ? new FuncFieldResolver <TSourceType, object>(context => { context.CopyArgumentsToUserContext(); return resolve(context); }) : null })); }
public void WhenDatabaseIsQueriedWithMultipleArgsValuesThenCorrectResults() { //Arrange InsertRegistrations(); var args = new QueryArguments { FromDate = new DateTime(2007, 1, 1), ToDate = new DateTime(2007, 12, 31), Project = "Past project", Customer = "Customer2", Hours = 6 }; //Act var result = _registrationRepository.Get(args); //Assert Assert.That(result.ToList().Count, Is.EqualTo(1)); Assert.True(result.All(reg => reg.Date >= args.FromDate && reg.Date <= args.ToDate && string.Equals(reg.Project, args.Project) && string.Equals(reg.Customer, args.Customer) && reg.Hours == args.Hours)); }
private dynamic GetInternalListInstances(ColumnMetadata columnMetadata, QueryArguments queryThirdArguments = null) { var metaTable = _dbMetadata.GetTableMetadatas().FirstOrDefault(x => x.Type.Name == columnMetadata.Type.Name); dynamic listGraphType = null; if (!_tableNameLookup.ExistSecondListGraphType($"{columnMetadata.ColumnName}_second_list")) { var tableType = GetThirdGraphType(metaTable, columnMetadata, queryThirdArguments); var inherateListType = typeof(ListGraphType <>).MakeGenericType(new Type[] { tableType.GetType() }); listGraphType = Activator.CreateInstance(inherateListType); listGraphType.ResolvedType = tableType; } else { foreach (var tableColumn in metaTable.Columns) { FillArguments(queryThirdArguments, tableColumn.ColumnName, tableColumn.Type); } } return(_tableNameLookup.GetOrInsertSecondListGraphType($"{columnMetadata.ColumnName}_second_list", listGraphType)); }
protected override IQueryOver <Invoice, Invoice> BuildQuery(IQueryOver <Invoice, Invoice> query, QueryArguments args) { return(query); }
protected abstract IQueryOver <TModel, TModel> BuildQuery(IQueryOver <TModel, TModel> query, QueryArguments args);
public virtual IEnumerable <TModel> Get(QueryArguments args) { return(BuildQuery(_session.QueryOver <TModel>(), args) .List()); }
public Subscription(IHttpContextAccessor accessor) { var todoArguments = new QueryArguments( new QueryArgument(typeof(StringGraphType)) { Name = "searchText" }, new QueryArgument(typeof(StringGraphType)) { Name = "assignedUser" } ); AddField(new EventStreamFieldType { Name = "todoAdded", Type = typeof(TodoType), Arguments = todoArguments, Resolver = new FuncFieldResolver <KeyValuePair <Id, Tuple <Todo, Id> > >(ctx => (KeyValuePair <Id, Tuple <Todo, Id> >)ctx.Source), Subscriber = new EventStreamResolver <object>(ctx => { var searchText = ctx.GetArgument <string>("searchText"); var assignedUser = ctx.GetArgument <string>("assignedUser"); var observer = accessor .GetService <GenericObservable <AddTodosCommand, Tuple <Todo, Id> > >(); return(WithParameters(observer, searchText, assignedUser) .Select(x => x as object) .AsObservable()); }) }); AddField(new EventStreamFieldType { Name = "todoUpdated", Type = typeof(TodoType), Arguments = todoArguments, Resolver = new FuncFieldResolver <KeyValuePair <Id, Tuple <Todo, Id> > >(ctx => (KeyValuePair <Id, Tuple <Todo, Id> >)ctx.Source), Subscriber = new EventStreamResolver <object>(ctx => { var searchText = ctx.GetArgument <string>("searchText"); var assignedUser = ctx.GetArgument <string>("assignedUser"); var observer = accessor .GetService <GenericObservable <UpdateTodosCommand, Tuple <Todo, Id> > >(); return(WithParameters(observer, searchText, assignedUser) .Select(x => x as object) .AsObservable()); }) }); AddField(new EventStreamFieldType { Name = "todoDeleted", Type = typeof(TodoType), Arguments = todoArguments, Resolver = new FuncFieldResolver <KeyValuePair <Id, Tuple <Todo, Id> > >(ctx => (KeyValuePair <Id, Tuple <Todo, Id> >)ctx.Source), Subscriber = new EventStreamResolver <object>(ctx => { var searchText = ctx.GetArgument <string>("searchText"); var assignedUser = ctx.GetArgument <string>("assignedUser"); var observer = accessor .GetService <GenericObservable <DeleteTodosCommand, Tuple <Todo, Id> > >(); return(WithParameters(observer, searchText, assignedUser) .Select(x => x as object) .AsObservable()); }) }); AddField(new EventStreamFieldType { Name = "userAdded", Type = typeof(UserType), Resolver = new FuncFieldResolver <KeyValuePair <Id, User> >(ctx => (KeyValuePair <Id, User>)ctx.Source), Subscriber = new EventStreamResolver <object>(ctx => accessor .GetService <GenericObservable <SignInCommand, User> >() .Select(x => x as object) .AsObservable() ) }); }
public void ConstructorSetsTheDefaultValues() { var args = new QueryArguments(); Assert.AreEqual(DataDefinitions.Both, args.DataToInclude); }
public Dictionary<string, object> GetArgumentValues(Schema schema, QueryArguments definitionArguments, Arguments astArguments, Variables variables) { if (definitionArguments == null || !definitionArguments.Any()) { return null; } return definitionArguments.Aggregate(new Dictionary<string, object>(), (acc, arg) => { var value = astArguments != null ? astArguments.ValueFor(arg.Name) : null; var coercedValue = CoerceValueAst(schema, schema.FindType(arg.Type), value, variables); acc[arg.Name] = coercedValue ?? arg.DefaultValue; return acc; }); }
public static FieldType RemoteField <TSourceType>(this ComplexGraphType <TSourceType> self, IEnumerable <Type> types, string remoteMoniker, string typeName, string name, string description = null, QueryArguments arguments = null, Func <ResolveFieldContext <TSourceType>, object> resolve = null, string deprecationReason = null) { var type = types.FirstOrDefault(t => t.GetCustomAttributes(true).Any(a => a is RemoteLiteralGraphTypeMetadataAttribute metadata && metadata.RemoteMoniker == remoteMoniker && metadata.Name == typeName)); if (type == null) { throw new ArgumentException($"Couldn't find a type in {nameof(types)} with remote '{remoteMoniker}' and name '{name}'"); } return(self.Field(type, name, description, arguments, resolve, deprecationReason)); }
public LinkDirective() : base("link", new[] { DirectiveLocation.FieldDefinition, DirectiveLocation.Object, DirectiveLocation.Interface }) { Arguments = new QueryArguments(new QueryArgument <NonNullGraphType <UriGraphType> > { Name = "url" }); }
public static void AddField(IContainer container, ComplexGraphType <Object> obj, Type type, PropertyInfo propertyInfo, MethodInfo methodInfo) { if (propertyInfo.PropertyType == typeof(IContainer)) { return; } var fieldType = propertyInfo.PropertyType; var fieldName = propertyInfo.Name.ToCamelCase(); var fieldDescription = ""; var authFieldName = $"{type.FullName}.{propertyInfo.Name}"; var sourceType = type.BaseType?.GenericTypeArguments.FirstOrDefault() ?? type; QueryArguments arguments = null; Func <ResolveFieldContext <object>, object> contextResolve; if (methodInfo != null) { arguments = GetPropertyArguments(sourceType, methodInfo); // Custom mapping of property contextResolve = context => { AuthorizeProperty(container, authFieldName); var sourceResolverInfo = container.GetInstance <ResolverInfoManager>().Create(context).First(); var output = methodInfo.Invoke(obj, GetArgumentValues(methodInfo, container, context, sourceResolverInfo)); output = container.GetInstance <ApiSchema>().PropertyFilterManager.Filter(sourceResolverInfo, propertyInfo, authFieldName, output); var baseType = TypeLoader.GetBaseType(output?.GetType(), out var isList); if (output != null && !baseType.IsValueType) { container.GetInstance <ResolverInfoManager>().Create(context, output, sourceResolverInfo); } return(output); }; } else { // 1 to 1 mapping of property to source contextResolve = context => { AuthorizeProperty(container, authFieldName); var properties = context.Source.GetType().GetProperties(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public); var sourceProp = properties.FirstOrDefault(p => p.Name == propertyInfo.Name); if (sourceProp == null) { throw new ArgumentException($"No matching source property found for GraphObject. Type: {type.Name} Property: {propertyInfo.Name}"); } var output = sourceProp.GetValue(context.Source); var sourceResolverInfo = container.GetInstance <ResolverInfoManager>().Create(context).First(); output = container.GetInstance <ApiSchema>().PropertyFilterManager.Filter(sourceResolverInfo, propertyInfo, authFieldName, output); var baseType = TypeLoader.GetBaseType(output?.GetType(), out var isList); if (output != null && !baseType.IsValueType) { container.GetInstance <ResolverInfoManager>().Create(context, output, sourceResolverInfo); } return(output); }; } var graphType = TypeLoader.GetGraphType(fieldType); var nonNull = Enumerable.Any(propertyInfo.CustomAttributes, a => a.AttributeType == typeof(RequiredAttribute)); if (nonNull) { graphType = typeof(NonNullGraphType <>).MakeGenericType(graphType); } var field = obj.Field(graphType, fieldName, fieldDescription, arguments, contextResolve); //field.ResolvedType = (IGraphType)Activator.CreateInstance(graphType); container.GetInstance <AuthorizationMap>().AddAuthorization(type, propertyInfo); }
public Dictionary<string, object> GetArgumentValues(ISchema schema, QueryArguments definitionArguments, Arguments astArguments, Variables variables) { if (definitionArguments == null || !definitionArguments.Any()) { return null; } return definitionArguments.Aggregate(new Dictionary<string, object>(), (acc, arg) => { var value = astArguments != null ? astArguments.ValueFor(arg.Name) : null; var type = schema.FindType(arg.Type); if (value is Variable) { var variable = (Variable) value; value = variables.ValueFor(variable.Name); } object coercedValue = null; if (IsValidValue(schema, type, value)) { coercedValue = CoerceValue(schema, type, value, variables); } acc[arg.Name] = coercedValue ?? arg.DefaultValue; return acc; }); }
public SkipDirective() : base("skip", new[] { DirectiveLocation.Field, DirectiveLocation.FragmentSpread, DirectiveLocation.InlineFragment }) { Description = "Directs the executor to skip this field or fragment when the 'if' argument is true."; Arguments = new QueryArguments(new QueryArgument<NonNullGraphType<BooleanGraphType>> { Name = "if", Description = "Skipped when true." }); }
public DreamerQuery(DatabaseContext databaseContext, DatabaseContext userDatabaseContext, VolontierDreamerExpressions volontierDreamerExpressions, VolontierUserExpressions volontierUserExpressions) { Name = "DreamerQuery"; var arguments = new QueryArguments(new List <QueryArgument> { new QueryArgument <IdGraphType> { Name = "dreamerId" }, new QueryArgument <StringGraphType> { Name = "searchName" } }); var userArguments = new QueryArguments(new List <QueryArgument> { new QueryArgument <IdGraphType> { Name = "userId" }, }); Field <ListGraphType <UserType> >("users", arguments: userArguments, resolve: context => { var userQuery = userDatabaseContext.Users.Where(_volontierUserExpressions.UserQuery); var userId = context.GetArgument <int?>("userId"); if (userId.HasValue) { return(userQuery.Where(u => u.UserId == userId).ToListAsync()); } return(userQuery.ToListAsync()); }); Field <ListGraphType <DreamerType> >("dreamers", arguments: arguments, resolve: context => { var dreamerQuery = databaseContext.Dreamers .Include(d => d.Dreams) .ThenInclude(d => d.DreamCategory) .Include(d => d.Dreams) .ThenInclude(d => d.RequiredSteps) .Where(_volontierDreamerExpressions.DreamersQuery); var dreamerId = context.GetArgument <int?>("dreamerId"); if (dreamerId.HasValue) { return(dreamerQuery.Where(d => d.DreamerId == dreamerId).ToListAsync()); } var searchName = context.GetArgument <string>("searchName"); if (!string.IsNullOrEmpty(searchName)) { return(dreamerQuery.Where(d => (d.FirstName + d.LastName).Contains(searchName)).ToListAsync()); } return(dreamerQuery.ToListAsync()); }); _volontierDreamerExpressions = volontierDreamerExpressions; _volontierUserExpressions = volontierUserExpressions; }
public static void Field( this IObjectGraphType obj, string name, IGraphType type, string description = null, QueryArguments arguments = null, Func<ResolveFieldContext, object> resolve = null) { var field = new FieldType(); field.Name = name; field.Description = description; field.Arguments = arguments; field.ResolvedType = type; field.Resolver = resolve != null ? new FuncFieldResolver<object>(resolve) : null; obj.AddField(field); }
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 { new QueryArgument <StringGraphType> { Name = "all" }, //new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "param" } }; } 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" }); } 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> /// 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 queryWorker_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e) { QueryArguments arg = e.Result as QueryArguments; if (arg != null) { if (arg.RawXmlResults == null) { DataGridView grid = dataGridView1; if (grid != null) { DataTable table = arg.Results; grid.AutoGenerateColumns = false; grid.Columns.Clear(); foreach (DataColumn column in table.Columns) { var columnIndex = grid.Columns.Add(column.ColumnName, column.ColumnName); grid.Columns[columnIndex].DataPropertyName = column.ColumnName; } grid.DataSource = arg.Results; } queryStatusBar1.UpdateValues(arg.Results.Rows.Count, arg.QueryTime, (long?)arg.Results.ExtendedProperties["TotalRows"]); queryStatusBar1.UpdateStatusLabel("Ready"); RawXmlTabVisible = false; ResultsTabVisible = true; } else { rawXmlBrowser.XmlDocument = arg.RawXmlResults; RawXmlTabVisible = true; ResultsTabVisible = false; queryStatusBar1.UpdateValues(0, arg.QueryTime); queryStatusBar1.UpdateStatusLabel("Ready"); } if (arg.Errors != null) { XmlDocument document = new XmlDocument(); var errorXElement = new XElement("errors", from error in arg.Errors select new XElement("error", new XElement("errorType", error.ErrorType), new XElement("context", error.Context), new XElement("message", error.Message) )); using (var xmlReader = errorXElement.CreateReader()) { document.Load(xmlReader); } errorMessagesBrowser.XmlDocument = document; ErrorMessageTabVisible = true; } else { ErrorMessageTabVisible = false; } ShowQueryPlan(arg.QueryPlan); ShowLog(arg.Log); } else if (e.Result is QueryErrorResult) { var error = (QueryErrorResult)e.Result; queryStatusBar1.UpdateValues(0, TimeSpan.Zero); queryStatusBar1.UpdateStatusLabel("Error"); RawXmlTabVisible = false; ResultsTabVisible = false; QueryPlanTabVisible = false; ShowLog(error.Log); MessageBox.Show(this, error.ErrorMessage, "SWQL Studio", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } }
public GraphQLDeprecatedDirective() : base("deprecated", new[] { DirectiveLocation.FieldDefinition, DirectiveLocation.EnumValue }) { Description = "Marks an element of a GraphQL schema as no longer supported."; Arguments = new QueryArguments(new QueryArgument<NonNullGraphType<BooleanGraphType>> { Name = "reason", Description = "Explains why this element was deprecated, usually also including a " + "suggestion for how to access supported similar data. Formatted " + "in [Markdown](https://daringfireball.net/projects/markdown/).", DefaultValue = "No longer supported" }); }
public Dictionary<string, object> GetArgumentValues(ISchema schema, QueryArguments definitionArguments, Arguments astArguments, Variables variables) { if (definitionArguments == null || !definitionArguments.Any()) { return null; } return definitionArguments.Aggregate(new Dictionary<string, object>(), (acc, arg) => { var value = astArguments?.ValueFor(arg.Name); var type = arg.ResolvedType; var coercedValue = CoerceValue(schema, type, value, variables); coercedValue = coercedValue ?? arg.DefaultValue; acc[arg.Name] = coercedValue; return acc; }); }