public override InterceptionResult <int> SavingChanges(DbContextEventData eventData, InterceptionResult <int> result)
{
var changesList = new List <CompareModel>();
foreach (var entry in
eventData.Context.ChangeTracker.Entries <Post>())
{
if (entry.State == EntityState.Added)
{
changesList.Add(new CompareModel()
{
OriginalValue = null,
NewValue = entry.CurrentValues.ToObject(),
});
}
else if (entry.State == EntityState.Deleted)
{
changesList.Add(new CompareModel()
{
OriginalValue = entry.OriginalValues.ToObject(),
NewValue = null,
});
}
else if (entry.State == EntityState.Modified)
{
changesList.Add(new CompareModel()
{
OriginalValue = entry.OriginalValues.ToObject(),
NewValue = entry.CurrentValues.ToObject(),
});
}
Console.WriteLine($"change list:{changesList.ToJson()}");
}
return(base.SavingChanges(eventData, result));
}
private void SetDataCreatedAndUpdated(DbContextEventData eventData)
{
Func <EntityEntry, bool> where = where =>
(where.State == EntityState.Added || where.State == EntityState.Modified) &&
where.Entity.GetType().GetInterfaces().Contains(typeof(IModified));
IOrderedEnumerable <EntityEntry> entityEntries = eventData
.Context
.ChangeTracker
.Entries()
.Where(where)
.OrderBy(w => w.State);
if (entityEntries.Count() > 0)
{
DateTime now = DateTime.Now;
foreach (var entity in entityEntries)
{
if (entity.State == EntityState.Added)
{
entity.Property("CreatedAt").CurrentValue = now;
entity.Property("UpdatedAt").CurrentValue = now;
}
else if (entity.State == EntityState.Modified)
{
entity.Property("UpdatedAt").CurrentValue = now;
}
}
}
}
public override InterceptionResult <int> SavingChanges(DbContextEventData eventData, InterceptionResult <int> result)
{
IContextWithEventOutbox contextWithEventOutbox = GuardCast(eventData);
if (contextWithEventOutbox.SaveEventsOnSaveChanges)
{
var events = GetEvents(eventData.Context);
if (events.Any())
{
int intResult = 0;
using (var transaction = new TransactionScope(new CommittableTransaction(new TransactionOptions()
{
IsolationLevel = IsolationLevel.ReadCommitted
})))
{
intResult = eventData.Context.SaveChanges();
// ReSharper disable once MethodHasAsyncOverloadWithCancellation
contextWithEventOutbox.EventOutbox.AddRange(events);
eventData.Context.SaveChanges();
transaction.Complete();
}
OnEventsAdded(events.Select(x => x.Id.ToString()));
return(InterceptionResult <int> .SuppressWithResult(intResult));
}
}
return(new InterceptionResult <int>());
}
public InterceptionResult <int> SavingChanges(DbContextEventData eventData, InterceptionResult <int> result)
{
//be careful ,this will risks a deadlock.
//when save data in aspnet core ,shuold use DbContext.SaveChangesAsync().
SavingChangesAsync(eventData, result).GetAwaiter().GetResult();
return(result);
}
private void NullableStampUsers(DbContextEventData @event)
{
var entitiesBeingCreated = @event.Context.ChangeTracker.Entries <IUserStamped <long?> >()
.Where(p => p.State == EntityState.Added)
.Select(p => p.Entity);
foreach (var entityBeingCreated in entitiesBeingCreated)
{
if (entityBeingCreated.CreatedById.HasValue == false && _currentUser.IsAuthenticated)
{
entityBeingCreated.CreatedById = _currentUser.Id;
}
if (entityBeingCreated.UpdatedById.HasValue == false && _currentUser.IsAuthenticated)
{
entityBeingCreated.UpdatedById = _currentUser.Id;
}
}
var entitiesBeingUpdated = @event.Context.ChangeTracker.Entries <IUserStamped <long?> >()
.Where(p => p.State == EntityState.Modified)
.Select(p => p.Entity);
foreach (var entityBeingUpdated in entitiesBeingUpdated)
{
entityBeingUpdated.UpdatedById = _currentUser.IsAuthenticated
?_currentUser.Id
: null;
}
}
public override ValueTask <InterceptionResult <int> > SavingChangesAsync(DbContextEventData eventData,
InterceptionResult <int> result,
CancellationToken cancellationToken = new CancellationToken())
{
InvokeInterceptorServices(eventData.Context);
return(ValueTask.FromResult(result));
}
public override async ValueTask <InterceptionResult <int> > SavingChangesAsync(
DbContextEventData eventData, InterceptionResult <int> result, CancellationToken cancellationToken = default)
{
await base.SavingChangesAsync(eventData, result, cancellationToken);
return(InterceptionResult <int> .SuppressWithResult(-1));
}
public override ValueTask <InterceptionResult <int> > SavingChangesAsync(
DbContextEventData @event,
InterceptionResult <int> result,
CancellationToken cancellationToken = default)
{
var entitiesBeingCreated = @event.Context.ChangeTracker.Entries <ITimeStamped>()
.Where(p => p.State == EntityState.Added)
.Select(p => p.Entity);
foreach (var entityBeingCreated in entitiesBeingCreated)
{
if (entityBeingCreated.CreatedAt == default)
{
entityBeingCreated.CreatedAt = DateTime.Now;
}
if (entityBeingCreated.UpdatedAt == default)
{
entityBeingCreated.UpdatedAt = DateTime.Now;
}
}
var entitiesBeingUpdated = @event.Context.ChangeTracker.Entries <ITimeStamped>()
.Where(p => p.State == EntityState.Modified)
.Select(p => p.Entity);
foreach (var entityBeingUpdated in entitiesBeingUpdated)
{
entityBeingUpdated.UpdatedAt = DateTime.Now;
}
return(new ValueTask <InterceptionResult <int> >(result));
}
private void EnlistTriggerSession(DbContextEventData eventData)
{
#if DEBUG
if (_triggerSession != null)
{
Debug.Assert(_capturedDbContext == eventData.Context);
}
else
{
_capturedDbContext = eventData.Context;
}
#endif
if (_triggerSession == null)
{
var triggerService = eventData.Context.GetService <ITriggerService>() ?? throw new InvalidOperationException("Triggers are not configured");
if (triggerService.Current != null)
{
_triggerSession = triggerService.Current;
}
else
{
_triggerSession = triggerService.CreateSession(eventData.Context);
}
}
_parallelSaveChangesCount += 1;
}
private void StampUsers(DbContextEventData @event)
{
var entitiesBeingCreated = @event.Context.ChangeTracker.Entries <IUserStamped>()
.Where(p => p.State == EntityState.Added)
.Select(p => p.Entity);
foreach (var entityBeingCreated in entitiesBeingCreated)
{
if (entityBeingCreated.CreatedById == default)
{
entityBeingCreated.CreatedById = _currentUser.Id;
}
if (entityBeingCreated.UpdatedById == default)
{
entityBeingCreated.UpdatedById = _currentUser.Id;
}
}
var entitiesBeingUpdated = @event.Context.ChangeTracker.Entries <IUserStamped>()
.Where(p => p.State == EntityState.Modified)
.Select(p => p.Entity);
foreach (var entityBeingUpdated in entitiesBeingUpdated)
{
entityBeingUpdated.UpdatedById = _currentUser.Id;
}
}
public InterceptionResult <int> SavingChanges(DbContextEventData eventData, InterceptionResult <int> result)
{
if (!(eventData.Context is TriggeredDbContext))
{
EnlistTriggerSession(eventData);
Debug.Assert(_triggerSession != null);
var defaultAutoDetectChangesEnabled = eventData.Context.ChangeTracker.AutoDetectChangesEnabled;
try
{
eventData.Context.ChangeTracker.AutoDetectChangesEnabled = false;
_triggerSession.RaiseBeforeSaveStartingTriggers().GetAwaiter().GetResult();
_triggerSession.RaiseBeforeSaveTriggers().GetAwaiter().GetResult();
_triggerSession.CaptureDiscoveredChanges();
_triggerSession.RaiseBeforeSaveCompletedTriggers().GetAwaiter().GetResult();
}
finally
{
eventData.Context.ChangeTracker.AutoDetectChangesEnabled = defaultAutoDetectChangesEnabled;
}
return(result);
}
return(result);
}
public override InterceptionResult <int> SavingChanges(DbContextEventData eventData, InterceptionResult <int> result)
{
_auditContext = new DefaultAuditContext(eventData.Context);
_helper.SetConfig(_auditContext);
_auditScope = _helper.BeginSaveChanges(_auditContext);
return(base.SavingChanges(eventData, result));
}
public async ValueTask <InterceptionResult <int> > SavingChangesAsync(DbContextEventData eventData, InterceptionResult <int> result, CancellationToken cancellationToken = default)
{
if (!(eventData.Context is TriggeredDbContext))
{
EnlistTriggerSession(eventData);
Debug.Assert(_triggerSession != null);
var defaultAutoDetectChangesEnabled = eventData.Context.ChangeTracker.AutoDetectChangesEnabled;
try
{
eventData.Context.ChangeTracker.AutoDetectChangesEnabled = false;
await _triggerSession.RaiseBeforeSaveStartingTriggers(cancellationToken).ConfigureAwait(false);
await _triggerSession.RaiseBeforeSaveTriggers(cancellationToken).ConfigureAwait(false);
_triggerSession.CaptureDiscoveredChanges();
await _triggerSession.RaiseBeforeSaveCompletedTriggers(cancellationToken).ConfigureAwait(false);
}
finally
{
eventData.Context.ChangeTracker.AutoDetectChangesEnabled = defaultAutoDetectChangesEnabled;
}
}
return(result);
}
public void SaveChangesCanceled(DbContextEventData eventData)
{
for (var i = 0; i < _interceptors.Length; i++)
{
_interceptors[i].SaveChangesCanceled(eventData);
}
}
public override InterceptionResult <int> SavingChanges(DbContextEventData eventData,
InterceptionResult <int> result)
{
ApplayAudits(eventData.Context.ChangeTracker);
return(base.SavingChanges(eventData, result));
}
public override InterceptionResult <int> SavingChanges(DbContextEventData eventData,
InterceptionResult <int> result)
{
WriteDates(eventData.Context.ChangeTracker);
return(result);
}
public override ValueTask <InterceptionResult <int> > SavingChangesAsync(
DbContextEventData eventData,
InterceptionResult <int> result,
CancellationToken cancellationToken = new CancellationToken())
{
SetDataCreatedAndUpdated(eventData);
return(new ValueTask <InterceptionResult <int> >(result));
}
public override ValueTask <InterceptionResult <int> > SavingChangesAsync(DbContextEventData eventData,
InterceptionResult <int> result,
CancellationToken cancellationToken = default)
{
Console.WriteLine($"Started saving changes.");
return(new ValueTask <InterceptionResult <int> >(result));
}
public override InterceptionResult <int> SavingChanges(
DbContextEventData eventData,
InterceptionResult <int> result
)
{
SoftDelete(eventData);
return(result);
}
public override InterceptionResult <int> SavingChanges(
DbContextEventData eventData,
InterceptionResult <int> result)
{
Console.WriteLine($"Saving changes for {eventData.Context.Database.GetConnectionString()}");
return(result);
}
public virtual void SaveChangesCanceled(DbContextEventData eventData)
{
Assert.NotNull(eventData.Context);
Context = eventData.Context;
CanceledCalled = true;
SyncCalled = true;
}
public async ValueTask <InterceptionResult <int> > SavingChangesAsync(DbContextEventData eventData,
InterceptionResult <int> result,
CancellationToken cancellationToken = new CancellationToken())
{
await PublishDomainEventsAsync(eventData.Context);
return(result);
}
/// <summary>
/// 拦截保存数据库之前
/// </summary>
/// <param name="eventData"></param>
/// <param name="result"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public override ValueTask <InterceptionResult <int> > SavingChangesAsync(DbContextEventData eventData, InterceptionResult <int> result, CancellationToken cancellationToken = default)
{
dynamic dbContext = eventData.Context;
dbContext.SavingChangesEventInner(eventData, result);
return(base.SavingChangesAsync(eventData, result, cancellationToken));
}
/// <summary>
/// 拦截保存数据库之前
/// </summary>
/// <param name="eventData"></param>
/// <param name="result"></param>
/// <returns></returns>
public override InterceptionResult <int> SavingChanges(DbContextEventData eventData, InterceptionResult <int> result)
{
dynamic dbContext = eventData.Context;
dbContext.SavingChangesEventInner(eventData, result);
return(base.SavingChanges(eventData, result));
}
public AuditableEntityInterceptorTests(ApplicationDbContextFixture dbFixture)
{
Context = dbFixture.Context;
_fixture = new Fixture()
.Customize(new AutoMoqCustomization());
_fixture.Register <DbContext>(() => Context);
_eventData = _fixture.Create <DbContextEventData>();
}
public override ValueTask <InterceptionResult <int> > SavingChangesAsync(DbContextEventData eventData,
InterceptionResult <int> result,
CancellationToken cancellationToken = default)
{
ApplayAudits(eventData.Context.ChangeTracker);
return(base.SavingChangesAsync(eventData, result, cancellationToken));
}
public async Task SaveChangesCanceledAsync(
DbContextEventData eventData,
CancellationToken cancellationToken = default)
{
for (var i = 0; i < _interceptors.Length; i++)
{
await _interceptors[i].SaveChangesCanceledAsync(eventData, cancellationToken).ConfigureAwait(false);
}
}
public InterceptionResult <int> SavingChanges(DbContextEventData eventData, InterceptionResult <int> result)
{
for (var i = 0; i < _interceptors.Length; i++)
{
result = _interceptors[i].SavingChanges(eventData, result);
}
return(result);
}
public override async ValueTask <InterceptionResult <int> > SavingChangesAsync(
DbContextEventData eventData,
InterceptionResult <int> result,
CancellationToken cancellationToken = new CancellationToken())
{
await DispatchDomainEventsAsync(eventData.Context.ChangeTracker);
return(result);
}
public override ValueTask <InterceptionResult <int> > SavingChangesAsync(
DbContextEventData eventData,
InterceptionResult <int> result,
CancellationToken cancellationToken = new CancellationToken())
{
Console.WriteLine($"Saving changes asynchronously for {eventData.Context.Database.GetConnectionString()}");
return(new ValueTask <InterceptionResult <int> >(result));
}
