Вынесение модели в отдельный проект

2025-04-18 12:20:15 +04:00
parent df7f01938f
commit e1ec15d03e
96 changed files with 974 additions and 7683 deletions
@@ -0,0 +1,412 @@
+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$;
+        """);
+        */
+    }
+}