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)); }
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()); }