EnvelopeGenerator/EnvelopeGenerator.Infrastructure/EGDbContext.cs

using DigitalData.EmailProfilerDispatcher.Abstraction.Entities;
using DigitalData.UserManager.Domain.Entities;
using DigitalData.UserManager.Infrastructure;
using DigitalData.UserManager.Infrastructure.Contracts;
using EnvelopeGenerator.Domain.Entities;
using Microsoft.EntityFrameworkCore;
using Group = DigitalData.UserManager.Domain.Entities.Group;
using Module = DigitalData.UserManager.Domain.Entities.Module;
using DigitalData.EmailProfilerDispatcher;
using Microsoft.Extensions.Options;
using DigitalData.Core.Client;
using Microsoft.Extensions.Logging;
using EnvelopeGenerator.Application.Common.Configurations;

namespace EnvelopeGenerator.Infrastructure;

public class EGDbContext : EGDbContextBase
{
    public EGDbContext(DbContextOptions<EGDbContext> options, IOptions<DbTriggerParams> triggerParamOptions, ILogger<EGDbContext>? logger = null) : base(options, triggerParamOptions, logger)
    {
    }
}

//TODO: Adding EmailOut instead of EmailOut.Abst is not correct for the arch. Re-design EmailPut consedering this. IMailDbContext shoud move to Abstraction layer (hint: in this case using DBSet in abst. will be problem because entity framework will have to be added.
public abstract class EGDbContextBase : DbContext, IUserManagerDbContext, IMailDbContext
{
    public DbSet<Config> Configs { get; set; }

    public DbSet<EnvelopeReceiver> EnvelopeReceivers { get; set; }

    public DbSet<Envelope> Envelopes { get; set; }

    public DbSet<Signature> DocumentReceiverElements { get; set; }

    public DbSet<DocumentStatus> DocumentStatus { get; set; }

    public DbSet<EmailTemplate> EmailTemplate { get; set; }

    public DbSet<Document> EnvelopeDocument { get; set; }

    public DbSet<History> EnvelopeHistories { get; set; }

    public DbSet<EnvelopeType> EnvelopeTypes { get; set; }

    public DbSet<Receiver> Receivers { get; set; }

    public DbSet<GroupOfUser> GroupOfUsers { get; set; }

    public DbSet<Group> Groups { get; set; }

    public DbSet<ModuleOfUser> ModuleOfUsers { get; set; }

    public DbSet<Module> Modules { get; set; }

    public DbSet<User> Users { get; set; }

    public DbSet<UserRep> UserReps { get; set; }

    public DbSet<EmailOut> EMailOuts { get; set; }

    public DbSet<EnvelopeReceiverReadOnly> EnvelopeReceiverReadOnlys { get; set; }

    public DbSet<ClientUser> ClientUsers { get; set; }

    private readonly DbTriggerParams _triggers;

    private readonly ILogger? _logger;

    public bool IsMigration { get; set; } = false;

    public EGDbContextBase(DbContextOptions options, IOptions<DbTriggerParams> triggerParamOptions, ILogger? logger = null) : base(options)
    {
        _triggers = triggerParamOptions.Value;
        _logger = logger;

        Configs = Set<Config>();
        EnvelopeReceivers = Set<EnvelopeReceiver>();
        Envelopes = Set<Envelope>();
        DocumentReceiverElements = Set<Signature>();
        DocumentStatus = Set<DocumentStatus>();
        EnvelopeDocument = Set<Document>();
        EnvelopeHistories = Set<History>();
        EnvelopeTypes = Set<EnvelopeType>();
        Receivers = Set<Receiver>();

        GroupOfUsers = Set<GroupOfUser>();
        Groups = Set<Group>();
        ModuleOfUsers = Set<ModuleOfUser>();
        Modules = Set<Module>();
        Users = Set<User>();
        UserReps = Set<UserRep>();
        EMailOuts = Set<EmailOut>();
        EnvelopeReceiverReadOnlys = Set<EnvelopeReceiverReadOnly>();
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Config>().HasNoKey();

        #region EnvelopeReceiver
        modelBuilder.Entity<EnvelopeReceiver>()
            .HasKey(er => new { er.EnvelopeId, er.ReceiverId });

        modelBuilder.Entity<EnvelopeReceiver>()
            .HasOne(er => er.Envelope)
            .WithMany(e => e.EnvelopeReceivers)
            .HasForeignKey(er => er.EnvelopeId);

        modelBuilder.Entity<EnvelopeReceiver>()
            .HasOne(er => er.Receiver)
            .WithMany(r => r.EnvelopeReceivers)
            .HasForeignKey(er => er.ReceiverId);
        #endregion EnvelopeReceiver

        #region Envelope
        modelBuilder.Entity<Envelope>()
            .HasIndex(e => e.Uuid)
            .IsUnique();

        modelBuilder.Entity<Envelope>()
            .HasMany(e => e.Documents)
            .WithOne()
            .HasForeignKey(ed => ed.EnvelopeId);

        modelBuilder.Entity<Envelope>()
            .HasMany(e => e.Histories)
            .WithOne(h => h.Envelope)
            .HasForeignKey(hist => hist.EnvelopeId);
        #endregion Envelope

        #region Receiver
        modelBuilder.Entity<Receiver>()
            .HasIndex(e => e.Signature)
            .IsUnique();

        modelBuilder.Entity<Receiver>()
            .HasIndex(e => e.EmailAddress)
            .IsUnique();
        #endregion Receiver

        #region EnvelopeDocument
        modelBuilder.Entity<Document>()
            .HasMany(ed => ed.Elements)
            .WithOne(e => e.Document)
            .HasForeignKey(e => e.DocumentId);
        #endregion EnvelopeDocument

        #region DocumentReceiverElement
        modelBuilder.Entity<Signature>()
            .HasOne(dre => dre.Document)
            .WithMany(ed => ed.Elements)
            .HasForeignKey(dre => dre.DocumentId);
        #endregion DocumentReceiverElement

        if (!IsMigration)
        {
            modelBuilder.Entity<History>()
                .HasOne(eh => eh.Receiver)
                .WithMany()
                .HasForeignKey(eh => eh.UserReference)
                .HasPrincipalKey(e => e.EmailAddress);

            modelBuilder.Entity<History>()
                .HasOne(eh => eh.Sender)
                .WithMany()
                .HasForeignKey(eh => eh.UserReference)
                .HasPrincipalKey(e => e.Email);
        }

        #region EnvelopeReceiverReadOnly
        modelBuilder.Entity<EnvelopeReceiverReadOnly>()
            .HasOne(erro => erro.Receiver)
            .WithMany()
            .HasForeignKey(erro => erro.AddedWho)
            .HasPrincipalKey(r => r.EmailAddress);
        #endregion EnvelopeReceiverReadOnly

        #region DocumentStatus
        modelBuilder.Entity<DocumentStatus>()
            .HasOne(ds => ds.Envelope)
            .WithMany()
            .HasForeignKey(ds => ds.EnvelopeId);

        modelBuilder.Entity<DocumentStatus>()
            .HasOne(ds => ds.Receiver)
            .WithMany()
            .HasForeignKey(ds => ds.ReceiverId);
        #endregion DocumentStatus

        #region Trigger
        // Configure entities to handle database triggers
        void AddTrigger<T>() where T : class => _triggers
            .Where(t => t.Key == typeof(T).Name)
            .SelectMany(t => t.Value)
            .ForEach(tName =>
            {
                modelBuilder.Entity<T>().ToTable(tb => tb.HasTrigger(tName));
                _logger?.LogInformation("Trigger '{triggerName}' has been added to the '{entityName}' entity.", tName, typeof(T).Name);
            });

        // TODO: call add trigger methods with attributes and reflection
        AddTrigger<Config>();
        AddTrigger<Signature>();
        AddTrigger<DocumentStatus>();
        AddTrigger<EmailTemplate>();
        AddTrigger<Envelope>();
        AddTrigger<Document>();
        AddTrigger<History>();
        AddTrigger<EnvelopeReceiver>();
        AddTrigger<EnvelopeReceiverReadOnly>();
        AddTrigger<EnvelopeType>();
        AddTrigger<Receiver>();
        AddTrigger<EmailOut>();
        #endregion Trigger

        //configure model builder for user manager tables
        modelBuilder.ConfigureUserManager();

        base.OnModelCreating(modelBuilder);
    }
}