public BreadCrumbMiddleware(OwinMiddleware next, string crumb, string expectedStage)
: base(next)
{
_crumb = crumb;
_expectedStage = expectedStage;
}
public ExceptionTrackingMiddleware(OwinMiddleware next)
: this(next, null)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="HealthMiddleware"/> class.
/// </summary>
/// <param name="next">OwinMiddleware Param</param>
public HealthMiddleware(OwinMiddleware next)
: base(next)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="InvalidAuthenticationMiddleware"/> class.
/// </summary>
/// <param name="next">
/// The next.
/// </param>
public InvalidAuthenticationMiddleware(OwinMiddleware next)
: base(next)
{
}
public NLogMiddleware(OwinMiddleware next)
: base(next)
{
}
public CustomMiddleware(OwinMiddleware next) : base(next)
{
}
public MappingsEndpointOwinMiddleware(OwinMiddleware next, IMappingsOptions options, IEnumerable <IManagementOptions> mgmtOptions, IApiExplorer apiExplorer, ILogger logger = null)
: base(next, mgmtOptions, logger: logger)
{
_options = options;
_apiExplorer = apiExplorer;
}
public HealthEndpointOwinMiddleware(OwinMiddleware next, HealthEndpoint endpoint, ILogger <HealthEndpointOwinMiddleware> logger = null)
: base(next, endpoint, logger: logger)
{
_endpoint = endpoint ?? throw new ArgumentNullException(nameof(endpoint));
}
/// <summary>
/// Instantiates the middleware with an optional pointer to the next component.
/// </summary>
/// <param name="next"></param>
public ApiMiddleware(OwinMiddleware next) : base(next)
{
}
public LoggingMiddleware(OwinMiddleware next) :
base(next)
{
}
public HealthEndpointOwinMiddleware(OwinMiddleware next, HealthEndpoint endpoint, IEnumerable <IManagementOptions> mgmtOptions, ILogger <HealthEndpointOwinMiddleware> logger = null)
: base(next, endpoint, mgmtOptions, logger: logger)
{
_endpoint = endpoint ?? throw new ArgumentNullException(nameof(endpoint));
}
public Middleware2(OwinMiddleware next) : base(next)
{
}
public InterceptMiddleware(OwinMiddleware next) : base(next)
{
}
public void Init()
{
_fixture = new Fixture().Customize(new AutoRhinoMockCustomization());
_nextMiddleware = MockRepository.GenerateMock <OwinMiddleware>(new FakeRootMiddelware());
_sut = new OnlyHttpGetMiddleware(_nextMiddleware);
}
/// <summary>
///
/// </summary>
/// <param name="next"></param>
public OwinMiddlewareTransition(OwinMiddleware next)
{
_next = next;
}
public AbstractPluginPathMiddleware(OwinMiddleware next) : base(next)
{
}
/// <summary>
/// Creates a new instance of the <see cref="OpenIdConnectServerMiddleware"/> class.
/// </summary>
public OpenIdConnectServerMiddleware(
[NotNull] OwinMiddleware next,
[NotNull] IDictionary <string, object> properties,
[NotNull] OpenIdConnectServerOptions options)
: base(next, options)
{
if (Options.Provider == null)
{
throw new ArgumentException("The authorization provider registered in the options cannot be null.", nameof(options));
}
if (Options.HtmlEncoder == null)
{
throw new ArgumentException("The HTML encoder registered in the options cannot be null.", nameof(options));
}
if (Options.SystemClock == null)
{
throw new ArgumentException("The system clock registered in the options cannot be null.", nameof(options));
}
if (Options.Issuer != null)
{
if (!Options.Issuer.IsAbsoluteUri)
{
throw new ArgumentException("The issuer registered in the options must be a valid absolute URI.", nameof(options));
}
// See http://openid.net/specs/openid-connect-discovery-1_0.html#IssuerDiscovery
if (!string.IsNullOrEmpty(Options.Issuer.Query) || !string.IsNullOrEmpty(Options.Issuer.Fragment))
{
throw new ArgumentException("The issuer registered in the options must contain " +
"no query and no fragment parts.", nameof(options));
}
// Note: while the issuer parameter should be a HTTPS URI, making HTTPS mandatory
// in Owin.Security.OpenIdConnect.Server would prevent the end developer from
// running the different samples in test environments, where HTTPS is often disabled.
// To mitigate this issue, AllowInsecureHttp can be set to true to bypass the HTTPS check.
// See http://openid.net/specs/openid-connect-discovery-1_0.html#IssuerDiscovery
if (!Options.AllowInsecureHttp && string.Equals(Options.Issuer.Scheme, Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentException("The issuer registered in the options must be a HTTPS URI when " +
"AllowInsecureHttp is not set to true.", nameof(options));
}
}
if (Options.AuthenticationMode == AuthenticationMode.Active)
{
throw new ArgumentException("Automatic authentication cannot be used with " +
"the OpenID Connect server middleware.", nameof(options));
}
// Ensure at least one signing certificate/key was registered if an access token handler was registered.
if (Options.AccessTokenHandler != null && Options.SigningCredentials.Count == 0)
{
throw new ArgumentException(
"At least one signing key must be registered when using JWT as the access token format. " +
"Consider registering a X.509 certificate using 'options.SigningCredentials.AddCertificate()' " +
"or call 'options.SigningCredentials.AddEphemeralKey()' to use an ephemeral key.", nameof(options));
}
if (Options.Logger == null)
{
options.Logger = NullLogger.Instance;
}
if (Options.DataProtectionProvider == null)
{
// Use the application name provided by the OWIN host as the Data Protection discriminator.
// If the application name cannot be resolved, throw an invalid operation exception.
var discriminator = new AppProperties(properties).AppName;
if (string.IsNullOrEmpty(discriminator))
{
throw new InvalidOperationException(
"The application name cannot be resolved from the OWIN application builder. " +
"Consider manually setting the 'DataProtectionProvider' property in the " +
"options using 'DataProtectionProvider.Create([unique application name])'.");
}
Options.DataProtectionProvider = DataProtectionProvider.Create(discriminator);
}
if (Options.AccessTokenFormat == null)
{
var protector = Options.DataProtectionProvider.CreateProtector(
nameof(OpenIdConnectServerHandler),
nameof(Options.AccessTokenFormat), Options.AuthenticationType);
Options.AccessTokenFormat = new AspNetTicketDataFormat(new DataProtectorShim(protector));
}
if (Options.AuthorizationCodeFormat == null)
{
var protector = Options.DataProtectionProvider.CreateProtector(
nameof(OpenIdConnectServerHandler),
nameof(Options.AuthorizationCodeFormat), Options.AuthenticationType);
Options.AuthorizationCodeFormat = new AspNetTicketDataFormat(new DataProtectorShim(protector));
}
if (Options.RefreshTokenFormat == null)
{
var protector = Options.DataProtectionProvider.CreateProtector(
nameof(OpenIdConnectServerHandler),
nameof(Options.RefreshTokenFormat), Options.AuthenticationType);
Options.RefreshTokenFormat = new AspNetTicketDataFormat(new DataProtectorShim(protector));
}
var environment = new AppProperties(properties).Get <string>("host.AppMode");
if (Options.AllowInsecureHttp && !string.Equals(environment, "Development", StringComparison.OrdinalIgnoreCase))
{
Options.Logger.LogWarning("Disabling the transport security requirement is not recommended in production. " +
"Consider setting 'OpenIdConnectServerOptions.AllowInsecureHttp' to 'false' " +
"to prevent the OpenID Connect server middleware from serving non-HTTPS requests.");
}
}
public RangeMiddleware(OwinMiddleware next, ServiceName serviceName, string path,
Func <PackageSearcherManager> searcherManagerThunk)
: base(next, serviceName, path, searcherManagerThunk)
{
}
public StaticFileMiddleware(OwinMiddleware next) : base(next)
{
}
public ActuatorHypermediaEndpointOwinMiddleware(OwinMiddleware next, ActuatorEndpoint endpoint, IEnumerable <IManagementOptions> mgmtOptions = null, ILogger <ActuatorHypermediaEndpointOwinMiddleware> logger = null)
: base(next, endpoint, mgmtOptions?.OfType <ActuatorManagementOptions>(), logger: logger)
{
_endpoint = endpoint ?? throw new ArgumentNullException(nameof(endpoint));
}
public MappingsEndpointOwinMiddleware(OwinMiddleware next, IMappingsOptions options, IApiExplorer apiExplorer, ILogger logger = null)
: base(next, logger: logger)
{
_options = options;
_apiExplorer = apiExplorer;
}
public Logger(OwinMiddleware next) : base(next)
{
}
public UrlRewriterOwinMiddleware(OwinMiddleware next, UrlRewriterOptions options)
: base(next)
{
_options = options;
}
private static AppFunc Conversion2(OwinMiddleware next)
{
return(new OwinMiddlewareTransition(next).Invoke);
}
public LogRequestInformationMiddleware(OwinMiddleware next)
: base(next)
{
}
public B2COpenIdConnectAuthenticationMiddleware(OwinMiddleware next, IAppBuilder app, OpenIdConnectAuthenticationOptions options)
: base(next, app, options)
{
_logger = app.CreateLogger <B2COpenIdConnectAuthenticationMiddleware>();
}
public HttpsRedirectMiddleware(OwinMiddleware next, int httpsPort, RedirectStatusCode statusCode) : base(next)
{
this.httpsPort = httpsPort;
this.statusCode = statusCode;
}
public NoCacheMiddleware(OwinMiddleware next)
: base(next)
{
}
public LoggingContextMiddleware(OwinMiddleware next, IDictionary <string, Func <string> > requestHeaders) : base(next)
{
_requestHeaders = requestHeaders;
}
public NoCacheMiddleware(OwinMiddleware next, NoCacheOptions options)
: base(next)
{
_options = options;
}
private static AppFunc Conversion2(OwinMiddleware next)
{
throw new NotImplementedException();
}
public BasicAuthenticationMiddleware(OwinMiddleware next, BasicAuthenticationOptions basicAuthenticationOptions)
: base(next, basicAuthenticationOptions)
{
}
private static AppFunc Conversion2(OwinMiddleware next)
{
return new OwinMiddlewareTransition(next).Invoke;
}
public ProfilesSdkCustomMiddleware(OwinMiddleware next)
: base(next)
{
_next = next;
}
