Pf2eDataScrapper/Pf2eModel/Pf2eDbContextModel.cs

using LinqToDB.Common;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
using Pf2eModel.Model.Base;
using Pf2eModel.Model.Base.Keywords;
using Pf2eModel.Model.Base.Source;
using Pf2eModel.Model.Base.Targets;
using Pf2eModel.Model.Common;
using Pf2eModel.Model.Enum;
using Pf2eModel.Model.Structure;
using Pf2eModel.Model.Structure.AncestryRelation;
using Pf2eModel.Model.Structure.BackgroundRelation;
using Pf2eModel.Model.Structure.ClassRelation;
using Pf2eModel.Model.Structure.DeityRelation;
using Pf2eModel.Model.Structure.FeatRelation;
using Pf2eModel.Model.Structure.SpellRelation;
using System.Reflection;

namespace Pf2eModel.Model;

public partial class Pf2eDbContext
{
    public const int NameLength = 255;

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

        DefineEnums(modelBuilder);
        DefineBase(modelBuilder);
        DefineCommon(modelBuilder);
        DefineStructure(modelBuilder);
        DefineFunctions(modelBuilder);
    }

    private void DefineEnums(ModelBuilder modelBuilder)
    {
        modelBuilder
            .HasPostgresEnum<EntityType>()
            .HasPostgresEnum<EntityRarity>()
            .HasPostgresEnum<AliasType>()
            .HasPostgresEnum<TraitType>()
            .HasPostgresEnum<ActionType>()
            .HasPostgresEnum<ActionCategory>()
            .HasPostgresEnum<Size>()
            .HasPostgresEnum<AncestryVision>()
            .HasPostgresEnum<ClassProgressionType>()
            .HasPostgresEnum<ConditionGroup>()
            .HasPostgresEnum<DeityCategory>()
            .HasPostgresEnum<DeityFonts>()
            .HasPostgresEnum<DeitySanctification>()
            .HasPostgresEnum<FeatActionType>()
            .HasPostgresEnum<FeatCategory>()
            .HasPostgresEnum<SpellAreaType>()
            .HasPostgresEnum<SpellDamageCategory>()
            .HasPostgresEnum<SpellDamageKinds>()
            .HasPostgresEnum<AttributeValues>()
            .HasPostgresEnum<TrainingStage>()
            .HasPostgresEnum<SourceCategory>()
            ;
    }

    private void DefineBase(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Entity>(entity =>
        {
            entity.HasMany(e => e.Traits).WithMany(t => t.Entities);

            entity.HasMany(e => e.Keywords).WithMany(t => t.Entities);

            // EntityAlias
            entity.HasMany(e => e.Aliases).WithOne(e => e.Entity)
                .HasForeignKey(e => e.EntityId)
                .OnDelete(DeleteBehavior.Cascade);

            // EntitySource
            entity.HasMany(e => e.Sources).WithOne(e => e.Entity)
                .HasForeignKey(e => e.EntityId)
                .OnDelete(DeleteBehavior.Cascade);

            // EntityExternal
            entity.HasMany(e => e.Externals).WithOne(e => e.Entity)
                .HasForeignKey(e => e.EntityId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<EntityAlias>(entity => { });

        // Source
        modelBuilder.Entity<Source>(entity =>
        {
            entity.Property(e => e.Id).HasColumnName("id");

            entity.HasMany(s => s.EntitySources).WithOne(e => e.Source)
                .HasForeignKey(e => e.SourceId)
                .OnDelete(DeleteBehavior.Cascade);

            // + EntitySource
        });
        modelBuilder.Entity<EntitySource>(entity => { });

        // External
        modelBuilder.Entity<ExternalTarget>(entity =>
        {
            entity.HasMany(t => t.EntityExternals).WithOne(e => e.Target)
                .HasForeignKey(e => e.TargetId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<EntityExternal>(entity => { });

        // Keywords
        modelBuilder.Entity<Keyword>(entity =>
        {
            entity.HasMany(e => e.Aliases).WithOne(e => e.Keyword)
                .HasForeignKey(e => e.KeywordId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<KeywordAlias>(entity => { });
    }

    private void DefineCommon(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Frequency>(entity => { });

        modelBuilder.Entity<Language>(entity => { });

        modelBuilder.Entity<Training>(entity => { });
    }

    private void BindEntity<T>(EntityTypeBuilder<T> entity) where T : class, IEntity
    {
        entity.HasOne(entity => entity.Entity)
            .WithOne()
            .HasForeignKey<T>(entity => entity.Id)
            .IsRequired();
    }

    private void DefineStructure(ModelBuilder modelBuilder)
    {
        // Action
        modelBuilder.Entity<Structure.Action>(entity =>
        {
            BindEntity(entity);
        });

        // Ancestry
        modelBuilder.Entity<Ancestry>(entity =>
        {
            BindEntity(entity);

            entity.HasMany(e => e.AncestryBoosts).WithOne(e => e.Ancestry)
                .HasForeignKey(e => e.AncestryId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.AncestryItems).WithOne(e => e.Ancestry)
                .HasForeignKey(e => e.AncestryId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.AncestryLanguages).WithOne(e => e.Ancestry)
                .HasForeignKey(e => e.AncestryId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<AncestryBoost>(entity => { });
        modelBuilder.Entity<AncestryItem>(entity =>
        {
            entity.HasOne(d => d.Item).WithMany()
                .HasForeignKey(d => d.ItemId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<AncestryLanguage>(entity =>
        {
            entity.HasOne(d => d.Language).WithMany()
                .HasForeignKey(d => d.LanguageId)
                .OnDelete(DeleteBehavior.Cascade);
        });

        // Background
        modelBuilder.Entity<Background>(entity =>
        {
            BindEntity(entity);
        });
        modelBuilder.Entity<BackgroundBoost>(entity =>
        {
            entity.HasOne(d => d.Background).WithMany(p => p.BackgroundBoosts)
                .HasForeignKey(d => d.BackgroundId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<BackgroundItem>(entity =>
        {
            entity.HasOne(d => d.Background).WithMany(p => p.BackgroundItems)
                .HasForeignKey(d => d.BackgroundId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasOne(d => d.Entity).WithMany()
                .HasForeignKey(d => d.EntityId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<BackgroundTraining>(entity =>
        {
            entity.HasOne(d => d.Background).WithMany(p => p.BackgroundSkills)
                .HasForeignKey(d => d.BackgroundId)
                .OnDelete(DeleteBehavior.Cascade);
        });

        // Class
        modelBuilder.Entity<Class>(entity =>
        {
            BindEntity(entity);
        });
        modelBuilder.Entity<ClassKeyAbility>(entity =>
        {
            entity.HasOne(d => d.Class).WithMany(p => p.ClassKeyAbilities)
                .HasForeignKey(d => d.ClassId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<ClassProgression>(entity =>
        {
            entity.HasOne(d => d.Class).WithMany(p => p.ClassProgressions)
                .HasForeignKey(d => d.ClassId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasOne(d => d.Entity).WithMany()
                .HasForeignKey(d => d.EntityId)
                .OnDelete(DeleteBehavior.SetNull);
        });
        modelBuilder.Entity<ClassTraining>(entity =>
        {
            entity.HasOne(d => d.Class).WithMany(p => p.ClassTrainings)
                .HasForeignKey(d => d.ClassId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasOne(d => d.Training).WithMany()
                .HasForeignKey(d => d.TrainingId)
                .OnDelete(DeleteBehavior.SetNull);
        });

        // Condition
        modelBuilder.Entity<Condition>(entity =>
        {
            BindEntity(entity);
        });

        // Deity
        modelBuilder.Entity<Deity>(entity =>
        {
            BindEntity(entity);

            entity.HasMany(e => e.DeityAttributes).WithOne(e => e.Deity)
                .HasForeignKey(e => e.DeityId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.DeityDomains).WithOne(e => e.Deity)
                .HasForeignKey(e => e.DeityId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.DeitySpells).WithOne(e => e.Deity)
                .HasForeignKey(e => e.DeityId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.DeityWeapons).WithOne(e => e.Deity)
                .HasForeignKey(e => e.DeityId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.Skills).WithMany();
        });
        modelBuilder.Entity<DeityAttribute>(entity => { });
        modelBuilder.Entity<DeityDomain>(entity => { });
        modelBuilder.Entity<DeitySpell>(entity =>
        {
            entity.HasOne(d => d.Spell).WithMany()
                .HasForeignKey(d => d.SpellId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<DeityWeapon>(entity => { });

        // Feat
        modelBuilder.Entity<Feat>(entity =>
        {
            BindEntity(entity);

            entity.HasMany(e => e.FeatPrerequisites).WithOne(e => e.Feat)
                .HasForeignKey(e => e.FeatId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<FeatPrerequisite>(entity => { });

        // Heritage
        modelBuilder.Entity<Heritage>(entity =>
        {
            BindEntity(entity);

            entity.HasOne(d => d.Ancestry).WithMany(p => p.Heritages)
                .HasForeignKey(d => d.AncestryId)
                .OnDelete(DeleteBehavior.Cascade);
        });

        // Spell
        modelBuilder.Entity<Spell>(entity =>
        {
            BindEntity(entity);

            entity.HasOne(e => e.SpellArea).WithOne(e => e.Spell)
                .HasForeignKey<SpellArea>(e => e.SpellId)
                .OnDelete(DeleteBehavior.Cascade)
                .IsRequired(false);

            entity.HasOne(e => e.SpellRitual).WithOne(e => e.Spell)
                .HasForeignKey<SpellRitual>(e => e.SpellId)
                .OnDelete(DeleteBehavior.Cascade)
                .IsRequired(false);

            entity.HasMany(e => e.SpellDamages).WithOne(e => e.Spell)
                .HasForeignKey(e => e.SpellId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.SpellDefenses).WithOne(e => e.Spell)
                .HasForeignKey(e => e.SpellId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<SpellArea>(entity => { });
        modelBuilder.Entity<SpellDamage>(entity => { });
        modelBuilder.Entity<SpellDefense>(entity => { });
        modelBuilder.Entity<SpellRitual>(entity => { });

        // Trait
        modelBuilder.Entity<Trait>(entity =>
        {
            BindEntity(entity);
        });
    }


    private void DefineFunctions(ModelBuilder modelBuilder)
    {
        // modelBuilder.HasDbFunction(typeof(Pf2eDbContext).GetMethod(nameof(FTruncateTables), Array.Empty<Type>()))
        /*
        modelBuilder.HasPostgresExtension($"""
            CREATE OR REPLACE FUNCTION f_truncate_tables()
                RETURNS void
                LANGUAGE plpgsql AS
            $func$
            BEGIN
                EXECUTE (
                    SELECT 'TRUNCATE TABLE '
                        || string_agg(format('%I.%I', schemaname, tablename), ', ')
                        || ' CASCADE;'
                    FROM   pg_tables
                    WHERE  schemaname = 'public'
                    AND  tablename != '__EFMigrationsHistory'
                );
            END
            $func$;
        """)
            ;

        /*
        Database.ExecuteSql($"""
            CREATE OR REPLACE FUNCTION f_truncate_tables()
                RETURNS void
                LANGUAGE plpgsql AS
            $func$
            BEGIN
                EXECUTE (
                    SELECT 'TRUNCATE TABLE '
                        || string_agg(format('%I.%I', schemaname, tablename), ', ')
                        || ' CASCADE;'
                    FROM   pg_tables
                    WHERE  schemaname = 'public'
                    AND  tablename != '__EFMigrationsHistory'
                );
            END
            $func$;
        """);

        Database.ExecuteSql($"""
            CREATE OR REPLACE FUNCTION f_drop_tables()
                RETURNS void
                LANGUAGE plpgsql AS
            $func$
            BEGIN
            EXECUTE (
                SELECT 'DROP TABLE '
                    || string_agg(format('%I.%I', schemaname, tablename), ', ')
                    || ' CASCADE;'
                FROM  pg_tables
                WHERE schemaname = 'public'
                );
            END
            $func$;
        """);

        Database.ExecuteSql($"""
            CREATE OR REPLACE FUNCTION f_permission_tables(_username text)
                RETURNS void
                LANGUAGE plpgsql AS
            $func$
            DECLARE
                _tbl text;
                _sch text;
            BEGIN
                FOR _sch, _tbl IN 
                    SELECT schemaname, tablename
                        FROM   pg_tables
                        WHERE  schemaname = 'public'
                LOOP
                    EXECUTE format('ALTER TABLE %I.%I OWNER TO %I', _sch, _tbl, _username);
                END LOOP;
            END
            $func$;
        """);
        */
    }
}