public async Task <ActionResult> Change(ChangeUserRoleViewModel model)
{
//get list of role
ViewBag.RoleId = new SelectList(_roleRepository.GetRoles(), "Id", "Name", model.RoleId);
if (ModelState.IsValid)
{
if (model.RoleId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
IdentityRole role = _roleRepository.GetRoleById(model.RoleId);
if (role == null)
{
ModelState.AddModelError(string.Empty, "System was unable to find to chosen role.");
return(View(model));
}
//check if user already exist in such selected role
if (await UserManager.IsInRoleAsync(model.UserId, role.Name))
{
ModelState.AddModelError(string.Empty, "User already exist in role.");
return(View(model));
}
UserManager.RemoveFromRole(model.UserId, model.RoleInUse); //remove user from RoleInUse
IdentityResult result = UserManager.AddToRole(model.UserId, role.Name); //add user role
await UserManager.UpdateSecurityStampAsync(model.UserId);
return(RedirectToAction("Index"));
}
return(View(model));
}
// You should be able to remove user from role here
// GET: /SystemRoles/RemoveFromRole/5
public ActionResult RemoveFromRole(string id, string role)
{
ChangeUserRoleViewModel model = new ChangeUserRoleViewModel();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (role == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var user = UserManager.FindByIdAsync(id);
if (user.Result == null)
{
ModelState.AddModelError(string.Empty, "System was unable to find user.");
return(View());
}
model.Email = user.Result.Email;
model.UserName = user.Result.UserName;
model.UserId = user.Result.Id;
model.RoleInUse = role;
return(View(model));
}
public async Task <IActionResult> ChangeRole([FromForm] ChangeUserRoleViewModel model)
{
var command = this.unitOfWork.Create <ChangeUserRoleCommand>();
await command.ExecuteAsync(model);
return(Redirect($"/Users/Details/{model.Id}"));
}
// You should be able to change user's role from here
// GET: /SystemRoles/Change/5
public ActionResult Change(string id, string role)
{
ChangeUserRoleViewModel model = new ChangeUserRoleViewModel();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (role == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var user = UserManager.FindByIdAsync(id);
if (user.Result == null)
{
ModelState.AddModelError(string.Empty, "System was unable to find user.");
return(View());
}
model.Email = user.Result.Email;
model.UserName = user.Result.UserName;
model.UserId = user.Result.Id;
model.RoleInUse = role;
//get list of role
ViewBag.RoleId = new SelectList(_roleRepository.GetRoles(), "Id", "Name", model.RoleId);
return(View(model));
}
public async Task <IActionResult> Role(string userId)
{
var user = await this.usersService.GetUserById(userId);
if (user == null)
{
return(NotFound());
}
var roles = await this.roleManager
.Roles
.Select(r => new SelectListItem
{
Text = r.Name,
Value = r.Name
})
.ToListAsync();
var model = new ChangeUserRoleViewModel
{
User = user,
Roles = roles
};
return(this.View(model));
}
public ActionResult ChangeRole()
{
ChangeUserRoleViewModel model = new ChangeUserRoleViewModel()
{
Users = adminService.GetUsers(),
MasterPage = UpdateMasterPageData()
};
return(View("~/Views/Admin/ChangeUserRole.cshtml", model));
}
/// <summary>
/// get user roles with select items.
/// </summary>
/// <param name="uid"></param>
/// <returns></returns>
public ChangeUserRoleViewModel GetViewModel(string uid)
{
ChangeUserRoleViewModel mdl;
List <SelectListItem> selecteditemsRoles;
string noAuth = "(无权限)";
SelectListItem sl = new SelectListItem()
{
Selected = true,
Text = noAuth,
Value = "200"
};
selecteditemsRoles = GetRoleListItem().ToList();
selecteditemsRoles.Add(sl);
var u = UserManager.FindById(uid);
string username = null, roleNameList = null;
if (u != null)
{
username = u.UserName;
var r = GetRoleNamesUser(u);
if (r != null)
{
selecteditemsRoles.RemoveAll(a => r.Contains(a.Text));
if (selecteditemsRoles.Count == 0)
{
selecteditemsRoles = new List <SelectListItem>()
{
new SelectListItem()
{
Text = noAuth, Value = "-1"
}
};
}
roleNameList = string.Join(",", r);
}
else
{
roleNameList = noAuth;
}
}
mdl = new ChangeUserRoleViewModel()
{
SelectListRoles = selecteditemsRoles,
Uid = uid,
UserName = username,
RoleList = roleNameList
};
return(mdl);
}
public async Task <IActionResult> Index()
{
var model = new ChangeUsersViewModel();
var users = _userManager.Users.OrderBy(x => x.UserName).ToList();
foreach (var user in users)
{
var userRoles = await _userManager.GetRolesAsync(user);
var userRole = userRoles.FirstOrDefault();
var userVM = new ChangeUserRoleViewModel
{
UserName = user.UserName,
Email = user.Email,
CurrentRole = userRole,
IsUser = userRole == "User",
IsModerator = userRole == "Moderator",
IsAdmin = userRole == "Admin",
};
switch (userRole)
{
case "Admin":
{
model.Administrators.Add(userVM);
break;
}
case "Moderator":
{
model.Moderators.Add(userVM);
break;
}
default:
{
model.Users.Add(userVM);
break;
}
}
}
var roles = _roleManager.Roles.Select(r => r.Name).ToList();
//var theusers = _roleManager.Roles.Where(r=>r.Name=="Admin").Select(r => r.Users);
model.Roles = roles;
//_roleManager.
return(View(model));
}
public async Task <IActionResult> SaveUserRole(ChangeUserRoleViewModel model)
{
var adminUsers = await _userManager.GetUsersInRoleAsync("Admin");
IList <ApplicationUser> blockedAdmins = adminUsers.Where(auser => auser.IsBlocked).ToList();
//If there is less than one admin, return error to user
try
{
var user = await _userManager.FindByEmailAsync(model.Email);
var oldRole = _userManager.GetRolesAsync(user).Result;
//Checks if user is an admin, there will at least be one unblocked admin and if the user is not currently blocked
if (model.OldRole == "Admin" &&
(_userManager.GetUsersInRoleAsync(model.OldRole).Result.Count == 1 ||
blockedAdmins.Count >= adminUsers.Count - 1) &&
!user.IsBlocked)
{
model.Roles = GetUserIdentityRoles();
throw new Exception("There Must be AT LEAST 1 unblocked Admin!");
//return View("ChangeRole", model);
//return BadRequest("There must be AT LEAST 1 Admin!");
}
await _userManager.RemoveFromRoleAsync(user, model.OldRole);
await _userManager.AddToRoleAsync(user, model.UserRole);
model.Roles = GetUserIdentityRoles();
var viewModel = new ChangeUserRoleViewModel
{
UserRole = "",
OldRole = oldRole[0],
Roles = model.Roles,
Email = user.Email
};
return(View("ChangeRole", viewModel));
}
catch (Exception e)
{
return(View("Error", new ErrorViewModel {
RequestId = e.Message
}));
}
}
public async Task <IActionResult> ChangeUserRole(ChangeUserRoleViewModel model)
{
if (model == null)
{
return(BadRequest());
}
ServerUser serverUser = await _context.ServerUser.Where(su => su.ServerId == model.ServerId && su.UserId == model.UserId).FirstOrDefaultAsync();
if (serverUser == null)
{
return(NotFound(model));
}
serverUser.RoleId = model.NewRoleId;
await _context.SaveChangesAsync();
return(Ok(serverUser));
}
public async Task <IActionResult> Edit(ChangeUserRoleViewModel model)
{
if (model == null)
{
return(NotFound());
}
var user = await _userHelper.GetUserByIdAsync(model.UserId);
if (ModelState.IsValid)
{
await _userHelper.UpdateUserAsync(user);
await _userHelper.ChangeUserRoleAsync(user, User.Identity.Name, model.RoleName);
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public async Task <IActionResult> Edit(string id)
{
if (id == null)
{
return(NotFound());
}
var user = await _userHelper.GetUserByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var model = new ChangeUserRoleViewModel
{
UserId = user.Id,
Roles = _userHelper.GetComboRoles()
};
return(View(model));
}
// You should be able to add another role to user
// GET: /SystemRoles/AddNewRole/5
public ActionResult AddNewRoleToUser(string id, string role)
{
ChangeUserRoleViewModel model = new ChangeUserRoleViewModel();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (role == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var user = UserManager.FindByIdAsync(id);
if (user.Result == null)
{
ModelState.AddModelError(string.Empty, "System was unable to find user.");
return(View());
}
//IList<string> userroles = await UserManager.GetRolesAsync(id);
//if (userroles.Count < 1)
//{
// ModelState.AddModelError(string.Empty, "No role found for this user.");
// return View();
//}
//string rolename = string.Empty;
//foreach (string role in userroles)
//{
// rolename = role;
//}
model.Email = user.Result.Email;
model.UserName = user.Result.UserName;
model.UserId = user.Result.Id;
model.RoleInUse = role;
//get list of role
ViewBag.RoleId = new SelectList(_roleRepository.GetRoles(), "Id", "Name", model.RoleId);
return(View(model));
}
public async Task <IActionResult> ChangeRole(string userEmail)
{
var roles = GetUserIdentityRoles();
var user = await _userManager.FindByEmailAsync(userEmail);
var oldRole = _userManager.GetRolesAsync(user).Result;
if (user.Equals(null))
{
return(NotFound());
}
var model = new ChangeUserRoleViewModel
{
UserRole = "",
OldRole = oldRole[0],
Roles = roles,
Email = user.Email
};
return(View(model));
}
public object ChangeUserRoleInProject(ChangeUserRoleViewModel changeUserRoleViewModel)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new BaseResponse(ResponseStatus.ValidationError.ToString(), ModelState.Values.ToList()[0].Errors[0].ErrorMessage)));
}
CurrentUserInfo currentUserInfo = _tokenHelper.GetUserInfo();
if (!_projectLogic.IsProjectExist(currentUserInfo.Id, changeUserRoleViewModel.ProjectId))
{
return(Request.CreateResponse(HttpStatusCode.NotFound, new BaseResponse(ResponseStatus.Notfound.ToString(), ResponseMessagesModel.ProjectNotFound)));
}
if (!_projectLogic.IsUserAdminOrCreatorOfProject(currentUserInfo.Id, changeUserRoleViewModel.ProjectId) || changeUserRoleViewModel.UserRole == UserRole.Creator)
{
return(Request.CreateResponse(HttpStatusCode.MethodNotAllowed, new BaseResponse(ResponseStatus.ValidationError.ToString(), ResponseMessagesModel.PermissionDenied)));
}
if (!_accountLogic.IsUserExist(changeUserRoleViewModel.UserId))
{
return(Request.CreateResponse(HttpStatusCode.NotFound, new BaseResponse(ResponseStatus.Notfound.ToString(), ResponseMessagesModel.UserIsNotFound)));
}
if (_projectTeamLogic.IsUserExistInProject(changeUserRoleViewModel.UserId, changeUserRoleViewModel.ProjectId))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new BaseResponse(ResponseStatus.ValidationError.ToString(), ResponseMessagesModel.UserAlreadyExistInProject)));
}
ProjectTeamData projectTeamData = ChangeUserRoleViewModel.GetProjectTeamData(changeUserRoleViewModel);
_projectTeamLogic.ChangeUserRole(projectTeamData);
return(Request.CreateResponse(HttpStatusCode.OK, new BaseResponse(ResponseStatus.Success.ToString(),
ResponseMessagesModel.Success)));
}
public ActionResult EditUserRole(ChangeUserRoleViewModel model)
{
var i = _roleSv.ChangeUserRole(model.Uid, model.SelectedRole, model.IsAdd);
return(Json(new { i }, JsonRequestBehavior.AllowGet));
}
public async Task<ActionResult> ChangeUserRole(ChangeUserRoleViewModel model)
{
await mediator.SendAsync(new UpdateInternalUserRole(model.UserId, model.Role));
return RedirectToAction("ChangeUserRoleSuccess", new { userId = model.UserId });
}
public async Task <ActionResult> ChangeUserRole(ChangeUserRoleViewModel model)
{
await mediator.SendAsync(new UpdateInternalUserRole(model.UserId, model.Role));
return(RedirectToAction("ChangeUserRoleSuccess", new { userId = model.UserId }));
}
