public void Details_RoleWithUsers_DetailsModelReturned()
{
// Arrange
const int ROLE_ID = 1;
var role = GetAnyRole(ROLE_ID);
MockGetRole(ROLE_ID, role);
var users = GetUsersForRole(ROLE_ID);
MockGetUsersInRole(ROLE_ID, users);
var expected = new RoleDetailsViewModel(role)
{
Users = new List <string> {
"sa", "superuser"
}
};
var service = BuildSUT();
// Act
var actionResult = service.Details(ROLE_ID);
// Assert
var actual = GetModel <RoleDetailsViewModel>(actionResult);
AreDetailsModelsEqual(actual, expected);
VerifyCheckAccess(AuthOperations.AdminDashboard.View, Times.Once());
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
/// <param name="modalDialogProvider">The modal dialog service.</param>
/// <param name="serviceFactory">The service factory.</param>
public UsersViewModel(IMainViewModel mainViewModel, IModalDialogProvider modalDialogProvider, IServiceFactory serviceFactory)
: base(mainViewModel, modalDialogProvider, serviceFactory)
{
UserDetailsViewModel = new UserDetailsViewModel(MainViewModel, ModalDialogProvider, ServiceFactory);
UserListViewModel = new UserListViewModel(MainViewModel, UserDetailsViewModel, ModalDialogProvider, ServiceFactory);
RoleDetailsViewModel = new RoleDetailsViewModel(MainViewModel, ModalDialogProvider, ServiceFactory);
RoleListViewModel = new RoleListViewModel(MainViewModel, RoleDetailsViewModel, ModalDialogProvider, ServiceFactory);
}
public ActionResult DetailsRole(string id)
{
ApplicationRole applicationRole = RoleManager.FindById(id);
RoleDetailsViewModel model = new RoleDetailsViewModel
{
Role = applicationRole
};
return(PartialView("_RoleDetailsModalPartial", model));
}
/// <summary>
/// Role details.
/// </summary>
/// <param name="id"> Role Id. </param>
/// <returns> The <see cref="ActionResult"/>. </returns>
public ActionResult Details(int id)
{
_authService.CheckAccess(AuthOperations.AdminDashboard.View);
var role = _rolesService.GetRole(id);
var result = new RoleDetailsViewModel(role);
result.Users = _rolesService.GetUsersInRole(id).ConvertAll(u => u.UserName);
return(View(result));
}
public IActionResult Details(int id)
{
Role role = roleService.GetByIdWithDetails(id);
RoleDetailsViewModel model = new RoleDetailsViewModel();
model.Id = role.Id;
model.Name = role.Name;
model.RolePrivileges = role.RolePrivileges.OrderBy(x => x.Privilege.Name).ToList();
model.UserRoles = role.UserRoles;
return(View(model));
}
public ActionResult DetailsRoleData(string id)
{
ApplicationRole applicationRole = RoleManager.FindById(id);
List <string> roleUserIds = applicationRole.Users.Select(x => x.UserId).ToList();
RoleDetailsViewModel model = new RoleDetailsViewModel
{
Role = applicationRole,
RoleSecurityGroups = applicationRole.SecurityGroups.ToList(),
RoleApplicationUsers = IdentityContext.Users.Where(x => roleUserIds.Contains(x.Id)).ToList()
};
return(PartialView("_RoleDetailsDataPartial", model));
}
public ActionResult RoleDetails(string ID)
{
RoleDetailsViewModel model = new RoleDetailsViewModel();
model.PageInfo = new PageInfo()
{
PageTitle = "Role Details",
PageDescription = "Role Details"
};
model.Role = ControlPanelService.Instance.GetRoleByID(ID);
return(PartialView("_RoleDetails", model));
}
private async Task <ViewResult> EditRoleView(string roleId, CancellationToken cancellationToken)
{
_ = roleId ?? throw new ArgumentNullException(nameof(roleId));
var roleModel = await roleService.GetRole(roleId, cancellationToken);
var rolePermissions = await roleService.GetRolePermissions(roleId, cancellationToken);
var allPermissions = ApplicationPermissions.All.ToList();
var viewModel = new RoleDetailsViewModel(roleModel, rolePermissions, allPermissions);
return(View("EditRole", viewModel));
}
public ActionResult Edit(RoleDetailsViewModel viewModel)
{
if (ModelState.IsValid)
{
var role = _roleRepository.Get <Role>(viewModel.Detail.Id);
role.Name = viewModel.Detail.Name;
role.Description = viewModel.Detail.Description;
_roleRepository.UnitOfWork.SaveChanges();
return(RedirectToAction(Mvc.Controller.Role.Details, Mvc.Controller.Role.Name, new { id = viewModel.Detail.Id }));
}
return(View(Mvc.View.Role.Edit, viewModel));
}
public async Task <IActionResult> GetInstCrs(int id)
{
Role role = await _rolesRepository.GetRolePermissions(id);
if (role != null)
{
RoleDetailsViewModel roleDetailsVM = Mapper.Map <Role, RoleDetailsViewModel>(role);
return(new OkObjectResult(roleDetailsVM));
}
else
{
return(NotFound());
}
}
public ActionResult Details(int id)
{
RoleDetails details = _roleRepository.GetRoleDetails(UserContext.User.Id, UserContext.User.OrganizationId, id);
if (details.Detail == null)
{
return(NotFoundResult());
}
RoleDetailsViewModel viewModel = Mapper.Map <RoleDetailsViewModel>(details);
InitDetailsViewModel(viewModel, details);
return(View(Mvc.View.Role.Details, viewModel));
}
public ActionResult Details(int id)
{
var role = _roleRepository.Get(id);
var permissions = _rolePermissionRepository.GetAllBy(r => r.RoleId == role.Id, "Permission").Select(r => r.Permission).ToList();
var members = _roleMemberRepository.GetAllBy(r => r.RoleId == role.Id, "User.Person").ToList().Select(m => m.User).ToList();
var vm = new RoleDetailsViewModel(role)
{
Permissions = permissions,
Users = members
};
return(View(vm));
}
public async Task <IActionResult> GetInstCrStds(int id)
{
Permission permisson = await _rolesRepository.GetEnrolledUsers(id);
if (permisson != null)
{
RoleDetailsViewModel instructorDetailsVM = Mapper.Map <Permission, RoleDetailsViewModel>(permisson);
return(new OkObjectResult(instructorDetailsVM));
}
else
{
return(NotFound());
}
}
public async Task <IActionResult> RoleDetails(string roleId)
{
ViewBag.roleId = roleId;
var role = await accountManager.GetRole(roleId);
var usersWithRole = await accountManager.GetUsersWithRole(role.Name);
var usersNotInRole = await accountManager.GetUsersNotInRole(role.Name);
RoleDetailsViewModel model = new RoleDetailsViewModel
{
InRole = usersWithRole,
NotInRole = usersNotInRole,
};
return(View(model));
}
public async Task <IActionResult> UpdateRole([FromForm] RoleDetailsViewModel model, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(await EditRoleView(model.RoleId, cancellationToken));
}
var assignedPermissions = model.Permissions
.Where(p => p.Assigned)
.Select(p => p.PermissionName);
await roleService.AssignRolePermissions(model.RoleId, assignedPermissions, cancellationToken);
TempData[TempDataUpdatedRole] = true;
return(RedirectToAction("Index"));
}
public async Task <IActionResult> EditConfirm(RoleDetailsViewModel detailsViewModel)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
var role = await rolesManager.FindByIdAsync(detailsViewModel.RoleId);
if (role == null)
{
return(RedirectToAction("Index"));
}
role.Name = detailsViewModel.NewRoleName;
await rolesManager.UpdateAsync(role);
return(RedirectToAction("Index"));
}
public IActionResult GetRoleDetails(int id)
{
Role _role = _roleRepository.GetSingle(r => r.Id == id, r => r.Users);
if (_role == null)
{
return(NotFound());
}
RoleDetailsViewModel _roleDetailsVM = Mapper.Map <Role, RoleDetailsViewModel>(_role);
foreach (var user in _role.Users)
{
User _userDb = _userRepository.GetSingle(user.UserId);
_roleDetailsVM.Users.Add(Mapper.Map <User, UserViewModel>(_userDb));
}
return(new OkObjectResult(_roleDetailsVM));
}
public async Task <ActionResult> RoleDetails(string roleID)
{
RoleDetailsViewModel model = new RoleDetailsViewModel();
var role = await RoleManager.FindByIdAsync(roleID);
if (role != null)
{
model.Role = role;
}
if (Request.IsAjaxRequest())
{
return(PartialView("_RoleDetails", model));
}
else
{
return(View(model));
}
}
public async Task <IActionResult> Edit(string id)
{
if (id == null)
{
return(NotFound());
}
var role = await rolesManager.FindByIdAsync(id);
if (role == null)
{
return(NotFound());
}
RoleDetailsViewModel detailViewModel = new RoleDetailsViewModel()
{
RoleName = role.Name,
RoleId = role.Id
};
return(View(detailViewModel));
}
//
// GET: /Roles/Details/5
public async Task <ActionResult> Details(string id)
{
if (string.IsNullOrEmpty(id) == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var role = await RoleManager.FindByIdAsync(id);
if (role == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
IList <string> usersNames = new List <string>();
var users = UserManager.Users;
if (users != null)
{
foreach (var user in users.ToList())
{
if (await UserManager.IsInRoleAsync(user.Id, role.Name))
{
usersNames.Add(user.UserName);
}
}
}
var viewModel = new RoleDetailsViewModel
{
Id = role.Id,
Name = role.Name,
Users = usersNames
};
return(View(viewModel));
}
public async Task <IActionResult> EditRole(string roleId)
{
ViewBag.roleId = roleId;
List <UserRoleViewModel> model = new List <UserRoleViewModel>();
var role = await accountManager.GetRole(roleId);
var usersWithRole = await accountManager.GetUsersWithRole(role.Name);
var usersNotInRole = await accountManager.GetUsersNotInRole(role.Name);
RoleDetailsViewModel temp = new RoleDetailsViewModel
{
InRole = usersWithRole,
NotInRole = usersNotInRole,
};
foreach (var user in temp.InRole)
{
model.Add(new UserRoleViewModel
{
IsSelected = true,
UserId = user.Id,
UserName = user.UserName
});
}
foreach (var user in temp.NotInRole)
{
model.Add(new UserRoleViewModel
{
IsSelected = false,
UserId = user.Id,
UserName = user.UserName
});
}
return(View(model));
}
public RoleDetailsView(RoleDetailsViewModel viewModel)
{
InitializeComponent();
this.DataContext = viewModel;
}
private void InitDetailsViewModel(RoleDetailsViewModel viewModel, RoleDetails details)
{
InitBaseDetailViewModel(details.Detail, viewModel.Detail);
InitBaseDetailEntityStateChange(viewModel.Detail);
ViewData[Mvc.ViewData.Controller] = Mvc.Controller.Role.Name;
}
private static void AreDetailsModelsEqual(RoleDetailsViewModel actual, RoleDetailsViewModel expected)
{
Assert.AreEqual(actual.Id, expected.Id, "Role ID does not match");
Assert.AreEqual(actual.Name, expected.Name, "Role Names are different");
CollectionAssert.AreEqual(expected.Users, actual.Users, "Users lists are different");
}
private static void AreDetailsModelsEqual(RoleDetailsViewModel actual, RoleDetailsViewModel expected)
{
actual.Id.Should().Be(expected.Id, "Role ID does not match");
actual.Name.Should().Be(expected.Name, "Role Names are different");
actual.Users.Should().BeEquivalentTo(expected.Users, "Users lists are different");
}
