game-ideas/src/GameIdeas/Server/GameIdeas.WebAPI/Context/GameIdeasContext.cs

using GameIdeas.Shared.Model;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

namespace GameIdeas.WebAPI.Context;

public class GameIdeasContext : IdentityDbContext<User>
{
    public GameIdeasContext(DbContextOptions<GameIdeasContext> option) 
        : base(option)
    {
        AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
        AppContext.SetSwitch("Npgsql.DisableDateTimeInfinityConversions", true);
    }

    public virtual DbSet<Developer> Developers { get; set; } = null!;
    public virtual DbSet<Platform> Platforms { get; set; } = null!;
    public virtual DbSet<Property> Properties { get; set; } = null!;
    public virtual DbSet<Publisher> Publishers { get; set; } = null!;
    public virtual DbSet<Tag> Tags { get; set; } = null!;
    public virtual DbSet<Game> Games { get; set; } = null!;
    public virtual DbSet<GamePlatform> GamePlatforms { get; set; } = null!;
    public virtual DbSet<GameProperty> GameProperties { get; set; } = null!;
    public virtual DbSet<GameTag> GameTags { get; set; } = null!;

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Developer>(entity => {
            entity.ToTable("Developer");

            entity.HasIndex(e => e.Name)
                .IsUnique();
        });

        modelBuilder.Entity<Platform>(entity => {
            entity.ToTable("Platform");

            entity.HasIndex(e => e.Label)
                .IsUnique();
        });

        modelBuilder.Entity<Property>(entity =>
        {
            entity.ToTable("Property"); 
            
            entity.HasIndex(e => e.Label)
                .IsUnique();
        });

        modelBuilder.Entity<Publisher>(entity => 
        { 
            entity.ToTable("Publisher"); 

            entity.HasIndex(e => e.Name)
                .IsUnique(); 
        });

        modelBuilder.Entity<Tag>(entity =>
        {
            entity.ToTable("Tag");

            entity.HasIndex(e => e.Label)
                    .IsUnique();
        });

        modelBuilder.Entity<Game>(entity =>
        {
            entity.ToTable("Game");

            entity.HasIndex(e => e.Title)
                .IsUnique();

            entity.HasIndex(e => e.CreationUserId);

            entity.HasIndex(e => e.ModificationUserId);

            entity.HasIndex(e => e.PublisherId);

            entity.HasIndex(e => e.DeveloperId);

            entity.Property(e => e.CreationDate)
                 .HasDefaultValueSql("now()");

            entity.Property(e => e.Id)
                .UseIdentityByDefaultColumn()
                .HasIdentityOptions(startValue: 100000);

            entity.HasOne(d => d.CreationUser)
                .WithMany(p => p.CreationGames)
                .HasForeignKey(d => d.CreationUserId)
                .OnDelete(DeleteBehavior.ClientSetNull);

            entity.HasOne(d => d.ModificationUser)
                .WithMany(p => p.ModificationGames)
                .HasForeignKey(d => d.ModificationUserId)
                .OnDelete(DeleteBehavior.ClientSetNull);

            entity.HasOne(d => d.Developer)
                .WithMany(p => p.Games)
                .HasForeignKey(d => d.DeveloperId)
                .OnDelete(DeleteBehavior.ClientSetNull);

            entity.HasOne(d => d.Publisher)
                .WithMany(p => p.Games)
                .HasForeignKey(d => d.PublisherId)
                .OnDelete(DeleteBehavior.ClientSetNull);
        });

        modelBuilder.Entity<GamePlatform>(entity =>
        {
            entity.ToTable("GamePlatform");

            entity.HasKey(e => new { e.GameId, e.PlatformId });

            entity.HasOne(d => d.Game)
                .WithMany(p => p.GamePlatforms)
                .HasForeignKey(d => d.GameId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasOne(d => d.Platform)
                .WithMany(p => p.GamePlatforms)
                .HasForeignKey(d => d.PlatformId)
                .OnDelete(DeleteBehavior.Cascade);
        });

        modelBuilder.Entity<GameProperty>(entity =>
        {
            entity.ToTable("GameProperty");

            entity.HasKey(e => new { e.GameId, e.PropertyId });

            entity.HasOne(d => d.Game)
                .WithMany(p => p.GameProperties)
                .HasForeignKey(d => d.GameId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasOne(d => d.Property)
                .WithMany(p => p.GameProperties)
                .HasForeignKey(d => d.PropertyId)
                .OnDelete(DeleteBehavior.Cascade);
        });

        modelBuilder.Entity<GameTag>(entity =>
        {
            entity.ToTable("GameTag");

            entity.HasKey(e => new { e.GameId, e.TagId });

            entity.HasOne(d => d.Game)
                .WithMany(p => p.GameTags)
                .HasForeignKey(d => d.GameId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasOne(d => d.Tag)
                .WithMany(p => p.GameTags)
                .HasForeignKey(d => d.TagId)
                .OnDelete(DeleteBehavior.Cascade);
        });

        base.OnModelCreating(modelBuilder);
    }
}