public void Init()
{
filter = new NonTenant
{
Logger = Substitute.For <ILogger>()
};
}
/// <summary>
/// 执行
/// </summary>
/// <param name="context">操作执行上下文</param>
/// <param name="next">委托</param>
/// <returns></returns>
public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
ActionFilterAttribute actionFilterAttribute = this;
actionFilterAttribute.OnActionExecuting(context);
await OnActionExecutingAsync(context);
if (context.Result != null)
{
return;
}
var executedContext = await next();
actionFilterAttribute.OnActionExecuted(executedContext);
}
/// <summary>
/// 构造ApiExecutionContextHandler
/// </summary>
/// <param name="attr"></param>
public ApiExecutionContextHandler(ActionFilterAttribute attr)
{
ExceptionHandler = new DefaultApiExceptionHandler();
ModelStateValidationErrorHandler = new DefaultModelStateValidationErrorHandler();
UnauthorizedRequestHandler = new DefaultUnauthorizedRequestHandler();
this.AssociateFilter = attr;
}
public ActionFilterAttributeTracer(ActionFilterAttribute innerFilter, ITraceWriter traceWriter)
{
Contract.Assert(innerFilter != null);
Contract.Assert(traceWriter != null);
_innerFilter = innerFilter;
_traceWriter = traceWriter;
}
public void Decorator_GetInner_On_ActionFilterAttributeTracer_Returns_ActionFilterAttribute()
{
// Arrange
ActionFilterAttribute expectedInner = new Mock <ActionFilterAttribute>().Object;
ActionFilterAttributeTracer productUnderTest = new ActionFilterAttributeTracer(expectedInner, new TestTraceWriter());
// Act
ActionFilterAttribute actualInner = Decorator.GetInner(productUnderTest as ActionFilterAttribute);
// Assert
Assert.Same(expectedInner, actualInner);
}
public void Inner_Property_On_ActionFilterAttributeTracer_Returns_ActionFilterAttribute()
{
// Arrange
ActionFilterAttribute expectedInner = new Mock <ActionFilterAttribute>().Object;
ActionFilterAttributeTracer productUnderTest = new ActionFilterAttributeTracer(expectedInner, new TestTraceWriter());
// Act
ActionFilterAttribute actualInner = productUnderTest.Inner;
// Assert
Assert.Same(expectedInner, actualInner);
}
/// <summary>
/// Tries to retrieve the id parameter from the currently executing action method.
/// <br/>
/// Throws ArgumentNullException if 'id' could not be found.
/// <br/>
/// Throws ArgumentException if 'id' is not an int.
/// </summary>
/// <returns>The int value of the 'id' parameter of the currently executing action method.</returns>
internal static int GetIdValue(this ActionFilterAttribute actionFilter, ActionExecutingContext filterContext)
{
object reviewIdObj;
if (!filterContext.ActionParameters.TryGetValue("id", out reviewIdObj))
{
throw new ArgumentNullException(
"id", string.Format(
"Could not find 'id' parameter in action method '{0}' but need it to control access!",
filterContext.ActionDescriptor.ActionName));
}
var reviewId = GetIdAsInt(reviewIdObj);
return(reviewId);
}
/// <summary>
/// Adds a type to a <see cref="FilterCollection" /> if it doesn't already exist.
/// </summary>
/// <typeparam name="TType">The type of the t type.</typeparam>
/// <param name="col">The col.</param>
/// <param name="order">Filter order</param>
/// <returns>FilterCollection.</returns>
public static FilterCollection TryAdd <TType>(this FilterCollection col, int?order = null)
where TType : IFilterMetadata
{
var vt = typeof(TType);
if (col.All(t =>
{
// Yet more lameness, really should be able to do a simple test here...
return(t switch
{
TypeFilterAttribute tf => tf.ImplementationType != vt,
ServiceFilterAttribute sf => sf.ServiceType != vt,
FormatFilterAttribute ff => ff.GetType() != vt,
ResultFilterAttribute rs => rs.GetType() != vt,
ExceptionFilterAttribute ef => ef.GetType() != vt,
ActionFilterAttribute af => af.GetType() != vt,
_ => t.GetType() != vt
});
}
public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
ActionFilterAttribute actionFilterAttribute = this;
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
actionFilterAttribute.OnActionExecuting(context);
if (context.Result != null)
{
return;
}
var context1 = await next();
await ProcessODataQuery(context1);
OnActionExecuted(context1);
}
public ActionFilterAttributeTracer(ActionFilterAttribute innerFilter, ITraceWriter traceWriter)
{
_innerFilter = innerFilter;
_traceWriter = traceWriter;
}
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 AuthenticationFilterAttribute()
{
principalFilter = new PrincipalPersistFilterAttribute();
}
protected override ActionFilterAttribute CreateSubject() => sut = Substitute.For <ActionFilterAttribute>();
