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);
}
public GlimpseAuthorizationFilter(IAuthorizationFilter authorizationFilter)
{
AuthorizationFilter = authorizationFilter;
}
/// <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;
}
public AuthorizationFilterTracer(IAuthorizationFilter innerFilter, ITraceWriter traceWriter)
: base(innerFilter, traceWriter)
{
}
