public async Task <IActionResult> RemoveUserFromRole(string id)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound());
}
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var roles = await _userManager.GetRolesAsync(user);
var validRoles = roles.Select(s => new UserRolesViewModel(s)).ToList();
var model = new AddUserToRoleViewModel(id, validRoles);
//foreach (var item in roles)
//{
// if(await _userManager.IsInRoleAsync(user,item.Name))
// {
// model.userRoles.Add(new UserRolesViewModel()
// {
// RoleName = item.Name
// });
// }
//}
return(View(model));
}
public async Task <IActionResult> AddUserToRole(string id)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound());
}
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var roles = _roleManager.Roles.ToList();
var model = new AddUserToRoleViewModel()
{
UserId = id
};
foreach (var role in roles)
{
if (!await _userManager.IsInRoleAsync(user, role.Name))
{
model.UserRoles.Add(new UserRolesViewModel()
{
RoleName = role.Name
});
}
}
return(View(model));
}
public async Task <IActionResult> RemoveUserFromRole(AddUserToRoleViewModel model)
{
if (model == null)
{
return(NotFound());
}
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
return(NotFound());
}
var requestRoles = model.UserRoles.Where(r => r.IsSelected)
.Select(u => u.RoleName)
.ToList();
var result = await _userManager.RemoveFromRolesAsync(user, requestRoles);
if (result.Succeeded)
{
return(RedirectToAction("index"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View(model));
}
public async Task <IActionResult> RemoveUserFromRole(AddUserToRoleViewModel viewModel)
{
if (ModelState.IsValid)
{
var roleExists = await _roleManager.RoleExistsAsync(viewModel.RoleName);
if (!roleExists)
{
return(NotFound());
}
var user = await _userManager.FindByNameAsync(viewModel.Username);
if (user == null)
{
return(NotFound());
}
IdentityResult result = await _userManager.RemoveFromRoleAsync(user, viewModel.RoleName);
if (result.Succeeded)
{
return(Ok());
}
}
return(Ok());
}
public ActionResult AddUserToRole(AddUserToRoleViewModel model)// GET: Users
{
if (ModelState.IsValid)
{
AppRole findRole = _context.AppRoles.SingleOrDefault(p => p.Id == model.RoleIdSected);
if (findRole != null)
{
AppUser findUser = _context.AppUsers.SingleOrDefault(u => u.Id == model.UserIdSected);
if (findUser != null)
{
if (findUser.Roles.Count() >= 1)
{
Response.Write("<script>alert('User will not have a few roles!');</script>");
}
else
{
findRole.AppUsers.Add(findUser);
_context.SaveChanges();
}
}
}
}
//Заповнити всі пости
model.ListRoles = _context.AppRoles.Select(p => new ListBoxItems()
{
Id = p.Id, Name = p.Name
});
//Заповнити всі юзери
model.ListUsers = _context.AppUsers.Select(p => new ListBoxItems()
{
Id = p.Id, Name = p.UserProfile.LastName + " " + p.UserProfile.FirstName
});
return(View(model));
}
// POST api/gateway/addusertorole
public async Task <IActionResult> AddUserToRole(AddUserToRoleViewModel model, [FromHeader] string authorization)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
HttpParameters httParameters =
HttpParametersService
.GetHttpParameters(
model,
ConfigHelper.AppSetting(Constants.ServerUrls, Constants.AddUserToRole),
HttpMethod.Put,
string.Empty,
authorization
);
AddUserToRoleResponse addUserToRoleResult = await _gWService.PostTo <AddUserToRoleResponse>(httParameters);
if (addUserToRoleResult.StatusCode == 401)
{
return(await ResponseService.GetResponse <UnauthorizedObjectResult, AddUserToRoleResponse>(addUserToRoleResult, ModelState));
}
else if (addUserToRoleResult.StatusCode != 200)
{
return(await ResponseService.GetResponse <BadRequestObjectResult, AddUserToRoleResponse>(addUserToRoleResult, ModelState));
}
return(new OkObjectResult(addUserToRoleResult));
}
public async Task <IActionResult> AddUserToRole(AddUserToRoleViewModel addUserToRoleViewModel)
{
var role = await _roleManager.FindByIdAsync(addUserToRoleViewModel.RoleId);
var user = await _userManager.FindByIdAsync(addUserToRoleViewModel.UserId);
if (role != null && user != null)
{
var result = await _userManager.AddToRoleAsync(user, role.Name);
if (result.Succeeded)
{
return(RedirectToAction("EditRole", new { id = role.Id }));
}
foreach (var item in result.Errors)
{
ModelState.AddModelError(string.Empty, item.Description);
}
return(View(addUserToRoleViewModel));
}
else
{
ModelState.AddModelError(string.Empty, "角色或者用户不存在");
}
return(View(addUserToRoleViewModel));
}
public async Task <IActionResult> AddtoRole(AddUserToRoleViewModel model)
{
var roleExists = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
if (user == null || !roleExists)
{
ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
var userisInRole = await userManager.IsInRoleAsync(user, model.Role);
if (userisInRole)
{
TempData.AddErrorMessage($"{user.UserName} already has role {model.Role}!");
return(RedirectToAction(nameof(Index)));
}
else
{
await this.userManager.AddToRoleAsync(user, model.Role);
TempData.AddSuccessMessage($"User {user.UserName} successfully added to role {model.Role}.");
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> AddUserToRole(string id)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound());
}
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var roles = _roleManager.Roles.AsNoTracking()
.Select(r => r.Name).ToList();
var userRoles = await _userManager.GetRolesAsync(user);
var validRoles = roles.Where(r => !userRoles.Contains(r))
.Select(r => new UserRolesViewModel(r)).ToList();
var model = new AddUserToRoleViewModel(id, validRoles);
return(View(model));
}
public async Task <IActionResult> AddUserToRole(string RoleId)
{
var Role = await _roleManager.FindByIdAsync(RoleId);
if (Role == null)
{
return(RedirectToAction("Error", "Error"));
}
var Users = _userManager.Users;
var model = new List <AddUserToRoleViewModel>();
foreach (var item in Users)
{
AddUserToRoleViewModel addUser = new AddUserToRoleViewModel()
{
RoleId = RoleId,
UserId = item.Id,
UserName = item.UserName
};
if (await _userManager.IsInRoleAsync(item, Role.Name))
{
addUser.IsSelected = true;
}
else
{
addUser.IsSelected = false;
}
model.Add(addUser);
}
return(View(model));
}
public async Task <IActionResult> RemoveUserFromRole(AddUserToRoleViewModel viewModel)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(viewModel.UserId);
if (user == null)
{
return(NotFound());
}
var requestRoles = viewModel.UserRoles.Where(p => p.IsSelected)
.Select(s => s.RoleName)
.ToList();
var result = await _userManager.RemoveFromRolesAsync(user, requestRoles);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
foreach (var item in result.Errors)
{
ModelState.AddModelError(string.Empty, item.Description);
}
}
return(View(viewModel));
}
public async Task <IActionResult> AddUserToRole(AddUserToRoleViewModel model)
{
if (ModelState.IsValid)
{
await userService.AddUserToRole(model.UserId, model.RoleName);
}
return(RedirectToAction("Index", "Home"));
}
public ActionResult AddUserToRole()
{
AddUserToRoleViewModel viewModel = new AddUserToRoleViewModel();
Dictionary <string, string> Users = new Dictionary <string, string>();
Db.AspNetUsers.ToList().ForEach(c => Users.Add(c.Id, c.UserName));
return(View(viewModel));
}
public ActionResult AddUserToRole()
{
var model = new AddUserToRoleViewModel()
{
Email = string.Empty,
Roles = new List <string>()
{
"Administrator", "Manager", "User"
},
SelectedRole = string.Empty
};
return(View(model));
}
public ActionResult AddUserToRole(string returnUrl)
{
var users = UserManager.Users.ToList();
users.RemoveAll(u => u.UserName == User.Identity.Name);
var model = new AddUserToRoleViewModel()
{
UserName = string.Empty,
Users = users,
Roles = Roles.ExportToList(),
SelectedRole = string.Empty
};
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public async Task <IActionResult> AddUserToRole(string userId)
{
AddUserToRoleViewModel result = new AddUserToRoleViewModel();
var user = await _userManager.FindByIdAsync(userId);
var roles = new List <string>(await _userManager.GetRolesAsync(user));
if (user != null)
{
var roleList = _roleManager.Roles.ToList();
result.Roles = roleList;
result.ActiveRoles = roles;
result.User = user;
}
return(View(result));
}
//[Authorize(Roles = "Admin")]
public ActionResult AddUserToRole()// GET: Users
{
AddUserToRoleViewModel model = new AddUserToRoleViewModel();
//Заповнити всі пости
model.ListRoles = _context.AppRoles.Select(p => new ListBoxItems()
{
Id = p.Id, Name = p.Name
});
//Заповнити всі юзери
model.ListUsers = _context.AppUsers.Select(p => new ListBoxItems()
{
Id = p.Id, Name = p.UserProfile.LastName + " " + p.UserProfile.FirstName
});
return(View(model));
}
public ActionResult AddUserToRole(AddUserToRoleViewModel model)
{
if (ModelState.IsValid)
{
var user = UserManager.Users.FirstOrDefault(usr => usr.Email == model.Email);
if (user == null)
{
return(HttpNotFound($"User {model.Email} not found"));
}
UserManager.AddToRole(user.Id, model.SelectedRole);
return(RedirectToAction("Index", "Friends"));
}
return(View(model));
}
public async Task <IActionResult> AddUserToRoleGetAsync([FromQuery] string userId)
{
var roles = await this.usersService.GetRolesAsync();
var selectListRoles = roles.Select(r => new SelectListItem
{
Text = r.Name,
Value = r.Name
});
var model = new AddUserToRoleViewModel
{
UserId = userId,
Roles = selectListRoles
};
return(this.PartialView("_AddUserToRolePartial", model));
}
public async Task <IActionResult> AddUserToRole(AddUserToRoleViewModel addUserToRole)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(addUserToRole.Email);
if (user != null)
{
var result = await _userManager.AddToRoleAsync(user, addUserToRole.RoleName);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles"));
}
}
}
return(RedirectToAction("ListRoles"));
}
public async Task <IActionResult> AddUserToRole(AddUserToRoleViewModel addUserTo)
{
var role = await roleManager.FindByIdAsync(addUserTo.roleId);
var user = await userManager.FindByIdAsync(addUserTo.userId);
if (role != null && user != null)
{
if (!await userManager.IsInRoleAsync(user, role.Name))
{
var result = await userManager.AddToRoleAsync(user, role.Name);
if (result.Succeeded)
{
}
}
}
return(RedirectToAction("RoleList"));
}
public async Task <IHttpActionResult> RemoveUserFromRole(AddUserToRoleViewModel model)
{
model.UserId = User.Identity.GetUserId(); // what if a user doesn't exist
if (model.UserId == null)
{
return(BadRequest("Not Found"));
}
var result = await UserManager.RemoveFromRoleAsync(model.UserId, model.RoleName); // what if a Role doesn't exist
if (model.RoleName == null)
{
return(BadRequest("Not Found"));
}
if (!result.Succeeded)
{
return(BadRequest());
}
return(Ok(result));
}
public async Task <IActionResult> AddUserToRole(string id)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound());
}
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var roles = _roleManager.Roles.AsTracking().Select(s => s.Name).ToList();
var userRoles = await _userManager.GetRolesAsync(user);
var validRoles = roles.Where(p => userRoles.Contains(p))
.Select(r => new UserRolesViewModel(r)).ToList();
var model = new AddUserToRoleViewModel(id, validRoles);
//foreach (var role in roles)
//{
// if(!await _userManager.IsInRoleAsync(user,role.Name))
// {
// model.userRoles.Add(new UserRolesViewModel()
// {
// RoleName = role.Name,
// IsSelected = false
// });
// }
// else
// {
// model.userRoles.Add(new UserRolesViewModel()
// {
// RoleName = role.Name,
// IsSelected = true
// });
// }
//}
return(View(model));
}
public ActionResult RemoveUserFromRole(AddUserToRoleViewModel model)
{
model.UserId = User.Identity.GetUserId();
if (model.UserId == null)
{
return(View("Not Found"));
}
var result = UserManager.RemoveFromRole(model.UserId, model.RoleName);
if (model.RoleName == null)
{
return(View("Not Found"));
}
if (!result.Succeeded)
{
return(View("Unsuccessful"));
}
return(View(model));
}
public async Task <IActionResult> RemoveUserFromRole(string id)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound());
}
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var userRoles = await _userManager.GetRolesAsync(user);
var validRoles = userRoles.Select(r => new UserRolesViewModel(r)).ToList();
var model = new AddUserToRoleViewModel(id, validRoles);
return(View(model));
}
public async Task <IActionResult> AddToRole(AddUserToRoleViewModel model)
{
var roleExist = await this.roleManager.RoleExistsAsync(model.Role);
var user = await this.userManager.FindByIdAsync(model.UserId);
if (!roleExist || user == null)
{
this.ModelState.AddModelError(string.Empty, "Invalid identity details.");
}
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction(nameof(this.AddToRole)));
}
this.TempData.AddSuccessMessage($"User {user.UserName} successfully added to {model.Role} role.");
await this.userManager.AddToRoleAsync(user, model.Role);
return(this.RedirectToAction(nameof(this.AddToRole)));
}
public async Task <IActionResult> AddUserToRoles(string id)
{
var user = await _userManager.FindByIdAsync(id);
if (user != null)
{
var roles = _roleManager.Roles.ToList();
if (roles.Any())
{
var userRoles = _userManager.GetRolesAsync(user).Result.ToList();
var addRoleModel = new AddUserToRoleViewModel()
{
UserName = user.UserName,
RolesName = new List <string>(),
};
foreach (var item in roles)
{
if (!userRoles.Contains(item.Name))
{
addRoleModel.AllRoles.Add(item.Name);
}
}
return(View(addRoleModel));
}
else
{
ModelState.AddModelError("", "نقشی وجود ندارد! ابتدا نقش اضافه کنید");
}
}
else
{
ModelState.AddModelError("", "کاربر یافت نشد");
}
return(RedirectToAction(nameof(List), new
{
errors = GetErrosFromModelState()
}));
}
public async Task <IActionResult> AddUserToRole(string roleId)
{
var role = await roleManager.FindByIdAsync(roleId);
if (role != null)
{
AddUserToRoleViewModel addUserToRole = new AddUserToRoleViewModel {
roleId = role.Id
};
var users = await userManager.Users.ToListAsync();
foreach (IdentityUser user in users)
{
if (!await userManager.IsInRoleAsync(user, role.Name))
{
addUserToRole.identityUsers.Add(user);
}
}
return(View(addUserToRole));
}
return(RedirectToAction("RoleList"));
}
public async Task <IActionResult> AddUserToRoles(AddUserToRoleViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
foreach (var item in model.RolesName)
{
var role = await _roleManager.FindByNameAsync(item);
if (role != null)
{
var result = await _userManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
AddErrosFromResult(result);
}
}
else
{
ModelState.AddModelError("", $"'{item}' یافت نشد");
}
}
if (ModelState.IsValid)
{
return(RedirectToAction(nameof(List)));
}
}
else
{
ModelState.AddModelError("", "کاربر یافت نشد");
}
}
return(View(model));
}
public async Task <IActionResult> AddToRoleAsync(AddUserToRoleViewModel 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["SuccessfullMessage"] = ($"User {user.UserName} successfully added to the {model.Role} role.");
return(RedirectToAction(nameof(Index)));
}
