public async Task <IActionResult> EditUsersInRole(string roleId)
{
ViewBag.roleId = roleId;
var role = await _roleManager.FindByIdAsync(roleId);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {roleId} cannot be found";
return(View("NotFound"));
}
var model = new List <UsersInRoleModel>();
foreach (var user in _userManager.Users)
{
var usersInRoleModel = new UsersInRoleModel
{
Id = user.Id,
Name = user.UserName,
IsSelected = await _userManager.IsInRoleAsync(user, role.Name)
};
model.Add(usersInRoleModel);
}
return(View(model));
}
public async Task <IHttpActionResult> ManageUsersInRole(UsersInRoleModel model)
{
var role = await this.AppRoleManager.FindByIdAsync(model.Id);
if (role == null)
{
ModelState.AddModelError("", "Role does not exist");
return(BadRequest(ModelState));
}
//will provide all the users in the role
foreach (string user in model.ActiveUsers)
{
var appUser = await this.AppUserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", String.Format("User: {0} does not exists", user));
continue;
}
if (!this.AppUserManager.IsInRole(user, role.Name))
{
IdentityResult result = await this.AppUserManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("User: {0} could not be added to role", user));
}
}
}
//This will give all the users
//who were once in that role but
//are not removed from that role
foreach (string user in model.RemovedUsers)
{
var appUser = await this.AppUserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", String.Format("User: {0} does not exists", user));
continue;
}
IdentityResult result = await this.AppUserManager.RemoveFromRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("User: {0} could not be removed from role", user));
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task<IHttpActionResult> ManageUsersInRole(UsersInRoleModel model)
{
var role = await this.AppRoleManager.FindByIdAsync(model.Id);
if (role == null)
{
ModelState.AddModelError("", "Role does not exist");
return BadRequest(ModelState);
}
foreach (string user in model.EnrolledUsers)
{
var appUser = await this.AppUserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", String.Format("User: {0} does not exists", user));
continue;
}
if (!this.AppUserManager.IsInRole(user, role.Name))
{
IdentityResult result = await this.AppUserManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("User: {0} could not be added to role", user));
}
}
}
foreach (string user in model.RemovedUsers)
{
var appUser = await this.AppUserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", String.Format("User: {0} does not exists", user));
continue;
}
IdentityResult result = await this.AppUserManager.RemoveFromRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("User: {0} could not be removed from role", user));
}
}
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
return Ok();
}
public async Task <IHttpActionResult> ManageUsersInRole([FromBody] UsersInRoleModel model)
{
var role = await RoleManager.FindByIdAsync(model.Id);
if (role == null)
{
ModelState.AddModelError("", "Rol no existe");
return(BadRequest(ModelState));
}
foreach (string user in model.EnrolledUsers)
{
var appUser = await UserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", String.Format("Usuario: {0} no existe", user));
continue;
}
if (!UserManager.IsInRole(user, role.Name))
{
IdentityResult result = await UserManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("Usuario: {0} no tiene agregado el rol", user));
}
}
}
foreach (string user in model.RemovedUsers)
{
var appUser = await UserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", String.Format("Usuario: {0} no existe", user));
continue;
}
IdentityResult result = await UserManager.RemoveFromRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("Usuario: {0} no tiene agregado el rol", user));
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task <IHttpActionResult> ManageUsersInRole(UsersInRoleModel model)
{
var role = await this.SenatRoleManager.FindByIdAsync(model.Id);
if (role == null)
{
ModelState.AddModelError("", "Role does not exist");
return(BadRequest(ModelState));
}
foreach (string user in model.EnrolledUsers)
{
var appUser = await this.senatUserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", String.Format("User: {0} does not exists", user));
continue;
}
if (!this.senatUserManager.IsInRole(user, role.Name))
{
IdentityResult result = await this.senatUserManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("User: {0} could not be added to role", user));
}
}
}
foreach (string user in model.RemovedUsers)
{
var appUser = await this.senatUserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", String.Format("User: {0} does not exists", user));
continue;
}
IdentityResult result = await this.senatUserManager.RemoveFromRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format("User: {0} could not be removed from role", user));
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task <IHttpActionResult> ManageUsersInRole(UsersInRoleModel model)
{
var role = await this.RoleManager.FindByIdAsync(model.RoleId);
if (role == null)
{
ModelState.AddModelError("", Common.Constants.ErrorMessage.RoleNotExist);
return(BadRequest(ModelState));
}
foreach (Guid userId in model.EnrolledUsers)
{
var appUser = await this.UserManager.FindByIdAsync(userId);
if (appUser == null)
{
ModelState.AddModelError("", String.Format(Common.Constants.ErrorMessage.UserNotFound, userId));
continue;
}
if (!this.UserManager.IsInRole(userId, role.Name))
{
IdentityResult result = await this.UserManager.AddToRoleAsync(userId, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format(Common.Constants.ErrorMessage.UserCannotAddToRole, userId));
}
}
}
foreach (Guid userId in model.RemovedUsers)
{
var appUser = await this.UserManager.FindByIdAsync(userId);
if (appUser == null)
{
ModelState.AddModelError("", String.Format(Common.Constants.ErrorMessage.UserNotFound, userId));
continue;
}
IdentityResult result = await this.UserManager.RemoveFromRoleAsync(userId, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", String.Format(Common.Constants.ErrorMessage.UserCannotRemoveFromRole, userId));
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task <IHttpActionResult> ManageUsersInRole(UsersInRoleModel model)
{
var role = await _applicationRoleManager.FindByIdAsync(model.Id);
if (role == null)
{
ModelState.AddModelError("", "Role does not exist");
return(BadRequest(ModelState));
}
foreach (var user in model.EnrolledUsers)
{
var appUser = await _applicationUserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", $"User: {user} does not exists");
continue;
}
if (!_applicationUserManager.IsInRole(user, role.Name))
{
var result = await _applicationUserManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", $"User: {user} could not be added to role");
}
}
}
foreach (var user in model.RemovedUsers)
{
var appUser = await _applicationUserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", $"User: {user} does not exists");
continue;
}
var result = await _applicationUserManager.RemoveFromRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", $"User: {user} could not be removed from role");
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task <IHttpActionResult> ManageUsersInRole(UsersInRoleModel model)
{
var role = this.AppRoleManager.FindById(model.Id);
if (role == null)
{
ModelState.AddModelError("", "Роль не існує");
return(BadRequest(ModelState));
}
foreach (string user in model.EnrolledUsers)
{
var appUser = await this.AppRoleManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", $"Юзвєря {user} немає");
continue;
}
if (!this.UserManager.IsInRole(user, role.Name))
{
IdentityResult result = await this.UserManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", $"Юзер {user} не доданий до ролі");
}
}
}
foreach (string user in model.RemovedUsers)
{
var appUser = await this.AppRoleManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", $"Юзвєря {user} немає");
continue;
}
IdentityResult result = await this.UserManager.RemoveFromRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", $"Юзвєря {user} не видалено з ролі");
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public ActionResult ManageRoles(string Id)
{
var x = db.Users.Find(Id);
var role = new UsersInRoleModel();
role.Id = Id;
role.roleList = new MultiSelectList(db.Roles, "Name", "Name", role.selectedRoles);
role.firstName = x.FirstName;
role.lastName = x.LastName;
role.selectedRoles = roleHelper.ListUserRoles(x.Id).ToArray();
return(View(role));
}
public async Task <ActionResult> Delete([Bind(Include = "Empleado, RolId")] EmpleadoUserRolModel empleadoUserRolModel)
{
var userRoles = new UsersInRoleModel(empleadoUserRolModel.RolId);
userRoles.RemovedUsers.Add(empleadoUserRolModel.Empleado.UserId);
var result = await PostAsync("api/Rol/ManageUsersInRole", userRoles);
if (!result.IsSuccessStatusCode)
{
ViewData["Error"] = await ErrorAsync("Rol", "Delete", "Error con tus permisos en la api", 401);
}
return(RedirectToAction("Index", new { id = empleadoUserRolModel.Empleado.Identificacion }));
}
public ActionResult Index()
{
List <UsersInRoleModel> users = new List <UsersInRoleModel>();
foreach (var user in db.Users.ToList())
{
var temp = new UsersInRoleModel();
temp.user = user;
temp.roles = roleHelper.ListUserRoles(user.Id).ToList();
users.Add(temp);
}
return(PartialView("~/Views/Admin/_ManageRolesPartial.cshtml"));
}
public IActionResult UsersInRole(UsersInRoleModel model)
{
FilterContainer <SystemUserRoles> container = FilterContainerBuilder.Build <SystemUserRoles>();
container.And(n => n.RoleId == model.RoleId);
var result = _systemUserRolesService.QueryPaged(x => x
.Page(model.Page, model.PageSize)
.Where(container)
//.Sort(n => n.OnFile(model.SortBy).ByDirection(model.SortDirection))
);
model.Items = result.Items;
model.TotalItems = result.TotalItems;
return(DynamicResult(model, $"~/Views/Security/{WebContext.ActionName}.cshtml"));
}
public async Task <IHttpActionResult> ManageUsersInRole(UsersInRoleModel model)
{
var role = await this.roleService.FindByIdAsync(model.Id);
if (role == null)
{
ModelState.AddModelError("", "Role does not exist");
return(BadRequest(ModelState));
}
await AddToRole(model.EnrolledUsers, role.Name);
await RemoveFromRole(model.RemovedUsers, role.Name);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public ActionResult Index()
{
List <UsersInRoleModel> users = new List <UsersInRoleModel>();
foreach (var user in db.Users.ToList())
{
//var x = db.Users.Find(Id);
var temp = new UsersInRoleModel();
var role = new UsersInRoleModel();
temp.user = user;
temp.roles = roleHelper.ListUserRoles(user.Id).ToList();
role.roleList = new MultiSelectList(db.Roles, "Name", "Name", role.selectedRoles);
//role.firstName = x.FirstName;
//role.lastName = x.LastName;
//role.selectedRoles = roleHelper.ListUserRoles(x.Id).ToArray();
users.Add(temp);
}
return(View(users));
}
public async Task <IHttpActionResult> ManageUsersInRole(UsersInRoleModel model)
{
var role = await AppRoleManager.FindByIdAsync(model.Id);
if (role == null)
{
ModelState.AddModelError("", "Role dos not exist");
return(BadRequest(ModelState));
}
foreach (var user in model.EnrolledUsers)
{
var appUser = await AppUserManager.FindByIdAsync(user);
if (appUser == null)
{
ModelState.AddModelError("", $"User dos not exist {user}");
continue;
}
if (!AppUserManager.IsInRole(user, role.Name))
{
IdentityResult result = await AppUserManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("User", $" User can't not added to role {user}");
}
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task <ResponseBasic> ManageUsersInRole(UsersInRoleModel model)
{
ResponseBasic response = new ResponseBasic();
var role = await this.RoleManager.FindByIdAsync(model.Id);
int rows = 0;
if (role == null)
{
response.Mensagge = "El Role No Existe";
response.Errors.Add(new ErrorMessage("", "El Role No Ha Sido Encontrado"));
return(response);
}
foreach (string user in model.EnrolledUsers)
{
var appUser = await this.UserManager.FindByIdAsync(user);
if (appUser == null)
{
response.Errors.Add(new ErrorMessage("", String.Format("Usuario: {0} No Existe", user)));
continue;
}
if (!this.UserManager.IsInRole(user, role.Name))
{
IdentityResult result = await UserManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
response.Errors.Add(new ErrorMessage("", String.Format("Usuario: {0} No Se Le Ha Agregado El Role", user)));
}
rows++;
}
}
foreach (string user in model.RemovedUsers)
{
var appUser = await this.UserManager.FindByIdAsync(user);
if (appUser == null)
{
response.Errors.Add(new ErrorMessage("", String.Format("Usuario: {0} No Existe", user)));
continue;
}
IdentityResult result = await this.UserManager.RemoveFromRoleAsync(user, role.Name);
if (!result.Succeeded)
{
response.Errors.Add(new ErrorMessage("", String.Format("Usuario: {0} No Se Le Ha Agregado El Role", user)));
}
rows++;
}
response.RowAffected = rows;
if (response.Errors.Count == 0)
{
response.Mensagge = "Operación Realizada Con Exito";
return(response);
}
response.Mensagge = "Operacón Realizada Con Errores";
return(response);
}
/// <summary>
/// Change the relationships between users and roles
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task ManageUsersInRolesAsync(UsersInRoleModel model)
{
await PutAsJsonAsync(model, "/api/Roles/ManageUsersInRole");
}
public async Task <IHttpActionResult> ManageUsersInRole(UsersInRoleModel model)
{
return(Ok(await new RoleBLL(Request).ManageUsersInRole(model)));
}
public async Task <IHttpActionResult> ManageUsersInRole([FromBody] UsersInRoleModel model)
{
DbResult _dbResult = new DbResult();
var role = await this.AppRoleManager.FindByIdAsync(model.Id);
if (role == null)
{
_dbResult = new DbResult
{
IsDbSuccess = false,
DbMessage = "Role does not exist"
};
}
foreach (string user in model.EnrolledUsers)
{
var appUser = await this.UserManager.FindByIdAsync(user);
if (appUser == null)
{
_dbResult = new DbResult
{
IsDbSuccess = false,
DbMessage = "User " + user + " does not exists"
};
continue;
}
if (!this.UserManager.IsInRole(user, role.Name))
{
IdentityResult result = await this.UserManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
_dbResult = new DbResult
{
IsDbSuccess = false,
DbMessage = "User " + user + " could not be added to role"
};
}
}
}
foreach (string user in model.RemovedUsers)
{
var appUser = await this.UserManager.FindByIdAsync(user);
if (appUser == null)
{
_dbResult = new DbResult
{
IsDbSuccess = false,
DbMessage = "User " + user + " does not exists"
};
continue;
}
IdentityResult result = await this.UserManager.RemoveFromRoleAsync(user, role.Name);
if (!result.Succeeded)
{
_dbResult = new DbResult
{
IsDbSuccess = false,
DbMessage = "User " + user + " could not be removed from role"
};
}
}
return(Ok(_dbResult));
}
