//TODO: Include/exclude lists for claims?
        public LDAPAuthenticationOptions()
            : base(LDAPAuthenticationDefaults.AuthenticationType)
        {
            AntiForgeryCookieName = AntiForgeryConfig.CookieName;
            AntiForgeryFieldName = LDAPAuthenticationDefaults.AntiForgeryFieldName;
            AuthenticationMode = AuthenticationMode.Active;
            CallbackPath = new PathString("/signin-activedirectoryldap");
            Caption = LDAPAuthenticationDefaults.Caption;
            ClaimTypes = new List<string>();//defaults?
            DomainKey = LDAPAuthenticationDefaults.DomainKey;
            //Domains = new List<DomainCredential>();
            PasswordKey = LDAPAuthenticationDefaults.PasswordKey;
            ReturnUrlParameter = LDAPAuthenticationDefaults.ReturnUrlParameter;
            StateKey = LDAPAuthenticationDefaults.StateKey;
            UsernameKey = LDAPAuthenticationDefaults.UsernameKey;
            ValidateAntiForgeryToken = true;

            RequiredClaims = new ReadOnlyCollection<string>(new List<string>
            {
                AntiForgeryConfig.UniqueClaimTypeIdentifier,
                ClaimsIdentity.DefaultNameClaimType,
                ClaimsIdentity.DefaultRoleClaimType,
                ClaimTypesAD.DisplayName,
                ClaimTypesAD.Domain,
                ClaimTypesAD.Guid,
                System.Security.Claims.ClaimTypes.NameIdentifier,
                System.Security.Claims.ClaimTypes.PrimarySid
            });
        }

        /// <summary>
        /// Combines the given URI components into a string that is properly encoded for use in HTTP headers.
        /// Note that unicode in the HostString will be encoded as punycode.
        /// </summary>
        /// <param name="scheme">http, https, etc.</param>
        /// <param name="host">The host portion of the uri normally included in the Host header. This may include the port.</param>
        /// <param name="pathBase">The first portion of the request path associated with application root.</param>
        /// <param name="path">The portion of the request path that identifies the requested resource.</param>
        /// <param name="query">The query, if any.</param>
        /// <param name="fragment">The fragment, if any.</param>
        /// <returns></returns>
        public static string BuildAbsolute(
            string scheme,
            HostString host,
            PathString pathBase = new PathString(),
            PathString path = new PathString(),
            QueryString query = new QueryString(),
            FragmentString fragment = new FragmentString())
        {
            var combinedPath = (pathBase.HasValue || path.HasValue) ? (pathBase + path).ToString() : "/";

            var encodedHost = host.ToString();
            var encodedQuery = query.ToString();
            var encodedFragment = fragment.ToString();

            // PERF: Calculate string length to allocate correct buffer size for StringBuilder.
            var length = scheme.Length + SchemeDelimiter.Length + encodedHost.Length
                + combinedPath.Length + encodedQuery.Length + encodedFragment.Length;

            return new StringBuilder(length)
                .Append(scheme)
                .Append(SchemeDelimiter)
                .Append(encodedHost)
                .Append(combinedPath)
                .Append(encodedQuery)
                .Append(encodedFragment)
                .ToString();
        }

        public StaticFileContext(HttpContext context, StaticFileOptions options, PathString matchUrl)
        {
            _context = context;
            _options = options;
            _matchUrl = matchUrl;
            _request = context.Request;
            _response = context.Response;

            _method = null;
            _isGet = false;
            _isHead = false;
            _subPath = PathString.Empty;
            _contentType = null;
            _fileInfo = null;
            _length = 0;
            _lastModified = new DateTime();
            _etag = null;
            _etagQuoted = null;
            _lastModifiedString = null;
            _ifMatchState = PreconditionState.Unspecified;
            _ifNoneMatchState = PreconditionState.Unspecified;
            _ifModifiedSinceState = PreconditionState.Unspecified;
            _ifUnmodifiedSinceState = PreconditionState.Unspecified;
            _ranges = null;
        }

 public WinAuthenticationOptions()
     : base(Constants.DefaultAuthenticationType)
 {
     Description.Caption = Constants.DefaultAuthenticationType;
     CallbackPath = new PathString("/windowsAuth");
     AuthenticationMode = AuthenticationMode.Active;
 }

        /// <summary>
        /// Branches the request pipeline based on matches of the given request path. If the request path starts with
        /// the given path, the branch is executed.
        /// </summary>
        /// <param name="app">The <see cref="IApplicationBuilder"/> instance.</param>
        /// <param name="pathMatch">The request path to match.</param>
        /// <param name="configuration">The branch to take for positive path matches.</param>
        /// <returns>The <see cref="IApplicationBuilder"/> instance.</returns>
        public static IApplicationBuilder Map(this IApplicationBuilder app, PathString pathMatch, Action<IApplicationBuilder> configuration)
        {
            if (app == null)
            {
                throw new ArgumentNullException(nameof(app));
            }

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

            if (pathMatch.HasValue && pathMatch.Value.EndsWith("/", StringComparison.Ordinal))
            {
                throw new ArgumentException("The path must not end with a '/'", nameof(pathMatch));
            }

            // create branch
            var branchBuilder = app.New();
            configuration(branchBuilder);
            var branch = branchBuilder.Build();

            var options = new MapOptions
            {
                Branch = branch,
                PathMatch = pathMatch,
            };
            return app.Use(next => new MapMiddleware(next, options).Invoke);
        }

        /// <summary>
        /// Adds a StatusCodePages middle-ware to the pipeline. Specifies that the response body should be generated by 
        /// re-executing the request pipeline using an alternate path. This path may contain a '{0}' placeholder of the 
        /// status code and a '{1}' placeholder of the status name.
        /// </summary>
        /// <param name="application">The application.</param>
        /// <param name="pathFormat">The string representing the path to the error page. This path may contain a '{0}' 
        /// placeholder of the status code and a '{1}' placeholder of the status description.</param>
        /// <returns>The application.</returns>
        public static IApplicationBuilder UseStatusNamePagesWithReExecute(
            this IApplicationBuilder application, 
            string pathFormat)
        {
            return application.UseStatusCodePages(
                async context =>
                {
                    var statusCode = context.HttpContext.Response.StatusCode;
                    var status = (HttpStatusCode)context.HttpContext.Response.StatusCode;
                    var newPath = new PathString(string.Format(
                        CultureInfo.InvariantCulture,
                        pathFormat,
                        statusCode,
                        status.ToString()));

                    var originalPath = context.HttpContext.Request.Path;
                    // Store the original paths so the application can check it.
                    context.HttpContext.SetFeature<IStatusCodeReExecuteFeature>(new StatusCodeReExecuteFeature()
                    {
                        OriginalPathBase = context.HttpContext.Request.PathBase.Value,
                        OriginalPath = originalPath.Value,
                    });

                    context.HttpContext.Request.Path = newPath;
                    try
                    {
                        await context.Next(context.HttpContext);
                    }
                    finally
                    {
                        context.HttpContext.Request.Path = originalPath;
                        context.HttpContext.SetFeature<IStatusCodeReExecuteFeature>(null);
                    }
                });
        }

        public WSO2AuthenticationOptions() : base(Constants.DefaultAuthenticationType)
        {
			Caption = Constants.DefaultAuthenticationType;
			CallbackPath = new PathString("/signin-wso2");
			AuthenticationMode = AuthenticationMode.Passive;
			BackchannelTimeout = TimeSpan.FromSeconds(60);
		}

 public KentorAuthServicesAuthenticationOptions()
     : base(Constants.DefaultAuthenticationType)
 {
     AuthenticationMode = AuthenticationMode.Passive;
     Description.Caption = Constants.DefaultCaption;
     MetadataPath = new PathString(Constants.DefaultMetadataPath);
 }

 public RulesEndpoint(
     IRuleData ruleData)
 {
     _ruleData = ruleData;
     _draftRulesPath = new PathString("/rules");
     _versionRulesPath = new PathString("/rules/{version}");
 }

 public LowCalorieAuthenticationServerOptions()
     : base("LowCalorieAuthentication")
 {
     this.AuthenticationMode = AuthenticationMode.Passive;
     TokenEndpointPath = new PathString("/token2");
     GernerateLocalToken = false;
 }

        public TestRunner Test(Func<HttpContext, Func<Task>, Task> test)
        {
            var path = new PathString("/test");
            actions[path] = test;

            return this;
        }

        public TestRunner Setup(Func<HttpContext, Func<Task>, Task> setup)
        {
            var path = new PathString("/setup");
            actions[path] = setup;

            return this;
        }

        public static async Task<SecurityCollection> GetSecuritiesAsync(this IMarketsFeature feature, string value) {
            var path = new PathString("/v1/markets/search").Add(new {
                q = value
            });

            return await feature.Client.GetAsync<SecurityCollection>(path);
        }

 public OpenIdConnectOptions(string authenticationScheme)
 {
     AuthenticationScheme = authenticationScheme;
     DisplayName = OpenIdConnectDefaults.Caption;
     CallbackPath = new PathString("/signin-oidc");
     Events = new OpenIdConnectEvents();
 }

 public SteamAuthenticationOptions()
 {
     ProviderDiscoveryUri = "http://steamcommunity.com/openid/";
     Caption = "Steam";
     AuthenticationType = "Steam";
     CallbackPath = new PathString("/signin-openidsteam");
 }

 public NestAuthenticationOptions()
     : base(Constants.DefaultAuthenticationType)
 {
     Description.Caption = Constants.DefaultAuthenticationType;
     CallbackPath = new PathString("/ExternalLoginCallback");
     AuthenticationMode = AuthenticationMode.Passive;
 }

 public TestEndpoint(
     IRuleData ruleData)
 {
     _ruleData = ruleData;
     _draftVersionPath = new PathString("/test");
     _versionPath = new PathString("/test/{version}");
 }

        // For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
        public void ConfigureAuth(IAppBuilder app)
        {
            // Configure the application for OAuth based flow
            PublicClientId = "MxRblSync.Api";
            OAuthAuthorizationOptions = new OAuthAuthorizationServerOptions
            {
                TokenEndpointPath = new PathString("/Authenticate"),
                AccessTokenExpireTimeSpan = TimeSpan.FromDays(14),
                Provider = new ApiAuthorizationProvider(
                    _loginSessionRepository,
                    _authKeyRepository,
                    _userRepository,
                    _hashingService,
                    PublicClientId),
            #if DEBUG
                AllowInsecureHttp = true
            #else
                AllowInsecureHttp = false
            #endif
            };

            // Enable the application to use bearer tokens to authenticate users
            app.UseOAuthAuthorizationServer(OAuthAuthorizationOptions);

            OAuthAuthenticationOptions = new OAuthBearerAuthenticationOptions
            {
                Provider = new ApiAuthenticationProvider(_authKeyRepository)
            };

            app.UseOAuthBearerAuthentication(OAuthAuthenticationOptions);
        }

        public void GetVirtualPath_ReturnsDataTokens(RouteValueDictionary dataTokens, string routerName)
        {
            // Arrange
            var virtualPath = new PathString("/TestVirtualPath");

            var pathContextValues = new RouteValueDictionary { { "controller", virtualPath } };

            var pathContext = CreateVirtualPathContext(
                pathContextValues,
                GetRouteOptions(),
                routerName);

            var route = CreateTemplateRoute("{controller}", routerName, dataTokens);
            var routeCollection = new RouteCollection();
            routeCollection.Add(route);

            var expectedDataTokens = dataTokens ?? new RouteValueDictionary();

            // Act
            var pathData = routeCollection.GetVirtualPath(pathContext);

            // Assert
            Assert.NotNull(pathData);
            Assert.Same(route, pathData.Router);

            Assert.Equal(virtualPath, pathData.VirtualPath);

            Assert.Equal(expectedDataTokens.Count, pathData.DataTokens.Count);
            foreach (var dataToken in expectedDataTokens)
            {
                Assert.True(pathData.DataTokens.ContainsKey(dataToken.Key));
                Assert.Equal(dataToken.Value, pathData.DataTokens[dataToken.Key]);
            }
        }

 /// <summary>
 /// Enables static file serving for the given request path
 /// 
 /// </summary>
 /// <param name="builder"/>
 /// <param name="defaultHtml">The default html to serve.</param>
 /// <returns/>
 public static IApplicationBuilder UseSpa(this IApplicationBuilder builder, string defaultHtml)
 {
     var options = new SpaOptions();
     var pathString = new PathString(defaultHtml);
     options.DefaultHtml = pathString;
     return builder.UseSpa(options);
 }