/// <summary>
/// intercept as an asynchronous operation.
/// </summary>
/// <param name="invocation">The invocation.</param>
/// <returns>Task.</returns>
public override async Task InterceptAsync(IMethodInvocation invocation)
{
if (!ShouldIntercept(invocation, out var auditLog, out var auditLogAction))
{
await invocation.ProceedAsync();
return;
}
// 开始进行计时操作。
var stopwatch = Stopwatch.StartNew();
try
{
await invocation.ProceedAsync();
}
catch (Exception ex)
{
// 如果出现了异常，一样的将异常信息添加到审计日志结果中。
auditLog.Exceptions.Add(ex);
throw;
}
finally
{
// 统计完成，并将信息加入到审计日志结果中。
stopwatch.Stop();
auditLogAction.ExecutionDuration = Convert.ToInt32(stopwatch.Elapsed.TotalMilliseconds);
auditLog.Actions.Add(auditLogAction);
}
}
public async Task InterceptAsync(IMethodInvocation invocation)
{
if (!CompensableHelper.IsCompensableMethod(invocation.Method))
{
await invocation.ProceedAsync();
return;
}
CompensableMethodContext compensableMethodContext = new CompensableMethodContext(invocation, _serviceProvider);
var isTransactionActive = _transactionManager.IsTransactionActive();
if (!TransactionUtils.IsLegalTransactionContext(isTransactionActive, compensableMethodContext))
{
throw new TransactionException($"no available compensable transaction, the method {compensableMethodContext.MethodInfo.Name} is illegal");
}
switch (compensableMethodContext.GetMethodRole(isTransactionActive))
{
case MethodRole.ROOT:
await RootMethodProceed(compensableMethodContext);
break;
case MethodRole.PROVIDER:
await ProviderMethodProceed(compensableMethodContext);
break;
default:
await invocation.ProceedAsync();
break;
}
}
public override async Task InterceptAsync(IMethodInvocation invocation)
{
if (!UnitOfWorkHelper.IsUnitOfWorkMethod(invocation.Method, out var unitOfWorkAttribute))
{
await invocation.ProceedAsync();
return;
}
using (var scope = _serviceScopeFactory.CreateScope())
{
var options = CreateOptions(scope.ServiceProvider, invocation, unitOfWorkAttribute);
var unitOfWorkManager = scope.ServiceProvider.GetRequiredService <IUnitOfWorkManager>();
//Trying to begin a reserved UOW by UnitOfWorkMiddleware
if (unitOfWorkManager.TryBeginReserved(UnitOfWork.UnitOfWorkReservationName, options))
{
await invocation.ProceedAsync();
return;
}
using (var uow = unitOfWorkManager.Begin(options))
{
await invocation.ProceedAsync();
await uow.CompleteAsync();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="invocation"></param>
/// <returns></returns>
public async Task InterceptAsync(IMethodInvocation invocation)
{
if (!ShouldIntercept(invocation, out var audit, out var auditAction))
{
await invocation.ProceedAsync();
return;
}
var stopwatch = Stopwatch.StartNew();
try
{
await invocation.ProceedAsync();
}
catch (Exception ex)
{
audit.Exceptions.Add(ex);
throw;
}
finally
{
stopwatch.Stop();
auditAction.ExecutionDuration = stopwatch.Elapsed;
audit.Actions.Add(auditAction);
}
}
public async Task InterceptAsync(IMethodInvocation invocation)
{
if (!CompensableHelper.IsCompensableMethod(invocation.Method))
{
await invocation.ProceedAsync();
return;
}
var transaction = _transactionManager.Current;
if (transaction != null)
{
switch (transaction.Status)
{
case TransactionStatus.TRYING:
EnlistParticipant(invocation);
break;
case TransactionStatus.CONFIRMING:
break;
case TransactionStatus.CANCELLING:
break;
}
}
await invocation.ProceedAsync();
}
/// <summary>
/// intercept as an asynchronous operation.
/// </summary>
/// <param name="invocation">The invocation.</param>
/// <returns>Task.</returns>
public override async Task InterceptAsync(IMethodInvocation invocation)
{
if (!UnitOfWorkHelper.IsUnitOfWorkMethod(invocation.Method, out var unitOfWorkAttribute))
{
await invocation.ProceedAsync();
return;
}
using (var uow = _unitOfWorkManager.Begin(CreateOptions(invocation, unitOfWorkAttribute)))
{
await invocation.ProceedAsync();
await uow.CompleteAsync();
}
}
private static async Task ProceedByLoggingAsync(
IMethodInvocation invocation,
IAuditingFactory auditingHelper,
IAuditLogScope auditLogScope)
{
var auditLog = auditLogScope.Log;
var auditLogAction = auditingHelper.CreateAuditLogAction(
auditLog,
invocation.TargetObject.GetType(),
invocation.Method,
invocation.Arguments
);
var stopwatch = Stopwatch.StartNew();
try
{
await invocation.ProceedAsync();
}
catch (Exception ex)
{
auditLog.Exceptions.Add(ex);
throw;
}
finally
{
stopwatch.Stop();
auditLogAction.ExecutionDuration = Convert.ToInt32(stopwatch.Elapsed.TotalMilliseconds);
auditLog.Actions.Add(auditLogAction);
}
}
/// <summary>
/// 拦截
/// </summary>
/// <param name="invocation"></param>
/// <returns></returns>
public override async Task InterceptAsync(IMethodInvocation invocation)
{
using var serviceScope = _serviceScopeFactory.CreateScope();
var auditingHelper = serviceScope.ServiceProvider.GetRequiredService <IAuditingFactory>();
var auditingOptions = serviceScope.ServiceProvider.GetRequiredService <IOptions <AuditingOptions> >().Value;
if (!ShouldIntercept(invocation, auditingOptions, auditingHelper))
{
await invocation.ProceedAsync();
return;
}
var auditingManager = serviceScope.ServiceProvider.GetRequiredService <IAuditingManager>();
if (auditingManager.Current != null)
{
await ProceedByLoggingAsync(invocation, auditingHelper, auditingManager.Current);
}
else
{
var currentUser = serviceScope.ServiceProvider.GetRequiredService <ICurrentUser>();
await ProcessWithNewAuditingScopeAsync(invocation, auditingOptions, currentUser, auditingManager, auditingHelper);
}
}
public override async Task InterceptAsync(IMethodInvocation invocation)
{
// 将被调用的方法传入，验证是否允许访问。
await AuthorizeAsync(invocation);
await invocation.ProceedAsync();
}
/// <summary>
///
/// </summary>
/// <param name="invocation"></param>
/// <returns></returns>
public async Task InterceptAsync(IMethodInvocation invocation)
{
var options = CreateOptions();
if (invocation.Method.AttributeExists <DisableUnitOfWorkAttribute>())
{
options.Scope = System.Transactions.TransactionScopeOption.Suppress;
}
using (var uow = _unitOfWorkManager.Begin(options))
{
await invocation.ProceedAsync();
if (invocation.IsAsync())
{
await uow.CompleteAsync();
}
else
{
uow.Complete();
}
}
}
public Task InterceptAsync(IMethodInvocation invocation) => invocation.ProceedAsync();
public override async Task InterceptAsync(IMethodInvocation invocation)
{
await AuthorizeAsync(invocation);
await invocation.ProceedAsync();
}