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; } }