public async Task <ActionResult> EditUserRoles([FromForm] EditUserRolesViewModel model)
{
//find the user
var user = _userManager.Users.First(u => u.Id.Equals(model.User.Id));
//add/remove roles from user as appropriate
foreach (var appRole in model.ApplicationRoles)
{
if (model.UserRoles != null && model.UserRoles.Contains(appRole))
{
await _userManager.AddToRoleAsync(user, appRole);
}
else
{
await _userManager.RemoveFromRoleAsync(user, appRole);
}
}
//get list of roles back from server
//could use model, fetching from server just in-case it didn't succeed for some reason
var userRoles = await _userManager.GetRolesAsync(user);
model.UserRoles = userRoles.ToList();
return(View(model));
}
public ActionResult EditUserRoles(string id, EditUserRolesViewModel formData)
{
var user = bugTrackerHelper.GetUserById(id);
var currentUserId = User.Identity.GetUserId();
foreach (var role in formData.UserRoles)
{
if (role.IsChecked && !UserManager.IsInRole(user.Id, role.RoleName))
{
UserManager.AddToRole(user.Id, role.RoleName);
}
else if (!role.IsChecked && UserManager.IsInRole(user.Id, role.RoleName))
{
if (!(currentUserId == id && role.RoleName == "Admin"))
{
UserManager.RemoveFromRole(user.Id, role.RoleName);
}
}
}
// If admin edit his roles re-assign his account
if (id == currentUserId)
{
var authenticationManager = HttpContext.GetOwinContext().Authentication;
var identity = UserManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
authenticationManager.SignIn(new AuthenticationProperties {
IsPersistent = false
}, identity);
}
return(RedirectToAction(nameof(HomeController.ManageUsers)));
}
public async Task <IActionResult> EditUserRoles(string userId)
{
ViewBag.userId = userId;
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with id : {userId} it can not be found";
return(View("NotFound"));
}
var model = new List <EditUserRolesViewModel>();
foreach (var role in _roleManager.Roles)
{
var editUserRolesViewModel = new EditUserRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
editUserRolesViewModel.IsSelected = true;
}
else
{
editUserRolesViewModel.IsSelected = false;
}
model.Add(editUserRolesViewModel);
}
return(View(model));
}
public async Task <IActionResult> EditUserRoles(string id)
{
ApplicationUser user = await userManager.FindByIdAsync(id);
if (user != null)
{
EditUserRolesViewModel model = new EditUserRolesViewModel
{
UserId = user.Id,
UserName = user.FirstName + " " + user.LastName,
Email = user.Email,
};
// Retrieve all the roles in the system.
IEnumerable <IdentityRole> roles = roleManager.Roles;
// Sort the roles by name then Loop through each role
foreach (var role in roles.OrderBy(x => x.Name).ToList())
{
model.Roles.Add(role.Name);
// Check if the user is in the role.
model.IsInRole.Add(await userManager.IsInRoleAsync(user, role.Name));
}
return(View(model));
}
else
{
ModelState.AddModelError("", $"User selected is not found");
return(RedirectToAction("UserList", "Admin"));
}
}
public async Task <IActionResult> UpdateUserRoles(string userName, EditUserRolesViewModel editUserRolesDto)
{
var user = await _userManager.FindByNameAsync(userName);
if (user == null)
{
return(NotFound("User not found!"));
}
var roles = await _userManager.GetRolesAsync(user);
roles = roles ?? new List <string>();
var result = await _userManager.AddToRolesAsync(user, editUserRolesDto.Roles.Except(roles));
if (!result.Succeeded)
{
return(BadRequest("Failed adding roles to the user."));
}
result = await _userManager.RemoveFromRolesAsync(user, roles.Except(editUserRolesDto.Roles));
if (!result.Succeeded)
{
return(BadRequest("Failed removing roles from the user"));
}
return(Ok(await _userManager.GetRolesAsync(user)));
}
public ActionResult EditUserRoles(string id)
{
var model = new EditUserRolesViewModel();
var user = bugTrackerHelper.GetUserById(id);
model.UserId = id;
model.DisplayName = user.DisplayName;
model.UserName = user.UserName;
var allRoles = bugTrackerHelper.GetAllRolesNames();
var userRolesId = user.Roles.Select(role => role.RoleId).ToList();
for (var i = 0; i < DbContext.Roles.Count(); i++)
{
Role role = new Role();
role.RoleName = allRoles[i];
if (UserManager.IsInRole(id, allRoles[i]))
{
role.IsChecked = true;
}
else
{
role.IsChecked = false;
}
model.UserRoles.Add(role);
}
return(View(model));
}
public async Task <IActionResult> OnGetAsync(string userid)
{
try
{
// получаем пользователя
User user = await _userManager.FindByIdAsync(userid);
IsSystemAdmin = _getAccountDataService.IsSystemAdmin();
if (user != null && IsSystemAdmin)
{
// получем список ролей пользователя
var userSystemRoles = await _userManager.GetRolesAsync(user);
var allSystemRoles = _roleManager.Roles.ToList();
EditUserRolesViewModel = new EditUserRolesViewModel
{
UserId = user.Id.ToString(),
UserEmail = user.Email,
UserSystemRoles = userSystemRoles,
AllSystemRoles = allSystemRoles
};
return(Page());
}
return(NotFound());
}
catch (Exception e)
{
_logger.LogError(e, "Error while loading EditUserRoles page");
return(NotFound());
}
}
public override async Task <IViewProviderResult> BuildUpdateAsync(User user, IViewProviderContext context)
{
// Build selected roles
var rolesToAdd = GetSelectedRoles();
// Update model
var model = new EditUserRolesViewModel
{
SelectedRoles = rolesToAdd
};
if (!await context.Updater.TryUpdateModelAsync(model))
{
return(await BuildEditAsync(user, context));
}
if (context.Updater.ModelState.IsValid)
{
var rolesToRemove = new List <string>();
foreach (var role in await _userManager.GetRolesAsync(user))
{
if (!rolesToAdd.Contains(role))
{
rolesToRemove.Add(role);
}
}
foreach (var role in rolesToRemove)
{
await _userManager.RemoveFromRoleAsync(user, role);
}
// Add new roles
foreach (var role in rolesToAdd)
{
if (!await _userManager.IsInRoleAsync(user, role))
{
await _userManager.AddToRoleAsync(user, role);
}
}
// Update user
var result = await _userManager.UpdateAsync(user);
foreach (var error in result.Errors)
{
context.Updater.ModelState.AddModelError(string.Empty, error.Description);
}
}
return(await BuildEditAsync(user, context));
}
public async Task <IActionResult> RemoveUserFromRole(EditUserRolesViewModel model)
{
var user = await this.userManager.FindByIdAsync(model.UserId);
var roles = await this.userManager.GetRolesAsync(user);
var allRoles = this.roleManager.Roles;
var userRoles = new List <RolesDropDownViewModel>();
foreach (var role in allRoles)
{
bool isInRole = roles.Contains(role.Name);
if (!isInRole)
{
continue;
}
else
{
var roleModel = new RolesDropDownViewModel
{
Id = role.Id,
Name = role.Name,
};
userRoles.Add(roleModel);
}
}
var viewModel = new EditUserRolesViewModel
{
UserName = user.UserName,
UserId = user.Id,
Roles = userRoles,
};
var roleName = allRoles
.Where(n => n.Id == model.RoleId)
.Select(x => x.Name)
.FirstOrDefault();
var result = await this.userManager.RemoveFromRoleAsync(user, roleName);
if (result.Succeeded)
{
return(this.RedirectToAction("AllUsers"));
}
else
{
return(this.View(viewModel));
}
}
public async Task <IActionResult> EditUserRoles(string id)
{
var viewModel = new EditUserRolesViewModel();
viewModel.AllRoles = await _auth.GetRolesAsSelectListItems();
viewModel.User = await _auth.GetUserById(id);
viewModel.SelectedRoles = await _auth.GetUsersRole(viewModel.User);
viewModel.Id = viewModel.User.Id;
viewModel.Email = viewModel.User.Email;
return(View(viewModel));
}
public async Task <ActionResult> Roles(string id)
{
var user = await UserManager.FindByIdAsync(id);
if (user == null)
{
return(HttpNotFound("User not found."));
}
var roleOptions = await GetRoleOptions(user);
var model = new EditUserRolesViewModel(user, roleOptions);
return(View(model));
}
public async Task <ActionResult> EditUserRoles([FromQuery] string userId)
{
//find the user
var user = _userManager.Users.First(u => u.Id.Equals(userId));
//get their roles
var userRoles = await _userManager.GetRolesAsync(user);
var model = new EditUserRolesViewModel();
model.User = user;
model.UserRoles = userRoles.ToList();
//list of all roles available in the application
model.ApplicationRoles = _roleManager.Roles.ToList().Select(x => x.Name).ToList();
return(View(model));
}
public async Task <IActionResult> RemoveUserFromRole(EditUserRolesViewModel model)
{
ApplicationUser user = await userManager.FindByIdAsync(model.UserId);
if (user != null)
{
// Remove user from the selected role.
var result = userManager.RemoveFromRoleAsync(user, model.RoleName);
if (result.Result.Succeeded == false)
{
ModelState.AddModelError("", $"Could not remove user from role {model.RoleName}");
}
}
// Redirect the user back to the edit role page to continue editing the user's roles.
return(RedirectToAction(nameof(EditUserRoles), "Account", routeValues: new { id = model.UserId }));
}
public override async Task <IViewProviderResult> BuildUpdateAsync(CategoryAdmin category,
IViewProviderContext context)
{
// Get posted role names
var rolesToAdd = GetRolesToAdd();
// Update model
var model = new EditUserRolesViewModel
{
SelectedRoles = rolesToAdd
};
if (!await context.Updater.TryUpdateModelAsync(model))
{
return(await BuildEditAsync(category, context));
}
if (context.Updater.ModelState.IsValid)
{
// Remove roles in two steps to prevent an iteration on a modified collection
var rolesToRemove = new List <string>();
foreach (var role in await _categoryManager.GetRolesAsync(category))
{
if (!rolesToAdd.Contains(role))
{
rolesToRemove.Add(role);
}
}
foreach (var role in rolesToRemove)
{
await _categoryManager.RemoveFromRoleAsync(category, role);
}
// Add new roles
foreach (var role in rolesToAdd)
{
if (!await _categoryManager.IsInRoleAsync(category, role))
{
await _categoryManager.AddToRoleAsync(category, role);
}
}
}
return(await BuildEditAsync(category, context));
}
public override async Task ComposeModelAsync(User user, IUpdateModel updater)
{
// Build selected roles
var rolesToAdd = GetSelectedRoles();
// Update model
var model = new EditUserRolesViewModel
{
SelectedRoles = rolesToAdd
};
await updater.TryUpdateModelAsync(model);
if (updater.ModelState.IsValid)
{
user.RoleNames = model.SelectedRoles;
}
}
public ActionResult EditUser(string id)
{
User user = _userService.FindUserById(id);
if (user == null)
{
return(View("Error"));
}
EditUserRolesViewModel editUserModel = new EditUserRolesViewModel()
{
Id = user.Id, UserName = user.UserName
};
editUserModel.AllRoles = _roleService.GetAll();
editUserModel.UserRoles = _userService.GetUserRoles(user.Id);
return(View(editUserModel));
}
public ActionResult EditRoles(EditUserRolesViewModel model)
{
Message msg = new Message();
string userRoles = Request.Form["UserRoles"];
try
{
msg = CMSService.UpdateFieldOneByOne("User", "CMSUser", "UserId=" + model.UserId, "UserRoles", userRoles);
return(RedirectToAction("Index"));
}
catch
{
msg.MessageStatus = "Error";
msg.MessageInfo = "操作出错了";
ViewBag.Status = msg.MessageStatus;
ViewBag.msg = msg.MessageInfo;
return(View());
}
}
public async Task <IActionResult> ManageResearchers()
{
if (TempData["submission"] != null)
{
ViewBag.submission = TempData["submission"].ToString();
ViewBag.AlertType = TempData["AlertType"].ToString();
}
var usersOfRole = await userManager.GetUsersInRoleAsync("Researcher");
// Creates a viewmodel and assigns the username and researcherstatus to the usersWithRoleList IList and the role name to the rolename.
var viewModel = new EditUserRolesViewModel();
foreach (var user in usersOfRole)
{
// Creates a viewmodel and assigns the username and researcherstatus and adds the viewmodel to the usersWithRoleList IList of viewModelList.
var userDetails = new UsersWithRoleViewModel();
userDetails.username = user.Email;
userDetails.Id = user.Id;
var ResearcherExists = await gsv.FindResearcherFromUserId(user.Id);
if (ResearcherExists != null)
{
// Assign only if this user has applied to be a researcher/has a research table.
userDetails.status = ResearcherExists.ResearcherRole;
}
else
{
userDetails.status = "Not Set";
}
viewModel.usersWithRoleList.Add(userDetails);
}
viewModel.roleName = "Researcher";
return(View(viewModel));
}
public async Task <IActionResult> EditUserRoles(EditUserRolesViewModel viewModel)
{
var user = await _auth.GetUserById(viewModel.Id);
IEnumerable <string> oldRoles = _auth.GetUsersRole(user).Result;
var rolesToDelete = oldRoles.Where(oldRoleName => viewModel.SelectedRoles.All(newRoleName => newRoleName != oldRoleName));
await _auth.DeleteRole(user, rolesToDelete);
//rolesToDelete.ToList().ForEach(x => _auth.DeleteRole(x))
viewModel.SelectedRoles.ToList().ForEach(x => _ = _auth.AddRoleToUser(viewModel.Id, x).Result);
// ViewModel.AllRoles = await _auth.GetRolesAsSelectListItems();
// ViewModel.User = await _auth.GetUserById(id);
// ViewModel.SelectedRoles = await _auth.GetUsersRole(ViewModel.User);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> RemoveUserFromRole(string id)
{
var user = await this.userManager.FindByIdAsync(id);
var roles = await this.userManager.GetRolesAsync(user);
var allRoles = this.roleManager.Roles;
var userRoles = new List <RolesDropDownViewModel>();
foreach (var role in allRoles)
{
bool isInRole = roles.Contains(role.Name);
if (!isInRole)
{
continue;
}
else
{
var roleModel = new RolesDropDownViewModel
{
Id = role.Id,
Name = role.Name,
};
userRoles.Add(roleModel);
}
}
var viewModel = new EditUserRolesViewModel
{
UserName = user.UserName,
UserId = user.Id,
Roles = userRoles,
};
return(this.View(viewModel));
}
public async Task <IActionResult> EditUserRole(string id)
{
try
{
var user = await _userManager.FindByIdAsync(id);
if (user != null)
{
var viewModelList = new List <EditUserRolesViewModel>();
foreach (var role in _roleManager.Roles)
{
var viewModel = new EditUserRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
viewModel.IsSelected = true;
}
else
{
viewModel.IsSelected = false;
}
viewModelList.Add(viewModel);
}
return(View(viewModelList));
}
return(NotFound(_localizer.GetString(Message.NotFound)));
}
catch (Exception ex)
{
Log.Error(ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError, _localizer.GetString(Message.SomethingWrongError)));
}
}
// 编辑权限
public ActionResult EditRoles(int id)
{
EditUserRolesViewModel model = new EditUserRolesViewModel();
DataTable dt = CMSService.SelectOne("User", "CMSUser", "UserId=" + id);
foreach (DataRow dr in dt.Rows)
{
UserDto dto = new UserDto();
dto = UserMapping.getDTO(dr);
model.UserId = dto.UserId;
model.UserName = dto.UserName;
model.UserRoles = dto.UserRoles;
}
DataTable RoleDt = CMSService.SelectSome("Role", "CMSRole", "1=1");
List <RoleDto> ListRoles = new List <RoleDto>();
foreach (DataRow dr in RoleDt.Rows)
{
RoleDto roleDto = RoleMapping.getDTO(dr);
ListRoles.Add(roleDto);
}
ViewData["ListRoles"] = ListRoles;
return(View(model));
}
public ActionResult EditUser(EditUserRolesViewModel editUserModel)
{
_userService.EditUserRoles(editUserModel.Id, editUserModel.UserRoles);
return(Redirect(Request.UrlReferrer.PathAndQuery));
}
