public AuditLog CreateLogRecord(object userName, EventType eventType, ITrackerContext context)
{
Type entityType = _dbEntry.Entity.GetType().GetEntityType();
DateTime changeTime = DateTime.UtcNow;
if (!entityType.IsTrackingEnabled())
{
return(null);
}
IEnumerable <string> keyNames = entityType.GetPrimaryKeyNames(context);
var newlog = new AuditLog
{
UserName = userName != null?userName.ToString() : null,
EventDateUTC = changeTime,
EventType = eventType,
TypeFullName = entityType.FullName,
RecordId = _dbEntry.GetPrimaryKeyValues(keyNames).ToString()
};
using (var detailsAuditor = (eventType == EventType.Added)
? new AddedLogDetailsAuditor(_dbEntry, newlog)
: new LogDetailsAuditor(_dbEntry, newlog))
{
newlog.LogDetails = detailsAuditor.CreateLogDetails().ToList();
}
return(newlog);
}
private static T AssertChange <T>(T entity, ITrackerContext db, object entityId, string userName, EventType eventType,
AuditLogDetail[] logdetails)
{
var logs = db.GetLogs <T>(entityId)
.Where(x => x.EventType == eventType && x.UserName == userName);
logs.AssertCountIsNotZero(
$"no logs found for {typeof (T).Name} with id {entityId} & username {userName ?? "null"}");
var lastLog = logs.OrderByDescending(x => x.AuditLogId)
.FirstOrDefault()
.AssertIsNotNull();
lastLog.LogDetails
.AssertCountIsNotZero("no log details found")
.AssertCount(logdetails.Count());
foreach (var auditLogDetail in logdetails)
{
logdetails.AssertAny(x => x.OriginalValue == auditLogDetail.OriginalValue &&
x.NewValue == auditLogDetail.NewValue &&
x.PropertyName == auditLogDetail.PropertyName,
$"cound not find log detail with original value: {auditLogDetail.OriginalValue}, " +
$"new value: {auditLogDetail.NewValue} " +
$"and propertyname: {auditLogDetail.PropertyName}");
}
return(entity);
}
/// <summary>
/// Get all logs for the given model type
/// </summary>
/// <typeparam name="TEntity">Type of domain model</typeparam>
/// <returns></returns>
public static IQueryable <AuditLog> GetLogs <TEntity>(ITrackerContext context)
{
IEnumerable <string> entityTypeNames = EntityTypeNames <TEntity>();
string entityTypeName = typeof(TEntity).Name;
return(context.AuditLog.Where(x => entityTypeNames.Contains(x.TypeFullName)));
}
public static T AssertAuditForModification <T>(this T entity, ITrackerContext db, object entityId,
string userName = null, params AuditLogDetail[] logdetails)
{
IEnumerable <AuditLog> logs = db.GetLogs <T>(entityId)
.Where(x => x.EventType == EventType.Modified && x.UserName == userName)
.ToList();
logs.AssertCountIsNotZero("log count is zero");
AuditLog lastLog = logs.Last()
.AssertIsNotNull("log not found");
lastLog.LogDetails
.AssertCountIsNotZero("no log details found")
.AssertCount(logdetails.Count());
foreach (AuditLogDetail logdetail in logdetails)
{
lastLog.LogDetails.AssertAny(x => x.OriginalValue == logdetail.OriginalValue &&
x.PropertyName == logdetail.PropertyName &&
x.NewValue == logdetail.NewValue,
"could not find an expected auditlog detail");
}
return(entity);
}
public AuditLog CreateLogRecord(object userName, EventType eventType, ITrackerContext context)
{
Type entityType = _dbEntry.Entity.GetType().GetEntityType();
DateTime changeTime = DateTime.UtcNow;
if (!entityType.IsTrackingEnabled())
{
return null;
}
IEnumerable<string> keyNames = entityType.GetPrimaryKeyNames(context);
var newlog = new AuditLog
{
UserName = userName != null ? userName.ToString() : null,
EventDateUTC = changeTime,
EventType = eventType,
TypeFullName = entityType.FullName,
RecordId = _dbEntry.GetPrimaryKeyValues(keyNames).ToString()
};
using (var detailsAuditor = (eventType == EventType.Added)
? new AddedLogDetailsAuditor(_dbEntry, newlog)
: new LogDetailsAuditor(_dbEntry, newlog))
{
newlog.LogDetails = detailsAuditor.CreateLogDetails().ToList();
}
return newlog;
}
public AuditService(ITrackerContext auditRepository, IUserContext userContext, IUrlHelper urlHelper, IUserService userService)
{
this._auditRepository = auditRepository;
this._userContext = userContext;
this._urlHelper = urlHelper;
this._userService = userService;
}
internal AuditLog CreateLogRecord(object userName, EventType eventType, ITrackerContext context)
{
Type entityType = _dbEntry.Entity.GetType().GetEntityType();
if (!EntityTrackingConfiguration.IsTrackingEnabled(entityType))
{
return null;
}
DateTime changeTime = DateTime.UtcNow;
//todo: make this a static class
var mapping = new DbMapping(context, entityType);
List<PropertyConfiguerationKey> keyNames = mapping.PrimaryKeys().ToList();
var newlog = new AuditLog
{
UserName = userName?.ToString(),
EventDateUTC = changeTime,
EventType = eventType,
TypeFullName = entityType.FullName,
RecordId = GetPrimaryKeyValuesOf(_dbEntry, keyNames).ToString()
};
var detailsAuditor = GetDetailsAuditor(eventType, newlog);
newlog.LogDetails = detailsAuditor.CreateLogDetails().ToList();
if (newlog.LogDetails.Any())
return newlog;
else
return null;
}
public static T AssertNoLogs <T>(this T entity, ITrackerContext db, object entityId)
{
var logs = db.GetLogs <T>(entityId);
logs.AssertCount(0, "Logs found when logs were not expected");
return(entity);
}
/// <summary>
/// Get all logs for the given model type for a specific record
/// </summary>
/// <typeparam name="TEntity">Type of domain model</typeparam>
/// <param name="primaryKey">primary key of record</param>
/// <returns></returns>
public static IQueryable <AuditLog> GetLogs <TEntity>(ITrackerContext context, object primaryKey)
{
string key = primaryKey.ToString();
string entityTypeName = typeof(TEntity).Name;
IEnumerable <string> entityTypeNames = EntityTypeNames <TEntity>();
return(context.AuditLog.Where(x => entityTypeNames.Contains(x.TypeFullName) && x.RecordId == key));
}
public LogDataMigration(ITrackerContext trackerContext)
{
if (trackerContext == null)
{
throw new ArgumentNullException(nameof(trackerContext));
}
_trackerContext = trackerContext;
}
public static T AssertNoLogs <T>(this T entity, ITrackerContext db, object entityId, EventType eventType)
{
IQueryable <AuditLog> logs = db.GetLogs <T>(entityId)
.Where(x => x.EventType == eventType);
logs.AssertCount(0, "Logs found when logs were not expected");
return(entity);
}
private static IEnumerable <string> PrimaryKeyNamesFactory(Type type, ITrackerContext context)
{
ObjectContext objectContext = ((IObjectContextAdapter)context).ObjectContext;
EdmType edmType;
if (objectContext.MetadataWorkspace.TryGetType(type.Name, type.Namespace, DataSpace.OSpace, out edmType))
{
return(edmType.MetadataProperties.Where(mp => mp.Name == "KeyMembers")
.SelectMany(mp => mp.Value as ReadOnlyMetadataCollection <EdmMember>)
.OfType <EdmProperty>().Select(edmProperty => edmProperty.Name));
}
throw new Exception(string.Format("could not find type '{0}' from objectContext", type.FullName));
}
internal AuditLog CreateLogRecord(object userName, EventType eventType, ITrackerContext context, ExpandoObject metadata)
{
Type entityType = _dbEntry.Entity.GetType().GetEntityType();
if (!EntityTrackingConfiguration.IsTrackingEnabled(entityType))
{
return(null);
}
DateTime changeTime = DateTime.UtcNow;
//todo: make this a static class
DbMapping mapping = new DbMapping(context, entityType);
List <PropertyConfiguerationKey> keyNames = mapping.PrimaryKeys().ToList();
AuditLog newlog = new AuditLog
{
UserName = userName?.ToString(),
EventDateUTC = changeTime,
EventType = eventType,
TypeFullName = entityType.FullName,
RecordId = GetPrimaryKeyValuesOf(_dbEntry, keyNames).ToString()
};
List <LogMetadata> logMetadata = metadata
.Where(x => x.Value != null)
.Select(m => new LogMetadata
{
AuditLog = newlog,
Key = m.Key,
Value = m.Value?.ToString()
})
.ToList();
newlog.Metadata = logMetadata;
ChangeLogDetailsAuditor detailsAuditor = GetDetailsAuditor(eventType, newlog);
newlog.LogDetails = detailsAuditor.CreateLogDetails().ToList();
if (newlog.LogDetails.Any())
{
return(newlog);
}
else
{
return(null);
}
}
internal AuditLog CreateLogRecord(object userName, EventType eventType, ITrackerContext context, ExpandoObject metadata)
{
Type entityType = _dbEntry.Entity.GetType();
if (!EntityTrackingConfiguration.IsTrackingEnabled(entityType))
{
return(null);
}
DateTime changeTime = DateTime.UtcNow;
//changed to static class by Aaron Sulwer 3/16/2018
List <PropertyConfigurationKey> keyNames = (context as DbContext).GetKeyNames(entityType).ToList();
var newlog = new AuditLog
{
UserName = userName?.ToString(),
EventDateUTC = changeTime,
EventType = eventType,
TypeFullName = entityType.FullName,
RecordId = GetPrimaryKeyValuesOf(_dbEntry, keyNames).ToString()
};
var logMetadata = metadata
.Where(x => x.Value != null)
.Select(m => new LogMetadata
{
AuditLog = newlog,
Key = m.Key,
Value = m.Value?.ToString()
})
.ToList();
newlog.Metadata = logMetadata;
var detailsAuditor = GetDetailsAuditor(eventType, newlog);
newlog.LogDetails = detailsAuditor.CreateLogDetails().ToList();
if (newlog.LogDetails.Any())
{
return(newlog);
}
else
{
return(null);
}
}
public static void AuditAdditions(ITrackerContext dbContext, object userName,
IEnumerable <DbEntityEntry> addedEntries)
{
// Get all Added entities
foreach (DbEntityEntry ent in addedEntries)
{
using (var auditer = new LogAuditor(ent))
{
AuditLog record = auditer.CreateLogRecord(userName, EventType.Added, dbContext);
if (record != null)
{
dbContext.AuditLog.Add(record);
}
}
}
}
public static void AuditChanges(ITrackerContext dbContext, object userName)
{
// Get all Deleted/Modified entities (not Unmodified or Detached or Added)
foreach (
DbEntityEntry ent in
dbContext.ChangeTracker.Entries()
.Where(p => p.State == EntityState.Deleted || p.State == EntityState.Modified))
{
using (var auditer = new LogAuditor(ent))
{
AuditLog record = auditer.CreateLogRecord(userName,
ent.State == EntityState.Modified ? EventType.Modified : EventType.Deleted, dbContext);
if (record != null)
{
dbContext.AuditLog.Add(record);
}
}
}
}
public static T AssertMetadata <T>(this T entity, ITrackerContext db, object entityId, Dictionary <string, string> metadataCollection = null)
{
IEnumerable <AuditLog> logs = db.GetLogs <T>(entityId)
.AssertCountIsNotZero("log count is zero");
AuditLog lastLog = logs.LastOrDefault()
.AssertIsNotNull("log not found");
if (metadataCollection != null)
{
lastLog.Metadata.AssertCount(metadataCollection.Count, "Count of metadata is different.");
foreach (var metadata in metadataCollection)
{
lastLog.Metadata.AssertAny(x => x.Key == metadata.Key && x.Value == metadata.Value, $"metadata not found: {metadata.Key} - {metadata.Value}");
}
}
return(entity);
}
public static T AssertAuditForAddition <T>(this T entity, ITrackerContext db, object entityId,
string userName = null, params KeyValuePair <string, string>[] newValues)
{
IEnumerable <AuditLog> logs = db.GetLogs <T>(entityId)
.AssertCountIsNotZero("log count is zero");
AuditLog lastLog = logs.Last(x => x.EventType == EventType.Added && x.UserName == userName)
.AssertIsNotNull("log not found");
lastLog.LogDetails
.AssertCountIsNotZero("no log details found")
.AssertCount(newValues.Count());
foreach (var keyValuePair in newValues)
{
lastLog.LogDetails.AssertAny(x => x.NewValue == keyValuePair.Value &&
x.PropertyName == keyValuePair.Key);
}
return(entity);
}
public static T AssertAuditForDeletion <T>(this T entity, ITrackerContext db, object entityId, string userName = null, params Expression <Func <T, object> >[] oldValueProperties)
{
IEnumerable <AuditLog> logs = db.GetLogs <T>(entityId)
.Where(x => x.EventType == EventType.Deleted && x.UserName == userName)
.AssertCountIsNotZero("log count is zero");
AuditLog lastLog = logs.Last()
.AssertIsNotNull("log not found");
lastLog.LogDetails
.AssertCountIsNotZero("no log details found")
.AssertCount(oldValueProperties.Count());
foreach (var property in oldValueProperties)
{
var keyValuePair = entity.GetKeyValuePair(property);
lastLog.LogDetails.AssertAny(x => x.OriginalValue == keyValuePair.Value && x.PropertyName == keyValuePair.Key);
}
return(entity);
}
internal AuditLog CreateLogRecord(object userName, EventType eventType, ITrackerContext context)
{
Type entityType = _dbEntry.Entity.GetType().GetEntityType();
if (!EntityTrackingConfiguration.IsTrackingEnabled(entityType))
{
return(null);
}
DateTime changeTime = DateTime.UtcNow;
//todo: make this a static class
var mapping = new DbMapping(context, entityType);
List <PropertyConfiguerationKey> keyNames = mapping.PrimaryKeys().ToList();
var newlog = new AuditLog
{
UserName = userName?.ToString(),
EventDateUTC = changeTime,
EventType = eventType,
TypeFullName = entityType.FullName,
RecordId = GetPrimaryKeyValuesOf(_dbEntry, keyNames).ToString()
};
var detailsAuditor = GetDetailsAuditor(eventType, newlog);
newlog.LogDetails = detailsAuditor.CreateLogDetails().ToList();
if (newlog.LogDetails.Any())
{
return(newlog);
}
else
{
return(null);
}
}
public static T AssertAuditForAddition <T>(this T entity, ITrackerContext db, object entityId,
string userName = null, params Expression <Func <T, object> >[] propertyExpressions)
{
IEnumerable <AuditLog> logs = db.GetLogs <T>(entityId)
.Where(x => x.EventType == EventType.Added && userName == x.UserName)
.AssertCountIsNotZero("log count is zero");
AuditLog lastLog = logs.LastOrDefault()
.AssertIsNotNull("log not found");
lastLog.LogDetails
.AssertCountIsNotZero("no log details found")
.AssertCount(propertyExpressions.Count());
foreach (Expression <Func <T, object> > expression in propertyExpressions)
{
KeyValuePair <string, string> keyValuePair = entity.GetKeyValuePair(expression);
lastLog.LogDetails.AssertAny(x => x.NewValue == keyValuePair.Value &&
x.PropertyName == keyValuePair.Key);
}
return(entity);
}
internal DbMapping(ITrackerContext context, Type entityType)
{
_entityType = entityType;
_entityMap = (context as DbContext).Db(_entityType);
}
public EFRepository(ITrackerContext context)
{
this._context = context;
}
/// <summary>
/// Get all logs for the enitity type name
/// </summary>
/// <param name="entityTypeName">Name of entity type</param>
/// <returns></returns>
public static IQueryable <AuditLog> GetLogs(ITrackerContext context, string entityTypeName)
{
return(context.AuditLog.Where(x => x.TypeFullName == entityTypeName));
}
internal DbMapping(ITrackerContext context, Type entityType)
{
_entityType = entityType;
_entityMap = (context as DbContext).Db(_entityType);
}
public static IEnumerable <string> GetPrimaryKeyNames(this Type type, ITrackerContext context)
{
string key = type.FullName;
return(GetFromCache(PrimaryKeyNameCache, key, k => PrimaryKeyNamesFactory(type, context)));
}
public LogDataMigration(ITrackerContext trackerContext)
{
_trackerContext = trackerContext ?? throw new ArgumentNullException(nameof(trackerContext));
}
/// <summary>
/// Get all logs for the given entity name for a specific record
/// </summary>
/// <param name="entityTypeName">entity type name</param>
/// <param name="primaryKey">primary key of record</param>
/// <returns></returns>
public static IQueryable <AuditLog> GetLogs(ITrackerContext context, string entityTypeName, object primaryKey)
{
string key = primaryKey.ToString();
return(context.AuditLog.Where(x => x.TypeFullName == entityTypeName && x.RecordId == key));
}
internal DbMapping(ITrackerContext context, Type entityType)
{
_context = context;
_entityType = entityType;
}
public static T AssertAuditForUndeletion <T>(this T entity, ITrackerContext db, object entityId,
string userName = null, params AuditLogDetail[] logdetails)
{
return(AssertChange(entity, db, entityId, userName, EventType.UnDeleted, logdetails));
}
/// <summary>
/// Get the id of the most recently created log for the given table name for a specific record
/// </summary>
/// <param name="tableName">table name</param>
/// <param name="primaryKey">primary key of record</param>
/// <returns>Log id</returns>
public static int GetLastAuditLogId(ITrackerContext context, string tableName, object primaryKey)
{
string key = primaryKey.ToString();
return(context.AuditLog.Where(x => x.TableName == tableName && x.RecordId == key).OrderByDescending(x => x.AuditLogId).Select(x => x.AuditLogId).FirstOrDefault());
}
public CoreTracker(ITrackerContext context)
{
_context = context;
}
public LogDataMigration(ITrackerContext trackerContext)
{
if(trackerContext == null) throw new ArgumentNullException(nameof(trackerContext));
_trackerContext = trackerContext;
}
public static IEnumerable <DbEntityEntry> GetAdditions(ITrackerContext dbContext)
{
return(dbContext.ChangeTracker.Entries().Where(p => p.State == EntityState.Added).ToList());
}
