C# ApplicationUserManager.RemoveFromRole方法代码示例

        public void ClearUserRoles(ApplicationUserManager userManager, string userId)
        {
            var user = userManager.FindById(userId);
            var currentRoles = new List<IdentityUserRole>();

            currentRoles.AddRange(user.UserRoles);
            foreach (var role in currentRoles)
            {
                userManager.RemoveFromRole(userId, role.RoleId);
            }
        }

 public void ClearUserRoles(string userId)
 {
     var um = new ApplicationUserManager(
         new UserStore<ApplicationUser>(context));
     var user = um.FindById(userId);
     var currentRoles = new List<IdentityUserRole>();
     currentRoles.AddRange(user.Roles);
     foreach (var role in currentRoles)
     {
         um.RemoveFromRole(userId, role.RoleId);
     }
 }

        public ActionResult ChangeRole( string id )
        {
            Person p = db.Users.Where( pp => id == pp.Id ).FirstOrDefault();

            var userManager = new ApplicationUserManager( new UserStore<Person>( db ) );

            if( userManager.IsInRole( p.Id, "editor" ) ) {
                userManager.RemoveFromRole( p.Id, "editor" );
                userManager.AddToRole( p.Id, "admin" );
            } else if( userManager.IsInRole( p.Id, "admin" ) ) {
                userManager.RemoveFromRole( p.Id, "admin" );
                userManager.AddToRole( p.Id, "user" );
            } else {
                userManager.RemoveFromRole( p.Id, "user" );
                userManager.AddToRole( p.Id, "editor" );
            }

            db.SaveChanges();

            return RedirectToAction( "AdminTable" );
        }

        public void Post(RoleUsersDto dto)
        {
            var context = ApplicationDbContext.Create();
            var userManager = new ApplicationUserManager(new UserStore<ApplicationUser>(context));
            var roleManager = new ApplicationRoleManager(new RoleStore<ApplicationRole>(context));

            if (!roleManager.RoleExists(dto.RoleName)) return;
            foreach (
                var user in
                    dto.UserNames.Select(userName => userManager.FindByName(userName))
                        .Where(user => user != null)
                        .Where(user => !userManager.IsInRole(user.Id, dto.RoleName)))
            {
                userManager.AddToRole(user.Id, dto.RoleName);
            }
            foreach (
                var user in 
                    dto.UserNames.Select(userName => userManager.FindByName(userName))
                        .Where(user => user != null)
                        .Where(user => userManager.IsInRole(user.Id, dto.RoleName)))
            {
                userManager.RemoveFromRole(user.Id, dto.RoleName);
            }
        }

        public async Task<bool> InsertOrUpdate(IdentityUserViewModel model, ApplicationUserManager userManager)
        {

            var user = await userManager.FindByIdAsync(model.Id);

            if (user == null)
            {
                user = new ApplicationUser();
                user.Assign(model);


                var result = await userManager.CreateAsync(user, "1234567");
                if (!result.Succeeded) return false;
                model.Id = user.Id;
            }
            else
            {
                user.Email = model.Email;
                user.UserName = model.UserName;
                user.DUI = model.DUI;
                user.PhoneNumber = model.PHONE_2;
                user.ADDRESS = model.ADDRESS;
                user.Category = model.Category;
                user.FirstName = model.FirstName;
                user.LastName = model.LastName;
                user.DUI = model.DUI;
                user.PHONE_2 = model.PHONE_2;
                user.ProfilePicture = model.ProfilePicture;
                user.CenterId = model.CenterId;
                //user.Address = model.Address;
                //user.FirstName = model.FirstName;
                //user.LastName = model.LastName;
                //user.DocumentNum = model.DocumentNum;
                //user.ProfilePicture = model.ProfilePicture;
                await userManager.UpdateAsync(user);
            }

            if (model.ForceChangePassword)
            {
                var tok = await userManager.GeneratePasswordResetTokenAsync(model.Id);

                var result = await userManager.ResetPasswordAsync(model.Id, tok, model.Password);

                if (!result.Succeeded) return false;
            }
            var roles = await userManager.GetRolesAsync(model.Id);

            if (!roles.Any() && !string.IsNullOrEmpty(model.Role))
            {
                var res = await userManager.AddToRoleAsync(model.Id, model.Role);
            }

            if (roles.All(r => r != model.Role) && roles.Any())
            {
                var result = await userManager.AddToRoleAsync(model.Id, model.Role);
            }
            roles.Where(r => r != model.Role).ToList().ForEach(role => userManager.RemoveFromRole(model.Id, role));

            if (model.CenterId != 0)
            {

                var claim = await Context.UserClaims.FirstOrDefaultAsync(c => c.UserId == user.Id && c.ClaimType == "CenterId");

                var claims = await userManager.GetClaimsAsync(user.Id);
                if (claim != null)
                {
                    claim.ClaimValue = model.CenterId.Value.ToString();
                    await Context.SaveChangesAsync();
                }
                else
                {
                    await userManager.AddClaimAsync(model.Id, new System.Security.Claims.Claim("CenterId", model.CenterId.ToString()));
                }
            }


            return true;
        }

        public ActionResult UserEdit(UserViewModel model)
        {
            if (ModelState.IsValid)
            {
                //userManager = new ApplicationUserManager(new ApplicationUserStore(identityDb));
                userManager = new ApplicationUserManager(new ApplicationUserStore(identityDb));

                var currentUser = identityDb.Users.Find(model.UserId);
                var currentRoles = currentUser.Roles;
                var currentRoleIds = currentRoles.Select(r => r.RoleId);

                var selectedRoles = new HashSet<int>();
                if (model.SelectedRoles != null)
                    selectedRoles = new HashSet<int>(model.SelectedRoles);

                foreach (var role in identityDb.Roles.ToList())
                {
                    if (currentRoleIds.Contains(role.Id) && !selectedRoles.Contains(role.Id))
                    {
                        userManager.RemoveFromRole(currentUser.Id, role.Name);
                    }
                    else if (!currentRoleIds.Contains(role.Id) && selectedRoles.Contains(role.Id))
                    {
                        userManager.AddToRole(currentUser.Id, role.Name);
                    }
                }
                return RedirectToAction("Users");
            }
            return View(model);
        }

        public ActionResult DeleteRoleForUser(string UserName, string RoleName)
        {
            try
            {
                var manager = new ApplicationUserManager(new UserStore<ApplicationUser>(context));

                ApplicationUser user = context.Users.Where(u => u.UserName.Equals(UserName, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();

                if (manager.IsInRole(user.Id, RoleName))
                {
                    manager.RemoveFromRole(user.Id, RoleName);
                    TempData["ValidationMessage"] = ("Success: " + " " + UserName + " " + "Was Removed From the " + " " + RoleName + " " + "Role");
                }
                else
                {
                    TempData["ValidationMessage"] = ("Error: " + " " + UserName + " " + "Was Not Successfully Removed From the " + " " + RoleName + " " + "Role");
                }
            }
            catch
            {
                TempData["ValidationMessage"] = ("Error: Something Went Wrong");
            }
            // prepopulat roles for the view dropdown
            var list = context.Roles.OrderBy(r => r.Name).ToList().Select(rr => new SelectListItem { Value = rr.Name.ToString(), Text = rr.Name }).ToList();
            ViewBag.Roles = list;

            return View("ManageRole");
        }

        public ActionResult Edit([Bind(Include = "UserId,Roles,UserName,Email")] UserEdit userEdit)
        {
            if (userEdit.UserId == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            var user = _db.Users.Find(userEdit.UserId);
            if (user == null)
            {
                return HttpNotFound();
            }
            if (!ModelState.IsValid) return View(userEdit);

            _userManager = Request.GetOwinContext().GetUserManager<ApplicationUserManager>();
            foreach (var role in userEdit.Roles)
            {
                if (role.IsChecked && !_userManager.IsInRole(user.Id, role.Name))
                    _userManager.AddToRole(user.Id, role.Name);
                if (!role.IsChecked && _userManager.IsInRole(user.Id, role.Name))
                    _userManager.RemoveFromRole(user.Id, role.Name);
            }
            _db.SaveChanges();
            // This was intended to force roles to update without manual logout login, but for now it's more trouble than it's worth
            /*var authenticationManager = HttpContext.GetOwinContext().Authentication;
            authenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
            var identity = _userManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
            authenticationManager.SignIn(new AuthenticationProperties { IsPersistent = false }, identity);*/
            return RedirectToAction("Index");
        }

 public void RemoveFromRole(ApplicationUserManager userManager, string userId, string roleName)
 {
     userManager.RemoveFromRole(userId, roleName);
 }