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[0].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="2">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="2">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() == 0) {
            <tr><td colspan="4" 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>()