public async Task ManageRolesPost_ShouldReturnViewWithModelWhenRemoveFromRolesAsyncFailed()
{
// Arrange
IdentityRoleViewModel formModel = new IdentityRoleViewModel()
{
Username = FirstUserUsername
};
Mock <RoleManager <IdentityRole> > roleManager = this.GetAndSetRoleManagerMock();
Mock <UserManager <User> > userManager = this.GetAndSetUserManagerMock();
userManager
.Setup(um => um.RemoveFromRolesAsync(It.IsAny <User>(), It.IsAny <List <string> >()))
.ReturnsAsync(IdentityResult.Failed(new IdentityError {
Description = "test"
}));
HomeController controller = new HomeController(null, userManager.Object, roleManager.Object);
// Act
IActionResult actionResult = await controller.ManageRoles(FirstUserId, formModel);
// Assert
actionResult.Should().BeOfType <ViewResult>();
object model = actionResult.As <ViewResult>().Model;
model.Should().BeOfType <IdentityRoleViewModel>();
IdentityRoleViewModel returnedModel = model.As <IdentityRoleViewModel>();
returnedModel.Username.Should().Be(formModel.Username);
}
public async Task <ActionResult> DeleteConfirmed(string id, IdentityRoleViewModel viewModel)
{
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
ModelState.AddModelError(String.Empty, "Role not found.");
return(View(viewModel));
}
if (role.NormalizedName == "ADMIN")
{
ModelState.AddModelError(String.Empty, "Role 'Admin' cannot be deleted.");
return(View(viewModel));
}
var result = await _roleManager.DeleteAsync(role);
if (!result.Succeeded)
{
AddErrors(result);
return(View(viewModel));
}
else
{
return(RedirectToAction("Index"));
}
}
public async Task <ActionResult> Edit([Bind("RoleId,RoleName")] IdentityRoleViewModel roleView)
{
if (ModelState.IsValid)
{
var role = await _roleManager.FindByIdAsync(roleView.RoleId);
role.Name = roleView.RoleName;
var result = await _roleManager.UpdateAsync(role);
// Fast exit if editing role 'admin'
if (role.NormalizedName == "ADMIN")
{
ModelState.AddModelError(string.Empty, "Admin role cannot be edited");
return(View(roleView));
}
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
AddErrors(result);
}
}
return(View(roleView));
}
private IEnumerable <AdminViewModels.AppUserAdminViewModel> ConvertAdminUsersToViewModel(IEnumerable <AppUserAdmin> adminUsers, List <ApplicationRole> roller)
{
var adminUserViewList = new List <AdminViewModels.AppUserAdminViewModel>();
foreach (var user in adminUsers)
{
var roleVMList = new List <IdentityRoleViewModel>();
var adminUserView = new AdminViewModels.AppUserAdminViewModel
{
Id = user.Id,
Email = user.Email,
PhoneNumber = user.PhoneNumber,
SkapadDatum = user.SkapadDatum,
SkapadAv = user.SkapadAv,
AndradDatum = user.AndradDatum,
AndradAv = user.AndradAv,
Roles = _portalSosService.HamtaAstridAnvandaresRoller(user.Id).Select(x => x.BeskrivandeNamn).ToList()
};
//Skapa lista över roller och markera valda roller för aktuell användare
foreach (var roll in roller)
{
var roleVm = new IdentityRoleViewModel
{
Id = roll.Id,
Name = roll.BeskrivandeNamn
};
if (adminUserView.Roles.Contains(roll.BeskrivandeNamn))
{
roleVm.Selected = true;
}
roleVMList.Add(roleVm);
}
//Skapa kommaseparerad textsträng över användarens roller
var rolesStr = String.Empty;
foreach (var role in adminUserView.Roles)
{
if (rolesStr.IsEmpty())
{
rolesStr = role;
}
else
{
rolesStr = rolesStr + ", " + role;
}
}
adminUserView.StringOfRoles = rolesStr;
adminUserView.ListOfRoles = roleVMList;
adminUserViewList.Add(adminUserView);
}
return(adminUserViewList);
}
public async Task <IActionResult> CreateRole(IdentityRoleViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await _adminService.CreateRole(model);
return(View(nameof(Index)));
}
public async Task <IActionResult> ManageRoles(string id)
{
var user = await this.userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
IdentityRoleViewModel viewModel = await GetRoleViewModel(user);
return(View(viewModel));
}
//[Authorize (Roles = "Admin")]
public async Task <IActionResult> CreateRoleAsync(IdentityRoleViewModel role)
{
var newRole = new IdentityRole(role.RoleName);
IdentityResult roleResult = new IdentityResult();
var roleExist = await this.roleManager.RoleExistsAsync(newRole.Name);
if (!roleExist)
{
roleResult = await this.roleManager.CreateAsync(newRole);
}
return(Ok(new { role = roleResult.Succeeded }));
}
public async Task <IdentityRole> UpdateRole(IdentityRoleViewModel role)
{
if (role == null || role.Name == null || role.Name == string.Empty)
{
throw new Exception("Updated role can not be null");
}
var newRole = new IdentityRole {
Name = role.Name
};
await _roleManager.UpdateAsync(newRole);
return(newRole);
}
private List <IdentityRoleViewModel> ConvertRolesToVM(List <ApplicationRole> roller)
{
var rollerList = new List <IdentityRoleViewModel>();
foreach (var roll in roller)
{
var roleVM = new IdentityRoleViewModel()
{
Id = roll.Id,
Name = roll.BeskrivandeNamn,
Selected = false
};
rollerList.Add(roleVM);
}
return(rollerList);
}
public async Task <IdentityRole> CreateRole(IdentityRoleViewModel role)
{
if (role == null || role.Name == string.Empty || role.Name == null)
{
throw new Exception("New role can not be null or empty");
}
var identityRole = new IdentityRole {
Name = role.Name
};
if (!await _roleManager.RoleExistsAsync(role.Name))
{
await _roleManager.CreateAsync(identityRole);
}
return(identityRole);
}
public async Task <IdentityRole> DeleteRole(IdentityRoleViewModel role)
{
if (role == null || role.Name == null || role.Name == string.Empty)
{
throw new Exception("Can not delete");
}
var identityRole = new IdentityRole {
Name = role.Name
};
if (await _roleManager.RoleExistsAsync(role.Name))
{
await _roleManager.DeleteAsync(identityRole);
}
return(identityRole);
}
public async Task ManageRolesPost_ShouldReturnRedirectToActionWhenValidUserId()
{
// Arrange
string tempDataSuccessMessage = null;
IdentityRoleViewModel formModel = new IdentityRoleViewModel()
{
SelectedRoles = new List <string>()
{
WebConstants.AdministratorRole
},
Username = FirstUserUsername
};
Mock <RoleManager <IdentityRole> > roleManager = this.GetAndSetRoleManagerMock();
Mock <UserManager <User> > userManager = this.GetAndSetUserManagerMock();
userManager
.Setup(um => um.RemoveFromRolesAsync(It.IsAny <User>(), It.IsAny <List <string> >()))
.ReturnsAsync(IdentityResult.Success);
userManager
.Setup(um => um.AddToRolesAsync(It.IsAny <User>(), It.IsAny <List <string> >()))
.ReturnsAsync(IdentityResult.Success);
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
tempData.SetupSet(t => t["SuccessMessage"] = It.IsAny <string>())
.Callback((string key, object successMessage) => tempDataSuccessMessage = successMessage as string);
HomeController controller = new HomeController(null, userManager.Object, roleManager.Object);
controller.TempData = tempData.Object;
// Act
IActionResult actionResult = await controller.ManageRoles(FirstUserId, formModel);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>();
actionResult.As <RedirectToActionResult>().ActionName.Should().Be("AllUsers");
tempDataSuccessMessage.Should().Be(ManageRolesMessageSuccessfull);
}
public static void SeedRoles
(RoleManager <IdentityRoleViewModel> roleManager)
{
if (!roleManager.RoleExistsAsync
("Administrator").Result)
{
IdentityRoleViewModel role = new IdentityRoleViewModel();
role.Name = "Administrator";
role.Descricao = "Executar todas as operações.";
IdentityResult roleResult = roleManager.
CreateAsync(role).Result;
}
if (!roleManager.RoleExistsAsync
("Aluno").Result)
{
IdentityRoleViewModel role = new IdentityRoleViewModel();
role.Name = "Aluno";
role.Descricao = "Executar as operações do Aluno";
IdentityResult roleResult = roleManager.
CreateAsync(role).Result;
}
if (!roleManager.RoleExistsAsync
("Professor").Result)
{
IdentityRoleViewModel role = new IdentityRoleViewModel();
role.Name = "Professor";
role.Descricao = "Executar as operações do Professor";
IdentityResult roleResult = roleManager.
CreateAsync(role).Result;
}
if (!roleManager.RoleExistsAsync
("Usuario").Result)
{
IdentityRoleViewModel role = new IdentityRoleViewModel();
role.Name = "Professor";
role.Descricao = "Executar as operações do Usuario";
IdentityResult roleResult = roleManager.
CreateAsync(role).Result;
}
}
private async Task <IdentityRoleViewModel> GetRoleViewModel(User user)
{
var currentRoles = await this.userManager.GetRolesAsync(user);
var viewModel = new IdentityRoleViewModel
{
Username = user.UserName,
SelectedRoles = currentRoles,
AvailableRoles = this.roleManager
.Roles
.ToList()
.Select(r => new SelectListItem()
{
Text = r.Name.Replace("User", " User"),
Value = r.Name
}).ToList()
};
return(viewModel);
}
public async Task <ActionResult> Create(IdentityRoleViewModel roleView)
{
if (ModelState.IsValid)
{
// Convert view model to a model
var newRole = new IdentityRole();
newRole.Name = roleView.RoleName;
var newRoleResult = await _roleManager.CreateAsync(newRole);
if (newRoleResult.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "Failed to create role");
}
}
// If here, then an error occured.
return(View(roleView));
}
public async Task ManageRolesGet_ShouldReturnViewWithCorrectModelWhenValidUserId()
{
// Arrange
Mock <RoleManager <IdentityRole> > roleManager = GetAndSetRoleManagerMock();
Mock <UserManager <User> > userManager = GetAndSetUserManagerMock();
HomeController controller = new HomeController(null, userManager.Object, roleManager.Object);
// Act
IActionResult actionResult = await controller.ManageRoles(FirstUserId);
// Arrange
actionResult.Should().BeOfType <ViewResult>();
object model = actionResult.As <ViewResult>().Model;
model.Should().BeOfType <IdentityRoleViewModel>();
IdentityRoleViewModel returnedModel = model.As <IdentityRoleViewModel>();
returnedModel.Username.Should().Be(FirstUserUsername);
}
public async Task <IActionResult> ManageRoles(string id, IdentityRoleViewModel model)
{
var user = await this.userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(await GetRoleViewModel(user)));
}
var currentRoles = await this.userManager.GetRolesAsync(user);
var result = await this.userManager.RemoveFromRolesAsync(user, currentRoles);
if (!result.Succeeded)
{
AddErrors(result);
return(View(model));
}
result = await this.userManager.AddToRolesAsync(user, model.SelectedRoles);
if (!result.Succeeded)
{
AddErrors(result);
return(View(model));
}
this.TempData["SuccessMessage"] = $"Successfuly changed roles for user \"{user.UserName}\"!";
return(RedirectToAction(nameof(AllUsers)));
}
