Exemple #1
0
 public SchemaBuilder(DbConnection connection, DbTransaction transaction, string tablePrefix)
 {
     _builder = SchemaBuilderFactory.For(connection);
     _tablePrefix = tablePrefix;
     Connection = connection;
     Transaction = transaction;
 }
		private DataServiceController(DSConfiguration settings, CustomAuthorizationHandler.ICustomContextStore customContextStore, ISchemaBuilder testSchemaBuilder)
		{
			TraceHelper.Current.CorrelateWithActivity(EtwActivity.GetActivityId());
			try
			{
				this.Configuration = settings;
				this.cmdManagers = new Dictionary<ManagementSystemType, ICommandManager>();
				this.PerfCounters = new PerfCounters(CurrentRequestHelper.EndPointAddress);
				this.UserDataCache = new UserDataCache(this.Configuration.Invocation.Lifetime);
				this.QuotaSystem = new QuotaSystem();
				InitialSessionStateManager initialSessionStateManager = new InitialSessionStateManager(this.Configuration.PowerShell.SessionConfig.Assembly, this.Configuration.PowerShell.SessionConfig.Type);
				this.intialSessionStateStore = new SharedItemStore<InitialSessionState, UserContext>(initialSessionStateManager, this.Configuration.Quotas.UserSchemaTimeout, this.Configuration.Quotas.MaxUserSchemas);
				PSRunspaceFactory pSRunspaceFactory = new PSRunspaceFactory(this.intialSessionStateStore, true);
				int runspaceTimeout = this.Configuration.PowerShell.Quotas.RunspaceTimeout;
				ExclusiveItemStore<PSRunspace, UserContext> exclusiveItemStore = new ExclusiveItemStore<PSRunspace, UserContext>(pSRunspaceFactory, runspaceTimeout, this.Configuration.PowerShell.Quotas.MaxRunspaces);
				PSCommandManager pSCommandManager = new PSCommandManager(exclusiveItemStore);
				this.cmdManagers.Add(ManagementSystemType.PowerShell, pSCommandManager);
				PSRunspaceFactory pSRunspaceFactory1 = new PSRunspaceFactory(this.intialSessionStateStore, false);
				ExclusiveItemStore<PSRunspace, UserContext> exclusiveItemStore1 = new ExclusiveItemStore<PSRunspace, UserContext>(pSRunspaceFactory1, runspaceTimeout, this.Configuration.PowerShell.Quotas.MaxRunspaces);
				this.cmdManagers.Add(ManagementSystemType.GenericInvoke, new GICommandManager(exclusiveItemStore1));
				List<ISchemaBuilder> schemaBuilders = new List<ISchemaBuilder>();
				if (testSchemaBuilder != null)
				{
					schemaBuilders.Add(testSchemaBuilder);
				}
				schemaBuilders.Add(new PSSchemaBuilder(exclusiveItemStore));
				schemaBuilders.Add(new GISchemaBuilder());
				SchemaFactory schemaFactory = new SchemaFactory(this.Configuration.SchemaFileName, this.Configuration.ResourceMappingFileName, schemaBuilders, settings);
				this.schemaStore = new SharedItemStore<Microsoft.Management.Odata.Schema.Schema, UserContext>(schemaFactory, this.Configuration.Quotas.UserSchemaTimeout, this.Configuration.Quotas.MaxUserSchemas);
				this.customAuthorizationHandler = new CustomAuthorizationHandler(this.Configuration.CustomAuthorization.Assembly, this.Configuration.CustomAuthorization.Type, customContextStore);
			}
			catch (Exception exception1)
			{
				Exception exception = exception1;
				TraceHelper.Current.DataServiceControllerCreationFailedOperational(exception.Message);
				if (TraceHelper.IsEnabled(5))
				{
					TraceHelper.Current.DebugMessage(exception.ToTraceMessage("DataServiceController failed to create"));
				}
				if (this.PerfCounters != null)
				{
					this.PerfCounters.Dispose();
				}
				throw;
			}
			TraceHelper.Current.DataServiceControllerCreationSucceeded();
		}
Exemple #3
0
        protected ISchema CreateSchemaWith(
            IFilterInputType type,
            FilterConvention convention,
            params FilterConventionExtension[] extensions)
        {
            ISchemaBuilder builder = SchemaBuilder.New()
                                     .AddConvention <IFilterConvention>(convention)
                                     .AddFiltering()
                                     .AddQueryType(
                c =>
                c.Name("Query")
                .Field("foo")
                .Type <StringType>()
                .Resolver("bar"))
                                     .AddType(type);

            foreach (var extension in extensions)
            {
                builder.AddConvention <IFilterConvention>(extension);
            }

            return(builder.Create());
        }
    protected ExecutorBuilder CreateProviderTester <TRuntimeType>(
        SortInputType <TRuntimeType> type,
        SortConvention?convention = null)
    {
        convention ??=
        new SortConvention(
            x => x.AddDefaults().BindRuntimeType(typeof(TRuntimeType), type.GetType()));

        ISchemaBuilder builder = SchemaBuilder.New()
                                 .AddConvention <ISortConvention>(convention)
                                 .TryAddTypeInterceptor <SortTypeInterceptor>()
                                 .AddQueryType(
            c =>
            c.Name("Query")
            .Field("foo")
            .Type <StringType>()
            .Resolve("bar"))
                                 .AddType(type);

        builder.Create();

        return(new ExecutorBuilder(type));
    }
Exemple #5
0
        private static void BuildNameLookup(
            IDescriptorContext context,
            ISchemaBuilder schemaBuilder,
            DocumentNode document,
            ICollection <NameString> schemaNames)
        {
            Dictionary <(NameString Type, NameString TargetSchema), NameString> nameLookup =
                new Dictionary <(NameString, NameString), NameString>();

            foreach (INamedSyntaxNode type in document.Definitions.OfType <INamedSyntaxNode>())
            {
                foreach (DirectiveNode directive in type.Directives
                         .Where(t => t.Name.Value.EqualsOrdinal(DirectiveNames.Source)))
                {
                    if (directive.Arguments.FirstOrDefault(
                            t => t.Name.Value.EqualsOrdinal(Source_Schema))?.Value
                        is StringValueNode schema &&
                        directive.Arguments.FirstOrDefault(
                            t => t.Name.Value.EqualsOrdinal(Source_Name))?.Value
                        is StringValueNode name &&
                        !name.Value.EqualsOrdinal(type.Name.Value))
                    {
                        nameLookup[(type.Name.Value, schema.Value)] = name.Value;
        protected IRequestExecutor CreateSchema <TEntity, T>(
            TEntity[] entities,
            FilterConvention?convention = null)
            where TEntity : class
            where T : FilterInputType <TEntity>
        {
            convention ??= new FilterConvention(x => x.AddDefaults().BindRuntimeType <TEntity, T>());

            Func <IResolverContext, IEnumerable <TEntity> >?resolver = BuildResolver(entities);

            ISchemaBuilder builder = SchemaBuilder.New()
                                     .AddConvention <IFilterConvention>(convention)
                                     .AddFiltering()
                                     .AddQueryType(c => c
                                                   .Name("Query")
                                                   .Field("root")
                                                   .Resolver(resolver)
                                                   .UseFiltering <T>());

            ISchema?schema = builder.Create();

            return(schema.MakeExecutable());
        }
Exemple #7
0
    protected ISchema CreateSchemaWithTypes(
        ISortInputType type,
        SortConvention convention,
        params Type[] extensions)
    {
        ISchemaBuilder builder = SchemaBuilder.New()
                                 .AddConvention <ISortConvention>(convention)
                                 .AddSorting()
                                 .AddQueryType(
            c =>
            c.Name("Query")
            .Field("foo")
            .Type <StringType>()
            .Resolve("bar"))
                                 .AddType(type);

        foreach (Type?extension in extensions)
        {
            builder.AddConvention <ISortConvention>(extension);
        }

        return(builder.Create());
    }
 public static ISchemaBuilder AddTypes(this ISchemaBuilder builder)
 {
     builder
     .AddType <MediaTypeEnum>()
     .AddType <InterviewType> ()
     .AddType <UserType> ()
     .AddType <MultipleChoiceQuestionType>()
     .AddType <TextQuestionType>()
     .AddType <RangeQuestionType>()
     .AddType <TextAnswerFormatType>()
     .AddType <VideoAnswerFormatType>()
     .AddType <AudioAnswerFormatType>()
     .AddType <RangeOptionInputType>()
     .AddType <AttachmentInputType>()
     .AddType <OptionInputType>()
     .AddType <TextQuestionInputType>()
     .AddType <InterchangeTemplateCreateCommandInputType>()
     .AddType <InterviewRoundCreateCommandInputType>()
     .AddType <InterviewCreateCommandInputType>()
     .AddQueryType <RootQuery>()
     .AddMutationType <Mutation>();
     return(builder);
 }
        protected ISchema CreateSchema <T>(T type)
            where T : IFilterInputType
        {
            var convention = new FilterConvention(x => x
                                                  .AddDefaults()
                                                  .AddSpatialOperations()
                                                  .BindSpatialTypes()
                                                  .Provider(
                                                      new QueryableFilterProvider(
                                                          p => p.AddSpatialHandlers().AddDefaultFieldHandlers())));

            ISchemaBuilder builder = SchemaBuilder.New()
                                     .AddConvention <IFilterConvention>(convention)
                                     .TryAddTypeInterceptor <FilterTypeInterceptor>()
                                     .AddQueryType(c => c
                                                   .Name("Query")
                                                   .Field("foo")
                                                   .Type <StringType>()
                                                   .Resolver("bar"))
                                     .AddType(type);

            return(builder.Create());
        }
        private async ValueTask <ISchema> CreateSchemaAsync(
            NameString schemaName,
            RequestExecutorSetup options,
            IServiceProvider serviceProvider,
            CancellationToken cancellationToken)
        {
            if (options.Schema is not null)
            {
                AssertSchemaNameValid(options.Schema, schemaName);
                return(options.Schema);
            }

            ISchemaBuilder schemaBuilder = options.SchemaBuilder ?? new SchemaBuilder();

            schemaBuilder.AddServices(serviceProvider);

            foreach (SchemaBuilderAction action in options.SchemaBuilderActions)
            {
                if (action.Action is { } configure)
                {
                    configure(serviceProvider, schemaBuilder);
                }

                if (action.AsyncAction is { } configureAsync)
                {
                    await configureAsync(serviceProvider, schemaBuilder, cancellationToken)
                    .ConfigureAwait(false);
                }
            }

            schemaBuilder.TryAddTypeInterceptor(new SetSchemaNameInterceptor(schemaName));

            ISchema schema = schemaBuilder.Create();

            AssertSchemaNameValid(schema, schemaName);
            return(schema);
        }
        public async Task InitializeAsync(IStore store, ISchemaBuilder builder)
        {
            _dialect     = SqlDialectFactory.For(store.Configuration.ConnectionFactory.DbConnectionType);
            _tablePrefix = store.Configuration.TablePrefix;
            _store       = store;

            SelectCommand = "SELECT " + _dialect.QuoteForColumnName("nextval") + " FROM " + _dialect.QuoteForTableName(_tablePrefix + TableName) + " WHERE " + _dialect.QuoteForTableName("dimension") + " = " + _dialect.QuoteForParameter("dimension") + _dialect.StatementEnd;
            UpdateCommand = "UPDATE " + _dialect.QuoteForTableName(_tablePrefix + TableName) + " SET " + _dialect.QuoteForColumnName("nextval") + " = " + _dialect.QuoteForParameter("new") + " WHERE " + _dialect.QuoteForColumnName("nextval") + " = " + _dialect.QuoteForParameter("previous") + " AND " + _dialect.QuoteForColumnName("dimension") + " = " + _dialect.QuoteForParameter("dimension") + _dialect.StatementEnd;
            InsertCommand = "INSERT INTO " + _dialect.QuoteForTableName(_tablePrefix + TableName) + " (" + _dialect.QuoteForColumnName("dimension") + ", " + _dialect.QuoteForColumnName("nextval") + ") VALUES(" + _dialect.QuoteForParameter("dimension") + ", " + _dialect.QuoteForParameter("nextval") + ")" + _dialect.StatementEnd;

            using (var connection = store.Configuration.ConnectionFactory.CreateConnection())
            {
                await connection.OpenAsync();

                try
                {
                    using (var transaction = connection.BeginTransaction())
                    {
                        var localBuilder = new SchemaBuilder(store.Configuration, transaction, false);

                        localBuilder.CreateTable(DbBlockIdGenerator.TableName, table => table
                                                 .Column <string>("dimension", column => column.PrimaryKey().NotNull())
                                                 .Column <ulong>("nextval")
                                                 )
                        //.AlterTable(DbBlockIdGenerator.TableName, table => table //FIXME Oracle
                        //    .CreateIndex("IX_Dimension", "dimension")
                        //)
                        ;

                        transaction.Commit();
                    }
                }
                catch
                {
                }
            }
        }
Exemple #12
0
    protected IRequestExecutor CreateSchema <TEntity, T>(
        TEntity?[] entities,
        SortConvention?convention         = null,
        Action <ISchemaBuilder>?configure = null)
        where TEntity : class
        where T : SortInputType <TEntity>
    {
        convention ??= new SortConvention(x => x.AddDefaults().BindRuntimeType <TEntity, T>());

        Func <IResolverContext, IEnumerable <TEntity> >?resolver = BuildResolver(entities !);

        ISchemaBuilder builder = SchemaBuilder.New()
                                 .AddConvention <ISortConvention>(convention)
                                 .AddSorting()
                                 .AddQueryType(
            c =>
        {
            c
            .Name("Query")
            .Field("root")
            .Resolve(resolver)
            .UseSorting <T>();

            c
            .Name("Query")
            .Field("rootExecutable")
            .Resolve(ctx => resolver(ctx).AsExecutable())
            .UseSorting <T>();
        });

        configure?.Invoke(builder);

        ISchema?schema = builder.Create();

        return(schema.MakeExecutable());
    }
Exemple #13
0
        public static ISchemaBuilder AddSchemaRegistry(
            this ISchemaBuilder builder,
            bool addRootTypes = true)
        {
            if (addRootTypes)
            {
                builder
                .AddQueryType(d => d.Name("Query"))
                .AddMutationType(d => d.Name("Mutation"))
                .AddSubscriptionType(d => d.Name("Subscription"));
            }

            return(builder
                   .AddType <EnvironmentQueries>()
                   .AddType <EnvironmentMutations>()
                   .AddType <SchemaQueries>()
                   .AddType <SchemaMutations>()
                   .AddType <SchemaSubscriptions>()
                   .AddType <SchemaExtension>()
                   .AddType <SchemaVersionExtension>()
                   .AddType <SchemaPublishReportExtension>()
                   .BindClrType <string, StringType>()
                   .BindClrType <Guid, IdType>());
        }
        public async Task InitializeAsync(IStore store, ISchemaBuilder builder)
        {
            _dialect     = store.Dialect;
            _tablePrefix = store.Configuration.TablePrefix;
            _store       = store;

            SelectCommand = "SELECT " + _dialect.QuoteForColumnName("nextval") + " FROM " + _dialect.QuoteForTableName(_tablePrefix + TableName) + " WHERE " + _dialect.QuoteForTableName("dimension") + " = @dimension;";
            UpdateCommand = "UPDATE " + _dialect.QuoteForTableName(_tablePrefix + TableName) + " SET " + _dialect.QuoteForColumnName("nextval") + "=@new WHERE " + _dialect.QuoteForColumnName("nextval") + " = @previous AND " + _dialect.QuoteForColumnName("dimension") + " = @dimension;";
            InsertCommand = "INSERT INTO " + _dialect.QuoteForTableName(_tablePrefix + TableName) + " (" + _dialect.QuoteForColumnName("dimension") + ", " + _dialect.QuoteForColumnName("nextval") + ") VALUES(@dimension, @nextval);";

            using (var connection = store.Configuration.ConnectionFactory.CreateConnection())
            {
                await connection.OpenAsync();

                try
                {
                    using (var transaction = connection.BeginTransaction(store.Configuration.IsolationLevel))
                    {
                        var localBuilder = new SchemaBuilder(store.Configuration, transaction, false);

                        localBuilder.CreateTable(DbBlockIdGenerator.TableName, table => table
                                                 .Column <string>("dimension", column => column.PrimaryKey().NotNull())
                                                 .Column <ulong>("nextval")
                                                 )
                        .AlterTable(DbBlockIdGenerator.TableName, table => table
                                    .CreateIndex("IX_Dimension", "dimension")
                                    );

                        transaction.Commit();
                    }
                }
                catch
                {
                }
            }
        }
        public void Convention_DefaultScope_Extensions_Enum()
        {
            // arrange
            // act
            var convention = new SortConvention(
                x => x.UseMock()
                .ConfigureEnum <DefaultSortEnumType>(y => y.Operation(123))
                .Operation(123).Name("test"));

            ISchemaBuilder builder = SchemaBuilder.New()
                                     .AddConvention <ISortConvention>(convention)
                                     .TryAddTypeInterceptor <SortTypeInterceptor>()
                                     .AddQueryType(c =>
                                                   c.Name("Query")
                                                   .Field("foo")
                                                   .Type <StringType>()
                                                   .Resolver("bar")
                                                   .Argument("test", x => x.Type <TestSort>()));

            ISchema schema = builder.Create();

            // assert
            schema.ToString().MatchSnapshot();
        }
Exemple #16
0
        public static ISchemaBuilder AddInputObjectType <T>(
            this ISchemaBuilder builder,
            Action <IInputObjectTypeDescriptor <T> > configure)
        {
            if (builder is null)
            {
                throw new ArgumentNullException(nameof(builder));
            }

            if (configure is null)
            {
                throw new ArgumentNullException(nameof(configure));
            }

            if (typeof(T).IsSchemaType() || typeof(T).IsNonGenericSchemaType())
            {
                throw new InvalidOperationException(
                          string.Format(
                              TypeResources.SchemaBuilderExtensions_AddInputObjectType_TIsSchemaType,
                              typeof(T).FullName));
            }

            return(builder.AddType(new InputObjectType <T>(configure)));
        }
Exemple #17
0
        /// <summary>
        /// Adds the ability for this graphql server to raise subscription events that can be published.
        /// </summary>
        /// <typeparam name="TSchema">The type of schema being configured.</typeparam>
        /// <param name="schemaBuilder">The schema builder.</param>
        /// <returns>GraphQL.AspNet.Interfaces.Configuration.ISchemaBuilder&lt;TSchema&gt;.</returns>
        public static ISchemaBuilder <TSchema> AddSubscriptionPublishing <TSchema>(
            this ISchemaBuilder <TSchema> schemaBuilder)
            where TSchema : class, ISchema
        {
            var extension = new SubscriptionPublisherSchemaExtension <TSchema>();

            // register the in-process publisher to the service collection before
            // if one is not already registered
            var defaultPublisher = CreateDefaultSubscriptionPublisherDescriptor();

            extension.OptionalServices.Add(defaultPublisher);

            // register the internal queueing mechanism that will asyncrounously transfer
            // raised events from controller methods to the registered subscription publisher
            schemaBuilder.AsServiceCollection().AddSingleton <SubscriptionEventQueue>();
            schemaBuilder.AsServiceCollection().AddHostedService <SubscriptionPublicationService>();
            schemaBuilder.AsServiceCollection().TryAdd(CreateDefaultSubscriptionRouterDescriptor());

            schemaBuilder.Options.RegisterExtension(extension);
            schemaBuilder.QueryExecutionPipeline.AddMiddleware <PublishRaisedSubscriptionEventsMiddleware <TSchema> >(
                ServiceLifetime.Singleton);

            return(schemaBuilder);
        }
Exemple #18
0
        void UserLogin(ISchemaBuilder builder)
        {
            builder.TableBuilder.CreateTable(_userLogin);

            builder.ProcedureBuilder
            .CreateDefaultProcedures(_userLogin)
            .CreateProcedure(new SchemaProcedure("SelectUserLoginsPaged", StoredProcedureType.SelectPaged)
                             .ForTable(_userLogin)
                             .WithParameters(new List <SchemaColumn>()
            {
                new SchemaColumn()
                {
                    Name   = "LoginProvider",
                    DbType = DbType.String,
                    Length = "128"
                },
                new SchemaColumn()
                {
                    Name   = "ProviderKey",
                    DbType = DbType.String,
                    Length = "128"
                }
            }));
        }
Exemple #19
0
        public static ISchemaBuilder RegisterQuerys(this ISchemaBuilder schemaBuilder)
        {
            schemaBuilder.AddQueryType <ObjectType <UserUseCase> >();

            return(schemaBuilder);
        }
Exemple #20
0
 public void Map(ISchemaBuilder <CustomerRegistered> map)
 {
     map.Name("CustomerRegistered");
 }
Exemple #21
0
        void UserRoles(ISchemaBuilder builder)
        {
            // create tables
            builder.TableBuilder.CreateTable(_userRoles);

            // Create procedures
            builder.ProcedureBuilder.CreateDefaultProcedures(_userRoles)

            // Overwrite our SelectUserRoleById created via CreateDefaultProcedures
            // above to also join and return all role data
            .CreateProcedure(
                new SchemaProcedure(
                    $"SelectUserRoleById",
                    @"
                                SELECT 
                                    ur.Id, 
                                    ur.UserId, 
                                    r.Id AS RoleId, 
                                    r.[Name], 
                                    r.NormalizedName, 
                                    r.Description, 
                                    r.Claims, 
                                    r.CreatedDate, 
                                    r.CreatedUserId, 
                                    r.ModifiedDate, 
                                    r.ModifiedUserId, 
                                    r.ConcurrencyStamp 
                                FROM {prefix}_UserRoles ur WITH (nolock) 
                                INNER JOIN {prefix}_Roles r ON ur.RoleId = r.Id 
                                WHERE (
                                    ur.Id = @Id
                                )")
                .ForTable(_userRoles)
                .WithParameter(_userRoles.PrimaryKeyColumn))

            .CreateProcedure(
                new SchemaProcedure("SelectRolesByUserId", @"
                            SELECT * FROM {prefix}_Roles WITH (nolock) WHERE Id IN (
	                            SELECT RoleId FROM {prefix}_UserRoles WITH (nolock) 
	                            WHERE (
	                               UserId = @UserId
	                            )
                            )
                        ")
                .WithParameter(new SchemaColumn()
            {
                Name   = "UserId",
                DbType = DbType.Int32
            }))

            .CreateProcedure(
                new SchemaProcedure("SelectUserRolesByUserId", StoredProcedureType.SelectByKey)
                .ForTable(_userRoles)
                .WithParameter(new SchemaColumn()
            {
                Name   = "UserId",
                DbType = DbType.Int32
            }))

            .CreateProcedure(new SchemaProcedure("SelectUserRolesPaged", StoredProcedureType.SelectPaged)
                             .ForTable(_userRoles)
                             .WithParameters(new List <SchemaColumn>()
            {
                new SchemaColumn()
                {
                    Name   = "Keywords",
                    DbType = DbType.String,
                    Length = "255"
                },
                new SchemaColumn()
                {
                    Name   = "RoleName",
                    DbType = DbType.String,
                    Length = "255"
                }
            }))

            .CreateProcedure(
                new SchemaProcedure("DeleteUserRolesByUserId", StoredProcedureType.DeleteByKey)
                .ForTable(_userRoles)
                .WithParameter(new SchemaColumn()
            {
                Name   = "UserId",
                DbType = DbType.Int32
            }))

            .CreateProcedure(
                new SchemaProcedure("DeleteUserRoleByUserIdAndRoleId", StoredProcedureType.DeleteByKey)
                .ForTable(_userRoles)
                .WithParameters(new List <SchemaColumn>()
            {
                new SchemaColumn()
                {
                    Name   = "UserId",
                    DbType = DbType.Int32
                },
                new SchemaColumn()
                {
                    Name   = "RoleId",
                    DbType = DbType.Int32
                }
            }));
        }
        protected IRequestExecutor CreateSchema <TEntity, T>(
            TEntity[] entities,
            FilterConvention?convention           = null,
            bool withPaging                       = false,
            Action <ISchemaBuilder>?configure     = null,
            Action <ModelBuilder>?onModelCreating = null)
            where TEntity : class
            where T : FilterInputType <TEntity>
        {
            convention ??= new FilterConvention(x => x.AddDefaults().BindRuntimeType <TEntity, T>());

            Func <IResolverContext, IEnumerable <TEntity> >?resolver =
                BuildResolver(onModelCreating, entities);

            ISchemaBuilder builder = SchemaBuilder.New()
                                     .AddConvention <IFilterConvention>(convention)
                                     .AddFiltering()
                                     .AddQueryType(
                c =>
            {
                ApplyConfigurationToField <TEntity, T>(
                    c.Name("Query").Field("root").Resolve(resolver),
                    withPaging);

                ApplyConfigurationToField <TEntity, T>(
                    c.Name("Query")
                    .Field("rootExecutable")
                    .Resolve(
                        ctx => resolver(ctx).AsExecutable()),
                    withPaging);
            });

            configure?.Invoke(builder);

            ISchema schema = builder.Create();

            return(new ServiceCollection()
                   .Configure <RequestExecutorSetup>(
                       Schema.DefaultName,
                       o => o.Schema = schema)
                   .AddGraphQL()
                   .UseRequest(
                       next => async context =>
            {
                await next(context);
                if (context.Result is IReadOnlyQueryResult result &&
                    context.ContextData.TryGetValue("sql", out var queryString))
                {
                    context.Result =
                        QueryResultBuilder
                        .FromResult(result)
                        .SetContextData("sql", queryString)
                        .Create();
                }
            })
                   .UseDefaultPipeline()
                   .Services
                   .BuildServiceProvider()
                   .GetRequiredService <IRequestExecutorResolver>()
                   .GetRequestExecutorAsync()
                   .Result);
        }
 public static ISchemaBuilder AddExportDirectiveType(
     this ISchemaBuilder builder)
 {
     return(builder.AddDirectiveType <ExportDirectiveType>());
 }
Exemple #24
0
 public SetUpEventHandler(
     ISchemaBuilder schemaBuilder)
 {
     _schemaBuilder = schemaBuilder;
 }
Exemple #25
0
        void Users(ISchemaBuilder builder)
        {
            builder.TableBuilder.CreateTable(_users);
            builder.ProcedureBuilder.CreateDefaultProcedures(_users)

            // Overwrite our SelectEntityById created via CreateDefaultProcedures
            // above to also return all EntityData within a second result set
            .CreateProcedure(
                new SchemaProcedure(
                    $"SelectUserById",
                    @"
                                /* user */
                                SELECT * FROM {prefix}_Users WITH (nolock) 
                                WHERE (
                                   Id = @Id
                                )
                                /* user data */
                                SELECT * FROM {prefix}_UserData WITH (nolock) 
                                WHERE (
                                   UserId = @Id
                                )
                                /* roles */
                                SELECT r.* FROM {prefix}_UserRoles ur WITH (nolock) 
                                INNER JOIN {prefix}_Roles r ON ur.RoleId = r.Id 
                                WHERE (
                                    ur.UserId = @Id
                                )
                                /* logins */
                                SELECT l.* FROM {prefix}_UserLogins l WITH (nolock)                                 
                                WHERE (
                                    l.UserId = @Id
                                )")
                .ForTable(_users)
                .WithParameter(_users.PrimaryKeyColumn))

            .CreateProcedure(new SchemaProcedure("SelectUserByEmail", @"
                            DECLARE @Id int;
                            SET @Id = (SELECT Id FROM {prefix}_Users WITH (nolock) 
                                WHERE (
                                   Email = @Email
                            ))
                            EXEC {prefix}_SelectUserById @id;")
                             .ForTable(_users)
                             .WithParameter(new SchemaColumn()
            {
                Name = "Email", DbType = DbType.String, Length = "255"
            }))


            .CreateProcedure(new SchemaProcedure("SelectUserByEmailNormalized", @"
                            DECLARE @Id int;
                            SET @Id = (SELECT Id FROM {prefix}_Users WITH (nolock) 
                                WHERE (
                                   NormalizedEmail = @NormalizedEmail
                            ))
                            EXEC {prefix}_SelectUserById @id;")
                             .ForTable(_users)
                             .WithParameter(
                                 new SchemaColumn()
            {
                Name = "NormalizedEmail", DbType = DbType.String, Length = "255"
            }))

            .CreateProcedure(new SchemaProcedure("SelectUserByUserName", @"
                            DECLARE @Id int;
                            SET @Id = (SELECT Id FROM {prefix}_Users WITH (nolock) 
                                WHERE (
                                   UserName = @UserName
                            ))
                            EXEC {prefix}_SelectUserById @id;")
                             .ForTable(_users)
                             .WithParameter(new SchemaColumn()
            {
                Name = "UserName", DbType = DbType.String, Length = "255"
            }))

            .CreateProcedure(
                new SchemaProcedure("SelectUserByUserNameNormalized", @"
                            DECLARE @Id int;
                            SET @Id = (SELECT Id FROM {prefix}_Users WITH (nolock) 
                                WHERE (
                                   NormalizedUserName = @NormalizedUserName
                            ))
                            EXEC {prefix}_SelectUserById @id;")
                .ForTable(_users)
                .WithParameter(new SchemaColumn()
            {
                Name   = "NormalizedUserName",
                DbType = DbType.String,
                Length = "255"
            }))

            .CreateProcedure(new SchemaProcedure("SelectUserByApiKey", @"
                            DECLARE @Id int;
                            SET @Id = (SELECT Id FROM {prefix}_Users WITH (nolock) 
                                WHERE (
                                   ApiKey = @ApiKey
                            ))
                            EXEC {prefix}_SelectUserById @id;")
                             .ForTable(_users)
                             .WithParameter(new SchemaColumn()
            {
                Name = "ApiKey", DbType = DbType.String, Length = "255"
            }))

            .CreateProcedure(
                new SchemaProcedure("SelectUserByEmailAndPassword", @"
                            DECLARE @Id int;
                            SET @Id = (SELECT Id FROM {prefix}_Users WITH (nolock) 
                                WHERE (
                                   Email = @Email AND PasswordHash = @PasswordHash
                            ))
                            EXEC {prefix}_SelectUserById @id;")
                .ForTable(_users)
                .WithParameters(new List <SchemaColumn>()
            {
                new SchemaColumn()
                {
                    Name   = "Email",
                    DbType = DbType.String,
                    Length = "255"
                },
                new SchemaColumn()
                {
                    Name   = "PasswordHash",
                    DbType = DbType.String,
                    Length = "255"
                }
            }))

            .CreateProcedure(
                new SchemaProcedure("SelectUserByResetToken", @"
                            DECLARE @Id int;
                            SET @Id = (SELECT Id FROM {prefix}_Users WITH (nolock) 
                                WHERE (
                                   ResetToken = @ResetToken
                            ))
                            EXEC {prefix}_SelectUserById @id;")
                .ForTable(_users)
                .WithParameters(new List <SchemaColumn>()
            {
                new SchemaColumn()
                {
                    Name   = "ResetToken",
                    DbType = DbType.String,
                    Length = "255"
                }
            }))

            .CreateProcedure(
                new SchemaProcedure("SelectUserByConfirmationToken", @"
                            DECLARE @Id int;
                            SET @Id = (SELECT Id FROM {prefix}_Users WITH (nolock) 
                                WHERE (
                                   ConfirmationToken = @ConfirmationToken
                            ))
                            EXEC {prefix}_SelectUserById @id;")
                .ForTable(_users)
                .WithParameters(new List <SchemaColumn>()
            {
                new SchemaColumn()
                {
                    Name   = "ConfirmationToken",
                    DbType = DbType.String,
                    Length = "255"
                }
            }))

            .CreateProcedure(new SchemaProcedure("SelectUsersPaged", StoredProcedureType.SelectPaged)
                             .ForTable(_users)
                             .WithParameters(new List <SchemaColumn>()
            {
                new SchemaColumn()
                {
                    Name   = "Keywords",
                    DbType = DbType.String,
                    Length = "255"
                },
                new SchemaColumn()
                {
                    Name   = "RoleName",
                    DbType = DbType.String,
                    Length = "255"
                }
            }));

            // Indexes
            builder.IndexBuilder.CreateIndex(new SchemaIndex()
            {
                TableName = _users.Name,
                Columns   = new string[]
                {
                    "UserName",
                    "NormalizedUserName",
                    "Email",
                    "NormalizedEmail",
                    "UserType"
                }
            });
        }
Exemple #26
0
 public override ISchemaBuilder AddGraphQlServices(ISchemaBuilder builder)
 {
     return(builder
            .AddQueryType <PermissionQueries>()
            .AddMutationType <PermissionMutations>());
 }
 public void SetUp()
 {
     schema_builder = new NhibernateSchemaBuilder(config);
     table = schema_builder.GetSchema().Tables.FirstOrDefault(x => x.TableName == "Employees");
 }
		public static void CreateDataServiceController(DSConfiguration settings, CustomAuthorizationHandler.ICustomContextStore customContextStore, ISchemaBuilder testSchemaBuilder)
		{
			string filePath;
			lock (DataServiceController.syncObject)
			{
				Configuration configuration = null;
				if (settings == null)
				{
					try
					{
						settings = DSConfiguration.GetSection(configuration);
					}
					catch (Exception exception1)
					{
						Exception exception = exception1;
						Microsoft.Management.Odata.Tracing.Tracer current = TraceHelper.Current;
						string str = "config file is ";
						if (configuration == null)
						{
							filePath = "(not available)";
						}
						else
						{
							filePath = configuration.FilePath;
						}
						current.DebugMessage(string.Concat(str, filePath));
						if (TraceHelper.IsEnabled(5))
						{
							TraceHelper.Current.DebugMessage(exception.ToTraceMessage("DataServiceController failed to create"));
						}
						TraceHelper.Current.DataServiceControllerCreationFailedOperational(exception.Message);
						throw;
					}
				}
				DataServiceController.current = new DataServiceController(settings, customContextStore, testSchemaBuilder);
			}
		}
 /// <summary>
 /// Adds Sorting support.
 /// </summary>
 /// <param name="builder">
 /// The <see cref="ISchemaBuilder"/>.
 /// </param>
 /// <returns>
 /// Returns the <see cref="ISchemaBuilder"/>.
 /// </returns>
 public static ISchemaBuilder AddSorting(this ISchemaBuilder builder) =>
 AddSorting(builder, x => x.AddDefaults());
Exemple #30
0
 public OrderEventUnionSchemaBuilderCase(ISchemaBuilder schemaBuilder)
 {
     this.schemaBuilder = schemaBuilder;
 }
 public static IServiceCollection AddGraphQLSchema(
     this IServiceCollection services,
     ISchemaBuilder builder)
 {
     return(services.AddGraphQLSchema(string.Empty, builder));
 }
Exemple #32
0
 public override ISchemaBuilder AddGraphQlServices(ISchemaBuilder builder)
 {
     return(builder
            .AddQueryType <WebsocketQueries>());
 }
Exemple #33
0
 public override ISchemaBuilder AddGraphQlServices(ISchemaBuilder builder)
 {
     return(builder
            .AddQueryType <PaymentWebhookQueries>());
 }
 public static ISchemaBuilder AddDirectiveType(
     this ISchemaBuilder builder,
     string name,
     DirectiveLocation location) =>
 AddDirectiveType(builder, name, location, x => x);
Exemple #35
0
 public Schema(ISchemaBuilder schemaObjectBuilder)
 {
     TableName = schemaObjectBuilder.GetTableName();
     Name = schemaObjectBuilder.GetName();
     Columns = schemaObjectBuilder.GetColumnCollectionSchema();
 }