public async Task <IActionResult> AddUserToRole(AddUserToRoleModel addUserToRoleModel)
{
if (ModelState.IsValid)
{
var userName = addUserToRoleModel.userName;
var roleName = addUserToRoleModel.roleName;
var roleID = addUserToRoleModel.roleID;
var user = await _userManager.FindByNameAsync(userName);
if (user != null)
{
var result = await _userManager.AddToRoleAsync(user, roleName);
if (result.Succeeded)
{
return(RedirectToAction(nameof(Detail), new { roleID = roleID }));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
else
{
ModelState.AddModelError(string.Empty, "用户不存在");
}
}
return(RedirectToAction(nameof(Index))); // TODO:应该改为跳转到专门的错误页
}
public async Task <IActionResult> AddUserToRole([FromBody] AddUserToRoleModel addUserToRoleModel)
{
return(await OnActionWorkAsync(async() =>
{
await _userService.AddUserToRole(addUserToRoleModel);
return Ok();
}));
}
public ActionResult AddUserToRole(AddUserToRoleModel model)
{
//UserManager.AddToRole(user.Id, model.)
var user = UserManager.FindByEmail(model.email);
if (user != null)
{
UserManager.AddToRole(user.Id, model.selectedRole);
}
return(RedirectToAction("Index", "Home"));
}
public async Task <StatusCodeResult> AddUserToRole(int userId, [FromBody] AddUserToRoleModel model, CancellationToken cancellationToken)
{
var command = new AddUserToRoleCommand()
{
UserId = userId,
RoleId = model.RoleId
};
await mediator.Send(command, cancellationToken);
return(StatusCode(StatusCodes.Status200OK));
}
// POST: /Account/AddUserToRole
public ActionResult AddUserToRole(AddUserToRoleModel model)
{
try
{
var user = UserManager.FindByEmail(model.Email);
UserManager.AddToRole(user.Id, model.SelectedRole);
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
return(HttpNotFound());
}
}
public async Task <IHttpActionResult> RemoveUserFromRole(AddUserToRoleModel removeModel)
{
IdentityResult result = await this.AppUserManager.RemoveFromRoleAsync(removeModel.UserId, removeModel.Roles);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("User: {0} could not be removed from role", removeModel.UserId));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
/// <summary>
/// </summary>
/// Adds the user to role.
/// <param name="addUserToRoleModel">The add user to role model.</param>
/// <returns>
/// <see cref="Task" />
/// </returns>
/// <exception cref="NotFoundException"></exception>
/// <exception cref="IdentityResultException"></exception>
public async Task AddUserToRole(AddUserToRoleModel addUserToRoleModel)
{
var user = await _userManager.FindByNameAsync(addUserToRoleModel.Username);
if (user == null)
{
throw new NotFoundException($"User {addUserToRoleModel.Username} not found");
}
var result = await _userManager.AddToRoleAsync(user, addUserToRoleModel.RoleName);
if (!result.Succeeded)
{
throw new IdentityResultException(result);
}
}
public async Task <ActionResult> UserRole(string page)
{
var rolesAssigneed = canLoggedInUserView();
string roleCanView = "Admin";
if (rolesAssigneed != null)
{
var element = rolesAssigneed.Where(x => x.StartsWith(roleCanView)).FirstOrDefault();
if (element != roleCanView)
{
return(RedirectToAction("Unauthorized", "Access"));
}
else
{
AddUserToRoleModel mainModel = new AddUserToRoleModel();
var roleList = new List <ExistingRole>();
var UserToAssignRole = _applicationDbContext.Users.SingleOrDefault(i => i.Id == page);
string FullName = UserToAssignRole.FullName;
ViewBag.FullName = FullName;
var roleModel = await RoleManager.Roles.ToListAsync();
foreach (var role in roleModel)
{
ExistingRole model = new ExistingRole();
model.Id = role.Id;
model.Name = role.Name;
model.Checked = false;
roleList.Add(model);
}
mainModel.UserId = page;
mainModel.ExistingRole = roleList;
return(View(mainModel));
}
}
else
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
}
return(RedirectToAction("Login", "Access"));
}
public ActionResult AddUserToRole(AddUserToRoleModel model)
{
try
{
var user = UserManager.FindByEmail(model.userEmail);
Store store = new Store();
store.Address = user.Address;
store.Email = user.Email;
store.Name = user.UserName;
store.TelephoneNumber = user.PhoneNumber;
db.Stores.Add(store);
db.SaveChanges();
UserManager.AddToRole(user.Id, model.selectedRole);
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
return(View(model));
}
}
public async Task <IActionResult> UpdateUserRoles([FromBody] AddUserToRoleModel model)
{
var isAdmin = await Utilities.IsUserSuperAdmin(User, _userManager);
if (!isAdmin)
{
return(Unauthorized());
}
var user = await _userManager.FindByIdAsync(model.UserId.ToString());
if (user == null)
{
return(RequestHandler.UserNotFound());
}
await RemoveRolesFromUser(user);
await AddRolesToUser(user, model.Roles);
return(Ok(user));
}
public async Task <IHttpActionResult> AddUserToRole(AddUserToRoleModel addModel)
{
string[] roles = new string[] { addModel.Roles };
var appUser = await this.AppUserManager.FindByIdAsync(addModel.UserId);
if (appUser == null)
{
return(NotFound());
}
var currentRoles = await this.AppUserManager.GetRolesAsync(appUser.Id);
var rolesNotExists = roles.Except(this.AppRoleManager.Roles.Select(x => x.Name)).ToArray();
//var roleNotExists = AppRoleManager.FindById(addModel.RoleId);
if (rolesNotExists == null)
{
ModelState.AddModelError("", string.Format("Roles '{0}' does not exixts in the system", string.Join(",", rolesNotExists)));
return(BadRequest(ModelState));
}
IdentityResult result = await this.AppUserManager.AddToRolesAsync(appUser.Id, roles);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("User: {0} could not be added to role", addModel.UserId));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task <ActionResult> UserRole(AddUserToRoleModel model)
{
foreach (var allRoles in model.ExistingRole)
{
if (allRoles.Checked == true)
{
string[] roles = new string[] { allRoles.Name };
foreach (var role in roles)
{
var isInRole = await UserManager.IsInRoleAsync(model.UserId, role);
if (!isInRole)
{
await UserManager.AddToRoleAsync(model.UserId, role);
}
else
{
ModelState.AddModelError("", role + "has already been assigned to user");
}
}
}
}
return(RedirectToAction("Index", "Manage"));
}
public ActionResult AddUserToRole()
{
var model = new AddUserToRoleModel();
return(View(model));
}
