【.NETCore 3】Ids4 ║ 统一角色管理（上）

// 配置上下文
public class MyDbContext : DbContext, IConfigurationDbContext
 {
     private readonly ConfigurationStoreOptions storeOptions;

     public MyDbContext(DbContextOptions<MyDbContext> options)
      : base(options)
     {
     }public DbSet<User> User { get; set; }
     public DbSet<Role> Roles { get; set; }
     public DbSet<ApiResource> ApiResources { get; set; }

     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         modelBuilder.ConfigureClientContext(storeOptions);
         modelBuilder.ConfigureResourcesContext(storeOptions);

         base.OnModelCreating(modelBuilder);
     }
 }


// 正常的注入服务
services.AddDbContext<MyDbContext>(builder => builder.UseOracle(connectionString, options => {
     options.MigrationsAssembly(migrationsAssembly);
     options.MigrationsHistoryTable("xxxx");
 }));

    public class UserRepository
    {
        private readonly MyDbContext _dbContext;
        public UserRepository(MyDbContext dbContext)
        {
            _dbContext = dbContext;
        }
        /// <summary>
        /// 根据SubjectID查询用户信息
        /// </summary>
        /// <param name="subjectId">用户id</param>
        /// <returns></returns>
        public IdentityUser FindBySubjectId(string subjectId) {
            return _dbContext.Set<User>().Where(r => r.SubjectId.Equals(subjectId)).Include(r => r.IdentityUserClaims).SingleOrDefault();
        }
        /// <summary>
        /// 根据用户名查询用户
        /// </summary>
        /// <param name="username">用户</param>
        /// <returns></returns>
        public IdentityUser FindByUsername(string username)
        {
            return _dbContext.Set<User>().Where(r => r.Username.Equals(username)).Include(r => r.IdentityUserClaims).SingleOrDefault();
        }
}

public virtual TKey Id {get;set}
public virtual string Name{get;set}
public virtual string NormalizedName{get;set}

// Add profile data for application roles by adding properties to the ApplicationRole class
public class ApplicationRole : IdentityRole<int>
{

    public bool IsDeleted { get; set; }
    public string Description { get; set; }
    /// <summary>
    ///排序
    /// </summary>
    public int OrderSort { get; set; }
    /// <summary>
    /// 是否激活
    /// </summary>
    public bool Enabled { get; set; }
    /// <summary>
    /// 创建ID
    /// </summary>
    public int? CreateId { get; set; }
    /// <summary>
    /// 创建者
    /// </summary>
    public string CreateBy { get; set; }
    /// <summary>
    /// 创建时间
    /// </summary>
    public DateTime? CreateTime { get; set; } = DateTime.Now;
    /// <summary>
    /// 修改ID
    /// </summary>
    public int? ModifyId { get; set; }
    /// <summary>
    /// 修改者
    /// </summary>
    public string ModifyBy { get; set; }
    /// <summary>
    /// 修改时间
    /// </summary>
    public DateTime? ModifyTime { get; set; } = DateTime.Now;

    // 同理我们需要创建一个 ApplicationUserRole 关系表，具体的看我源码吧
    public ICollection<ApplicationUserRole> UserRoles { get; set; }

services.AddIdentity<ApplicationUser, ApplicationRole>()
    .AddEntityFrameworkStores<ApplicationDbContext>()
    .AddDefaultTokenProviders();

// 注意下 红色的 int类型，到时候创建的表的主键是 int 类型的。
 public class ApplicationDbContext
 : IdentityDbContext<ApplicationUser, ApplicationRole, int, IdentityUserClaim<int>,
 ApplicationUserRole, IdentityUserLogin<int>,
 IdentityRoleClaim<int>, IdentityUserToken<int>>
 {
     public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
         : base(options)
     {
     }

     protected override void OnModelCreating(ModelBuilder builder)
     {
         base.OnModelCreating(builder);

         builder.Entity<ApplicationUserRole>(userRole =>
         {
             userRole.HasKey(ur => new { ur.UserId, ur.RoleId });

             userRole.HasOne(ur => ur.Role)
                 .WithMany(r => r.UserRoles)
                 .HasForeignKey(ur => ur.RoleId)
                 .IsRequired();

             userRole.HasOne(ur => ur.User)
                 .WithMany(r => r.UserRoles)
                 .HasForeignKey(ur => ur.UserId)
                 .IsRequired();
         });

         builder.Entity<ApplicationRole>()
             .ToTable("Role");
     }

[HttpGet]
 [Route("account/Roleregister")]
 public IActionResult RoleRegister(string returnUrl = null)
 {
     ViewData["ReturnUrl"] = returnUrl;
     return View();
 }

 [HttpPost]
 [Route("account/Roleregister")]
 [ValidateAntiForgeryToken]
 public async Task<IActionResult> RoleRegister(RoleRegisterViewModel model, string returnUrl = null)
 {
     ViewData["ReturnUrl"] = returnUrl;
     IdentityResult result = new IdentityResult();

     if (ModelState.IsValid)
     {
         var roleItem = _roleManager.FindByNameAsync(model.RoleName).Result;

         if (roleItem == null)
         {
             var role = new ApplicationRole
             {
                 Name = model.RoleName
             };

             result = await _roleManager.CreateAsync(role);

             if (result.Succeeded)
             {
                 if (result.Succeeded)
                 {
                     return RedirectToLocal(returnUrl);
                 }
             }

         }
         else
         {
             ModelState.AddModelError(string.Empty, $"{roleItem?.Name} already exists");

         }

         AddErrors(result);
     }

     // If we got this far, something failed, redisplay form
     return View(model);
 }


 [HttpGet]
 [Route("account/Roles")]
 [Authorize]
 public IActionResult Roles(string returnUrl = null)
 {
     ViewData["ReturnUrl"] = returnUrl;
     var roles = _roleManager.Roles.Where(d => !d.IsDeleted).ToList();
     return View(roles);
 }



 [HttpGet("{id}")]
 [Route("account/Roleedit/{id}")]
 [Authorize(Roles = "SuperAdmin")]
 public async Task<IActionResult> RoleEdit(string id, string returnUrl = null)
 {
     ViewData["ReturnUrl"] = returnUrl;
     if (id == null)
     {
         return NotFound();
     }

     var user = await _roleManager.FindByIdAsync(id);

     if (user == null)
     {
         return NotFound();
     }

     return View(new RoleEditViewModel(user.Id, user.Name));
 }


 [HttpPost]
 [Route("account/Roleedit/{id}")]
 [ValidateAntiForgeryToken]
 [Authorize(Roles = "SuperAdmin")]
 public async Task<IActionResult> RoleEdit(RoleEditViewModel model, string id, string returnUrl = null)
 {
     ViewData["ReturnUrl"] = returnUrl;
     IdentityResult result = new IdentityResult();

     if (ModelState.IsValid)
     {
         var roleItem = _roleManager.FindByIdAsync(model.Id).Result;

         if (roleItem != null)
         {
             roleItem.Name = model.RoleName;

             result = await _roleManager.UpdateAsync(roleItem);

             if (result.Succeeded)
             {
                 return RedirectToLocal(returnUrl);
             }

         }
         else
         {
             ModelState.AddModelError(string.Empty, $"{roleItem?.Name} no exist!");
         }

         AddErrors(result);
     }

     // If we got this far, something failed, redisplay form
     return View(model);
 }

 [HttpPost]
 [Route("account/Roledelete/{id}")]
 [Authorize(Roles = "SuperAdmin")]
 public async Task<JsonResult> RoleDelete(string id)
 {
     IdentityResult result = new IdentityResult();

     if (ModelState.IsValid)
     {
         var roleItem = _roleManager.FindByIdAsync(id).Result;

         if (roleItem != null)
         {
             roleItem.IsDeleted = true；

             result = await _roleManager.UpdateAsync(roleItem);

             if (result.Succeeded)
             {
                 return Json(result);
             }
         }
         else
         {
             ModelState.AddModelError(string.Empty, $"{roleItem?.Name} no exist!");
         }

         AddErrors(result);
     }

     return Json(result.Errors);

 }