mvc core2.1 Identity.EntityFramework Core ROle和用户绑定查看 (八）完成

添加角色属性查看

Views ->Shared->_Layout.cshtml

<div class="navbar-collapse collapse">
<ul class="nav navbar-nav">
　　<li><a asp-area="" asp-controller="Home" asp-action="Index">Home</a></li>
　　<li><a asp-area="" asp-controller="Home" asp-action="About">About</a></li>
　　<li><a asp-area="" asp-controller="Home" asp-action="Contact">Contact</a></li>
　　<li><a asp-area="" asp-controller="Account" asp-action="Index">Account</a></li>
　　<li><a asp-area="" asp-controller="Claims" asp-action="Index">Claims</a></li>
　　<li><a asp-area="" asp-controller="Role" asp-action="Index">Role</a></li>   //加这句

Controllers ->RoleController.cs 新建

 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
 using IdentityMvc.Models;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Authorization;
 using IdentityMvc.Models.AccountViewModels;
 using Microsoft.AspNetCore.Authentication;
 using System.ComponentModel.DataAnnotations;
 using Microsoft.EntityFrameworkCore;
 using IdentityMvc.Models.RoleViewModels;
 using System.Security.Claims;

 namespace IdentityMvc.Controllers
 {
     [Authorize]
     public class RoleController : Controller
     {
         private readonly UserManager<ApplicationUser> _userManager;
         private readonly RoleManager<ApplicationRole> _roleManager;

         public RoleController(UserManager<ApplicationUser> userManager,
             RoleManager<ApplicationRole> roleManager)
         {
             _roleManager = roleManager;
             _userManager = userManager;
         }
         [TempData]
         public string ErrorMessage { get; set; }

         [HttpGet]
         public ActionResult Index() {

             var dd = _roleManager.Roles.Include(d => d.UserRoles).Select(o => new
             {
                 o.Id,
                 o.Name,
                 userlist = o.UserRoles.Select(t => t.UserId).ToList(),
             }).Select(t => new {t.Id,t.Name,
                 useridlist = string.Join(",", t.userlist)
             });
             List<RoleViewModels> list = new List<RoleViewModels>();

             foreach (var gg in dd)
             {
                 var pp = _userManager.Users.Where(o => gg.useridlist.Contains(o.Id)).Select(o => o.UserName).ToList();

                 list.Add( new RoleViewModels { Id= gg.Id,Role=gg.Name, Name = string.Join(",", pp) });

             }

             return View(list);
             // return View(_roleManager.Roles.Include(d => d.UserRoles));
         }

         [HttpGet]
         public ActionResult Create() {
             return View();
         }

         [HttpPost]
         public async Task<ActionResult> Create(RoleViewModels model)
          {
             if (ModelState.IsValid) {
                  IdentityResult result = await _roleManager.CreateAsync(new ApplicationRole{Name=model.Name});
                 if (result.Succeeded) {

                     var officeClaim = new Claim("office", model.OfficeNumber.ToString(), ClaimValueTypes.String);
                     await _roleManager.AddClaimAsync(await _roleManager.FindByNameAsync(model.Name), officeClaim);

                     return RedirectToAction("Index");
                 } else {
                     AddErrors(result);
                 }
             }
             return View(model);
         }

         [HttpPost]
         public async Task<ActionResult> Delete(string id) {
             ApplicationRole role = await _roleManager.FindByIdAsync(id);
             if (role != null) {
                 IdentityResult result = await _roleManager.DeleteAsync(role);
                 if (result.Succeeded) {
                     return RedirectToAction("Index");
                 } else {
                     return View("Error", result.Errors);
                 }
             } else {
                 return View("Error", new string[] { "Role Not Found" });
             }
         }

          public async Task<ActionResult> Edit(string id) {
             ApplicationRole role = await _roleManager.FindByIdAsync(id);
              var temp = _roleManager.Roles.Include(d => d.UserRoles).Where(d => d.Id == id)
                .Select(d => new
                {
                    d.UserRoles
                }).ToArray();
             string[] memberID = temp[].UserRoles.Select(x => x.UserId).ToArray();
             var  members = _userManager.Users.Where(x => memberID.Any(y => y == x.Id));
             var nonMembers = _userManager.Users.Except(members);

             return View(new RoleEditModel {
                 Role = role,
                 Members = members,
                 NonMembers = nonMembers
             });
         }

         [HttpPost]
         public async Task<ActionResult> Edit(RoleModificationModel model) {
             IdentityResult result;
             if (ModelState.IsValid) {
                 foreach (string userId in model.IdsToAdd ?? new string[] { }) {
                     result = await _userManager.AddToRoleAsync(await _userManager.FindByIdAsync(userId), model.RoleName);
                     if (!result.Succeeded) {
                         return View("Error", result.Errors);
                     }
                 }
                 foreach (string userId in model.IdsToDelete ?? new string[] { }) {
                      result = await _userManager.RemoveFromRoleAsync(await _userManager.FindByIdAsync(userId),
                         model.RoleName);
                      if (!result.Succeeded) {
                         return View("Error", result.Errors);
                     }
                 }
                 return RedirectToAction("Index");
             }
             return View("Error", new string[] { "Role Not Found" });
         }

         private void AddErrors(IdentityResult result)
         {
             foreach (var error in result.Errors)
             {
                 ModelState.AddModelError(string.Empty, error.Description);
             }
         }
     }
 }

Models->RoleViewModels->RoleViewModels.cs 新建

 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Threading.Tasks;

 namespace IdentityMvc.Models.RoleViewModels
 {
     public class RoleViewModels
     {
         public string Id { get; set; }

         public string Name { get; set; }

         public string Role { get; set; }

         public string OfficeNumber { get; set; }
     }
       public class RoleEditModel
     {
         public ApplicationRole Role { get; set; }
         public IEnumerable<ApplicationUser> Members { get; set; }
         public IEnumerable<ApplicationUser> NonMembers { get; set; }
     }
     public class RoleModificationModel {
         [Required]
         public string RoleName { get; set; }
         public string[] IdsToAdd { get; set; }
         public string[] IdsToDelete { get; set; }
     }
 }

Views->Role->Create.cshtml

 @model RoleViewModels
 @{ ViewBag.Title = "Create Role";}
 <h2>Create Role</h2>
 @Html.ValidationSummary(false)
 @using (Html.BeginForm()) {
     <div class="form-group">
                 <label asp-for="Name" class="control-label"></label>
                 <input asp-for="Name" class="form-control" />
                 <span asp-validation-for="Name" class="text-danger"></span>
             </div>
     <div class="form-group">
                 <label asp-for="OfficeNumber" class="control-label"></label>
                 <input asp-for="OfficeNumber" class="form-control" />
                 <span asp-validation-for="OfficeNumber" class="text-danger"></span>
             </div>

     <button type="submit" class="btn btn-primary">Create</button>
     @Html.ActionLink("Cancel", "Index", null, new { @class = "btn btn-default" })
 }

Views->Role->Edit.cshtml

 @model RoleEditModel
 @{ ViewBag.Title = "Edit Role";}
 @Html.ValidationSummary()
 @using (Html.BeginForm()) {
     <input type="hidden" name="roleName" value="@Model.Role.Name" />
     <div class="panel panel-primary">
         <div class="panel-heading">Add To @Model.Role.Name</div>
         <table class="table table-striped">
             @if (Model.NonMembers == null) {
                 <tr><td colspan="">All Users Are Members</td></tr>
             } else {
                 <tr><td>User ID</td><td>Add To Role</td></tr>
                 foreach (ApplicationUser user in Model.NonMembers) {
                     <tr>
                         <td>@user.UserName</td>
                         <td>
                             <input type="checkbox" name="IdsToAdd" value="@user.Id">
                         </td>
                     </tr>
                 }
             }
         </table>
     </div>
     <div class="panel panel-primary">
         <div class="panel-heading">Remove from @Model.Role.Name</div>
         <table class="table table-striped">
             @if (Model.Members == null) {
                 <tr><td colspan="">No Users Are Members</td></tr>
             } else {
                 <tr><td>User ID</td><td>Remove From Role</td></tr>
                 foreach (ApplicationUser user in Model.Members) {
                     <tr>
                         <td>@user.UserName</td>
                         <td>
                             <input type="checkbox" name="IdsToDelete" value="@user.Id">
                         </td>
                     </tr>
                 }
             }
         </table>
     </div>
     <button type="submit" class="btn btn-primary">Save</button>
     @Html.ActionLink("Cancel", "Index", null, new { @class = "btn btn-default" })
 }

Views->Role->Index.cshtml

 @model IEnumerable<RoleViewModels>
 @using IdentityMvc.App_Code
 @{ ViewBag.Title = "Roles"; }

 <div class="panel panel-primary">
     <div class="panel-heading">Roles</div>
     <table class="table table-striped"> 

         <tr><th>ID</th><th>Name</th><th>Users</th><th></th></tr>
         @if (Model.Count() == ) {
             <tr><td colspan="" class="text-center">No Roles</td></tr>
         } else {
             foreach (RoleViewModels role in Model) {
                 <tr>
                     <td>@role.Id</td>
                     <td>@role.Role</td>
                     <td>@role.Name
                     </td>
                     <td>
                         @using (Html.BeginForm("Delete", "Role",
                             new { id = role.Id })) {
                             @Html.ActionLink("Edit", "Edit", new { id = role.Id },
                                      new { @class = "btn btn-primary btn-xs" })
                             <button class="btn btn-danger btn-xs"
                                     type="submit">
                                 Delete
                             </button>
                         }
                     </td>
                 </tr>
             }
         }
     </table>
 </div>
 @Html.ActionLink("Create", "Create", null, new { @class = "btn btn-primary" })  

Startup.cs->ConfigureServices

services.AddIdentity<ApplicationUser, IdentityRole>() ->   services.AddIdentity<ApplicationUser, ApplicationRole>()