public async Task <ActionResult> AssignRole_POST(AssignUserRoleViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await UserManager.FindByEmailAsync(model.Email);
var role = await RoleManager.FindByNameAsync(model.Role);
if (user == null)
{
ModelState.AddModelError("Email",
$"No user found with the email address '{model.Email}'!");
}
else if (role == null)
{
ModelState.AddModelError("Role",
$"The role '{model.Role}' does not exist!");
}
else
{
await UserManager.AddToRoleAsync(user.Id, role.Name);
TempData["Message"] = $"User '{user.Email}' has been assigned to the role '{role.Name}'!";
return(RedirectToAction("Index"));
}
return(View(model));
}
public ActionResult AssignUserRole()
{
var model = new AssignUserRoleViewModel();
model.Users = UserManager.Users.ToList();
model.Roles = RoleManager.Roles.ToList();
return(View(model));
}
public ActionResult SubmitForm(AssignUserRoleViewModel formData)
{
AssignUserRoleService service = new AssignUserRoleService();
ValidationResult result = service.SubmitForm(formData, ModelState);
return(Json(
new { success = !result.ErrorFlag, responseText = result.Message, errorList = result.ModelStateErrorList },
JsonRequestBehavior.AllowGet
));
}
public ActionResult List()
{
ViewBag.Title = UtilityService.GetPagetTitlePrefix(ConstantVariableService.FormStateList);
AssignUserRoleService service = new AssignUserRoleService();
AssignUserRoleViewModel model = service.InitialListSearch();
ViewBag.DisplayOnly = AuthorizeService.CheckDisplayOnly(new[] { AssignUserRoleViewModel.RoleForManageData });
return(View("~/Views/Authorization/AssignUserRole/AssignUserRoleList.cshtml", model));
}
public async Task <IActionResult> AssignUserRole(string id)
{
var model = new AssignUserRoleViewModel
{
Input = new AssignUserRoleViewModel.InputModel
{
ID = id
}
};
var allroles = await _roleManager.Roles.ToListAsync();
allroles.ForEach((r) => { model.AllRoles.Add(r.Name); });
return(View(model));
}
public ActionResult AssignUserRole()
{
if (!User.IsInRole("Admin"))
{
RedirectToAction("Index", "Home");
}
ViewBag.UserList = new SelectList(db.Users, "Id", "FirstName");
ViewBag.RoleList = new SelectList(db.Users, "Id", "FirstName");
AssignUserRoleViewModel model = new AssignUserRoleViewModel();
model.UserId = new SelectList(db.Users, "Id", "FirstName");
model.RoleName = new SelectList(db.Roles, "Name", "Name");
model.UserRoles = db.Users.ToList();
return(View(model));
}
public ActionResult ManageUserRole(string userId)
{
//My code; not Jason's
//How do I load up a DropDownList with Role Information?
//new SelectList("The list of data pushed into the control",
//"the column that will be used to communicate my selection(s) to the post",
//"the column we show the user inside the control",
//"If they already occupy a role..show this instead of nothing")
AssignUserRoleViewModel userVM = new AssignUserRoleViewModel();
var currentRole = roleHelper.ListUserRoles(userId).FirstOrDefault();
userVM.PersonWhoWillBeAssignedtotheRole = db.Users.Find(userId);
userVM.RoleList = new SelectList(db.Roles.ToList(), "Name", "Name", currentRole);
return(View(userVM));
}
public async Task <IActionResult> AssignUserRole(AssignUserRoleViewModel model)
{
var user = await _userManager.FindByIdAsync(model.Input.ID);
if (user == null)
{
return(NotFound("Không tìm thấy user"));
}
var roles = await _userManager.GetRolesAsync(user);
var allroles = await _roleManager.Roles.ToListAsync();
allroles.ForEach((r) => { model.AllRoles.Add(r.Name); });
if (model.IsConfirmed)
{
model.Input.RoleNames = roles.ToArray();
model.IsConfirmed = true;
ModelState.Clear();
}
else
{
if (model.Input.RoleNames == null)
{
model.Input.RoleNames = Array.Empty <string>();
}
foreach (var rolename in model.Input.RoleNames)
{
if (roles.Contains(rolename))
{
continue;
}
await _userManager.AddToRoleAsync(user, rolename);
}
foreach (var rolename in roles)
{
if (model.Input.RoleNames.Contains(rolename))
{
continue;
}
await _userManager.RemoveFromRoleAsync(user, rolename);
}
return(RedirectToAction(nameof(ListUser)));
}
model.Input.Name = user.UserName;
return(View(model));
}
public ActionResult Manage(int recordKey, string formState, string assignUserRoleCode, string assignUserType)
{
AssignUserRoleService service = new AssignUserRoleService();
AssignUserRoleViewModel assignUserViewModel = service.GetDetail(recordKey, formState, assignUserRoleCode, assignUserType);
if (assignUserViewModel != null)
{
ViewBag.Title = UtilityService.GetPagetTitlePrefix(formState);
return(View("~/Views/Authorization/AssignUserRole/AssignUserRoleDetail.cshtml", assignUserViewModel));
}
else
{
//return to List page
return(List());
}
}
public ActionResult ManageUserRole(AssignUserRoleViewModel model)
{ //My Code & not Jason's
//This is where I will be using the UserRolesHelper class to make sure my user occupies the proper role
//The first thing I want to do is make sure I remove the user from ALL ROLES they may occupy
foreach (var role in roleHelper.ListUserRoles(model.UserId))
{
roleHelper.RemoveUserFromRole(model.UserId, role);
}
//If the incoming role selection is NOT NULL I want to assign the user to the selected role
if (!string.IsNullOrEmpty(model.SelectedRole))
{
roleHelper.AddUserToRole(model.UserId, model.SelectedRole);
}
return(RedirectToAction("UserIndex"));
}
public async Task <ActionResult> AssignUserRole(AssignUserRoleViewModel model)
{
var user = _userManager.Users.SingleOrDefault(p => p.Email == model.UserName);
foreach (var userRoleViewModel in model.UserRoles)
{
if (await _userManager.IsInRoleAsync(user, userRoleViewModel.RoleName))
{
await _userManager.RemoveFromRoleAsync(user, userRoleViewModel.RoleName);
}
if (userRoleViewModel.IsAssigned)
{
var result = await _userManager.AddToRoleAsync(user, userRoleViewModel.RoleName);
}
}
return(RedirectToAction("Users"));
}
public async Task <ActionResult> AssignUserRole(string userName)
{
AssignUserRoleViewModel model = new AssignUserRoleViewModel();
var user = _userManager.Users.SingleOrDefault(p => p.Email == userName);
if (user == null)
{
return(NotFound());
}
foreach (var role in _roleManager.Roles)
{
model.UserRoles.Add(new UserRoleViewModel()
{
RoleName = role.Name,
IsAssigned = await _userManager.IsInRoleAsync(user, role.Name)
});
}
return(View(model));
}
public ActionResult AssignUserRole()
{
AssignUserRoleViewModel model = new AssignUserRoleViewModel();
model.UserId = new SelectList(db.Users, "Id", "FirstName");
model.RoleName = new SelectList(db.Roles, "Name", "Name");
model.UserRoles = new List <UserRoleVM>();
foreach (var user in db.Users.ToList())
{
model.UserRoles.Add(new UserRoleVM
{
UserName = $"{user.FirstName} {user.LastName}",
RoleName = helper.ListUserRoles(user.Id).FirstOrDefault()
}
);
}
return(View(model));
}
public async Task <string> AssignRemoveUserInRoleAsync(AssignUserRoleViewModel model)
{
if (model.Action == "Assign")
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return($"User with user name = {model.Email} cannot be found");
}
var role = await _roleManager.FindByNameAsync(model.RoleName);
if (role == null)
{
return($"Role with name = {model.RoleName} cannot be found");
}
var result = await _userManager.AddToRoleAsync(user, role.Name);
if (result.Succeeded)
{
return("success");
}
string errorData = string.Empty;
List <IdentityError> li = new List <IdentityError>();
foreach (var error in result.Errors)
{
errorData = error.Description;
li.Add(new IdentityError
{
Code = error.Code,
Description = error.Description
});
}
return(errorData);
}
else if (model.Action == "Remove")
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return($"User with user name = {model.Email} cannot be found");
}
var role = await _roleManager.FindByNameAsync(model.RoleName);
if (role == null)
{
return($"Role with name = {model.RoleName} cannot be found");
}
var result = await _userManager.RemoveFromRoleAsync(user, role.Name);
if (result.Succeeded)
{
return("success");
}
string errorData = string.Empty;
List <IdentityError> li = new List <IdentityError>();
foreach (var error in result.Errors)
{
errorData = error.Description;
li.Add(new IdentityError
{
Code = error.Code,
Description = error.Description
});
}
return(errorData);
}
else
{
return("You have sent invalid request, please try again!!");
}
}
