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);
        }
Esempio n. 5
0
 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"]);
 }
Esempio n. 6
0
        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);
        }
Esempio n. 9
0
    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);
        }
Esempio n. 12
0
 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);
        }
Esempio n. 14
0
        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());
        }
Esempio n. 18
0
        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);
        }
Esempio n. 19
0
        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;
        }
Esempio n. 20
0
        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);
        }
Esempio n. 21
0
 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));
        }
Esempio n. 23
0
        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));
        }
Esempio n. 24
0
 protected override IQueryOver <Invoice, Invoice> BuildQuery(IQueryOver <Invoice, Invoice> query, QueryArguments args)
 {
     return(query);
 }
Esempio n. 25
0
 protected abstract IQueryOver <TModel, TModel> BuildQuery(IQueryOver <TModel, TModel> query, QueryArguments args);
Esempio n. 26
0
 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;
            });
        }
Esempio n. 30
0
        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);
        }
Esempio n. 33
0
        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;
            });
        }
Esempio n. 34
0
 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."
     });
 }
Esempio n. 35
0
        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));
                            }
Esempio n. 39
0
        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 void ConstructorSetsTheDefaultValues()
        {
            var args = new QueryArguments();

            Assert.AreEqual(DataDefinitions.Both, args.DataToInclude);
        }
Esempio n. 41
0
 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"
     });
 }
Esempio n. 42
0
        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;
            });
        }