UnivatePropertiesAPI/UnivateProperties_API/Context/DataContext.cs

using Microsoft.EntityFrameworkCore;
using UnivateProperties_API.Model.Communication;
using UnivateProperties_API.Model.Users;
using UnivateProperties_API.Model.Properties;
using UnivateProperties_API.Model.Region;
using UnivateProperties_API.Model.Timeshare;
using System.Linq;
using UnivateProperties_API.Model;
using UnivateProperties_API.Model.Banks;
using UnivateProperties_API.Model.Misc;
using UnivateProperties_API.Model.ProcessFlow;
using UnivateProperties_API.Model.Logging;

namespace UnivateProperties_API.Context
{
    public class DataContext : DbContext
    {
        public DataContext(DbContextOptions<DataContext> options) : base(options)
        {

        }

        #region User
        public virtual DbSet<Agency> Agencies { get; set; }
        public virtual DbSet<Agent> Agents { get; set; }
        public virtual DbSet<User> Users { get; set; }
        public virtual DbSet<Individual> Individuals { get; set; }
        public virtual DbSet<Address> Addresses { get; set; }
        #endregion User

        #region Communication
        public virtual DbSet<Email> Emails { get; set; }
        public virtual DbSet<SMTPAccount> Accounts { get; set; }
        public virtual DbSet<SMTPHost> Hosts { get; set; }
        #endregion Communication

        #region Property
        public DbSet<Property> Properties { get; set; }
        public DbSet<PropertyImage> PropertyImages { get; set; }
        public DbSet<PropertyType> PropertyTypes { get; set; }
        public DbSet<PropertyUserField> PropertyUserFields { get; set; }
        public DbSet<UserDefinedField> UserDefinedFields { get; set; }
        public DbSet<UserDefinedGroup> UserDefinedGroups { get; set; }
        #endregion

        #region Region 
        public DbSet<Province> Provinces { get; set; }
        public DbSet<City> Cities { get; set; }
        public DbSet<Suburb> Suburbs { get; set; }
        #endregion

        #region Timeshare
        public DbSet<TimeshareWeek> Weeks { get; set; }
        public DbSet<Status> Status { get; set; }
        public DbSet<UnitConfiguration> UnitConfigurations { get; set; }
        public DbSet<UnitConfigurationType> UnitConfigurationTypes { get; set; }
        public DbSet<Season> Seasons { get; set; }
        public DbSet<Bank> Banks { get; set; }
        public DbSet<BankAccount> BankAccounts { get; set; }
        #endregion Timeshare

        #region ProcessFlow
        public DbSet<ProcessFlow> ProcessFlows { get; set; }
        public DbSet<BidItem> BidItems { get; set; }
        #endregion

        #region Logs
        public DbSet<SearchLog> SearchLogs { get; set; }
        #endregion

        #region Misc
        public DbSet<Location> Location { get; set; }
        #endregion

        public override int SaveChanges()
        {
            foreach (var item in ChangeTracker
                                    .Entries()
                                    .Where(x => x.State == EntityState.Modified || x.State == EntityState.Added)
                                    .Select(x => x.Entity)
                                    .ToList())
            {
                if (item is BaseEntity)
                {
                    (item as BaseEntity).UpdateModified(string.Empty);
                }
            }
            UpdateSoftDeleteStatuses();
            return base.SaveChanges();
        }

        private void UpdateSoftDeleteStatuses()
        {
            foreach (var entry in ChangeTracker.Entries())
            {
                switch (entry.State)
                {
                    case EntityState.Added:
                        entry.CurrentValues["IsDeleted"] = false;
                        break;
                    case EntityState.Deleted:
                        entry.State = EntityState.Modified;
                        entry.CurrentValues["IsDeleted"] = true;
                        break;
                }
            }
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<SMTPHost>().ToTable("Hosts");
            modelBuilder.Entity<UnitConfiguration>()
                .HasIndex(u => u.Code)
                .IsUnique();
            modelBuilder.Entity<Individual>(b =>
            {
                b.HasKey(e => e.Id);
                b.Property(e => e.Id).ValueGeneratedOnAdd();
            });
            modelBuilder.Entity<Individual>()
            .HasIndex(i => new { i.Telephone, i.CellNumber, i.Email })
            .IsUnique(true);
            modelBuilder.Entity<Agent>(b =>
            {
                b.HasKey(e => e.Id);
                b.Property(e => e.Id).ValueGeneratedOnAdd();
            });
            modelBuilder.Entity<Agency>(b =>
            {
                b.HasKey(e => e.Id);
                b.Property(e => e.Id).ValueGeneratedOnAdd();
            });
            modelBuilder.Entity<Person>(b =>
            {
                b.HasKey(e => e.Id);
                b.Property(e => e.Id).ValueGeneratedOnAdd();
            });
            modelBuilder.Entity<User>()
            .HasIndex(u => u.Username)
            .IsUnique(true);
            modelBuilder.Entity<Email>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<SMTPAccount>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<SMTPHost>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<Property>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<PropertyImage>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<PropertyType>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<PropertyUserField>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<UserDefinedField>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<UserDefinedGroup>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<City>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<Province>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<Suburb>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<Season>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<Status>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<TimeshareWeek>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<UnitConfiguration>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<UnitConfigurationType>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<Agency>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<Person>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<User>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<Bank>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<BankAccount>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<SearchLog>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<Address>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<BidItem>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
            modelBuilder.Entity<ProcessFlow>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
        }
    }
}