public HttpActionSelectorTracer(IHttpActionSelector innerSelector, ITraceWriter traceWriter)
{
Contract.Assert(innerSelector != null);
Contract.Assert(traceWriter != null);
_innerSelector = innerSelector;
_traceWriter = traceWriter;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataActionSelector" /> class.
/// </summary>
/// <param name="innerSelector">The inner controller selector to call.</param>
public ODataActionSelector(IHttpActionSelector innerSelector)
{
if (innerSelector == null)
{
throw Error.ArgumentNull("innerSelector");
}
_innerSelector = innerSelector;
}
private IHttpActionSelector GetActionSelector()
{
if (MemoryCache.Default["ActionSelector"] == null)
{
IHttpActionSelector selector = this.Config.Services.GetActionSelector();
return(selector);
}
return(MemoryCache.Default["ActionSelector"] as IHttpActionSelector);
}
private static void CreateActionSelectorTracer(HttpConfiguration configuration, ITraceWriter traceWriter)
{
IHttpActionSelector selector = GetService <IHttpActionSelector>(configuration.Services);
if (selector != null && !(selector is HttpActionSelectorTracer))
{
HttpActionSelectorTracer tracer = new HttpActionSelectorTracer(selector, traceWriter);
configuration.Services.Replace(typeof(IHttpActionSelector), tracer);
}
}
public IEnumerable <Tuple <string, FilterScope> > Get()
{
IHttpActionSelector actionSelector = this.Configuration.Services.GetActionSelector();
HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(this.ControllerContext);
foreach (FilterInfo filterInfo in actionDescriptor.GetFilterPipeline())
{
yield return(new Tuple <string, FilterScope>(filterInfo.Instance.GetType().Name, filterInfo.Scope));
}
}
private static IEnumerable <HttpRouteEntry> CreateRouteEntries(HttpControllerDescriptor controllerDescriptor)
{
IHttpActionSelector actionSelector = controllerDescriptor.Configuration.Services.GetActionSelector();
ILookup <string, HttpActionDescriptor> actionMap = actionSelector.GetActionMapping(controllerDescriptor);
if (actionMap == null)
{
return(Enumerable.Empty <HttpRouteEntry>());
}
List <HttpRouteEntry> routes = new List <HttpRouteEntry>();
string routePrefix = GetRoutePrefix(controllerDescriptor);
List <ReflectedHttpActionDescriptor> actionsWithoutRoutes = new List <ReflectedHttpActionDescriptor>();
foreach (IGrouping <string, HttpActionDescriptor> actionGrouping in actionMap)
{
string actionName = actionGrouping.Key;
foreach (ReflectedHttpActionDescriptor actionDescriptor in actionGrouping.OfType <ReflectedHttpActionDescriptor>())
{
Collection <IHttpRouteInfoProvider> routeProviders = actionDescriptor.GetCustomAttributes <IHttpRouteInfoProvider>(inherit: false);
// Ignore the Route attributes from inherited actions.
if (actionDescriptor.MethodInfo != null &&
actionDescriptor.MethodInfo.DeclaringType != controllerDescriptor.ControllerType)
{
routeProviders = null;
}
if (routeProviders != null && routeProviders.Count > 0)
{
AddRouteEntries(routes, actionName, routePrefix, routeProviders,
new ReflectedHttpActionDescriptor[] { actionDescriptor });
}
else
{
// IF there are no routes on the specific action, attach it to the controller routes (if any).
actionsWithoutRoutes.Add(actionDescriptor);
}
}
}
Collection <IHttpRouteInfoProvider> controllerRouteProviders =
controllerDescriptor.GetCustomAttributes <IHttpRouteInfoProvider>(inherit: false);
// If they exist and have not been overridden, create routes for controller-level route providers.
if (controllerRouteProviders != null && controllerRouteProviders.Count > 0 &&
actionsWithoutRoutes.Count > 0)
{
AddRouteEntries(routes, actionsWithoutRoutes[0].ActionName, routePrefix, controllerRouteProviders,
actionsWithoutRoutes);
}
return(routes);
}
static void ApplyImplicitConventions(HttpControllerDescriptor controller, IHttpActionSelector actionSelector, ApiVersionModel implicitVersionModel)
{
controller.SetApiVersionModel(implicitVersionModel);
var actions = actionSelector.GetActionMapping(controller).SelectMany(g => g);
foreach (var action in actions)
{
action.SetProperty(implicitVersionModel);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceLinkParser"/> class.
/// </summary>
/// <param name="configuration">
/// The configuration to use to parse the URIs.
/// </param>
public ResourceLinkParser(HttpConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
this.configuration = configuration;
this.actionSelector = this.configuration.Services.GetActionSelector();
this.controllerSelector = this.configuration.Services.GetHttpControllerSelector();
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceLinkParser"/> class.
/// </summary>
/// <param name="a_configuration">
/// The configuration to use to parse the URIs.
/// </param>
public ResourceLinkParser(HttpConfiguration a_configuration)
{
if (a_configuration == null)
{
throw new ArgumentNullException("a_configuration");
}
m_configuration = a_configuration;
m_actionSelector = m_configuration.Services.GetActionSelector();
m_controllerSelector = m_configuration.Services.GetHttpControllerSelector();
}
public override Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
this.Initialize(controllerContext);
IHttpActionSelector actionSelector = this.Configuration.Services.GetActionSelector();
HttpControllerDescriptor controllerDescriptor = this.ControllerContext.ControllerDescriptor;
HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(controllerContext);
HttpActionContext actionContext = new HttpActionContext(controllerContext, actionDescriptor);
actionDescriptor.ActionBinding.ExecuteBindingAsync(actionContext, cancellationToken).Wait();
return(this.Configuration.Services.GetActionInvoker().InvokeActionAsync(actionContext, cancellationToken));
}
public void Inner_Property_On_HttpActionSelectorTracer_Returns_IHttpActionSelector()
{
// Arrange
IHttpActionSelector expectedInner = new Mock <IHttpActionSelector>().Object;
HttpActionSelectorTracer productUnderTest = new HttpActionSelectorTracer(expectedInner, new TestTraceWriter());
// Act
IHttpActionSelector actualInner = productUnderTest.Inner;
// Assert
Assert.Same(expectedInner, actualInner);
}
public void Decorator_GetInner_On_HttpActionSelectorTracer_Returns_IHttpActionSelector()
{
// Arrange
IHttpActionSelector expectedInner = new Mock <IHttpActionSelector>().Object;
HttpActionSelectorTracer productUnderTest = new HttpActionSelectorTracer(expectedInner, new TestTraceWriter());
// Act
IHttpActionSelector actualInner = Decorator.GetInner(productUnderTest as IHttpActionSelector);
// Assert
Assert.Same(expectedInner, actualInner);
}
void ExploreRouteActions(
IHttpRoute route,
HttpControllerDescriptor controllerDescriptor,
IHttpActionSelector actionSelector,
Collection <VersionedApiDescription> apiDescriptions,
ApiVersion apiVersion)
{
Contract.Requires(route != null);
Contract.Requires(controllerDescriptor != null);
Contract.Requires(actionSelector != null);
Contract.Requires(apiDescriptions != null);
Contract.Requires(apiVersion != null);
var actionMapping = actionSelector.GetActionMapping(controllerDescriptor);
if (actionMapping == null)
{
return;
}
const string ActionRouteParameterName = null;
foreach (var grouping in actionMapping)
{
foreach (var action in grouping)
{
if (!ShouldExploreAction(ActionRouteParameterName, action, route, apiVersion))
{
continue;
}
var parameterDescriptions = CreateParameterDescriptions(action, route);
var context = new ODataRouteBuilderContext(
Configuration,
apiVersion,
(ODataRoute)route,
action,
parameterDescriptions,
ModelTypeBuilder,
Options);
if (context.IsRouteExcluded)
{
continue;
}
var relativePath = new ODataRouteBuilder(context).Build();
PopulateActionDescriptions(action, route, context, relativePath, apiDescriptions, apiVersion);
}
}
}
private void Initialize()
{
// Look for attribute to provide specialized information for this controller type
HttpControllerConfigurationAttribute controllerConfig =
_controllerType.GetCustomAttributes <HttpControllerConfigurationAttribute>(inherit: true).FirstOrDefault();
// If we find attribute then first ask dependency resolver and if we get null then create it ourselves
if (controllerConfig != null)
{
if (controllerConfig.HttpControllerActivator != null)
{
_controllerActivator = GetService <IHttpControllerActivator>(_configuration, controllerConfig.HttpControllerActivator);
}
if (controllerConfig.HttpActionSelector != null)
{
_actionSelector = GetService <IHttpActionSelector>(_configuration, controllerConfig.HttpActionSelector);
}
if (controllerConfig.HttpActionInvoker != null)
{
_actionInvoker = GetService <IHttpActionInvoker>(_configuration, controllerConfig.HttpActionInvoker);
}
if (controllerConfig.ActionValueBinder != null)
{
_actionValueBinder = GetService <IActionValueBinder>(_configuration, controllerConfig.ActionValueBinder);
}
}
// For everything still null we call the dependency resolver as normal.
if (_controllerActivator == null)
{
_controllerActivator = Configuration.ServiceResolver.GetHttpControllerActivator();
}
if (_actionSelector == null)
{
_actionSelector = Configuration.ServiceResolver.GetActionSelector();
}
if (_actionInvoker == null)
{
_actionInvoker = Configuration.ServiceResolver.GetActionInvoker();
}
if (_actionValueBinder == null)
{
_actionValueBinder = Configuration.ServiceResolver.GetActionValueBinder();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityRepositoryActionSelector" /> class.
/// </summary>
/// <param name="containerMetadata">The container metadata describing all the entity sets in the container.</param>
/// <param name="innerSelector">The inner controller selector to call.</param>
public EntityRepositoryActionSelector(IContainerMetadata containerMetadata, IHttpActionSelector innerSelector)
{
if (containerMetadata == null)
{
throw new ArgumentNullException("containerMetadata");
}
if (innerSelector == null)
{
throw new ArgumentNullException("innerSelector");
}
_containerMetadata = containerMetadata;
_innerSelector = innerSelector;
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityRepositoryActionSelector" /> class.
/// </summary>
/// <param name="containerMetadata">The container metadata describing all the entity sets in the container.</param>
/// <param name="innerSelector">The inner controller selector to call.</param>
public EntityRepositoryActionSelector(IContainerMetadata containerMetadata, IHttpActionSelector innerSelector)
{
if (containerMetadata == null)
{
throw new ArgumentNullException("containerMetadata");
}
if (innerSelector == null)
{
throw new ArgumentNullException("innerSelector");
}
_containerMetadata = containerMetadata;
_innerSelector = innerSelector;
}
private static void AddRouteEntries(SubRouteCollection collector, HttpControllerDescriptor controller,
IInlineConstraintResolver constraintResolver)
{
IHttpActionSelector actionSelector = controller.Configuration.Services.GetActionSelector();
ILookup <string, HttpActionDescriptor> actionMap = actionSelector.GetActionMapping(controller);
if (actionMap == null)
{
return;
}
string prefix = GetRoutePrefix(controller);
List <ReflectedHttpActionDescriptor> actionsWithoutRoutes = new List <ReflectedHttpActionDescriptor>();
foreach (IGrouping <string, HttpActionDescriptor> actionGrouping in actionMap)
{
foreach (ReflectedHttpActionDescriptor action in actionGrouping.OfType <ReflectedHttpActionDescriptor>())
{
IReadOnlyCollection <IDirectRouteFactory> factories = GetRouteFactories(action);
// Ignore the Route attributes from inherited actions.
if (action.MethodInfo != null &&
action.MethodInfo.DeclaringType != controller.ControllerType)
{
factories = null;
}
if (factories != null && factories.Count > 0)
{
AddRouteEntries(collector, prefix, factories,
new ReflectedHttpActionDescriptor[] { action }, constraintResolver, targetIsAction: true);
}
else
{
// IF there are no routes on the specific action, attach it to the controller routes (if any).
actionsWithoutRoutes.Add(action);
}
}
}
IReadOnlyCollection <IDirectRouteFactory> controllerFactories = GetRouteFactories(controller);
// If they exist and have not been overridden, create routes for controller-level route providers.
if (controllerFactories.Count > 0 && actionsWithoutRoutes.Count > 0)
{
AddRouteEntries(collector, prefix, controllerFactories, actionsWithoutRoutes,
constraintResolver, targetIsAction: false);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataActionSelector" /> class.
/// </summary>
/// <param name="routingConventions">The OData routing conventions to use for OData requests.</param>
/// <param name="innerSelector">The inner controller selector to call.</param>
public ODataActionSelector(IEnumerable<IODataRoutingConvention> routingConventions, IHttpActionSelector innerSelector)
{
if (routingConventions == null)
{
throw Error.ArgumentNull("routingConventions");
}
if (innerSelector == null)
{
throw Error.ArgumentNull("innerSelector");
}
_routingConventions = routingConventions;
_innerSelector = innerSelector;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataActionSelector" /> class.
/// </summary>
/// <param name="routingConventions">The OData routing conventions to use for OData requests.</param>
/// <param name="innerSelector">The inner controller selector to call.</param>
public ODataActionSelector(IEnumerable <IODataRoutingConvention> routingConventions, IHttpActionSelector innerSelector)
{
if (routingConventions == null)
{
throw Error.ArgumentNull("routingConventions");
}
if (innerSelector == null)
{
throw Error.ArgumentNull("innerSelector");
}
_routingConventions = routingConventions;
_innerSelector = innerSelector;
}
static void Main(string[] args)
{
HttpConfiguration configuration = new HttpConfiguration();
HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(configuration, "demo", typeof(DemoController));
IHttpActionSelector actionSelector = configuration.Services.GetActionSelector();
HttpActionDescriptor actionDescriptor = actionSelector.GetActionMapping(controllerDescriptor)["DemoAction"].First();
IActionValueBinder actionValueBinder = configuration.Services.GetActionValueBinder();
HttpActionBinding actionBinding = actionValueBinder.GetBinding(actionDescriptor);
Console.WriteLine("{0,-18}{1}", "Parameter", "HttpParameterBinding");
foreach (HttpParameterBinding parameterBinding in actionBinding.ParameterBindings)
{
Console.WriteLine("{0,-18}{1}", parameterBinding.Descriptor.ParameterName, parameterBinding.GetType().Name);
}
}
public IEnumerable <Tuple <string, string> > Get()
{
IHttpActionSelector actionSelector = GlobalConfiguration.Configuration.Services.GetActionSelector();
foreach (var group in actionSelector.GetActionMapping(this.ControllerContext.ControllerDescriptor))
{
foreach (HttpActionDescriptor actionDescriptor in group)
{
if (actionDescriptor.ActionName != "Get")
{
string converterTypeName = actionDescriptor.ResultConverter == null ? "N/A" : actionDescriptor.ResultConverter.GetType().Name;
yield return(new Tuple <string, string>(actionDescriptor.ActionName, converterTypeName));
}
}
}
}
/// <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);
}
}
}
/// <summary>
/// Callback invoked to set per-controller overrides for this controllerDescriptor.
/// </summary>
/// <param name="controllerSettings">The controller settings to initialize.</param>
/// <param name="controllerDescriptor">The controller descriptor. Note that the <see
/// cref="T:System.Web.Http.Controllers.HttpControllerDescriptor" /> can be associated with the derived
/// controller type given that <see cref="T:System.Web.Http.Controllers.IControllerConfiguration" /> is
/// inherited.</param>
public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
{
if (controllerSettings == null)
{
throw Error.ArgumentNull("controllerSettings");
}
if (controllerDescriptor == null)
{
throw Error.ArgumentNull("controllerDescriptor");
}
ServicesContainer services = controllerSettings.Services;
Contract.Assert(services != null);
// Replace the action selector with one that is based on the OData routing conventions
IHttpActionSelector originalActionSelector = services.GetActionSelector();
IHttpActionSelector actionSelector = new ODataActionSelector(originalActionSelector);
controllerSettings.Services.Replace(typeof(IHttpActionSelector), actionSelector);
}
public IEnumerable <Tuple <string, string, FilterScope> > Get()
{
HttpControllerDescriptor[] controllerDescriptors = new HttpControllerDescriptor[] {
new HttpControllerDescriptor(this.Configuration, "foo", typeof(FooController)),
new HttpControllerDescriptor(this.Configuration, "bar", typeof(BarController)),
new HttpControllerDescriptor(this.Configuration, "baz", typeof(BazController)),
};
IHttpActionSelector actionSelector = this.Configuration.Services.GetActionSelector();
IEnumerable <HttpActionDescriptor> actionDescriptors = controllerDescriptors.SelectMany(controllerDescriptor =>
actionSelector.GetActionMapping(controllerDescriptor)["Action"]);
foreach (HttpActionDescriptor actionDescriptor in actionDescriptors)
{
foreach (FilterInfo filterInfo in actionDescriptor.GetFilterPipeline())
{
yield return(new Tuple <string, string, FilterScope>(
string.Format("{0}.{1}", actionDescriptor.ControllerDescriptor.ControllerType.Name, actionDescriptor.ActionName),
filterInfo.Instance.GetType().Name,
filterInfo.Scope));
}
}
}
public override RequestAnalysisResult GetRequestAnalysis(RequestAnalysisContext analysisContext)
{
HttpRequestMessage request = analysisContext.RequestMessage;
HttpConfiguration httpConfiguration = request.GetConfiguration();
IHttpRouteData httpRouteData = httpConfiguration.Routes.GetRouteData(request);
request.SetRouteData(httpRouteData);
//IAssembliesResolver assembliesResolver= httpConfiguration.Services.GetAssembliesResolver();
//IHttpControllerTypeResolver controllerTypeResolver = httpConfiguration.Services.GetHttpControllerTypeResolver();
//ICollection<Type> controllerTypes= controllerTypeResolver.GetControllerTypes(assembliesResolver);
IHttpControllerSelector controllerSelector = httpConfiguration.Services.GetHttpControllerSelector();
HttpControllerDescriptor controllerDescriptor = controllerSelector.SelectController(request);
HttpControllerContext controllerContext = new HttpControllerContext(httpConfiguration, httpRouteData, request);
controllerContext.ControllerDescriptor = controllerDescriptor;
IHttpActionSelector actionSelector = httpConfiguration.Services.GetActionSelector();
HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(controllerContext);
RequestAnalysisResult analysisResult = new RequestAnalysisResult();
analysisResult.Url = request.RequestUri.ToString();
analysisResult.SupportedHttpMethods = actionDescriptor.SupportedHttpMethods.Select(method => method.Method).ToArray();
analysisResult.Parameters = actionDescriptor.GetParameters().Select(parameter => parameter.ParameterName).ToArray();
analysisResult.ActionName = actionDescriptor.ActionName;
analysisResult.ControllerName = actionDescriptor.ControllerDescriptor.ControllerName;
analysisResult.Values = httpRouteData.Values;
analysisResult.DataTokens = httpRouteData.Route.DataTokens;
analysisResult.Mode = Mode;
string path = new DirectoryInfo(string.Format(@"{0}{1}", AppDomain.CurrentDomain.BaseDirectory, LookupPrefix)).FullName;
analysisResult.FilePath = LookupFilePath(path, analysisResult.ControllerName);
return(analysisResult);
}
public MediaDataControllerTests()
{
if (ConfigurationManager.AppSettings["TestServiceURL"] != null)
{
testServiceURL = ConfigurationManager.AppSettings["TestServiceURL"];
}
if (string.IsNullOrEmpty(testServiceURL))
{
testServiceURL = DynamicControllerTests.cDefaultBaseURL;
var configuration = new HttpConfiguration();
Task <System.Web.OData.Routing.ODataRoute> odataRoute = configuration.MapRestierRoute <DynamicApi>("DynamicApi", "DynamicApi");
odataRoute.Wait();
odataRoute.Result.PathRouteConstraint.RoutingConventions.Add(new ODataRestierDynamic.DynamicFactory.MediadataRoutingConvention());
// Register an Action selector that can include template parameters in the name
IHttpActionSelector actionSelectorService = configuration.Services.GetActionSelector();
configuration.Services.Replace(typeof(IHttpActionSelector), new DynamicODataActionSelector(actionSelectorService));
// Register an Action invoker that can include template parameters in the name
IHttpActionInvoker actionInvokerService = configuration.Services.GetActionInvoker();
configuration.Services.Replace(typeof(IHttpActionInvoker), new DynamicODataActionInvoker(actionInvokerService));
client = new HttpClient(new HttpServer(configuration));
}
else
{
var handler = new HttpClientHandler {
UseDefaultCredentials = true
};
client = new HttpClient(handler);
}
if (!testServiceURL.EndsWith("/"))
{
testServiceURL += "/";
}
}
public SuperscribeActionSelectorAdapter(IHttpActionSelector actionSelector)
{
this.baseActionSelector = actionSelector;
}
public HttpActionSelectorTracer(IHttpActionSelector innerSelector, ITraceWriter traceWriter)
{
_innerSelector = innerSelector;
_traceWriter = traceWriter;
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegatingApiControllerActionSelector" /> class.
/// </summary>
/// <param name="innerActionSelector">The inner action selector.</param>
public DelegatingApiControllerActionSelector(IHttpActionSelector innerActionSelector)
{
InnerActionSelector = innerActionSelector;
}
public InspectActionSelector(IHttpActionSelector delegating)
{
_delegating = delegating;
}
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 DynamicActionSelector(HttpConfiguration configuration, IHttpActionSelector originalSelector)
: base()
{
this._configuration = configuration;
this._originalActionSelector = originalSelector;
}
public InspectActionSelector(IHttpActionSelector innerSelector)
{
_innerSelector = innerSelector;
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegatingApiControllerActionSelector" /> class.
/// </summary>
/// <param name="innerActionSelector">The inner action selector.</param>
public DelegatingApiControllerActionSelector(IHttpActionSelector innerActionSelector)
{
InnerActionSelector = innerActionSelector;
}
internal RaygunWebApiActionSelector(IHttpActionSelector concreteSelector, IRaygunWebApiClientProvider clientCreator)
{
_concreteSelector = concreteSelector;
_clientCreator = clientCreator;
}
/// <summary>
/// Initializes a new instance of the DynamicODataActionSelector class.
/// </summary>
/// <param name="innerSelector">The inner controller selector to call.</param>
public DynamicODataActionSelector(IHttpActionSelector innerSelector)
{
_innerSelector = innerSelector;
}
public DebugActionSelector(IHttpActionSelector httpActionSelector)
{
// TODO: Complete member initialization
this.httpActionSelector = httpActionSelector;
}
static HttpControllerDescriptor[] ApplyCollatedModel(List <HttpControllerDescriptor> controllers, IHttpActionSelector actionSelector, ApiVersionModel collatedModel)
{
Contract.Requires(controllers != null);
Contract.Requires(actionSelector != null);
Contract.Requires(collatedModel != null);
Contract.Ensures(Contract.Result <HttpControllerDescriptor[]>() != null);
foreach (var controller in controllers)
{
var model = controller.GetApiVersionModel();
var actions = actionSelector.GetActionMapping(controller).SelectMany(g => g);
controller.SetProperty(model.Aggregate(collatedModel));
foreach (var action in actions)
{
model = action.GetApiVersionModel();
action.SetProperty(model.Aggregate(collatedModel));
}
}
return(controllers.ToArray());
}
public SuperscribeActionSelectorAdapter(IHttpActionSelector actionSelector)
{
this.baseActionSelector = actionSelector;
}
static void ApplyAttributeOrImplicitConventions(HttpControllerDescriptor controller, IHttpActionSelector actionSelector, ApiVersionModel implicitVersionModel)
{
Contract.Requires(controller != null);
Contract.Requires(actionSelector != null);
Contract.Requires(implicitVersionModel != null);
if (IsDecoratedWithAttributes(controller))
{
var conventions = new ControllerApiVersionConventionBuilder(controller.ControllerType);
conventions.ApplyTo(controller);
}
else
{
ApplyImplicitConventions(controller, actionSelector, implicitVersionModel);
}
}
/// <summary>
/// constructor initializes members
/// </summary>
/// <param name="innerSelector">an IHttpActionSelector</param>
public InspectActionSelector(IHttpActionSelector innerSelector)
{
_innerSelector = innerSelector;
}
public DebugActionSelector(IHttpActionSelector httpActionSelector)
{
// TODO: Complete member initialization
this.httpActionSelector = httpActionSelector;
}
