public void AuthorizationFilters_ReturnsActionScopeAuthorizationFilters_WhenOverrideScopeIsAction() { // Arrange IAuthorizationFilter expectedGlobalFilter = CreateDummyAuthorizationFilter(); FilterInfo globalFilter = new FilterInfo(expectedGlobalFilter, FilterScope.Global); IAuthorizationFilter expectedControllerFilter = CreateDummyAuthorizationFilter(); FilterInfo controllerFilter = new FilterInfo( expectedControllerFilter, FilterScope.Controller ); IAuthorizationFilter expectedActionFilter = CreateDummyAuthorizationFilter(); FilterInfo actionFilter = new FilterInfo(expectedActionFilter, FilterScope.Action); FilterInfo overrideFilter = new FilterInfo( CreateOverride(typeof(IAuthorizationFilter)), FilterScope.Action ); IEnumerable <FilterInfo> filters = new FilterInfo[] { globalFilter, controllerFilter, actionFilter, overrideFilter }; FilterGrouping product = CreateProductUnderTest(filters); // Act IAuthorizationFilter[] authorizationFilters = product.AuthorizationFilters; // Assert Assert.NotNull(authorizationFilters); IAuthorizationFilter authorizationFilter = Assert.Single(authorizationFilters); Assert.Same(expectedActionFilter, authorizationFilter); }
/// <summary> /// Checks if the user is permitted to perform the requested action /// </summary> /// <param name="controllerContext"> /// The controller context. /// </param> /// <param name="actionDescriptor"> /// The action descriptor. /// </param> /// <returns> /// True if the current user is authorized and False otherwise /// </returns> private static bool ActionIsAuthorized(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { if (actionDescriptor == null) { return(false); // action does not exist so say yes - should we authorise this?! } var authContext = new AuthorizationContext(controllerContext, actionDescriptor); // run each auth filter until on fails // performance could be improved by some caching foreach (var filter in FilterProviders.Providers.GetFilters(controllerContext, actionDescriptor)) { IAuthorizationFilter authorizationFilter = filter.Instance as IAuthorizationFilter; if (authorizationFilter != null) { authorizationFilter.OnAuthorization(authContext); if (authContext.Result != null) { return(false); } } } return(true); }
/// <summary> /// Adds the authorization filter. /// </summary> /// <param name="filter">The filter.</param> protected virtual void AddAuthorizationFilter(IAuthorizationFilter filter) { if (!AuthorizationFilters.Contains(filter)) { AuthorizationFilters.Add(filter); } }
public void Constructor_PopulatesFilterCollections() { // Arrange IActionFilter expectedActionFilter = CreateDummyActionFilter(); IAuthorizationFilter expectedAuthorizationFilter = CreateDummyAuthorizationFilter(); IAuthenticationFilter expectedAuthenticationFilter = CreateDummyAuthenticationFilter(); IExceptionFilter expectedExceptionFilter = CreateDummyExceptionFilter(); IResultFilter expectedResultFilter = CreateDummyResultFilter(); List <Filter> filters = new List <Filter>() { CreateFilter(expectedActionFilter), CreateFilter(expectedAuthorizationFilter), CreateFilter(expectedAuthenticationFilter), CreateFilter(expectedExceptionFilter), CreateFilter(expectedResultFilter), }; // Act FilterInfo filterInfo = new FilterInfo(filters); // Assert Assert.Same(expectedActionFilter, filterInfo.ActionFilters.SingleOrDefault()); Assert.Same(expectedAuthorizationFilter, filterInfo.AuthorizationFilters.SingleOrDefault()); Assert.Same(expectedAuthenticationFilter, filterInfo.AuthenticationFilters.SingleOrDefault()); Assert.Same(expectedExceptionFilter, filterInfo.ExceptionFilters.SingleOrDefault()); Assert.Same(expectedResultFilter, filterInfo.ResultFilters.SingleOrDefault()); }
public Task <HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken) { // We need to reverse the filter list so that least specific filters (Global) get run first and the most // specific filters (Action) get run last. Func <Task <HttpResponseMessage> > result = () => _innerResult.ExecuteAsync(cancellationToken); for (int i = _filters.Length - 1; i >= 0; i--) { IAuthorizationFilter filter = _filters[i]; Func < Func <Task <HttpResponseMessage> >, IAuthorizationFilter, Func <Task <HttpResponseMessage> > > chainContinuation = (continuation, innerFilter) => { return(() => innerFilter.ExecuteAuthorizationFilterAsync( _context, cancellationToken, continuation )); }; result = chainContinuation(result, filter); } return(result()); }
/// <summary> /// Determines whether the specified authorization filter is authorized. /// </summary> /// <param name="authorizationFilter">The authorization filter.</param> /// <param name="controllerContext">The controller context.</param> /// <param name="actionDescriptor">The action descriptor.</param> /// <returns> /// <c>true</c> if the specified authorization filter is authorized; otherwise, <c>false</c>. /// </returns> private static bool IsAuthorized(IAuthorizationFilter authorizationFilter, ControllerContext controllerContext, ActionDescriptor actionDescriptor) { var authorizationContext = new AuthorizationContext(controllerContext, actionDescriptor); authorizationFilter.OnAuthorization(authorizationContext); return(authorizationContext.Result == null); }
public DefaultServiceExecutor(IServiceEntryLocate serviceEntryLocate, IServiceRouteProvider serviceRouteProvider, IAuthorizationFilter authorizationFilter, ILogger <DefaultServiceExecutor> logger) { _serviceEntryLocate = serviceEntryLocate; _logger = logger; _serviceRouteProvider = serviceRouteProvider; _authorizationFilter = authorizationFilter; }
public HttpExecutor(IServiceEntryLocate serviceEntryLocate, IServiceRouteProvider serviceRouteProvider, IAuthorizationFilter authorizationFilter, ITypeConvertibleService typeConvertibleService) { _serviceEntryLocate = serviceEntryLocate; _typeConvertibleService = typeConvertibleService; _serviceRouteProvider = serviceRouteProvider; _authorizationFilter = authorizationFilter; //_serviceProxyProvider = serviceProxyProvider; _diagnosticListener = new DiagnosticListener("BimTechDiagnosticListener"); }
public HttpServiceExecutor(IServiceEntryLocate serviceEntryLocate, IServiceRouteProvider serviceRouteProvider, IAuthorizationFilter authorizationFilter, ILogger <HttpServiceExecutor> logger, CPlatformContainer serviceProvider, ITypeConvertibleService typeConvertibleService) { _serviceEntryLocate = serviceEntryLocate; _logger = logger; _serviceProvider = serviceProvider; _typeConvertibleService = typeConvertibleService; _serviceRouteProvider = serviceRouteProvider; _authorizationFilter = authorizationFilter; }
public AuthorizationFilterResult(HttpActionContext context, IAuthorizationFilter[] filters, IHttpActionResult innerResult) { Contract.Assert(context != null); Contract.Assert(filters != null); Contract.Assert(innerResult != null); _context = context; _filters = filters; _innerResult = innerResult; }
public void Inner_Property_On_AuthorizationFilterTracer_Returns_IAuthorizationFilter() { // Arrange IAuthorizationFilter expectedInner = new Mock <IAuthorizationFilter>().Object; AuthorizationFilterTracer productUnderTest = new AuthorizationFilterTracer(expectedInner, new TestTraceWriter()); // Act IAuthorizationFilter actualInner = productUnderTest.Inner as IAuthorizationFilter; // Assert Assert.Same(expectedInner, actualInner); }
public static IIlaroAdmin Initialise( string connectionStringName = "", string routesPrefix = "IlaroAdmin", IAuthorizationFilter authorize = null, CultureInfo culture = null) { var admin = Current; admin.Initialise(connectionStringName, routesPrefix, authorize); return(admin); }
public BootstrapperConfiguration() { Servers = new List<Func<BackgroundJobServer>>(); DashboardPath = "/hangfire"; AuthorizationFilters = new IAuthorizationFilter[] { new LocalRequestsOnlyAuthorizationFilter() }; Filters = new List<object>(); }
public void Decorator_GetInner_On_AuthorizationFilterTracer_Returns_IAuthorizationFilter() { // Arrange IAuthorizationFilter expectedInner = new Mock <IAuthorizationFilter>().Object; AuthorizationFilterTracer productUnderTest = new AuthorizationFilterTracer(expectedInner, new TestTraceWriter()); // Act IAuthorizationFilter actualInner = Decorator.GetInner(productUnderTest as IAuthorizationFilter); // Assert Assert.Same(expectedInner, actualInner); }
public BootstrapperConfiguration() { Servers = new List <Func <BackgroundJobServer> >(); DashboardPath = "/hangfire"; AuthorizationFilters = new IAuthorizationFilter[] { new LocalRequestsOnlyAuthorizationFilter() }; Filters = new List <object>(); }
public HttpExecutor(IServiceEntryLocate serviceEntryLocate, IServiceRouteProvider serviceRouteProvider, IAuthorizationFilter authorizationFilter, ILogger <HttpExecutor> logger, CPlatformContainer serviceProvider, IServiceProxyProvider serviceProxyProvider, ITypeConvertibleService typeConvertibleService) { _serviceEntryLocate = serviceEntryLocate; _logger = logger; _serviceProvider = serviceProvider; _typeConvertibleService = typeConvertibleService; _serviceRouteProvider = serviceRouteProvider; _authorizationFilter = authorizationFilter; _serviceProxyProvider = serviceProxyProvider; _diagnosticListener = new DiagnosticListener(DiagnosticListenerExtensions.DiagnosticListenerName); }
private Task <HttpResponseMessage> Apply( IAuthorizationFilter head, Queue <IAuthorizationFilter> tail, HttpActionContext actionContext, CancellationToken cancellationToken, Func <Task <HttpResponseMessage> > continuation ) { return(head.ExecuteAuthorizationFilterAsync( actionContext, cancellationToken, () => tail.Count == 0 ? continuation() : Apply(tail.Dequeue(), tail, actionContext, cancellationToken, continuation) )); }
public async Task ExecuteAsync_ChainsFiltersInOrderFollowedByInnerActionContinuation() { // Arrange HttpActionContext actionContextInstance = ContextUtil.CreateActionContext(); List <string> log = new List <string>(); Mock <IAuthorizationFilter> globalFilterMock = CreateAuthorizationFilterMock( (ctx, ct, continuation) => { log.Add("globalFilter"); return(continuation()); } ); Mock <IAuthorizationFilter> actionFilterMock = CreateAuthorizationFilterMock( (ctx, ct, continuation) => { log.Add("actionFilter"); return(continuation()); } ); Mock <IHttpActionResult> innerResultMock = new Mock <IHttpActionResult>(); innerResultMock .Setup(r => r.ExecuteAsync(It.IsAny <CancellationToken>())) .Returns( () => { log.Add("innerAction"); return(Task.FromResult <HttpResponseMessage>(null)); } ); IHttpActionResult innerResult = innerResultMock.Object; var filters = new IAuthorizationFilter[] { globalFilterMock.Object, actionFilterMock.Object, }; IHttpActionResult authorizationFilter = new AuthorizationFilterResult( actionContextInstance, filters, innerResult ); // Act await authorizationFilter.ExecuteAsync(CancellationToken.None); // Assert Assert.Equal(new[] { "globalFilter", "actionFilter", "innerAction" }, log.ToArray()); globalFilterMock.Verify(); actionFilterMock.Verify(); }
public static void AfterOnAuthorization( this DiagnosticListener diagnosticListener, AuthorizationFilterContext authorizationContext, IAuthorizationFilter filter) { Debug.Assert(diagnosticListener != null); Debug.Assert(authorizationContext != null); Debug.Assert(filter != null); // Inlinable fast-path check if diagnostic listener is enabled if (diagnosticListener.IsEnabled()) { AfterOnAuthorizationImpl(diagnosticListener, authorizationContext, filter); } }
private void SplitFilters(OverrideFilterInfo info) { Contract.Assert(info.Filters != null); foreach (Filter filter in info.Filters) { Contract.Assert(filter != null); IActionFilter actionFilter = filter.Instance as IActionFilter; if (actionFilter != null && filter.Scope >= info.ActionOverrideScope) { _actionFilters.Add(actionFilter); } IAuthenticationFilter authenticationFilter = filter.Instance as IAuthenticationFilter; if ( authenticationFilter != null && filter.Scope >= info.AuthenticationOverrideScope ) { _authenticationFilters.Add(authenticationFilter); } IAuthorizationFilter authorizationFilter = filter.Instance as IAuthorizationFilter; if (authorizationFilter != null && filter.Scope >= info.AuthorizationOverrideScope) { _authorizationFilters.Add(authorizationFilter); } IExceptionFilter exceptionFilter = filter.Instance as IExceptionFilter; if (exceptionFilter != null && filter.Scope >= info.ExceptionOverrideScope) { _exceptionFilters.Add(exceptionFilter); } IResultFilter resultFilter = filter.Instance as IResultFilter; if (resultFilter != null && filter.Scope >= info.ResultOverrideScope) { _resultFilters.Add(resultFilter); } } }
public static void AfterOnAuthorization( this DiagnosticSource diagnosticSource, AuthorizationFilterContext authorizationContext, IAuthorizationFilter filter) { if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.AfterOnAuthorization")) { diagnosticSource.Write( "Microsoft.AspNetCore.Mvc.AfterOnAuthorization", new { actionDescriptor = authorizationContext.ActionDescriptor, authorizationContext = authorizationContext, filter = filter }); } }
public static void BeforeOnAuthorization( this DiagnosticSource diagnosticSource, AuthorizationFilterContext authorizationContext, IAuthorizationFilter filter) { if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.BeforeOnAuthorization")) { diagnosticSource.Write( "Microsoft.AspNetCore.Mvc.BeforeOnAuthorization", new { actionDescriptor = authorizationContext.ActionDescriptor, authorizationContext = authorizationContext, filter = filter }); } }
public void ExecuteAsync_RunsExceptionFilter_WhenAuthorizationFilterThrowsException() { // Arrange Exception expectedException = new NotImplementedException(); ApiController controller = new ExceptionlessController(); Mock <IAuthorizationFilter> filterMock = new Mock <IAuthorizationFilter>(); filterMock.Setup(f => f.ExecuteAuthorizationFilterAsync(It.IsAny <HttpActionContext>(), It.IsAny <CancellationToken>(), It.IsAny <Func <Task <HttpResponseMessage> > >())).Callback(() => { throw expectedException; }); IAuthorizationFilter filter = filterMock.Object; // Act & Assert TestExceptionFilter(controller, expectedException, (configuration) => { configuration.Filters.Add(filter); }); }
public void AuthorizationFilters_ReturnsLastAuthorizationFilters_WhenOverrideScopeIsLast() { // Arrange Filter firstFilter = CreateFilter(CreateDummyAuthorizationFilter(), FilterScope.First); Filter globalFilter = CreateFilter( CreateDummyAuthorizationFilter(), FilterScope.Global ); Filter controllerFilter = CreateFilter( CreateDummyAuthorizationFilter(), FilterScope.Controller ); Filter actionFilter = CreateFilter( CreateDummyAuthorizationFilter(), FilterScope.Action ); IAuthorizationFilter expectedLastFilter = CreateDummyAuthorizationFilter(); Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last); Filter overrideFilter = CreateFilter( CreateOverride(typeof(IAuthorizationFilter)), FilterScope.Last ); IEnumerable <Filter> filters = new Filter[] { firstFilter, globalFilter, controllerFilter, actionFilter, lastFilter, overrideFilter }; FilterInfo product = CreateProductUnderTest(filters); // Act IList <IAuthorizationFilter> authorizationFilters = product.AuthorizationFilters; // Assert Assert.NotNull(authorizationFilters); Assert.Equal(1, authorizationFilters.Count); Assert.Same(expectedLastFilter, authorizationFilters[0]); }
public void Initialise( string connectionStringName = "", string routesPrefix = "IlaroAdmin", IAuthorizationFilter authorize = null) { RoutesPrefix = routesPrefix; Authorize = authorize; RoutesPrefix = routesPrefix; ConnectionStringName = GetConnectionStringName(connectionStringName); foreach (var customizer in CustomizerHolders) { var entity = CreateInstance(customizer.Key); ((CustomizersHolder)customizer.Value).CustomizeEntity(entity, this); } foreach (var customizer in CustomizerHolders) { var entity = GetEntity(customizer.Key); ((CustomizersHolder)customizer.Value).CustomizeProperties(entity, this); } }
public static void BeforeOnAuthorization( this DiagnosticSource diagnosticSource, AuthorizationFilterContext authorizationContext, IAuthorizationFilter filter) { Debug.Assert(diagnosticSource != null); Debug.Assert(authorizationContext != null); Debug.Assert(filter != null); if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.BeforeOnAuthorization")) { diagnosticSource.Write( "Microsoft.AspNetCore.Mvc.BeforeOnAuthorization", new { actionDescriptor = authorizationContext.ActionDescriptor, authorizationContext = authorizationContext, filter = filter }); } }
public void ExecuteAsync_ChainsFiltersInOrderFollowedByInnerActionContinuation() { // Arrange HttpActionContext actionContextInstance = ContextUtil.CreateActionContext(); List<string> log = new List<string>(); Mock<IAuthorizationFilter> globalFilterMock = CreateAuthorizationFilterMock((ctx, ct, continuation) => { log.Add("globalFilter"); return continuation(); }); Mock<IAuthorizationFilter> actionFilterMock = CreateAuthorizationFilterMock((ctx, ct, continuation) => { log.Add("actionFilter"); return continuation(); }); Mock<IHttpActionResult> innerResultMock = new Mock<IHttpActionResult>(); innerResultMock.Setup(r => r.ExecuteAsync(It.IsAny<CancellationToken>())).Returns(() => { log.Add("innerAction"); return Task.FromResult<HttpResponseMessage>(null); }); IHttpActionResult innerResult = innerResultMock.Object; var filters = new IAuthorizationFilter[] { globalFilterMock.Object, actionFilterMock.Object, }; IHttpActionResult authorizationFilter = new AuthorizationFilterResult(actionContextInstance, filters, innerResult); // Act Task<HttpResponseMessage> result = authorizationFilter.ExecuteAsync(CancellationToken.None); // Assert Assert.NotNull(result); result.WaitUntilCompleted(); Assert.Equal(new[] { "globalFilter", "actionFilter", "innerAction" }, log.ToArray()); globalFilterMock.Verify(); actionFilterMock.Verify(); }
/// <summary> /// Add HTTP base health check middleware to the <see cref="IApplicationBuilder"/> request execution pipe. /// </summary> /// <param name="builder"></param> /// <param name="path">The path to use as healhcheck route.</param> public static void UseHttpHealthCheck(this IApplicationBuilder builder, string path = "/status") { builder.Map(path, (app) => { app.Run(async ctx => { IHttpHealthService service = ctx.RequestServices.GetRequiredService <IHttpHealthService> (); if (HttpMethod.Get.Method.Equals(ctx.Request.Method)) { IHttpHealthService checker = ctx.RequestServices.GetRequiredService <IHttpHealthService> (); ctx.Response.ContentType = "text/plain"; await ctx.Response.WriteAsync(checker.Health); if (!checker.IsHealthy) { ctx.Response.StatusCode = 503; } } else if (HttpMethod.Put.Method.Equals(ctx.Request.Method)) { if (service != null) { IAuthorizationFilter filter = app.ApplicationServices.GetService <IAuthorizationFilter>(); if (filter != null) { if (await filter.FilterAsync(ctx)) { await service.HttpPutRequestReceived(ctx); } } } } }); }); }
public AuthorizationFilterTracer(IAuthorizationFilter innerFilter, ITraceWriter traceWriter) : base(innerFilter, traceWriter) { }
public GlimpseAuthorizationFilter(IAuthorizationFilter authorizationFilter) { AuthorizationFilter = authorizationFilter; }
private static void AfterOnAuthorizationImpl(DiagnosticListener diagnosticListener, AuthorizationFilterContext authorizationContext, IAuthorizationFilter filter) { if (diagnosticListener.IsEnabled(Diagnostics.AfterAuthorizationFilterOnAuthorizationEventData.EventName)) { diagnosticListener.Write( Diagnostics.AfterAuthorizationFilterOnAuthorizationEventData.EventName, new AfterAuthorizationFilterOnAuthorizationEventData( authorizationContext.ActionDescriptor, authorizationContext, filter )); } }
public AuthorizationFilterOverride(IAuthorizationFilter wrappedFilter) { _wrappedFilter = wrappedFilter; }
public void InvokeActionWithAuthorizationFilters_ChainsFiltersInOrderFollowedByInnerActionContinuation() { // Arrange List<string> log = new List<string>(); Mock<IAuthorizationFilter> globalFilterMock = CreateAuthorizationFilterMock((ctx, ct, continuation) => { log.Add("globalFilter"); return continuation(); }); Mock<IAuthorizationFilter> actionFilterMock = CreateAuthorizationFilterMock((ctx, ct, continuation) => { log.Add("actionFilter"); return continuation(); }); Func<Task<HttpResponseMessage>> innerAction = () => Task<HttpResponseMessage>.Factory.StartNew(() => { log.Add("innerAction"); return null; }); var filters = new IAuthorizationFilter[] { globalFilterMock.Object, actionFilterMock.Object, }; // Act var result = ApiController.InvokeActionWithAuthorizationFilters(_actionContextInstance, CancellationToken.None, filters, innerAction); // Assert Assert.NotNull(result); var resultTask = result(); Assert.NotNull(resultTask); resultTask.WaitUntilCompleted(); Assert.Equal(new[] { "globalFilter", "actionFilter", "innerAction" }, log.ToArray()); globalFilterMock.Verify(); actionFilterMock.Verify(); }
public static void AfterOnAuthorization( this DiagnosticSource diagnosticSource, AuthorizationFilterContext authorizationContext, IAuthorizationFilter filter) { Debug.Assert(diagnosticSource != null); Debug.Assert(authorizationContext != null); Debug.Assert(filter != null); if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.AfterOnAuthorization")) { diagnosticSource.Write( "Microsoft.AspNetCore.Mvc.AfterOnAuthorization", new { actionDescriptor = authorizationContext.ActionDescriptor, authorizationContext = authorizationContext, filter = filter }); } }
/// <summary> /// Add default HTTP health service to the provided <see cref="IServiceCollection"/>. /// </summary> /// <param name="healthService"></param> public static IServiceCollection AddHttpHealthService(this IServiceCollection services, IAuthorizationFilter filter) { services.AddSingleton <IHttpHealthService>(HttpHealthService.Default); return(services.AddSingleton(filter)); }
public static IEnumerable <IFilter> CreateFilterTracers(IFilter filter, ITraceWriter traceWriter) { List <IFilter> filters = new List <IFilter>(); bool addedActionAttributeTracer = false; bool addedAuthorizationAttributeTracer = false; bool addedExceptionAttributeTracer = false; ActionFilterAttribute actionFilterAttribute = filter as ActionFilterAttribute; if (actionFilterAttribute != null) { filters.Add(new ActionFilterAttributeTracer(actionFilterAttribute, traceWriter)); addedActionAttributeTracer = true; } AuthorizationFilterAttribute authorizationFilterAttribute = filter as AuthorizationFilterAttribute; if (authorizationFilterAttribute != null) { filters.Add(new AuthorizationFilterAttributeTracer(authorizationFilterAttribute, traceWriter)); addedAuthorizationAttributeTracer = true; } ExceptionFilterAttribute exceptionFilterAttribute = filter as ExceptionFilterAttribute; if (exceptionFilterAttribute != null) { filters.Add(new ExceptionFilterAttributeTracer(exceptionFilterAttribute, traceWriter)); addedExceptionAttributeTracer = true; } // Do not add an IActionFilter tracer if we already added an ActionFilterAttribute tracer IActionFilter actionFilter = filter as IActionFilter; if (actionFilter != null && !addedActionAttributeTracer) { filters.Add(new ActionFilterTracer(actionFilter, traceWriter)); } // Do not add an IAuthorizationFilter tracer if we already added an AuthorizationFilterAttribute tracer IAuthorizationFilter authorizationFilter = filter as IAuthorizationFilter; if (authorizationFilter != null && !addedAuthorizationAttributeTracer) { filters.Add(new AuthorizationFilterTracer(authorizationFilter, traceWriter)); } // Do not add an IExceptionFilter tracer if we already added an ExceptoinFilterAttribute tracer IExceptionFilter exceptionFilter = filter as IExceptionFilter; if (exceptionFilter != null && !addedExceptionAttributeTracer) { filters.Add(new ExceptionFilterTracer(exceptionFilter, traceWriter)); } if (filters.Count == 0) { filters.Add(new FilterTracer(filter, traceWriter)); } return(filters); }
/// <summary> /// Adds the specified filter to the AuthorizationFilter list. /// </summary> /// <param name="filter"></param> protected virtual void AddAuthorizationFilter(IAuthorizationFilter filter) { if (AuthorizationFilters.Contains(filter)) return; AuthorizationFilters.Add(filter); }
public static void SetAuthorizationFilter(this HttpConfiguration configuration, IAuthorizationFilter filter) { configuration.Filters.Add(filter); }
public AuthorizationFilterOverride(IAuthorizationFilter wrappedFilter) { this._wrappedFilter = wrappedFilter; }