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"));
}
