Audit & Compliance

/// <summary>
/// Represents a single audit log entry in the database.
/// Captures WHO did WHAT to WHICH entity, WHEN, and from WHERE.
/// </summary>
public class AuditLog : AuditableEntity
{
    public string EventType { get; set; } = string.Empty;
    public string? HttpMethod { get; set; }
    public string? Endpoint { get; set; }
    public string? EntityType { get; set; }
    public string? EntityId { get; set; }
    public string? OldValues { get; set; }
    public string? NewValues { get; set; }
    public string? ChangedProperties { get; set; }
    public Guid? UserId { get; set; }
    public Guid? TenantId { get; set; }
    public string? Username { get; set; }
    public bool IsAdmin { get; set; }
    public string? IpAddress { get; set; }
    public string? UserAgent { get; set; }
    public string? CorrelationId { get; set; }
    public int? StatusCode { get; set; }
    public long? DurationMs { get; set; }
    public bool IsSuccess { get; set; } = true;
    public string? ErrorMessage { get; set; }
    public DateTime Timestamp { get; set; } = DateTime.UtcNow;
    public string? Metadata { get; set; }
    public string? ModuleTag { get; set; }
}

/// <summary>
/// EF Core interceptor that captures entity changes before SaveChanges.
/// Handles standard CRUD mutations, Soft Deletes, and prevents infinite recursion.
/// </summary>
public class AuditableEntityInterceptor : SaveChangesInterceptor
{
    private readonly IAuditService _auditService;

    public override async ValueTask<InterceptionResult<int>> SavingChangesAsync(
        DbContextEventData eventData, InterceptionResult<int> result, CancellationToken ct)
    {
        var context = eventData.Context;
        if (context == null) return await base.SavingChangesAsync(eventData, result, ct);

        // 1. Intercept Soft Delete BEFORE state is modified by BaseDbContext
        var softDeleteEntries = context.ChangeTracker.Entries<ISoftDeletable>()
            .Where(e => e.State == EntityState.Deleted)
            .ToList();

        foreach (var entry in softDeleteEntries)
        {
            await _auditService.LogEntityChangeAsync(
                AuditEventTypes.Delete,
                entry.Entity.GetType().Name,
                GetEntityId(entry.Entity),
                "Soft Deleted",
                null,
                "IsDeleted",
                ct
            );
        }

        // 2. Intercept Standard CRUD mutations
        foreach (var entry in context.ChangeTracker.Entries())
        {
            if (entry.Entity is AuditLog) // Prevent infinite recursion StackOverflow
                continue;

            if (entry.State == EntityState.Unchanged || entry.State == EntityState.Detached)
                continue;

            string eventType = entry.State switch
            {
                EntityState.Added => AuditEventTypes.Create,
                EntityState.Modified => AuditEventTypes.Update,
                EntityState.Deleted => AuditEventTypes.Delete,
                _ => "Unknown"
            };

            var oldValues = new Dictionary<string, object?>();
            var newValues = new Dictionary<string, object?>();
            var changedProps = new List<string>();

            foreach (var prop in entry.Properties)
            {
                if (prop.Metadata.IsPrimaryKey()) continue;

                if (entry.State == EntityState.Added)
                {
                    newValues[prop.Metadata.Name] = prop.CurrentValue;
                }
                else if (entry.State == EntityState.Modified && prop.IsModified)
                {
                    var original = entry.OriginalValues[prop.Metadata.Name];
                    var current = prop.CurrentValue;
                    if (!Equals(original, current))
                    {
                        oldValues[prop.Metadata.Name] = original;
                        newValues[prop.Metadata.Name] = current;
                        changedProps.Add(prop.Metadata.Name);
                    }
                }
                else if (entry.State == EntityState.Deleted)
                {
                    oldValues[prop.Metadata.Name] = entry.OriginalValues[prop.Metadata.Name];
                }
            }

            if (entry.State == EntityState.Modified && !changedProps.Any())
                continue; // Skip if no properties changed

            await _auditService.LogEntityChangeAsync(
                eventType,
                entry.Entity.GetType().Name,
                GetEntityId(entry.Entity),
                entry.State.ToString(),
                Serialize(oldValues),
                Serialize(newValues),
                ct
            );
        }

        return await base.SavingChangesAsync(eventData, result, ct);
    }
}

public interface IExportService
{
    Task<byte[]> ExportAsync<T>(
        IEnumerable<T> data,
        ExportOptions options,
        CancellationToken ct = default);
}

public class ExportOptions
{
    public string Title { get; set; } = "Export";
    public string[] Columns { get; set; } = Array.Empty<string>();
    public string DateFormat { get; set; } = "yyyy-MM-dd HH:mm:ss";
    public bool IncludeHeaders { get; set; } = true;
    public string? WatermarkText { get; set; }     // PDF only
    public string? BrandingLogoPath { get; set; }   // PDF only
}

GET /api/v1/audit?
  userId=a1b2c3d4...
  &action=Modified
  &entityName=Admin
  &from=2026-01-01T00:00:00Z
  &to=2026-02-20T23:59:59Z
  &search=password
  &page=1
  &pageSize=25
  &sortBy=timestamp
  &sortDirection=desc