/// <summary>
    /// Registers the Entity Framework 6.x stores services in the DI container and
    /// configures OpenIddict to use the Entity Framework 6.x entities by default.
    /// </summary>
    /// <param name="builder">The services builder used by OpenIddict to register new services.</param>
    /// <param name="configuration">The configuration delegate used to configure the Entity Framework 6.x services.</param>
    /// <remarks>This extension can be safely called multiple times.</remarks>
    /// <returns>The <see cref="OpenIddictCoreBuilder"/>.</returns>
    public static OpenIddictCoreBuilder UseEntityFramework(
        this OpenIddictCoreBuilder builder, Action <OpenIddictEntityFrameworkBuilder> configuration)
    {
        if (builder is null)
        {
            throw new ArgumentNullException(nameof(builder));
        }

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

        configuration(builder.UseEntityFramework());

        return(builder);
    }
Exemple #2
0
    /// <summary>
    /// Registers the MongoDB stores services in the DI container and
    /// configures OpenIddict to use the MongoDB entities by default.
    /// </summary>
    /// <param name="builder">The services builder used by OpenIddict to register new services.</param>
    /// <param name="configuration">The configuration delegate used to configure the MongoDB services.</param>
    /// <remarks>This extension can be safely called multiple times.</remarks>
    /// <returns>The <see cref="OpenIddictCoreBuilder"/>.</returns>
    public static OpenIddictCoreBuilder UseMongoDb(
        this OpenIddictCoreBuilder builder, Action <OpenIddictMongoDbBuilder> configuration)
    {
        if (builder is null)
        {
            throw new ArgumentNullException(nameof(builder));
        }

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

        configuration(builder.UseMongoDb());

        return(builder);
    }
        public void UseMongoDb_RegistersDefaultEntities()
        {
            // Arrange
            var services = new ServiceCollection().AddOptions();
            var builder  = new OpenIddictCoreBuilder(services);

            // Act
            builder.UseMongoDb();

            // Assert
            var provider = services.BuildServiceProvider();
            var options  = provider.GetRequiredService <IOptionsMonitor <OpenIddictCoreOptions> >().CurrentValue;

            Assert.Equal(typeof(OpenIddictMongoDbApplication), options.DefaultApplicationType);
            Assert.Equal(typeof(OpenIddictMongoDbAuthorization), options.DefaultAuthorizationType);
            Assert.Equal(typeof(OpenIddictMongoDbScope), options.DefaultScopeType);
            Assert.Equal(typeof(OpenIddictMongoDbToken), options.DefaultTokenType);
        }
Exemple #4
0
        public void UseEntityFrameworkModels_KeyTypeDefaultsToString()
        {
            // Arrange
            var services = new ServiceCollection().AddOptions();
            var builder  = new OpenIddictCoreBuilder(services);

            // Act
            builder.UseEntityFramework();

            // Assert
            var provider = services.BuildServiceProvider();
            var options  = provider.GetRequiredService <IOptionsMonitor <OpenIddictCoreOptions> >().CurrentValue;

            Assert.Equal(typeof(OpenIddictApplication), options.DefaultApplicationType);
            Assert.Equal(typeof(OpenIddictAuthorization), options.DefaultAuthorizationType);
            Assert.Equal(typeof(OpenIddictScope), options.DefaultScopeType);
            Assert.Equal(typeof(OpenIddictToken), options.DefaultTokenType);
        }
        public void UseEntityFrameworkCore_KeyTypeCanBeOverriden()
        {
            // Arrange
            var services = new ServiceCollection().AddOptions();
            var builder  = new OpenIddictCoreBuilder(services);

            // Act
            builder.UseEntityFrameworkCore().ReplaceDefaultEntities <Guid>();

            // Assert
            var provider = services.BuildServiceProvider();
            var options  = provider.GetRequiredService <IOptionsMonitor <OpenIddictCoreOptions> >().CurrentValue;

            Assert.Equal(typeof(OpenIddictApplication <Guid>), options.DefaultApplicationType);
            Assert.Equal(typeof(OpenIddictAuthorization <Guid>), options.DefaultAuthorizationType);
            Assert.Equal(typeof(OpenIddictScope <Guid>), options.DefaultScopeType);
            Assert.Equal(typeof(OpenIddictToken <Guid>), options.DefaultTokenType);
        }
Exemple #6
0
    /// <summary>
    /// Registers the OpenIddict Quartz.NET integration in the DI container.
    /// </summary>
    /// <param name="builder">The services builder used by OpenIddict to register new services.</param>
    /// <remarks>This extension can be safely called multiple times.</remarks>
    /// <returns>The <see cref="OpenIddictQuartzBuilder"/>.</returns>
    public static OpenIddictQuartzBuilder UseQuartz(this OpenIddictCoreBuilder builder)
    {
        if (builder is null)
        {
            throw new ArgumentNullException(nameof(builder));
        }

        builder.Services.AddQuartz();

        // The OpenIddict job is registered as a service to allow
        // Quartz.NET's DI integration to resolve it from the DI.
        builder.Services.TryAddTransient <OpenIddictQuartzJob>();

        // Note: TryAddEnumerable() is used here to ensure the initializer is registered only once.
        builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <
                                              IConfigureOptions <QuartzOptions>, OpenIddictQuartzConfiguration>());

        return(new OpenIddictQuartzBuilder(builder.Services));
    }
        public void UseQuartz_CanBeSafelyInvokedMultipleTimes()
        {
            // Arrange
            var services = new ServiceCollection();
            var builder  = new OpenIddictCoreBuilder(services);

            // Act
            builder.UseQuartz();
            builder.UseQuartz();
            builder.UseQuartz();

            // Assert
            Assert.Single(services, service => service.ServiceType == typeof(OpenIddictQuartzJob) &&
                          service.ImplementationType == typeof(OpenIddictQuartzJob) &&
                          service.Lifetime == ServiceLifetime.Transient);

            Assert.Single(services, service => service.ServiceType == typeof(IConfigureOptions <QuartzOptions>) &&
                          service.ImplementationType == typeof(OpenIddictQuartzConfiguration) &&
                          service.Lifetime == ServiceLifetime.Singleton);
        }