public class FoodlyAuthDbContext : IdentityDbContext<User,Role,string>
    {
        public FoodlyAuthDbContext(DbContextOptions<FoodlyAuthDbContext> options) : base(options) { }


        public virtual DbSet<RefreshToken> RefreshToken { get; set; }

        protected override void OnModelCreating(ModelBuilder builder)
        {
            builder.Entity((Action<EntityTypeBuilder<User>>) (b =>
            {
                b.HasKey(u => (object) u.Id);
                b.Property(u => u.Id).HasMaxLength(254);
                b.HasIndex(u => u.NormalizedUserName).HasName("UserNameIndex")
                    .IsUnique();
                b.HasIndex(u => u.NormalizedEmail).HasName("EmailIndex");
                b.ToTable("User");
                b.Property(u => u.ConcurrencyStamp)
                    .IsConcurrencyToken();
                b.Property(u => u.UserName).HasMaxLength(254);
                b.Property(u => u.NormalizedUserName).HasMaxLength(254);
                b.Property(u => u.Email).HasMaxLength(254);
                b.Property(u => u.NormalizedEmail).HasMaxLength(254);
//                b.HasOne((Expression<Func<User, RefreshToken>>) null)
//                    .WithOne().HasForeignKey<RefreshToken>(rt => (object) rt.RefreshTokenId).IsRequired();
                b.HasMany((Expression<Func<User, IEnumerable<IdentityUserClaim<string>>>>) null).WithOne()
                    .HasForeignKey(uc => (object) uc.UserId).IsRequired();
                b.HasMany((Expression<Func<User, IEnumerable<IdentityUserLogin<string>>>>) null).WithOne()
                    .HasForeignKey(ul => (object) ul.UserId).IsRequired();
                b.HasMany((Expression<Func<User, IEnumerable<IdentityUserToken<string>>>>) null).WithOne()
                    .HasForeignKey(ut => (object) ut.UserId).IsRequired();
            }));
            builder.Entity((Action<EntityTypeBuilder<IdentityUserClaim<string>>>) (b =>
            {
                b.HasKey(uc => uc.Id);
                b.Property(u => u.Id).HasMaxLength(254);
                b.ToTable("UserClaim");
            }));
            builder.Entity((Action<EntityTypeBuilder<IdentityUserLogin<string>>>) (b =>
            {
                b.HasKey(l => new
                {
                    l.LoginProvider,
                    l.ProviderKey
                });
                b.Property(x => x.LoginProvider).HasMaxLength(254);
                b.Property(x => x.ProviderKey).HasMaxLength(254);
                b.ToTable("UserLogin");
            }));
            builder.Entity((Action<EntityTypeBuilder<IdentityUserToken<string>>>) (b =>
            {
                b.HasKey(l => new
                {
                    l.UserId,
                    l.LoginProvider,
                    l.Name
                });
                b.Property(x => x.UserId).HasMaxLength(254);
                b.Property(x => x.LoginProvider).HasMaxLength(254);
                b.Property(x => x.Name).HasMaxLength(254);
                b.ToTable("UserToken");
            }));

            builder.Entity<User>(b => b.HasMany<IdentityUserRole<string>>()
                .WithOne().HasForeignKey(ur => (object) ur.UserId).IsRequired());

            builder.Entity<Role>(b =>
            {
                b.HasKey(r => (object) r.Id);
                b.Property(u => u.Id).HasMaxLength(254);
                b.HasIndex(r => r.NormalizedName).HasName("RoleNameIndex").IsUnique();
                b.ToTable("Role");
                b.Property(r => r.ConcurrencyStamp).IsConcurrencyToken();
                b.Property(u => u.Name).HasMaxLength(254);
                b.Property(u => u.NormalizedName).HasMaxLength(254);
                b.HasMany<IdentityUserRole<string>>()
                    .WithOne().HasForeignKey(ur => (object) ur.RoleId).IsRequired();
                b.HasMany<IdentityRoleClaim<string>>().WithOne()
                    .HasForeignKey(rc => (object) rc.RoleId).IsRequired();
            });
            builder.Entity<IdentityRoleClaim<string>>(b =>
            {
                b.HasKey(rc => (object) rc.Id);
                b.Property(u => u.Id).HasMaxLength(254);
                b.ToTable("RoleClaim");
            });
            builder.Entity<IdentityUserRole<string>>(b =>
            {
                b.HasKey(r => new
                {
                    r.UserId,
                    r.RoleId
                });
                b.Property(x => x.RoleId).HasMaxLength(254);
                b.Property(x => x.UserId).HasMaxLength(254);
                b.ToTable("UserRole");
            });

            builder.Entity<RefreshToken>(b =>
            {
                b.HasKey(r => (object) r.RefreshTokenId);
                b.Property(u => u.RefreshTokenId).HasMaxLength(254);
                b.Property(x => x.ClientId).HasMaxLength(254);
                b.Property(x => x.UserId).HasMaxLength(254);
                b.ToTable("RefreshToken");
            });

            builder.Entity<User>()
                .HasOne(e => e.RefreshToken)
                .WithOne(e => e.User).IsRequired()
                .OnDelete(DeleteBehavior.Restrict);
        }
    }