public async Task <ActionResult> DeleteRole(string id, EditUserRoleViewModel viewModel)
{
if (ModelState.IsValid)
{
// Fast exit if trying to modify user 'a' or role 'admin'
if (viewModel.Username == "a" && viewModel.SelectedRole.ToUpper() == "ADMIN")
{
ModelState.AddModelError(string.Empty, "User 'a' cannot be removed from Admin");
ViewData["AllRoles"] = new SelectList(_roleManager.Roles, "Name", "Name");
return(View(viewModel));
}
var roleToDelete = viewModel.SelectedRole;
var user = await _userManager.FindByNameAsync(viewModel.Username);
var result = await _userManager.RemoveFromRoleAsync(user, roleToDelete);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
AddErrors(result);
}
}
// If here, then error occured
ViewData["AllRoles"] = new SelectList(_roleManager.Roles, "Name", "Name");
return(View(viewModel));
}
public async Task <IActionResult> EditRole(string id)
{
var role = await roleManager.FindByIdAsync(id);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {id} cannot be found.";
return(View("NotFound"));
}
var model = new EditUserRoleViewModel
{
Id = role.Id,
RoleName = role.Name
};
foreach (var user in userManager.Users.ToList())
{
if (await userManager.IsInRoleAsync(user, role.Name))
{
model.Users.Add(user.UserName);
}
}
return(View(model));
}
public async Task <IActionResult> EditUser(string id)
{
var user = await userManager.FindByIdAsync(id);
EditUserViewModel model = new EditUserViewModel
{
Id = user.Id,
Username = user.UserName,
Email = user.Email,
SecQuestion1 = user.SecurityQuestion1,
SecQuestion2 = user.SecurityQuestion2
};
var roles = roleManager.Roles.ToList();
var rolesUserIsIn = await userManager.GetRolesAsync(user);
var RoleList = new List <EditUserRoleViewModel>();
for (int i = 0; i < roles.Count(); i++)
{
var vm = new EditUserRoleViewModel();
vm.RoleName = roles[i].Name;
if (rolesUserIsIn.Contains(roles[i].Name))
{
vm.IsSelected = true;
}
else
{
vm.IsSelected = false;
}
RoleList.Add(vm);
}
model.Roles = RoleList;
return(View(model));
}
public async Task <IActionResult> EditUserRole(string roleid)
{
var role = await roleManager.FindByIdAsync(roleid);
if (role == null)
{
return(View("NotFound"));
}
List <EditUserRoleViewModel> model = new List <EditUserRoleViewModel>();
foreach (var user in usermanager.Users.ToList())
{
var item = new EditUserRoleViewModel();
item.UserName = user.UserName;
if (await usermanager.IsInRoleAsync(user, role.Name))
{
item.IsSelected = true;
}
else
{
item.IsSelected = false;
}
model.Add(item);
}
ViewBag.RoleId = roleid;
return(View(model));
}
public async Task <ActionResult> Edit(string id)
{
_dbContext = HttpContext.GetOwinContext().Get <ApplicationDbContext>();
var user = await(from u in _dbContext.Users
select new
{
UserId = u.Id,
u.UserName,
Roles = _dbContext.Roles.Where(r => u.Roles.Any(ur => ur.RoleId == r.Id)).Select(r => r.Name)
}).SingleOrDefaultAsync(u => u.UserId == id);
if (user == null)
{
return(HttpNotFound());
}
var roles = await _dbContext.Roles.ToListAsync();
var viewModel = new EditUserRoleViewModel
{
UserId = user.UserId,
UserName = user.UserName,
SelectedRoles = user.Roles,
Roles = roles
};
return(View(viewModel));
}
public async Task <IActionResult> EditRole(EditUserRoleViewModel model)
{
var role = await roleManager.FindByIdAsync(model.Id);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {model.Id} cannot be found.";
return(View("NotFound"));
}
else
{
role.Name = model.RoleName;
var result = await roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
}
/// <summary>
/// edit account
/// </summary>
/// <param name="editUser">user model</param>
/// <returns>true if create false otherwise</returns>
public async Task <bool> Edit(EditUserRoleViewModel editUser)
{
try
{
var user = await _userManager.FindByIdAsync(editUser.Id);
var userRole = await _userManager.GetRolesAsync(user);
var result = await _userManager.RemoveFromRolesAsync(user, userRole);
if (result.Succeeded)
{
result = await _userManager.AddToRoleAsync(user, editUser.IsSuperAdmin? "SuperAdmin" : "ContentManager");
_logger.LogInformation(user.Email + " Was Edited by Super Admin");
return(true);
}
else
{
return(false);
}
}
catch
{
return(false);
}
}
public IActionResult Put(EditUserRoleViewModel userRoleViewModel)
{
try
{
var user = _userManager.FindByIdAsync(userRoleViewModel.UserId).Result;
if (user == null)
{
return(BadRequest($"UserId ({userRoleViewModel.UserId}) does not exists!"));
}
string oldRole = _userManager.GetRolesAsync(user).Result.FirstOrDefault();
if (!string.IsNullOrEmpty(oldRole))
{
_userManager.RemoveFromRoleAsync(user, oldRole).Wait();
}
_userManager.AddToRoleAsync(user, userRoleViewModel.Role).Wait();
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var user = (from u in _context.CUsers
select new
{
UserId = u.Id,
u.UserName,
Roles = _context.CRoles.Where(r => r.CUsersRoles.Any(ur => ur.UserId == u.Id)).Select(r => r.RoleName).ToList()
}).SingleOrDefault(u => u.UserId == id);
if (user == null)
{
return(NotFound());
}
var roles = _context.CRoles.ToList();
var viewModel = new EditUserRoleViewModel
{
UserId = user.UserId,
UserName = user.UserName,
SelectedRoles = user.Roles,
Roles = roles
};
return(View(viewModel));
}
public ActionResult Edit(string userId)
{
var userRoles = _userRoleService.GetUserRole(userId);
var roles = _roleRepository.Find(x => x.IsActive && x.Id != "Admin");
var viewModel = new EditUserRoleViewModel
{
Roles = roles,
UserRole = userRoles
};
return(View(viewModel));
}
// duplicated action EDIT POST/GET and changed to EditUserRoles
// GET: ManageUsers/EditUserRoles/5
public ActionResult EditUserRoles(string Id)
{
if (Id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (!UserRoleHelper.IsAdmin(User.Identity.GetUserId())) // check if current user has admin rights
{
return(RedirectToAction("AccessDenied", "Manage"));
}
ApplicationUser CurrUser = dbcontext.Users.Find(Id);
if (CurrUser == null)
{
return(HttpNotFound());
}
EditUserRoleViewModel field = new EditUserRoleViewModel(); // get access to model fields we will be showing
var userStore = new UserStore <ApplicationUser>(dbcontext); // access to roles using Identity Framework
var userManager = new UserManager <ApplicationUser>(userStore);
// update db info with new data given by user in form View
field.Id = CurrUser.Id;
field.UserName = CurrUser.UserName;
field.Email = CurrUser.Email;
field.Name = CurrUser.Name;
field.Surname = CurrUser.Surname;
field.Country = CurrUser.Country;
field.Town = CurrUser.Town;
field.Street = CurrUser.Street;
field.NumHouse = CurrUser.NumHouse;
field.NumFlat = CurrUser.NumFlat;
field.ZIPCode = CurrUser.ZIPCode;
field.PhoneNumber = CurrUser.PhoneNumber;
if (UserRoleHelper.IsAdmin(field.Id))
{
field.RoleType = UserRoleTypes.Administrator;
}
if (UserRoleHelper.IsEmployee(field.Id))
{
field.RoleType = UserRoleTypes.Employee;
}
if (UserRoleHelper.IsUser(field.Id))
{
field.RoleType = UserRoleTypes.Customer;
}
return(View(field));
}
public IActionResult Register()
{
RegisterViewModel model = new RegisterViewModel();
var roles = roleManager.Roles;
foreach (AppRole role in roles)
{
EditUserRoleViewModel vm = new EditUserRoleViewModel();
vm.IsSelected = false;
vm.RoleName = role.Name;
model.Roles.Add(vm);
}
return(View(model));
}
public async Task DeleteUserRole(Guid userId, [FromForm] EditUserRoleViewModel model)
{
var command = new DeleteUserRoleCommand(
userId,
model.RoleIds
);
await _bus.SendCommand(command);
if (_notifications.HasNotifications())
{
var errorMessage = _notifications.GetNotificationMessage();
throw new GirvsException(StatusCodes.Status400BadRequest, errorMessage);
}
}
public async Task <IActionResult> Edit(string userId)
{
var user = await _userService.GetUserAsync(userId);
var editUserRoleViewModel = new EditUserRoleViewModel();
editUserRoleViewModel.UserId = user.Id;
editUserRoleViewModel.Email = user.Email;
var roles = await _roleService.GetAllRoles();
editUserRoleViewModel.Roles = roles;
return(View("UserRoleEdit", editUserRoleViewModel));
}
public async Task <ActionResult> Edit([Bind(Include = "UserName,Email,Id")] EditUserRoleViewModel editUser, params string[] selectedRole)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(editUser.Id);
if (user == null)
{
return(HttpNotFound());
}
//不允许修改用户名
user.Email = editUser.Email;
//更新用户信息
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
return(View());
}
//更新角色
//删除现有角色
//var userRoles = user.Roles.ToList();
//userRoles.ForEach(t => _db.Set<IdentityUserRole>().Remove(t));
// 清楚该用户的所有角色
IList <string> roles = await _userManager.GetRolesAsync(user);
foreach (string roleName in roles)
{
await _userManager.RemoveFromRolesAsync(user.Id, roleName);
}
//添加所选角色
selectedRole = selectedRole ?? new string[] { };
foreach (string roleName in selectedRole)
{
//var userRole = new IdentityUserRole { RoleId = roleId, UserId = user.Id };
//_db.Set<IdentityUserRole>().Add(userRole);
await _userManager.AddToRoleAsync(user.Id, roleName);
}
//_db.SaveChanges();
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "操作失败。");
return(View());
}
public IActionResult CreateUser()
{
CreateUserViewModel model = new CreateUserViewModel();
var roles = roleManager.Roles.ToList();
var RoleList = new List <EditUserRoleViewModel>();
for (int i = 0; i < roles.Count(); i++)
{
var vm = new EditUserRoleViewModel();
vm.RoleName = roles[i].Name;
vm.IsSelected = false;
RoleList.Add(vm);
}
model.Roles = RoleList;
return(View(model));
}
// GET: UserRoles/AddRole/5
public async Task <ActionResult> AddRole(string id)
{
// Get user
var user = await _userManager.FindByNameAsync(id);
var usersRoles = await _userManager.GetRolesAsync(user);
// Convert into a view model
var viewModel = new EditUserRoleViewModel()
{
Username = user.UserName,
Email = user.Email,
Roles = usersRoles
};
ViewData["AllRoles"] = new SelectList(_roleManager.Roles, "Name", "Name");
return(View(viewModel));
}
public IActionResult Edit(EditUserRoleViewModel viewModel, int id)
{
if (ModelState.IsValid)
{
var user = _context.CUsers.Find(viewModel.UserId);
_context.CUsersRoles.Where(r => r.UserId == viewModel.UserId).ToList().ForEach(r => _context.CUsersRoles.Remove(r));
foreach (var roleId in viewModel.SelectedRoles)
{
int roleID = Convert.ToInt32(roleId);
user.CUsersRoles.Add(new CUsersRoles()
{
RoleId = roleID,
UserId = viewModel.UserId
});
}
_context.SaveChanges();
Success();
return(RedirectToAction(nameof(Index)));
}
return(RedirectToAction("Edit", id));
}
public async Task <IActionResult> Edit(EditUserRoleViewModel editUser)
{
var isEdited = await _userManagment.Edit(editUser);
if (isEdited)
{
if (!editUser.IsSuperAdmin)
{
AddDefaultConfig(editUser.Id);
}
_toastNotification.AddSuccessToastMessage(editUser.Email + " Edited Successfully");
_eventLogger.LogInfoEvent(HttpContext.User.Identity.Name, Common.ActivityEnum.Update, "Super Admin > User Managment > Edit", editUser.Email + " Edited Successfully");
return(RedirectToAction("Index", "Home"));
}
else
{
_toastNotification.AddErrorToastMessage("There is Error in Delete " + editUser.Email);
_logger.LogError("There is Error in Delete " + editUser.Email);
return(View());
}
}
public async Task <IActionResult> EditUsersInRole(string roleId, string msg)
{
ViewBag.roleId = roleId;
if (msg != null && msg.Equals("rlinuse"))
{
ViewBag.ErrorMessage = $"UserName is already added to this role";
}
else if (msg != null && msg.Equals("ntblnk"))
{
ViewBag.ErrorMessage = $"UserName is Required";
}
var role = await roleManager.FindByIdAsync(roleId);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {roleId} cannot be found";
return(View("NotFound"));
}
var model = new EditUserRoleViewModel();
foreach (var user in userManager.Users)
{
var userRoleViewModel = new UserRoleViewModel
{
UserId = user.Id,
UserName = user.UserName
};
if (await userManager.IsInRoleAsync(user, role.Name))
{
model.Users.Add(userRoleViewModel);
}
}
return(View(model));
}
public async Task <ActionResult> Edit(EditUserRoleViewModel viewModel)
{
_dbContext = HttpContext.GetOwinContext().Get <ApplicationDbContext>();
if (!ModelState.IsValid)
{
viewModel.Roles = await _dbContext.Roles.ToListAsync();
return(View(viewModel));
}
var user = _dbContext.Users.Find(viewModel.UserId);
user.Roles.Clear();
foreach (var roleId in viewModel.SelectedRoles)
{
user.Roles.Add(new IdentityUserRole {
RoleId = roleId
});
}
await _dbContext.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> AddRole(string id, EditUserRoleViewModel viewModel)
{
if (ModelState.IsValid)
{
var roleToAdd = viewModel.SelectedRole;
var user = await _userManager.FindByNameAsync(id);
var result = await _userManager.AddToRoleAsync(user, roleToAdd);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
AddErrors(result);
}
}
// If here, then error occured
ViewData["AllRoles"] = new SelectList(_roleManager.Roles, "Name", "Name");
return(View(viewModel));
}
public async Task <IActionResult> Edit(string id)
{
var user = await _userManager.FindByIdAsync(id);
EditUserRoleViewModel dto = new EditUserRoleViewModel();
if (id == null || user == null)
{
return(StatusCode(404));
}
else
{
ViewBag.Roles = _roleManager.Roles.Select(x => x.Name).ToList();
dto.Email = user.Email;
dto.Id = user.Id;
dto.IsSuperAdmin = await _userManager.IsInRoleAsync(user, UserRolesConst.SuperAdmin);
dto.IsFirstLogin = user.isFirstLogin;
dto.TwoFactorEnabled = user.TwoFactorEnabled;
dto.EmailConfirmed = user.EmailConfirmed;
}
return(View(dto));
}
public ActionResult Edit(EditUserRoleViewModel viewModel)
{
var selectedRoles = viewModel.CheckedRoles != null
? viewModel.CheckedRoles.Split(',').Select(x => x.ToString())
: new List <string>();
//check first if user have roles
if (!selectedRoles.Any())
{
ModelState.AddModelError("", "No selected role");
var roles = _roleRepository.Find(x => x.IsActive && x.Id != "Admin");
var userRoles = _userRoleService.GetUserRole(viewModel.UserRole.Id);
viewModel.Roles = roles;
viewModel.UserRole = userRoles;
return(View(viewModel));
}
//update user
var user = _userRepository.GetById(viewModel.UserRole.Id);
_userRepository.Update(user);
user.FirstName = viewModel.UserRole.FirstName;
user.LastName = viewModel.UserRole.LastName;
user.PasswordHash = UserManager.PasswordHasher.HashPassword(viewModel.Password);
user.UserName = viewModel.UserRole.UserName;
//update roles
_userRoleRepository.UpdateUserRole(viewModel.UserRole.Id, selectedRoles);
_unitOfWork.Commit();
_logger.Info(Payroll.Resources.LoggerMessages.INFO_ACCOUNT_UPDATE, user.Id, User.Identity.GetUserId());
_logger.Info(Payroll.Resources.LoggerMessages.INFO_ACCOUNT_UPDATE_ROLE, user.Id, String.Join(",", selectedRoles), User.Identity.GetUserId());
return(RedirectToAction("Index"));
}
// all fields will be used so instead of Bind we can use just the ready Model for it
public ActionResult EditUserRoles(EditUserRoleViewModel model)
{
if (ModelState.IsValid)
{
if (!UserRoleHelper.IsAdmin(User.Identity.GetUserId())) // check if current user has admin rights
{
return(RedirectToAction("AccessDenied", "Manage"));
}
ApplicationUser CurrUser = dbcontext.Users.Find(model.Id);
if (CurrUser == null || model.Id == null)
{
return(HttpNotFound());
}
// user cannot change his own role. Check if user currently editing has same id as the one being edited
if (model.Id == User.Identity.GetUserId())
{
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeOwnRoleErr }));
}
// declaration of needed variables to have the ability to change user roles : Identity Framework. Takes role types and users we will be later using from DB
var userStore = new UserStore <ApplicationUser>(dbcontext);
var userManager = new UserManager <ApplicationUser>(userStore);
// change user role to Administrator
if (model.RoleType == UserRoleTypes.Administrator)
{
if (userManager.IsInRole(CurrUser.Id, "User"))
{
userManager.RemoveFromRole(CurrUser.Id, "User");
}
if (userManager.IsInRole(CurrUser.Id, "Employee"))
{
userManager.RemoveFromRole(CurrUser.Id, "Employee");
}
userManager.AddToRole(CurrUser.Id, "Administrator");
dbcontext.Entry(CurrUser).State = System.Data.Entity.EntityState.Modified;
dbcontext.SaveChanges();
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeRoleToAdmin }));
}
// change user role to Employee
if (model.RoleType == UserRoleTypes.Employee)
{
if (userManager.IsInRole(CurrUser.Id, "User"))
{
userManager.RemoveFromRole(CurrUser.Id, "User");
}
if (userManager.IsInRole(CurrUser.Id, "Administrator"))
{
userManager.RemoveFromRole(CurrUser.Id, "Administrator");
}
userManager.AddToRole(CurrUser.Id, "Employee");
dbcontext.Entry(CurrUser).State = System.Data.Entity.EntityState.Modified;
dbcontext.SaveChanges();
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeRoleToEmployee }));
}
// change user role to Customer\User
if (model.RoleType == UserRoleTypes.Customer)
{
if (userManager.IsInRole(CurrUser.Id, "Employee"))
{
userManager.RemoveFromRole(CurrUser.Id, "Employee");
}
if (userManager.IsInRole(CurrUser.Id, "Administrator"))
{
userManager.RemoveFromRole(CurrUser.Id, "Administrator");
}
userManager.AddToRole(CurrUser.Id, "User");
dbcontext.Entry(CurrUser).State = System.Data.Entity.EntityState.Modified;
dbcontext.SaveChanges();
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeRoleToCustomer }));
}
return(RedirectToAction("Index", new { Message = ManageMessageId.Error }));
}
return(View(model));
}
public ActionResult EditRole(string userId)
{
EditUserRoleViewModel model = this.service.GetUserRoles(userId);
return(this.View(model));
}
public override async Task <IDisplayResult> UpdateAsync(User user, UpdateEditorContext context)
{
var model = new EditUserRoleViewModel();
// The current user cannot alter their own roles. This prevents them removing access to the site for themselves.
if (String.Equals(_httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier), user.UserId, StringComparison.OrdinalIgnoreCase))
{
return(Edit(user));
}
if (await context.Updater.TryUpdateModelAsync(model, Prefix))
{
// Authorize each role in the model to prevent html injection.
var authorizedRoleNames = await GetAuthorizedRoleNamesAsync(model.Roles.Select(x => x.Role));
var userRoleNames = await _userRoleStore.GetRolesAsync(user, default(CancellationToken));
var authorizedSelectedRoleNames = await GetAuthorizedRoleNamesAsync(model.Roles.Where(x => x.IsSelected).Select(x => x.Role));
if (context.IsNew)
{
// Only add authorized new roles.
foreach (var role in authorizedSelectedRoleNames)
{
await _userRoleStore.AddToRoleAsync(user, _userManager.NormalizeName(role), default(CancellationToken));
}
}
else
{
// Remove roles in two steps to prevent an iteration on a modified collection
var rolesToRemove = new List <string>();
foreach (var role in userRoleNames)
{
// When the user has permission to manage the role and it is no longer selected the role can be removed.
if (authorizedRoleNames.Contains(role, StringComparer.OrdinalIgnoreCase) && !authorizedSelectedRoleNames.Contains(role, StringComparer.OrdinalIgnoreCase))
{
rolesToRemove.Add(role);
}
}
foreach (var role in rolesToRemove)
{
if (String.Equals(role, AdministratorRole, StringComparison.OrdinalIgnoreCase))
{
var usersOfAdminRole = (await _userManager.GetUsersInRoleAsync(AdministratorRole)).Cast <User>();
// Make sure we always have at least one administrator account
if (usersOfAdminRole.Count() == 1 && String.Equals(user.UserId, usersOfAdminRole.First().UserId, StringComparison.OrdinalIgnoreCase))
{
_notifier.Warning(H["Cannot remove administrator role from the only administrator."]);
continue;
}
else
{
await _userRoleStore.RemoveFromRoleAsync(user, _userManager.NormalizeName(role), default(CancellationToken));
}
}
else
{
await _userRoleStore.RemoveFromRoleAsync(user, _userManager.NormalizeName(role), default(CancellationToken));
}
}
// Add new roles
foreach (var role in authorizedSelectedRoleNames)
{
if (!await _userRoleStore.IsInRoleAsync(user, _userManager.NormalizeName(role), default(CancellationToken)))
{
await _userRoleStore.AddToRoleAsync(user, _userManager.NormalizeName(role), default(CancellationToken));
}
}
}
}
return(Edit(user));
}
public async Task <IActionResult> EditUsersInRole(EditUserRoleViewModel model, string roleId, string task)
{
var role = await roleManager.FindByIdAsync(roleId);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {roleId} cannot be found";
return(View("NotFound"));
}
if (task.Equals("Add"))
{
if (model.UserName == null)
{
ModelState.AddModelError(string.Empty, "UserName Required");
return(RedirectToAction("EditUsersInRole", new { roleId = roleId, msg = "ntblnk" }));
}
var user = await userManager.FindByEmailAsync(model.UserName);
IdentityResult result = null;
if (user == null)
{
ViewBag.ErrorMessage = $"Role with Id = {model.UserName} cannot be found";
return(View("NotFound"));
}
if (!(await userManager.IsInRoleAsync(user, role.Name)))
{
result = await userManager.AddToRoleAsync(user, role.Name);
if (result.Succeeded)
{
return(RedirectToAction("EditRole", new { Id = roleId }));
}
}
else
{
return(RedirectToAction("EditUsersInRole", new { roleId = roleId, msg = "rlinuse" }));
}
}
else if (task.Equals("Remove"))
{
for (int i = 0; i < model.Users.Count; i++)
{
var user = await userManager.FindByIdAsync(model.Users[i].UserId);
IdentityResult result = null;
if (model.Users[i].IsSelected && await userManager.IsInRoleAsync(user, role.Name))
{
result = await userManager.RemoveFromRoleAsync(user, role.Name);
}
else
{
continue;
}
if (result.Succeeded)
{
if (i < (model.Users.Count - 1))
{
continue;
}
else
{
return(RedirectToAction("EditRole", new { Id = roleId }));
}
}
}
}
return(RedirectToAction("EditRole", new { Id = roleId }));
}
