public async Task <IdentityResult> Put([FromBody] RoleModificationViewModel model)
{
var result = IdentityResult.Success;
foreach (var userId in model.IdsToAdd ?? new string[] { })
{
var user = await _userManager.FindByIdAsync(userId);
result = await _userManager.AddToRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
return(result);
}
}
foreach (var userId in model.IdsToDelete ?? new string[] { })
{
var user = await _userManager.FindByIdAsync(userId);
result = await _userManager.RemoveFromRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
return(result);
}
}
return(result);
}
public async Task <ActionResult> Edit(RoleModificationViewModel model)
{
IdentityResult result;
if (ModelState.IsValid)
{
foreach (string userId in model.IdsToAdd ?? new string[] { })
{
result = await _userManager.AddToRoleAsync(userId, model.RoleName);
if (!result.Succeeded)
{
return(View("_Error", result.Errors));
}
}
foreach (string userId in model.IdsToDelete ?? new string[] { })
{
result = await _userManager.RemoveFromRoleAsync(userId, model.RoleName);
if (!result.Succeeded)
{
return(View("_Error", result.Errors));
}
}
return(RedirectToAction("Index"));
}
return(View("_Error", new string[] { "Role Not Found" }));
}
} // end public async Task<IActionResult> OnGetAsync(string id)
public async Task<IActionResult> OnPostAsync([FromForm]RoleModificationViewModel model)
{
IdentityResult result;
if (ModelState.IsValid)
{
if (model.IdsToAdd != null) // Avoid null exception
{
foreach (string addId in model.IdsToAdd)
{
Core3IDUser user = await userManager.FindByIdAsync(addId);
if (user == null)
{
return BadRequest(String.Format("User with Id, {0}, was not found and cannot be added to role, {1}.", addId, model.RoleName));
}
else
{
result = await userManager.AddToRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
} // endif (!result.Succeeded)
} // endif (user == null)
} // end foreach (string addId in model.IdsToAdd)
} // endif (model.IdsToAdd != null)
if (model.IdsToDelete != null) // Avoid null exception
{
foreach (string deleteId in model.IdsToDelete)
{
Core3IDUser user = await userManager.FindByIdAsync(deleteId);
if (user == null)
{
return BadRequest(String.Format("User with Id, {0}, was not found and cannot be deleted from role, {1}.", deleteId, model.RoleName));
}
else
{
result = await userManager.RemoveFromRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
} // endif (!result.Succeeded)
} // endif (user == null)
} // end foreach (string deleteId in model.IdsToDelete)
} // endif (model.IdsToDelete != null)
} // endif (ModelState.IsValid)
return RedirectToPage("/RoleAdmin/ManageUsers", new { id = model.RoleId });
} // end public async Task<IActionResult> Edit(RoleModificationViewModel model)
public async Task <IActionResult> RoleUsersMembership(string roleId)
{
var role = await roleManager.FindByIdAsync(roleId);
if (role == null)
{
ViewBag.ErrorMessage($"Sorry, the role with Id = {roleId} could not be found");
return(RedirectToAction("NotFound"));
}
var model = new RoleModificationViewModel()
{
RoleId = role.Id,
RoleName = role.Name
};
model.Users = new List <string>();
model.Obj = new List <UserRoleViewModel>();
foreach (var user in userManager.Users.ToList())
{
if (await userManager.IsInRoleAsync(user, role.Name))
{
model.Users.Add(user.UserName);
}
}
foreach (var user in userManager.Users.ToList())
{
var userRole = new UserRoleViewModel()
{
UserId = user.Id,
UserName = user.UserName
};
if (await userManager.IsInRoleAsync(user, role.Name))
{
userRole.IsSelected = true;
}
else
{
userRole.IsSelected = false;
}
model.Obj.Add(userRole);
}
return(View(model));
}
public async Task <IActionResult> Edit(RoleModificationViewModel model)
{
IdentityResult result;
if (ModelState.IsValid)
{
foreach (string userId in model.IdsToAdd ?? new string[] { })
{
ApplicationUser user = await userManager.FindByIdAsync(userId);
if (user != null)
{
// below line code used in AccountController to add all
// new users to the "Users" role as soon as they Register.
result = await userManager.AddToRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
}
}
}
foreach (string userId in model.IdsToDelete ?? new string[] { })
{
ApplicationUser user = await userManager.FindByIdAsync(userId);
if (user != null)
{
result = await userManager.RemoveFromRoleAsync(user,
model.RoleName);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
}
}
}
}
if (ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
else
{
return(await Edit(model.RoleId));
}
}
public async Task <IActionResult> Edit(RoleModificationViewModel model)
{
IdentityResult result;
if (ModelState.IsValid)
{
foreach (string userId in model.IdsToAdd ?? new string[] { })
{
AppUser user = await userManager.FindByIdAsync(userId);
if (user != null)
{
result = await userManager.AddToRoleAsync(user,
model.RoleName);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
}
}
}
foreach (string userId in model.IdsToDelete ?? new string[] { })
{
AppUser user = await userManager.FindByIdAsync(userId);
if (user != null)
{
result = await userManager.RemoveFromRoleAsync(user,
model.RoleName);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
}
}
}
}
if (ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
else
{
return(await Edit(model.RoleId));
}
}
public async Task <ActionResult> Edit(RoleModificationViewModel model)
{
IdentityResult result;
if (ModelState.IsValid)
{
var role = await RoleManager.FindByNameAsync(model.RoleName);
if (role != null)
{
role.IsAvailableForAdministrators = model.IsAvailableForAdministrators;
result = await RoleManager.UpdateAsync(role);
if (!result.Succeeded)
{
return(View("Error", result.Errors));
}
}
else
{
return(View("Error", new string[] { "Ролята не е намерена!" }));
}
foreach (string userId in model.IdsToAdd ?? new string[] { })
{
result = await UserManager.AddToRoleAsync(userId, model.RoleName);
if (!result.Succeeded)
{
return(View("Error", result.Errors));
}
}
foreach (string userId in model.IdsToDelete ?? new string[] { })
{
result = await UserManager.RemoveFromRoleAsync(userId, model.RoleName);
if (!result.Succeeded)
{
return(View("Error", result.Errors));
}
}
return(RedirectToAction("Index"));
}
return(View("Error", new string[] { "Ролята не е намерена!" }));
}
public async Task <ActionResult> Edit(RoleModificationViewModel model)
{
if (!ModelState.IsValid)
{
return(HttpNotFound("Role Not Found"));
}
var result = await _authorizationServerManager.UpdateRoleAsync(model);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
RedirectToAction("Edit", "RoleAdmin", model.Id);
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> EditRole(RoleModificationViewModel model)
{
IdentityResult result;
if (ModelState.IsValid)
{
foreach (string userId in model.IdsToAdd ?? new string[] { })
{
AppUser user = await userManager.FindByIdAsync(userId);
if (user != null)
{
result = await userManager.AddToRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
}
}
}
foreach (string userId in model.IdsToDelete ?? new string[] { })
{
AppUser user = await userManager.FindByIdAsync(userId);
if (user != null)
{
result = await userManager.RemoveFromRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
}
}
}
}
if (ModelState.IsValid)
{
TempData["SuccessMessage"] = "Udało się zapisać użytkowników w grupach";
return(RedirectToAction("Roles"));
}
else
{
return(await EditRole(model.RoleId));
}
}
public async Task <IActionResult> Edit(RoleModificationViewModel roleModificationViewModel)
{
if (ModelState.IsValid)
{
foreach (var userId in roleModificationViewModel.ToAdd ?? new string[] { })
{
User user = await this.userManager.FindByIdAsync(userId);
if (user != null)
{
IdentityResult result = await this.userManager.AddToRoleAsync(user, roleModificationViewModel.RoleName);
if (!result.Succeeded)
{
ModelState.AddModelError(string.Empty, result.Errors.ToString());
}
}
}
foreach (var userId in roleModificationViewModel.ToDelete ?? new string[] { })
{
User user = await this.userManager.FindByIdAsync(userId);
if (user != null)
{
IdentityResult result = await this.userManager.RemoveFromRoleAsync(user, roleModificationViewModel.RoleName);
if (!result.Succeeded)
{
ModelState.AddModelError(string.Empty, result.Errors.ToString());
}
}
}
}
if (ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
else
{
return(await Edit(roleModificationViewModel.RoleId));
}
}
public async Task <IActionResult> RoleUsersMembership(RoleModificationViewModel model)
{
var role = await roleManager.FindByIdAsync(model.RoleId);
if (role == null)
{
ViewBag.ErroMessage = $"Sorry, the role with the Id = {model.RoleId} could not be found";
return(RedirectToAction("NotFound"));
}
for (int i = 0; i < model.Obj.Count; i++)
{
var user = await userManager.FindByIdAsync(model.Obj[i].UserId);
IdentityResult result = new IdentityResult();
if (model.Obj[i].IsSelected && !(await userManager.IsInRoleAsync(user, role.Name)))
{
result = await userManager.AddToRoleAsync(user, role.Name);
}
else if (!model.Obj[i].IsSelected && await userManager.IsInRoleAsync(user, role.Name))
{
result = await userManager.RemoveFromRoleAsync(user, role.Name);
}
else
{
continue;
}
if (result.Succeeded)
{
if (i < model.Obj.Count - 1)
{
continue;
}
else
{
return(RedirectToAction("RoleUsersMembership", new { roleId = model.RoleId }));
}
}
}
return(RedirectToAction("RoleUsersMembership", new { roleId = model.RoleId }));
}
public IActionResult Edit(RoleModificationViewModel model)
{
if (ModelState.IsValid)
{
foreach (var userLogin in model.LoginsToAdd ?? new string[] { })
{
var user = userService.FindByLogin(userLogin);
userService.AddToRole(user, model.RoleName);
}
foreach (var userLogin in model.LoginsToDelete ?? new string[] { })
{
var user = userService.FindByLogin(userLogin);
userService.RemoveFromRole(user, model.RoleName);
}
return(RedirectToAction(nameof(Index)));
}
return(RedirectToAction(nameof(Edit), model.RoleId));
}
public async Task <IActionResult> EditRole(RoleModificationViewModel model)
{
if (ModelState.IsValid)
{
foreach (int userId in model.IdsToAdd ?? new int[] {})
{
var user = _userServices.GetItem(userId);
if (user != null)
{
var result = await _userServices.AddToRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
}
}
}
foreach (var userId in model.IdsToDelete ?? new int[] { })
{
var user = _userServices.GetItem(userId);
if (user != null)
{
var result = await _userServices.RemoveFromRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
AddErrorsFromResult(result);
}
}
}
}
if (ModelState.IsValid)
{
return(RedirectToAction(nameof(Roles)));
}
return(await EditRole(model.RoleId));
}
public async Task <ActionResult> Edit(RoleModificationViewModel model)
{
IdentityResult result;
if (!ModelState.IsValid)
{
return(View("Error"));
}
foreach (string userId in model.IdsToAdd ?? new string[] { })
{
result = await UserManager.AddToRoleAsync(userId, model.RoleName);
if (!result.Succeeded)
{
return(View("Error"));
}
}
foreach (var userId in model.IdsToDelete ?? new string[] { })
{
//演示用，正式部署时去掉
var currentUser = await UserManager.FindByIdAsync(userId);
if (currentUser.UserName == "000000" && model.RoleName == "Administrator")
{
return(View("Error"));
}
result = await UserManager.RemoveFromRoleAsync(userId, model.RoleName);
if (!result.Succeeded)
{
return(View("Error"));
}
}
return(RedirectToAction("Index"));
}
public async Task <IdentityResult> UpdateRoleAsync(RoleModificationViewModel model)
{
HttpResponseMessage response = await _client.PutAsJsonAsync("api/role", model);
return(GetIdentityResult(await response.Content.ReadAsAsync <JObject>()));
}
