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