Warhammer/Dotnet/DataLayer/DeathwatchDbContext.cs

using Domain;
using Domain.Weapons;
using Domain.XML_Model;
using Microsoft.EntityFrameworkCore;

namespace DataLayer;

public class DeathwatchDbContext : DbContext
{
    public DbSet<Player> Players { get; set; }
    public DbSet<Weapon> Weapons { get; set; }
    public DbSet<Extension> Extensions { get; set; }
    public DbSet<Accessoire> Accessoires { get; set; }
    public DbSet<Root> Roots { get; set; }
    public DbSet<Extension> Extension { get; set; }
    public DbSet<Competence> Competences { get; set; }
    public DbSet<Amélioration> Améliorations { get; set; }
    public DbSet<Archétype> Archétypes { get; set; }
    public DbSet<Arme> Armes { get; set; }
    public DbSet<Armure> Armures { get; set; }
    public DbSet<Assermentation> Assermentations { get; set; }
    public DbSet<Attribut> Attributs { get; set; }
    public DbSet<Carrière> Carrières { get; set; }
    public DbSet<Coordonnée> Coordonnées { get; set; }
    public DbSet<Cybernétique> Cybernétiques { get; set; }
    public DbSet<Discipline> Disciplines { get; set; }
    public DbSet<Divination> Divinations { get; set; }
    public DbSet<Equipement> Equipements { get; set; }
    public DbSet<Implant> Implants { get; set; }
    public DbSet<Monde> Mondes { get; set; }
    public DbSet<Mutation> Mutations { get; set; }
    public DbSet<Pouvoir> Pouvoirs { get; set; }
    public DbSet<Promote> Promotions { get; set; }
    public DbSet<Seuil> Seuils { get; set; }
    public DbSet<Sousmonde> Sousmondes { get; set; }
    public DbSet<Talent> Talents { get; set; }
    public DbSet<Trait> Traits { get; set; }
    public DbSet<Trouble> Troubles { get; set; }
    public DbSet<TypeMonde> TypeMondes { get; set; }
    public DbSet<TypeName> TypesNom { get; set; }
    //public DbSet<AccessoiresArmes> AllAccessoiresArmes { get; set; }
    //public DbSet<Améliorations> AllAméliorations { get; set; }
    //public DbSet<Archétypes> AllArchétypes { get; set; }
    //public DbSet<Armes> AllArmes { get; set; }
    //public DbSet<Armures> AllArmures { get; set; }
    //public DbSet<Assermentations> AllAssermentations { get; set; }
    //public DbSet<AttributsArmes> AllAttributsArmes { get; set; }
    //public DbSet<Carrières> AllCarrières { get; set; }
    //public DbSet<Competences> AllCompetences { get; set; }
    //public DbSet<Coordonnées> AllCoordonnées { get; set; }
    //public DbSet<Cybernétiques> AllCybernétiques { get; set; }
    //public DbSet<Disciplines> AllDisciplines { get; set; }
    //public DbSet<Divinations> AllDivinations { get; set; }
    //public DbSet<Equipements> AllEquipements { get; set; }
    //public DbSet<Implants> AllImplants { get; set; }
    //public DbSet<Mondes> AllMondes { get; set; }
    //public DbSet<Mutations> AllMutations { get; set; }
    //public DbSet<Pouvoirs> AllPouvoirs { get; set; }
    //public DbSet<Promotions> AllPromotions { get; set; }
    //public DbSet<SeuilsXp> AllSeuilsXp { get; set; }
    //public DbSet<Sousmondes> AllSousmondes { get; set; }
    //public DbSet<Talents> AllTalents { get; set; }
    //public DbSet<Traits> AllTraits { get; set; }
    //public DbSet<Troubles> AllTroubles { get; set; }
    //public DbSet<TypeMondes> AllTypeMondes { get; set; }
    //public DbSet<TypesNom> AllTypesNom { get; set; }


    public DeathwatchDbContext() : base()
    {
    }

    public DeathwatchDbContext(DbContextOptions<DeathwatchDbContext> options) : base(options)
    {
    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        if (!optionsBuilder.IsConfigured)
        {
            //optionsBuilder.UseSqlServer("Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=ReadersDB");
        }
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Player and Weapon relationship
        modelBuilder.Entity<Player>()
            .HasMany(p => p.Weapons)
            .WithMany(w => w.Players)
            .UsingEntity(j => j.ToTable("PlayerWeapons"));

        //// Extension table configuration
        //modelBuilder.Entity<Extension>().ToTable("Extensions");

        //// Accessoire table configuration
        //modelBuilder.Entity<Accessoire>().ToTable("Accessoires");

        //// Amelioration table configuration
        //modelBuilder.Entity<Amelioration>().ToTable("Ameliorations");

        // Additional configurations for XML Model classes

        modelBuilder.Entity<Extension>().ToTable("Extensions");
        modelBuilder.Entity<Accessoire>().ToTable("Accessoires");
        modelBuilder.Entity<Amélioration>().ToTable("Améliorations");
        modelBuilder.Entity<Archétype>().ToTable("Archétypes");
        modelBuilder.Entity<Arme>().ToTable("Armes");
        modelBuilder.Entity<Armure>().ToTable("Armures");
        modelBuilder.Entity<Assermentation>().ToTable("Assermentations");
        modelBuilder.Entity<Attribut>().ToTable("Attributs");
        modelBuilder.Entity<Carrière>().ToTable("Carrières");
        modelBuilder.Entity<Competence>().ToTable("Competences");
        modelBuilder.Entity<Coordonnée>().ToTable("Coordonnées");
        modelBuilder.Entity<Cybernétique>().ToTable("Cybernétiques");
        modelBuilder.Entity<Discipline>().ToTable("Disciplines");
        modelBuilder.Entity<Divination>().ToTable("Divinations");
        modelBuilder.Entity<Equipement>().ToTable("Equipements");
        modelBuilder.Entity<Implant>().ToTable("Implants");
        modelBuilder.Entity<Monde>().ToTable("Mondes");
        modelBuilder.Entity<Mutation>().ToTable("Mutations");
        modelBuilder.Entity<Pouvoir>().ToTable("Pouvoirs");
        modelBuilder.Entity<Promote>().ToTable("Promotions");
        modelBuilder.Entity<Seuil>().ToTable("Seuils");
        modelBuilder.Entity<Sousmonde>().ToTable("Sousmondes");
        modelBuilder.Entity<Talent>().ToTable("Talents");
        modelBuilder.Entity<Trait>().ToTable("Traits");
        modelBuilder.Entity<Trouble>().ToTable("Troubles");
        modelBuilder.Entity<TypeMonde>().ToTable("TypeMondes");
        modelBuilder.Entity<TypeName>().ToTable("TypesNom");

        //modelBuilder.Entity<AccessoiresArmes>()
        //    .HasMany(a => a.Accessoire)
        //    .WithOne()
        //    .HasForeignKey(x => x.AccessoireId);

        //modelBuilder.Entity<Améliorations>()
        //    .HasMany(a => a.Amélioration)
        //    .WithOne()
        //    .HasForeignKey(x => x.AméliorationId);

        //modelBuilder.Entity<Archétypes>()
        //    .HasMany(a => a.Archétype)
        //    .WithOne()
        //    .HasForeignKey(x => x.ArchétypeId);

        //modelBuilder.Entity<Armes>()
        //    .HasMany(a => a.Arme)
        //    .WithOne()
        //    .HasForeignKey(x => x.ArmeId);

        //modelBuilder.Entity<Armures>()
        //    .HasMany(a => a.Armure)
        //    .WithOne()
        //    .HasForeignKey(x => x.ArmureId);

        //modelBuilder.Entity<Assermentations>()
        //    .HasMany(a => a.Assermentation)
        //    .WithOne()
        //    .HasForeignKey(x => x.AssermentationId);

        //modelBuilder.Entity<AttributsArmes>()
        //    .HasMany(a => a.Attribut)
        //    .WithOne()
        //    .HasForeignKey(x => x.AttributId);

        //modelBuilder.Entity<Carrières>()
        //    .HasMany(c => c.Carrière)
        //    .WithOne()
        //    .HasForeignKey(x => x.CarrièreId);

        //modelBuilder.Entity<Competences>()
        //    .HasMany(c => c.Competence)
        //    .WithOne()
        //    .HasForeignKey(x => x.CompetenceId);

        //modelBuilder.Entity<Coordonnées>()
        //    .HasMany(c => c.Coordonnée)
        //    .WithOne()
        //    .HasForeignKey(x => x.CoordonnéeId);

        //modelBuilder.Entity<Cybernétiques>()
        //    .HasMany(c => c.Cybernétique)
        //    .WithOne()
        //    .HasForeignKey(x => x.CybernétiqueId);

        //modelBuilder.Entity<Disciplines>()
        //    .HasMany(d => d.Discipline)
        //    .WithOne()
        //    .HasForeignKey(x => x.DisciplineId);

        //modelBuilder.Entity<Divinations>()
        //    .HasMany(d => d.Divination)
        //    .WithOne()
        //    .HasForeignKey(x => x.DivinationId);

        //modelBuilder.Entity<Equipements>()
        //    .HasMany(e => e.Equipement)
        //    .WithOne()
        //    .HasForeignKey(x => x.EquipementId);

        //modelBuilder.Entity<Implants>()
        //    .HasMany(i => i.Implant)
        //    .WithOne()
        //    .HasForeignKey(x => x.ImplantId);

        //modelBuilder.Entity<Mondes>()
        //    .HasMany(m => m.Monde)
        //    .WithOne()
        //    .HasForeignKey(x => x.MondeId);

        //modelBuilder.Entity<Mutations>()
        //    .HasMany(m => m.Mutation)
        //    .WithOne()
        //    .HasForeignKey(x => x.MutationId);

        //modelBuilder.Entity<Pouvoirs>()
        //    .HasMany(p => p.Pouvoir)
        //    .WithOne()
        //    .HasForeignKey(x => x.PouvoirId);

        //modelBuilder.Entity<Promotions>()
        //    .HasMany(p => p.Promotion)
        //    .WithOne()
        //    .HasForeignKey(x => x.PromotionId);

        //modelBuilder.Entity<SeuilsXp>()
        //    .HasMany(s => s.Seuil)
        //    .WithOne()
        //    .HasForeignKey(x => x.SeuilId);

        //modelBuilder.Entity<Sousmondes>()
        //    .HasMany(s => s.Sousmonde)
        //    .WithOne()
        //    .HasForeignKey(x => x.SousmondeId);

        //modelBuilder.Entity<Talents>()
        //    .HasMany(t => t.Talent)
        //    .WithOne()
        //    .HasForeignKey(x => x.TalentId);

        //modelBuilder.Entity<Traits>()
        //    .HasMany(t => t.Trait)
        //    .WithOne()
        //    .HasForeignKey(x => x.TraitId);

        //modelBuilder.Entity<Troubles>()
        //    .HasMany(t => t.Trouble)
        //    .WithOne()
        //    .HasForeignKey(x => x.TroubleId);

        //modelBuilder.Entity<TypeMondes>()
        //    .HasMany(t => t.TypeMonde)
        //    .WithOne()
        //    .HasForeignKey(x => x.TypeMondeId);

        //modelBuilder.Entity<TypesNom>()
        //    .HasMany(t => t.TypeNom)
        //    .WithOne()
        //    .HasForeignKey(x => x.TypeNomId);

    }
}