public static object GetOriginalEntity(DbEntityEntry dbEntry)
{
var entityType = dbEntry.Entity.GetType();
if (TrackingEntitiesConfiguration.GetConfigFor(entityType) == null)
{
entityType = entityType.BaseType;
}
var originalEntity = Activator.CreateInstance(entityType, true);
foreach (var propertyName in dbEntry.OriginalValues.PropertyNames)
{
var property = entityType.GetProperty(propertyName);
var value = dbEntry.OriginalValues[propertyName];
if (!(value is DbPropertyValues))
{
property.SetValue(originalEntity, value);
}
/*else
* {
* // nested entity
* property.SetValue(originalEntity, GetOriginalEntity(value as DbPropertyValues, property.PropertyType));
* }*/
}
return(originalEntity);
}
public void TrackManyChangesForTheUserEntity()
{
var oldUserEntity = new UserEntity
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
Name = "some name",
UserType = UserType.Customer
};
var config = TrackingEntitiesConfiguration.GetConfigFor(oldUserEntity.GetType());
var newUserEntity = oldUserEntity.DeepClone();
newUserEntity.Name = "new name";
newUserEntity.Email = "*****@*****.**";
newUserEntity.UserType = UserType.Reseller;
var result = GetPropertyChangesWay2.GetChangesFor(oldUserEntity, newUserEntity, config);
Assert.IsTrue(result.Count == 3);
var userTypeChange = result.FirstOrDefault(x => x.PropertyName == "UserType");
Assert.IsTrue(userTypeChange != null);
Assert.IsTrue(userTypeChange.OldValue == oldUserEntity.UserType.ToString());
Assert.IsTrue(userTypeChange.NewValue == newUserEntity.UserType.ToString());
}
public void TestConfigurationForUserEntity()
{
var allUserRoles = EnumHelper.ToArray <UserType>();
var trackingEntityConfig = TrackingEntitiesConfiguration
.TrackEntityChangesFor <UserEntity>()
.TrackProperty(x => x.Name, allUserRoles)
.TrackProperty(x => x.Email, allUserRoles.ExceptItem(UserType.Customer))
.TrackProperty(x => x.UserType, allUserRoles.ExceptItem(UserType.Customer, UserType.Reseller))
.TrackProperty(x => x.Orders, new [] { UserType.SystemUser })
.BuildConfiguration();
Assert.IsTrue(trackingEntityConfig.EntityName.IsNullOrEmpty() == false);
var nameProperty = trackingEntityConfig.PropertyList.FirstOrDefault(x => x.Name == nameof(UserEntity.Name));
Assert.IsTrue(nameProperty != null);
Assert.IsTrue(nameProperty.Name == nameof(UserEntity.Name));
Assert.IsTrue(nameProperty.IsVisibleForUserRoles.SequenceEqual(allUserRoles));
Assert.IsTrue(trackingEntityConfig.EntityName.IsNullOrEmpty() == false);
var orderProperty = trackingEntityConfig.PropertyList.FirstOrDefault(x => x.Name == nameof(UserEntity.Orders));
Assert.IsTrue(orderProperty != null);
Assert.IsTrue(orderProperty.IsVisibleForUserRoles.Count == 1);
Assert.IsTrue(orderProperty.IsVisibleForUserRoles.First() == UserType.SystemUser);
Assert.IsTrue(orderProperty.Name == nameof(UserEntity.Orders));
}
public async Task <List <EntityNameModel> > GetTrackingTableNamesAsync()
{
var trackingEntityNames = TrackingEntitiesConfiguration.GetConfigList().Select(x => x.EntityName);
return(trackingEntityNames.Select(x => new EntityNameModel
{
EntityName = x,
EntityNameForDisplaying = x.SplitByCaps()
}).ToList());
}
public void TrackNoChangesForDeletedEntity()
{
var userEntity = new UserEntity();
var config = TrackingEntitiesConfiguration.GetConfigFor(userEntity.GetType());
var result = GetPropertyChangesWay2.GetChangesFor(userEntity, null, config);
Assert.IsTrue(result.Count == 1);
Assert.IsTrue(result.First().OldValue == default(UserType).ToString());
Assert.IsTrue(result.First().NewValue == null);
}
public void TrackNoChangesForNull()
{
var userEntity = new UserEntity();
var config = TrackingEntitiesConfiguration.GetConfigFor(userEntity.GetType());
var result = GetPropertyChangesWay2.GetChangesFor((UserEntity)null, null, config);
Assert.IsTrue(result.Count == 0);
result = GetPropertyChangesWay2.GetChangesFor(userEntity, userEntity, config);
Assert.IsTrue(result.Count == 0);
}
private void ProcessChangesBeforeSave()
{
ChangeTracker.DetectChanges();
var changes = this.ChangeTracker.Entries()
.Where(e => e.State == EntityState.Added || e.State == EntityState.Modified || e.State == EntityState.Deleted);
var now = DateTime.UtcNow;
foreach (var dbEntry in changes)
{
var entity = dbEntry.Entity as BaseEntity;
if (entity is null)
{
continue;
}
if (dbEntry.State == EntityState.Added)
{
if (entity.Id == Guid.Empty)
{
entity.Id = Guid.NewGuid();
}
entity.CreatedDateUtc = now;
entity.CreatedByUserId = UserManager.GetCurrentUserId();
entity.UpdatedDateUtc = now;
entity.UpdatedByUserId = UserManager.GetCurrentUserId();
}
if (dbEntry.State == EntityState.Modified)
{
dbEntry.Property(nameof(BaseEntity.CreatedDateUtc)).IsModified = false;
dbEntry.Property(nameof(BaseEntity.CreatedByUserId)).IsModified = false;
}
if (dbEntry.State == EntityState.Modified)
{
entity.UpdatedDateUtc = now;
entity.UpdatedByUserId = UserManager.GetCurrentUserId();
dbEntry.Property(nameof(BaseEntity.UpdatedDateUtc)).IsModified = true;
dbEntry.Property(nameof(BaseEntity.UpdatedByUserId)).IsModified = true;
}
var currentTrackingEntityConfig = TrackingEntitiesConfiguration.GetConfigFor(x => x.EntityType == entity.GetType() || x.EntityType == entity.GetType().BaseType);
if (currentTrackingEntityConfig != null)
{
var trackEntityChange = TrackChangesLogic.GetTrackEntityChangeRecord(this, dbEntry, currentTrackingEntityConfig);
if (trackEntityChange != null)
{
TrackEntityChanges.Add(trackEntityChange);
}
}
}
}
public void TrackFirstOneChangeForTheUserEntity()
{
var oldUserEntity = new UserEntity();
var config = TrackingEntitiesConfiguration.GetConfigFor(oldUserEntity.GetType());
var newUserEntity = oldUserEntity.DeepClone();
newUserEntity.Name = "new name";
var result = GetPropertyChangesWay2.GetChangesFor(oldUserEntity, newUserEntity, config);
Assert.IsTrue(result.Count == 1);
Assert.IsTrue(result.First().OldValue == null);
Assert.IsTrue(result.First().NewValue == (newUserEntity.Name ?? string.Empty));
}
public void TrackNoChangesForTheSameUserEntityWhichIsNotNull()
{
var userEntity = new UserEntity
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
Name = "some name",
UserType = UserType.Customer
};
var config = TrackingEntitiesConfiguration.GetConfigFor(userEntity.GetType());
var result = GetPropertyChangesWay2.GetChangesFor(userEntity, userEntity, config);
Assert.IsTrue(result.Count == 0);
}
public void TrackOneChangeForTheUserEntity()
{
var oldUserEntity = new UserEntity
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
Name = "some name",
UserType = UserType.Customer
};
var config = TrackingEntitiesConfiguration.GetConfigFor(oldUserEntity.GetType());
var newUserEntity = oldUserEntity.DeepClone();
newUserEntity.Name = "new name";
var result = GetPropertyChangesWay2.GetChangesFor(oldUserEntity, newUserEntity, config);
Assert.IsTrue(result.Count == 1);
Assert.IsTrue(result.First().OldValue == oldUserEntity.Name);
Assert.IsTrue(result.First().NewValue == newUserEntity.Name);
}
public void TrackNoChangesForNewEntity()
{
var userEntity = new UserEntity {
Email = "*****@*****.**"
};
var config = TrackingEntitiesConfiguration.GetConfigFor(userEntity.GetType());
var result = GetPropertyChangesWay2.GetChangesFor(null, userEntity, config);
Assert.IsTrue(result.Count == 2);
var userTypeChange = result.FirstOrDefault(x => x.PropertyName == nameof(UserEntity.UserType));
Assert.IsTrue(userTypeChange != null);
Assert.IsTrue(userTypeChange.OldValue == null);
Assert.IsTrue(userTypeChange.NewValue == default(UserType).ToString());
var emailChange = result.FirstOrDefault(x => x.PropertyName == nameof(userEntity.Email));
Assert.IsTrue(emailChange != null);
Assert.IsTrue(emailChange.OldValue == null);
Assert.IsTrue(emailChange.NewValue.IsNullOrEmpty() == false);
}
public async Task <List <ChangeModel> > GetChangesAsync(GetChangesListModel query)
{
query = query ?? new GetChangesListModel();
var getEntityChangesDbQuery = Storage.TrackEntityChanges.AsQueryable();
if (query.EntityNames.Any())
{
getEntityChangesDbQuery = getEntityChangesDbQuery.Where(e => query.EntityNames.Contains(e.EntityTable));
}
if (query.UserIds.Any())
{
getEntityChangesDbQuery = getEntityChangesDbQuery.Where(e => query.UserIds.Contains(e.ChangedByUserId));
}
if (query.TakeHistoryForLastNumberOfDays.HasValue)
{
var fromDate = DateTime.UtcNow.AddDays(-query.TakeHistoryForLastNumberOfDays.Value);
getEntityChangesDbQuery = getEntityChangesDbQuery.Where(e => fromDate <= e.ChangeDateUtc);
}
if (query.EntityId.HasValue)
{
getEntityChangesDbQuery = getEntityChangesDbQuery.Where(e => e.EntityId == query.EntityId.Value);
}
var entityChanges = await getEntityChangesDbQuery
.Select(e => new ChangeModel
{
Id = e.Id,
ChangeDate = e.ChangeDateUtc,
ChangeType = e.ChangeType,
PropertyChangesAsJson = e.PropertiesChangesWay1,
EntityName = e.EntityTable,
EntityId = e.EntityId,
ChangedByUser = new UserModel
{
Name = e.ChangedByUser.Name,
Email = e.ChangedByUser.Email,
UserType = e.ChangedByUser.UserType
}
})
.OrderByDescending(x => x.ChangeDate)
.ToListAsync();
entityChanges.ForEach(changeModel =>
{
var config = TrackingEntitiesConfiguration.GetConfigFor(changeModel.EntityName);
if (config == null)
{
return;
}
changeModel.PropertyChanges = JsonConvert.DeserializeObject <List <PropertyChangeDescription> >(changeModel.PropertyChangesAsJson)
?? new List <PropertyChangeDescription>();
changeModel.EntityNameForDisplaying = changeModel.EntityName.SplitByCaps();
foreach (var property in changeModel.PropertyChanges)
{
var propertyConfig = config.PropertyList.FirstOrDefault(x => x.Name == property.PropertyName);
if (propertyConfig == null)
{
continue;
}
property.IsVisibleForUserRoles = propertyConfig.IsVisibleForUserRoles;
property.PropertyNameForDisplaying = property.PropertyName.SplitByCaps();
property.OldValueForDisplaying = propertyConfig.DisplayingPropertyFunction(property.OldValue);
property.NewValueForDisplaying = propertyConfig.DisplayingPropertyFunction(property.NewValue);
}
if (query.FilterByUserRole.HasValue)
{
changeModel.PropertyChanges = changeModel.PropertyChanges
.Where(x => x.IsVisibleForUserRoles.Contains(query.FilterByUserRole.Value))
.ToList();
}
});
return(entityChanges);
}
