protected virtual void ApplyStudioXConceptsForDeletedEntity(EntityEntry entry, long?userId,
EntityChangeReport changeReport)
{
CancelDeletionForSoftDelete(entry);
SetDeletionAuditProperties(entry.Entity, userId);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Deleted));
}
public async Task TriggerChangedEventsAsync(EntityChangeReport changeReport)
{
foreach (var changedEntity in changeReport.ChangedEntities)
{
switch (changedEntity.ChangeType)
{
case EntityChangeType.Created:
await TriggerEntityCreatedEventAsync(changedEntity.Entity);
break;
case EntityChangeType.Updated:
await TriggerEntityUpdatedEventAsync(changedEntity.Entity);
break;
case EntityChangeType.Deleted:
await TriggerEntityDeletedEventAsync(changedEntity.Entity);
break;
default:
throw new ScorpioException("Unknown EntityChangeType: " + changedEntity.ChangeType);
}
}
foreach (var domainEvent in changeReport.DomainEvents)
{
await _eventBus.PublishAsync(domainEvent.EventData.GetType(), domainEvent.EventData);
}
}
protected virtual void AddDomainEvents(EntityChangeReport changeReport, object entityAsObj)
{
var generatesDomainEventsEntity = entityAsObj as IGeneratesDomainEvents;
if (generatesDomainEventsEntity == null)
{
return;
}
var localEvents = generatesDomainEventsEntity.GetLocalEvents()?.ToArray();
if (localEvents != null && localEvents.Any())
{
changeReport.DomainEvents.AddRange(localEvents.Select(eventData => new DomainEventEntry(entityAsObj, eventData)));
generatesDomainEventsEntity.ClearLocalEvents();
}
var distributedEvents = generatesDomainEventsEntity.GetDistributedEvents()?.ToArray();
if (distributedEvents != null && distributedEvents.Any())
{
changeReport.DistributedEvents.AddRange(distributedEvents.Select(eventData => new DomainEventEntry(entityAsObj, eventData)));
generatesDomainEventsEntity.ClearDistributedEvents();
}
}
protected virtual void ApplyXqConceptsForAddedEntity(EntityEntry entry, EntityChangeReport changeReport)
{
CheckAndSetId(entry);
SetConcurrencyStampIfNull(entry);
SetCreationAuditProperties(entry);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Created));
}
protected virtual void ApplyXqConceptsForDeletedEntity(EntityEntry entry, EntityChangeReport changeReport)
{
CancelDeletionForSoftDelete(entry);
UpdateConcurrencyStamp(entry);
SetDeletionAuditProperties(entry);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Deleted));
}
public async Task TriggerChangingEventsAsync(EntityChangeReport changeReport)
{
foreach (var changedEntity in changeReport.ChangedEntities)
{
switch (changedEntity.ChangeType)
{
case EntityChangeType.Created:
await TriggerEntityCreatingEventAsync(changedEntity.Entity);
break;
case EntityChangeType.Updated:
await TriggerEntityUpdatingEventAsync(changedEntity.Entity);
break;
case EntityChangeType.Deleted:
await TriggerEntityDeletingEventAsync(changedEntity.Entity);
break;
default:
throw new ScorpioException("Unknown EntityChangeType: " + changedEntity.ChangeType);
}
}
}
public void SaveLogs(EntityChangeReport entityChangeReport)
{
//LOGS
foreach (var entry in entityChangeReport.ChangedEntities)
{
//TODO: AZ implementar;
}
}
protected virtual void ApplyAbpConceptsForAddedEntity(DbEntityEntry entry, long?userId,
EntityChangeReport changeReport)
{
CheckAndSetId(entry.Entity);
CheckAndSetMustHaveTenantIdProperty(entry.Entity);
CheckAndSetMayHaveTenantIdProperty(entry.Entity);
SetCreationAuditProperties(entry.Entity, userId);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Created));
}
protected virtual EntityChangeReport ApplyAbpConcepts(IEnumerable <EntityEntry> entries)
{
var changeReport = new EntityChangeReport();
foreach (var entry in entries)
{
ApplyAbpConcepts(entry, changeReport);
}
return(changeReport);
}
void ReturnObject()
{
_fsql.Ado.MasterPool.Return(_conn);
_tran = null;
_conn = null;
#if ns20
Current.Value = null;
#endif
EntityChangeReport.Clear();
}
protected virtual EntityChangeReport ApplyXqConcepts()
{
var changeReport = new EntityChangeReport();
foreach (var entry in ChangeTracker.Entries().ToList())
{
ApplyXqConcepts(entry, changeReport);
}
return(changeReport);
}
protected virtual void ApplyAbpConceptsForModifiedEntity(EntityEntry entry, EntityChangeReport changeReport)
{
if (entry.Entity is ISoftDelete && entry.Entity.As <ISoftDelete>().IsDeleted)
{
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Deleted));
}
else
{
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Updated));
}
}
protected virtual EntityChangeReport ApplyAbpConcepts()
{
EntityChangeReport changeReport = new EntityChangeReport();
int?auditUserId = this.GetAuditUserId();
foreach (EntityEntry entry in this.ChangeTracker.Entries().ToList <EntityEntry>())
{
this.ApplyAbpConcepts(entry, auditUserId, changeReport);
}
return(changeReport);
}
public override async Task <int> SaveChangesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
EntityChangeReport entityChangeReport = this.ApplyAbpConcepts();
var result = await base.SaveChangesAsync(cancellationToken);
SaveLogs(entityChangeReport);
await base.SaveChangesAsync();
return(result);
}
public override int SaveChanges(bool acceptAllChangesOnSuccess)
{
EntityChangeReport entityChangeReport = this.ApplyAbpConcepts();
var result = base.SaveChanges(acceptAllChangesOnSuccess);
SaveLogs(entityChangeReport);
base.SaveChanges(acceptAllChangesOnSuccess);
return(result);
}
protected virtual EntityChangeReport ApplyAbpConcepts()
{
/* Implement other concepts from ABP v1.x */
var changeReport = new EntityChangeReport();
foreach (var entry in ChangeTracker.Entries().ToList())
{
ApplyAbpConcepts(entry, changeReport);
}
return(changeReport);
}
protected virtual void ApplyAbpConceptsForDeletedEntity(DbEntityEntry entry, long?userId,
EntityChangeReport changeReport)
{
if (IsHardDeleteEntity(entry))
{
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Deleted));
return;
}
CancelDeletionForSoftDelete(entry);
SetDeletionAuditProperties(entry.Entity, userId);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Deleted));
}
protected virtual EntityChangeReport ApplyStoveConcepts()
{
var changeReport = new EntityChangeReport();
long?userId = GetAuditUserId();
foreach (EntityEntry entry in ChangeTracker.Entries().ToList())
{
ApplyStoveConcepts(entry, userId, changeReport);
}
return(changeReport);
}
protected virtual EntityChangeReport ApplyCodeZeroConcepts()
{
var changeReport = new EntityChangeReport();
var userId = GetAuditUserId();
foreach (var entry in ChangeTracker.Entries().ToList())
{
ApplyCodeZeroConcepts(entry, userId, changeReport);
}
return(changeReport);
}
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);
}
}
protected virtual void ApplyStudioXConceptsForModifiedEntity(EntityEntry entry, long?userId,
EntityChangeReport changeReport)
{
SetModificationAuditProperties(entry.Entity, userId);
if (entry.Entity is ISoftDelete && entry.Entity.As <ISoftDelete>().IsDeleted)
{
SetDeletionAuditProperties(entry.Entity, userId);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Deleted));
}
else
{
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Updated));
}
}
protected virtual void ApplyXqConceptsForModifiedEntity(EntityEntry entry, EntityChangeReport changeReport)
{
UpdateConcurrencyStamp(entry);
SetModificationAuditProperties(entry);
if (entry.Entity is ISoftDelete && entry.Entity.As <ISoftDelete>().IsDeleted)
{
SetDeletionAuditProperties(entry);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Deleted));
}
else
{
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Updated));
}
}
public override int SaveChanges()
{
try
{
EntityChangeReport changedEntities = ApplyStoveConcepts();
int result = base.SaveChanges();
EntityChangeEventHelper.TriggerEvents(changedEntities);
return(result);
}
catch (DbEntityValidationException ex)
{
LogDbEntityValidationException(ex);
throw;
}
}
protected override EntityChangeReport ApplyAbpConcepts()
{
var changeReport = new EntityChangeReport();
var userId = GetAuditUserId();
var entries = ChangeTracker.Entries().ToList();
foreach (var entry in entries)
{
switch (entry.State)
{
case EntityState.Added:
CheckAndSetId(entry.Entity);
CheckAndSetMustHaveTenantIdProperty(entry.Entity);
CheckAndSetMayHaveTenantIdProperty(entry.Entity);
SetCreationAuditProperties(entry.Entity, userId);
CheckAndSetMustHaveOrganizeIdProperty(entry.Entity);
SetCreationAuditProperties(entry.Entity, SessionManager.UserId);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Created));
break;
case EntityState.Modified:
SetModificationAuditProperties(entry, userId);
SetModificationAuditProperties(entry, SessionManager.UserId);
if (entry.Entity is ISoftDelete && entry.Entity.As <ISoftDelete>().IsDeleted)
{
SetDeletionAuditProperties(entry.Entity, userId);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Deleted));
}
else
{
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Updated));
}
break;
case EntityState.Deleted:
CancelDeletionForSoftDelete(entry);
SetDeletionAuditProperties(entry.Entity, userId);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Deleted));
break;
}
}
return(changeReport);
}
protected override EntityChangeReport ApplyAbpConcepts()
{
var changeReport = new EntityChangeReport();
var userId = GetAuditUserId();
foreach (var entry in ChangeTracker.Entries().ToList())
{
if (entry.IsOwnedModifiedOrAdded())
{
Entry(entry.Entity).State = EntityState.Modified;
}
ApplyAbpConcepts(entry, userId, changeReport);
}
return(changeReport);
}
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 int SaveChanges()
{
try
{
EntityChangeReport entityChangeReport = this.ApplyAbpConcepts();
int num = base.SaveChanges();
//todo falta ver los eventos
//this.EntityChangeEventHelper.TriggerEvents(entityChangeReport);
return(num);
}
catch (DbUpdateConcurrencyException ex)
{
throw new DBConcurrencyException(ex.Message, (Exception)ex);
}
}
protected virtual EntityChangeReport ApplyAbpConcepts()
{
var changeReport = new EntityChangeReport();
var userId = this.GetAuditUserId();
var entries = this.ChangeTracker.Entries().ToList();
foreach (var entry in entries)
{
switch (entry.State)
{
case EntityState.Added:
this.CheckAndSetId(entry.Entity);
this.CheckAndSetMustHaveTenantIdProperty(entry.Entity);
this.CheckAndSetMayHaveTenantIdProperty(entry.Entity);
this.SetCreationAuditProperties(entry.Entity, userId);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Created));
break;
case EntityState.Modified:
this.SetModificationAuditProperties(entry, userId);
if (entry.Entity is ISoftDelete && entry.Entity.As <ISoftDelete>().IsDeleted)
{
this.SetDeletionAuditProperties(entry.Entity, userId);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Deleted));
}
else
{
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Updated));
}
break;
case EntityState.Deleted:
this.CancelDeletionForSoftDelete(entry);
this.SetDeletionAuditProperties(entry.Entity, userId);
changeReport.ChangedEntities.Add(new EntityChangeEntry(entry.Entity, EntityChangeType.Deleted));
break;
}
this.AddDomainEvents(changeReport.DomainEvents, entry.Entity);
}
return(changeReport);
}
public override async Task <int> SaveChangesAsync(CancellationToken cancellationToken)
{
try
{
EntityChangeReport changeReport = ApplyStoveConcepts();
int result = await base.SaveChangesAsync(cancellationToken);
await EntityChangeEventHelper.TriggerEventsAsync(changeReport);
return(result);
}
catch (DbEntityValidationException ex)
{
LogDbEntityValidationException(ex);
throw;
}
}
protected virtual void ApplyXqConcepts(EntityEntry entry, EntityChangeReport changeReport)
{
switch (entry.State)
{
case EntityState.Added:
ApplyXqConceptsForAddedEntity(entry, changeReport);
break;
case EntityState.Modified:
ApplyXqConceptsForModifiedEntity(entry, changeReport);
break;
case EntityState.Deleted:
ApplyXqConceptsForDeletedEntity(entry, changeReport);
break;
}
AddDomainEvents(changeReport, entry.Entity);
}
