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)
{
}
