/// <summary>
/// Adds the specified controller as a managed odata controller.
/// </summary>
/// <param name="entitySetName"></param>
/// <param name="httpControllerDescriptor"></param>
/// <exception cref="ArgumentException">If <paramref name="entitySetName"/> already exists in the collection.</exception>
public void AddController(string entitySetName, HttpControllerDescriptor httpControllerDescriptor)
{
Contract.Requires<ArgumentException>(! string.IsNullOrWhiteSpace(entitySetName));
Contract.Requires<ArgumentNullException>(httpControllerDescriptor != null);
if (_fallbackControllerSelector.GetControllerMapping().ContainsKey(entitySetName))
{
throw new ArgumentException(string.Format("HttpControllerDescriptor with name '{0}' already exists in this Web API.", entitySetName));
}
_managedControllers.Add(entitySetName, httpControllerDescriptor);
}
/// <summary>
/// Initializes a new instance of the <see cref="AttributeRoutingConvention"/> class.
/// </summary>
/// <param name="routeName">The name of the route.</param>
/// <param name="configuration">The <see cref="HttpConfiguration"/> to use for figuring out all the controllers to
/// look for a match.</param>
/// <param name="pathTemplateHandler">The path template handler to be used for parsing the path templates.</param>
public AttributeRoutingConvention(string routeName, HttpConfiguration configuration,
IODataPathTemplateHandler pathTemplateHandler)
: this(routeName, pathTemplateHandler)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
IODataPathHandler pathHandler = pathTemplateHandler as 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;
}
Action <HttpConfiguration> oldInitializer = configuration.Initializer;
bool initialized = false;
configuration.Initializer = (config) =>
{
if (!initialized)
{
initialized = true;
oldInitializer(config);
IHttpControllerSelector controllerSelector = config.Services.GetHttpControllerSelector();
_attributeMappings = BuildAttributeMappings(controllerSelector.GetControllerMapping().Values);
}
};
}
/// <summary>
/// Gets the <see cref="HttpControllerContext"/> for the supplied <see cref="Uri"/>.
/// </summary>
/// <param name="a_uri">
/// The URI.
/// </param>
/// <returns>
/// The <see cref="HttpControllerContext"/> instance for the supplier URI.
/// </returns>
private HttpControllerContext GetControllerContext(Uri a_uri)
{
using (var request = new HttpRequestMessage(HttpMethod.Get, a_uri))
{
var routeData = Configuration.Routes.GetRouteData(request);
if (routeData == null)
{
return(null);
}
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = Configuration;
var controllerContext = new HttpControllerContext(Configuration, routeData, request);
var controllerName = GetControllerName(routeData);
if (!m_controllerSelector.GetControllerMapping().ContainsKey(controllerName))
{
return(null);
}
controllerContext.ControllerDescriptor = m_controllerSelector.SelectController(request);
return(controllerContext);
}
}
private Collection <ApiDescription> InitializeApiDescriptions()
{
Collection <ApiDescription> apiDescriptions = new Collection <ApiDescription>();
IHttpControllerSelector controllerSelector = _config.Services.GetHttpControllerSelector();
IDictionary <string, HttpControllerDescriptor> controllerMappings = controllerSelector.GetControllerMapping();
if (controllerMappings != null)
{
ApiDescriptionComparer descriptionComparer = new ApiDescriptionComparer();
foreach (IHttpRoute route in FlattenRoutes(_config.Routes))
{
CandidateAction[] directRouteCandidates = route.GetDirectRouteCandidates();
HttpControllerDescriptor directRouteController = GetDirectRouteController(directRouteCandidates);
Collection <ApiDescription> descriptionsFromRoute =
(directRouteController != null && directRouteCandidates != null) ?
ExploreDirectRoute(directRouteController, directRouteCandidates, route) :
ExploreRouteControllers(controllerMappings, route);
// Remove ApiDescription that will lead to ambiguous action matching.
// E.g. a controller with Post() and PostComment(). When the route template is {controller}, it produces POST /controller and POST /controller.
descriptionsFromRoute = RemoveInvalidApiDescriptions(descriptionsFromRoute);
foreach (ApiDescription description in descriptionsFromRoute)
{
apiDescriptions.Add(description);
}
}
}
return(apiDescriptions);
}
/// <summary>
/// Initializes a new instance of the <see cref="AttributeRoutingConvention"/> class.
/// </summary>
/// <param name="model">The <see cref="IEdmModel"/> to be used for parsing the route templates.</param>
/// <param name="configuration">The <see cref="HttpConfiguration"/> to use for figuring out all the controllers to
/// look for a match.</param>
/// <param name="pathTemplateHandler">The path template handler to be used for parsing the path templates.</param>
public AttributeRoutingConvention(IEdmModel model, HttpConfiguration configuration,
IODataPathTemplateHandler pathTemplateHandler)
: this(model, pathTemplateHandler)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
DefaultODataPathHandler odataPathHandler = pathTemplateHandler as DefaultODataPathHandler;
if (odataPathHandler != null)
{
odataPathHandler.ResolverSetttings = configuration.GetResolverSettings();
}
Action <HttpConfiguration> oldInitializer = configuration.Initializer;
bool initialized = false;
configuration.Initializer = (config) =>
{
if (!initialized)
{
initialized = true;
oldInitializer(config);
IHttpControllerSelector controllerSelector = config.Services.GetHttpControllerSelector();
_attributeMappings = BuildAttributeMappings(controllerSelector.GetControllerMapping().Values);
}
};
}
private static IDictionary <ODataPathTemplate, HttpActionDescriptor> GetAttributeRoutingActionMap(HttpConfiguration httpConfig,
AttributeRoutingConvention routingConvention)
{
IHttpControllerSelector controllerSelector = httpConfig.Services.GetHttpControllerSelector();
return(BuildAttributeMappings(controllerSelector.GetControllerMapping().Values, routingConvention));
}
public void GetBinding_Wraps_FormatterParameterBinding(bool tracingEnabled)
{
// Arrange
HttpConfiguration config = new HttpConfiguration();
config.Services.Replace(
typeof(IAssembliesResolver),
new TestAssemblyResolver(new MockAssembly(typeof(PerRequestActionValueBinderTestSampleController))));
if (tracingEnabled)
{
config.Services.Replace(typeof(ITraceWriter), new Mock <ITraceWriter>().Object);
ITraceManager traceManager = config.Services.GetTraceManager();
traceManager.Initialize(config);
}
IHttpControllerSelector controllerSelector = config.Services.GetHttpControllerSelector();
IHttpActionSelector actionSelector = config.Services.GetActionSelector();
HttpControllerDescriptor controllerDescriptor = controllerSelector.GetControllerMapping()["PerRequestActionValueBinderTestSample"];
HttpActionDescriptor actionDescriptor = actionSelector.GetActionMapping(controllerDescriptor)["Post"].Single();
PerRequestActionValueBinder binder = new PerRequestActionValueBinder(new DefaultActionValueBinder());
// Act
HttpActionBinding binding = binder.GetBinding(actionDescriptor);
// Assert
HttpParameterBinding parameterBinding = binding.ParameterBindings.Where(p => p.Descriptor.ParameterName == "customer").Single();
Assert.True(parameterBinding is PerRequestParameterBinding);
}
static void Main(string[] args)
{
HttpConfiguration configuration = new HttpConfiguration();
IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector();
IDictionary <string, HttpControllerDescriptor> mappings = controllerSelector.GetControllerMapping();
Console.WriteLine("{0,-16}{1,-10}", "ControllerName", "TypeName");
foreach (var item in mappings)
{
Console.WriteLine("{0,-16}{1,-10}", item.Key, item.Value.ControllerType.Name);
}
}
private static HttpRouteCollection MapHttpAttributeRoutesInternal(this HttpConfiguration configuration, HttpRouteBuilder routeBuilder)
{
HttpRouteCollection subRoutes = new HttpRouteCollection();
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
if (routeBuilder == null)
{
throw Error.ArgumentNull("routeBuilder");
}
List <HttpRouteEntry> attributeRoutes = new List <HttpRouteEntry>();
IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector();
IDictionary <string, HttpControllerDescriptor> controllerMap = controllerSelector.GetControllerMapping();
if (controllerMap != null)
{
foreach (HttpControllerDescriptor controllerDescriptor in controllerMap.Values)
{
IEnumerable <HttpRouteEntry> controllerRoutes = CreateRouteEntries(controllerDescriptor);
foreach (HttpRouteEntry route in controllerRoutes)
{
route.Route = routeBuilder.BuildHttpRoute(route.Template, route.Actions);
}
SetDefaultRouteNames(controllerRoutes, controllerDescriptor.ControllerName);
attributeRoutes.AddRange(controllerRoutes);
}
attributeRoutes.Sort();
foreach (HttpRouteEntry attributeRoute in attributeRoutes)
{
IHttpRoute route = attributeRoute.Route;
if (route != null)
{
subRoutes.Add(attributeRoute.Name, attributeRoute.Route);
}
}
}
return(subRoutes);
}
private static void AddRouteEntries(SubRouteCollection collector, HttpConfiguration configuration,
IInlineConstraintResolver constraintResolver)
{
Contract.Assert(configuration != null);
IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector();
IDictionary <string, HttpControllerDescriptor> controllerMap = controllerSelector.GetControllerMapping();
if (controllerMap != null)
{
foreach (HttpControllerDescriptor controllerDescriptor in controllerMap.Values)
{
AddRouteEntries(collector, controllerDescriptor, constraintResolver);
}
}
}
private Collection <ApiDescription> InitializeApiDescriptions()
{
Collection <ApiDescription> apiDescriptions = new Collection <ApiDescription>();
IHttpControllerSelector controllerSelector =
_config.Services.GetHttpControllerSelector();
IDictionary <string, HttpControllerDescriptor> controllerMappings =
controllerSelector.GetControllerMapping();
if (controllerMappings != null)
{
ApiDescriptionComparer descriptionComparer = new ApiDescriptionComparer();
foreach (IHttpRoute route in FlattenRoutes(_config.Routes))
{
CandidateAction[] directRouteCandidates = route.GetDirectRouteCandidates();
HttpControllerDescriptor directRouteController = GetDirectRouteController(
directRouteCandidates
);
Collection <ApiDescription> descriptionsFromRoute =
(directRouteController != null && directRouteCandidates != null)
? ExploreDirectRoute(
directRouteController,
directRouteCandidates,
route
)
: ExploreRouteControllers(controllerMappings, route);
// Remove ApiDescription that will lead to ambiguous action matching.
// E.g. a controller with Post() and PostComment(). When the route template is {controller}, it produces POST /controller and POST /controller.
descriptionsFromRoute = RemoveInvalidApiDescriptions(descriptionsFromRoute);
foreach (ApiDescription description in descriptionsFromRoute)
{
// Do not add the description if the previous route has a matching description with the same HTTP method and relative path.
// E.g. having two routes with the templates "api/Values/{id}" and "api/{controller}/{id}" can potentially produce the same
// relative path "api/Values/{id}" but only the first one matters.
if (!apiDescriptions.Contains(description, descriptionComparer))
{
apiDescriptions.Add(description);
}
}
}
}
return(apiDescriptions);
}
private Collection <ApiDescription> InitializeApiDescriptions()
{
Collection <ApiDescription> apiDescriptions = new Collection <ApiDescription>();
IHttpControllerSelector controllerSelector = _config.Services.GetHttpControllerSelector();
IDictionary <string, HttpControllerDescriptor> controllerMappings = controllerSelector.GetControllerMapping();
if (controllerMappings != null)
{
foreach (var route in _config.Routes)
{
ExploreRouteControllers(controllerMappings, route, apiDescriptions);
}
// remove ApiDescription that will lead to ambiguous action matching. E.g. a controller with Post() and PostComment(). When the route template is {controller}, it produces POST /controller and POST /controller.
apiDescriptions = RemoveInvalidApiDescriptions(apiDescriptions);
}
return(apiDescriptions);
}
/// <summary>
/// Initializes a new instance of the <see cref="AttributeRoutingConvention"/> class.
/// </summary>
/// <param name="model">The <see cref="IEdmModel"/> to be used for parsing the route templates.</param>
/// <param name="configuration">The <see cref="HttpConfiguration"/> to use for figuring out all the controllers to
/// look for a match.</param>
/// <param name="pathTemplateHandler">The path template handler to be used for parsing the path templates.</param>
public AttributeRoutingConvention(IEdmModel model, HttpConfiguration configuration,
IODataPathTemplateHandler pathTemplateHandler)
: this(model, pathTemplateHandler)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
Action <HttpConfiguration> oldInitializer = configuration.Initializer;
configuration.Initializer = (config) =>
{
oldInitializer(config);
IHttpControllerSelector controllerSelector = config.Services.GetHttpControllerSelector();
_attributeMappingsFunc =
() => BuildAttributeMappings(controllerSelector.GetControllerMapping().Values);
};
}
/// <summary>
/// Maps the attribute-defined routes for the application.
/// </summary>
/// <param name="configuration">The server configuration.</param>
/// <param name="routeBuilder">The <see cref="HttpRouteBuilder"/> to use for generating attribute routes.</param>
public static void MapHttpAttributeRoutes(this HttpConfiguration configuration, HttpRouteBuilder routeBuilder)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
if (routeBuilder == null)
{
throw Error.ArgumentNull("routeBuilder");
}
List <HttpRouteEntry> attributeRoutes = new List <HttpRouteEntry>();
IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector();
IDictionary <string, HttpControllerDescriptor> controllerMapping = controllerSelector.GetControllerMapping();
if (controllerMapping != null)
{
foreach (HttpControllerDescriptor controllerDescriptor in controllerMapping.Values)
{
Collection <RoutePrefixAttribute> routePrefixes = controllerDescriptor.GetCustomAttributes <RoutePrefixAttribute>(inherit: false);
IHttpActionSelector actionSelector = controllerDescriptor.Configuration.Services.GetActionSelector();
ILookup <string, HttpActionDescriptor> actionMapping = actionSelector.GetActionMapping(controllerDescriptor);
if (actionMapping != null)
{
foreach (IGrouping <string, HttpActionDescriptor> actionGrouping in actionMapping)
{
string controllerName = controllerDescriptor.ControllerName;
attributeRoutes.AddRange(CreateAttributeRoutes(routeBuilder, controllerName, routePrefixes, actionGrouping));
}
}
}
attributeRoutes.Sort();
foreach (HttpRouteEntry attributeRoute in attributeRoutes)
{
configuration.Routes.Add(attributeRoute.Name, attributeRoute.Route);
}
}
}
protected override void UpdateConfiguration(WebRouteConfiguration configuration)
{
var controllers = new[] { typeof(BaseAddressFactoryModelsController) };
configuration.AddControllers(controllers);
var model = GetEdmModel(configuration);
configuration.Routes.Clear();
configuration.MapODataServiceRoute("odata", "odata", model);
configuration.EnsureInitialized();
ServicesContainer services = configuration.Services;
IHttpControllerSelector controllerSelector = services.GetHttpControllerSelector();
var controllerMappings = controllerSelector.GetControllerMapping().Values;
foreach (var c in controllerMappings)
{
var odataFormatter = c.Configuration.Formatters.OfType <ODataMediaTypeFormatter>();
foreach (var f in odataFormatter)
{
f.BaseAddressFactory = (m) => new Uri("http://foo.bar/", UriKind.Absolute);
}
}
}
public IDictionary <string, HttpControllerDescriptor> GetControllerMapping()
{
return(_innerSelector.GetControllerMapping());
}
private static void AddRouteEntries(
SubRouteCollection collector,
HttpConfiguration configuration,
IInlineConstraintResolver constraintResolver,
IDirectRouteProvider directRouteProvider)
{
Contract.Assert(configuration != null);
Contract.Assert(directRouteProvider != null);
IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector();
IDictionary <string, HttpControllerDescriptor> controllerMap = controllerSelector.GetControllerMapping();
if (controllerMap != null)
{
foreach (HttpControllerDescriptor controllerDescriptor in controllerMap.Values)
{
IHttpActionSelector actionSelector = controllerDescriptor.Configuration.Services.GetActionSelector();
ILookup <string, HttpActionDescriptor> actionsByName =
actionSelector.GetActionMapping(controllerDescriptor);
if (actionsByName == null)
{
continue;
}
List <HttpActionDescriptor> actions = actionsByName.SelectMany(g => g).ToList();
IReadOnlyCollection <RouteEntry> newEntries =
directRouteProvider.GetDirectRoutes(controllerDescriptor, actions, constraintResolver);
if (newEntries == null)
{
throw Error.InvalidOperation(
SRResources.TypeMethodMustNotReturnNull,
typeof(IDirectRouteProvider).Name, "GetDirectRoutes");
}
foreach (RouteEntry entry in newEntries)
{
if (entry == null)
{
throw Error.InvalidOperation(
SRResources.TypeMethodMustNotReturnNull,
typeof(IDirectRouteProvider).Name, "GetDirectRoutes");
}
DirectRouteBuilder.ValidateRouteEntry(entry);
// We need to mark each action as only reachable by direct routes so that traditional routes
// don't accidentally hit them.
HttpControllerDescriptor routeControllerDescriptor = entry.Route.GetTargetControllerDescriptor();
if (routeControllerDescriptor == null)
{
HttpActionDescriptor[] actionDescriptors = entry.Route.GetTargetActionDescriptors();
foreach (var actionDescriptor in actionDescriptors)
{
actionDescriptor.SetIsAttributeRouted(true);
}
}
else
{
routeControllerDescriptor.SetIsAttributeRouted(true);
}
}
collector.AddRange(newEntries);
}
}
}
public override IDictionary <string, HttpControllerDescriptor> GetControllerMapping()
{
IDictionary <string, HttpControllerDescriptor> toReturn = _originalControllerSelector != null?_originalControllerSelector.GetControllerMapping() : base.GetControllerMapping();
foreach (var objPair in ControllerDescriptors)
{
toReturn.Add(objPair.Key, objPair.Value);
}
return(toReturn);
}
public System.Collections.Generic.IDictionary <string, HttpControllerDescriptor> GetControllerMapping()
{
return(_concreteSelector.GetControllerMapping());
}
public IDictionary <string, HttpControllerDescriptor> GetControllerMapping()
{
var httpControllerDescriptors = inner.GetControllerMapping();
return(httpControllerDescriptors);
}
