public static void RegisterRoutes(HttpRouteCollection routes) { routes.MapHttpRoute("BeersRoute", "beers/{id}", new { controller = "Beer" }); // this one is needed only because beers vs. 1 beer are separated into 2 controllers routes.MapHttpRoute("DefaultApi", "{controller}/{id}", new { id = RouteParameter.Optional }); routes.MapHttpRoute("BreweryBeersRoute", "breweries/{id}/beers", new { controller = "BeersFromBrewery" }); routes.MapHttpRoute("StyleBeersRoute", "styles/{id}/beers", new { controller = "BeersFromStyle" }); }
public void AdvancedMapODataServiceRoute_ConfiguresARoute_WithAnODataRouteConstraintAndVersionConstraints() { // Arrange HttpRouteCollection routes = new HttpRouteCollection(); IEdmModel model = new EdmModel(); string routeName = "name"; string routePrefix = "prefix"; var pathHandler = new DefaultODataPathHandler(); var conventions = new List<IODataRoutingConvention>(); // Act routes.MapODataServiceRoute(routeName, routePrefix, model, pathHandler, conventions); // Assert IHttpRoute odataRoute = routes[routeName]; Assert.Single(routes); Assert.Equal(routePrefix + "/{*odataPath}", odataRoute.RouteTemplate); Assert.Equal(2, odataRoute.Constraints.Count); var odataPathConstraint = Assert.Single(odataRoute.Constraints.Values.OfType<ODataPathRouteConstraint>()); Assert.Same(model, odataPathConstraint.EdmModel); Assert.IsType<DefaultODataPathHandler>(odataPathConstraint.PathHandler); Assert.NotNull(odataPathConstraint.RoutingConventions); var odataVersionConstraint = Assert.Single(odataRoute.Constraints.Values.OfType<ODataVersionConstraint>()); Assert.Equal(ODataVersion.V1, odataVersionConstraint.MinVersion); Assert.Equal(ODataVersion.V3, odataVersionConstraint.MaxVersion); }
public void Test() { //var apiExplorer = new Mock<IApiExplorer>(); //var apiDescriptions = new Collection<ApiDescription>(); //var httpConfiguration = new HttpConfiguration(); //var actionDescriptor = // new ReflectedHttpActionDescriptor( // new HttpControllerDescriptor(httpConfiguration, typeof (TestController).Name, typeof (TestController)), // new TestController().GetType().GetMethod("Get")); //var apiDescriptionMock = new Mock<ApiDescription>(); //apiDescriptionMock.Setup(x => x.ResponseDescription).Returns(new ResponseDescription()); //apiDescriptionMock.Setup(x => x.ActionDescriptor).Returns(actionDescriptor); //apiDescriptionMock.Setup(x => x.RelativePath).Returns("test"); //apiDescriptionMock.Setup(x => x.Route).Returns(new HttpRoute("test/{id}")); //apiDescriptions.Add(apiDescriptionMock.Object); //apiExplorer.Setup(x => x.ApiDescriptions).Returns(apiDescriptions); var routes = new HttpRouteCollection(); routes.Add("test", new HttpRoute("test/{id}")); var conf = new HttpConfiguration(routes); var apiExplorer = conf.Services.GetApiExplorer(); var apiExplorerService = new ApiExplorerService(apiExplorer, "http://test.com"); var ramlDoc = apiExplorerService.GetRaml(); Assert.IsNotNull(ramlDoc); }
public static void RegisterRoutes(HttpRouteCollection routes) { routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional }); }
private HttpConfiguration(HttpConfiguration configuration, HttpControllerSettings settings) { _routes = configuration.Routes; _filters = configuration.Filters; _messageHandlers = configuration.MessageHandlers; _properties = configuration.Properties; _dependencyResolver = configuration.DependencyResolver; IncludeErrorDetailPolicy = configuration.IncludeErrorDetailPolicy; // per-controller settings Services = settings.IsServiceCollectionInitialized ? settings.Services : configuration.Services; _formatters = settings.IsFormatterCollectionInitialized ? settings.Formatters : configuration.Formatters; ParameterBindingRules = settings.IsParameterBindingRuleCollectionInitialized ? settings.ParameterBindingRules : configuration.ParameterBindingRules; // Use the original configuration's initializer so that its Initialize() // will perform the same logic on this clone as on the original. Initializer = configuration.Initializer; // create a new validator cache if the validator providers have changed if (settings.IsServiceCollectionInitialized && !settings.Services.GetModelValidatorProviders().SequenceEqual(configuration.Services.GetModelValidatorProviders())) { ModelValidatorCache validatorCache = new ModelValidatorCache(new Lazy<IEnumerable<ModelValidatorProvider>>(() => Services.GetModelValidatorProviders())); RegisterForDispose(validatorCache); settings.Services.Replace(typeof(IModelValidatorCache), validatorCache); } }
public void HttpRouteCollection_Dispose_UniquifiesHandlers() { // Arrange var collection = new HttpRouteCollection(); var handler1 = new Mock<HttpMessageHandler>(); handler1.Protected().Setup("Dispose", true).Verifiable(); var handler2 = new Mock<HttpMessageHandler>(); handler1.Protected().Setup("Dispose", true).Verifiable(); var route1 = new Mock<IHttpRoute>(); route1.SetupGet(r => r.Handler).Returns(handler1.Object); var route2 = new Mock<IHttpRoute>(); route2.SetupGet(r => r.Handler).Returns(handler1.Object); var route3 = new Mock<IHttpRoute>(); route3.SetupGet(r => r.Handler).Returns(handler2.Object); collection.Add("route1", route1.Object); collection.Add("route2", route2.Object); collection.Add("route3", route3.Object); // Act collection.Dispose(); // Assert handler1.Protected().Verify("Dispose", Times.Once(), true); handler2.Protected().Verify("Dispose", Times.Once(), true); }
private static void RegisterRoutes( HttpRouteCollection routes ) { routes.MapHttpRoute( "Info", "", new { controller = "Game", action = "Info" } ); routes.MapHttpRoute( "User", "User", new { controller = "User" } ); routes.MapHttpRoute( "Game", "{action}", new { controller = "Game" } ); routes.MapHttpRoute( "Default", "{controller}/{action}" ); }
public bool TryAddRoute(string routeName, string routeTemplate, IEnumerable<HttpMethod> methods, HttpRouteCollection routes, out IHttpRoute route) { route = null; try { var routeBuilder = CreateRouteBuilder(routeTemplate); var constraints = routeBuilder.Constraints; if (methods != null) { // if the methods collection is not null, apply the constraint // if the methods collection is empty, we'll create a constraint // that disallows ALL methods constraints.Add("httpMethod", new HttpMethodConstraint(methods.ToArray())); } route = routes.CreateRoute(routeBuilder.Template, routeBuilder.Defaults, constraints); routes.Add(routeName, route); } catch (Exception ex) when (!ex.IsFatal()) { // catch any route parsing errors return false; } return true; }
public static void RegisterRoutes(HttpRouteCollection routes) { // See http://github.com/mccalltd/AttributeRouting/wiki for more options. // To debug routes locally using the built in ASP.NET development server, go to /routes.axd routes.MapHttpAttributeRoutes(); }
public void Match_UsesODataDefaultRoutingConventions_IfControllerFound(string expectedControllerName, string entitySetName) { // Arrange const string routeName = "api"; var request = new HttpRequestMessage(HttpMethod.Get, "http://any/" + entitySetName); var routeCollection = new HttpRouteCollection { { routeName, new HttpRoute() } }; var config = new HttpConfiguration(routeCollection); request.SetConfiguration(config); var pathHandler = new DefaultODataPathHandler(); var model = GetEdmModel(); config.MapHttpAttributeRoutes(); var conventions = config.CreateODataDomainRoutingConventions<NorthwindDomainController>(model); var constraint = new DefaultODataPathRouteConstraint(pathHandler, model, routeName, conventions); config.EnsureInitialized(); var values = new Dictionary<string, object> { { ODataRouteConstants.ODataPath, entitySetName }, }; // Act var matched = constraint.Match(request, route: null, parameterName: null, values: values, routeDirection: HttpRouteDirection.UriResolution); // Assert Assert.True(matched); Assert.Equal(expectedControllerName, values[ODataRouteConstants.Controller]); }
private void Configure(HttpRouteCollection routes) { routes.MapHttpRoute( "DefaultApiWithId", "Api/TestDependency", new { controller = "TestDependency" }); }
public static void RegisterRoutes(HttpRouteCollection routes) { // See http://github.com/mccalltd/AttributeRouting/wiki for more options. // To debug routes locally using the built in ASP.NET development server, go to /routes.axd Assembly assembly = Assembly.GetAssembly(typeof(IPDetectServer.Services.ServiceAssemble)); routes.MapHttpAttributeRoutes(config=>config.AddRoutesFromAssembly(assembly)); }
public static void RegisterRoutes(HttpRouteCollection routes) { //routes.MapHttpRoute( // "Default", // "{controller}/{action}/{id}", // new { controller = "Home", action = "Get", id = RouteParameter.Optional } //); }
public static void RegisterRoutes(HttpRouteCollection routes) { routes.MapHttpRoute( "DefaultHttpRoute", "api/{controller}/{key}", defaults: new { key = RouteParameter.Optional }, constraints: new { key = new GuidRouteConstraint() }); }
private static void ConfigureWebApiRoutes(HttpRouteCollection routes) { routes.MapHttpRoute( "API Default", "api/{controller}/{id}", new { id = RouteParameter.Optional } ); }
private static void Configure(HttpRouteCollection routes) { routes.MapHttpRoute( "DefaultApiWithId", "Api/{controller}/{id}", new { id = RouteParameter.Optional }, new { id = @"\d+" }); }
public static void RegisterRoutes(HttpRouteCollection routes) { routes.MapHttpRoute( name: "Leases", routeTemplate: "leases/{resource}/{leaseId}", defaults: new { controller = "Leases", resource = RouteParameter.Optional, leaseId = RouteParameter.Optional } ); }
/// <summary> /// Routing registration. /// </summary> /// <param name="routes"></param> public static void RegisterRoutes(HttpRouteCollection routes) { routes.MapHttpRoute( "Default", "api/{controller}/{id}", new {controller = "Default", id = RouteParameter.Optional}, new {} ); }
public void BuildRouteTable() { routes = new HttpRouteCollection(); configuration = new HttpConfiguration(routes); documentationProvider = new Mock<IDocumentationProviderEx>(); configuration.Services.Replace(typeof(IDocumentationProvider), documentationProvider.Object); new NuGetWebApiRouteMapper("api/").MapApiRoutes(configuration); }
public void Parameter_Constructor() { string path = "/some/path"; HttpRouteCollection routes = new HttpRouteCollection(path); HttpConfiguration configuration = new HttpConfiguration(routes); Assert.Same(routes, configuration.Routes); Assert.Equal(path, configuration.VirtualPathRoot); }
public static void RegisterRoutes(HttpRouteCollection routes) { routes.MapHttpAttributeRoutes( config => { config.AddRoutesFromAssembly(Assembly.GetExecutingAssembly()); config.AddDefaultRouteConstraint(@"^id$", new RegexRouteConstraint(@"^\d+$")); }); }
public static TestContext InitializeRoutesTest(TestContext testContext) { //context = testContext; HttpRouteCollection routes = new HttpRouteCollection(); HttpConfiguration config = new HttpConfiguration(routes); testContext.Properties["routes"] = routes; testContext.Properties["config"] = config; WebApiConfig.Register(config); return testContext; }
/// <summary> /// Initializes a new instance of the <see cref="HttpConfiguration"/> class. /// </summary> /// <param name="routes">The <see cref="HttpRouteCollection"/> to associate with this instance.</param> public HttpConfiguration(HttpRouteCollection routes) { if (routes == null) { throw Error.ArgumentNull("routes"); } _routes = routes; _serviceResolver = new DependencyResolver(this); }
/// <summary> /// Initializes a new instance of the <see cref="HttpConfiguration"/> class. /// </summary> /// <param name="routes">The <see cref="HttpRouteCollection"/> to associate with this instance.</param> public HttpConfiguration(HttpRouteCollection routes) { if (routes == null) { throw Error.ArgumentNull("routes"); } _routes = routes; Services = new DefaultServices(this); }
public void Testv1() { var routes = new HttpRouteCollection(); routes.Add("test", new HttpRoute("test/{id}")); var conf = new HttpConfiguration(routes); var apiExplorer = conf.Services.GetApiExplorer(); var apiExplorerService = new ApiExplorerServiceVersion1(apiExplorer, "http://test.com"); var ramlDoc = apiExplorerService.GetRaml(); Assert.IsNotNull(ramlDoc); Assert.AreEqual(RamlVersion.Version1, ramlDoc.RamlVersion); }
public static void RegisterRoutes(HttpRouteCollection routes) { //Register routes //in this example Attribute base Routing is used //routes.MapHttpRoute( // name: "PartialIngest", // routeTemplate: "api/{controller}/{id}", // defaults: new { controller = "PartialIngest", id = RouteParameter.Optional } //); }
private void AddHttpRoutes(HttpRouteCollection routeCollection) { //var routes = GetRoutes(); foreach (var route in this.routes) { routeCollection.MapHttpRoute( route.Name, route.Template, route.Defaults); } }
/// <summary> /// Initializes a new instance of the <see cref="HttpConfiguration"/> class. /// </summary> /// <param name="routes">The <see cref="HttpRouteCollection"/> to associate with this instance.</param> public HttpConfiguration(HttpRouteCollection routes) { if (routes == null) { throw Error.ArgumentNull("routes"); } _routes = routes; Services = new DefaultServices(this); ParameterBindingRules = DefaultActionValueBinder.GetDefaultParameterBinders(); }
private static void Configure(HttpRouteCollection routes) { routes.MapHttpRoute( "Hello", "Api/Hello", new { controller = "Test", action = "ReturnHello" }); }
/// <summary> /// Registers the HTTP routes. /// </summary> public static void RegisterRoutes(HttpRouteCollection httpRouteCollection) { // Build the HTTP method contraint. HttpMethodConstraint httpMethodConstraint = new HttpMethodConstraint(HttpMethod.Post); // Map the HTTP route. httpRouteCollection.MapHttpRoute( name: "api/scheduling/course-schedules", routeTemplate: "api/scheduling/course-schedules", defaults: new { controller = "CourseSchedules" }, constraints: new { httpMethods = httpMethodConstraint }); }
/// <summary> /// Scans the specified assemblies for all routes defined with AttributeRouting attributes, /// and applies configuration options against the routes found. /// </summary> /// <param name="routes"> </param> /// <param name="configuration">The configuration object</param> public static void MapHttpAttributeRoutes(this HttpRouteCollection routes, HttpWebAttributeRoutingConfiguration configuration) { routes.MapHttpAttributeRoutesInternal(configuration); }
/// <summary> /// 注册URL路由配置 /// </summary> /// <param name="routes"></param> public virtual void RegisterRoutes(HttpRouteCollection routes) { routes.MapHttpRoute("DefaultApi", "{controller}/{action}/{id}", new { id = RouteParameter.Optional }); }
/// <summary> /// Test method to call constraint.Match using the proper arguments for each platform. /// </summary> /// <param name="constraint">The constraint object.</param> /// <param name="routeRequest">The abstracted request.</param> /// <param name="direction">The abstracted route direction.</param> /// <returns>Result from constraint.Match,</returns> private bool ConstraintMatch(ODataPathRouteConstraint constraint, TestRouteRequest routeRequest, Dictionary <string, object> values, RouteDirection direction) { #if NETCORE IRouteBuilder config = RoutingConfigurationFactory.Create(); if (routeRequest?.PathHandler != null && routeRequest?.Model != null) { config.MapODataServiceRoute(_routeName, "", builder => builder.AddService(Microsoft.OData.ServiceLifetime.Singleton, sp => routeRequest.PathHandler) .AddService(Microsoft.OData.ServiceLifetime.Singleton, sp => routeRequest.Model)); } else if (routeRequest?.PathHandler != null) { config.MapODataServiceRoute(_routeName, "", builder => builder.AddService(Microsoft.OData.ServiceLifetime.Singleton, sp => routeRequest.PathHandler)); } else if (routeRequest?.Model != null) { config.MapODataServiceRoute(_routeName, "", builder => builder.AddService(Microsoft.OData.ServiceLifetime.Singleton, sp => routeRequest.Model)); } else { config.MapODataServiceRoute(_routeName, "", builder => { }); } HttpRequest request = (routeRequest != null) ? RequestFactory.Create(routeRequest.Method, routeRequest.Uri, config, _routeName) : RequestFactory.Create(); // The RequestFactory will create a request container which most tests want but for checking the constraint, // we don't want a request container before the test runs since Match() creates one. request.DeleteRequestContainer(true); if (routeRequest != null) { routeRequest.InnerRequest = request; } AspNetCore.Routing.RouteDirection routeDirection = (direction == RouteDirection.UriResolution) ? AspNetCore.Routing.RouteDirection.IncomingRequest : AspNetCore.Routing.RouteDirection.UrlGeneration; RouteValueDictionary routeValues = new RouteValueDictionary(values); return(constraint.Match(request.HttpContext, null, null, routeValues, routeDirection)); #else HttpRequestMessage request = (routeRequest != null) ? new HttpRequestMessage(routeRequest.Method, routeRequest.Uri) : new HttpRequestMessage(); var httpRouteCollection = new HttpRouteCollection { { _routeName, new HttpRoute() }, }; var configuration = new HttpConfiguration(httpRouteCollection); if (routeRequest != null && routeRequest.PathHandler != null && routeRequest.Model != null) { configuration.CreateODataRootContainer(_routeName, builder => builder.AddService(Microsoft.OData.ServiceLifetime.Singleton, sp => routeRequest.PathHandler) .AddService(Microsoft.OData.ServiceLifetime.Singleton, sp => routeRequest.Model)); } else if (routeRequest != null && routeRequest.PathHandler != null) { configuration.CreateODataRootContainer(_routeName, builder => builder.AddService(Microsoft.OData.ServiceLifetime.Singleton, sp => routeRequest.PathHandler)); } else if (routeRequest != null && routeRequest.Model != null) { configuration.CreateODataRootContainer(_routeName, builder => builder.AddService(Microsoft.OData.ServiceLifetime.Singleton, sp => routeRequest.Model)); } else { PerRouteContainer perRouteContainer = configuration.GetPerRouteContainer() as PerRouteContainer; perRouteContainer.SetODataRootContainer(_routeName, _rootContainer); } request.SetConfiguration(configuration); if (routeRequest != null) { routeRequest.InnerRequest = request; } HttpRouteDirection routeDirection = (direction == RouteDirection.UriResolution) ? HttpRouteDirection.UriResolution : HttpRouteDirection.UriGeneration; return(constraint.Match(request, null, null, values, routeDirection)); #endif }
public static void AddHttpRoutes(this HttpRouteCollection routeCollection) { var routes = GetRoutes(); routes.ForEach(route => routeCollection.MapHttpRoute(route.Name, route.Template, route.Defaults)); }
public static void MapODataServiceRoute(this HttpRouteCollection routes, IEdmModel model) { routes.MapODataServiceRoute("IgnoredRouteName", null, model); }
public bool TryAddRoute(string routeName, string routeTemplate, IEnumerable <HttpMethod> methods, HttpRouteCollection routes, out IHttpRoute route) { route = null; try { var routeBuilder = CreateRouteBuilder(routeTemplate); var constraints = routeBuilder.Constraints; if (methods != null) { // if the methods collection is not null, apply the constraint // if the methods collection is empty, we'll create a constraint // that disallows ALL methods constraints.Add("httpMethod", new HttpMethodConstraint(methods.ToArray())); } route = routes.CreateRoute(routeBuilder.Template, routeBuilder.Defaults, constraints); routes.Add(routeName, route); } catch (Exception ex) when(!ex.IsFatal()) { // catch any route parsing errors return(false); } return(true); }
public static void RegisterRoutes(HttpRouteCollection routes) { routes.MapHttpAttributeRoutes(); }
private static void MapHttpAttributeRoutesInternal(this HttpRouteCollection routes, HttpWebAttributeRoutingConfiguration configuration) { var generatedRoutes = new RouteBuilder(configuration).BuildAllRoutes(); generatedRoutes.ToList().ForEach(r => routes.Add(r.RouteName, (HttpAttributeRoute)r)); }
public static void Register(HttpRouteCollection routes) { }
public RouteTemplateMiddleware(OwinMiddleware next, HttpRouteCollection routes) : base(next) { _routes = routes; }
/// <summary> /// Maps the specified OData route. When the <paramref name="batchHandler"/> is provided, it will create a /// '$batch' endpoint to handle the batch requests. /// </summary> /// <param name="routes">A collection of routes for the application.</param> /// <param name="routeName">The name of the route to map.</param> /// <param name="routePrefix">The prefix to add to the OData route's path template.</param> /// <param name="model">The EDM model to use for parsing OData paths.</param> /// <param name="batchHandler">The <see cref="ODataBatchHandler"/>.</param> /// <returns>The added <see cref="ODataRoute"/>.</returns> public static ODataRoute MapODataServiceRoute(this HttpRouteCollection routes, string routeName, string routePrefix, IEdmModel model, ODataBatchHandler batchHandler) { return(MapODataServiceRoute(routes, routeName, routePrefix, model, new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault(), batchHandler)); }
/// <summary> /// Maps the specified OData route. /// </summary> /// <param name="routes">A collection of routes for the application.</param> /// <param name="routeName">The name of the route to map.</param> /// <param name="routePrefix">The prefix to add to the OData route's path template.</param> /// <param name="model">The EDM model to use for parsing OData paths.</param> /// <returns>The added <see cref="ODataRoute"/>.</returns> public static ODataRoute MapODataServiceRoute(this HttpRouteCollection routes, string routeName, string routePrefix, IEdmModel model) { return(MapODataServiceRoute(routes, routeName, routePrefix, model, batchHandler: null)); }
public static void RegisterRoutes(HttpRouteCollection routes) { routes.MapHttpRoute( name: "playr/pause", routeTemplate: "pause", defaults: new { controller = "control", action = "pause" } ); routes.MapHttpRoute( name: "playr/play", routeTemplate: "play", defaults: new { controller = "control", action = "play" } ); routes.MapHttpRoute( name: "playr/playpause", routeTemplate: "playpause", defaults: new { controller = "control", action = "playpause" } ); routes.MapHttpRoute( name: "playr/next", routeTemplate: "next", defaults: new { controller = "control", action = "next" } ); routes.MapHttpRoute( name: "playr/previous", routeTemplate: "previous", defaults: new { controller = "control", action = "previous" } ); routes.MapHttpRoute( name: "playr/volume/up", routeTemplate: "volume/up", defaults: new { controller = "control", action = "VolumeUp" } ); routes.MapHttpRoute( name: "playr/volume/down", routeTemplate: "volume/down", defaults: new { controller = "control", action = "VolumeDown" } ); routes.MapHttpRoute( name: "playr/current", routeTemplate: "current", defaults: new { controller = "info", action = "CurrentTrack" } ); routes.MapHttpRoute( name: "playr/queue", routeTemplate: "queue", defaults: new { controller = "info", action = "Queue" } ); routes.MapHttpRoute( name: "playr/queue/id", routeTemplate: "queue/{id}", defaults: new { controller = "info", action = "QueueSong" } ); routes.MapHttpRoute( name: "playr/songs/id/download", routeTemplate: "songs/{id}/download", defaults: new { controller = "info", action = "DownloadSong" } ); routes.MapHttpRoute( name: "playr/songs/id/artwork", routeTemplate: "songs/{id}/artwork", defaults: new { controller = "info", action = "Artwork" } ); routes.MapHttpRoute( name: "playr/songs/id/favorite", routeTemplate: "songs/{id}/favorite", defaults: new { controller = "info", action = "favorite" } ); routes.MapHttpRoute( name: "playr/albums/name/download", routeTemplate: "albums/{name}/download", defaults: new { controller = "info", action = "DownloadAlbum" } ); routes.MapHttpRoute( name: "playr/upload", routeTemplate: "upload", defaults: new { controller = "info", action = "upload" } ); routes.MapHttpRoute( name: "playr/say", routeTemplate: "say", defaults: new { controller = "control", action = "speak" } ); routes.MapHttpRoute( name: "playr/users/register", routeTemplate: "users/register", defaults: new { controller = "users", action = "register" } ); routes.MapHttpRoute( name: "playr/users/email", routeTemplate: "users/{email}", defaults: new { controller = "users", action = "find" } ); routes.MapHttpRoute( name: "playr/users/email/reset", routeTemplate: "users/{email}/reset", defaults: new { controller = "users", action = "resetToken" } ); //routes.MapHttpRoute("default", "{controller}/{action}"); }
private static void Configure(HttpRouteCollection routes) { routes.MapHttpRoute("TaxApi", "api/{controller}/{municipality}/{date}", new { municipality = RouteParameter.Optional, date = RouteParameter.Optional } ); }
public static void Configure(HttpRouteCollection routes) { RouteTable.Routes.Ignore("{resource}.axd/{*pathInfo}"); routes.MapUrlVersionedHttpRoute("Default", "{controller}/{action}/{id}", new { id = RouteParameter.Optional }); }
public static IHttpRoute MapHttpRoute(this HttpRouteCollection routes, string name, string routeTemplate, object defaults, SessionStateBehavior sessionBehavior, UserSessionRole[] requiredRoles) { return(MapHttpRoute(routes, name, routeTemplate, defaults, null, sessionBehavior, requiredRoles)); }
/// <summary> /// Maps the specified OData route and the OData route attributes. /// </summary> /// <param name="configuration">The server configuration.</param> /// <param name="routeName">The name of the route to map.</param> /// <param name="routePrefix">The prefix to add to the OData route's path template.</param> /// <param name="configureAction">The configuring action to add the services to the root container.</param> /// <returns>The added <see cref="ODataRoute"/>.</returns> public static ODataRoute MapODataServiceRoute(this HttpConfiguration configuration, string routeName, string routePrefix, Action <IContainerBuilder> configureAction) { if (configuration == null) { throw Error.ArgumentNull("configuration"); } if (routeName == null) { throw Error.ArgumentNull("routeName"); } // 1) Build and configure the root container. IServiceProvider rootContainer = configuration.CreateODataRootContainer(routeName, configureAction); // 2) Resolve the path handler and set URI resolver to it. IODataPathHandler pathHandler = rootContainer.GetRequiredService <IODataPathHandler>(); // if settings is not on local, use the global configuration settings. if (pathHandler != null && pathHandler.UrlKeyDelimiter == null) { ODataUrlKeyDelimiter urlKeyDelimiter = configuration.GetUrlKeyDelimiter(); pathHandler.UrlKeyDelimiter = urlKeyDelimiter; } // 3) Resolve some required services and create the route constraint. ODataPathRouteConstraint routeConstraint = new ODataPathRouteConstraint(routeName); // Attribute routing must initialized before configuration.EnsureInitialized is called. rootContainer.GetServices <IODataRoutingConvention>(); // 4) Resolve HTTP handler, create the OData route and register it. ODataRoute route; HttpRouteCollection routes = configuration.Routes; routePrefix = RemoveTrailingSlash(routePrefix); HttpMessageHandler messageHandler = rootContainer.GetService <HttpMessageHandler>(); if (messageHandler != null) { route = new ODataRoute( routePrefix, routeConstraint, defaults: null, constraints: null, dataTokens: null, handler: messageHandler); } else { ODataBatchHandler batchHandler = rootContainer.GetService <ODataBatchHandler>(); if (batchHandler != null) { batchHandler.ODataRouteName = routeName; string batchTemplate = String.IsNullOrEmpty(routePrefix) ? ODataRouteConstants.Batch : routePrefix + '/' + ODataRouteConstants.Batch; routes.MapHttpBatchRoute(routeName + "Batch", batchTemplate, batchHandler); } route = new ODataRoute(routePrefix, routeConstraint); } routes.Add(routeName, route); return(route); }
public LinkGenerator(HttpRouteCollection routeCollection, IEnumerable <IHttpController> controllers) { _routeCollection = routeCollection; _controllers = controllers; }
void RegisterWebApi(HttpRouteCollection routes) { routes.MapHttpAttributeRoutes(c => c.AddRoutesFromAssembly(_webApiControllerExample.Assembly)); }
public CustomRouteBehavior() { config = new HttpConfiguration(); routes = config.Routes; }
public static IHttpRoute MapHttpRoute(this HttpRouteCollection routes, string name, string routeTemplate, object defaults, string[] namespaces) { return(routes.MapHttpRoute(name, routeTemplate, defaults, null, null, namespaces)); }
/// <summary> /// Maps the HTTP route lowercase. /// </summary> /// <param name="routes">The routes.</param> /// <param name="name">The name.</param> /// <param name="routeTemplate">The route template.</param> /// <param name="defaults">The defaults.</param> /// <returns></returns> public static IHttpRoute MapHttpRouteLowercase(this HttpRouteCollection routes, string name, string routeTemplate, object defaults) { return(MapHttpRouteLowercase(routes, name, routeTemplate, defaults, null)); }
private void AddHttpRoutes(HttpRouteCollection routeCollection) { var routes = GetRoutes(); routes.ForEach(route => routeCollection.MapHttpRoute(route.Name, route.Template, route.Defaults)); }
public HttpRouterConfigurator(HttpRouteCollection routes) { this.routes = routes; }
public HandlebarsMediaTypeFormatter(HttpRouteCollection routes, IHandlebarsTemplate template, IRequestFormatter formatter) : this(new HttpConfiguration(routes), template, formatter) { }
/// <summary> /// Routes are mapped such that urls generated are lowercase /// </summary> /// <param name="routes"></param> public static void RegisterRoutes(HttpRouteCollection routes) { //NB: ic === "institution code"; ver === "version" string instCode = "Core"; routes.IgnoreRoute(routeName: "resources", routeTemplate: "{resource}.axd/{*pathInfo}"); routes.IgnoreRoute("static", "{ *staticfile}", new { staticfile = @".*\.(css|less|sass|js|gif|png|jpg|jpeg|ico|svg|ttf|eot|woff|woff2|xml|csv|txt|map|json|pdf|doc|docx|xls|xlsx|dll|exe|pdb)(/.*)?" }); // From most specific to most general routes.MapHttpRoute( //LowerCase( name: "Api_Default", routeTemplate: "api/", defaults: new { ver = "1.0", ic = instCode, area = "", controller = "Home", action = "Index", id = RouteParameter.Optional }, constraints: new { id = @"\d*" } ); routes.MapHttpRoute( //LowerCase( name: "Api_DefaultApi", routeTemplate: "api/{ver}/", defaults: new { ic = instCode, area = "", controller = "Home", action = "Index", id = RouteParameter.Optional }, constraints: new { id = @"\d*" } ); routes.MapHttpRoute( //LowerCase( name: "Api_Error", routeTemplate: "api/{ver}/Error", defaults: new { ic = instCode, area = "", controller = "Error", action = "Index", id = RouteParameter.Optional }, constraints: new { id = @"\d*" } ); routes.MapHttpRoute( //LowerCase( name: "Api_TenantError", routeTemplate: "api/{ver}/{ic}/Error", defaults: new { area = "", controller = "Error", action = "Index", id = RouteParameter.Optional }, constraints: new { id = @"\d*" } ); routes.MapHttpRoute( //LowerCase( name: "Api_IcOnly", routeTemplate: "api/{ver}/{ic}", defaults: new { area = "", controller = "Home", action = "Index", id = RouteParameter.Optional }, constraints: new { id = @"\d*" } ); // Ambigous; this clashes with the below a lot of times //routes.MapHttpRoute( //LowerCase( // name: "Api_ControllerAndActionOnly", // routeTemplate: "api/{ver}/{controller}/{action}/{id}", // defaults: new { ic = instCode, area = "", id = RouteParameter.Optional }, // constraints: new { id = @"\d*" } //); routes.MapHttpRoute( //LowerCase( name: "Api_MultiTenant", routeTemplate: "api/{ver}/{ic}/{controller}/{action}/{id}", defaults: new { area = "", id = RouteParameter.Optional }, constraints: new { id = @"\d*" } ); routes.MapHttpRoute( //LowerCase( name: "Api_MultiTenantWithArea", routeTemplate: "api/{ver}/{ic}/{area}/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional }, constraints: new { id = @"\d*" } ); }
public static void RegisterRoutes(HttpRouteCollection routes) { routes.MapHttpRoute( name: "UserNetwork", routeTemplate: "user/{id}/network/{networkId}", defaults: new { controller = "UserNetwork" } ); routes.MapHttpRoute( name: "User", routeTemplate: "user/{id}", defaults: new { controller = "User", id = RouteParameter.Optional } ); routes.MapHttpRoute( name: "Network", routeTemplate: "network/{id}", defaults: new { controller = "Network", id = RouteParameter.Optional } ); routes.MapHttpRoute( name: "DeviceClass", routeTemplate: "device/class/{id}", defaults: new { controller = "DeviceClass", id = RouteParameter.Optional } ); routes.MapHttpRoute( name: "Equipment", routeTemplate: "device/class/{deviceClassId}/equipment/{id}", defaults: new { controller = "Equipment", id = RouteParameter.Optional } ); routes.MapHttpRoute( name: "DeviceNotificationPoll", routeTemplate: "device/{deviceGuid}/notification/poll", defaults: new { controller = "DeviceNotificationPoll" } ); routes.MapHttpRoute( name: "DeviceNotificationPollMany", routeTemplate: "device/notification/poll", defaults: new { controller = "DeviceNotificationPoll" } ); routes.MapHttpRoute( name: "DeviceNotification", routeTemplate: "device/{deviceGuid}/notification/{id}", defaults: new { controller = "DeviceNotification", id = RouteParameter.Optional } ); routes.MapHttpRoute( name: "DeviceCommandIdPoll", routeTemplate: "device/{deviceGuid}/command/{id}/poll", defaults: new { controller = "DeviceCommandPoll" } ); routes.MapHttpRoute( name: "DeviceCommandPoll", routeTemplate: "device/{deviceGuid}/command/poll", defaults: new { controller = "DeviceCommandPoll" } ); routes.MapHttpRoute( name: "DeviceCommand", routeTemplate: "device/{deviceGuid}/command/{id}", defaults: new { controller = "DeviceCommand", id = RouteParameter.Optional } ); routes.MapHttpRoute( name: "DeviceEquipment", routeTemplate: "device/{id}/equipment/{code}", defaults: new { controller = "DeviceEquipment", code = RouteParameter.Optional } ); routes.MapHttpRoute( name: "Device", routeTemplate: "device/{id}", defaults: new { controller = "Device", id = RouteParameter.Optional } ); routes.MapHttpRoute( name: "Info", routeTemplate: "info", defaults: new { controller = "ApiInfo" } ); routes.MapHttpRoute( name: "Cron", routeTemplate: "cron/{action}", defaults: new { controller = "Cron" } ); routes.MapHttpRoute( name: "Metadata", routeTemplate: "metadata", defaults: new { controller = "Metadata" } ); routes.MapHttpRoute( name: "Home", routeTemplate: "", defaults: new { controller = "Home" } ); }
protected virtual void ConfigureRoutes(HttpRouteCollection routes) { }
public FromRouteBinderPrecedenceBehavior() { config = new HttpConfiguration(); routes = config.Routes; }
protected virtual void RegisterRoutes(HttpRouteCollection routes) { }