Pf2eDataScrapper/Pf2eDataScrapper/Pf2eTestContext.cs

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using Pf2eDataScrapper.Model;
using Pf2eDataScrapper.Model.Enum;
using System.ComponentModel;
using System.Reflection;

namespace Pf2eDataScrapper;

public partial class Pf2eTestContext : DbContext
{
    public Pf2eTestContext()
    {
    }

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

    #region DbSets

    public virtual DbSet<Model.Action> Actions { get; set; }

    public virtual DbSet<Ancestry> Ancestries { get; set; }

    public virtual DbSet<AncestryBoost> AncestryBoosts { get; set; }

    public virtual DbSet<AncestryItem> AncestryItems { get; set; }

    public virtual DbSet<AncestryLanguage> AncestryLanguages { get; set; }

    public virtual DbSet<Background> Backgrounds { get; set; }

    public virtual DbSet<BackgroundBoost> BackgroundBoosts { get; set; }

    public virtual DbSet<BackgroundItem> BackgroundItems { get; set; }

    public virtual DbSet<BackgroundSkill> BackgroundSkills { get; set; }

    public virtual DbSet<CampaignFeature> CampaignFeatures { get; set; }

    public virtual DbSet<Class> Classes { get; set; }

    public virtual DbSet<ClassKeyAbility> ClassKeyAbilities { get; set; }

    public virtual DbSet<ClassProgression> ClassProgressions { get; set; }

    public virtual DbSet<ClassTraining> ClassTrainings { get; set; }

    public virtual DbSet<Condition> Conditions { get; set; }

    public virtual DbSet<Deity> Deities { get; set; }

    public virtual DbSet<DeityAttribute> DeityAttributes { get; set; }

    public virtual DbSet<DeityDomain> DeityDomains { get; set; }

    public virtual DbSet<DeitySpell> DeitySpells { get; set; }

    public virtual DbSet<DeityWeapon> DeityWeapons { get; set; }

    public virtual DbSet<Entity> Entities { get; set; }

    public virtual DbSet<EntityAlias> EntityAliases { get; set; }

    public virtual DbSet<EntityExternal> EntityExternals { get; set; }

    public virtual DbSet<EntityKeyword> EntityKeywords { get; set; }

    public virtual DbSet<EntitySource> EntitySources { get; set; }

    public virtual DbSet<ExternalTarget> ExternalTargets { get; set; }

    public virtual DbSet<Feat> Feats { get; set; }

    public virtual DbSet<FeatPrerequisite> FeatPrerequisites { get; set; }

    public virtual DbSet<Frequency> Frequencies { get; set; }

    public virtual DbSet<Heritage> Heritages { get; set; }

    public virtual DbSet<Keyword> Keywords { get; set; }

    public virtual DbSet<KeywordAlias> KeywordAliases { get; set; }

    public virtual DbSet<Language> Languages { get; set; }

    public virtual DbSet<Source> Sources { get; set; }

    public virtual DbSet<Spell> Spells { get; set; }

    public virtual DbSet<SpellArea> SpellAreas { get; set; }

    public virtual DbSet<SpellDamage> SpellDamages { get; set; }

    public virtual DbSet<SpellDefense> SpellDefenses { get; set; }

    public virtual DbSet<SpellRitual> SpellRituals { get; set; }

    public virtual DbSet<Training> Trainings { get; set; }

    public virtual DbSet<Trait> Traits { get; set; }

    #endregion
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseNpgsql(EnvSettings.DatabaseConnection,
            builder =>
            {
                builder
                    .MapEnum<EntityType>("entity_type")
                    .MapEnum<ConditionGroup>("condition_group");
            }
        );
    }

    protected string FromEnum<T>(T enumValue) where T : Enum
    {
        var enumFieldName = enumValue.ToString();
        var field = typeof(T).GetField(enumFieldName);
        if (field is null)
        {
            return enumFieldName;
        }

        var attribute = field.GetCustomAttribute<DescriptionAttribute>();
        return attribute is null ? enumFieldName : attribute.Description;
    }

    protected T ToEnum<T>(string enumValue) where T : Enum
    {
        var enumType = typeof(T);
        foreach (var field in enumType.GetFields())
        {
            var attribute = field.GetCustomAttribute<DescriptionAttribute>();
            if (attribute is null)
            {
                if (field.Name == enumValue)
                {
                    return (T)field.GetValue(null)!;
                }
            }
            else
            {
                if (attribute.Description == enumValue)
                {
                    return (T)field.GetValue(null)!;
                }
            }
        }
        throw new ArgumentException($"No matching value found for {enumValue} in {enumType.Name}");
    }

    protected ValueConverter<T, string> GetEnumConverter<T>() where T : Enum
    {
        return new ValueConverter<T, string>(
            v => FromEnum(v),
            v => ToEnum<T>(v));
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.UseIdentityByDefaultColumns();

        modelBuilder
            .HasPostgresEnum<EntityType>("entity_type")
            .HasPostgresEnum<ConditionGroup>("condition_group")
            ;

        modelBuilder
            .HasPostgresEnum("action_category", new[] { "offensive", "defensive", "interaction", "familiar" })
            .HasPostgresEnum("action_type", new[] { "action", "free", "reaction", "passive" })
            .HasPostgresEnum("alias_type", new[] { "old", "english", "hobby" })
            .HasPostgresEnum("ancestry_vision", new[] { "normal", "low_light_vision", "darkvision" })
            .HasPostgresEnum("campaign_feature_category", new[] { "army_tactic", "army_war_action", "kingdom_activity", "kingdom_feat", "kingdom_feature" })
            .HasPostgresEnum("class_progression_type", new[] { "entity", "ancestry_feat", "class_feat", "general_feat", "skill_feat", "skill_increase" })
            // .HasPostgresEnum("condition_group", new[] { "senses", "abilities", "death", "attitudes", "detection" })
            .HasPostgresEnum("deity_category", new[] { "deity", "pantheon", "covenant", "philosophy" })
            .HasPostgresEnum("deity_fonts", new[] { "none", "heal", "harm", "any" })
            .HasPostgresEnum("deity_sanctification", new[] { "holy", "unholy", "any" })
            .HasPostgresEnum("entity_rarity", new[] { "common", "uncommon", "rare", "unique" })
            // .HasPostgresEnum("entity_type", new[] { "action", "ancestry", "background", "backpack", "campaign_feature", "class", "condition", "deity", "feat", "heritage", "spell" })
            .HasPostgresEnum("enum_size", new[] { "med", "lanuages", "system", "tiny" })
            .HasPostgresEnum("feat_category", new[] { "ancestryfeature", "classfeature", "calling", "class", "skill", "general", "ancestry", "bonus", "deityboon", "curse", "pfsboon" })
            .HasPostgresEnum("spell_area_type", new[] { "burst", "emanation", "cone", "line", "square", "cube", "cylinder" })
            .HasPostgresEnum("spell_damage_category", new[] { "persistent", "splash" })
            .HasPostgresEnum("spell_damage_kinds", new[] { "damage", "healing", "any" })
            .HasPostgresEnum("trait_type", new[] { "regular", "tradition" });


        modelBuilder.Entity<Entity>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("entity_pkey");

            entity.ToTable("entity");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Description).HasColumnName("description");
            entity.Property(e => e.DescriptionGm).HasColumnName("description_gm");
            entity.Property(e => e.Type)
                .HasColumnName("type");
            entity.Property(e => e.Img)
                .HasMaxLength(150)
                .HasColumnName("img");
            entity.Property(e => e.IsChecked)
                .HasDefaultValue(false)
                .HasColumnName("is_checked");
            entity.Property(e => e.IsTranslated)
                .HasDefaultValue(false)
                .HasColumnName("is_translated");
            entity.Property(e => e.Name)
                .HasMaxLength(150)
                .HasColumnName("name");
            entity.Property(e => e.Slug)
                .HasMaxLength(150)
                .HasColumnName("slug");

            entity.HasMany(d => d.Traits).WithMany()
                .UsingEntity<Dictionary<string, object>>(
                    "EntityTrait",
                    r => r.HasOne<Trait>().WithMany()
                        .HasForeignKey("TraitId")
                        .OnDelete(DeleteBehavior.ClientSetNull)
                        .HasConstraintName("entity_traits_trait_id_fkey"),
                    l => l.HasOne<Entity>().WithMany()
                        .HasForeignKey("EntityId")
                        .OnDelete(DeleteBehavior.ClientSetNull)
                        .HasConstraintName("entity_traits_entity_id_fkey"),
                    j =>
                    {
                        j.HasKey("EntityId", "TraitId").HasName("entity_traits_pkey");
                        j.ToTable("entity_traits");
                        j.IndexerProperty<int>("EntityId").HasColumnName("entity_id");
                        j.IndexerProperty<int>("TraitId").HasColumnName("trait_id");
                    });
        });

        modelBuilder.Entity<EntityAlias>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("entity_aliases_pkey");

            entity.ToTable("entity_aliases");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Alias)
                .HasColumnType("character varying")
                .HasColumnName("alias");
            entity.Property(e => e.EntityId).HasColumnName("entity_id");

            entity.HasOne(d => d.Entity).WithMany()
                .HasForeignKey(d => d.EntityId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("entity_aliases_entity_id_fkey");
        });

        modelBuilder.Entity<EntityExternal>(entity =>
        {
            entity.HasKey(e => new { e.EntityId, e.TargetId }).HasName("entity_external_pkey");

            entity.ToTable("entity_external");

            entity.Property(e => e.EntityId).HasColumnName("entity_id");
            entity.Property(e => e.TargetId).HasColumnName("target_id");
            entity.Property(e => e.Md5)
                .HasColumnType("character varying")
                .HasColumnName("md5");
            entity.Property(e => e.Path)
                .HasColumnType("character varying")
                .HasColumnName("path");
            entity.Property(e => e.Suffix)
                .HasDefaultValueSql("''::character varying")
                .HasColumnType("character varying")
                .HasColumnName("suffix");

            entity.HasOne(d => d.Entity).WithMany()
                .HasForeignKey(d => d.EntityId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("entity_external_entity_id_fkey");

            entity.HasOne(d => d.Target).WithMany()
                .HasForeignKey(d => d.TargetId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("entity_external_target_id_fkey");
        });

        modelBuilder.Entity<EntityKeyword>(entity =>
        {
            entity
                .HasNoKey()
                .ToTable("entity_keywords");

            entity.Property(e => e.EntityId).HasColumnName("entity_id");
            entity.Property(e => e.KeywordId).HasColumnName("keyword_id");

            entity.HasOne(d => d.Entity).WithMany()
                .HasForeignKey(d => d.EntityId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("entity_keywords_entity_id_fkey");

            entity.HasOne(d => d.Keyword).WithMany()
                .HasForeignKey(d => d.KeywordId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("entity_keywords_keyword_id_fkey");
        });

        modelBuilder.Entity<EntitySource>(entity =>
        {
            entity
                .HasNoKey()
                .ToTable("entity_sources");

            entity.Property(e => e.EntityId).HasColumnName("entity_id");
            entity.Property(e => e.IsRemaster).HasColumnName("is_remaster");
            entity.Property(e => e.SourceId).HasColumnName("source_id");
            entity.Property(e => e.Suffix)
                .HasDefaultValueSql("''::character varying")
                .HasColumnType("character varying")
                .HasColumnName("suffix");

            entity.HasOne(d => d.Entity).WithMany()
                .HasForeignKey(d => d.EntityId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("entity_sources_entity_id_fkey");

            entity.HasOne(d => d.Source).WithMany()
                .HasForeignKey(d => d.SourceId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("entity_sources_source_id_fkey");
        });

        modelBuilder.Entity<ExternalTarget>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("external_target_pkey");

            entity.ToTable("external_target");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Icon)
                .HasColumnType("character varying")
                .HasColumnName("icon");
            entity.Property(e => e.Name)
                .HasColumnType("character varying")
                .HasColumnName("name");
        });


        modelBuilder.Entity<Frequency>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("frequency_pkey");

            entity.ToTable("frequency");

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.Property(e => e.Max).HasColumnName("max");
            entity.Property(e => e.Per).HasColumnName("per");
            entity.Property(e => e.Value).HasColumnName("value");

            entity.HasOne(d => d.IdNavigation).WithOne()
                .HasForeignKey<Frequency>(d => d.Id)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("frequency_id_fkey");
        });

        modelBuilder.Entity<Keyword>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("keyword_pkey");

            entity.ToTable("keyword");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Slug)
                .HasMaxLength(50)
                .HasColumnName("slug");
        });

        modelBuilder.Entity<KeywordAlias>(entity =>
        {
            entity
                .HasNoKey()
                .ToTable("keyword_aliases");

            entity.Property(e => e.KeywordId).HasColumnName("keyword_id");
            entity.Property(e => e.Value)
                .HasColumnType("character varying")
                .HasColumnName("value");

            entity.HasOne(d => d.Keyword).WithMany()
                .HasForeignKey(d => d.KeywordId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("keyword_aliases_keyword_id_fkey");
        });

        modelBuilder.Entity<Language>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("language_pkey");

            entity.ToTable("language");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Name)
                .HasColumnType("character varying")
                .HasColumnName("name");
        });

        modelBuilder.Entity<Source>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("source_pkey");

            entity.ToTable("source");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Name)
                .HasColumnType("character varying")
                .HasColumnName("name");
            entity.Property(e => e.Url)
                .HasColumnType("character varying")
                .HasColumnName("url");
        });

        modelBuilder.Entity<Training>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("trainings_pkey");

            entity.ToTable("trainings");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Key)
                .HasColumnType("character varying")
                .HasColumnName("key");
        });

        modelBuilder.Entity<Trait>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("trait_pkey");

            entity.ToTable("trait");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Description).HasColumnName("description");
            entity.Property(e => e.Name)
                .HasColumnType("character varying")
                .HasColumnName("name");
            entity.Property(e => e.Slug)
                .HasColumnType("character varying")
                .HasColumnName("slug");
        });





        modelBuilder.Entity<Model.Action>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("action_pkey");

            entity.ToTable("action");

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.HasOne(e => e.Entity).WithOne()
                .HasForeignKey<Model.Action>(e => e.Id)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("action_id_fkey");
            entity.Property(e => e.Actions).HasColumnName("actions");
            entity.Property(e => e.DeathNote).HasColumnName("death_note");
        });



        modelBuilder.Entity<Ancestry>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("ancestry_pkey");

            entity.ToTable("ancestry");

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.HasOne(e => e.Entity).WithOne()
                .HasForeignKey<Ancestry>(e => e.Id)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("ancestry_id_fkey");
            entity.Property(e => e.Hp).HasColumnName("hp");
            entity.Property(e => e.Reach).HasColumnName("reach");
            entity.Property(e => e.Speed).HasColumnName("speed");
        });

        modelBuilder.Entity<AncestryBoost>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("ancestry_boosts_pkey");

            entity.ToTable("ancestry_boosts");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.AncestryId).HasColumnName("ancestry_id");
            entity.Property(e => e.Boost)
                .HasDefaultValue(true)
                .HasColumnName("boost");
            entity.Property(e => e.Value)
                .HasMaxLength(3)
                .HasColumnName("value");

            entity.HasOne(d => d.Ancestry).WithMany(p => p.AncestryBoosts)
                .HasForeignKey(d => d.AncestryId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("ancestry_boosts_ancestry_id_fkey");
        });

        modelBuilder.Entity<AncestryItem>(entity =>
        {
            entity.HasKey(e => new { e.AncestryId, e.ItemId }).HasName("ancestry_items_pkey");

            entity.ToTable("ancestry_items");

            entity.Property(e => e.AncestryId).HasColumnName("ancestry_id");
            entity.Property(e => e.ItemId).HasColumnName("item_id");
            entity.Property(e => e.Level).HasColumnName("level");

            entity.HasOne(d => d.Ancestry).WithMany(p => p.AncestryItems)
                .HasForeignKey(d => d.AncestryId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("ancestry_items_ancestry_id_fkey");

            entity.HasOne(d => d.Item).WithMany()
                .HasForeignKey(d => d.ItemId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("ancestry_items_item_id_fkey");
        });

        modelBuilder.Entity<AncestryLanguage>(entity =>
        {
            entity.HasKey(e => new { e.AncestryId, e.LanguageId }).HasName("ancestry_languages_pkey");

            entity.ToTable("ancestry_languages");

            entity.Property(e => e.AncestryId).HasColumnName("ancestry_id");
            entity.Property(e => e.LanguageId).HasColumnName("language_id");
            entity.Property(e => e.IsAdditional).HasColumnName("is_additional");

            entity.HasOne(d => d.Ancestry).WithMany(p => p.AncestryLanguages)
                .HasForeignKey(d => d.AncestryId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("ancestry_languages_ancestry_id_fkey");

            entity.HasOne(d => d.Language).WithMany(p => p.AncestryLanguages)
                .HasForeignKey(d => d.LanguageId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("ancestry_languages_language_id_fkey");
        });



        modelBuilder.Entity<Background>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("background_pkey");

            entity.ToTable("background");

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.HasOne(e => e.Entity).WithOne()
                .HasForeignKey<Background>(e => e.Id)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("background_id_fkey");
        });

        modelBuilder.Entity<BackgroundBoost>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("background_boosts_pkey");

            entity.ToTable("background_boosts");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.BackgroundId).HasColumnName("background_id");
            entity.Property(e => e.Value)
                .HasMaxLength(3)
                .HasColumnName("value");

            entity.HasOne(d => d.Background).WithMany(p => p.BackgroundBoosts)
                .HasForeignKey(d => d.BackgroundId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("background_boosts_background_id_fkey");
        });

        modelBuilder.Entity<BackgroundItem>(entity =>
        {
            entity.HasKey(e => new { e.BackgroundId, e.EntityId }).HasName("background_items_pkey");

            entity.ToTable("background_items");

            entity.Property(e => e.BackgroundId).HasColumnName("background_id");
            entity.Property(e => e.EntityId).HasColumnName("entity_id");
            entity.Property(e => e.Level).HasColumnName("level");

            entity.HasOne(d => d.Background).WithMany(p => p.BackgroundItems)
                .HasForeignKey(d => d.BackgroundId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("background_items_background_id_fkey");

            entity.HasOne(d => d.Entity).WithMany()
                .HasForeignKey(d => d.EntityId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("background_items_entity_id_fkey");
        });

        modelBuilder.Entity<BackgroundSkill>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("background_skills_pkey");

            entity.ToTable("background_skills");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.BackgroundId).HasColumnName("background_id");
            entity.Property(e => e.IsSkill).HasColumnName("is_skill");
            entity.Property(e => e.Name)
                .HasColumnType("character varying")
                .HasColumnName("name");

            entity.HasOne(d => d.Background).WithMany(p => p.BackgroundSkills)
                .HasForeignKey(d => d.BackgroundId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("background_skills_background_id_fkey");
        });



        modelBuilder.Entity<CampaignFeature>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("campaign_feature_pkey");

            entity.ToTable("campaign_feature");

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.HasOne(e => e.Entity).WithOne()
                .HasForeignKey<CampaignFeature>(e => e.Id)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("campaign_feature_id_fkey");

            entity.Property(e => e.Level).HasColumnName("level");
            entity.Property(e => e.Actions).HasColumnName("actions");
            entity.Property(e => e.Prerequisites)
                .HasColumnType("character varying")
                .HasColumnName("prerequisites");
            entity.Property(e => e.Extra).HasColumnName("extra");
        });



        modelBuilder.Entity<Class>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("class_pkey");

            entity.ToTable("class");

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.HasOne(e => e.Entity).WithOne()
                .HasForeignKey<Class>(e => e.Id)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("class_id_fkey");

            entity.Property(e => e.Hp).HasColumnName("hp");
            entity.Property(e => e.Perception).HasColumnName("perception");
            entity.Property(e => e.Spellcasting).HasColumnName("spellcasting");
            entity.Property(e => e.AdditionalTrainedSkills).HasColumnName("additionalTrainedSkills");
        });

        modelBuilder.Entity<ClassKeyAbility>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("class_key_abilities_pkey");

            entity.ToTable("class_key_abilities");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.ClassId).HasColumnName("class_id");
            entity.Property(e => e.Value)
                .HasMaxLength(3)
                .HasColumnName("value");

            entity.HasOne(d => d.Class).WithMany(p => p.ClassKeyAbilities)
                .HasForeignKey(d => d.ClassId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("class_key_abilities_class_id_fkey");
        });

        modelBuilder.Entity<ClassProgression>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("class_progression_pkey");

            entity.ToTable("class_progression");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.ClassId).HasColumnName("class_id");
            entity.Property(e => e.EntityId).HasColumnName("entity_id");
            entity.Property(e => e.Level).HasColumnName("level");

            entity.HasOne(d => d.Class).WithMany(p => p.ClassProgressions)
                .HasForeignKey(d => d.ClassId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("class_progression_class_id_fkey");

            entity.HasOne(d => d.Entity).WithMany()
                .HasForeignKey(d => d.EntityId)
                .HasConstraintName("class_progression_entity_id_fkey");
        });

        modelBuilder.Entity<ClassTraining>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("class_trainings_pkey");

            entity.ToTable("class_trainings");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.ClassId).HasColumnName("class_id");
            entity.Property(e => e.Item).HasColumnName("item");
            entity.Property(e => e.Name)
                .HasColumnType("character varying")
                .HasColumnName("name");
            entity.Property(e => e.Stage).HasColumnName("stage");

            entity.HasOne(d => d.Class).WithMany(p => p.ClassTrainings)
                .HasForeignKey(d => d.ClassId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("class_trainings_class_id_fkey");

            entity.HasOne(d => d.ItemNavigation).WithMany(p => p.ClassTrainings)
                .HasForeignKey(d => d.Item)
                .HasConstraintName("class_trainings_item_fkey");
        });



        modelBuilder.Entity<Condition>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("condition_pkey");

            entity.ToTable("condition");

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.HasOne(e => e.Entity).WithOne()
                .HasForeignKey<Condition>(e => e.Id)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("condition_id_fkey");

            entity.Property(e => e.Group).HasColumnName("group");
            entity.Property(e => e.Extra).HasColumnName("extra");
        });



        modelBuilder.Entity<Deity>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("deity_pkey");

            entity.ToTable("deity");

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.HasOne(e => e.Entity).WithOne()
                .HasForeignKey<Deity>(e => e.Id)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("deity_id_fkey");

            entity.Property(e => e.SanctificationMust).HasColumnName("sanctification_must");

            entity.HasMany(d => d.Skills).WithMany(p => p.Deities)
                .UsingEntity<Dictionary<string, object>>(
                    "DeitySkill",
                    r => r.HasOne<Training>().WithMany()
                        .HasForeignKey("SkillId")
                        .OnDelete(DeleteBehavior.ClientSetNull)
                        .HasConstraintName("deity_skills_skill_id_fkey"),
                    l => l.HasOne<Deity>().WithMany()
                        .HasForeignKey("DeityId")
                        .OnDelete(DeleteBehavior.ClientSetNull)
                        .HasConstraintName("deity_skills_deity_id_fkey"),
                    j =>
                    {
                        j.HasKey("DeityId", "SkillId").HasName("deity_skills_pkey");
                        j.ToTable("deity_skills");
                        j.IndexerProperty<int>("DeityId").HasColumnName("deity_id");
                        j.IndexerProperty<int>("SkillId").HasColumnName("skill_id");
                    });
        });

        modelBuilder.Entity<DeityAttribute>(entity =>
        {
            entity.HasKey(e => new { e.DeityId, e.Attribute }).HasName("deity_attributes_pkey");

            entity.ToTable("deity_attributes");

            entity.Property(e => e.DeityId).HasColumnName("deity_id");
            entity.Property(e => e.Attribute)
                .HasMaxLength(3)
                .HasColumnName("attribute");

            entity.HasOne(d => d.Deity).WithMany(p => p.DeityAttributes)
                .HasForeignKey(d => d.DeityId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("deity_attributes_deity_id_fkey");
        });

        modelBuilder.Entity<DeityDomain>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("deity_domains_pkey");

            entity.ToTable("deity_domains");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.DeityId).HasColumnName("deity_id");
            entity.Property(e => e.IsPrimary).HasColumnName("is_primary");
            entity.Property(e => e.Value)
                .HasColumnType("character varying")
                .HasColumnName("value");

            entity.HasOne(d => d.Deity).WithMany(p => p.DeityDomains)
                .HasForeignKey(d => d.DeityId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("deity_domains_deity_id_fkey");
        });

        modelBuilder.Entity<DeitySpell>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("deity_spells_pkey");

            entity.ToTable("deity_spells");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.DeityId).HasColumnName("deity_id");
            entity.Property(e => e.Level).HasColumnName("level");
            entity.Property(e => e.SpellId).HasColumnName("spell_id");

            entity.HasOne(d => d.Deity).WithMany(p => p.DeitySpells)
                .HasForeignKey(d => d.DeityId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("deity_spells_deity_id_fkey");

            entity.HasOne(d => d.Spell).WithMany(p => p.DeitySpells)
                .HasForeignKey(d => d.SpellId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("deity_spells_spell_id_fkey");
        });

        modelBuilder.Entity<DeityWeapon>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("deity_weapons_pkey");

            entity.ToTable("deity_weapons");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.DeityId).HasColumnName("deity_id");
            entity.Property(e => e.Weapon)
                .HasColumnType("character varying")
                .HasColumnName("weapon");

            entity.HasOne(d => d.Deity).WithMany(p => p.DeityWeapons)
                .HasForeignKey(d => d.DeityId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("deity_weapons_deity_id_fkey");
        });



        modelBuilder.Entity<Feat>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("feat_pkey");

            entity.ToTable("feat");

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.HasOne(e => e.Entity).WithOne()
                .HasForeignKey<Feat>(e => e.Id)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("feat_id_fkey");

            entity.Property(e => e.Actions).HasColumnName("actions");
            entity.Property(e => e.Level).HasColumnName("level");
            entity.Property(e => e.LevelTaken).HasColumnName("level_taken");
            entity.Property(e => e.MaxTakable).HasColumnName("max_takable");
            entity.Property(e => e.Location)
                .HasMaxLength(12)
                .HasColumnName("location");
            entity.Property(e => e.OnlyLevel1).HasColumnName("only_level_1");
        });

        modelBuilder.Entity<FeatPrerequisite>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("feat_prerequisites_pkey");

            entity.ToTable("feat_prerequisites");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.FeatId).HasColumnName("feat_id");
            entity.Property(e => e.Value)
                .HasColumnType("character varying")
                .HasColumnName("value");

            entity.HasOne(d => d.Feat).WithMany(p => p.FeatPrerequisites)
                .HasForeignKey(d => d.FeatId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("feat_prerequisites_feat_id_fkey");
        });



        modelBuilder.Entity<Heritage>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("heritage_pkey");

            entity.ToTable("heritage");

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.HasOne(e => e.Entity).WithOne()
                .HasForeignKey<Heritage>(e => e.Id)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("heritage_id_fkey");

            entity.Property(e => e.AncestryId).HasColumnName("ancestry_id");
            entity.HasOne(d => d.Ancestry).WithMany(p => p.Heritages)
                .HasForeignKey(d => d.AncestryId)
                .HasConstraintName("heritage_ancestry_id_fkey");
        });



        modelBuilder.Entity<Spell>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("spell_pkey");

            entity.ToTable("spell");

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.HasOne(e => e.Entity).WithOne()
                .HasForeignKey<Spell>(e => e.Id)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("spell_id_fkey");

            entity.Property(e => e.Level).HasColumnName("level");
            entity.Property(e => e.Cost).HasColumnName("cost");
            entity.Property(e => e.Counteraction).HasColumnName("counteraction");
            entity.Property(e => e.Sustained).HasColumnName("sustained");
            entity.Property(e => e.Duration)
                .HasColumnType("character varying")
                .HasColumnName("duration");
            entity.Property(e => e.Range)
                .HasColumnType("character varying")
                .HasColumnName("range");
            entity.Property(e => e.Requirements)
                .HasColumnType("character varying")
                .HasColumnName("requirements");
            entity.Property(e => e.Target)
                .HasColumnType("character varying")
                .HasColumnName("target");
            entity.Property(e => e.Time)
                .HasColumnType("character varying")
                .HasColumnName("time");
            entity.Property(e => e.CanHeightening).HasColumnName("can_heightening");
        });

        modelBuilder.Entity<SpellArea>(entity =>
        {
            entity.HasKey(e => e.SpellId).HasName("spell_area_pkey");

            entity.ToTable("spell_area");

            entity.Property(e => e.SpellId)
                .ValueGeneratedNever()
                .HasColumnName("spell_id");
            entity.Property(e => e.Details)
                .HasColumnType("character varying")
                .HasColumnName("details");
            entity.Property(e => e.Value).HasColumnName("value");

            entity.HasOne(d => d.Spell).WithOne(p => p.SpellArea)
                .HasForeignKey<SpellArea>(d => d.SpellId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("spell_area_spell_id_fkey");
        });

        modelBuilder.Entity<SpellDamage>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("spell_damage_pkey");

            entity.ToTable("spell_damage");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.ApplyMod).HasColumnName("apply_mod");
            entity.Property(e => e.Formula)
                .HasColumnType("character varying")
                .HasColumnName("formula");
            entity.Property(e => e.Key)
                .HasColumnType("character varying")
                .HasColumnName("key");
            entity.Property(e => e.Materials)
                .HasColumnType("character varying")
                .HasColumnName("materials");
            entity.Property(e => e.SpellId).HasColumnName("spell_id");
            entity.Property(e => e.Type)
                .HasColumnType("character varying")
                .HasColumnName("type");

            entity.HasOne(d => d.Spell).WithMany(p => p.SpellDamages)
                .HasForeignKey(d => d.SpellId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("spell_damage_spell_id_fkey");
        });

        modelBuilder.Entity<SpellDefense>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("spell_defense_pkey");

            entity.ToTable("spell_defense");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.IsBasic).HasColumnName("is_basic");
            entity.Property(e => e.IsPassive).HasColumnName("is_passive");
            entity.Property(e => e.SpellId).HasColumnName("spell_id");
            entity.Property(e => e.Statistic)
                .HasColumnType("character varying")
                .HasColumnName("statistic");

            entity.HasOne(d => d.Spell).WithMany(p => p.SpellDefenses)
                .HasForeignKey(d => d.SpellId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("spell_defense_spell_id_fkey");
        });

        modelBuilder.Entity<SpellRitual>(entity =>
        {
            entity.HasKey(e => e.SpellId).HasName("spell_ritual_pkey");

            entity.ToTable("spell_ritual");

            entity.Property(e => e.SpellId)
                .ValueGeneratedNever()
                .HasColumnName("spell_id");
            entity.Property(e => e.PrimaryCheck)
                .HasColumnType("character varying")
                .HasColumnName("primary_check");
            entity.Property(e => e.SecondaryCasters).HasColumnName("secondary_casters");
            entity.Property(e => e.SecondaryChecks)
                .HasColumnType("character varying")
                .HasColumnName("secondary_checks");

            entity.HasOne(d => d.Spell).WithOne(p => p.SpellRitual)
                .HasForeignKey<SpellRitual>(d => d.SpellId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("spell_ritual_spell_id_fkey");
        });


        OnModelCreatingPartial(modelBuilder);
    }

    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}