public async Task <IActionResult> ManageUserRoles(ManageUserRolesViewModel heimdallUser)
{
if (!this.User.IsInRole("DemoUser"))
{
HeimdallUser user = await this.context.Users.FindAsync(heimdallUser.User.Id).ConfigureAwait(false);
IEnumerable <string> roles = await this.RolesService.ListUserRolesAsync(user).ConfigureAwait(false);
await this.userManager.RemoveFromRolesAsync(user, roles).ConfigureAwait(false);
string[] userRoles = heimdallUser.SelectedRoles;
// string userRole = HeimdallUser.SelectedRoles.FirstOrDefault();
foreach (string role in userRoles)
{
if (Enum.TryParse(role, out Roles roleValue))
{
await this.RolesService.AddUserToRoleAsync(user, role).ConfigureAwait(false);
}
}
return(this.RedirectToAction("ManageUserRoles"));
}
else
{
this.TempData["DemoLockout"] =
"Your changes have not been saved. To make changes to the database, please log in as a full user.";
return(this.RedirectToAction("Index", "Home"));
}
}
public async Task <IActionResult> Index(string userId)
{
var userRolesVMList = new List <UserRolesViewModel>();
var user = await _userManager.FindByIdAsync(userId);
foreach (var role in _roleManager.Roles)
{
var userRolesVM = new UserRolesViewModel
{
RoleName = role.Name
};
userRolesVM.Selected = await _userManager.IsInRoleAsync(user, role.Name);
userRolesVMList.Add(userRolesVM);
}
var manageUserRolesVM = new ManageUserRolesViewModel
{
UserId = userId,
UserRoles = userRolesVMList
};
return(View(manageUserRolesVM));
}
public async Task <IActionResult> ManageUserRoles(string userId)
{
ViewBag.UserId = userId;
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
var modelList = new List <ManageUserRolesViewModel>();
foreach (var role in roleManager.Roles.ToList())
{
var model = new ManageUserRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name
};
var isInRole = await userManager.IsInRoleAsync(user, role.Name);
if (isInRole)
{
model.IsSelected = true;
}
modelList.Add(model);
}
return(View(modelList));
}
public async Task <IActionResult> Manage(ManageUserRolesViewModel model, string userId)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(View());
}
var roles = await _userManager.GetRolesAsync(user);
var result = await _userManager.RemoveFromRolesAsync(user, roles);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user existing roles");
return(View(model));
}
result = await _userManager.AddToRoleAsync(user, model.SelectedValue);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot add selected roles to user");
return(View(model));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Manage(string userId)
{
if (!User.IsInRole(Warehouse.Areas.Identity.Roles.Admin))
{
return(RedirectToAction("Index", "Home"));
}
ViewBag.userId = userId;
var user = await _userManager.FindByIdAsync(userId);
ViewBag.UserName = user.UserName;
var model = new List <ManageUserRolesViewModel>();
foreach (var role in _roleManager.Roles)
{
var userRolesViewModel = new ManageUserRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
userRolesViewModel.Selected = true;
}
else
{
userRolesViewModel.Selected = false;
}
model.Add(userRolesViewModel);
}
return(View(model));
}
public ActionResult ManageUserRoles(string UserName, ManageUserRolesViewModel postedRoles)
{
string sql = string.Empty;
var membership = (SimpleMembershipProvider)Membership.Provider;
var roles = (SimpleRoleProvider)Roles.Provider;
List <string> selectedRoles = postedRoles.AllRoles;
sql = "Delete From webpages_UsersInRoles Where UserId = (Select UserId From UserProfile Where UserName = '******')";
ExecuteSQL(sql);
if ((selectedRoles != null) && (selectedRoles.Any()))
{
foreach (string Role in selectedRoles)
{
if (!roles.GetRolesForUser(UserName).Contains(Role))
{
roles.AddUsersToRoles(new[] { UserName }, new[] { Role });
}
}
}
postedRoles.UpdateResult = "Rollen wurden vergeben";
postedRoles.AllRoles = getAllRoles();
postedRoles.UserHasRoles = getAllRolesForUser(UserName);
return(View(postedRoles));
}
public async Task <IActionResult> AdminRoles(string userId)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"El usuario con el ID = {userId} no se encuentra.";
return(NotFound());
}
ViewBag.userID = user.Id;
ViewBag.UserName = user.UserName;
var model = new List <ManageUserRolesViewModel>();
foreach (IdentityRole role in _roleManager.Roles)
{
var usuarioRole = new ManageUserRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name,
IsSelected = await _userManager.IsInRoleAsync(user, role.Name)
};
model.Add(usuarioRole);
}
return(View(model));
}
public async Task <IActionResult> Manage(Guid userId)
{
ViewBag.userId = userId;
User user = await _userManager.FindByIdAsync(userId.ToString());
IList <string> userRoleList = await _userManager.GetRolesAsync(user);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
ViewBag.UserName = user.UserName;
List <ManageUserRolesViewModel> model = new List <ManageUserRolesViewModel>();
foreach (Role role in _roleManager.Roles)
{
ManageUserRolesViewModel userRolesViewModel = new ManageUserRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name
};
//if (await _userManager.IsInRoleAsync(user, role.Name))
if (userRoleList.Contains(role.Name))
{
userRolesViewModel.Selected = true;
}
else
{
userRolesViewModel.Selected = false;
}
model.Add(userRolesViewModel);
}
return(View(model));
}
public async Task <IActionResult> Manage(string userId)
{
ViewBag.userId = userId;
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
ViewBag.UserName = user.UserName;
var model = new List <ManageUserRolesViewModel>();
//make sure to add ToList to avoid datareader error
//https://stackoverflow.com/questions/60727080/helping-solving-there-is-already-an-open-datareader-associated-with-this-comman
foreach (var role in _roleManager.Roles.ToList())
{
var userRolesViewModel = new ManageUserRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
userRolesViewModel.Selected = true;
}
else
{
userRolesViewModel.Selected = false;
}
model.Add(userRolesViewModel);
}
return(View(model));
}
public async Task <IActionResult> ManageUserRoles(ManageUserRolesViewModel psuser)
{
if (!User.IsInRole("Demo"))
{
PSUser user = _context.Users.Find(psuser.User.Id);
IEnumerable <string> roles = await _rolesService.ListUserRoles(user);
await _userManager.RemoveFromRolesAsync(user, roles);
var userRoles = psuser.SelectedRoles;
string userRole = psuser.SelectedRoles.FirstOrDefault();
foreach (var role in userRoles)
{
if (Enum.TryParse(role, out Roles roleValue))
{
await _rolesService.AddUserToRole(user, role);
}
}
return(RedirectToAction("ManageUserRoles"));
}
else
{
TempData["DemoLockout"] = "Your changes have not been saved. To make changes to the database, please log in as a full user.";
return(RedirectToAction("Index", "Home"));
}
}
public async Task <IActionResult> ManageUserRoles(string userId)
{
ViewBag.userId = userId;
var user = await usermanager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"user with id ={user.Id} cannot be found";
return(View("NotFound"));
}
var model = new List <ManageUserRolesViewModel>();
foreach (var role in rolemanager.Roles)
{
var manageRoleViewmodel = new ManageUserRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name
};
if (await usermanager.IsInRoleAsync(user, role.Name))
{
manageRoleViewmodel.IsSelected = true;
}
else
{
manageRoleViewmodel.IsSelected = false;
}
model.Add(manageRoleViewmodel);
}
return(View(model));
}
public async Task <IActionResult> Index(string userId)
{
var viewModel = new List <UserRolesViewModel>();
var user = await _userManager.FindByIdAsync(userId);
foreach (var role in _roleManager.Roles)
{
var userRolesViewModel = new UserRolesViewModel
{
RoleName = role.Name
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
userRolesViewModel.Selected = true;
}
else
{
userRolesViewModel.Selected = false;
}
viewModel.Add(userRolesViewModel);
}
var model = new ManageUserRolesViewModel()
{
UserId = userId,
UserRoles = viewModel
};
return(View(model));
}
public async Task <IActionResult> ManageUserRoles(string Id)
{
var user = await _userManager.FindByIdAsync(Id);
if (user == null)
{
return(NotFound());
}
var listModel = new List <ManageUserRolesViewModel>();
foreach (var item in _roleManager.Roles.ToList())
{
var model = new ManageUserRolesViewModel
{
RoleId = item.Id,
RoleName = item.Name
};
model.IsSelected = await _userManager.IsInRoleAsync(user, item.Name) ? true : false;
listModel.Add(model);
}
ViewBag.UserId = user.Id;
ViewBag.UserName = user.UserName;
return(View(listModel));
}
public async Task <IActionResult> Manage(string userId)
{
ViewBag.userId = userId;
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return View()
}
ViewBag.UserName = user.UserName;
var model = new List <ManageUserRolesViewModel>();
foreach (var role in _roleManager.Roles)
{
var userRolesViewModel = new ManageUserRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
userRolesViewModel.Selected = true;
}
else
{
userRolesViewModel.Selected = false;
}
model.Add(userRolesViewModel);
}
return(View(model));
}
public async Task <JsonResult> RemoveUserFromRole(ManageUserRolesViewModel manageUserRolesViewModel)
{
OntoIdentityUser ontoIdentityUser = await _UserManager.FindByNameAsync(manageUserRolesViewModel.UserName);
IdentityResult result = await _UserManager.RemoveFromRoleAsync(ontoIdentityUser.Id, manageUserRolesViewModel.RoleName);
string resultMessage = result.Succeeded ? SuccessMsg.UserRemovedFromRoleSuccesfully : ErrorMsg.UserRemovedFromRoleError;
return(Json(resultMessage));
}
public ActionResult Manage()
{
var users = this.Data.Users.All()
.OrderBy(u => u.Email)
.ToList();
var adminRole = this.Data.Roles.All().First(r => r.Name == GlobalConstants.AdminRole);
var model = new ManageUserRolesViewModel()
{
AdminRole = adminRole, Users = users
};
return(this.View(model));
}
public ActionResult ManageUserRoles(ManageMessageId?message)
{
var u = new ManageUserRolesViewModel();
u.UserName = Request["UserName"];
u.AllRoles = getAllRoles();
u.UserHasRoles = getAllRolesForUser(u.UserName);
u.UpdateResult = "";
ViewBag.StatusMessage = message == ManageMessageId.ManageUserRolesSuccess
? "Rollen wurden vergeben"
: "Fehler beim Rollen vergeben";
return(View(u));
}
public ActionResult ManageUserRole(string roleName, string roleID)
{
List <OntoIdentityUser> listOfUsers = _UserManager.GetListOfUsersForRole(roleID);
ManageUserRolesViewModel manageUserRolesViewModel = new ManageUserRolesViewModel()
{
RoleName = roleName,
ListOfUser = listOfUsers,
RoleID = roleID
};
return(View(manageUserRolesViewModel));
}
public async Task <IdentityResult> UpdateUserRolesAsync(ManageUserRolesViewModel model, ApplicationUser user)
{
var roles = await this.userManager.GetRolesAsync(user);
var result = await this.userManager.RemoveFromRolesAsync(user, roles);
if (!result.Succeeded)
{
return(result);
}
return(await this.userManager.AddToRolesAsync(user, model.RoleModels.Where(x => x.Selected).Select(y => y.RoleName)));
}
public async Task <IActionResult> Manage(string userId)
{
userId.ToString();
ViewBag.userId = userId.ToString();
var user = await _userManager.FindByIdAsync(userId.ToString());
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
ViewBag.UserName = user.UserName;
var model = new List <ManageUserRolesViewModel>();
AppUser currentUser = _userManager.GetUserAsync(User).Result;
IEnumerable <IdentityRole <Guid> > roleList = null;
if (await _userManager.IsInRoleAsync(currentUser, "Admin"))
{
roleList = _roleManager.Roles;
}
else if (await _userManager.IsInRoleAsync(currentUser, "Manager"))
{
roleList = _roleManager.Roles.Where(x => x.Name != "Admin").ToList();
}
foreach (var role in roleList)
{
var userRolesViewModel = new ManageUserRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
userRolesViewModel.Selected = true;
}
else
{
userRolesViewModel.Selected = false;
}
model.Add(userRolesViewModel);
}
return(View(model));
}
public async Task <IActionResult> Update(string id, ManageUserRolesViewModel model)
{
var user = await _userManager.FindByIdAsync(id);
var roles = await _userManager.GetRolesAsync(user);
var result = await _userManager.RemoveFromRolesAsync(user, roles);
result = await _userManager.AddToRolesAsync(user, model.UserRoles.Where(x => x.Selected).Select(y => y.RoleName));
//var currentUser = await _userManager.GetUserAsync(User);
//await _signInManager.RefreshSignInAsync(currentUser);
//await Infrastructure.Identity.Seeds.DefaultSuperAdminUser.SeedAsync(_userManager, _roleManager);
_notify.Success($"Updated Roles for User '{user.Email}'");
return(RedirectToAction("Index", new { userId = id }));
}
public async Task <IActionResult> ManageUserRoles()
{
List <ManageUserRolesViewModel> model = new List <ManageUserRolesViewModel>();
List <BTUser> users = _context.Users.ToList();
foreach (var user in users)
{
ManageUserRolesViewModel vm = new ManageUserRolesViewModel();
vm.User = user;
var selected = (await _rolesService.ListUserRoles(user)).FirstOrDefault();
vm.Roles = new SelectList(_context.Roles, "Name", "Name", selected);
model.Add(vm);
}
return(View(model));
}
public async Task <Result <string> > EditRoleByUsername(string username, ManageUserRolesViewModel model)
{
var user = await _userManager.FindByNameAsync(username);
var roles = await _userManager.GetRolesAsync(user);
var result = await _userManager.RemoveFromRolesAsync(user, roles);
result = await _userManager.AddToRolesAsync(user, model.UserRoles.Where(x => x.Selected).Select(y => y.RoleName));
// var currentUser = await _userManager.GetUserAsync(User);
// await _signInManager.RefreshSignInAsync(currentUser);
// await Infrastructure.Identity.Seeds.DefaultSuperAdminUser.SeedAsync(_userManager, _roleManager);
return(Result <string> .Success("true"));
}
public async Task <IActionResult> Manage(string userId)
{
ViewBag.userId = userId;
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("/Views/Shared/NotFound.cshtml"));
}
ViewBag.UserName = user.UserName;
var model = new List <ManageUserRolesViewModel>();
var roles = await _userManager.GetRolesAsync(user);
if (roles == null)
{
return(View("/Views/Shared/NotFound.cshtml"));
}
foreach (var role in _roleManager.Roles)
{
var userRoles = new ManageUserRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name
};
if (roles.Contains(role.Name))
{
userRoles.Selected = true;
}
else
{
userRoles.Selected = false;
}
model.Add(userRoles);
}
//ViewBag for bell icon on the nav menu
var userLoggedIn = await _userManager.GetUserAsync(User);
ViewBag.HasNotificationToRead = _context.Notification.Include(n => n.User).Where(notif => notif.DestinaryID == userLoggedIn.Id && !notif.IsRead).Count();
return(View(model));
}
public async Task <IActionResult> Update(string id, ManageUserRolesViewModel model)
{
var user = await _userManager.FindByIdAsync(id);
var roles = await _userManager.GetRolesAsync(user);
var result = await _userManager.RemoveFromRolesAsync(user, roles);
result = await _userManager.AddToRolesAsync(user, model.UserRoles.Where(x => x.Selected).Select(y => y.RoleName));
var currentUser = await _userManager.GetUserAsync(User);
await _signInManager.RefreshSignInAsync(currentUser);
await Seeds.DefaultUsers.SeedSuperAdminAsync(_userManager, _roleManager);
return(RedirectToAction("Index", new { userId = id }));
}
public async Task <IActionResult> ManageUserRoles()
{
List <ManageUserRolesViewModel> model = new List <ManageUserRolesViewModel>();
List <PSUser> users = _context.Users.ToList();
foreach (var user in users)
{
ManageUserRolesViewModel vm = new ManageUserRolesViewModel
{
User = user
};
var selected = await _rolesService.ListUserRoles(user);
vm.Roles = new MultiSelectList(_context.Roles, "Name", "Name", selected); //Overload example, maybe just a select list instead?
model.Add(vm);
}
return(View(model));
}
public async Task <IActionResult> SetRoles(ManageUserRolesViewModel item, string name)
{
BTUser user = _context.Users.Find(item.UserId);
IEnumerable <string> roles = await _BTRoles.ListUserRoles(user);
await _userManager.RemoveFromRolesAsync(user, roles);
string userRole = name;
if (Enum.TryParse(userRole, out Roles roleValue))
{
await _BTRoles.AddUserToRole(user, userRole);
return(RedirectToAction("SetRoles"));
}
return(RedirectToAction("SetRoles"));
}
public async Task <IActionResult> Manage(string userID)
{
// Passing the userId directly to the View
ViewBag.userId = userID;
// tries to the get the user from the database
var user = await _userManager.FindByIdAsync(userID);
// returns not found if the user doesn't exist in the database
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userID} cannot be found";
return(View("NotFound"));
}
ViewBag.UserName = user.UserName;
var model = new List <ManageUserRolesViewModel>();
var roles = _roleManager.Roles.ToList();
foreach (var role in roles)
{
var userRolesViewModel = new ManageUserRolesViewModel
{
RoleID = role.Id,
RoleName = role.Name
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
userRolesViewModel.Selected = true;
}
else
{
userRolesViewModel.Selected = false;
}
model.Add(userRolesViewModel);
}
// return the list of roles to the View
return(View(model));
}
public async Task <JsonResult> AddUserToRole(ManageUserRolesViewModel manageUserRolesViewModel)
{
OntoIdentityUser ontoIdentityUser = await _UserManager.FindByNameAsync(manageUserRolesViewModel.UserName);
string resultMessage;
if (ontoIdentityUser == null)
{
resultMessage = ErrorMsg.UserDoesNotExists;
return(Json(resultMessage));
}
IdentityResult result = await _UserManager.AddToRoleAsync(ontoIdentityUser.Id, manageUserRolesViewModel.RoleName);
resultMessage = result.Succeeded ? SuccessMsg.UserAddedToRoleSuccesfuly : ErrorMsg.UserAddedToRoleError;
return(Json(resultMessage));
}
public async Task <IActionResult> Manage(ManageUserRolesViewModel model, string userId)
{
var user = await this.userManager.FindByIdAsync(userId);
if (user == null)
{
return(this.Json(new { isValid = false, html = this.View(model) }));
}
var result = await this.usersService.UpdateUserRolesAsync(model, user);
if (!result.Succeeded)
{
this.ModelState.AddModelError(string.Empty, "Cannot change user existing roles");
return(this.Json(new { isValid = false, html = this.View(model) }));
}
return(this.Json(new { isValid = true, redirectToUrl = this.Url.Action("Index", "Users") }));
}
