public override async Task <int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default)
{
try {
var auditLog = AuditingManager?.Current?.Log;
List <EntityChangeInfo> entityChangeList = null;
if (auditLog != null)
{
entityChangeList = EntityHistoryHelper.CreateChangeList(ChangeTracker.Entries().ToList());
}
var changeReport = ApplyRocketConcepts();
var result = await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
await EntityChangeEventHelper.TriggerEventsAsync(changeReport);
if (auditLog != null)
{
EntityHistoryHelper.UpdateChangeList(entityChangeList);
auditLog.EntityChanges.AddRange(entityChangeList);
Logger.LogDebug($"Added {entityChangeList.Count} entity changes to the current audit log");
}
return(result);
} catch (DbUpdateConcurrencyException ex) {
throw new RocketDbConcurrencyException(ex.Message, ex);
} finally {
ChangeTracker.AutoDetectChangesEnabled = true;
}
}
public override void Delete(TEntity entity)
{
ActionFilterExecuter.ExecuteDeletionAuditFilter <TEntity, string>(entity);
EntityChangeEventHelper.TriggerEntityDeletingEvent(entity);
if (entity is ISoftDelete)
{
Session.Bucket.Upsert(new Document <TEntity>
{
Content = entity,
Id = $"{typeof(TEntity).Name}:{entity.Id}"
}).EnsureSuccess();
}
else
{
Session.Bucket.Remove(new Document <TEntity>
{
Content = entity,
Id = $"{typeof(TEntity).Name}:{entity.Id}"
}).EnsureSuccess();
}
EntityChangeEventHelper.TriggerEntityDeletedEventOnUowCompleted(entity);
}
public override void Update(TEntity entity)
{
EntityChangeEventHelper.TriggerEntityUpdatingEvent(entity);
DapperActionFilterExecuter.ExecuteModificationAuditFilter <TEntity, TPrimaryKey>(entity);
Connection.Update(entity, ActiveTransaction);
EntityChangeEventHelper.TriggerEntityUpdatedEventOnUowCompleted(entity);
}
/// <summary>
/// Insert and get entity（this method for mysql only Support identityPrimaryKey int or long ）
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public override TEntity InsertAndGetEntity(TEntity entity)
{
EntityChangeEventHelper.TriggerEntityCreatingEvent(entity);
if ((DbType == DataType.SqlServer) || (DbType == DataType.PostgreSQL))
{
entity = DataBase.Insert(entity)
.WithConnection(Connection)
.WithTransaction(transaction: ActiveTransaction)
.ExecuteInserted().First();
}
else
{
var identityid = DataBase.Insert(entity)
.WithConnection(Connection)
.WithTransaction(transaction: ActiveTransaction)
.ExecuteIdentity();
try
{
entity.Id = Convert.ToInt32((dynamic)identityid);
}
catch (Exception)
{
throw new NotSupportedException("for mysql only Support int or long type PrimaryKey");
}
}
EntityChangeEventHelper.TriggerEntityCreatedEventOnUowCompleted(entity);
return(entity);
}
public override void Update(TEntity entity)
{
EntityChangeEventHelper.TriggerEntityUpdatingEvent(entity);
DataBase.Update <TEntity>().WithConnection(Connection)
.WithTransaction(transaction: ActiveTransaction)
.SetSource(entity).ExecuteAffrows();
EntityChangeEventHelper.TriggerEntityUpdatedEventOnUowCompleted(entity);
}
/// <summary>
/// Inserts the specified entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public override TEntity Insert(TEntity entity)
{
EntityChangeEventHelper.PublishEntityCreatingEvent(entity);
RavenActionFilterExecuter.ExecuteCreationAuditFilter <TEntity, TPrimaryKey>(entity);
Session.Store(entity);
EntityChangeEventHelper.PublishEntityCreatedEventOnUowCompleted(entity);
return(entity);
}
public override int SaveChanges()
{
var changeReport = ApplyAbpConcepts();
var result = base.SaveChanges();
EntityChangeEventHelper.TriggerEvents(changeReport);
return(result);
}
/// <summary>
/// Updates the specified entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public override TEntity Update(TEntity entity)
{
EntityChangeEventHelper.TriggerEntityUpdatingEvent(entity);
RavenActionFilterExecuter.ExecuteModificationAuditFilter <TEntity, TPrimaryKey>(entity);
Session.Store(entity);
EntityChangeEventHelper.TriggerEntityUpdatedEventOnUowCompleted(entity);
return(entity);
}
public override TPrimaryKey InsertAndGetId(TEntity entity)
{
EntityChangeEventHelper.TriggerEntityCreatingEvent(entity);
DapperActionFilterExecuter.ExecuteCreationAuditFilter <TEntity, TPrimaryKey>(entity);
TPrimaryKey primaryKey = Connection.Insert(entity, ActiveTransaction);
EntityChangeEventHelper.TriggerEntityCreatedEventOnUowCompleted(entity);
return(primaryKey);
}
public override async Task <int> SaveChangesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
var changeReport = ApplyAbpConcepts();
var result = await base.SaveChangesAsync(cancellationToken);
await EntityChangeEventHelper.TriggerEventsAsync(changeReport);
return(result);
}
public override void OnDelete(object entity, object id, object[] state, string[] propertyNames, IType[] types)
{
EntityChangeEventHelper.TriggerEntityDeletingEvent(entity);
EntityChangeEventHelper.TriggerEntityDeletedEventOnUowCompleted(entity);
TriggerDomainEvents(entity);
EntityHistoryHelper?.AddEntityChange(entity);
base.OnDelete(entity, id, state, propertyNames, types);
}
public override void Delete(TEntity entity)
{
EntityChangeEventHelper.TriggerEntityDeletingEvent(entity);
if (entity is ISoftDelete)
{
Update(entity);
}
else
{
DataBase.Delete <TEntity>(entity).WithConnection(Connection).WithTransaction(transaction: ActiveTransaction).ExecuteAffrows();
}
EntityChangeEventHelper.TriggerEntityDeletedEventOnUowCompleted(entity);
}
public override int SaveChanges()
{
try
{
EntityChangeReport changeReport = ApplyStoveConcepts();
int result = base.SaveChanges();
EntityChangeEventHelper.TriggerEvents(changeReport);
return(result);
}
catch (DbUpdateConcurrencyException ex)
{
throw new StoveDbConcurrencyException(ex.Message, ex);
}
}
public override void Delete(TEntity entity)
{
EntityChangeEventHelper.TriggerEntityDeletingEvent(entity);
if (entity is ISoftDelete)
{
DapperActionFilterExecuter.ExecuteDeletionAuditFilter <TEntity, TPrimaryKey>(entity);
Connection.Update(entity, ActiveTransaction);
}
else
{
Connection.Delete(entity, ActiveTransaction);
}
EntityChangeEventHelper.TriggerEntityDeletedEventOnUowCompleted(entity);
}
/// <summary>
/// Deletes the specified entity.
/// </summary>
/// <param name="entity">The entity.</param>
public override void Delete(TEntity entity)
{
EntityChangeEventHelper.TriggerEntityDeletingEvent(entity);
if (entity is ISoftDelete)
{
RavenActionFilterExecuter.ExecuteDeletionAuditFilter <TEntity, TPrimaryKey>(entity);
Session.Store(entity);
}
else
{
Session.Delete(entity);
}
EntityChangeEventHelper.TriggerEntityDeletedEventOnUowCompleted(entity);
}
public override int SaveChanges()
{
try
{
var changedEntities = ApplyCodeZeroConcepts();
var result = base.SaveChanges();
EntityChangeEventHelper.TriggerEvents(changedEntities);
return(result);
}
catch (DbEntityValidationException ex)
{
LogDbEntityValidationException(ex);
throw;
}
}
public override int SaveChanges()
{
try
{
EntityChangeReport changedEntities = ApplyStoveConcepts();
int result = base.SaveChanges();
EntityChangeEventHelper.PublishEvents(changedEntities);
return(result);
}
catch (DbEntityValidationException ex)
{
LogDbEntityValidationException(ex);
throw;
}
}
public override TEntity UpdateAndGetEntity(TEntity entity)
{
if (DbType == DataType.MySql)
{
throw new NotSupportedException("Mysql Not Support UpdateAndGetEntity");
}
else
{
EntityChangeEventHelper.TriggerEntityUpdatingEvent(entity);
var updated = DataBase.Update <TEntity>().WithConnection(Connection)
.WithTransaction(transaction: ActiveTransaction)
.SetSource(entity).ExecuteUpdated();
EntityChangeEventHelper.TriggerEntityUpdatedEventOnUowCompleted(entity);
return(updated.FirstOrDefault());
}
}
public override async Task <int> SaveChangesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
try
{
EntityChangeReport changeReport = ApplyStoveConcepts();
int result = await base.SaveChangesAsync(cancellationToken);
await EntityChangeEventHelper.TriggerEventsAsync(changeReport, cancellationToken);
return(result);
}
catch (DbUpdateConcurrencyException ex)
{
throw new StoveDbConcurrencyException(ex.Message, ex);
}
}
public override async Task <int> SaveChangesAsync(CancellationToken cancellationToken)
{
try
{
var changeReport = ApplyCodeZeroConcepts();
var result = await base.SaveChangesAsync(cancellationToken);
await EntityChangeEventHelper.TriggerEventsAsync(changeReport);
return(result);
}
catch (DbEntityValidationException ex)
{
LogDbEntityValidationException(ex);
throw;
}
}
public override async Task <int> SaveChangesAsync(CancellationToken cancellationToken)
{
try
{
EntityChangeReport changeReport = ApplyStoveConcepts();
int result = await base.SaveChangesAsync(cancellationToken);
await EntityChangeEventHelper.PublishEventsAsync(changeReport, cancellationToken);
return(result);
}
catch (DbEntityValidationException ex)
{
LogDbEntityValidationException(ex);
throw;
}
}
protected virtual void ApplyAbpConcepts()
{
var userId = GetAuditUserId();
var entries = ChangeTracker.Entries().ToList();
foreach (var entry in entries)
{
switch (entry.State)
{
case EntityState.Added:
CheckAndSetId(entry);
CheckAndSetMustHaveTenantIdProperty(entry.Entity);
CheckAndSetMayHaveTenantIdProperty(entry.Entity);
SetCreationAuditProperties(entry.Entity, userId);
EntityChangeEventHelper.TriggerEntityCreatingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityCreatedEventOnUowCompleted(entry.Entity);
break;
case EntityState.Modified:
SetModificationAuditProperties(entry, userId);
if (entry.Entity is ISoftDelete && entry.Entity.As <ISoftDelete>().IsDeleted)
{
SetDeletionAuditProperties(entry.Entity, userId);
EntityChangeEventHelper.TriggerEntityDeletingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityDeletedEventOnUowCompleted(entry.Entity);
}
else
{
EntityChangeEventHelper.TriggerEntityUpdatingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityUpdatedEventOnUowCompleted(entry.Entity);
}
break;
case EntityState.Deleted:
CancelDeletionForSoftDelete(entry);
SetDeletionAuditProperties(entry.Entity, userId);
EntityChangeEventHelper.TriggerEntityDeletingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityDeletedEventOnUowCompleted(entry.Entity);
break;
}
TriggerDomainEvents(entry.Entity);
}
}
protected virtual void ApplyAbpConcepts()
{
foreach (var entry in ChangeTracker.Entries())
{
switch (entry.State)
{
case EntityState.Added:
SetCreationAuditProperties(entry);
CheckAndSetTenantIdProperty(entry);
EntityChangeEventHelper.TriggerEntityCreatingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityCreatedEventOnUowCompleted(entry.Entity);
break;
case EntityState.Modified:
PreventSettingCreationAuditProperties(entry);
CheckAndSetTenantIdProperty(entry);
SetModificationAuditProperties(entry);
if (entry.Entity is ISoftDelete && entry.Entity.As <ISoftDelete>().IsDeleted)
{
if (entry.Entity is IDeletionAudited)
{
SetDeletionAuditProperties(entry.Entity.As <IDeletionAudited>());
}
EntityChangeEventHelper.TriggerEntityDeletingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityDeletedEventOnUowCompleted(entry.Entity);
}
else
{
EntityChangeEventHelper.TriggerEntityUpdatingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityUpdatedEventOnUowCompleted(entry.Entity);
}
break;
case EntityState.Deleted:
PreventSettingCreationAuditProperties(entry);
HandleSoftDelete(entry);
EntityChangeEventHelper.TriggerEntityDeletingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityDeletedEventOnUowCompleted(entry.Entity);
break;
}
}
}
public override TEntity Update(TEntity entity)
{
ActionFilterExecuter.ExecuteModificationAuditFilter <TEntity, string>(entity);
EntityChangeEventHelper.TriggerEntityUpdatingEvent(entity);
IDocumentResult <TEntity> result = Session.Bucket.Upsert(new Document <TEntity>
{
Content = entity,
Id = $"{typeof(TEntity).Name}:{entity.Id}"
});
result.EnsureSuccess();
EntityChangeEventHelper.TriggerEntityUpdatedEventOnUowCompleted(entity);
return(result.Content);
}
public override bool OnSave(object entity, object id, object[] state, string[] propertyNames, IType[] types)
{
//Set Id for Guids
if (entity is IEntity <Guid> )
{
var guidEntity = entity as IEntity <Guid>;
if (guidEntity.IsTransient())
{
guidEntity.Id = _guidGenerator.Value.Create();
}
}
//Set CreationTime for new entity
if (entity is IHasCreationTime)
{
for (var i = 0; i < propertyNames.Length; i++)
{
if (propertyNames[i] == "CreationTime")
{
state[i] = (entity as IHasCreationTime).CreationTime = Clock.Now;
}
}
}
//Set CreatorUserId for new entity
if (entity is ICreationAudited && _abpSession.Value.UserId.HasValue)
{
for (var i = 0; i < propertyNames.Length; i++)
{
if (propertyNames[i] == "CreatorUserId")
{
state[i] = (entity as ICreationAudited).CreatorUserId = _abpSession.Value.UserId;
}
}
}
EntityChangeEventHelper.TriggerEntityCreatingEvent(entity);
EntityChangeEventHelper.TriggerEntityCreatedEventOnUowCompleted(entity);
TriggerDomainEvents(entity);
EntityHistoryHelper?.AddEntityChange(entity);
return(base.OnSave(entity, id, state, propertyNames, types));
}
public override TEntity Insert(TEntity entity)
{
entity.Id = GuidGenerator.Create().ToString("N");
ActionFilterExecuter.ExecuteCreationAuditFilter <TEntity, string>(entity);
EntityChangeEventHelper.TriggerEntityCreatingEvent(entity);
IDocumentResult <TEntity> result = Session.Bucket.Insert(new Document <TEntity>
{
Content = entity,
Id = $"{typeof(TEntity).Name}:{entity.Id}"
});
result.EnsureSuccess();
EntityChangeEventHelper.TriggerEntityCreatedEventOnUowCompleted(entity);
return(result.Content);
}
public override int SaveChanges(bool acceptAllChangesOnSuccess)
{
//TODO: Reduce duplications with SaveChangesAsync
//TODO: Instead of adding entity changes to audit log, write them to uow and add to audit log only if uow succeed
ChangeTracker.DetectChanges();
try
{
ChangeTracker.AutoDetectChangesEnabled = false; //TODO: Why this is needed?
var auditLog = AuditingManager?.Current?.Log;
List <EntityChangeInfo> entityChangeList = null;
if (auditLog != null)
{
entityChangeList = EntityHistoryHelper.CreateChangeList(ChangeTracker.Entries().ToList());
}
var changeReport = ApplyAbpConcepts();
var result = base.SaveChanges(acceptAllChangesOnSuccess);
AsyncHelper.RunSync(() => EntityChangeEventHelper.TriggerEventsAsync(changeReport));
if (auditLog != null)
{
EntityHistoryHelper.UpdateChangeList(entityChangeList);
auditLog.EntityChanges.AddRange(entityChangeList);
}
return(result);
}
catch (DbUpdateConcurrencyException ex)
{
throw new AbpDbConcurrencyException(ex.Message, ex);
}
finally
{
ChangeTracker.AutoDetectChangesEnabled = true;
}
}
public override int SaveChanges(bool acceptAllChangesOnSuccess)
{
ChangeTracker.DetectChanges();
try
{
ChangeTracker.AutoDetectChangesEnabled = false; //TODO: Why this is needed?
var changeReport = ApplyAbpConcepts();
var result = base.SaveChanges(acceptAllChangesOnSuccess);
AsyncHelper.RunSync(() => EntityChangeEventHelper.TriggerEventsAsync(changeReport));
return(result);
}
catch (DbUpdateConcurrencyException ex)
{
throw new AbpDbConcurrencyException(ex.Message, ex);
}
finally
{
ChangeTracker.AutoDetectChangesEnabled = true;
}
}
protected virtual void ApplyAbpConcepts()
{
var entries = ChangeTracker.Entries().ToList();
foreach (var entry in entries)
{
switch (entry.State)
{
case EntityState.Added:
EntityChangeEventHelper.TriggerEntityCreatingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityCreatedEventOnUowCompleted(entry.Entity);
break;
case EntityState.Modified:
SetModificationAuditProperties(entry);
if (entry.Entity is ISoftDelete && (entry.Entity as ISoftDelete).IsDeleted)
{
SetDeletionAuditProperties(entry.Entity);
EntityChangeEventHelper.TriggerEntityDeletingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityDeletedEventOnUowCompleted(entry.Entity);
}
else
{
EntityChangeEventHelper.TriggerEntityUpdatingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityUpdatedEventOnUowCompleted(entry.Entity);
}
break;
case EntityState.Deleted:
CancelDeletionForSoftDelete(entry);
SetDeletionAuditProperties(entry.Entity);
EntityChangeEventHelper.TriggerEntityDeletingEvent(entry.Entity);
EntityChangeEventHelper.TriggerEntityDeletedEventOnUowCompleted(entry.Entity);
break;
}
}
}
public override async Task <int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default)
{
ChangeTracker.DetectChanges();
try
{
ChangeTracker.AutoDetectChangesEnabled = false; //TODO: Why this is needed?
var changeReport = ApplyAbpConcepts();
var result = await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
await EntityChangeEventHelper.TriggerEventsAsync(changeReport);
return(result);
}
catch (DbUpdateConcurrencyException ex)
{
throw new AbpDbConcurrencyException(ex.Message, ex);
}
finally
{
ChangeTracker.AutoDetectChangesEnabled = true;
}
}
