Example #1
0
        public static void Register(HttpConfiguration config)
        {
            DelegatingHandler[] handlers = new DelegatingHandler[]
            {
                new ApiKeyHandler(new OktaProvider())
            };

            var routeHandlers = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(config), handlers);

            // Web API configuration and services

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "Login",
                routeTemplate: "api/Auth/{action}/{data}",
                defaults: new { Controller = "Auth", data = RouteParameter.Optional }
                );

            config.Routes.MapHttpRoute(
                name: "Index",
                routeTemplate: "api/index",
                defaults: new { Controller = "Index" }
                );


            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                handler: routeHandlers,
                constraints: null,
                defaults: new { id = RouteParameter.Optional }
                );
        }
        public ClientContext(string userName, string password, string serviceUri, IEnumerable <DelegatingHandler> handlers = null)
        {
            omniSession = new OmniSession();
            piiUser     = new User();

            if (string.IsNullOrEmpty(userName) || string.IsNullOrEmpty(password) || string.IsNullOrEmpty(serviceUri))
            {
                throw new ArgumentNullException("username, password or service uri");
            }

            HttpMessageHandler innerHandler = null;
            var apiErrorHandler             = new XOMNIPublicApiErrorHandler();

            if (handlers != null)
            {
                var unifiedHandlers = handlers.ToList();
                unifiedHandlers.Insert(0, apiErrorHandler);
                innerHandler = HttpClientFactory.CreatePipeline(new HttpClientHandler(), unifiedHandlers);
            }
            else
            {
                innerHandler = HttpClientFactory.CreatePipeline(new HttpClientHandler(), new[] { apiErrorHandler });
            }

            this.UserName = userName;
            this.Password = password;
            this.Clients  = new ConcurrentDictionary <Type, object>();

            this.HttpClient             = new HttpClient(innerHandler);
            this.HttpClient.BaseAddress = new Uri(serviceUri);
            this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(AuthenticationSchema,
                                                                                                Convert.ToBase64String(Encoding.UTF8.GetBytes(string.Format("{0}:{1}", userName, password))));
            this.HttpClient.DefaultRequestHeaders.Accept.ParseAdd(string.Format("application/vnd.xomni.api-{0}", "v3_0"));
        }
Example #3
0
        public static void Register(HttpConfiguration config)
        {
            // Configuración y servicios de API web
            var cors = new EnableCorsAttribute("*", "*", "*");

            config.EnableCors(cors);
            // Rutas de API web
            config.MapHttpAttributeRoutes();

            // List of delegating handlers.
            DelegatingHandler[] handlers = new DelegatingHandler[] {
                new AuthorizationHandler()
            };

            // Create a message handler chain with an end-point.
            var routeHandlers = HttpClientFactory.CreatePipeline(
                new HttpControllerDispatcher(config), handlers);

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional },
                constraints: null,
                handler: routeHandlers
                );
        }
Example #4
0
        protected void Application_Start(object sender, EventArgs e)
        {
            HttpConfiguration  config         = GlobalConfiguration.Configuration;
            HttpMessageHandler serverPipeline = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(config), new[] { new AuthMessageHandler() });

            config.Routes.MapHttpRoute(
                "ServerHttpRoute",
                "api/cars/{id}",
                defaults: new { id = RouteParameter.Optional, controller = "cars" },
                constraints: null,
                handler: serverPipeline
                );

            config.Routes.MapHttpRoute(
                "ClientHttpRoute",
                "client/cars/{id}",
                new { id = RouteParameter.Optional, controller = "carsclient" }
                );

            RegisterDependencies(config);

            // Any complex type parameter which is Assignable From
            // IRequestCommand will be bound from the URI
            config.ParameterBindingRules.Insert(0, descriptor =>
                                                typeof(IRequestCommand).IsAssignableFrom(descriptor.ParameterType)
                    ? new FromUriAttribute().GetBinding(descriptor) : null);
        }
Example #5
0
        public void A_message_handler_can_be_specified_to_perform_authentication_prior_to_the_sensor_authorization_check()
        {
            var authenticator = new Authenticator
            {
                Send = request =>
                {
                    var response = request.CreateResponse(HttpStatusCode.OK);
                    response.Headers.Add("authenticated", "true");
                    return(response);
                }
            };
            var httpConfig = new HttpConfiguration();

            HttpMessageHandler handler = HttpClientFactory.CreatePipeline(
                new HttpControllerDispatcher(httpConfig),
                new[] { authenticator });

            httpConfig.MapSensorRoutes(
                ctx => ctx.Response.Headers.Contains("authenticated") &&
                ctx.Response.Headers.GetValues("authenticated").Single() == "true",
                handler: handler);

            var apiClient = new HttpClient(new HttpServer(httpConfig));

            apiClient.GetAsync("http://blammo.biz/sensors").Result.StatusCode.Should().Be(HttpStatusCode.OK);
        }
        public void Configuration(IAppBuilder app)
        {
            var config = new HttpConfiguration();

            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(name: "routemy",
                                       routeTemplate: "api/{controller}/{id}",
                                       defaults: new { id = RouteParameter.Optional },
                                       handler: new SpecialDelegatingHandler(), constraints: null);

            config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver =
                new CamelCasePropertyNamesContractResolver();

            //config.MessageHandlers.Add(new SpecialDelegatingHandler());


            var pipeline = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(config), new List <DelegatingHandler>()
            {
                new SpecialDelegatingHandler()
            });

            config.Routes.MapHttpRoute(name: "specialroute",
                                       routeTemplate: "api2/{controller}/{id}",
                                       defaults: new { id = RouteParameter.Optional },
                                       constraints: null,
                                       handler: pipeline);

            config.Filters.Add(new MyAuthenticationFilter());

            app.UseWebApi(config);
        }
Example #7
0
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.MessageHandlers.Add(new JWTValidationHandler());

            // List of delegating handlers.
            DelegatingHandler[] handlers = new DelegatingHandler[] {
                //new MessageHandler3()
            };

            // Create a message handler chain with an end-point.
            var routeHandlers = HttpClientFactory.CreatePipeline(
                new HttpControllerDispatcher(config), handlers);


            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );

            config.Routes.MapHttpRoute(
                name: "DefaultApi2",
                routeTemplate: "api2/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional },
                constraints: null,
                handler: new JWTValidationHandler()
                );
        }
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            routes.MapHttpRoute(
                name: "Auth",
                routeTemplate: "api/auth/verify",
                defaults: new { controller = "Auth" });

            routes.MapHttpRoute(
                name: "ProxyHandler",
                routeTemplate: "api/{*path}",
                handler: HttpClientFactory.CreatePipeline
                (
                    innerHandler: new HttpClientHandler(),
                    handlers: new DelegatingHandler[] { new MML.Web.LoanCenter.Handlers.ProxyHandler() }
                ),
                defaults: new { path = RouteParameter.Optional },
                constraints: null);

            routes.MapRoute(
                "Default",                    // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
                );

            if (_serviceBrokerInitialized == false)
            {
                XmlNode serviceConfiguration = ConfigurationManager.GetSection("ServiceConfiguration") as XmlNode;
                ServiceBroker.RegisterClients(serviceConfiguration);
                _serviceBrokerInitialized = true;
            }
        }
Example #9
0
        public static void Register(HttpConfiguration config)
        {
            var Handler = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(config), new DelegatingHandler[] { new CustomMessageHandler() });

            //config.MessageHandlers.Add(new CustomMessageHandler()); //Global level handler mapping

            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );

            config.Routes.MapHttpRoute(
                name: "HomeApi",
                routeTemplate: "Home/{action}/{id}",
                defaults: new
            {
                Controller = "Home",
                id         = RouteParameter.Optional
            },
                constraints: null,
                handler: Handler //Route level message handler
                );
        }
Example #10
0
        public static void Register(HttpConfiguration config)
        {
            // Web API routes
            config.MapHttpAttributeRoutes();


            // Enables cors in entire application
            config.EnableCors();

            // Creates routing for the application
            config.Routes.MapHttpRoute(
                name: "SsoApi",
                routeTemplate: "v1/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional },
                constraints: new { controller = "Sso" },
                handler: HttpClientFactory.CreatePipeline(
                    new HttpControllerDispatcher(config),
                    new DelegatingHandler[] { new SsoAuthenticateHandler() })
                );

            // Creates routing for the application
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "v1/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional },
                constraints: null,
                handler: HttpClientFactory.CreatePipeline(
                    new HttpControllerDispatcher(config),
                    new DelegatingHandler[] { new AuthenticateHandler() })
                );
        }
Example #11
0
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            // Configure Web API to use only bearer token authentication.
            config.SuppressDefaultHostAuthentication();
            config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );

            config.Routes.MapHttpRoute(name: "Proxy", routeTemplate: "{ *path}", handler:
                                       HttpClientFactory.CreatePipeline
                                       (
                                           innerHandler: new HttpClientHandler(), // will never get here if proxy is doing its job
                                           handlers: new DelegatingHandler[]
                                           { new ProxyHandler() }
                                       ),
                                       defaults: new { path = RouteParameter.Optional },
                                       constraints:
                                       null
                                       );
        }
Example #12
0
        /// <seealso href="https://developer.foursquare.com/overview/auth#userless" />
        public FoursquareUserlessContext(HttpMessageHandler handler, UserlessAccessSettings settings)
        {
            if (handler == null)
            {
                throw new ArgumentNullException(nameof(handler));
            }
            if (settings == null)
            {
                throw new ArgumentNullException(nameof(settings));
            }

            var userlessHandler = HttpClientFactory.CreatePipeline(handler, new DelegatingHandler[]
            {
                new QueryAppenderHandler("client_id", settings.ClientId),
                new QueryAppenderHandler("client_secret", settings.ClientSecret)
            });

            _httpClient = new HttpClient(userlessHandler, false)
            {
                BaseAddress = new Uri(Constants.FoursquareApiBaseUrl)
            };

            Categories = new CategoriesClient(_httpClient);
            Venues     = new VenuesClient(_httpClient);
            Photos     = new PhotosClient(_httpClient);
        }
        public static void Configure(HttpConfiguration config)
        {
            var pipeline = HttpClientFactory.CreatePipeline(
                new HttpControllerDispatcher(config),
                new DelegatingHandler[] {
                new CompressionHandler(),
                new NotAcceptablePayloadHandler(),
                new HtmlResourceRedirectHandler()
            });
            var constraints = new
            {
                name = new EndpointConstraint()
            };

            config.Routes.MapHttpRoute("Index", string.Empty, new { controller = "Help" });
            config.Routes.MapHttpRoute("WithExtension", "{name}.{ext}", new { controller = "FixedQuery" }, constraints, pipeline);
            config.Routes.MapHttpRoute("WithoutExtension", "{name}", new { controller = "FixedQuery", ext = string.Empty }, constraints, pipeline);
            config.Routes.MapHttpRoute("BadRequest", "{*any}", new { controller = "BadRequest" });

            config.Services.Add(typeof(IExceptionLogger), new AIExceptionLogger());

            config.Formatters.Clear();
            config.Formatters.Add(new HttpErrorJsonFormatter());
            config.Formatters.Add(new HttpErrorXmlFormatter());
        }
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            /*******************************************************/
            DelegatingHandler[] handlers = new DelegatingHandler[]
            {
                new PerRouteMessageHandler()
            };
            var routeHandlers = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(config), handlers);

            /*******************************************************/
            // Web API routes
            config.MapHttpAttributeRoutes();
            config.MessageHandlers.Add(new AllRouteMessageHandler());
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );
            config.Routes.MapHttpRoute(
                name: "Route2",
                routeTemplate: "api2/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional },
                constraints: null,
                handler: routeHandlers//<<<<<<<<<<<***********************************
                );
        }
Example #15
0
        public static void Register(HttpConfiguration config)
        {
            //var cors = new EnableCorsAttribute("*", "*", "*");
            config.EnableCors();

            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "SteamRoute",
                routeTemplate: "api/steam",
                defaults: null,
                constraints: null,
                handler: HttpClientFactory.CreatePipeline(
                    new HttpControllerDispatcher(config),
                    new DelegatingHandler[] { new SteamHandler() }
                    )
                );

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );

            //config.MessageHandlers.Add(new SteamHandler());
        }
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );


            // New Code
            ODataModelBuilder builder = new ODataConventionModelBuilder();

            builder.EntitySet <Customer>("Customer");
            builder.EntitySet <Job>("Job");
            builder.EntitySet <Manager>("Manager");
            builder.EntitySet <Technician>("Technician");
            builder.EntitySet <DailyStatistic>("DailyStatistic");
            config.MapODataServiceRoute(
                routeName: "ODataRoute",
                routePrefix: null,
                model: builder.GetEdmModel(),
                defaultHandler: HttpClientFactory.CreatePipeline(innerHandler: new HttpControllerDispatcher(config),
                                                                 handlers: new[] { new ODataNullValueMessageHandler() })
                );

            //Enable $select, $expand, and others
            config.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
        }
Example #17
0
        /// <summary>
        /// 此扩展方法,用于调用引用的dll,使用其中的route
        /// </summary>
        /// <param name="httpConfiguration"></param>
        public static void RegisterAssembly(this HttpConfiguration httpConfiguration)
        {
            IEnumerable <Assembly> assemblies = BuildManager.GetReferencedAssemblies().Cast <Assembly>().Where(x => x.GetName().Name.StartsWith("BLL"));

            foreach (Assembly assembly in assemblies)
            {              //查找拥有特定特性路由的控制器类
                List <Type> types = assembly.GetTypes().Where(x => x.IsDefined(typeof(RegRouteHandlerAttribute))).ToList();
                foreach (Type type in types)
                {
                    //获取特性路由对象
                    RegRouteHandlerAttribute attribute = type.GetCustomAttribute <RegRouteHandlerAttribute>();
                    //创建handler对象
                    DelegatingHandler handler = Activator.CreateInstance(type) as DelegatingHandler;
                    //创建自定义消息管道
                    HttpMessageHandler httpHandlers = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(httpConfiguration), new DelegatingHandler[] { handler });
                    //注册路由
                    httpConfiguration.Routes.MapHttpRoute(
                        name: attribute.ControllerName,
                        routeTemplate: attribute.Template,
                        defaults: new { controller = attribute.ControllerName },
                        constraints: null,
                        handler: httpHandlers
                        );
                }
            }
        }
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services

            // Web API routes
            config.MapHttpAttributeRoutes();

            var cacheService  = new MemoryCacheService(int.Parse(ConfigurationManager.AppSettings["CacheDurationInSeconds"]));
            var configuration = new CachedConfiguration(new ConfigurationManagerConfiguration(), cacheService);

            var webProxyUserRepository = new CachedWebProxyUserRepository(new SqlServerWebProxyUserRepository(configuration), cacheService);

            //var proxyLogging = new FileProxyLogging(configuration);
            var proxyLogging = new AzureBlobStorageLogging(configuration);
            //var proxyLogging = new NullProxyLogging();

            //var proxyRouting = new LogicRouting();
            var proxyRouting = new NasAvWebServicesRouting(configuration, webProxyUserRepository);


            config.Routes.MapHttpRoute(name: "Proxy", routeTemplate: "{*path}", handler:
                                       HttpClientFactory.CreatePipeline(
                                           innerHandler: new HttpClientHandler(), // will never get here if proxy is doing its job
                                           handlers: new DelegatingHandler[] { new ProxyHandler(proxyRouting, proxyLogging, configuration) }),
                                       defaults: new { path = RouteParameter.Optional },
                                       constraints: null
                                       );
        }
Example #19
0
        private static HttpMessageHandler GetSecureHandler(HttpConfiguration config)
        {
            DelegatingHandler[] handlers = new DelegatingHandler[] {
                new BasicAuthenticationHandler()
            };

            return(HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(config), handlers));
        }
 /// <seealso href="https://developer.foursquare.com/overview/versioning" />
 private static HttpMessageHandler CreateHandler()
 {
     return(HttpClientFactory.CreatePipeline(new HttpClientHandler(), new DelegatingHandler[]
     {
         new OAuthTokenSwitchHandler(),
         new QueryAppenderHandler("v", "20170523")
     }));
 }
Example #21
0
        /// <summary>
        /// Prepares the server for operation.
        /// </summary>
        /// <remarks>
        /// This method must be called after all configuration is complete
        /// but before the first request is processed.
        /// </remarks>
        protected virtual void Initialize()
        {
            // Do final initialization of the configuration.
            // It is considered immutable from this point forward.
            _configuration.EnsureInitialized();

            // Create pipeline
            InnerHandler = HttpClientFactory.CreatePipeline(_dispatcher, _configuration.MessageHandlers);
        }
Example #22
0
 protected override void UpdateConfiguration(WebRouteConfiguration configuration)
 {
     configuration.
     MapODataServiceRoute(
         routeName: "RawValue",
         routePrefix: "RawValue",
         model: GetEdmModel(configuration), pathHandler: new DefaultODataPathHandler(),
         routingConventions: ODataRoutingConventions.CreateDefault(),
         defaultHandler: HttpClientFactory.CreatePipeline(innerHandler: new HttpControllerDispatcher(configuration), handlers: new[] { new ODataNullValueMessageHandler() }));
 }
        // Web API configuration and services
        public static void Register(HttpConfiguration config)
        {
            // Enable CORS with default pipeline
            config.EnableCors();

            // Setting up JSON serialization
            config.Formatters.JsonFormatter.SerializerSettings.Formatting       = Newtonsoft.Json.Formatting.Indented;
            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
            config.Formatters.JsonFormatter.MediaTypeMappings.Add(new RequestHeaderMapping(
                                                                      "Accept",
                                                                      "text/html",
                                                                      StringComparison.InvariantCultureIgnoreCase,
                                                                      true,
                                                                      "application/json"));

            // Web API routes
            config.MapHttpAttributeRoutes();

            // Default Route to index.html
            config.Routes.MapHttpRoute(
                name: "Index",
                routeTemplate: "{id}.html",
                defaults: new { id = "index" });

            // If we want a global access token delegating handler do it here
            // Global DelegatingHandler
            config.MessageHandlers.Add(new AccessTokenAuthenticationDelegatingHandler());

            // Non-default Controller Routes
            config.Routes.MapHttpRoute(
                name: "Sso",
                routeTemplate: "{version}/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional },
                constraints: new { version = "v1", controller = "Sso" },
                handler:
                HttpClientFactory.CreatePipeline(
                    new HttpControllerDispatcher(config),
                    new DelegatingHandler[] { new SsoAccessTokenAuthenticationDelegatingHandler() })
                );

            // Default Controller Route
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "{version}/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional, action = "Get" },
                constraints: new { version = "v1" }
                );

            // Global Authorization Filters

            // Global Action Filters

            // Global Exception Filters
            config.Filters.Add(new AnyExceptionFilterAttribute());
        }
Example #24
0
 public static void UpdateConfiguration(HttpConfiguration configuration)
 {
     configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
     configuration.
     MapODataServiceRoute(
         routeName: "RawValue",
         routePrefix: "RawValue",
         model: GetEdmModel(configuration), pathHandler: new DefaultODataPathHandler(),
         routingConventions: ODataRoutingConventions.CreateDefault(),
         defaultHandler: HttpClientFactory.CreatePipeline(innerHandler: new HttpControllerDispatcher(configuration), handlers: new[] { new ODataNullValueMessageHandler() }));
 }
Example #25
0
        private static void MapRoute(HttpConfiguration httpConfiguration, IEdmModel edmModel, string routePrefix, HttpBatchHandler batchHandler)
        {
            // batch handler should be mapped first
            var routeTemplate = string.IsNullOrEmpty(routePrefix) ? ODataRouteConstants.Batch : routePrefix + '/' + ODataRouteConstants.Batch;

            httpConfiguration.Routes.MapHttpBatchRoute(routePrefix + "Batch", routeTemplate, batchHandler);

            var httpMessageHandler = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(httpConfiguration), new DelegatingHandler[0]);

            httpConfiguration.MapODataServiceRoute(routePrefix, routePrefix, edmModel, httpMessageHandler);
        }
Example #26
0
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services

            config.Services.Replace(typeof(IExceptionHandler), new AppExceptionHandler());
            config.Services.Replace(typeof(IExceptionLogger), new AppExceptionLogger());
            // Web API routes

            // Support for More Media Types
            var bson = new BsonMediaTypeFormatter();

            bson.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/vnd.contoso"));
            config.Formatters.Add(bson);


            // DelegatingHandler[] handlers = new DelegatingHandler[]{new TokenAuthenicationHandler()};

            // Create a message handler chain with an end-point.
            // var routeHandlers = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(config), handlers);

            config.MapHttpAttributeRoutes();

            //config.Routes.MapHttpRoute(
            //  name: "DefaultPublicApi",
            //  routeTemplate: "apiV2/public/{id}",
            //  defaults: new { controller = "MyKeyController", Id = RouteParameter.Optional }
            //  );

            config.Routes.MapHttpRoute(
                name: "ApiRoot",
                routeTemplate: "api/public/{method}",
                defaults: new { controller = "MyKeyController", method = "ApiKey" }
                );

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional },
                constraints: null,
                handler: HttpClientFactory.CreatePipeline(
                    new HttpControllerDispatcher(config),
                    new DelegatingHandler[]
            {
                new TokenAuthenicationHandler()
            })
                // handler: new TokenAuthenicationHandler(GlobalConfiguration.Configuration)
                );



            // config.MessageHandlers.Add(new TokenAuthenicationHandler());
        }
Example #27
0
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            // Pipelines
            HttpMessageHandler siteLanguagePipeline =
                HttpClientFactory.CreatePipeline(
                    new HttpControllerDispatcher(GlobalConfiguration.Configuration),
                    new[] { new SiteLanguageDispatcher() });

            HttpMessageHandler cityPipeline =
                HttpClientFactory.CreatePipeline(
                    new HttpControllerDispatcher(GlobalConfiguration.Configuration),
                    new DelegatingHandler[] { new SiteLanguageDispatcher(), new CityDispatcher() });

            HttpMessageHandler hotelPipeline =
                HttpClientFactory.CreatePipeline(
                    new HttpControllerDispatcher(GlobalConfiguration.Configuration),
                    new DelegatingHandler[] { new SiteLanguageDispatcher(), new CityDispatcher(), new HotelDispatcher() });

            routes.MapHttpRoute(
                name: "CityApiRoute",
                routeTemplate: "content/{site}/{language}/cities/{cityName}",
                defaults: new { controller = "City", cityName = RouteParameter.Optional },
                constraints: null,
                handler: siteLanguagePipeline
                );

            routes.MapHttpRoute(
                name: "HotelApiRoute",
                routeTemplate: "content/{site}/{language}/cities/{cityName}/hotels/{id}",
                defaults: new { controller = "Hotel", id = RouteParameter.Optional },
                constraints: null,
                handler: cityPipeline
                );

            routes.MapHttpRoute(
                name: "SpaApiRoute",
                routeTemplate: "content/{site}/{language}/cities/{cityName}/hotels/{hotelName}/spas/{id}",
                defaults: new { controller = "Spa", id = RouteParameter.Optional },
                constraints: null,
                handler: hotelPipeline
                );

            routes.MapHttpRoute(
                name: "SpaApiRoute1",
                routeTemplate: "content/{site}/{language}/cities/{cityName}/spas/{id}",
                defaults: new { controller = "Spa", id = RouteParameter.Optional },
                constraints: null,
                handler: cityPipeline
                );
        }
 /// <summary>
 /// Gets a custom message handler that explicitly contains the CorsMessageHandler for use
 /// with our RestApi routes.
 /// </summary>
 /// <param name="config"></param>
 /// <returns></returns>
 private static HttpMessageHandler GetMessageHandler(HttpConfiguration config)
 {
     // Create a message handler chain with an end-point.
     return(HttpClientFactory.CreatePipeline(
                new HttpControllerDispatcher(config),
                new DelegatingHandler[]
     {
         //Explicitly include the CorsMessage handler!
         // we're doing this so people don't have to do EnableCors() in their startup,
         // we don't care about that, we always want to support Cors for the rest api
         new CorsMessageHandler(config)
     }));
 }
Example #29
0
        static void Main(string[] args)
        {
            var baseAddress = "http://localhost:8080";
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress);

            // config.MessageHandlers.Add(new ProgressMessageHandler() { });


            // Web API 路由
            config.MapHttpAttributeRoutes();

            //全局允许CROS
            // config.EnableCors();//启用跨域


            config.Routes.MapHttpRoute
            (
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
            config.MaxConcurrentRequests = 1000;
            var handlers      = new DelegatingHandler[] { new PassiveAuthenticationMessageHandler(), new HttpServer() };
            var routeHandlers = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(config), handlers);

            config.Routes.MapHttpRoute(
                name: "CustomerRouter",
                routeTemplate: "MyAPI/{Controller}/{Action}/Id",
                defaults: new { Id = RouteParameter.Optional },
                constraints: null,
                handler: routeHandlers
                );
            HttpSelfHostServer server = new HttpSelfHostServer(config);

            server.OpenAsync();


            TaskManager.Instance.Initialize();
            TaskManager.Instance.Start();
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server);

            Console.WriteLine("Server  http://localhost:8080   Open now ....at {0}..", server.Configuration.VirtualPathRoot);
            config.EnsureInitialized();
            foreach (var route in config.Routes)
            {
                System.Diagnostics.Debug.WriteLine(route);
            }

            Console.ReadLine();
        }
 SomeFunction()
 {
     using (var client = new HttpClient(
                HttpClientFactory.CreatePipeline(
                    new HttpClientHandler
     {
         CookieContainer = new CookieContainer(),
         UseCookies = true
     },
                    new DelegatingHandler[] { new CustomHandler() })))
     {
         //do something with `client`
     }
 }