/// <summary> /// Pres the save changes. /// </summary> /// <param name="dbContext">The database context.</param> /// <param name="state">The state.</param> public override void PreSaveChanges(Rock.Data.DbContext dbContext, System.Data.Entity.EntityState state) { if (state == System.Data.Entity.EntityState.Deleted) { // manually delete any grouprequirements of this group since it can't be cascade deleted var groupRequirementService = new GroupRequirementService(dbContext as RockContext); var groupRequirements = groupRequirementService.Queryable().Where(a => a.GroupId.HasValue && a.GroupId == this.Id).ToList(); if (groupRequirements.Any()) { groupRequirementService.DeleteRange(groupRequirements); } // manually set any attendance search group ids to null var attendanceService = new AttendanceService(dbContext as RockContext); foreach (var attendance in attendanceService.Queryable() .Where(a => a.SearchResultGroupId.HasValue && a.SearchResultGroupId.Value == this.Id)) { attendance.SearchResultGroupId = null; } } base.PreSaveChanges(dbContext, state); }
/// <summary> /// Method that will be called on an entity immediately before the item is saved by context /// </summary> /// <param name="dbContext">The database context.</param> /// <param name="state">The state.</param> public override void PreSaveChanges(Rock.Data.DbContext dbContext, System.Data.Entity.EntityState state) { if (_logEntries != null) { if (_logEntries.Any()) { if (dbContext is RockContext) { var workflowLogService = new WorkflowLogService((dbContext as RockContext)); foreach (var logEntry in _logEntries) { workflowLogService.Add(new WorkflowLog { LogDateTime = logEntry.LogDateTime, LogText = logEntry.LogText, WorkflowId = this.Id }); } _logEntries.Clear(); } } } // Set the workflow number if (state == System.Data.Entity.EntityState.Added) { int maxNumber = new WorkflowService(dbContext as RockContext) .Queryable().AsNoTracking() .Where(w => w.WorkflowTypeId == this.WorkflowTypeId) .Max(w => (int?)w.WorkflowIdNumber) ?? 0; this.WorkflowIdNumber = maxNumber + 1; } base.PreSaveChanges(dbContext, state); }
/// <summary> /// Updates any Cache Objects that are associated with this entity /// </summary> /// <param name="entityState">State of the entity.</param> /// <param name="dbContext">The database context.</param> public void UpdateCache(System.Data.Entity.EntityState entityState, Rock.Data.DbContext dbContext) { AttributeCache cacheAttribute = AttributeCache.Get(this.AttributeId, dbContext as RockContext); if (cacheAttribute == null) { return; } if (this.EntityId.HasValue && cacheAttribute.EntityTypeId.HasValue) { EntityTypeCache entityType = EntityTypeCache.Get(cacheAttribute.EntityTypeId.Value, dbContext as RockContext); if (entityType?.HasEntityCache() == true) { entityType.FlushCachedItem(this.EntityId.Value); } else if (cacheAttribute.EntityTypeId == EntityTypeCache.GetId <Rock.Model.Device>()) { Rock.CheckIn.KioskDevice.FlushItem(this.EntityId.Value); } } if ((!cacheAttribute.EntityTypeId.HasValue || cacheAttribute.EntityTypeId.Value == 0) && string.IsNullOrEmpty(cacheAttribute.EntityTypeQualifierColumn) && string.IsNullOrEmpty(cacheAttribute.EntityTypeQualifierValue)) { // Update GlobalAttributes if one of the values changed GlobalAttributesCache.Remove(); } }
/// <summary> /// Creates a new PmnTaskChangeLog item. /// </summary> /// <param name="task">The task to create the log item for.</param> /// <param name="objState">The current state of the object.</param> /// <param name="identity">The current identity.</param> /// <param name="db">The datacontext.</param> /// <returns></returns> public async Task <Audit.PmnTaskChangeLog> CreateLogItemAsync(PmnTask task, System.Data.Entity.EntityState objState, ApiIdentity identity, DataContext db) { Audit.PmnTaskChangeLog logItem = null; if (identity != null) { var orgUser = await db.Users.Where(u => u.ID == identity.ID).Select(u => new { u.UserName, u.Organization.Acronym }).FirstOrDefaultAsync(); logItem = new Audit.PmnTaskChangeLog { Description = string.Format("Task has been {0} by {1}.", objState, (orgUser.Acronym + @"\" + orgUser.UserName)), Reason = objState, UserID = identity == null ? Guid.Empty : identity.ID, TaskID = task.ID, Task = task }; } else { logItem = new Audit.PmnTaskChangeLog { Description = string.Format("Task has been {0} because {1}.", objState, (task.Subject)), Reason = objState, UserID = Guid.Empty, TaskID = task.ID, Task = task }; } return(logItem); }
/// <summary> /// Updates any Cache Objects that are associated with this entity /// </summary> /// <param name="entityState">State of the entity.</param> /// <param name="dbContext">The database context.</param> public void UpdateCache(System.Data.Entity.EntityState entityState, Rock.Data.DbContext dbContext) { BlockCache.UpdateCachedEntity(this.Id, entityState); var model = this; if (model.SiteId.HasValue && model.SiteId != originalSiteId) { PageCache.RemoveSiteBlocks(model.SiteId.Value); } else if (model.LayoutId.HasValue && model.LayoutId != originalLayoutId) { PageCache.RemoveLayoutBlocks(model.LayoutId.Value); } if (originalSiteId.HasValue) { PageCache.RemoveSiteBlocks(originalSiteId.Value); } else if (originalLayoutId.HasValue) { PageCache.RemoveLayoutBlocks(originalLayoutId.Value); } else if (originalPageId.HasValue) { var page = PageCache.Get(originalPageId.Value); page.RemoveBlocks(); } }
/// <summary> /// Prepare list of Audit Logs from data properties after modify only /// </summary> /// <param name="dbEntry"></param> /// <param name="userId"></param> /// <param name="changeTime"></param> /// <param name="tableName"></param> /// <param name="keyName"></param> /// <param name="StatusPropertyId"></param> /// <param name="state"></param> /// <returns></returns> public List <AuditEntity> ModifiedAuditFromDataProperties(DbEntityEntry dbEntry, long userId, DateTime changeTime, string tableName, string primaryKeyName, string isActivePropertyId, string isDeletedProperty, System.Data.Entity.EntityState state) { List <AuditEntity> auditTrailsList = new List <AuditEntity>(); //in case Modify entiry if (state == System.Data.Entity.EntityState.Modified) { // For Modified, add the changed record only , the current state of the entity , and the original var xml = GetModified(dbEntry, userId, changeTime, tableName, primaryKeyName, isActivePropertyId, isDeletedProperty); if (string.IsNullOrEmpty(xml)) { return(null); } auditTrailsList.Add(new AuditEntity() { UserId = userId, LogDate = changeTime, EventType = "Modify", TableName = tableName, RecordId = dbEntry.OriginalValues.GetValue <object>(primaryKeyName).ToString(), ChangeXml = xml, IsData = true }); } return(auditTrailsList); }
/// <summary> /// 注册一个新的对象到仓储上下文中 /// </summary> /// <typeparam name="TEntity"> 要注册的类型 </typeparam> public void RegisterNew <TEntity>(TEntity entity) where TEntity : class //EntityBase<TKey> { System.Data.Entity.EntityState state = Context.Entry(entity).State; if (state == System.Data.Entity.EntityState.Detached) { Context.Entry(entity).State = System.Data.Entity.EntityState.Added; } IsCommitted = false; }
/// <summary> /// 注册一个新的对象到仓储上下文中 /// </summary> /// <typeparam name="TEntity"> 要注册的类型 </typeparam> /// <typeparam name="TKey">实体主键类型</typeparam> /// <param name="entity"> 要注册的对象 </param> public void RegisterNew <TEntity, TKey>(TEntity entity) where TEntity : EntityBase <TKey> { EntityState state = Context.Entry(entity).State; if (state == EntityState.Detached) { Context.Entry(entity).State = EntityState.Added; } IsCommitted = false; }
public void ChangeState <TEntity>(TEntity entity, System.Data.Entity.EntityState requestedState) where TEntity : BaseEntity { var entry = this.Entry(entity); if (entry.State != requestedState) { // Only change state when requested state differs, // because EF internally sets all properties to modified // if necessary, even when requested state equals current state. entry.State = requestedState; } }
/// <summary> /// Pres the save. /// </summary> /// <param name="dbContext">The database context.</param> /// <param name="state">The state.</param> public override void PreSaveChanges(Data.DbContext dbContext, System.Data.Entity.EntityState state) { var channel = this.ContentChannel; if (state == System.Data.Entity.EntityState.Deleted) { ChildItems.Clear(); ParentItems.Clear(); } base.PreSaveChanges(dbContext, state); }
public void ChangeState <TEntity>(TEntity entity, EfState requestedState) where TEntity : BaseEntity { //Console.WriteLine("ChangeState ORIGINAL"); var entry = this.Entry(entity); if (entry.State != requestedState) { // Only change state when requested state differs, // because EF internally sets all properties to modified // if necessary, even when requested state equals current state. entry.State = requestedState; } }
/// <summary> /// Pres the save changes. /// </summary> /// <param name="dbContext">The database context.</param> /// <param name="state">The state.</param> public override void PreSaveChanges(Rock.Data.DbContext dbContext, System.Data.Entity.EntityState state) { if (state == System.Data.Entity.EntityState.Deleted) { // manually delete any grouprequirements of this group since it can't be cascade deleted var groupRequirementService = new GroupRequirementService(dbContext as RockContext); var groupRequirements = groupRequirementService.Queryable().Where(a => a.GroupId == this.Id).ToList(); if (groupRequirements.Any()) { groupRequirementService.DeleteRange(groupRequirements); } } }
/// <summary> /// Pres the save changes. /// </summary> /// <param name="dbContext">The database context.</param> /// <param name="state">The state.</param> public override void PreSaveChanges(Rock.Data.DbContext dbContext, System.Data.Entity.EntityState state) { if (ImageId.HasValue) { BinaryFileService binaryFileService = new BinaryFileService((RockContext)dbContext); var binaryFile = binaryFileService.Get(ImageId.Value); if (binaryFile != null && binaryFile.IsTemporary) { binaryFile.IsTemporary = false; } } base.PreSaveChanges(dbContext, state); }
/// <summary> /// Updates any Cache Objects that are associated with this entity /// </summary> /// <param name="entityState">State of the entity.</param> /// <param name="dbContext">The database context.</param> public void UpdateCache(System.Data.Entity.EntityState entityState, Rock.Data.DbContext dbContext) { var group = this.Group ?? new GroupService(new RockContext()).GetNoTracking(this.GroupId); if (group != null) { var groupType = GroupTypeCache.Get(group.GroupTypeId, (RockContext)dbContext); if (group.IsSecurityRole || groupType?.Guid == Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid()) { RoleCache.FlushItem(group.Id); Rock.Security.Authorization.Clear(); } } }
/// <summary> /// Updates any Cache Objects that are associated with this entity /// </summary> /// <param name="entityState">State of the entity.</param> /// <param name="dbContext">The database context.</param> public void UpdateCache(System.Data.Entity.EntityState entityState, Rock.Data.DbContext dbContext) { SiteCache.UpdateCachedEntity(this.Id, entityState); using (var rockContext = new RockContext()) { foreach (int pageId in new PageService(rockContext).GetBySiteId(this.Id) .Select(p => p.Id) .ToList()) { PageCache.UpdateCachedEntity(pageId, EntityState.Detached); } } }
/// <summary> /// Updates any Cache Objects that are associated with this entity /// </summary> /// <param name="entityState">State of the entity.</param> /// <param name="dbContext">The database context.</param> public void UpdateCache(System.Data.Entity.EntityState entityState, Rock.Data.DbContext dbContext) { // Make sure CampusCache.All is cached using the dbContext (to avoid deadlock if snapshot isolation is disabled) var campusId = this.GetCampusId(dbContext as RockContext); // CampusCache has a CampusLocation that could get stale when Location changes, so refresh the CampusCache for this location's Campus if (this.CampusId.HasValue) { CampusCache.UpdateCachedEntity(this.CampusId.Value, EntityState.Detached); } // and also refresh the CampusCache for any Campus that uses this location foreach (var campus in CampusCache.All(dbContext as RockContext).Where(c => c.LocationId == this.Id)) { CampusCache.UpdateCachedEntity(campus.Id, EntityState.Detached); } }
/// <summary> /// Updates any Cache Objects that are associated with this entity /// </summary> /// <param name="entityState">State of the entity.</param> /// <param name="dbContext">The database context.</param> public void UpdateCache(System.Data.Entity.EntityState entityState, Rock.Data.DbContext dbContext) { // If the group changed, and it was a security group, flush the security for the group Guid?originalGroupTypeGuid = null; Guid groupTypeScheduleRole = Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid(); if (_originalGroupTypeId.HasValue && _originalGroupTypeId != this.GroupTypeId) { originalGroupTypeGuid = GroupTypeCache.Get(_originalGroupTypeId.Value, (RockContext)dbContext)?.Guid; } var groupTypeGuid = GroupTypeCache.Get(this.GroupTypeId, (RockContext)dbContext)?.Guid; if (this.IsSecurityRole || (_originalIsSecurityRole == true) || (groupTypeGuid == groupTypeScheduleRole) || (originalGroupTypeGuid == groupTypeScheduleRole)) { RoleCache.FlushItem(this.Id); } }
/// <summary> /// Pres the save. /// </summary> /// <param name="dbContext">The database context.</param> /// <param name="state">The state.</param> public override void PreSaveChanges(Rock.Data.DbContext dbContext, System.Data.Entity.EntityState state) { if (state == System.Data.Entity.EntityState.Deleted) { ChildGroupTypes.Clear(); // manually delete any grouprequirements of this grouptype since it can't be cascade deleted var groupRequirementService = new GroupRequirementService(dbContext as RockContext); var groupRequirements = groupRequirementService.Queryable().Where(a => a.GroupTypeId.HasValue && a.GroupTypeId == this.Id).ToList(); if (groupRequirements.Any()) { groupRequirementService.DeleteRange(groupRequirements); } } // clean up the index if (state == System.Data.Entity.EntityState.Deleted && IsIndexEnabled) { this.DeleteIndexedDocumentsByGroupType(this.Id); } else if (state == System.Data.Entity.EntityState.Modified) { // check if indexing is enabled var changeEntry = dbContext.ChangeTracker.Entries <GroupType>().Where(a => a.Entity == this).FirstOrDefault(); if (changeEntry != null) { var originalIndexState = (bool)changeEntry.OriginalValues["IsIndexEnabled"]; if (originalIndexState == true && IsIndexEnabled == false) { // clear out index items this.DeleteIndexedDocumentsByGroupType(Id); } else if (IsIndexEnabled == true) { // if indexing is enabled then bulk index - needed as an attribute could have changed from IsIndexed BulkIndexDocumentsByGroupType(Id); } } } base.PreSaveChanges(dbContext, state); }
public virtual void Update(T entity) { if (entity == null) { throw (new System.ArgumentNullException("entity")); } // ************************************************** // Just For Debug! // ************************************************** System.Data.Entity.EntityState oEntityState = DatabaseContext.Entry(entity).State; // ************************************************** // /Just For Debug! // ************************************************** if (oEntityState == System.Data.Entity.EntityState.Detached) { DbSet.Attach(entity); } // ************************************************** // Just For Debug! // ************************************************** oEntityState = DatabaseContext.Entry(entity).State; // ************************************************** // /Just For Debug! // ************************************************** DatabaseContext.Entry(entity).State = System.Data.Entity.EntityState.Modified; // ************************************************** // Just For Debug! // ************************************************** oEntityState = DatabaseContext.Entry(entity).State; // ************************************************** // /Just For Debug! // ************************************************** }
/// <summary> /// Removes or invalidates the CachedItem based on EntityState /// </summary> /// <param name="entityId">The entity identifier.</param> /// <param name="entityState">State of the entity. If unknown, use <see cref="EntityState.Detached" /></param> public static void UpdateCachedEntity(int entityId, System.Data.Entity.EntityState entityState) { // NOTE: Don't read the Item into the Cache here since it could be part of a transaction that could be rolled back. // Reading it from the database here could also cause a deadlock depending on the database isolation level. // Just remove it from Cache, and update the AllIds based on entityState if (entityState == EntityState.Deleted) { Remove(entityId); } else if (entityState == EntityState.Added) { // add this entity to All Ids, but don't fetch it into cache until somebody asks for it AddToAllIds(entityId); } else { FlushItem(entityId); } }
public static Axerrio.Data.Entity.EntityState ConvertFromEFEntityState(this System.Data.Entity.EntityState state, Axerrio.Data.Entity.EntityState currentState) { switch (state) { case System.Data.Entity.EntityState.Unchanged: return(Axerrio.Data.Entity.EntityState.Unchanged); case System.Data.Entity.EntityState.Added: return(Axerrio.Data.Entity.EntityState.Added); case System.Data.Entity.EntityState.Modified: return(Axerrio.Data.Entity.EntityState.Modified); case System.Data.Entity.EntityState.Deleted: return(Axerrio.Data.Entity.EntityState.Deleted); default: return(currentState); } }
public DomainBuildResult Build(Hatfield.EnviroData.DataProfile.WQ.Models.WQProfileEntity entity, Hatfield.EnviroData.Core.ODM2Entities dbContext) { var data = (Hatfield.EnviroData.DataProfile.WQ.Models.Site)entity; Hatfield.EnviroData.Core.Site domain = null; System.Data.Entity.EntityState state = EntityState.Unchanged; if (data == null) { throw new NullReferenceException("System fail to build domain on null entity."); } if (data.Id > 0) { domain = dbContext.Sites.Where(x => x.SamplingFeatureID == data.Id).FirstOrDefault(); } //data has not change, return the data in the database if (!IsDataDirty(data, domain)) { return(new DomainBuildResult(true, domain, EntityState.Unchanged)); } //data is dirty if (domain == null) { domain = new Core.Site(); state = EntityState.Added; } else { state = EntityState.Modified; } domain.Latitude = data.Latitude.HasValue ? data.Latitude.Value : domain.Latitude; domain.Longitude = data.Longitude.HasValue ? data.Longitude.Value : domain.Longitude; domain.SamplingFeature.SamplingFeatureName = data.Name; var result = new DomainBuildResult(true, domain, state); return(result); }
/// <summary> /// Updates the specified model. /// </summary> /// <param name="model">The model.</param> public override void Update(Model.Entities.User model) { // Detach existing Entity User existingEntity = Context.Set <User>().Find(ObjectMapper.GetEntityIdentifier <Model.Entities.User>(model)); System.Data.Entity.EntityState existingState = Context.Entry <User>(existingEntity).State; if (existingState != System.Data.Entity.EntityState.Detached) { Context.Entry <User>(existingEntity).State = System.Data.Entity.EntityState.Detached; } User updatedEntity = UserEntityFactory.CreateFromDomainModel(model, ObjectMapper); DbEntityEntry entry = Context.Entry <User>(updatedEntity); if (entry.State == System.Data.Entity.EntityState.Detached) { //Context.Set<User>().Attach(updatedEntity); Context.Entry <User>(updatedEntity).State = System.Data.Entity.EntityState.Modified; Context.SaveChanges(); } }
/// <summary> /// Updates the specified model. /// </summary> /// <param name="model">The model.</param> public virtual void Update(TModel model) { // Detach existing Entity TContextEntity existingEntity = Context.Set <TContextEntity>().Find(ObjectMapper.GetEntityIdentifier <TModel>(model)); System.Data.Entity.EntityState existingState = Context.Entry <TContextEntity>(existingEntity).State; if (existingState != System.Data.Entity.EntityState.Detached) { Context.Entry <TContextEntity>(existingEntity).State = System.Data.Entity.EntityState.Detached; } TContextEntity updatedEntity = ObjectMapper.Map <TModel, TContextEntity>(model); DbEntityEntry entry = Context.Entry <TContextEntity>(updatedEntity); if (entry.State == System.Data.Entity.EntityState.Detached) { //Context.Set<TContextEntity>().Attach(updatedEntity); entry.State = System.Data.Entity.EntityState.Modified; Context.SaveChanges(); } }
static EntityState GetEntityState(System.Data.Entity.EntityState entityStates) { switch (entityStates) { case System.Data.Entity.EntityState.Added: return(EntityState.Added); case System.Data.Entity.EntityState.Deleted: return(EntityState.Deleted); case System.Data.Entity.EntityState.Detached: return(EntityState.Detached); case System.Data.Entity.EntityState.Modified: return(EntityState.Modified); case System.Data.Entity.EntityState.Unchanged: return(EntityState.Unchanged); default: throw new NotImplementedException(); } }
/// <summary> /// Updates the <see cref="EntityAttributesCache"/> based on the attribute and entityState /// </summary> /// <param name="attribute">The attribute.</param> /// <param name="entityState">State of the entity.</param> internal static void UpdateCacheEntityAttributes(Rock.Model.Attribute attribute, System.Data.Entity.EntityState entityState) { var entityAttributesList = EntityAttributesCache.Get().EntityAttributes.ToList(); if (entityAttributesList == null || attribute == null) { return; } bool listUpdated = false; if (entityState == EntityState.Deleted) { foreach (var entityAttributesItem in entityAttributesList.Where(a => a.AttributeIds.Contains(attribute.Id))) { entityAttributesItem.AttributeIds.Remove(attribute.Id); listUpdated = true; } } if (attribute?.EntityTypeId.HasValue == true) { if (entityState == EntityState.Modified) { foreach (var entityAttributesItem in entityAttributesList.Where(a => a.AttributeIds.Contains(attribute.Id))) { if (entityAttributesItem.EntityTypeId != attribute.EntityTypeId || entityAttributesItem.EntityTypeQualifierColumn != attribute.EntityTypeQualifierColumn || entityAttributesItem.EntityTypeQualifierValue != attribute.EntityTypeQualifierValue) { entityAttributesItem.AttributeIds.Remove(attribute.Id); listUpdated = true; } } } if (entityState == EntityState.Added || entityState == EntityState.Modified) { var entityTypeEntityAttributesList = entityAttributesList.Where(a => a.EntityTypeId == attribute.EntityTypeId.Value && a.EntityTypeQualifierColumn == attribute.EntityTypeQualifierColumn && a.EntityTypeQualifierValue == attribute.EntityTypeQualifierValue); if (entityTypeEntityAttributesList.Any()) { foreach (var entityAttributes in entityTypeEntityAttributesList) { if (!entityAttributes.AttributeIds.Contains(attribute.Id)) { entityAttributes.AttributeIds.Add(attribute.Id); listUpdated = true; } } } else { entityAttributesList.Add(new EntityAttributes() { EntityTypeId = attribute.EntityTypeId, EntityTypeQualifierColumn = attribute.EntityTypeQualifierColumn, EntityTypeQualifierValue = attribute.EntityTypeQualifierValue, AttributeIds = new List <int>(new int[] { attribute.Id }) }); listUpdated = true; } } } if (listUpdated) { var cache = EntityAttributesCache.Get(); cache.EntityAttributes = entityAttributesList; cache.EntityAttributesByEntityTypeId = entityAttributesList.Where(a => a.EntityTypeId.HasValue).GroupBy(g => g.EntityTypeId.Value).ToDictionary(k => k.Key, v => v.ToList() ?? new List <EntityAttributes>()); EntityAttributesCache.UpdateCacheItem(KEY, cache, TimeSpan.MaxValue); } }
/// <summary> /// Attach an entity to the context. If it's already loaded, return the loaded entity. /// </summary> /// <param name="entity"></param> /// <param name="entityState"></param> /// <returns></returns> private T Attach(T entity, System.Data.Entity.EntityState entityState) { if (entity == null) { return(null); } DbEntityEntry <T> entityEntry = context.Entry(entity); if (entityEntry.State == entityState) { return(entity); } if (entity != null && entityEntry.State == System.Data.Entity.EntityState.Detached) { if (entity is IEntity) { // Get the entity's Id and look for an already loaded instance in EntitySet.Local. If found, return the loaded entity. Guid id = ((IEntity)entity).Id; IEntity existing = EntitySet.Local.Cast <IEntity>().FirstOrDefault(p => p.Id == id); if (existing != null) { return(existing as T); } } } // EF makes attaching an object from another context very painful if that object contains other referenced entities. Attach() can throw an exception if // any of the referenced entities were previously loaded into the context. // The first step is capture the state of all tracked entites in the context by storing them in a dictionary (keyed by entity.Id) var stateDict = new Dictionary <Guid, System.Data.Entity.EntityState>(); foreach (var entry in context.ChangeTracker.Entries()) { if (entry.Entity is IEntity) { stateDict[((IEntity)entry.Entity).Id] = entry.State; } } // Then add the entity via the Add method. EntitySet.Add(entity); // Change the entity state to what we want it to be (Unmodified, or Modified) context.Entry(entity).State = entityState; // Finally check the state of all tracked entities, looking for ones that are in an Added State. foreach (var entry in context.ChangeTracker.Entries().Where(p => p.State == System.Data.Entity.EntityState.Added && p.Entity is IEntity)) { System.Data.Entity.EntityState state; if (stateDict.TryGetValue(((IEntity)entry.Entity).Id, out state)) { // If the entity was already being tracked and wasn't originally in the Added state, detach the entity. if (state != System.Data.Entity.EntityState.Added) { context.Entry(entry.Entity).State = System.Data.Entity.EntityState.Detached; } } else { // If the entity wasn't being tracked, make sure it's state is Unchanged. context.Entry(entry.Entity).State = System.Data.Entity.EntityState.Unchanged; } } return(entity); }
/// <summary> /// Prepare list of Audit Logs from data properties /// </summary> /// <param name="dbEntry"></param> /// <param name="userId"></param> /// <param name="changeTime"></param> /// <param name="tableName"></param> /// <param name="keyName"></param> /// <param name="StatusPropertyId"></param> /// <param name="state"></param> /// <returns></returns> public List <AuditEntity> AddAuditFromDataProperties(DbEntityEntry dbEntry, long userId, DateTime changeTime, string tableName, string primaryKeyName, string isActivePropertyId, string isDeletedProperty, System.Data.Entity.EntityState state) { List <AuditEntity> auditTrailsList = new List <AuditEntity>(); //in case add new Entiry if (state == EntityState.Added) { // For Inserts, just add the whole record , the current state of the entity var xml = GetCurrents(dbEntry, userId, changeTime, tableName, primaryKeyName, isActivePropertyId, isDeletedProperty); //if no changes for some reason just return , no need to save empty xml ; a fail safe if (string.IsNullOrEmpty(xml)) { return(null); } auditTrailsList.Add(new AuditEntity() { UserId = userId, LogDate = changeTime, EventType = "Add", TableName = tableName, RecordId = dbEntry.CurrentValues.GetValue <object>(primaryKeyName).ToString(), ChangeXml = xml, IsData = true }); } return(auditTrailsList); }
public void ChangeState <TEntity>(TEntity entity, System.Data.Entity.EntityState newState) where TEntity : BaseEntity { this.Entry(entity).State = newState; }
public void ChangeState <TEntity>(TEntity entity, System.Data.Entity.EntityState newState) where TEntity : BaseEntity { Console.WriteLine("ChangeState ORIGINAL"); this.Entry(entity).State = newState; }