Round #217

Add auditing via SaveChanges override that captures before/after state

To add auditing via `SaveChanges` override in Entity Framework Core, you can capture the before and after state of entities by overriding the `SaveChanges` and `SaveChangesAsync` methods in your DbContext class. Here's an example implementation: ```csharp using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; public class MyDbContext : DbContext { public override int SaveChanges() { var entries = ChangeTracker.Entries() .Where(e => e.Entity != null && (e.State == EntityState.Added || e.State == EntityState.Modified || e.State == EntityState.Deleted)); foreach (var entry in entries) { if (entry.State == EntityState.Added) { // Capture before state (null for added entities) var beforeState = new Dictionary<string, object>(); var afterState = new Dictionary<string, object>(); foreach (var property in entry.Properties) { afterState.Add(property.Name, property.CurrentValue); } // Save audit log SaveAuditLog(entry.Entity, beforeState, afterState, "INSERT"); } else if (entry.State == EntityState.Modified) { // Capture before and after state var beforeState = new Dictionary<string, object>(); var afterState = new Dictionary<string, object>(); foreach (var property in entry.Properties) { if (property.IsModified) { beforeState.Add(property.Name, property.OriginalValue); afterState.Add(property.Name, property.CurrentValue); } } // Save audit log SaveAuditLog(entry.Entity, beforeState, afterState, "UPDATE"); } else if (entry.State == EntityState.Deleted) { // Capture before state (current state for deleted entities) var beforeState = new Dictionary<string, object>(); var afterState = new Dictionary<string, object>(); foreach (var property in entry.Properties) { beforeState.Add(property.Name, property.CurrentValue); } // Save audit log SaveAuditLog(entry.Entity, beforeState, afterState, "DELETE"); } } return base.SaveChanges(); } public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default) { var entries = ChangeTracker.Entries() .Where(e => e.Entity != null && (e.State == EntityState.Added || e.State == EntityState.Modified || e.State == EntityState.Deleted)); foreach (var entry in entries) { if (entry.State == EntityState.Added) { // Capture before state (null for added entities) var beforeState = new Dictionary<string, object>(); var afterState = new Dictionary<string, object>(); foreach (var property in entry.Properties) { afterState.Add(property.Name, property.CurrentValue); } // Save audit log await SaveAuditLogAsync(entry.Entity, beforeState, afterState, "INSERT"); } else if (entry.State == EntityState.Modified) { // Capture before and after state var beforeState = new Dictionary<string, object>(); var afterState = new Dictionary<string, object>(); foreach (var property in entry.Properties) { if (property.IsModified) { beforeState.Add(property.Name, property.OriginalValue); afterState.Add(property.Name, property.CurrentValue); } } // Save audit log await SaveAuditLogAsync(entry.Entity, beforeState, afterState, "UPDATE"); } else if (entry.State == EntityState.Deleted) { // Capture before state (current state for deleted entities) var beforeState = new Dictionary<string, object>(); var afterState = new Dictionary<string, object>(); foreach (var property in entry.Properties) { beforeState.Add(property.Name, property.CurrentValue); } // Save audit log await SaveAuditLogAsync(entry.Entity, beforeState, afterState, "DELETE"); } } return await base.SaveChangesAsync(cancellationToken); } private void SaveAuditLog(object entity, Dictionary<string, object> beforeState, Dictionary<string, object> afterState, string operation) { // Implement your audit log saving logic here // For example, you can save the audit log to a database table var auditLog = new AuditLog { EntityName = entity.GetType().Name, EntityId = entity.GetHashCode(), Operation = operation, BeforeState = beforeState, AfterState = afterState, Timestamp = DateTime.Now }; // Save the audit log to the database AuditLogs.Add(auditLog); base.SaveChanges(); } private async Task SaveAuditLogAsync(object entity, Dictionary<string, object> beforeState, Dictionary<string, object> afterState, string operation) { // Implement your audit log saving logic here // For example,

```csharp using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; // Define an audit log entity public class AuditLog { public int Id { get; set; } public string TableName { get; set; } public string EntityId { get; set; } public string EntityType { get; set; } public string ChangedBy { get; set; } public DateTime ChangedDate { get; set; } public string ChangeType { get; set; } public string OriginalValues { get; set; } public string NewValues { get; set; } } // Define the DbContext with auditing public class AuditingDbContext : DbContext { public DbSet<AuditLog> AuditLogs { get; set; } public AuditingDbContext(DbContextOptions<AuditingDbContext> options) : base(options) { } public override async Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default) { var auditEntries = OnBeforeSaveChanges(); var result = await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken); await OnAfterSaveChanges(auditEntries); return result; } public override int SaveChanges(bool acceptAllChangesOnSuccess) { var auditEntries = OnBeforeSaveChanges(); var result = base.SaveChanges(acceptAllChangesOnSuccess); OnAfterSaveChanges(auditEntries); return result; } private List<Dictionary<string, object>> OnBeforeSaveChanges() { var auditEntries = new List<Dictionary<string, object>>(); foreach (var entry in ChangeTracker.Entries().Where(e => e.State == EntityState.Added || e.State == EntityState.Modified || e.State == EntityState.Deleted)) { var auditEntry = new Dictionary<string, object> { { "EntityName", entry.Entity.GetType().Name }, { "EntityId", entry.Entity }, { "ChangeType", entry.State.ToString() }, { "OriginalValues", entry.OriginalValues }, { "NewValues", entry.CurrentValues } }; auditEntries.Add(auditEntry); } return auditEntries; } private async Task OnAfterSaveChanges(List<Dictionary<string, object>> auditEntries) { foreach (var auditEntry in auditEntries) { var auditLog = new AuditLog { TableName = ((string)auditEntry["EntityName"]).ToLower(), EntityId = auditEntry["EntityId"].ToString(), EntityType = (string)auditEntry["EntityName"], ChangedBy = "System", // Replace with the actual user ChangedDate = DateTime.Now, ChangeType = (string)auditEntry["ChangeType"], OriginalValues = auditEntry["OriginalValues"].ToString(), NewValues = auditEntry["NewValues"].ToString() }; AuditLogs.Add(auditLog); } await SaveChangesAsync(); } } // Example usage public class Program { public static async Task Main(string[] args) { var options = new DbContextOptionsBuilder<AuditingDbContext>() .UseInMemoryDatabase(databaseName: "AuditingDbContext") .Options; using var context = new AuditingDbContext(options); context.Database.EnsureCreated(); var entity = new MyEntity { Name = "Test" }; context.MyEntities.Add(entity); await context.SaveChangesAsync(); var auditLogs = await context.AuditLogs.ToListAsync(); foreach (var auditLog in auditLogs) { Console.WriteLine($"Table: {auditLog.TableName}, EntityId: {auditLog.EntityId}, ChangeType: {auditLog.ChangeType}"); } } } public class MyEntity { public int Id { get; set; } public string Name { get; set; } } public class MyEntityConfiguration : IEntityTypeConfiguration<MyEntity> { public void Configure(EntityTypeBuilder<MyEntity> builder) { builder.ToTable("myentities"); builder.HasKey(e => e.Id); builder.Property(e => e.Name).IsRequired(); } } ``` This implementation provides a basic auditing mechanism by overriding the `SaveChanges` and `SaveChangesAsync` methods in the `DbContext`. It captures the before and after state of entities and logs the changes to an `AuditLog` entity. Here's a step-by-step explanation: 1. **Define the `AuditLog` entity**: This entity represents a single audit log entry, containing information about the changed entity, the type of change, and the original and new values. 2. **Create the `AuditingDbContext` class**: This class inherits from `DbContext` and overrides the `SaveChanges` and `SaveChangesAsync` methods to implement auditing. 3. **Implement `OnBeforeSaveChanges`**: This method is called before saving changes to the database. It iterates over the changed