public async Task <HttpResponseMessage> ExecuteActionFilterAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func <Task <HttpResponseMessage> > continuation)
{
var actionDescriptor = actionContext.ActionDescriptor as ReflectedHttpActionDescriptor;
if (actionDescriptor == null || !_auditingHelper.ShouldSaveAudit(actionDescriptor?.MethodInfo, true))//此时说明不需要审计
{
return(await continuation());
}
var auditInfo = _auditingHelper.CreateAuditInfo(
actionContext.ActionDescriptor.ControllerDescriptor.ControllerType,
actionDescriptor.MethodInfo,
actionContext.ActionArguments);
var stopwatch = Stopwatch.StartNew();
try
{
return(await continuation());
}
catch (Exception ex)
{
auditInfo.Exception = ex;//若发生异常则保存异常
throw;
}
finally
{
stopwatch.Stop();
auditInfo.ExecutionDuration = Convert.ToInt32(stopwatch.Elapsed.TotalMilliseconds);
await _auditingHelper.SaveAsync(auditInfo);//插入审计信息到数据库
}
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="audit"></param>
/// <param name="auditAction"></param>
/// <returns></returns>
protected virtual bool ShouldIntercept(AspectContext context, out AuditInfo audit, out AuditActionInfo auditAction)
{
audit = null;
auditAction = null;
if (CrossCuttingConcerns.IsApplied(context.Implementation, Concerns))
{
return(false);
}
if (context.ServiceMethod.AttributeExists <DisableAuditingAttribute>() || context.ImplementationMethod.AttributeExists <DisableAuditingAttribute>())
{
return(false);
}
var auditScope = _auditingManager.Current;
if (auditScope == null)
{
return(false);
}
if (!_auditingHelper.ShouldSaveAudit(context.ImplementationMethod) && !_auditingHelper.ShouldSaveAudit(context.ServiceMethod))
{
return(false);
}
audit = auditScope.Info;
auditAction = _auditingHelper.CreateAuditAction(
context.Implementation.GetType(), context.ImplementationMethod, context.Parameters
);
return(true);
}
protected virtual bool ShouldIntercept(
IAbpMethodInvocation invocation,
out AuditLogInfo auditLog,
out AuditLogActionInfo auditLogAction)
{
auditLog = null;
auditLogAction = null;
if (AbpCrossCuttingConcerns.IsApplied(invocation.TargetObject, AbpCrossCuttingConcerns.Auditing))
{
return(false);
}
var auditLogScope = _auditingManager.Current;
if (auditLogScope == null)
{
return(false);
}
if (!_auditingHelper.ShouldSaveAudit(invocation.Method))
{
return(false);
}
auditLog = auditLogScope.Log;
auditLogAction = _auditingHelper.CreateAuditLogAction(
auditLog,
invocation.TargetObject.GetType(),
invocation.Method,
invocation.Arguments
);
return(true);
}
public void Intercept(IInvocation invocation)
{
//判断过滤器是否已经处理了过了
if (AbpCrossCuttingConcerns.IsApplied(invocation.InvocationTarget, AbpCrossCuttingConcerns.Auditing))
{
invocation.Proceed();
return;
}
//通过 IAuditingHelper 来判断当前方法是否需要记录审计日志信息
if (!_auditingHelper.ShouldSaveAudit(invocation.MethodInvocationTarget))
{
invocation.Proceed();
return;
}
// 构造审计信息
var auditInfo = _auditingHelper.CreateAuditInfo(invocation.TargetType, invocation.MethodInvocationTarget, invocation.Arguments);
//判断方法的类型，同步方法与异步方法的处理逻辑不一样
if (invocation.Method.IsAsync())
{
PerformAsyncAuditing(invocation, auditInfo);
}
else
{
PerformSyncAuditing(invocation, auditInfo);
}
}
public void Intercept(IInvocation invocation)
{
if (AbpCrossCuttingConcerns.IsApplied(invocation.InvocationTarget, AbpCrossCuttingConcerns.Auditing))
{
invocation.Proceed();
return;
}
if (!_auditingHelper.ShouldSaveAudit(invocation.MethodInvocationTarget))
{
invocation.Proceed();
return;
}
var auditInfo = _auditingHelper.CreateAuditInfo(invocation.TargetType, invocation.MethodInvocationTarget, invocation.Arguments);
if (AsyncHelper.IsAsyncMethod(invocation.Method))
{
PerformAsyncAuditing(invocation, auditInfo);
}
else
{
PerformSyncAuditing(invocation, auditInfo);
}
}
private bool ShouldSaveAudit(ActionExecutingContext filterContext)
{
var currentMethodInfo = filterContext.ActionDescriptor.GetMethodInfoOrNull();
if (currentMethodInfo == null)
{
return(false);
}
if (_configuration == null)
{
return(false);
}
if (!_configuration.IsAuditingEnabled)
{
return(false);
}
if (filterContext.IsChildAction && !_configuration.IsAuditingEnabledForChildActions)
{
return(false);
}
return(_auditingHelper.ShouldSaveAudit(currentMethodInfo, true));
}
/// <summary>
/// Shoulds the intercept.
/// </summary>
/// <param name="invocation">The invocation.</param>
/// <param name="auditLog">The audit log.</param>
/// <param name="auditLogAction">The audit log action.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
protected virtual bool ShouldIntercept(
IMethodInvocation invocation,
out AuditLogInfo auditLog,
out AuditLogActionInfo auditLogAction)
{
auditLog = null;
auditLogAction = null;
if (CrossCuttingConcerns.IsApplied(invocation.TargetObject, CrossCuttingConcerns.Auditing))
{
return(false);
}
// 如果没有获取到 Scop，则返回 false。
var auditLogScope = _auditingManager.Current;
if (auditLogScope == null)
{
return(false);
}
// 进行二次判断是否需要存储审计日志。
if (!_auditingHelper.ShouldSaveAudit(invocation.Method))
{
return(false);
}
// 构建审计日志信息。
auditLog = auditLogScope.Log;
auditLogAction = _auditingHelper.CreateAuditLogAction(
auditLog,
invocation.TargetObject.GetType(),
invocation.Method,
invocation.Arguments
);
return(true);
}
private bool ShouldSaveAudit(HttpActionContext context)
{
if (context.ActionDescriptor.IsDynamicInfrastructureAction())
{
return(false);
}
return(_auditingHelper.ShouldSaveAudit(context.ActionDescriptor.GetMethodInfoOrNull(), true));
}
private bool ShouldSaveAudit(ActionExecutingContext actionContext)
{
if (!_auditingConfiguration.IsEnabled || !_auditingConfiguration.MvcControllers.IsEnabled)
{
return(false);
}
return(_auditingHelper.ShouldSaveAudit(actionContext.ActionDescriptor.GetMethodInfo(), true));
}
/// <summary>
/// 是否需要审计
/// </summary>
/// <param name="filterContext"></param>
/// <returns></returns>
private bool ShouldSaveAudit(ActionExecutingContext filterContext)
{
var currentMethodInfo = filterContext.ActionDescriptor.GetMethodInfoOrNull();
if (currentMethodInfo == null)
{
return(false);
}
return(_auditingHelper.ShouldSaveAudit(currentMethodInfo, true));//默认为true
}
public override void InterceptSynchronous(IInvocation invocation)
{
if (AbpCrossCuttingConcerns.IsApplied(invocation.InvocationTarget, AbpCrossCuttingConcerns.Auditing))
{
invocation.Proceed();
return;
}
if (!_auditingHelper.ShouldSaveAudit(invocation.MethodInvocationTarget))
{
invocation.Proceed();
return;
}
var auditInfo = _auditingHelper.CreateAuditInfo(invocation.TargetType, invocation.MethodInvocationTarget, invocation.Arguments);
var stopwatch = Stopwatch.StartNew();
try
{
invocation.Proceed();
}
catch (Exception ex)
{
auditInfo.Exception = ex;
throw;
}
finally
{
stopwatch.Stop();
auditInfo.ExecutionDuration = Convert.ToInt32(stopwatch.Elapsed.TotalMilliseconds);
if (_auditingConfiguration.SaveReturnValues && invocation.ReturnValue != null)
{
auditInfo.ReturnValue = _auditSerializer.Serialize(invocation.ReturnValue);
}
_auditingHelper.Save(auditInfo);
}
}
private bool ShouldSaveAudit(HttpActionContext context)
{
if (!_auditingConfiguration.IsEnabled)
{
return(false);
}
if (context.ActionDescriptor.IsDynamicAbpAction())
{
return(false);
}
return(_auditingHelper.ShouldSaveAudit(context.ActionDescriptor.GetMethodInfoOrNull(), true));
}
private bool ShouldSaveAudit(ActionExecutingContext context, out AuditLogInfo auditLog,
out AuditLogActionInfo auditLogAction)
{
auditLog = null;
auditLogAction = null;
var method = context.HttpContext.Request.Method;
if (method.Equals(HttpMethod.Options.Method, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (!Options.IsEnabled)
{
return(false);
}
if (!context.ActionDescriptor.IsControllerAction())
{
return(false);
}
var auditLogScope = _auditingManager.Current;
if (auditLogScope == null)
{
return(false);
}
if (!_auditingHelper.ShouldSaveAudit(context.ActionDescriptor.GetMethodInfo(), true))
{
return(false);
}
auditLog = auditLogScope.Log;
auditLog.UserId = _currentUser?.Id;
auditLog.UserName = _currentUser?.UserName;
auditLogAction = _auditingHelper.CreateAuditLogAction(
auditLog,
context.ActionDescriptor.AsControllerActionDescriptor().ControllerTypeInfo.AsType(),
context.ActionDescriptor.AsControllerActionDescriptor().MethodInfo,
context.ActionArguments
);
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="audit"></param>
/// <param name="auditAction"></param>
/// <returns></returns>
protected virtual bool ShouldIntercept(IMethodInvocation context, out AuditInfo audit, out AuditActionInfo auditAction)
{
audit = null;
auditAction = null;
if (!_options.IsEnabled)
{
return(false);
}
if (!(_options.IsEnabledForAnonymousUsers || (_principalAccessor.Principal?.Identity?.IsAuthenticated ?? false)))
{
return(false);
}
if (CrossCuttingConcerns.IsApplied(context.TargetObject, Concerns))
{
return(false);
}
if (context.Method.AttributeExists <AuditedAttribute>())
{
return(true);
}
if (context.Method.AttributeExists <DisableAuditingAttribute>())
{
return(false);
}
var auditScope = _auditingManager.Current;
if (auditScope == null)
{
return(false);
}
if (!_auditingHelper.ShouldSaveAudit(context.Method, true))
{
return(false);
}
audit = auditScope.Info;
auditAction = _auditingHelper.CreateAuditAction(
context.TargetObject.GetType(), context.Method, context.Arguments
);
return(true);
}
public void Intercept(IInvocation invocation)
{
if (!_auditingHelper.ShouldSaveAudit(invocation.MethodInvocationTarget))
{
invocation.Proceed();
return;
}
var auditInfo = _auditingHelper.CreateAuditInfo(invocation.TargetType, invocation.MethodInvocationTarget, invocation.Arguments);
if (invocation.Method.ReturnType == typeof(Task) ||
(invocation.Method.ReturnType.GetTypeInfo().IsGenericType&& invocation.Method.ReturnType.GetGenericTypeDefinition() == typeof(Task <>)))
{
PerformAsyncAuditing(invocation, auditInfo);
}
else
{
PerformSyncAuditing(invocation, auditInfo);
}
}
private bool ShouldSaveAudit(ActionExecutingContext context, out AuditLogInfo auditLog, out AuditLogActionInfo auditLogAction)
{
auditLog = null;
auditLogAction = null;
if (!Options.IsEnabled)
{
return(false);
}
if (!context.ActionDescriptor.IsControllerAction())
{
return(false);
}
var auditLogScope = _auditingManager.Current;
if (auditLogScope == null)
{
return(false);
}
if (!_auditingHelper.ShouldSaveAudit(context.ActionDescriptor.GetMethodInfo(), true))
{
return(false);
}
//TODO: This is partially duplication of AuditHelper.ShouldSaveAudit method. Check why it does not work for controllers
if (!AuditingInterceptorRegistrar.ShouldAuditTypeByDefault(context.Controller.GetType()))
{
return(false);
}
auditLog = auditLogScope.Log;
auditLogAction = _auditingHelper.CreateAuditLogAction(
auditLog,
context.ActionDescriptor.AsControllerActionDescriptor().ControllerTypeInfo.AsType(),
context.ActionDescriptor.AsControllerActionDescriptor().MethodInfo,
context.ActionArguments
);
return(true);
}
public void OnAuthorization(AuthorizationContext filterContext)
{
if (filterContext.IsChildAction)
{
return;
}
var methodInfo = filterContext.ActionDescriptor.GetMethodInfoOrNull();
if (methodInfo == null)
{
return;
}
if (_auditingHelper.ShouldSaveAudit(methodInfo) && _userContext.GetCurrentUser() == null
)
{
HandleUnauthorizedRequest(filterContext, methodInfo)
;
}
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="audit"></param>
/// <param name="auditAction"></param>
/// <returns></returns>
protected virtual bool ShouldIntercept(AspectContext context, out AuditInfo audit, out AuditActionInfo auditAction)
{
audit = null;
auditAction = null;
if (_options.IsEnabled == false)
{
return(false);
}
if (!(_options.IsEnabledForAnonymousUsers || (_principalAccessor.Principal?.Identity?.IsAuthenticated ?? false)))
{
return(false);
}
if (CrossCuttingConcerns.IsApplied(context.Implementation, Concerns))
{
return(false);
}
if (context.ServiceMethod.AttributeExists <DisableAuditingAttribute>() || context.ImplementationMethod.AttributeExists <DisableAuditingAttribute>())
{
return(false);
}
var auditScope = _auditingManager.Current;
if (auditScope == null)
{
return(false);
}
if (!_auditingHelper.ShouldSaveAudit(context.ImplementationMethod, true) && !_auditingHelper.ShouldSaveAudit(context.ServiceMethod, true))
{
return(false);
}
audit = auditScope.Info;
auditAction = _auditingHelper.CreateAuditAction(
context.Implementation.GetType(), context.ImplementationMethod, context.Parameters
);
return(true);
}
protected virtual bool ShouldIntercept(IAbpMethodInvocation invocation,
AbpAuditingOptions options,
IAuditingHelper auditingHelper)
{
if (!options.IsEnabled)
{
return(false);
}
if (AbpCrossCuttingConcerns.IsApplied(invocation.TargetObject, AbpCrossCuttingConcerns.Auditing))
{
return(false);
}
if (!auditingHelper.ShouldSaveAudit(invocation.Method))
{
return(false);
}
return(true);
}
private bool ShouldSaveAudit(ActionExecutingContext context, out AuditInfo auditLog, out AuditActionInfo auditLogAction)
{
auditLog = null;
auditLogAction = null;
if (!Options.IsEnabled)
{
return(false);
}
if (!Options.IsAuditingController())
{
return(false);
}
if (!context.ActionDescriptor.IsControllerAction())
{
return(false);
}
var auditLogScope = _auditingManager.Current;
if (auditLogScope == null)
{
return(false);
}
if (!_auditingHelper.ShouldSaveAudit(context.ActionDescriptor.GetMethodInfo(), true))
{
return(false);
}
auditLog = auditLogScope.Info;
auditLogAction = _auditingHelper.CreateAuditAction(
context.ActionDescriptor.AsControllerActionDescriptor().ControllerTypeInfo.AsType(),
context.ActionDescriptor.AsControllerActionDescriptor().MethodInfo,
context.ActionArguments
);
return(true);
}
private bool ShouldSaveAudit(PageHandlerExecutingContext context, out AuditInfo auditLog, out AuditActionInfo auditLogAction)
{
auditLog = null;
auditLogAction = null;
if (!Options.IsEnabled)
{
return(false);
}
if (!Options.IsAuditingPage())
{
return(false);
}
if (!(context.ActionDescriptor is CompiledPageActionDescriptor))
{
return(false);
}
var auditLogScope = _auditingManager.Current;
if (auditLogScope == null)
{
return(false);
}
if (!_auditingHelper.ShouldSaveAudit(context.HandlerMethod.MethodInfo, true))
{
return(false);
}
auditLog = auditLogScope.Info;
auditLogAction = _auditingHelper.CreateAuditAction(
context.ActionDescriptor.HandlerTypeInfo,
context.HandlerMethod.MethodInfo,
context.HandlerArguments
);
return(true);
}
private bool ShouldSaveAudit(PageHandlerExecutingContext actionContext)
{
return(_configuration.IsAuditingEnabled &&
_auditingHelper.ShouldSaveAudit(actionContext.HandlerMethod.MethodInfo, true));
}
private bool ShouldSaveAudit(ActionExecutingContext actionContext)
{
return(_configuration.IsAuditingEnabled &&
actionContext.ActionDescriptor.IsControllerAction() &&
_auditingHelper.ShouldSaveAudit(actionContext.ActionDescriptor.GetMethodInfo(), true));
}
public void ShouldSaveAuditForAttribute(Type type, bool result)
{
var method = type.GetMethod("Method");
_auditingHelper.ShouldSaveAudit(method).ShouldBe(result);
}
