public async Task <IActionResult> RemoveFromRole(AddUserToRoleFormModel model)
{
var user = await this.userManager.FindByIdAsync(model.UserId);
if (!await this.IdentityDetailsValid(user, model.Role))
{
ModelState.AddModelError(string.Empty, $"Invalid Identity Details for {user}");
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
bool IsUserInRole = await this.userManager.IsInRoleAsync(user, model.Role);
if (!IsUserInRole)
{
TempData.AddSuccessMessage($"User {user.UserName} is not in Role {model.Role}");
return(RedirectToAction(nameof(Index)));
}
await this.userManager.RemoveFromRoleAsync(user, model.Role);
TempData.AddSuccessMessage($"User {user.UserName} is removed from role {model.Role}");
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
var userExists = user != null;
if (!roleExists || !userExists)
{
ModelState.AddModelError(string.Empty, "User or role does not exists.");
return(RedirectToAction(nameof(Index)));
}
if (!ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, "Invalid model state.");
return(RedirectToAction(nameof(Index)));
}
await this.userManager.AddToRoleAsync(user, model.Role);
// If the profile does not exists create new teacher profile
if (model.Role == TeacherRole && !usersService.TeacherProfileExists(model.UserId))
{
await usersService.CreateTeacherProfile(model.UserId);
}
TempData.AddSuccessMessage($"User {user.UserName} successfully added to the {model.Role} role.");
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
var userRole = await this.userManager.GetRolesAsync(user);
var userExists = user != null;
if (!userExists || !roleExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
if (userRole.Count > 0)
{
await userManager.RemoveFromRoleAsync(user, userRole.FirstOrDefault());
}
await this.userManager.AddToRoleAsync(user, model.Role);
TempData.AddSuccessMessage($"User {user.UserName} added to {model.Role} role.");
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
var userExists = user != null;
if (!roleExists || !userExists)
{
ModelState.AddModelError(string.Empty, WebConstants.InvalidIdentityDetailsOrUser);
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var role = model.Role;
var success = await this.users.ChangeUserRoleAsync(user, role);
if (!success)
{
return(BadRequest());
}
TempData.AddSuccessMessage(String.Format(WebConstants.TempDataUserRoleSuccessfullChange, user.Name, model.Role));
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
bool roleExists = await this.roleManager.RoleExistsAsync(model.Role);
User user = await this.userManager.FindByIdAsync(model.UserId);
bool userExists = user != null;
bool isAlreadyInRole = this.users.IsAlreadyInRole(user.Id);
if (!roleExists || !userExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
if (!isAlreadyInRole)
{
await this.userManager.AddToRoleAsync(user, model.Role);
TempData.AddSuccessMessage($"User {user.UserName} successfully added to {model.Role} role.");
return(RedirectToAction(nameof(Index)));
}
await this.userManager.AddToRoleAsync(user, model.Role);
TempData.AddSuccessMessage($"User {user.UserName} successfully added to {model.Role} role.");
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var userExists = await this.userManager.FindByIdAsync(model.UserId) != null;
var user = await this.userManager.FindByIdAsync(model.UserId);
if (!roleExists || !userExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details!");
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
if (model.Role == WebConstants.NoRole)
{
var roles = await userManager.GetRolesAsync(user);
await this.userManager.RemoveFromRolesAsync(user, roles);
TempData.AddSuccessMessage($@"User {user.UserName} removed from role\s {string.Join(", ", roles)}!");
return(RedirectToAction(nameof(Index)));
}
await this.userManager.AddToRoleAsync(user, model.Role);
TempData.AddSuccessMessage($"User {user.UserName} successfully added to role {model.Role}!");
return(this.RedirectToAction(nameof(this.Index)));
}
public async Task <IActionResult> AddToRole([FromBody] AddUserToRoleFormModel model)
{
bool roleExists = await this.roleManager.RoleExistsAsync(model.Role);
User user = await this.userManager.FindByIdAsync(model.UserId);
bool userExists = user != null;
bool isAlreadyInRole = this.users.IsAlreadyInRole(user.Id);
if (!roleExists || !userExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!isAlreadyInRole)
{
await this.userManager.AddToRoleAsync(user, model.Role);
return(Ok());
}
await this.userManager.AddToRoleAsync(user, model.Role);
return(Ok());
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
if (!roleExists || user == null)
{
this.ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction(nameof(this.Index)));
}
await this.userManager.AddToRoleAsync(user, model.Role);
if (user != null)
{
this.TempData.AddSuccessMessage($"Successfully added user: {user.UserName} to the {model.Role} role.");
}
return(this.RedirectToAction(nameof(this.Index)));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var user = await this.userManager.FindByIdAsync(model.UserId);
var role = model.Role;
var roleExists = await this.roleManager.RoleExistsAsync(role);
var userExists = user != null;
var userIsInRole = await this.userManager.IsInRoleAsync(user, role);
if (!roleExists || !userExists)
{
ModelState.TryAddModelError(string.Empty, InvalidIdentityDetails);
}
if (!ModelState.IsValid)
{
TempData.AddErrorMessage(ErrorModelState());
return(RedirectToAction(nameof(AllUsers)));
}
await this.userManager.AddToRoleAsync(user, model.Role);
var userName = user.FirstName;
TempData.AddSuccessMessage(UserAddedSuccessFullToRole(userName, model.Role));
return(RedirectToAction(nameof(AllUsers)));
}
public async Task <IActionResult> ChangeRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
var userExists = user != null;
if (!roleExists || !userExists)
{
this.ModelState.AddModelError(string.Empty, WebConstants.ModelStateCustomError);
}
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction(nameof(Index)));
}
var userInRoles = await this.userManager.GetRolesAsync(user);
if (userInRoles.Any())
{
await this.userManager.RemoveFromRolesAsync(user, userInRoles);
await this.userManager.AddToRoleAsync(user, model.Role);
}
await this.userManager.AddToRoleAsync(user, model.Role);
TempData.AddSuccessMessage(string.Format(WebConstants.SuccessMessageRoleChangePlaceholder, user.UserName, model.Role));
return(RedirectToAction(nameof(Index)));
}
public async Task AddToRoleWithInvalidModelStateRoleShouldReturnBadRequest()
{
string errorMessage = null;
var userManager = UserManagerMock.New;
userManager
.Setup(u => u.FindByIdAsync(It.IsAny <string>()))
.ReturnsAsync(this.users.First());
var roleManager = RoleManagerMock.New;
roleManager
.Setup(m => m.RoleExistsAsync(It.IsAny <string>()))
.ReturnsAsync(true);
var controller = new UsersController(userManager.Object, roleManager.Object);
var tempData = new Mock <ITempDataDictionary>();
tempData
.SetupSet(t => t[TempDataErrorMessageKey] = It.IsAny <string>())
.Callback((string key, object message) => errorMessage = message as string);
controller.TempData = tempData.Object;
controller.ModelState.AddModelError(string.Empty, string.Empty);
var model = new AddUserToRoleFormModel
{
Role = string.Empty,
UserId = string.Empty
};
var result = await controller.AddToRole(model);
this.AssertAddToRoleInvalidRequest(errorMessage, model, result, DefaultErrorMessage);
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
var userExists = user != null;
if (!roleExists || !userExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details!");
}
if (!ModelState.IsValid)
{
TempData.AddErrorMessage("Invalid identity details! No roles updated!");
return(RedirectToAction(nameof(UsersController.Index)));
}
if (model.Role == WebConstants.UserRole)
{
await this.userManager.RemoveFromRoleAsync(user, WebConstants.AdministratorRole);
}
else
{
await this.userManager.AddToRoleAsync(user, model.Role);
}
TempData.AddSuccessMessage($"User {user.UserName} successfully added to the {model.Role} role.");
return(RedirectToAction(nameof(UsersController.Index)));
}
private void AssertAddToRoleInvalidRequest(string msg, AddUserToRoleFormModel model, IActionResult result, string assertMsg)
{
msg.Should().Be(assertMsg);
result.Should().BeOfType <RedirectToActionResult>();
var redirect = result.As <RedirectToActionResult>();
redirect.ActionName.Should().Be("UserDetails");
redirect.ControllerName.Should().Be("Users");
redirect.RouteValues.Keys.Should().Contain("area");
redirect.RouteValues["area"].Should().Be(Administration);
redirect.RouteValues.Keys.Should().Contain("id");
redirect.RouteValues["id"].Should().Be(model.UserId);
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(All)));
}
User user = await userManager.FindByIdAsync(model.UserId);
IdentityResult result = await this.userManager.AddToRoleAsync(user, model.Role);
this.AddTempDataNotification("User added to role " + model.Role, NotificationType.Success);
return(RedirectToAction(nameof(All)));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
var userExists = user != null;
if (!roleExists || !userExists)
{
this.ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!this.ModelState.IsValid)
{
this.RedirectToAction(nameof(this.Index));
}
if (this.Request.Form.ContainsKey("add"))
{
if (await this.userManager.IsInRoleAsync(user, model.Role))
{
this.TempData.AddWarningMessage($"User {user.UserName} is already in {model.Role} role.");
return(this.RedirectToAction(nameof(this.Index)));
}
await this.userManager.AddToRoleAsync(user, model.Role);
this.TempData.AddSuccessMessage($"User {user.UserName} successfully added to the {model.Role} role.");
}
if (this.Request.Form.ContainsKey("remove"))
{
if (!await this.userManager.IsInRoleAsync(user, model.Role))
{
this.TempData.AddWarningMessage($"User {user.UserName} is not in {model.Role} role.");
return(this.RedirectToAction(nameof(this.Index)));
}
await this.userManager.RemoveFromRoleAsync(user, model.Role);
this.TempData.AddSuccessMessage($"User {user.UserName} is no longer {model.Role}.");
}
return(this.RedirectToAction(nameof(this.Index)));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
var userExists = user != null;
if (!roleExists || !userExists)
{
this.ModelState.AddModelError(string.Empty, ErrorMsgInvalidIdentity);
}
if (!this.ModelState.IsValid)
{
this.RedirectToAction(nameof(this.Index));
}
if (this.Request.Form.ContainsKey(AddRequestKey))
{
if (await this.userManager.IsInRoleAsync(user, model.Role))
{
this.TempData.AddWarningMessage(string.Format(WarrningUserAlreadyInRole, user.UserName, model.Role));
return(this.RedirectToAction(nameof(this.Index)));
}
await this.userManager.AddToRoleAsync(user, model.Role);
this.TempData.AddSuccessMessage(string.Format(SuccessUserAddedToRole, user.UserName, model.Role));
}
if (this.Request.Form.ContainsKey(RemoveRequestKey))
{
if (!await this.userManager.IsInRoleAsync(user, model.Role))
{
this.TempData.AddWarningMessage(string.Format(WarrningUserNotInRole, user.UserName, model.Role));
return(this.RedirectToAction(nameof(this.Index)));
}
await this.userManager.RemoveFromRoleAsync(user, model.Role);
this.TempData.AddSuccessMessage(string.Format(SuccessUserRemovedFromRole, user.UserName, model.Role));
}
return(this.RedirectToAction(nameof(this.Index)));
}
public async Task <IActionResult> DeleteUser(AddUserToRoleFormModel model)
{
var user = await this.userManager.FindByIdAsync(model.UserId);
var userExists = user != null;
if (!userExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
await this.userManager.DeleteAsync(user);
TempData.AddSuccessMessage($"User {user.UserName} was successfully deleted.");
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
var userExists = user != null;
if (!roleExists || !userExists || !ModelState.IsValid)
{
TempData.AddErrorMessage("Invalid identity details.");
return(RedirectToAction(nameof(UserDetails), "Users", new { area = Administration, id = model.UserId }));
}
await this.userManager.AddToRoleAsync(user, model.Role);
TempData.AddSuccessMessage($"User {user.UserName} successfully added to the {model.Role} role.");
return(RedirectToAction(nameof(UserDetails), "Users", new { area = Administration, id = model.UserId }));
}
public async Task <IActionResult> RemoveFromRole(AddUserToRoleFormModel model)
{
var roleExists = await this._roleManager.RoleExistsAsync(model.Role);
var user = await this._userManager.FindByIdAsync(model.UserId);
var userRoles = await this._userManager.GetRolesAsync(user);
var userExists = user != null;
if (!roleExists || !userExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
foreach (var role in userRoles)
{
if (role != model.Role)
{
TempData.ErrorMessage("User dosn`t have this role");
return(RedirectToAction(nameof(AllCustomers)));
}
}
if (!ModelState.IsValid)
{
RedirectToAction(nameof(AllCustomers));
}
await this._userManager.RemoveFromRoleAsync(user, model.Role);
if (user != null)
{
TempData.AddSuccessMessage($"Successfully removed user {user.UserName} to {model.Role} role");
}
return(RedirectToAction(nameof(AllCustomers)));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
var userExist = user != null;
var roleExist = await roleManager.RoleExistsAsync(model.Role);
if (!roleExist || !userExist)
{
ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
TempData.AddSuccessMessage($"User {user} added to {model.Role} role.");
await this.userManager.AddToRoleAsync(user, model.Role);
return(RedirectToAction("Index"));
}
public async Task AddToRoleWithValidDataShouldReturnViewWithValidModel()
{
var user = this.users.First();
var role = this.roles.First().Name;
string successMessage = null;
var userManager = UserManagerMock.New;
userManager
.Setup(u => u.FindByIdAsync(It.IsAny <string>()))
.ReturnsAsync(user);
userManager
.Setup(u => u.AddToRoleAsync(user, role))
.ReturnsAsync(new IdentityResult());
var roleManager = RoleManagerMock.New;
roleManager
.Setup(m => m.RoleExistsAsync(It.IsAny <string>()))
.ReturnsAsync(true);
var controller = new UsersController(userManager.Object, roleManager.Object);
var tempData = new Mock <ITempDataDictionary>();
tempData
.SetupSet(t => t[TempDataSuccessMessageKey] = It.IsAny <string>())
.Callback((string key, object message) => successMessage = message as string);
controller.TempData = tempData.Object;
var model = new AddUserToRoleFormModel
{
Role = role,
UserId = user.Id
};
var result = await controller.AddToRole(model);
var assertMsg = $"User {user.UserName} successfully added to the {model.Role} role.";
this.AssertAddToRoleInvalidRequest(successMessage, model, result, assertMsg);
}
public async Task <ActionResult> AddToRole(AddUserToRoleFormModel model)
{
var user = this.userService.FindById(model.UserId);
var role = this.users.GetRoles(model.Role);
var userExists = user != null;
var roleExists = role != null;
if (!roleExists || !userExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
await this.userService.AddToRoleAsync(user.Id, role.Name);
TempData.AddSuccessMessage($"User {user.UserName} successfully added to the {role.Name} role.");
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> RemoveFromRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
var userExists = user != null;
if (!roleExists || !userExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
await this.userManager.RemoveFromRoleAsync(user, model.Role);
TempData.AddSuccessMessage($"User {user.UserName} successfully removed from the {model.Role} role.");
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
var userExists = user != null;
if (!roleExists || !userExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
await this.userManager.AddToRoleAsync(user, model.Role);
this.TempData.AddSuccessMessage(string.Format(SuccessfullAddRoleToUser, model.Role, user.UserName));
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> RemoveFromRole(AddUserToRoleFormModel model)
{
var user = await this.userManager.FindByIdAsync(model.UserId);
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var userExists = user != null;
if (!roleExists || !userExists)
{
this.ModelState.AddModelError(string.Empty, InvalidIdentityError);
}
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction(nameof(this.Index))
.WithWarning(string.Empty, CouldNotUpdateRecord));
}
var result = await this.userManager.RemoveFromRoleAsync(user, model.Role);
return(this.RedirectToAction(nameof(this.Index))
.WithSuccess(string.Empty, RecordUpdatedSuccessfully));
}
public async Task <IActionResult> AddToRole(AddUserToRoleFormModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
var userExists = user != null;
if (!roleExists || !userExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
await this.userManager.AddToRoleAsync(user, model.Role);
TempData.AddSuccessMessage($"Потребителят {user.UserName} е добавен успешно в ролята {model.Role}");
return(RedirectToAction(nameof(Index)));
}
