public async Task <IActionResult> RoleEdit(string id) { IdentityRole _role = await _roleManager.FindByIdAsync(id); //users with the assigned role var RolesInUser = _DbPortal.GetT_PRT_USERS_BelongingToRole(id); //all users var allUsers = _userManager.Users.ToList(); var model = new RoleEditViewModel { T_PRT_ROLES = _role, Users_In_Role = RolesInUser.Select(x => new SelectListItem { Value = x.Id, Text = x.Email }), Users_Not_In_Role = allUsers.Except(RolesInUser).OrderBy(a => a.Email).Select(x => new SelectListItem { Value = x.Id, Text = x.Email }) }; return(View(model)); }
public async Task <IActionResult> OnGetAsync() { IdentityRole role = await roleManager.FindByNameAsync("Mentors"); // Perhaps rename mentors role ApprovedMentors if (role == null) { return(NotFound()); } List <ApplicationUser> members = new List <ApplicationUser>(); List <ApplicationUser> nonMembers = new List <ApplicationUser>(); foreach (ApplicationUser user in userManager.Users) { if (user.IsMentor) { var list = await userManager.IsInRoleAsync(user, role.Name) ? members : nonMembers; list.Add(user); } } RoleEditViewModel = new RoleEditViewModel { Role = role, Members = members, NonMembers = nonMembers }; return(Page()); }
public async Task <ActionResult> RoleEdit(RoleEditViewModel model, string submitButton) { IdentityRole _role = await _roleManager.FindByIdAsync(model.T_PRT_ROLES.Id); if (_role != null) { IdentityResult succId = new IdentityResult(); // ADDING ROLE TO USER if (submitButton == "Add") { foreach (string u in model.Users_Not_In_Role_Selected) { succId = await _userManager.AddToRoleAsync(_userManager.FindByIdAsync(u).Result, _role.Name); } } // REMOVE ROLE FROM USER else if (submitButton == "Remove") { foreach (string u in model.Users_In_Role_Selected) { succId = await _userManager.RemoveFromRoleAsync(_userManager.FindByIdAsync(u).Result, _role.Name); } } if (succId.Succeeded) { TempData["Success"] = "Update successful."; } } return(RedirectToAction("RoleEdit", new { id = model.T_PRT_ROLES.Id })); }
public ActionResult Create(RoleEditViewModel model) { if (!this.ModelState.IsValid) { return(View(model)); } var role = new Role() { RoleName = model.Name, Description = model.Description }; try { this.roleService.CreateRole(role); } catch (Exception ex) { this.ModelState.AddModelError("Name", ex.Message); return(View(model)); } return(RedirectToAction("Details", new { id = role.RoleId })); }
public ActionResult EditSavePOST(int id) { if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not authorized to manage roles"))) { return(new HttpUnauthorizedResult()); } var viewModel = new RoleEditViewModel(); try { UpdateModel(viewModel); // Save List <string> rolePermissions = new List <string>(); foreach (string key in Request.Form.Keys) { if (key.StartsWith("Checkbox.") && Request.Form[key] == "true") { string permissionName = key.Substring("Checkbox.".Length); rolePermissions.Add(permissionName); } } _roleService.UpdateRole(viewModel.Id, viewModel.Name, rolePermissions); Services.Notifier.Information(T("Your Role has been saved.")); return(RedirectToAction("Edit", new { id })); } catch (Exception exception) { this.Error(exception, T("Editing Role failed: {0}", exception.Message), Logger, Services.Notifier); return(RedirectToAction("Edit", id)); } }
public async Task <IActionResult> EditRole(RoleEditViewModel revm) { var role = await roleManager.FindByIdAsync(revm.Id); if (role == null) { ViewBag.ErrorMessage = $"Nivel de acesso não encontrado"; return(View("NotFound")); } else { role.Name = revm.RoleName; var result = await roleManager.UpdateAsync(role); if (result.Succeeded) { return(RedirectToAction("ListRoles")); } foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(View()); }
public void PostCreate() { MockRoleService service = new MockRoleService(); RoleController controller = GetRoleController(service); int nroles = service.Roles.Count; var model = new RoleEditViewModel() { Name = "New Role", Description = "New Role" }; ActionResult result = controller.Create(model); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult)); RedirectToRouteResult redirectResult = (RedirectToRouteResult)result; Assert.AreEqual("Details", redirectResult.RouteValues["action"]); Assert.AreEqual(nroles + 1, service.Roles.Count); Assert.IsNotNull(service.NewRole); Assert.AreEqual("New Role", service.NewRole.RoleName); }
public async Task <IActionResult> EditRoles(string userName, RoleEditViewModel roleEditViewModel) { var user = await _userManager.FindByNameAsync(userName); var userRoles = await _userManager.GetRolesAsync(user); var selectedRoles = roleEditViewModel.RoleNames; selectedRoles = selectedRoles ?? new string[] {}; var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles)); if (!result.Succeeded) { return(BadRequest("Failed to add to roles")); } result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles)); if (!result.Succeeded) { return(BadRequest("Failed to remove the roles")); } return(Ok(await _userManager.GetRolesAsync(user))); }
public RoleEditViewModel Update(RoleEditViewModel Role) { Role _Role = RoleRepo.Update(Role.ToModel()); unitOfWork.commit(); return(_Role.ToEditableViewModel()); }
public async Task <IActionResult> EditRole(RoleEditViewModel model) { if (ModelState.IsValid) { var role = await _roleManager.FindByIdAsync(model.Id); if (role == null) { ViewBag.errorMessage = $"Role with Id={model.Id} cann't be found"; return(View("NotFound")); } role.Name = model.Name; var result = await _roleManager.UpdateAsync(role); if (result.Succeeded) { return(RedirectToAction("Roles", new { Controller = "Role" })); } foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(View(model)); }
public ActionResult Edit(int id) { if (!Services.Authorizer.Authorize(Permissions.ManageRoles, T("Not authorized to manage roles"))) { return(new HttpUnauthorizedResult()); } var role = _roleService.GetRole(id); if (role == null) { return(HttpNotFound()); } var model = new RoleEditViewModel { Name = role.Name, Id = role.Id, RoleCategoryPermissions = _roleService.GetInstalledPermissions(), CurrentPermissions = _roleService.GetPermissionsForRole(id) }; var simulation = UserSimulation.Create(role.Name); model.EffectivePermissions = model.RoleCategoryPermissions .SelectMany(group => group.Value) .Where(permission => _authorizationService.TryCheckAccess(permission, simulation, null)) .Select(permission => permission.Name) .Distinct() .ToList(); return(View(model)); }
public IActionResult Edit(string id) { var model = new RoleEditViewModel(); model.OldName = id; return(this.View(model)); }
public async Task <IActionResult> OnGetAsync(string id) { if (string.IsNullOrEmpty(id)) { return(NotFound()); } IdentityRole role = await roleManager.FindByIdAsync(id); if (role == null) { return(NotFound()); } List <ApplicationUser> members = new List <ApplicationUser>(); List <ApplicationUser> nonMembers = new List <ApplicationUser>(); foreach (ApplicationUser user in userManager.Users) { var list = await userManager.IsInRoleAsync(user, role.Name) ? members : nonMembers; list.Add(user); } RoleEditViewModel = new RoleEditViewModel { Role = role, Members = members, NonMembers = nonMembers.Where(nm => nm.IsMentor) }; return(Page()); }
public async Task <IActionResult> EditRole(string id) { // Find the role by Role ID var role = await roleManager.FindByIdAsync(id); if (role == null) { ViewBag.ErrorMessage = $"Role with Id = {id} cannot be found"; return(View("NotFound")); } var model = new RoleEditViewModel { Id = role.Id, RoleName = role.Name }; // Retrieve all the Users foreach (var user in userManager.Users) { // If the user is in this role, add the username to // Users property of RoleEditViewModel. This model // object is then passed to the view for display if (await userManager.IsInRoleAsync(user, role.Name)) { model.Users.Add(user.UserName); } } return(View(model)); }
public async Task <IActionResult> EditRole(RoleEditViewModel model) { var role = await roleManager.FindByIdAsync(model.Id); if (role == null) { ViewBag.ErrorMessage = $"Role with Id = {model.Id} cannot be found"; return(View("NotFound")); } else { role.Name = model.RoleName; // Update the Role using UpdateAsync var result = await roleManager.UpdateAsync(role); if (result.Succeeded) { return(RedirectToAction("ListRoles")); } foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } return(View(model)); } }
public async Task <IActionResult> EditRoles(string userName, RoleEditViewModel roleEdit) { string modifyBy = User.FindFirst(ClaimTypes.NameIdentifier)?.Value; var user = await _userManager.FindByNameAsync(userName); var userRoles = await _userManager.GetRolesAsync(user); var selectedRoles = roleEdit.RoleNames; selectedRoles = selectedRoles ?? new string[] { }; var result = await _userManager.AddToRolesAsync(user, selectedRoles.Except(userRoles)); if (!result.Succeeded) { return(BadRequest("Faild to add to roles")); } result = await _userManager.RemoveFromRolesAsync(user, userRoles.Except(selectedRoles)); if (!result.Succeeded) { return(BadRequest("Faild to remove to roles")); } if (selectedRoles.Contains("Vendor")) { var shops = await _singleton.vendorRepository.AddVendorShopTableName(user, modifyBy); } return(Ok(await _userManager.GetRolesAsync(user))); }
public RoleEditViewModel Add(RoleEditViewModel Role) { Role _Role = RoleRepo.Add(Role.toModel()); unitOfWork.commit(); return(_Role.toEditViewModel()); }
public async Task <ActionResult> EditRole(RoleEditViewModel model) { if (ModelState.IsValid) { IdentityResult result; foreach (var userId in model.IdsToAdd ?? new string[] { }) { result = await UserService.AddToRoleAsync(userId, model.RoleName); if (!result.Succeeded) { ViewBag.Error = "The user was not added to the role"; return(View("Error")); } } foreach (var userId in model.IdsToDelete ?? new string[] { }) { result = await UserService.RemoveFromRoleAsync(userId, model.RoleName); if (!result.Succeeded) { ViewBag.Error = "The user was not deleted from the role"; return(View("Error")); } } return(RedirectToAction("Index")); } return(View("Error")); }
public async Task <IActionResult> EditRole(string id) { var role = await _roleManager.FindByIdAsync(id); if (role == null) { ViewBag.ErrorMessage = $"Role with Id = {id} cannot be found!"; return(View("NotFound")); } var model = new RoleEditViewModel() { Id = role.Id, RoleName = role.Name, }; var listUser = await _userManager.Users.ToListAsync(); foreach (var user in listUser) { var isInRole = await _userManager.IsInRoleAsync(user, role.Name); if (isInRole) { model.Users.Add(user.UserName); } } return(View(model)); }
public async Task <IActionResult> EditRole(RoleEditViewModel roleEditViewModel) { if (!ModelState.IsValid) { return(View(roleEditViewModel)); } var role = await _roleManager.FindByIdAsync(roleEditViewModel.Id); if (role != null) { role.Name = roleEditViewModel.RoleName; var result = await _roleManager.UpdateAsync(role); if (result.Succeeded) { return(RedirectToAction("Index")); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } return(View(roleEditViewModel)); } } return(RedirectToAction("Index")); }
public void PostEdit() { MockRoleService service = new MockRoleService(); RoleController controller = GetRoleController(service); Role role = service.Roles[0]; RoleEditViewModel model = new RoleEditViewModel() { Id = role.RoleId, Name = "New " + role.RoleName }; ActionResult result = controller.Edit(role.RoleId, model); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult)); RedirectToRouteResult redirectResult = (RedirectToRouteResult)result; Assert.AreEqual("Details", redirectResult.RouteValues["action"]); Assert.AreEqual(role.RoleId, redirectResult.RouteValues["id"]); Assert.AreEqual(role.RoleName, model.Name); Assert.AreEqual(role.RoleId, model.Id); }
public async Task <IActionResult> EditRole(string id) { var role = await _roleManager.FindByIdAsync(id); if (role == null) { return(RedirectToAction("Index")); } var roleEditViewModel = new RoleEditViewModel { Id = id, RoleName = role.Name, Users = new List <string>() }; var users = await _userManager.Users.ToListAsync(); foreach (var user in users) { if (await _userManager.IsInRoleAsync(user, role.Name)) { roleEditViewModel.Users.Add(user.UserName); } } return(View(roleEditViewModel)); }
public void Edit_BeforeViewDisplayed_EditModelReturned() { // Arrange const int ROLE_ID = 1; const int OTHER_ROLE_ID = 2; var role = GetAnyRole(ROLE_ID); MockGetRole(ROLE_ID, role); var users = GetUserInRoles(ROLE_ID, OTHER_ROLE_ID); MockGetAllUsersWithRoles(users); var expected = new RoleEditViewModel(role) { UsersInRole = GetDefaultUsersInRole(), UsersOutsideRole = GetDefaultUsersOutsideRole() }; var service = BuildSUT(); // Act var actionResult = service.Edit(ROLE_ID); // Assert var actual = GetModel <RoleEditViewModel>(actionResult); AreEditModelsEqual(actual, expected); VerifyCheckAccess(AuthOperations.AdminDashboard.View, Times.Once()); }
/// <summary> /// </summary> /// <param name="viewModel"></param> public async Task <RoleEditViewModel> FillForEditAsync(RoleEditViewModel viewModel) { // Process var permissions = AccessPermissionManager.GetAsSelectListItems(); // Result return(viewModel); }
private static void AreEditModelsEqual(RoleEditViewModel actual, RoleEditViewModel expected) { actual.Id.Should().Be(expected.Id, "Role ID does not match"); actual.Name.Should().Be(expected.Name, "Role Names are different"); actual.UsersInRole.Should().BeEquivalentTo(expected.UsersInRole, "Users in Role lists are different"); actual.UsersOutsideRole.Should().BeEquivalentTo(expected.UsersOutsideRole, "Users outside Role lists are different"); }
public ActionResult Edit(int id) { var vm = new RoleEditViewModel(); vm.Role = UserService.GetRole(id) ; return(View(vm)); }
public async Task <IActionResult> EditRole(string id) { var role = await _roleManager.FindByIdAsync(id); if (role == null) { return(RedirectToAction("Index")); } var roleEditViewModel = new RoleEditViewModel { Id = id, RoleName = role.Name, Users = new List <string>() }; List <string> userList = new List <string>(); var re = SessionOps.GetSessionList <string>(HttpContext.Session.Get($"role_{id}_user_list")); if (re != null) { userList = re; } else { var configAuthorization = Config.App.GetJToken(Constants.JsontagAuthorization) as JObject; var authBlob = AzureService.GetBlob(null, "index", WebUIConfig.AppInfoConfigFile); var json = await authBlob.DownloadGenericObjectAsync(); var addAuth = JsonUtils.GetJToken(Constants.JsontagAuthorization, json); var addAuthObj = addAuth == null ? null : addAuth as JObject; if (!Object.ReferenceEquals(addAuthObj, null)) { addAuthObj.Merge(configAuthorization, new JsonMergeSettings { MergeArrayHandling = MergeArrayHandling.Union }); } if (!Object.ReferenceEquals(addAuthObj, null)) { foreach (var pair in addAuthObj) { if (pair.Key == role.Name) { var peopleArray = pair.Value as JArray; foreach (var onepeople in peopleArray) { userList.Add(onepeople.ToString()); } } } } SessionOps.SetSession($"role_{id}_user_list", userList, HttpContext.Session); } roleEditViewModel.Users = userList; return(View(roleEditViewModel)); }
public ActionResult RoleEdit(long id) { RoleEditViewModel model = new RoleEditViewModel(); model.PermIds = permissionService.GetByRoleId(id); model.Role = roleService.GetById(id); model.Permissions = permissionService.GetAll(); return(View(model)); }
public async Task <IActionResult> Edit(RoleEditViewModel model) { var role = await this.roleManagerWrapper.FindByNameAsync(model.OldName); role.Name = model.NewName; await this.roleManagerWrapper.UpdateRoleAsync(role); return(this.RedirectToAction(nameof(Index))); }
public ActionResult EditRole(RoleEditViewModel model) { Role role = new Role(model.RoleID, model.Name, model.Convert()); var client = new RestClient("http://localhost:4000/api/roles"); var request = new RestRequest(Method.PUT); request.AddJsonBody(role); var response = client.Execute(request); return(RedirectToAction("ViewRoleList", "Roles")); }