DbContext/CrossCheckDb.cs - master - AstroJohn/MailRobot

DbContext/CrossCheckDb.cs
375 строк13 KB
AstroJohn
куча всего
18 фев 2025, 17:13
18 фев 2025, 17:1376b62c6
using System;
using System.Data.Entity;
using System.Data.Entity.Core.Mapping;
using System.Data.Entity.Core.Metadata.Edm;
using System.Data.Entity.Infrastructure;
using System.Linq;
using DbContext.Mapping;
using DbContext.Models;

namespace DbContext
{
    public class CrossCheckDb : System.Data.Entity.DbContext
    {

        public CrossCheckDb(string connectionString)
        {
            Database.SetInitializer<CrossCheckDb>(null);
            Database.Connection.ConnectionString = connectionString;
        }

        public virtual DbSet<Bands> Bands { get; set; }
        public virtual DbSet<Category> Category { get; set; }
        public virtual DbSet<CategoryBands> CategoryBands { get; set; }
        public virtual DbSet<CategoryHierarchy> CategoryHierarchy { get; set; }
        public virtual DbSet<Errors> Errors { get; set; }
        public virtual DbSet<HfResults> HfResults { get; set; }
        public virtual DbSet<VhfResults> VhfResults { get; set; }
        public virtual DbSet<LogFiles> LogFiles { get; set; }
        public virtual DbSet<LogFilesBandResults> LogFilesBandResults { get; set; }
        public virtual DbSet<LogFilesBandResultsMults> LogFilesBandResultsMults { get; set; }
        public virtual DbSet<LogFilesChangeCategory> LogFilesChangeCategory { get; set; }
        public virtual DbSet<LogFilesAudio> LogFilesAudio { get; set; }
        public virtual DbSet<LogFilesCategory> LogFilesCategory { get; set; }
        public virtual DbSet<LogFilesCategoryReplace> LogFilesCategoryReplace { get; set; }
        public virtual DbSet<Modes> Modes { get; set; }
        public virtual DbSet<Qsos> QSOs { get; set; }
        public virtual DbSet<Swls> SWLs { get; set; }
        public virtual DbSet<QsosBadErrors> QSOsBadErrors { get; set; }
        public virtual DbSet<QsosDsq> QSOsDSQ { get; set; }
        public virtual DbSet<QsosMults> QSOsMults { get; set; }
        public virtual DbSet<QsosPoints> QSOsPoints { get; set; }
        public virtual DbSet<QsosSystemErrors> QSOsSystemErrors { get; set; }
        public virtual DbSet<Ranks> Ranks { get; set; }
        public virtual DbSet<Settings> Settings { get; set; }
        public virtual DbSet<SuperCategory> SuperCategory { get; set; }
        public virtual DbSet<SuperCategoryCallsigns> SuperCategoryCallsigns { get; set; }
        public virtual DbSet<SuperCategoryCountry> SuperCategoryCountry { get; set; }
        public virtual DbSet<VhfActivityDates> VhfActivityDates { get; set; }
        public virtual DbSet<Operators> Operators { get; set; }
        public virtual DbSet<Operators2> Operators2 { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Operators>();

            modelBuilder.Entity<Operators2>();

            modelBuilder.Entity<LogFilesCategoryReplace>();

            modelBuilder.Entity<VhfActivityDates>();

            modelBuilder.Entity<QsosBadErrors>();

            modelBuilder.Entity<QsosDsq>();

            modelBuilder.Entity<QsosMults>();
            
            modelBuilder.Entity<QsosPoints>();

            modelBuilder.Entity<QsosSystemErrors>();

            modelBuilder.Entity<SuperCategoryCallsigns>();

            modelBuilder.Entity<SuperCategoryCountry>();

            modelBuilder.Entity<QsosMults>();

            modelBuilder.Entity<HfResults>();

            modelBuilder.Entity<VhfResults>();

            modelBuilder.Entity<LogFilesChangeCategory>();

            modelBuilder.Entity<LogFilesBandResults>();

            modelBuilder.Entity<LogFilesBandResultsMults>();

            /*
            modelBuilder.Entity<Bands>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<Bands>()
                .Property(e => e.BandMid)
                .IsUnicode(false);

            modelBuilder.Entity<Bands>()
                .HasMany(e => e.Category)
                .WithOptional(e => e.Bands)
                .HasForeignKey(e => e.Band);

            modelBuilder.Entity<Bands>()
                .HasMany(e => e.CategoryBands)
                .WithOptional(e => e.Bands)
                .HasForeignKey(e => e.Band);

            modelBuilder.Entity<Category>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<Category>()
                .HasMany(e => e.CategoryBands)
                .WithOptional(e => e.Category)
                .HasForeignKey(e => e.CategoryId);

            modelBuilder.Entity<Category>()
                .HasMany(e => e.CategoryHierarchy)
                .WithRequired(e => e.Category)
                .HasForeignKey(e => e.CategoryId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Qsos>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<Qsos>()
                .Property(e => e.ErrType)
                .IsUnicode(false);

            modelBuilder.Entity<Qsos>()
                .Property(e => e.ErrPar)
                .IsUnicode(false);

            modelBuilder.Entity<Qsos>()
                .Property(e => e.CountryId)
                .IsUnicode(false);

            modelBuilder.Entity<Qsos>()
                .Property(e => e.RegionId)
                .IsUnicode(false);

            modelBuilder.Entity<Qsos>()
                .Property(e => e.DistrictId)
                .IsUnicode(false);

            modelBuilder.Entity<Qsos>()
                .HasMany(e => e.QsoMults)
                .WithRequired(e => e.Qso)
                .HasForeignKey(e => e.QsoId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Qsos>()
                .HasOptional(e => e.Qso2Way)
                .WithMany()
                .HasForeignKey(e => e.Id2)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Qsos>()
                .HasMany(e => e.QsoPoints)
                .WithRequired(e => e.Qso)
                .HasForeignKey(e => e.QsoId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<LogFiles>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<LogFiles>()
                .Property(e => e.Location)
                .IsUnicode(false);

            modelBuilder.Entity<LogFiles>()
                .Property(e => e.Email)
                .IsUnicode(false);

            modelBuilder.Entity<Swls>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<Swls>()
                .Property(e => e.ErrType)
                .IsUnicode(false);

            modelBuilder.Entity<Swls>()
                .Property(e => e.ErrPar)
                .IsUnicode(false);

            modelBuilder.Entity<Swls>()
                .Property(e => e.CountryId1)
                .IsUnicode(false);

            modelBuilder.Entity<Swls>()
                .Property(e => e.RegionId1)
                .IsUnicode(false);

            modelBuilder.Entity<Swls>()
                .Property(e => e.CountryId2)
                .IsUnicode(false);

            modelBuilder.Entity<Swls>()
                .Property(e => e.RegionId2)
                .IsUnicode(false);
            */

            modelBuilder.Configurations.Add(new BandsMapping());

            modelBuilder.Configurations.Add(new CategoryMapping());

            modelBuilder.Configurations.Add(new QsosMapping());

            modelBuilder.Configurations.Add(new LogFilesMapping());

            modelBuilder.Configurations.Add(new LogFilesBandResultsMapping());

            modelBuilder.Configurations.Add(new SwlsMapping());

            modelBuilder.Configurations.Add(new HfResultsMapping());

            modelBuilder.Configurations.Add(new VhfResultsMapping());

            modelBuilder.Entity<LogFilesChangeCategory>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<LogFilesChangeCategory>()
                .Property(e => e.Call)
                .IsUnicode(false);

            modelBuilder.Entity<LogFilesChangeCategory>()
                .Property(e => e.Category)
                .IsUnicode(false);

            modelBuilder.Entity<LogFilesChangeCategory>()
                .Property(e => e.NewCategory)
                .IsUnicode(false);


            modelBuilder.Entity<LogFilesAudio>()
                .HasKey(e => e.Call);

            modelBuilder.Entity<LogFilesAudio>()
                .Property(e => e.Call)
                .IsUnicode(false);


            modelBuilder.Entity<LogFilesCategory>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<LogFilesCategory>()
                .Property(e => e.Location)
                .IsUnicode(false);


            modelBuilder.Entity<Modes>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<Modes>()
                .HasMany(e => e.Category)
                .WithOptional(e => e.Modes)
                .HasForeignKey(e => e.Mode);

            modelBuilder.Entity<Modes>()
                .HasMany(e => e.LogFilesBandResultsMults)
                .WithRequired(e => e.Mode)
                .HasForeignKey(e => e.ModeId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Modes>()
                .HasMany(e => e.SuperCategory)
                .WithOptional(e => e.Modes)
                .HasForeignKey(e => e.Mode);


            modelBuilder.Entity<QsosMults>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<QsosMults>()
                .Property(e => e.Category)
                .IsUnicode(false);

            modelBuilder.Entity<QsosMults>()
                .Property(e => e.Mult)
                .IsUnicode(false);


            modelBuilder.Entity<Ranks>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<Ranks>()
                .Property(e => e.Rank)
                .IsUnicode(false);


            modelBuilder.Entity<Settings>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<Settings>()
                .Property(e => e.Name)
                .IsUnicode(false);


            modelBuilder.Entity<SuperCategory>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<SuperCategory>()
                .Property(e => e.Name)
                .IsUnicode(false);

            modelBuilder.Entity<SuperCategory>()
                .HasMany(e => e.CategoryHierarchy)
                .WithRequired(e => e.SuperCategory)
                .HasForeignKey(e => e.SuperCategoryId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<SuperCategory>()
                .HasMany(e => e.SuperCategoryCountry)
                .WithRequired(e => e.SuperCategory)
                .HasForeignKey(e => e.SuperCategoryId)
                .WillCascadeOnDelete(false);


            modelBuilder.Entity<SuperCategoryCallsigns>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<SuperCategoryCallsigns>()
                .Property(e => e.Callsign)
                .IsUnicode(false);


            modelBuilder.Entity<SuperCategoryCountry>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<SuperCategoryCountry>()
                .Property(e => e.CountryId)
                .IsUnicode(false);

            modelBuilder.Entity<SuperCategoryCountry>()
                .Property(e => e.RegionId)
                .IsUnicode(false);


            modelBuilder.Entity<CategoryHierarchy>()
                .HasKey(e => e.Id);

        }

        public string GetTableName(Type type)
        {
            var metadata             = ((IObjectContextAdapter)this).ObjectContext.MetadataWorkspace;
            var objectItemCollection = ((ObjectItemCollection)metadata.GetItemCollection(DataSpace.OSpace));
            var entityType           = metadata.GetItems<EntityType>(DataSpace.OSpace).Single(e => objectItemCollection.GetClrType(e) == type);
            var entitySet            = metadata.GetItems(DataSpace.CSpace).Where(x => x.BuiltInTypeKind == BuiltInTypeKind.EntityType).Cast<EntityType>().Single(x => x.Name == entityType.Name);
            var entitySetMappings    = metadata.GetItems<EntityContainerMapping>(DataSpace.CSSpace).Single().EntitySetMappings.ToList();

            EntitySet table;

            var mapping = entitySetMappings.SingleOrDefault(x => x.EntitySet.Name == entitySet.Name);
            if (mapping != null)
            {
                table = mapping.EntityTypeMappings.Single().Fragments.Single().StoreEntitySet;
            }
            else
            {
                mapping = entitySetMappings.SingleOrDefault(x => x.EntityTypeMappings.Where(y => y.EntityType != null).Any(y => y.EntityType.Name == entitySet.Name));

                if (mapping != null)
                {
                    table = mapping.EntityTypeMappings.Where(x => x.EntityType != null).Single(x => x.EntityType.Name == entityType.Name).Fragments.Single().StoreEntitySet;
                }
                else
                {
                    var entitySetMapping = entitySetMappings.Single(x => x.EntityTypeMappings.Any(y => y.IsOfEntityTypes.Any(z => z.Name == entitySet.Name)));
                    table = entitySetMapping.EntityTypeMappings.First(x => x.IsOfEntityTypes.Any(y => y.Name == entitySet.Name)).Fragments.Single().StoreEntitySet;
                }
            }

            return (string)table.MetadataProperties["Table"].Value ?? table.Name;
        }

    }
}