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;

namespace EnvelopeGenerator.Infrastructure
{
    //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 class EGDbContext : DbContext, IUserManagerDbContext, IMailDbContext
    {
        public DbSet<UserReceiver> UserReceivers { get; set; }

        public DbSet<Config> Configs { get; set; }

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

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

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

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

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

        public DbSet<EnvelopeCertificate> EnvelopeCertificates { get; set; }

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

        public DbSet<EnvelopeHistory> 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 EGDbContext(DbContextOptions<EGDbContext> options) : base(options)
        {
            UserReceivers = Set<UserReceiver>();
            Configs = Set<Config>();
            EnvelopeReceivers = Set<EnvelopeReceiver>();
            Envelopes = Set<Envelope>();
            DocumentReceiverElements = Set<DocumentReceiverElement>();
            DocumentStatus = Set<DocumentStatus>();
            EnvelopeCertificates = Set<EnvelopeCertificate>();
            EnvelopeDocument = Set<EnvelopeDocument>();
            EnvelopeHistories = Set<EnvelopeHistory>();
            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>();
        }

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

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

            modelBuilder.Entity<EnvelopeDocument>();
            modelBuilder.Entity<DocumentReceiverElement>();
            modelBuilder.Entity<DocumentStatus>();
            modelBuilder.Entity<EmailTemplate>();
            modelBuilder.Entity<Envelope>();
            modelBuilder.Entity<EnvelopeCertificate>();
            modelBuilder.Entity<EnvelopeHistory>();
            modelBuilder.Entity<EnvelopeType>();
            modelBuilder.Entity<Receiver>();
            modelBuilder.Entity<UserReceiver>();
            modelBuilder.Entity<EmailOut>();

            // Configure the one-to-many relationship of Envelope
            modelBuilder.Entity<Envelope>()
                .HasMany(e => e.Documents)
                .WithOne()
                .HasForeignKey(ed => ed.EnvelopeId);

            modelBuilder.Entity<Envelope>()
                .HasMany(e => e.History)
                .WithOne()
                .HasForeignKey(eh => eh.EnvelopeId);

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

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

            modelBuilder.Entity<EnvelopeHistory>()
                .HasOne(eh => eh.Receiver)
                .WithMany()
                .HasForeignKey(eh => eh.UserReference)
                .HasPrincipalKey(e => e.EmailAddress);

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

            // Configure entities to handle database triggers
            modelBuilder.Entity<Envelope>().ToTable(tb => tb.HasTrigger("TBSIG_ENVELOPE_HISTORY_AFT_INS"));
            modelBuilder.Entity<EnvelopeHistory>().ToTable(tb => tb.HasTrigger("TBSIG_ENVELOPE_HISTORY_AFT_INS"));
            modelBuilder.Entity<EmailOut>().ToTable(tb => tb.HasTrigger("TBEMLP_EMAIL_OUT_AFT_INS"));
            modelBuilder.Entity<EmailOut>().ToTable(tb => tb.HasTrigger("TBEMLP_EMAIL_OUT_AFT_UPD"));
            
            //configure model builder for user manager tables
            modelBuilder.ConfigureUserManager();

            base.OnModelCreating(modelBuilder);
        }
    }
}