public IEnumerable <AuditedEntity> GetAuditEntities()
{
var entities = new List <AuditedEntity>();
foreach (var entry in ChangeTracker.Entries())
{
AuditedEntity auditEntity = null;
switch (entry.State)
{
case EntityState.Added:
auditEntity = GetAuditEntity(entry, OperationType.Add);
break;
case EntityState.Modified:
auditEntity = GetAuditEntity(entry, OperationType.Modify);
break;
case EntityState.Deleted:
auditEntity = GetAuditEntity(entry, OperationType.Delete);
break;
}
if (auditEntity != null)
{
entities.Add(auditEntity);
}
}
return(entities);
}
public async Task GetAsync_WhenMultipleEntitesMatchSpecification_ReturnsFirstEntityFound()
{
var createdBy = _fixture.Create <string>();
var firstEntity = new AuditedEntity {
CreatedBy = createdBy
};
var secondEntity = new AuditedEntity {
CreatedBy = createdBy
};
await _memoryDb.Context.Set <AuditedEntity>().AddAsync(firstEntity);
await _memoryDb.Context.SaveChangesAsync();
await _memoryDb.Context.Set <AuditedEntity>().AddAsync(secondEntity);
await _memoryDb.Context.SaveChangesAsync();
var entity = await _memoryDb.Repository.GetAsync(new CreatedBySpec(createdBy));
Assert.Multiple(() =>
{
Assert.AreEqual(firstEntity, entity);
Assert.AreNotEqual(secondEntity, entity);
});
}
public async Task ListAsync_WhenMultipleEntitesMatchSpecification_WithOrderBy_ReturnsAllEntities()
{
var createdBy = _fixture.Create <string>();
var firstEntity = new AuditedEntity {
CreatedBy = createdBy, Name = "banana"
};
var secondEntity = new AuditedEntity {
CreatedBy = createdBy, Name = "apple"
};
await _memoryDb.Context.Set <AuditedEntity>().AddAsync(firstEntity);
await _memoryDb.Context.Set <AuditedEntity>().AddAsync(secondEntity);
await _memoryDb.Context.SaveChangesAsync();
var entities = await _memoryDb.Repository.ListAsync(new CreatedBySpec(createdBy).OrderByDescending(a => a.Name));
Assert.Multiple(() =>
{
Assert.AreEqual(2, entities.Count);
CollectionAssert.Contains(entities, firstEntity);
CollectionAssert.Contains(entities, secondEntity);
});
}
public override void SaveAuditedEntity(AuditedEntity auditedEntity)
{
string userName = System.Threading.Thread.CurrentPrincipal.Identity.Name;
var audit = new AuditRecord
{
Action = (byte)auditedEntity.Action,
AuditDate = DateTime.Now,
EntityTable = auditedEntity.EntityType.Name,
EntityTableKey = auditedEntity.EntityKey,
AssociationTable = auditedEntity.ParentEntityType.Name,
AssociationTableKey = auditedEntity.ParentKey,
UserName = userName
};
foreach (var modifiedProperty in auditedEntity.ModifiedProperties)
{
if (modifiedProperty.DisplayName.Trim() != "Date Updated" &&
modifiedProperty.DisplayName.Trim() != "User Updated Id")
{
audit.AuditRecordFields.Add(
new AuditRecordField
{
MemberName = modifiedProperty.DisplayName,
OldValue = modifiedProperty.OldValue,
NewValue = modifiedProperty.NewValue
});
}
}
if (audit.AuditRecordFields.Count > 0)
{
AuditRecords.InsertOnSubmit(audit);
}
}
public override void SaveAuditedEntity(AuditedEntity auditedEntity)
{
var userName = "******"; // HttpContext.Current.User.Identity.Name;
var audit = new AuditRecord
{
Action = (byte)auditedEntity.Action,
AuditDate = DateTime.Now,
ParentTable = auditedEntity.ParentEntityType.Name,
ParentKey = auditedEntity.ParentKey,
Table = auditedEntity.EntityType.Name,
TableKey = auditedEntity.EntityKey,
UserName = userName,
ModifiedProperties = auditedEntity.ModifiedProperties
.Select(auditedProperty => new AuditRecordProperty
{
PropertyName = auditedProperty.DisplayName,
OldValue = auditedProperty.OldValue,
NewValue = auditedProperty.NewValue
})
.ToList()
};
if (audit.ModifiedProperties.Count > 0)
{
AuditRecords.Add(audit);
}
}
public override void SaveAuditedEntity(AuditedEntity auditedEntity)
{
var audit = new AuditRecord
{
Action = (byte)auditedEntity.Action,
AuditDate = DateTime.Now,
ParentTable = auditedEntity.ParentEntityType.Name,
ParentKey = auditedEntity.ParentKey,
Table = auditedEntity.EntityType.Name,
TableKey = auditedEntity.EntityKey,
UserName = "******",
};
foreach (var modifiedProperty in auditedEntity.ModifiedProperties)
{
audit.AuditRecordProperties.Add(
new AuditRecordProperty
{
PropertyName = modifiedProperty.DisplayName,
OldValue = modifiedProperty.OldValue,
NewValue = modifiedProperty.NewValue
});
}
if (audit.AuditRecordProperties.Count > 0)
{
AuditRecords.AddObject(audit);
}
}
public void SetUpdatedDataFields(AuditedEntity AuditedEntity, DataRow row)
{
String userGuid = (row["LastUpdatedUserGuid"].ToString() == "" || row["LastUpdatedUserGuid"] == null) ? userGuid = ZEROSGUID : userGuid = row["LastUpdatedUserGuid"].ToString();
Guid LastUpdatedUserGuid = new Guid(userGuid);
AuditedEntity.LastUpdatedDate = (row["LastUpdatedDate"].ToString()).Length == 0 ? AuditedEntity.LastUpdatedDate : DateTime.Parse(row["LastUpdatedDate"].ToString());
AuditedEntity.LastUpdatedUser = ZEROSGUID.Equals(LastUpdatedUserGuid) ? AuditedEntity.LastUpdatedUser : (User)UsersDB[LastUpdatedUserGuid];
AuditedEntity.SyncDate = DateTime.Now;
}
public async Task Init()
{
_entity = new AuditedEntity {
Id = Guid.NewGuid(), CreatedBy = _fixture.Create <string>(), CreatedProcess = _fixture.Create <string>(), CreatedOn = DateTime.UtcNow, Name = _fixture.Create <string>()
};
_memoryDb.Context.Add(_entity);
await _memoryDb.Context.SaveChangesAsync();
}
public async Task SaveChangesAsync_WithAddedEntity_SavesToSet()
{
var entity = new AuditedEntity();
await _memoryDb.Repository.AddAsync(entity);
await _memoryDb.Repository.SaveAsync();
Assert.Contains(entity, _memoryDb.Context.Set <AuditedEntity>().ToList());
}
public async Task AddAsync_WhenAddingEntity_VerifyDbSetContainsAddedEntity()
{
var auditEntity = new AuditedEntity();
await _memoryDb.Repository.AddAsync(auditEntity);
Assert.Multiple(() =>
{
CollectionAssert.Contains(_memoryDb.Context.Set <AuditedEntity>().Local, auditEntity);
CollectionAssert.DoesNotContain(_memoryDb.Context.Set <AuditedEntity>(), auditEntity);
});
}
public void Attach_WhenAttachingEntity_VerifyDbSetContainsEntity()
{
var auditEntity = new AuditedEntity();
_memoryDb.Repository.Attach(auditEntity);
Assert.Multiple(() =>
{
CollectionAssert.Contains(_memoryDb.Context.Set <AuditedEntity>().Local, auditEntity);
CollectionAssert.DoesNotContain(_memoryDb.Context.Set <AuditedEntity>(), auditEntity);
});
}
public async Task GetAsync_WhenEntityDoesNotMatchSpecification_ReturnsNull()
{
var createdBy = _fixture.Create <string>();
var auditEntity = new AuditedEntity
{
CreatedBy = _fixture.Create <string>()
};
_memoryDb.Context.Set <AuditedEntity>().Add(auditEntity);
_memoryDb.Context.SaveChanges();
var entity = await _memoryDb.Repository.GetAsync(new CreatedBySpec(createdBy));
Assert.IsNull(entity);
}
public void Remove_WhenRemovingEntity_VerifyDbSetDoesNotContainRemovedEntity()
{
var auditEntity = new AuditedEntity();
_memoryDb.Context.Add(auditEntity);
_memoryDb.Context.SaveChanges();
_memoryDb.Repository.Remove(auditEntity);
Assert.Multiple(() =>
{
CollectionAssert.DoesNotContain(_memoryDb.Context.Set <AuditedEntity>().Local, auditEntity);
CollectionAssert.Contains(_memoryDb.Context.Set <AuditedEntity>(), auditEntity);
});
}
public void SetCreationDataFields(AuditedEntity AuditedEntity, DataRow row, Guid Guid)
{
if (AuditedEntity.CreatedDate != null && AuditedEntity.SyncDate != null)
{
return;
}
String userGuid = (row["CreatedUserGuid"].ToString() == "" || row["CreatedUserGuid"] == null) ? userGuid = ZEROSGUID : userGuid = row["CreatedUserGuid"].ToString();
Guid CreatedUserGuid = new Guid(userGuid);
AuditedEntity.CreatedDate = (row["CreatedDate"].ToString()).Length == 0 ? AuditedEntity.CreatedDate : DateTime.Parse(row["CreatedDate"].ToString());
AuditedEntity.CreatedUser = ZEROSGUID.Equals(CreatedUserGuid.ToString()) ? AuditedEntity.CreatedUser : (User)UsersDB[CreatedUserGuid];
AuditedEntity.SyncDate = DateTime.Now;
AuditedEntity.SyncGuid = Guid;
}
public async Task GetAsync_WhenEntityMatchesSpecification_ReturnsEntity()
{
var createdBy = _fixture.Create <string>();
var auditEntity = new AuditedEntity
{
CreatedBy = createdBy
};
await _memoryDb.Context.AddAsync(auditEntity);
await _memoryDb.Context.SaveChangesAsync();
var entity = await _memoryDb.Repository.GetAsync(new CreatedBySpec(createdBy));
Assert.AreEqual(auditEntity, entity);
}
public void SetLastUpdatedUserID(AuditedEntity auditedEntity)
{
User user = GetUserInfo();
if (auditedEntity.GetType().FullName.Equals("VPPS.CSI.Domain.Beneficiary"))
{
((Beneficiary)auditedEntity).LastUpdatedUserID = user.UserID;
}
if (auditedEntity.GetType().FullName.Equals("VPPS.CSI.Domain.ChildStatusHistory"))
{
((ChildStatusHistory)auditedEntity).LastUpdatedUserID = user.UserID;
}
if (auditedEntity.GetType().FullName.Equals("VPPS.CSI.Domain.ChildStatus"))
{
((ChildStatus)auditedEntity).LastUpdatedUserID = user.UserID;
}
}
public void UndeleteLog()
{
var data = new AuditedEntity
{
Id = Randomizer.Next(),
Value1 = Randomizer.GetString()
};
var auditLog = AuditGenerator.UndeleteLog(data, AuditGenerator.NewLog(data));
Assert.AreEqual(2, auditLog.Entries.Count());
Assert.AreEqual(AuditType.Undelete, auditLog.Entries.ElementAt(1).Type);
Assert.AreEqual(2, auditLog.Entries.ElementAt(1).Changes.Count());
Assert.IsTrue(auditLog.Entries.ElementAt(1).Changes.Any(x =>
x.PropertyName == "Id" && x.NewValue.Equals(data.Id) && x.OldValue == null));
Assert.IsTrue(auditLog.Entries.ElementAt(1).Changes.Any(x =>
x.PropertyName == "Value1" && x.NewValue.Equals(data.Value1) && x.OldValue == null));
}
public async Task SingleAsync_WhenMoreThanOneEntityMatchesSpecification_ThrowsInvalidOperationException()
{
var createdBy = _fixture.Create <string>();
var firstEntity = new AuditedEntity {
Id = Guid.NewGuid(), CreatedBy = createdBy
};
var secondEntity = new AuditedEntity {
Id = Guid.NewGuid(), CreatedBy = createdBy
};
await _memoryDb.Context.Set <AuditedEntity>().AddAsync(firstEntity);
await _memoryDb.Context.Set <AuditedEntity>().AddAsync(secondEntity);
await _memoryDb.Context.SaveChangesAsync();
Assert.ThrowsAsync <InvalidOperationException>(async() => await _memoryDb.Repository.SingleAsync(new CreatedBySpec(createdBy)));
}
public void Setup()
{
Randomizer = Randomizer.CreateRandomizer();
ExpectedBasicEntity1 = new BasicEntity {
Id = Randomizer.Next()
};
ExpectedBasicEntity2 = new BasicEntity {
Id = Randomizer.Next()
};
ExpectedIndexedEntity = new IndexedEntity {
Id = Randomizer.Next(), IndexedValue = Randomizer.GetString()
};
ExpectedAuditedEntity = new AuditedEntity {
Id = Randomizer.Next()
};
ExpectedAuditedEntityAuditLog = new AuditLog();
ExpectedIndexKey = new IndexKey <string>()
{
Value = Randomizer.GetString()
};
MockDataStream = new Mock <IDataWorker>();
MockDataStream
.Setup(x => x.Exists <BasicEntity>(ExpectedBasicEntity1.Id))
.ReturnsAsync(true);
MockDataStream
.Setup(x => x.Read <BasicEntity>(ExpectedBasicEntity1.Id))
.ReturnsAsync(ExpectedBasicEntity1);
MockDataStream
.Setup(x => x.Exists <BasicEntity>(ExpectedIndexedEntity.Id))
.ReturnsAsync(true);
MockDataStream
.Setup(x => x.Exists <IndexedEntity>(ExpectedIndexedEntity.Id))
.ReturnsAsync(true);
MockDataStream
.Setup(x => x.Read <BasicEntity>(ExpectedIndexedEntity.Id))
.ReturnsAsync(ExpectedIndexedEntity);
MockDataStream
.Setup(x => x.Read <IndexedEntity>(ExpectedIndexedEntity.Id))
.ReturnsAsync(ExpectedIndexedEntity);
MockDataStream
.Setup(x => x.Exists <BasicEntity>(ExpectedAuditedEntity.Id))
.ReturnsAsync(true);
MockDataStream
.Setup(x => x.Exists <AuditedEntity>(ExpectedAuditedEntity.Id))
.ReturnsAsync(true);
MockDataStream
.Setup(x => x.Read <BasicEntity>(ExpectedAuditedEntity.Id))
.ReturnsAsync(ExpectedAuditedEntity);
MockDataStream
.Setup(x => x.Read <AuditedEntity>(ExpectedAuditedEntity.Id))
.ReturnsAsync(ExpectedAuditedEntity);
MockDataStream
.Setup(x => x.WriteAndCommit(ExpectedBasicEntity1.Id, ExpectedBasicEntity1))
.ReturnsAsync(true);
MockDataStream
.Setup(x => x.WriteAndCommit(ExpectedIndexedEntity.Id, ExpectedIndexedEntity))
.ReturnsAsync(true);
MockDataStream
.Setup(x => x.Write(ExpectedAuditedEntity.Id, ExpectedAuditedEntity))
.ReturnsAsync(true);
MockDataStream
.Setup(x => x.Commit <BasicEntity>(ExpectedAuditedEntity.Id))
.ReturnsAsync(true);
MockDataStream
.Setup(x => x.Delete <BasicEntity>(ExpectedBasicEntity1.Id))
.ReturnsAsync(true);
MockDataStream
.Setup(x => x.Delete <AuditedEntity>(ExpectedAuditedEntity.Id))
.ReturnsAsync(true);
ExpectedNextBasicEntityId = Randomizer.Next();
MockDataStream
.Setup(x => x.NextId <BasicEntity>())
.Returns(ExpectedNextBasicEntityId);
MockDataStream
.Setup(x => x.ReadAll <BasicEntity>())
.Returns(ExpectedBasicEntityList);
MockIndexer = new Mock <IIndexWorker>();
MockIndexer
.Setup(x => x.IndexExist <IndexedEntity>("IndexedValue"))
.ReturnsAsync(true);
MockIndexer
.Setup(
x => x.GetIdsFromIndex <IndexedEntity, string>("IndexedValue", ExpectedIndexedEntity.IndexedValue))
.Returns(ExpectedIndexEntityList);
MockIndexer
.Setup(
x => x.GetKeysFromIndex <IndexedEntity, string>("IndexedValue"))
.Returns(ExpectedIndexKeysEntityList);
MockIndexer
.Setup(x => x.Index(ExpectedBasicEntity1))
.ReturnsAsync(true);
MockIndexer
.Setup(x => x.Index(ExpectedIndexedEntity))
.ReturnsAsync(true);
MockIndexer
.Setup(x => x.Index(ExpectedAuditedEntity))
.ReturnsAsync(true);
MockIndexer
.Setup(x => x.Unindex(ExpectedBasicEntity1))
.ReturnsAsync(true);
MockIndexer
.Setup(x => x.Unindex(ExpectedAuditedEntity))
.ReturnsAsync(true);
MockAudit = new Mock <IAuditWorker>();
MockAudit
.Setup(x => x.CreationEvent(ExpectedAuditedEntity))
.ReturnsAsync(true);
MockAudit
.Setup(x => x.UpdateEvent(ExpectedAuditedEntity, ExpectedAuditedEntity))
.ReturnsAsync(true);
MockAudit
.Setup(x => x.DeleteEvent(ExpectedAuditedEntity))
.ReturnsAsync(true);
MockAudit
.Setup(x => x.CommitEvents(ExpectedAuditedEntity))
.ReturnsAsync(true);
MockAudit
.Setup(x => x.ReadAllEvents <AuditedEntity>(ExpectedAuditedEntity.Id))
.ReturnsAsync(ExpectedAuditedEntityAuditLog);
MockLogger = new Mock <ILogger>();
DataManager = new DataManager(MockDataStream.Object, MockIndexer.Object, MockAudit.Object,
MockLogger.Object);
}
protected virtual AuditedEntity GetAuditEntity(EntityEntry entry, OperationType operationType)
{
var type = entry.Entity.GetType();
var typeName = type.FullName;
string entityId = null;
var properties = new List <AuditedProperty>();
foreach (var property in entry.CurrentValues.Properties)
{
if (property.IsConcurrencyToken)
{
continue;
}
var propertyName = property.Name;
var propertyEntry = entry.Property(property.Name);
if (property.IsPrimaryKey())
{
entityId = entry.State == EntityState.Deleted
? propertyEntry.OriginalValue?.ToString()
: propertyEntry.CurrentValue?.ToString();
}
string propertyType = property.ClrType.ToString();
string originalValue = null;
string newValue = null;
if (entry.State == EntityState.Added)
{
newValue = propertyEntry.CurrentValue?.ToString();
}
else if (entry.State == EntityState.Deleted)
{
originalValue = propertyEntry.OriginalValue?.ToString();
}
else if (entry.State == EntityState.Modified)
{
var currentValue = propertyEntry.CurrentValue?.ToString();
originalValue = propertyEntry.OriginalValue?.ToString();
if (currentValue == originalValue)
{
continue;
}
newValue = currentValue;
}
if (string.IsNullOrWhiteSpace(originalValue))
{
// 原值为空，新值不为空则记录
if (!string.IsNullOrWhiteSpace(newValue))
{
properties.Add(new AuditedProperty(propertyName, propertyType, originalValue, newValue));
}
}
else
{
if (!originalValue.Equals(newValue))
{
properties.Add(new AuditedProperty(propertyName, propertyType, originalValue, newValue));
}
}
}
var auditedEntity = new AuditedEntity(typeName, entityId, operationType);
auditedEntity.AddProperties(properties);
return(auditedEntity);
}
public async Task RegisterUpdate(AuditedEntity entity)
{
var user = await currentUserProvider.GetCurrentUser();
entity.MarkAsUpdated(user);
}
/// <summary> /// Use this method to define how to save the actual audit record into the database /// </summary> public abstract void SaveAuditedEntity(AuditedEntity record);
protected AuditedEntity SetCreatedUser(AuditedEntity entity)
{
entity.CreatedUser = user;
return(entity);
}
public virtual void SaveAuditedEntity(AuditedEntity record)
{
}
protected AuditedEntity SetLastUpdatedUser(AuditedEntity entity)
{
entity.LastUpdatedUser = user;
return(entity);
}
