private void AuditableEntity()
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity &&
(x.State == System.Data.Entity.EntityState.Added || x.State == System.Data.Entity.EntityState.Modified));
foreach (var entry in modifiedEntries)
{
IAuditableEntity auditableEntity = entry.Entity as IAuditableEntity;
IEntity <string> Entity = entry.Entity as IEntity <string>;
if (auditableEntity != null)
{
string identityName = Thread.CurrentPrincipal.Identity.Name;
DateTime now = DateTime.UtcNow;
if (entry.State == System.Data.Entity.EntityState.Added)
{
Entity.Id = Guid.NewGuid().ToString();
auditableEntity.CreatedBy = identityName;
auditableEntity.CreatedDate = now;
}
else
{
base.Entry(auditableEntity).Property(x => x.CreatedBy).IsModified = false;
base.Entry(auditableEntity).Property(x => x.CreatedDate).IsModified = false;
}
auditableEntity.UpdatedBy = identityName;
auditableEntity.UpdatedDate = now;
}
}
}
public override int SaveChanges()
{
var modifiedEntries = ChangeTracker.Entries().Where(x => x.Entity is IAuditableEntity &&
(x.State == EntityState.Added || x.State == EntityState.Modified));
try
{
foreach (var entry in modifiedEntries)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
DateTime now = DateTime.UtcNow;
if (entry.State == EntityState.Added)
{
entity.CreatedDate = now;
entity.Status = true;
}
else
{
base.Entry(entity).Property(x => x.CreatedDate).IsModified = false;
}
entity.UpdatedDate = now;
}
}
return(base.SaveChanges());
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
var validationErrors = dbEx.EntityValidationErrors;
var validationError = validationErrors.SelectMany(x => x.ValidationErrors).ToList();
throw dbEx;
}
}
public override int SaveChanges()
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity &&
(x.State == System.Data.Entity.EntityState.Added || x.State == System.Data.Entity.EntityState.Modified));
foreach (var entry in modifiedEntries)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
string identityName = Thread.CurrentPrincipal.Identity.Name;
DateTime now = DateTime.UtcNow;
if (entry.State == System.Data.Entity.EntityState.Added)
{
// entity.CreatedBy = identityName;
entity.CreatedDate = now;
}
else
{
// base.Entry(entity).Property(x => x.CreatedBy).IsModified = false;
base.Entry(entity).Property(x => x.CreatedDate).IsModified = false;
}
// entity.UpdatedBy = identityName;
entity.UpdatedDate = now;
}
}
return(base.SaveChanges());
}
protected void SetLastUpdated(IAuditableEntity entity, IEntityHeader user)
{
var date = DateTime.Now.ToJSONString();
entity.LastUpdatedBy = EntityHeader.Create(user.Id, user.Text);
entity.LastUpdatedDate = date;
}
public override int SaveChanges()
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity &&
(x.State == EntityState.Added || x.State == EntityState.Modified));
foreach (var entry in modifiedEntries)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
//TODO later for Web
string identityName = new WindowsPrincipal(WindowsIdentity.GetCurrent()).Identity.Name;
DateTime now = DateTime.UtcNow;
if (entry.State == EntityState.Added)
{
entity.CreatedBy = identityName;
entity.CreatedDate = now;
}
else
{
base.Entry(entity).Property(x => x.CreatedBy).IsModified = false;
base.Entry(entity).Property(x => x.CreatedDate).IsModified = false;
}
entity.UpdatedBy = identityName;
entity.UpdatedDate = now;
}
}
return(base.SaveChanges());
}
public override int SaveChanges()
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity &&
(x.State == System.Data.Entity.EntityState.Added || x.State == System.Data.Entity.EntityState.Modified));
foreach (var entry in modifiedEntries)
{
// IAuditableEntity
IAuditableEntity auditableEntity = entry.Entity as IAuditableEntity;
if (auditableEntity != null)
{
ProcAuditableEntity(entry, auditableEntity);
}
// ISaveEntity
ISaveEntity saveEntity = entry.Entity as ISaveEntity;
if (saveEntity != null)
{
ProcSaveEntity(saveEntity);
}
}
return(base.SaveChanges());
}
//DbSet<TEntity> Set<TEntity>() where TEntity : class;
//DbEntityEntry<TEntity> Entry<TEntity>(TEntity entity) where TEntity : class;
//int SaveChanges();
public override int SaveChanges()
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity &&
(x.State == EntityState.Added || x.State == EntityState.Modified));
var currentUsername = curuser;
// !string.IsNullOrEmpty(HttpContext.User?.Identity?.Name)
// ? HttpContext.Current.User.Identity.Name : "SYSTEM";
foreach (var entry in modifiedEntries)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
//string identityName = Thread.CurrentPrincipal.Identity.Name;
DateTime now = DateTime.Now;
if (entry.State == EntityState.Added)
{
entity.UserCreated = currentUsername;
entity.DateCreated = now;
}
else
{
base.Entry(entity).Property(x => x.UserCreated).IsModified = false;
base.Entry(entity).Property(x => x.DateCreated).IsModified = false;
}
entity.UserModified = currentUsername;
entity.DateModified = now;
}
}
return(base.SaveChanges());
}
private void SetAuditParams(IAuditableEntity entity)
{
entity.CreatedBy = EntityHeader.Create(Guid.NewGuid().ToId(), "dontcare");
entity.LastUpdatedBy = entity.CreatedBy;
entity.CreationDate = DateTime.Now.ToJSONString();
entity.LastUpdatedDate = entity.CreationDate;
}
public override int SaveChanges()
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity &&
(x.State == System.Data.Entity.EntityState.Added || x.State == System.Data.Entity.EntityState.Modified));
foreach (var entry in modifiedEntries)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
DateTime now = DateTime.UtcNow;
if (entry.State == System.Data.Entity.EntityState.Added)
{
//// TODO Set Created by and Updated By
entity.CreatedBy = 0;
entity.CreatedDate = now;
entity.IsActive = true;
}
else
{
base.Entry(entity).Property(x => x.CreatedBy).IsModified = false;
base.Entry(entity).Property(x => x.CreatedDate).IsModified = false;
base.Entry(entity).Property(x => x.IsActive).IsModified = false;
}
entity.UpdatedBy = 0;
entity.UpdatedDate = now;
}
}
return(base.SaveChanges());
}
private void SetPropertiesLog()
{
var modifiedEntries = _entities.ChangeTracker.Entries().Where(x => x.Entity is IAuditableEntity &&
(x.State == (EntityState)EntityState.Added || x.State == (EntityState)EntityState.Modified));
foreach (var entry in modifiedEntries)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
DateTime now = DateTime.UtcNow;
if (entry.State == EntityState.Added)
{
entity.IsActive = true;
entity.CreatedBy = UserName;
entity.CreatedDate = now;
}
else
{
_entities.Entry(entity).Property("CreatedBy").IsModified = false;
_entities.Entry(entity).Property("CreatedDate").IsModified = false;
entity.UpdatedBy = UserName;
entity.UpdatedDate = now;
}
}
}
}
public static void UpdateAuditableEntities <T>(this T dbContext) where T : DbContext, IHttpDbContext
{
IEnumerable <EntityEntry> modifiedEntries = dbContext.ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity &&
(x.State == EntityState.Added ||
x.State == EntityState.Modified));
DateTime now = DateTime.UtcNow;
foreach (EntityEntry entry in modifiedEntries)
{
IAuditableEntity entity = (IAuditableEntity)entry.Entity;
if (entry.State == EntityState.Added)
{
entity.CreatedDate = now;
entity.CreatedBy = dbContext.CurrentUserId;
}
else
{
dbContext.Entry(entity).Property(x => x.CreatedBy).IsModified = false;
dbContext.Entry(entity).Property(x => x.CreatedDate).IsModified = false;
}
entity.UpdatedDate = now;
entity.UpdatedBy = dbContext.CurrentUserId;
}
}
public override int SaveChanges()
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity && (x.State == EntityState.Added || x.State == EntityState.Modified));
foreach (var entry in modifiedEntries)
{
IAuditableEntity auditableEntity = entry.Entity as IAuditableEntity;
if (auditableEntity != null)
{
string userName = Thread.CurrentPrincipal.Identity.Name;
DateTime now = DateTime.UtcNow;
if (entry.State == EntityState.Added)
{
auditableEntity.CreatedAt = now;
auditableEntity.CreatedBy = userName;
}
else
{
base.Entry(auditableEntity).Property(e => e.CreatedAt).IsModified = false;
base.Entry(auditableEntity).Property(e => e.CreatedBy).IsModified = false;
}
auditableEntity.UpdatedAt = now;
auditableEntity.UpdatedBy = userName;
}
}
return(base.SaveChanges());
}
private void AuditEntity()
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity &&
(x.State == EntityState.Added || x.State == EntityState.Modified));
foreach (var entry in modifiedEntries)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
string identityName = Thread.CurrentPrincipal.Identity.Name;
var now = DateTime.UtcNow;
if (entry.State == EntityState.Added)
{
entity.CreatedBy = identityName;
entity.CreatedDate = now;
}
else
{
base.Entry(entity).Property(x => x.CreatedBy).IsModified = false;
base.Entry(entity).Property(x => x.CreatedDate).IsModified = false;
}
entity.UpdatedBy = identityName;
entity.UpdatedDate = now;
}
}
}
private void UpdateAuditEntities()
{
IEnumerable <EntityEntry> modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity && (x.State == EntityState.Added || x.State == EntityState.Modified));
foreach (EntityEntry entry in modifiedEntries)
{
IAuditableEntity entity = (IAuditableEntity)entry.Entity;
DateTime now = DateTime.UtcNow;
if (entry.State == EntityState.Added)
{
entity.CreatedDate = now;
entity.CreatedBy = CurrentUserId;
}
else
{
Entry(entity).Property(x => x.CreatedBy).IsModified = false;
Entry(entity).Property(x => x.CreatedDate).IsModified = false;
}
entity.UpdatedDate = now;
entity.UpdatedBy = CurrentUserId;
}
}
public override int SaveChanges()
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity &&
(x.State == Microsoft.EntityFrameworkCore.EntityState.Added || x.State == Microsoft.EntityFrameworkCore.EntityState.Modified));
foreach (var entry in modifiedEntries)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
string identityName = _curUser;
DateTime now = DateTime.UtcNow;
if (entry.State == Microsoft.EntityFrameworkCore.EntityState.Added)
{
entity.CreatedBy = identityName;
entity.CreatedDate = now;
}
else
{
base.Entry(entity).Property(x => x.CreatedBy).IsModified = false;
base.Entry(entity).Property(x => x.CreatedDate).IsModified = false;
}
entity.UpdatedBy = identityName;
entity.UpdatedDate = now;
}
}
return(base.SaveChanges());
}
protected void AddAuditProperties(IAuditableEntity entity, DateTime creationTimeStamp, EntityHeader org, EntityHeader user)
{
entity.CreationDate = creationTimeStamp.ToJSONString();
entity.LastUpdatedDate = creationTimeStamp.ToJSONString();
entity.CreatedBy = user;
entity.LastUpdatedBy = user;
}
public virtual Task <int> CommitAsync()
{
IEnumerable <DbEntityEntry> dbEntityEntries =
from x in base.ChangeTracker.Entries()
where (!(x.Entity is IAuditableEntity) ? false : (x.State == EntityState.Added ? true : x.State == EntityState.Modified))
select x;
foreach (DbEntityEntry dbEntityEntry in dbEntityEntries)
{
IAuditableEntity entity = dbEntityEntry.Entity as IAuditableEntity;
if (entity != null)
{
string name = Thread.CurrentPrincipal.Identity.Name;
DateTime utcNow = DateTime.UtcNow;
if (dbEntityEntry.State != EntityState.Added)
{
base.Entry <IAuditableEntity>(entity).Property <string>((IAuditableEntity x) => x.CreatedBy).IsModified = false;
base.Entry <IAuditableEntity>(entity).Property <DateTime>((IAuditableEntity x) => x.CreatedDate).IsModified = false;
}
else
{
entity.CreatedBy = name;
entity.CreatedDate = utcNow;
}
entity.UpdatedBy = name;
entity.UpdatedDate = new DateTime?(utcNow);
}
}
return(this.SaveChangesAsync());
}
public async Task <int> SaveChangesAsync()
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity &&
(x.State == EntityState.Added || x.State == EntityState.Modified));
foreach (var entry in modifiedEntries)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
string identityName = _principal?.Identity.Name ?? "system"; // Thread.CurrentPrincipal.Identity.Name;
DateTime now = DateTime.Now;
if (entry.State == EntityState.Added)
{
entity.CreatedBy = identityName;
entity.CreatedDate = now;
}
else
{
Entry(entity).Property(x => x.CreatedBy).IsModified = false;
Entry(entity).Property(x => x.CreatedDate).IsModified = false;
}
entity.UpdatedBy = identityName;
entity.UpdatedDate = now;
}
}
bool saveFailed;
do
{
saveFailed = false;
try
{
return(await base.SaveChangesAsync());
}
catch (DbUpdateConcurrencyException e)
{
saveFailed = true;
Console.WriteLine(e.Message);
return(-1001);
}
catch (DbUpdateException e)
{
Console.WriteLine(e.Message);
saveFailed = true;
return(-1002);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
saveFailed = true;
return(-1003);
}
} while (saveFailed);
}
public static void SaveEntity(IAuditableEntity entity)
{
entity.ModifiedBy = HttpContext.Current.User.Identity.Name;
if (String.IsNullOrEmpty(entity.CreatedBy)) //assume new
{
entity.CreatedBy = HttpContext.Current.User.Identity.Name;
}
Bll.SaveEntity(entity); //you might need to use generics
}
protected void SetAuditProperties(IAuditableEntity entity)
{
var createDate = DateTime.Now.ToJSONString();
entity.CreationDate = createDate;
entity.LastUpdatedDate = createDate;
entity.CreatedBy = UserEntityHeader;
entity.LastUpdatedBy = UserEntityHeader;
}
public static void SetLastUpdatedFields(this IAuditableEntity entity, IEntityHeader user)
{
entity.LastUpdatedDate = DateTime.Now.ToJSONString();
entity.LastUpdatedBy = new EntityHeader()
{
Id = user.Id,
Text = user.Text
};
}
protected void SetUpdatedProperties(IAuditableEntity entity)
{
if (entity == null)
{
throw new NullReferenceException("NULL Entity Passed to SetUpdatedProperties");
}
entity.LastUpdatedDate = DateTime.Now.ToJSONString();
entity.LastUpdatedBy = UserEntityHeader;
}
protected virtual void RefineCreateAudit(IAuditableEntity auditable, IUserIdentity identity)
{
auditable.CreationDate = Now;
var userName = identity.Name;
if (!string.IsNullOrWhiteSpace(userName))
{
auditable.CreatedBy = userName;
}
}
private void SetCreateInfo(object saveEntity, DateTime operateTime, int operateUserId, string opName)
{
IAuditableEntity iSaveEntity = saveEntity as IAuditableEntity;
if (iSaveEntity != null)
{
iSaveEntity.CreateAt = operateTime;
iSaveEntity.CreateBy = operateUserId;
iSaveEntity.LastModifyComment = opName;
}
}
private void SetUpdateInfo(object updateEntity, DateTime operateTime, int operateUserId, string opName)
{
IAuditableEntity iUpdateEntity = updateEntity as IAuditableEntity;
if (iUpdateEntity != null)
{
iUpdateEntity.LastModifyAt = operateTime;
iUpdateEntity.LastModifyBy = operateUserId;
iUpdateEntity.LastModifyComment = opName;
}
}
protected virtual void UpdateAuditableProperties()
{
var now = DateTime.Now;
int userId = -1;
//if (System.Web.HttpContext.Current != null && System.Web.HttpContext.Current.Session != null && System.Web.HttpContext.Current.Session["CurrentAccountID"] != null)
if (System.Web.HttpContext.Current != null && System.Web.HttpContext.Current.User != null && System.Web.HttpContext.Current.User.Identity != null)
{
int.TryParse(System.Web.HttpContext.Current.User.Identity.Name, out userId);
//userId = Convert.ToInt32(System.Web.HttpContext.Current.Session["CurrentAccountID"]);
//KMIH.Persistence.Security.IHCustomPrincipal iuser = System.Web.HttpContext.Current.User as KMIH.Persistence.Security.IHCustomPrincipal;
//if (iuser != null) userId = iuser.UserId;
}
//bool b = long.TryParse(Thread.CurrentPrincipal.Identity.Name, out userId);
var changedAuditableEntities = from entry in ChangeTracker.Entries <IAuditableEntity>()
let state = entry.State
where
state.HasFlag(EntityState.Added) ||
state.HasFlag(EntityState.Modified) ||
state.HasFlag(EntityState.Deleted)
select entry;
foreach (var entry in changedAuditableEntities)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
switch (entry.State)
{
case EntityState.Added:
entity.CreatedTime = now;
entity.CreatedBy = userId;
entity.ModifiedTime = now;
entity.ModifiedBy = userId;
entity.IsDeleted = false;
break;
case EntityState.Modified:
entity.ModifiedTime = now;
entity.ModifiedBy = userId;
//entity.IsDeleted = false;
break;
case EntityState.Deleted:
entry.State = EntityState.Modified;
entity.ModifiedTime = now;
entity.ModifiedBy = userId;
entity.IsDeleted = true;
break;
}
}
}
}
public override int SaveChanges()
{
try
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.Entity is IAuditableEntity &&
(x.State == System.Data.Entity.EntityState.Added || x.State == System.Data.Entity.EntityState.Modified));
foreach (var entry in modifiedEntries)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
string identityName = Thread.CurrentPrincipal.Identity.Name;
DateTime now = DateTime.UtcNow;
if (entry.State == System.Data.Entity.EntityState.Added)
{
entity.CreatedBy = identityName;
entity.CreatedDate = now;
}
else
{
base.Entry(entity).Property(x => x.CreatedBy).IsModified = false;
base.Entry(entity).Property(x => x.CreatedDate).IsModified = false;
}
entity.UpdatedBy = identityName;
entity.UpdatedDate = now;
}
}
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}",
validationErrors.Entry.Entity.ToString(),
validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
raise = new InvalidOperationException(message, raise);
}
}
throw raise;
}
return(base.SaveChanges());
}
protected virtual void Committing()
{
try
{
int userId = 0;
if (System.Web.HttpContext.Current != null)
{
var sessionUserId = System.Web.HttpContext.Current.Session["UserId"];
if (sessionUserId != null)
{
userId = (int)sessionUserId;
var modifiedEntries = this._repository.TrackedEntries
.Where(x => x.Entity is IAuditableEntity
&&
(x.State == System.Data.Entity.EntityState.Added ||
x.State == System.Data.Entity.EntityState.Modified
));
foreach (var entry in modifiedEntries)
{
IAuditableEntity entity = entry.Entity as IAuditableEntity;
if (entity != null)
{
DateTime now = DateTime.UtcNow;
if (entry.State == System.Data.Entity.EntityState.Added)
{
entity.CreatedBy = userId;
entity.CreationDate = now;
}
else
{
entity.ModifiedBy = userId;
entity.ModificationDate = now;
}
}
}
}
}
}
catch (Exception ex)
{
ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
log.Info(String.Format("Exception occured while updating history of IAuditableEntity {0}\n {1}",
typeof(T).Name, ex.ToString()));
}
}
protected void ConcurrencyCheck(IAuditableEntity fromRepo, string updatedDateStamp)
{
if (fromRepo.LastUpdatedDate != updatedDateStamp)
{
throw new ValidationException(ValidationResource.Concurrency_Error, new System.Collections.Generic.List <Core.Validation.ErrorMessage>()
{
new Core.Validation.ErrorMessage(
ValidationResource.Concurrency_ErrorMessage
.Replace(Tokens.VALIDATION_USER_FULL_NAME, fromRepo.LastUpdatedBy.Text)
.Replace(Tokens.VALIDATION_DATESTAMP, fromRepo.LastUpdatedDate),
false)
});
}
}
private void SetAuditFields(IAuditableEntity auditableEntity, string writeEvent)
{
if (auditableEntity == null) return;
switch (writeEvent)
{
case "Insert":
auditableEntity.CreateDate = DateTime.UtcNow;
break;
case "Update":
auditableEntity.EditDate = DateTime.UtcNow;
break;
}
}
public override Task <int> SaveChangesAsync(CancellationToken cancellationToken = default)
{
IEnumerable <EntityEntry> unsavedItems = ChangeTracker.Entries()
.Where(entity => entity.Entity is IAuditableEntity &&
(entity.State == EntityState.Added ||
entity.State == EntityState.Modified));
foreach (EntityEntry item in unsavedItems)
{
IAuditableEntity entity = (IAuditableEntity)item.Entity;
DateTime now = DateTime.Now;
entity.UpdatedDate = now;
}
return(base.SaveChangesAsync(cancellationToken));
}
