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; }
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; }
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()); }
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; }