private static KeyValuePair<string, string> BuildKeyRepresentation(EntityEntry entityEntry, string seperator)
{
var keyProperties = entityEntry.Metadata.GetProperties().Where(x => x.IsPrimaryKey()).ToList();
if (keyProperties == null)
throw new ArgumentException("No key found in");
var keyPropertyEntries =
keyProperties.Select(keyProperty => entityEntry.Property(keyProperty.Name)).ToList();
var keyNameString = new StringBuilder();
foreach (var keyProperty in keyProperties)
{
keyNameString.Append(keyProperty.Name);
keyNameString.Append(seperator);
}
keyNameString.Remove(keyNameString.Length - 1, 1);
var keyValueString = new StringBuilder();
foreach (var keyPropertyEntry in keyPropertyEntries)
{
keyValueString.Append(keyPropertyEntry.CurrentValue);
keyValueString.Append(seperator);
}
keyValueString.Remove(keyValueString.Length - 1, 1);
var key = keyNameString.ToString();
var value = keyValueString.ToString();
return new KeyValuePair<string, string>(key, value);
}
public void Members_check_arguments()
{
Assert.Equal(
"stateEntry",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => new EntityEntry(null)).ParamName);
Assert.Equal(
"stateEntry",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => new EntityEntry<Random>(null)).ParamName);
var entry = new EntityEntry(new Mock<StateEntry>().Object);
Assert.Equal(
Strings.FormatArgumentIsEmpty("propertyName"),
Assert.Throws<ArgumentException>(() => entry.Property("")).Message);
var genericEntry = new EntityEntry<Random>(new Mock<StateEntry>().Object);
Assert.Equal(
"propertyExpression",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => genericEntry.Property((Expression<Func<Random, int>>)null)).ParamName);
}
/// <summary>Audit entity deleted.</summary>
/// <param name="objectStateEntry">The object state entry.</param>
public static void AuditEntityDeleted(AuditEntry entry, EntityEntry objectStateEntry)
{
foreach (var propertyEntry in objectStateEntry.Metadata.GetProperties())
{
var property = objectStateEntry.Property(propertyEntry.Name);
if (entry.Parent.CurrentOrDefaultConfiguration.IsAuditedProperty(entry.Entry, propertyEntry.Name))
{
entry.Properties.Add(new AuditEntryProperty(entry, propertyEntry.Name, property.OriginalValue, null));
}
}
}
private static IEnumerable<CustomAuditLog> GetAuditLogs(EntityEntry entityEntry, string userName, EntityState entityState)
{
var returnValue = new List<CustomAuditLog>();
// var keyRepresentation = BuildKeyRepresentation(entityEntry, KeySeperator);
DateTime RightNow = DateTime.Now;
Guid AuditBatchID;
UuidCreateSequential(out AuditBatchID);
var auditedPropertyNames =
entityEntry.Entity.GetType()
.GetProperties().Where(p => !p.GetCustomAttributes(typeof(DoNotAudit), true).Any())
.Select(info => info.Name);
var differences = new List<PropertyDiff>();
foreach (var propertyEntry in entityEntry.Metadata.GetProperties()
.Where(x => auditedPropertyNames.Contains(x.Name))
.Select(property => new { PropertyName = property.Name, Property = entityEntry.Property(property.Name) }))
{
var originalValue = Convert.ToString(propertyEntry.Property.OriginalValue);
var currentValue = Convert.ToString(propertyEntry.Property.CurrentValue);
if (entityState == EntityState.Modified && originalValue == currentValue) //Values are the same, don't log
continue;
var diff = new PropertyDiff { PropertyName = propertyEntry.PropertyName, OriginalValue = originalValue, NewValue = currentValue } ;
differences.Add(diff);
}
var ser = JsonConvert.SerializeObject(differences);
returnValue.Add(new CustomAuditLog
{
Differences = ser,
EventDateTime = RightNow,
EventType = entityState.ToString(),
UserName = userName,
TableName = entityEntry.Entity.GetType().Name
});
return returnValue;
}
private static IEnumerable<AuditLog> GetAuditLogs(EntityEntry entityEntry, string userName, EntityState entityState)
{
var returnValue = new List<AuditLog>();
var keyRepresentation = BuildKeyRepresentation(entityEntry, KeySeperator);
var auditedPropertyNames =
entityEntry.Entity.GetType()
.GetProperties().Where(p => !p.GetCustomAttributes(typeof (DoNotAudit), true).Any())
.Select(info => info.Name);
foreach (var propertyEntry in entityEntry.Metadata.GetProperties()
.Where(x => auditedPropertyNames.Contains(x.Name))
.Select(property => entityEntry.Property(property.Name)))
{
if(entityState == EntityState.Modified)
if (Convert.ToString(propertyEntry.OriginalValue) == Convert.ToString(propertyEntry.CurrentValue)) //Values are the same, don't log
continue;
returnValue.Add(new AuditLog
{
KeyNames = keyRepresentation.Key,
KeyValues = keyRepresentation.Value,
OriginalValue = entityState != EntityState.Added
? Convert.ToString(propertyEntry.OriginalValue)
: null,
NewValue = entityState == EntityState.Modified || entityState == EntityState.Added
? Convert.ToString(propertyEntry.CurrentValue)
: null,
ColumnName = propertyEntry.Metadata.Name,
EventDateTime = DateTime.Now,
EventType = entityState.ToString(),
UserName = userName,
TableName = entityEntry.Entity.GetType().Name
});
}
return returnValue;
}
public void Can_get_property_entry_by_lambda()
{
var stateEntryMock = CreateStateEntryMock();
var entry = new EntityEntry<Chunky>(stateEntryMock.Object);
Assert.Equal("Monkey", entry.Property(e => e.Monkey).Name);
}
public void Can_get_property_entry_by_name()
{
var stateEntryMock = CreateStateEntryMock();
var entry = new EntityEntry<Random>(stateEntryMock.Object);
Assert.Equal("Monkey", entry.Property("Monkey").Name);
}
