CodeLiturgy.Dashboard/BlueWest.Api/Users/ApplicationUserDbContext.cs

using System;
using System.Threading.Tasks;
using BlueWest.Data;
using BlueWest.WebApi.EF;
using BlueWest.WebApi.EF.Model;
using Duende.IdentityServer.EntityFramework.Entities;
using Duende.IdentityServer.EntityFramework.Interfaces;
using Duende.IdentityServer.Stores.Serialization;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

namespace BlueWest.WebApi.Context.Users;

/// <summary>
/// Application User Db Context
/// </summary>
public class ApplicationUserDbContext : IdentityDbContext<
    ApplicationUser,
    ApplicationRole,
    string,
    ApplicationUserClaim,
    ApplicationUserRole,
    ApplicationUserLogin,
    ApplicationRoleClaim,
    ApplicationUserToken>
{

    /// <summary>
    /// Configures the schema needed for the identity framework.
    /// </summary>
    /// <param name="builder">
    /// The builder being used to construct the model for this context.
    /// </param>
    
    /// <summary>
    /// Database for the context of database users
    /// </summary>
    /// <param name="options"></param>
    public ApplicationUserDbContext(DbContextOptions<ApplicationUserDbContext> options) : base(options)
    {
        Database.EnsureCreated();
        
    }

    /// <summary>
    /// Configures the schema needed for the identity framework.
    /// </summary>
    /// <param name="builder">
    /// The builder being used to construct the model for this context.
    /// </param>
    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);
        

        builder.Entity<ApplicationUserRole>().ToTable("UserRoles");
        builder.Entity<ApplicationUser>(b =>
        {
            b.HasMany<ApplicationUserRole>()
                .WithOne()
                .HasForeignKey(ur => ur.UserId).IsRequired();
        });

        builder.Entity<ApplicationUser>().ToTable("ApplicationUser")
            .HasKey(x => x.Id);



        builder.Entity<ApplicationRole>(b =>
        {
            b.HasKey(r => r.Id);
            b.HasIndex(r => r.NormalizedName).HasDatabaseName("RoleNameIndex").IsUnique();
            b.ToTable("Roles");
            b.Property(r => r.ConcurrencyStamp).IsConcurrencyToken();

            b.Property(u => u.Name).HasMaxLength(256);
            b.Property(u => u.NormalizedName).HasMaxLength(256);

            b.HasMany<ApplicationUserRole>().WithOne().HasForeignKey(ur => ur.RoleId).IsRequired();
            b.HasMany<ApplicationRoleClaim>().WithOne().HasForeignKey(rc => rc.RoleId).IsRequired();
        });

        builder.Entity<ApplicationRoleClaim>(b =>
        {
            b.HasKey(rc => rc.Id);
            b.ToTable("RoleClaims");
        });

        builder.Entity<ApplicationUserRole>(b =>
        {
            b.HasKey(r => new { r.UserId, r.RoleId });
            b.ToTable("UserRoles");
        });
        
        builder.Entity<User>(b => b.HasOne<ApplicationUser>()
            .WithMany(x => x.Users)
            .HasForeignKey(x => x.ApplicationUserId));

        builder.ConfigureCurrentDbModel();
    }

}