public async Task <IActionResult> AssignUserToRole(int id, int roleid) { ApplicationUser user = await usermanager.FindByIdAsync(id.ToString()); if (user == null) { return(NotFound()); } ApplicationRole role = await rolemanager.FindByIdAsync(roleid.ToString()); if (role == null) { return(NotFound()); } IdentityResult result = await usermanager.AddToRoleAsync(user, role.Name); if (result.Succeeded) { return(Ok()); } return(BadRequest(result.Errors)); }
//[HttpPost] //public async Task<ActionResult> Roles(RoleViewModel roleViewModel) //{ // if (ModelState.IsValid) // { // if (!RoleManager.RoleExists(roleViewModel.Name)) // { // var role = new IdentityRole(roleViewModel.Name); // var roleresult = await RoleManager.CreateAsync(role); // if (!roleresult.Succeeded) // { // ViewBag.Msg = _hlp.getMsg(AlertType.success.ToString(), "Added successfully!"); // ModelState.AddModelError("", roleresult.Errors.First()); // return View(RoleManager.Roles); // } // } // else // { // ViewBag.Msg = _hlp.getMsg(AlertType.danger.ToString(), "The role already exist!"); // } // } // return View(RoleManager.Roles); //} public async Task <ActionResult> RoleDetails(string id) { if (id == null) { return(View("Response", new ResponseViewModel() { Msg = "Bad Request!" })); } var role = await RoleManager.FindByIdAsync(id); // Get the list of Users in this Role var users = new List <ApplicationUser>(); // Get the list of Users in this Role foreach (var user in UserManager.Users.ToList()) { if (await UserManager.IsInRoleAsync(user.Id, role.Name)) { users.Add(user); } } ViewBag.Users = users; ViewBag.UserCount = users.Count(); return(View(role)); }
// // GET: /Roles/Details/5 public async Task <ActionResult> Details(string id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } var role = await _roleManager.FindByIdAsync(id); //pega a lista de usuarios nessa role var users = new List <ApplicationUser>(); //pega a lista de usuarios nessa role foreach (var user in _userManager.Users.ToList()) { if (await _userManager.IsInRoleAsync(user.Id, role.Name)) { //adiciona o usuario na lista de aplicationUser junto com as roles por id e o nome users.Add(user); } } ViewBag.Users = users; ViewBag.UserCount = users.Count(); return(View(role)); }
public async Task <ActionResult> Details(string id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } var role = await _roleManager.FindByIdAsync(id); // Get the list of Users in this Role var users = new List <ApplicationUser>(); // Get the list of Users in this Role foreach (var user in _userManager.Users.ToList()) { if (await _userManager.IsInRoleAsync(user.Id, role.Name)) { users.Add(user); } } ViewBag.Users = users; ViewBag.UserCount = users.Count(); return(View(role)); }
public async Task <IHttpActionResult> GetRole(Guid Id) { var role = await _applicationRoleManager.FindByIdAsync(Id); if (role != null) { return(Ok(_identityRoleResponseFactory.Create(role))); } return(NotFound()); }
public async Task <IdentityResult> editrole(RoleViewModel roleModel) { var role = await _rm.FindByIdAsync(roleModel.Id); role.Name = roleModel.Name; // Update the new Description property: //role.Description = roleModel.Description; var result = await _rm.UpdateAsync(role); return(result); }
public override async Task <IdentityRoleDto> GetByIdAsync(object id) { if (!await ExistsAsync(id)) { CustomException.ThrowNotFoundException($"There is no role with id = {id}."); } var role = await _roleManager.FindByIdAsync((string)id); return(_roleModelFactory.GetModel(role)); }
public async Task <KoreRole> GetRoleById(object roleId) { string id = roleId.ToString(); var role = await roleManager.FindByIdAsync(id); return(new KoreRole { Id = role.Id, Name = role.Name }); }
public async Task <IHttpActionResult> GetRole(string id) { var role = roleManager.FindByIdAsync(id); if (role != null) { return(Ok(role)); } return(NotFound()); }
public async Task <ActionResult> GetRole(string id) { var result = await _roleManager.FindByIdAsync(id); if (result == null) { return(NotFound()); } var role = _mapper.MapTo <RoleDto>(result); return(Ok(role)); }
// GET: ApplicationRoles/Details/5 public async Task <ActionResult> Details(string id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } ApplicationRole applicationRole = await RoleManager.FindByIdAsync(id); if (applicationRole == null) { return(HttpNotFound()); } return(View(applicationRole)); }
public async Task <RoleClaimsResponseResult> GetClaimsByRoleId( [FromQuery][Required] string roleId) { ApplicationRole role = await _roleManager.FindByIdAsync(roleId); if (role != null) { var result = await _roleManager.GetClaimsAsync(role); return(new RoleClaimsResponseResult() { Code = 200, Data = (from one in result select new ApplicationRoleClaim() { RoleId = roleId, ClaimType = one.Type, ClaimValue = one.Value }).ToArray() }); } return(new RoleClaimsResponseResult() { Code = 403, Message = "Role does not exists" }); }
public async Task <string> AssignRolesAsync(string username, string rolescsv) { string message = string.Empty; try { string[] roles = rolescsv.Split(','); ApplicationUser user = await userManager.FindByNameAsync(username); List <string> userAssignedRoles = new List <string>(); foreach (ApplicationUserRole aur in user.Roles) { ApplicationRole applicationRole = await roleManager.FindByIdAsync(aur.RoleId); userAssignedRoles.Add(applicationRole.Name); } IdentityResult result = await userManager.RemoveFromRolesAsync(user.Id, userAssignedRoles.ToArray()); result = await userManager.UpdateAsync(user); result = await userManager.AddToRolesAsync(user.Id, roles); result = await userManager.UpdateAsync(user); message = "Success - Role assignment successful"; } catch (Exception ex) { message = string.Format("Error - Role assignment to user {0} unsuccessful, role names {1}", username, rolescsv); throw ex; } return(message); }
public async Task <IActionResult> GetRole(int id) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } ApplicationRole role = await rolemanager.FindByIdAsync(id.ToString()); if (role == null) { return(NotFound()); } return(Ok(role)); }
public async Task <ActionResult> Create(string UserId, string RoleId) { if (ModelState.IsValid) { if (!String.IsNullOrEmpty(RoleId)) { //Find Role Admin var role = await _roleManager.FindByIdAsync(RoleId); var result = await _userManager.AddToRoleAsync(UserId, role.Name); if (!result.Succeeded) { ModelState.AddModelError("", result.Errors.First().ToString()); ViewBag.RoleId = new SelectList(await _roleManager.Roles.ToListAsync(), "Id", "Name"); return(View()); } } return(RedirectToAction("Index")); } else { ViewBag.RoleId = new SelectList(_roleManager.Roles, "Id", "Name"); return(View()); } }
public async Task <ActionResult> Edit(string id) { var role = await _roleManager.FindByIdAsync(id); if (role == null) { return(RedirectToAction("Index")); } var editRole = new EditRoleViewModel { Id = role.Id, Name = role.Name, Description = role.Description }; return(View(editRole)); }
public async Task <IHttpActionResult> ManageUsersInRole(UserInRoleModel userInRoleModel) { IdentityRole identityRole = await ApplicationRoleManager.FindByIdAsync(userInRoleModel.Id); if (identityRole == null) { ModelState.AddModelError("", "Role does not exist"); return(BadRequest(ModelState)); } foreach (string userId in userInRoleModel.EnrolledUsers) { ApplicationUser applicationUser = await ApplicationUserManager.FindByIdAsync(userId); if (applicationUser == null) { ModelState.AddModelError("", $"User by Id: {userId} dous not exist"); continue; } if (!ApplicationUserManager.IsInRole(userId, identityRole.Name)) { IdentityResult identityResult = await ApplicationUserManager.AddToRoleAsync(userId, identityRole.Name); if (!identityResult.Succeeded) { ModelState.AddModelError("", $"User by Id: {userId} could not be added to role"); } } } foreach (string userId in userInRoleModel.RemovedUsers) { ApplicationUser applicationUser = await ApplicationUserManager.FindByIdAsync(userId); if (applicationUser == null) { ModelState.AddModelError("", $"User by Id: {userId} does not exist"); continue; } IdentityResult identityResult = await ApplicationUserManager.RemoveFromRoleAsync(userId, identityRole.Name); if (!identityResult.Succeeded) { ModelState.AddModelError("", $"User by Id: {userId} could not be removed from role"); } } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } return(Ok()); }
public async Task <IHttpActionResult> ManageUsersInRole(UsersInRoleDto 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) == false) { var result = await ApplicationUserManager.AddToRoleAsync(user, role.Name); if (result.Succeeded == false) { 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 <ClaimModel> AddClaimAsync(string roleId, ClaimModel claim) { var roleEntity = await _roleManager.FindByIdAsync(roleId); if (roleEntity == null) { throw new NotFoundException($"Could not locate entity with Id {roleId}"); } var roleClaim = new RoleClaim { RoleId = roleEntity.Id, ClaimValue = claim.ClaimValue, ClaimType = claim.ClaimType }; await _roleClaimRepository.AddAsync(roleClaim); return(_mapper.Map <ClaimModel>(roleClaim)); }
public async Task <IHttpActionResult> GetRole(string id) { IdentityRole identityRole = await ApplicationRoleManager.FindByIdAsync(id); if (identityRole == null) { return(NotFound()); } return(Ok(ModelFactory.Create(identityRole))); }
public async Task <IHttpActionResult> DeleteRoleAsync(string id) { var role = await ApplicationRoleManager.FindByIdAsync(id); if (role == null) { return(NotFound()); } var result = await ApplicationRoleManager.DeleteAsync(role); return(result.Succeeded ? Ok() : GetErrorResult(result)); }
public async Task <object> DeleteRole(Guid roleId) { ResponseMessageModel message; var role = await _roleManager.FindByIdAsync(roleId.ToString()); if (role == null) { message = new ResponseMessageModel { Code = MessageCode.OBJECT_NOT_FOUND }; return(message); } var result = await _roleManager.DeleteAsync(role); if (result.Succeeded) { message = new ResponseMessageModel { Code = MessageCode.SUCCESS, }; return(message); } //error occurs string errorMessage = ""; foreach (var error in result.Errors) { errorMessage += error.Description + "\r\n"; } message = new ResponseMessageModel { Code = MessageCode.SQL_ACTION_ERROR, ErrorMessage = errorMessage }; return(message); }
public async Task <IdentityResult> CreateOrUpdateAsync(RoleViewModel model) { if (model.Id == 0) { var applicationRole = Mapper.Map <ApplicationRole>(model); applicationRole.Id = 1; var result = await _applicationRoleManager.CreateAsync(applicationRole); model.Id = applicationRole.Id; return(result); } var role = _applicationRoleManager.FindByIdAsync(model.Id).Result; if (role == null) { return(IdentityResult.Failed()); } MapApplicationRole(role, model); var updateResult = await _applicationRoleManager.UpdateAsync(role); return(updateResult); }
public async Task<IdentityResult> UpdateRole(JObject newRole) { string roleName = ((dynamic)newRole).Name.Value; string roleId = ((dynamic)newRole).Id.Value; IdentityResult result = null; var roleStore = new RoleStore<IdentityRole>(_contextProvider.Context); var roleManager = new ApplicationRoleManager(roleStore); var role = await roleManager.FindByIdAsync(roleId); if (role != null) { role.Name = roleName; result = await roleManager.UpdateAsync(role); } return result; }
public async Task <ActionResult> Delete(string id) { var role = await _roleManager.FindByIdAsync(id); if (role == null) { return(NotFound()); } var result = await _roleManager.DeleteAsync(role); if (result.Succeeded) { return(NoContent()); } return(BadRequest()); }
public async Task <IHttpActionResult> DeleteRole(string id) { IdentityRole identityRole = await ApplicationRoleManager.FindByIdAsync(id); if (identityRole == null) { NotFound(); } IdentityResult identityResult = await ApplicationRoleManager.DeleteAsync(identityRole); if (!identityResult.Succeeded) { return(GetErrorResult(identityResult)); } return(Ok()); }
public async Task <ActionResult> EditRoleUser(string id) { ApplicationRoleManager RoleManager = HttpContext.GetOwinContext().Get <ApplicationRoleManager>(); ApplicationRole role = await RoleManager.FindByIdAsync(id); string[] memberIDs = role.Users.Select(x => x.UserId).ToArray(); IEnumerable <ApplicationUser> members = UserManager.Users.Where(x => memberIDs.Any(y => y == x.Id)); IEnumerable <ApplicationUser> nonMembers = UserManager.Users.Except(members); return(View(new RoleEditViewModel { Role = role, Members = members, NonMembers = nonMembers })); }
public async Task <IActionResult> Roles() { var failures = new List <string>(); TimeZoneInfo pst = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time"); DateTime longAgo = new DateTime(1800, 1, 1); var legacyRoles = await legacyDb.Roles.ToArrayAsync(); foreach (var role in legacyRoles) { await roleManager.CreateAsync(new ApplicationRole { Id = role.Id, Name = role.Name, Description = role.Description }); } var roleRoles = legacyDb.RoleRoles.OrderBy(f => f.RoleRow_Id).ToArray(); ApplicationRole child = new ApplicationRole(); foreach (var row in roleRoles) { if (child == null || row.RoleRow_Id != child.Id) { if (child != null) { await roleManager.UpdateAsync(child); } child = await roleManager.FindByIdAsync(row.RoleRow_Id); } child.Ancestors.Add(new RoleRoleMembership { ParentId = row.RoleRow_Id1, Child = child, IsDirect = true }); } // await roleManager.RebuildInheritance(); return(Content("Done\n\n" + string.Join("\n", failures))); }
public async Task <IdentityRole> FindByIdAsync(string roleId) { return(await _appRoleManager.FindByIdAsync(roleId)); }
public async Task <bool> Crear(UserRolesUnidadCategoria usuario) { VerificarExistenciaJefaturas(usuario); try { var role = await _roleManager.FindByIdAsync(usuario.SelectedRoleId); var contrasenaTemporal = Membership.GeneratePassword(15, 2); var newUser = new ApplicationUser() { Id = usuario.Id, Nombre = usuario.Nombre, PrimerApellido = usuario.PrimerApellido, SegundoApellido = usuario.SegundoApellido, Email = usuario.Email, PhoneNumber = usuario.PhoneNumber, UserName = usuario.Email, FechaIngreso = usuario.FechaIngreso, FechaCreacion = DateTime.Now, UnidadTecnicaId = Convert.ToInt32(usuario.SelectedUnidadTecnicaId), CategoriaId = Convert.ToInt32(usuario.SelectedCategoriaId), EstaActivo = true, EsContrasenaTemporal = true, FotoRuta = usuario.Foto != null ? usuario.Foto.FileName : null, SaldoDiasEmpleado = new SaldoDiasPorEmpleado() { Cedula = usuario.Id, SaldoDiasDisponibles = 0, UltimaActualizacion = DateTime.Now } }; var result = await _userManager.CreateAsync(newUser, contrasenaTemporal); if (result.Succeeded) { var userSaved = await _userManager.FindByEmailAsync(usuario.Email); await _userManager.AddToRoleAsync(userSaved.Id.ToString(), role.Name); if (usuario.EsSuperusuario) { await _userManager.AddToRoleAsync(userSaved.Id.ToString(), "Manager"); } // Guardar foto de usuario, en caso que se haya seleccionado alguna GuardarFoto(usuario.Foto); // Envio contrasena temporal al correo del usuario try { await _userManager.SendEmailAsync(userSaved.Id, "ContraseƱa Temporal", $"Su contraseƱa temporal para el sistema de solicitud de vacaciones es: <strong>{ contrasenaTemporal }</strong>"); } catch (Exception ex) { Console.WriteLine(ex); throw; } return(true); } return(false); } catch (Exception ex) { return(false); } }
public async Task<IdentityResult> SaveChanges(JObject newRole) { string roleName = ((dynamic)newRole).Name.Value; string roleId = ((dynamic)newRole).Id.Value; //dynamic oldRole = ((dynamic)newRole).oldRole.Value; IdentityResult result = null; var roleStore = new RoleStore<IdentityRole>(_contextProvider.Context); var roleManager = new ApplicationRoleManager(roleStore); var role = await roleManager.FindByIdAsync(roleId); if (role == null) { result = await roleManager.CreateAsync(new IdentityRole(roleName)); } return result; }
public Task <IdentityRole> GetRole(Guid id) { return(_applicationRoleManager.FindByIdAsync(id.ToString())); }