public WsFederationPluginOptions(PluginDependencies dependencies)
{
if (dependencies == null)
{
throw new ArgumentNullException("dependencies");
}
_dependencies = dependencies;
}
private void ConfigurePlugins(IAppBuilder app, PluginDependencies dependencies)
{
var options = new WsFederationPluginOptions(dependencies)
{
RelyingPartyService = () => new TestRelyingPartyService(),
};
app.UseWsFederationPlugin(options);
}
public static IdentityServerAppBuilder UseIdentityServerCore(this IAppBuilder app, IdentityServerCoreOptions options)
{
if (options == null) throw new ArgumentNullException("options");
// thank you Microsoft for the clean syntax
JwtSecurityTokenHandler.InboundClaimTypeMap = ClaimMappings.None;
JwtSecurityTokenHandler.OutboundClaimTypeMap = ClaimMappings.None;
app.UseCookieAuthentication(new CookieAuthenticationOptions { AuthenticationType = Constants.PrimaryAuthenticationType });
app.UseCookieAuthentication(new CookieAuthenticationOptions { AuthenticationType = Constants.ExternalAuthenticationType, AuthenticationMode = AuthenticationMode.Passive });
app.UseCookieAuthentication(new CookieAuthenticationOptions { AuthenticationType = Constants.PartialSignInAuthenticationType, AuthenticationMode = AuthenticationMode.Passive });
if (options.SocialIdentityProviderConfiguration != null)
{
options.SocialIdentityProviderConfiguration(app, Constants.ExternalAuthenticationType);
}
var pluginDependencies = new PluginDependencies();
if (options.PluginConfiguration != null)
{
options.PluginConfiguration(app, pluginDependencies);
}
app.UseFileServer(new FileServerOptions
{
RequestPath = new PathString("/assets"),
FileSystem = new EmbeddedResourceFileSystem(typeof(Constants).Assembly, "Thinktecture.IdentityServer.Core.Assets")
});
app.UseStageMarker(PipelineStage.MapHandler);
app.UseFileServer(new FileServerOptions
{
RequestPath = new PathString("/assets/libs/fonts"),
FileSystem = new EmbeddedResourceFileSystem(typeof(Constants).Assembly, "Thinktecture.IdentityServer.Core.Assets.libs.bootstrap.fonts")
});
app.UseStageMarker(PipelineStage.MapHandler);
app.Use<AutofacContainerMiddleware>(AutofacConfig.Configure(options, pluginDependencies));
Microsoft.Owin.Infrastructure.SignatureConversions.AddConversions(app);
app.UseWebApi(WebApiConfig.Configure(options));
return new IdentityServerAppBuilder(app);
}
public static IContainer Configure(IdentityServerCoreOptions options, PluginDependencies pluginDepencies)
{
if (options == null) throw new ArgumentNullException("options");
if (options.Factory == null) throw new InvalidOperationException("null factory");
IdentityServerServiceFactory fact = options.Factory;
fact.Validate();
var builder = new ContainerBuilder();
// mandatory from factory
builder.Register(ctx => fact.AuthorizationCodeStore()).As<IAuthorizationCodeStore>();
builder.Register(ctx => fact.CoreSettings()).As<ICoreSettings>();
builder.Register(ctx => fact.Logger()).As<ILogger>();
builder.Register(ctx => fact.TokenHandleStore()).As<ITokenHandleStore>();
builder.Register(ctx => fact.UserService()).As<IUserService>();
builder.Register(ctx => fact.ConsentService()).As<IConsentService>();
// optional from factory
if (fact.ClaimsProvider != null)
{
builder.Register(ctx => fact.ClaimsProvider()).As<IClaimsProvider>();
}
else
{
builder.RegisterType<DefaultClaimsProvider>().As<IClaimsProvider>();
}
if (fact.TokenService != null)
{
builder.Register(ctx => fact.TokenService()).As<ITokenService>();
}
else
{
builder.RegisterType<DefaultTokenService>().As<ITokenService>();
}
if (fact.CustomRequestValidator != null)
{
builder.Register(ctx => fact.CustomRequestValidator()).As<ICustomRequestValidator>();
}
else
{
builder.RegisterType<DefaultCustomRequestValidator>().As<ICustomRequestValidator>();
}
if (fact.AssertionGrantValidator != null)
{
builder.Register(ctx => fact.AssertionGrantValidator()).As<IAssertionGrantValidator>();
}
else
{
builder.RegisterType<DefaultAssertionGrantValidator>().As<IAssertionGrantValidator>();
}
if (fact.ExternalClaimsFilter != null)
{
builder.Register(ctx => fact.ExternalClaimsFilter()).As<IExternalClaimsFilter>();
}
else
{
builder.RegisterType<DefaultExternalClaimsFilter>().As<IExternalClaimsFilter>();
}
// validators
builder.RegisterType<TokenRequestValidator>();
builder.RegisterType<AuthorizeRequestValidator>();
builder.RegisterType<ClientValidator>();
builder.RegisterType<TokenValidator>();
// processors
builder.RegisterType<TokenResponseGenerator>();
builder.RegisterType<AuthorizeResponseGenerator>();
builder.RegisterType<AuthorizeInteractionResponseGenerator>();
builder.RegisterType<UserInfoResponseGenerator>();
// for authentication
var authenticationOptions = options.AuthenticationOptions ?? new AuthenticationOptions();
builder.RegisterInstance(authenticationOptions).AsSelf();
// load core controller
builder.RegisterApiControllers(typeof(AuthorizeEndpointController).Assembly);
if (pluginDepencies != null)
{
if (pluginDepencies.ApiControllerAssemblies != null)
{
foreach (var asm in pluginDepencies.ApiControllerAssemblies)
{
builder.RegisterApiControllers(asm);
}
}
if (pluginDepencies.Types != null)
{
foreach (var type in pluginDepencies.Types)
{
if (type.Value == null)
{
builder.RegisterType(type.Key);
}
else
{
builder.RegisterType(type.Key).As(type.Value);
}
}
}
if (pluginDepencies.Factories != null)
{
foreach (var factory in pluginDepencies.Factories)
{
builder.Register(ctx => factory.Value()).As(factory.Key);
}
}
}
return builder.Build();
}