public static void ValidateFilterPipeline(HttpActionDescriptor actionDescriptor, bool isQueryable) { Collection <FilterInfo> filters = actionDescriptor.GetFilterPipeline(); if (isQueryable) { string order = string.Empty; // The queryable attributes need to come after the TableQueryFilter, but our other // filter may sneak in somewhere. foreach (FilterInfo filter in filters) { if (filter.Instance is TableQueryFilter) { order += "1"; } if (filter.Instance is EnableQueryAttribute || filter.Instance is QueryableAttribute) { order += "2"; } } Assert.Equal(3, filters.Count); Assert.Equal("12", order); } else { Assert.Equal(2, filters.Count); filters.Where(f => f.Instance is TableQueryFilter).Single(); } }
internal static bool IsQueryableAction(this HttpRequestMessage request, HttpActionDescriptor actionDescriptor) { if (request == null) { throw new ArgumentNullException("request"); } bool result; if (!request.Properties.TryGetValue(IsQueryableActionKey, out result)) { result = actionDescriptor != null && actionDescriptor.GetFilterPipeline().Any(f => { // When Web Api diagnostic logging is on, all filters are wrapped in a FilterTracer. // FilterTracer implements IDecorator<IFilter>, which lets us get at the inner (and actual) filter. IFilter filter = f.Instance; IDecorator <IFilter> decorator = filter as IDecorator <IFilter>; if (decorator != null) { filter = decorator.Inner; } Type instance = filter.GetType(); return(instance == typeof(QueryableAttribute) || instance == typeof(EnableQueryAttribute)); }); request.Properties[IsQueryableActionKey] = result; } return(result); }
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)); } }
public virtual Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken) { if (_request != null) { // if user has registered a controller factory which produces the same controller instance, we should throw here throw Error.InvalidOperation(SRResources.CannotSupportSingletonInstance, typeof(ApiController).Name, typeof(IHttpControllerActivator).Name); } Initialize(controllerContext); // We can't be reused, and we know we're disposable, so make sure we go away when // the request has been completed. if (_request != null) { _request.RegisterForDispose(this); } HttpControllerDescriptor controllerDescriptor = controllerContext.ControllerDescriptor; ServicesContainer controllerServices = controllerDescriptor.Configuration.Services; HttpActionDescriptor actionDescriptor = controllerServices.GetActionSelector().SelectAction(controllerContext); HttpActionContext actionContext = new HttpActionContext(controllerContext, actionDescriptor); IEnumerable <FilterInfo> filters = actionDescriptor.GetFilterPipeline(); FilterGrouping filterGrouping = new FilterGrouping(filters); IEnumerable <IActionFilter> actionFilters = filterGrouping.ActionFilters; IEnumerable <IAuthorizationFilter> authorizationFilters = filterGrouping.AuthorizationFilters; IEnumerable <IExceptionFilter> exceptionFilters = filterGrouping.ExceptionFilters; // Func<Task<HttpResponseMessage>> Task <HttpResponseMessage> result = InvokeActionWithAuthorizationFilters(actionContext, cancellationToken, authorizationFilters, () => { HttpActionBinding actionBinding = actionDescriptor.ActionBinding; Task bindTask = actionBinding.ExecuteBindingAsync(actionContext, cancellationToken); return(bindTask.Then <HttpResponseMessage>(() => { _modelState = actionContext.ModelState; Func <Task <HttpResponseMessage> > invokeFunc = InvokeActionWithActionFilters(actionContext, cancellationToken, actionFilters, () => { return controllerServices.GetActionInvoker().InvokeActionAsync(actionContext, cancellationToken); }); return invokeFunc(); })); })(); result = InvokeActionWithExceptionFilters(result, actionContext, cancellationToken, exceptionFilters); return(result); }
public override HttpActionDescriptor SelectAction(HttpControllerContext controllerContext) { HttpActionDescriptor action = base.SelectAction(controllerContext); IEnumerable <FilterInfo> filters = action.GetFilterPipeline(); IEnumerable <FilterInfo> orderedFilters = GetFilters <IAuthenticationFilter>(filters) .Concat(GetFilters <IAuthorizationFilter>(filters)) .Concat(GetFilters <IActionFilter>(filters)); foreach (FilterInfo filter in orderedFilters) { Debug.WriteLine("Scope {0} Type: {1}", filter.Scope, filter.Instance.GetType().Name); } return(action); }
public override Collection <FilterInfo> GetFilterPipeline() { Collection <FilterInfo> originalFilters = _innerDescriptor.GetFilterPipeline(); Collection <FilterInfo> newFilters = new Collection <FilterInfo>(); // for any actions that support query composition, we need to replace it with our // query filter. foreach (FilterInfo filterInfo in originalFilters) { FilterInfo newInfo = filterInfo; QueryableAttribute queryableFilter = filterInfo.Instance as QueryableAttribute; if (queryableFilter != null) { newInfo = new FilterInfo(new QueryFilterAttribute() { ResultLimit = queryableFilter.ResultLimit }, filterInfo.Scope); } newFilters.Add(newInfo); } return(newFilters); }
public override Collection <FilterInfo> GetFilterPipeline() { List <FilterInfo> filters = new List <FilterInfo>(_innerDescriptor.GetFilterPipeline()); List <FilterInfo> returnFilters = new List <FilterInfo>(filters.Count); for (int i = 0; i < filters.Count; i++) { // If this filter has been wrapped already, use as is if (FilterTracer.IsFilterTracer(filters[i].Instance)) { returnFilters.Add(filters[i]); } else { IEnumerable <FilterInfo> filterTracers = FilterTracer.CreateFilterTracers(filters[i], _traceWriter); foreach (FilterInfo filterTracer in filterTracers) { returnFilters.Add(filterTracer); } } } return(new Collection <FilterInfo>(returnFilters)); }
public override Collection <FilterInfo> GetFilterPipeline() { return(_originalAction.GetFilterPipeline()); }
public override ReadOnlyCollection <Filter> GetFilterPipeline() { return(originalAction.GetFilterPipeline()); }
public override Collection <FilterInfo> GetFilterPipeline() { var pipeline = originalAction.GetFilterPipeline(); return(pipeline); }
internal static bool IsQueryableAction(this HttpRequestMessage request, HttpActionDescriptor actionDescriptor) { if (request == null) { throw new ArgumentNullException("request"); } bool result; if (!request.Properties.TryGetValue(IsQueryableActionKey, out result)) { result = actionDescriptor != null && actionDescriptor.GetFilterPipeline().Any(f => { // When Web Api diagnostic logging is on, all filters are wrapped in a FilterTracer. // FilterTracer implements IDecorator<IFilter>, which lets us get at the inner (and actual) filter. IFilter filter = f.Instance; IDecorator<IFilter> decorator = filter as IDecorator<IFilter>; if (decorator != null) { filter = decorator.Inner; } Type instance = filter.GetType(); return instance == typeof(QueryableAttribute) || instance == typeof(EnableQueryAttribute); }); request.Properties[IsQueryableActionKey] = result; } return result; }