private void check(IValuePair actual, EntityState state, object oldValue, object newValue, string propertyName)
{
Assert.AreEqual(state, actual.State);
Assert.AreEqual(oldValue, actual.OriginalValue());
Assert.AreEqual(newValue, actual.NewValue());
Assert.AreEqual(propertyName, actual.PropertyName);
}
/// <summary>
/// Saves the current entity.
/// </summary>
/// <param name="db">The db context</param>
/// <param name="state">The current entity state</param>
public override void OnSave(DataContext db, System.Data.EntityState state)
{
var user = HttpContext.Current.User;
// We never connect comments to drafts.
ParentIsDraft = false;
if (state == EntityState.Added)
{
if (Id == Guid.Empty)
{
Id = Guid.NewGuid();
}
Created = Updated = DateTime.Now;
if (user.Identity.IsAuthenticated || db.Identity != Guid.Empty)
{
CreatedById = UpdatedById = db.Identity != Guid.Empty ? db.Identity : new Guid(user.Identity.Name);
}
}
else if (state == EntityState.Modified)
{
Updated = DateTime.Now;
if (user.Identity.IsAuthenticated || db.Identity != Guid.Empty)
{
UpdatedById = db.Identity != Guid.Empty ? db.Identity : new Guid(user.Identity.Name);
}
}
base.OnSave(db, state);
}
/// <summary>
/// Saves the current user.
/// </summary>
/// <param name="db">The db context</param>
/// <param name="state">The entity state</param>
public override void OnSave(DataContext db, System.Data.EntityState state)
{
var user = HttpContext.Current != null ? HttpContext.Current.User : null;
if (db.Identity != Guid.Empty || user.Identity.IsAuthenticated)
{
if (state == EntityState.Added)
{
if (Id == Guid.Empty)
{
Id = Guid.NewGuid();
}
Created = Updated = DateTime.Now;
CreatedById = UpdatedById = db.Identity != Guid.Empty ? db.Identity : new Guid(user.Identity.Name);
}
else if (state == EntityState.Modified)
{
Updated = DateTime.Now;
UpdatedById = db.Identity != Guid.Empty ? db.Identity : new Guid(user.Identity.Name);
}
}
else
{
throw new UnauthorizedAccessException("User must be logged in to save entity");
}
}
/// <summary>
/// Returns all <see cref="DbEntityEntry"/> from <paramref name="context"/> with specified <see cref="EntityState"/>
/// (all changed by default).</summary>
/// <remarks> We can use <see cref="ObjectStateEntry"/>, if needed (with <see cref="IObjectContextAdapter"/>.
/// But we should touch <see cref="DbChangeTracker.Entries()"/> anyway (due to EF implementation).</remarks>
public static DbEntityEntry[] GetDbStateEntries(this DbContext context,
EntityState state = EntityState.Added | EntityState.Modified | EntityState.Deleted)
{
if (context == null) return new DbEntityEntry[0];
// returns array to avoid parallel calls problems
return context.ChangeTracker.Entries().Where(x => (x.State & state) != 0).ToArray();
}
public RelationshipChange(EntityKey sourceKey, EntityKey targetKey, object source, object target, EntitySetBase entitySet, EntityState state)
{
_sourceKey = sourceKey;
_targetKey = targetKey;
_source = source;
_target = target;
_entitySet = entitySet;
_state = state;
}
public void AttachUpdatedObject(System.Data.Objects.DataClasses.IEntityWithKey obj, EntityState objState = EntityState.Modified)
{
ObjectStateEntry state;
bool exist = this.ObjectStateManager.TryGetObjectStateEntry(obj, out state);
if (!exist || state == null || state.State == EntityState.Detached)
{
this.Attach(obj);
this.ObjectStateManager.ChangeObjectState(obj, objState);
}
}
private void AddModifiedEntities(IEnumerable<DbEntityEntry> changes, EntityState? entityState = null)
{
foreach (var entry in changes)
{
ChangeEntity changesEntity = GetChangeEntity(entry, entityState ?? entry.State);
if (changesEntity != null)
{
_changeSet.ChangeEntities.Add(changesEntity);
}
}
}
/// <summary>
/// Executes after the changes.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="item">The item.</param>
/// <param name="state">The state.</param>
private void After(ObjectContext context, DbEntityEntry item, EntityState state)
{
var now = DateTime.UtcNow;
string entitySetName;
var keys = state == EntityState.Deleted ? this.GetEntityKeyDeleted(item, out entitySetName) : this.GetEntityKeyUpdated(context, item, state, out entitySetName);
if (keys != null)
{
var activityLog = this.StateEntry2OperationLog(entitySetName, item.GetType().Name, now, keys, state);
this._logContext.Add(activityLog);
}
}
private ChangeEntity GetChangeEntity(DbEntityEntry entry, EntityState entityState)
{
if (!((BaseEntity)entry.Entity).IsTrackChanges)
return null;
List<ChangeField> changeFields = new List<ChangeField>();
List<string> modifiedProperties;
if (entityState == EntityState.Added || entityState == EntityState.Modified)
modifiedProperties = entry.CurrentValues.PropertyNames.ToList();
else if (entityState == EntityState.Deleted)
modifiedProperties = entry.OriginalValues.PropertyNames.ToList();
else
throw new NotSupportedException(entityState.ToString());
foreach (var modifiedPropertyName in modifiedProperties)
{
string newValue = null;
string oldValue = null;
if (entityState != EntityState.Deleted)
newValue = String.Format("{0}", entry.CurrentValues[modifiedPropertyName]);
if (entityState != EntityState.Added)
oldValue = String.Format("{0}", entry.OriginalValues[modifiedPropertyName]);
if (newValue != oldValue)
{
ChangeField changeField = new ChangeField();
changeField.NewValue = newValue;
changeField.OldValue = oldValue;
changeField.FieldName = modifiedPropertyName;
changeFields.Add(changeField);
}
}
if (changeFields.Count != 0)
{
var changeEntity = new ChangeEntity()
{
EntityName = GetEntityName(entry.Entity),
ChangeActionId = CreateChangeEntity(entityState),
KeyValue = ((BaseEntity)entry.Entity).Id,
ChangeFields = new List<ChangeField>()
};
foreach (var changeField in changeFields)
changeEntity.ChangeFields.Add(changeField);
return changeEntity;
}
else
{
return null;
}
}
private EntityEventArgs CreateArgs(DbEntityEntry item, EntityState state)
{
PropertyValues originalValues = null;
PropertyValues currentValues = null;
if (state == EntityState.Modified && !(item.State == EntityState.Detached))
{
originalValues = new PropertyValues(item.OriginalValues);
currentValues = new PropertyValues(item.CurrentValues);
}
var args = new EntityEventArgs(state, originalValues, currentValues);
return args;
}
/// <summary>
/// Attaches an untracked entity to an entity set and marks it as modified.
/// Note: child elements need to be manually added.
/// </summary>
/// <param name="entity"></param>
/// <param name="entitySet"></param>
/// <param name="markAsModified"></param>
/// <param name="addNew"></param>
/// <returns></returns>
public object Attach(object entity, bool addNew = false, System.Data.EntityState entityState = System.Data.EntityState.Modified)
{
var dbSet = Context.Set(entity.GetType());
if (addNew)
{
dbSet.Add(entity);
}
else
{
dbSet.Attach(entity);
GetEntityEntry(entity).State = entityState;
}
return(entity);
}
private static IEnumerable<Tuple<object, object>> GetRelationships(
this DbContext context,
EntityState relationshipState,
Func<ObjectStateEntry, int, object> getValue)
{
context.ChangeTracker.DetectChanges();
var objectContext = ((IObjectContextAdapter)context).ObjectContext;
return objectContext.ObjectStateManager
.GetObjectStateEntries(relationshipState)
.Where(e => e.IsRelationship)
.Select(
e => Tuple.Create(
objectContext.GetObjectByKey((EntityKey)getValue(e, 0)),
objectContext.GetObjectByKey((EntityKey)getValue(e, 1))));
}
private DbObjectState ToDbObjectState(EntityState state)
{
switch (state)
{
case EntityState.Unchanged:
return DbObjectState.Unchanged;
case EntityState.Added:
return DbObjectState.Added;
case EntityState.Modified:
return DbObjectState.Modified;
case EntityState.Deleted:
return DbObjectState.Deleted;
default:
return DbObjectState.Unchanged;
}
}
internal void AddChangedField(string fieldName,object fieldValue)
{
if (this._EntityState == EntityState.Deleted)
{
throw new NotSupportedException("删除状态的对象不能做操作！");
}
if (_OriginalEntityState == EntityState.UnChange) //说明是从datareader里面读取出来后修改的
{
if (_OriginalData.ContainsKey(fieldName))
{
//如果相同则将该字段移除 ，不相同添加进ChangedFields
if (_OriginalData[fieldName]!=null&&_OriginalData[fieldName].Equals(fieldValue))
{
_ChangedFields.Remove(fieldName);
if (_ChangedFields.Count == 0)
{
_EntityState = EntityState.UnChange;
}
}
else
{
_EntityState = EntityState.Modified;
if (!_ChangedFields.Contains(fieldName))
{
_ChangedFields.Add(fieldName);
}
}
}
}
else if (_OriginalEntityState == EntityState.New)//只有New的时候才会去修改_OriginalData
{
if (_OriginalData.ContainsKey(fieldName))
{
_OriginalData[fieldName] = fieldValue;
}
else
{
_OriginalData.Add(fieldName, fieldValue);
}
}
else
{
throw new NotSupportedException(_OriginalEntityState + " 是未知的EntityState");
}
}
private static IEnumerable<Tuple<string, string, object, string, object, object>> GetSavedValues(ObjectContext context, EntityState state
, Func<ObjectStateEntry, IEnumerable<Tuple<string, object, object>>> getValues)
{
return context
.ObjectStateManager
.GetObjectStateEntries(state)
.SelectMany(
e =>
{
string entityname = e.EntitySet.Name;
object id = null;
if (e.EntityKey != null && e.EntityKey.EntityKeyValues != null)
id = e.EntityKey.EntityKeyValues.Select(k => k.Value).FirstOrDefault();
return getValues(e).Select(t => Tuple.Create(state.ToString(), entityname, id, t.Item1, t.Item2, t.Item3));
}
);
}
private static void DoTest(
EntityState state,
bool isPostSave,
Expression<Action<IInterceptor<IAuditedEntity>>> expression = null)
{
// Arrange
var entityEntry = new Mock<IEntityEntry>();
entityEntry.SetupGet(x => x.Entity).Returns(new Book { Id = 123 });
entityEntry.SetupGet(x => x.State).Returns(state);
var interceptor = new Mock<IInterceptor<IAuditedEntity>>(MockBehavior.Strict);
if (expression != null) interceptor.Setup(expression);
// Act
new MockInterceptor<IAuditedEntity>(interceptor.Object).Intercept(entityEntry.Object, isPostSave);
// Assert
interceptor.VerifyAll();
}
// Recursively get entity states
public static IEnumerable<EntityState> GetEntityStates(this DbContext context,
ITrackable item, EntityState? entityState = null,
ObjectVisitationHelper visitationHelper = null)
{
// Prevent endless recursion
ObjectVisitationHelper.EnsureCreated(ref visitationHelper);
if (!visitationHelper.TryVisit(item)) yield break;
foreach (var colProp in item.GetNavigationProperties().OfCollectionType())
{
foreach (ITrackable child in colProp.EntityCollection)
{
foreach (var state in context.GetEntityStates(child, visitationHelper: visitationHelper))
{
if (entityState == null || state == entityState)
yield return state;
}
}
}
yield return context.Entry(item).State;
}
public static ObjectState ConvertState(EntityState state)
{
switch (state)
{
case EntityState.Detached:
return ObjectState.Unchanged;
case EntityState.Unchanged:
return ObjectState.Unchanged;
case EntityState.Added:
return ObjectState.Added;
case EntityState.Deleted:
return ObjectState.Deleted;
case EntityState.Modified:
return ObjectState.Modified;
default:
throw new ArgumentOutOfRangeException("state");
}
}
/// <summary>
/// Saves the current entity.
/// </summary>
/// <param name="db">The db context</param>
/// <param name="state">The current entity state</param>
public override void OnSave(DataContext db, System.Data.EntityState state)
{
if (db.Identity != Guid.Empty || Application.Current.UserProvider.IsAuthenticated || AllowAnonymous)
{
if (state == EntityState.Added)
{
if (Id == Guid.Empty)
{
Id = Guid.NewGuid();
}
Created = Updated = DateTime.Now;
CreatedById = UpdatedById = db.Identity != Guid.Empty ? db.Identity : Application.Current.UserProvider.UserId;
}
else if (state == EntityState.Modified)
{
Updated = DateTime.Now;
UpdatedById = db.Identity != Guid.Empty ? db.Identity : Application.Current.UserProvider.UserId;
}
}
else
{
throw new UnauthorizedAccessException("User must be logged in to save entity");
}
}
private void After(DbEntityEntry item, EntityState state)
{
if (this.IsTargetEntity(item))
this.OnAfter(item, state);
}
/// <summary>
/// 1、恢复实体为默认状态。
/// 2、标记实体为不做任何数据库操作（仅对.Save()有效果）
/// </summary>
public void DeAttach()
{
this.isAttached = false;
this.entityState = EntityState.Unchanged;
}
/// <summary>
/// 将实体置为指定状态
/// </summary>
public void Attach(EntityState entityState)
{
this.entityState = entityState;
}
public HookEntityMetadata(EntityState state)
{
_state = state;
}
private void Current_collection_value_can_be_read_and_set(EntityState state)
{
using (var context = new F1Context())
{
var engineEntry = context.Entry(GetTeamEntry(context).Entity.Engine);
engineEntry.State = state;
var collectionEntry = engineEntry.Collection(t => t.Gearboxes);
var value = collectionEntry.CurrentValue;
Assert.Same(engineEntry.Entity.Gearboxes, value);
value = new List<Gearbox>();
collectionEntry.CurrentValue = value;
Assert.Same(engineEntry.Entity.Gearboxes, value);
context.ChangeTracker.DetectChanges();
value = collectionEntry.CurrentValue;
Assert.Same(engineEntry.Entity.Gearboxes, value);
collectionEntry.CurrentValue = null;
Assert.Null(collectionEntry.CurrentValue);
context.ChangeTracker.DetectChanges();
}
}
private void TestPropertyValuePositiveForState(Func<DbPropertyEntry<Building, string>, string> getValue,
Action<DbPropertyEntry<Building, string>, string> setValue,
EntityState state)
{
using (var context = new AdvancedPatternsMasterContext())
{
var building = context.Buildings.Single(b => b.Name == "Building One");
var entry = context.Entry(building);
var propEntry = entry.Property(b => b.Name);
entry.State = state;
Assert.Equal("Building One", getValue(propEntry));
setValue(propEntry, "New Building");
Assert.Equal("New Building", getValue(propEntry));
}
}
private void Current_reference_value_for_one_to_many_principal_can_be_read_and_set(EntityState state)
{
using (var context = new F1Context())
{
var teamEntry = GetTeamEntry(context);
teamEntry.State = state;
var refEntry = teamEntry.Reference(t => t.Gearbox);
var value = refEntry.CurrentValue;
Assert.Same(teamEntry.Entity.Gearbox, value);
value = new Gearbox { Id = -7 };
refEntry.CurrentValue = value;
Assert.Same(teamEntry.Entity.Gearbox, value);
if (state != EntityState.Detached && state != EntityState.Deleted)
{
// FK is fixed up without a call to DetectChanges
Assert.Equal(teamEntry.Entity.GearboxId, value.Id);
}
if (state == EntityState.Deleted)
{
Assert.Throws<InvalidOperationException>(() => context.ChangeTracker.DetectChanges()).
ValidateMessage("RelatedEnd_UnableToAddRelationshipWithDeletedEntity");
}
else
{
context.ChangeTracker.DetectChanges();
}
value = refEntry.CurrentValue;
Assert.Same(teamEntry.Entity.Gearbox, value);
refEntry.CurrentValue = null;
Assert.Null(refEntry.CurrentValue);
Assert.Null(teamEntry.Entity.Gearbox);
if (state != EntityState.Detached)
{
// FK is fixed up without a call to DetectChanges
// For Deleted state the FK should already have been null
Assert.Null(teamEntry.Entity.GearboxId);
}
context.ChangeTracker.DetectChanges();
}
}
private void Current_reference_value_for_independent_one_to_many_principal_can_be_read_and_set(EntityState state)
{
using (var context = new F1Context())
{
var teamEntry = GetTeamEntry(context);
teamEntry.State = state;
var refEntry = teamEntry.Reference(t => t.Engine);
var value = refEntry.CurrentValue;
Assert.Same(teamEntry.Entity.Engine, value);
value = new Engine();
refEntry.CurrentValue = value;
Assert.Same(teamEntry.Entity.Engine, value);
if (state == EntityState.Deleted)
{
Assert.Throws<InvalidOperationException>(() => context.ChangeTracker.DetectChanges()).
ValidateMessage("RelatedEnd_UnableToAddRelationshipWithDeletedEntity");
}
else
{
context.ChangeTracker.DetectChanges();
}
value = refEntry.CurrentValue;
Assert.Same(teamEntry.Entity.Engine, value);
refEntry.CurrentValue = null;
Assert.Null(refEntry.CurrentValue);
Assert.Null(teamEntry.Entity.Engine);
context.ChangeTracker.DetectChanges();
}
}
private void Current_reference_value_for_one_to_one_principal_can_be_read_and_set(EntityState state)
{
using (var context = new F1Context())
{
var chassisEntry = context.Entry(GetTeamEntry(context).Entity.Chassis);
chassisEntry.State = state;
var refEntry = chassisEntry.Reference(c => c.Team);
var value = refEntry.CurrentValue;
Assert.Same(chassisEntry.Entity.Team, value);
if (state == EntityState.Unchanged || state == EntityState.Modified)
{
// Changing the reference to the principal will cause EF to throw a referential integrity exception
// because it would need a change in the PK of the dependent.
Assert.Throws<InvalidOperationException>(() => refEntry.CurrentValue = new Team()).ValidateMessage(
"EntityReference_CannotChangeReferentialConstraintProperty");
}
else
{
value = new Team();
refEntry.CurrentValue = value;
Assert.Same(chassisEntry.Entity.Team, value);
if (state == EntityState.Deleted)
{
Assert.Throws<InvalidOperationException>(() => context.ChangeTracker.DetectChanges()).
ValidateMessage("RelatedEnd_UnableToAddRelationshipWithDeletedEntity");
}
else
{
context.ChangeTracker.DetectChanges();
}
value = refEntry.CurrentValue;
Assert.Same(chassisEntry.Entity.Team, value);
}
refEntry.CurrentValue = null;
Assert.Null(refEntry.CurrentValue);
Assert.Null(chassisEntry.Entity.Team);
context.ChangeTracker.DetectChanges();
}
}
private void DbPropertyEntryTest(EntityState state, Action<DbEntityEntry<Building>> test)
{
using (var context = new AdvancedPatternsMasterContext())
{
var entry = context.Entry(new Building
{
Name = "Building 18",
Address = new Address
{
Street = "1 Microsoft Way",
City = "Redmond",
State = "WA",
ZipCode = "98052",
County = "KING",
SiteInfo = new SiteInfo { Zone = 2, Environment = "Clean" }
},
NotInModel = "NotInModel",
});
entry.State = state;
test(entry);
}
}
private void CheckPropertyIsModified(DbEntityEntry entityEntry, DbPropertyEntry propertyEntry,
EntityState initialState)
{
if (initialState == EntityState.Modified || initialState == EntityState.Unchanged)
{
Assert.True(propertyEntry.IsModified);
Assert.Equal(EntityState.Modified, entityEntry.State);
}
else
{
Assert.False(propertyEntry.IsModified);
Assert.Equal(initialState, entityEntry.State);
}
}
public static void ChangeEntityState(EntityObject item, EntityState entityState)
{
EntityModelContainer context = GetContext();
context.ObjectStateManager.ChangeObjectState(item, entityState);
}
protected abstract void OnAfter(DbEntityEntry item, EntityState state);
private static InternalEntityEntry CreateEntry(
EntityState entityState,
bool generateKeyValues = false,
bool computeNonKeyValue = false)
{
var model = BuildModel(generateKeyValues, computeNonKeyValue);
return RelationalTestHelpers.Instance.CreateInternalEntry(model, entityState, new T1 { Id = 1, Name = computeNonKeyValue ? null : "Test" });
}
public static void State(this ValidationContext context, EntityState state)
{
context.Items["state"] = state;
}
