public override async Task <Empty> UpdateUserRole(UpdateUserRoleRequest request, ServerCallContext context) { var updateUserRoleCommand = _mapper.Map <UpdateUserRoleCommand>(request); var response = await _mediator.Send(updateUserRoleCommand); return(new Empty()); }
public IActionResult UpdateUserRoles([FromBody] UpdateUserRoleRequest updateUserRoleRequest) { if (updateUserRoleRequest == null || string.IsNullOrWhiteSpace(updateUserRoleRequest.Login) || updateUserRoleRequest.RoleIds == null) { return(HandleBadRequest("A valid login name and a (potentially empty) list of user roles need to be supplied.")); } List <Role> roles = new List <Role>(); try { foreach (int roleId in updateUserRoleRequest.RoleIds) { roles.Add((Role)roleId); } } catch { return(HandleBadRequest("One or more of the supplied IDs is not a valid Sartre role ID.")); } UserService.UpdateUserRoles(updateUserRoleRequest.Login, roles); return(Ok()); }
public async Task <IActionResult> UpdateUserRole([FromBody] UpdateUserRoleRequest model) { bool isExist = !string.IsNullOrEmpty(model.Email); IdentityResult Result; string roleName = string.Empty; if (ModelState.IsValid) { ApplicationUser applicationUser = await _userManager.FindByEmailAsync(model.Email); var UserRole = await _userManager.GetRolesAsync(applicationUser); if (UserRole != null) { Result = await _roleservice.RemoveFromRoleAsync(applicationUser, model.Old_ApplicationRoleName); string RoleName = applicationUser.Name; Result = await _roleservice.AddToRoleAsync(applicationUser, model.New_ApplicationRoleName); if (Result.Succeeded) { return(Ok(" SuccessFully Updated UserRole In AspNetUserRole table...." + model.Email)); } } Result = await _roleservice.AddToRoleAsync(applicationUser, model.Old_ApplicationRoleName); } return(Ok($"Faild to Update Role {roleName} for user " + model.Email)); }
public async Task <IActionResult> RemoveRoles( int id, [FromBody] UpdateUserRoleRequest request) { if (await appsService.IsRequestValidOnThisLicense( request.AppId, request.License, request.RequestorId)) { var result = await usersService.RemoveUserRoles( id, request.RoleIds.ToList(), request.License); if (result.Success) { result.Message = ControllerMessages.StatusCode200(result.Message); return(Ok(result)); } else { result.Message = ControllerMessages.StatusCode404(result.Message); return(NotFound(result)); } } else { return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage)); } }
public async Task <IActionResult> UpdateUserRole(int roleId, [FromBody] UpdateUserRoleRequest request) { var updateUserRoleCommand = new UpdateUserRoleCommand(roleId, request); var result = await mediator.Send(updateUserRoleCommand); return(StatusCode((int)result.Code, result.Value)); }
public async Task <UpdateUserRoleResponse> UpdateUserRole(UpdateUserRoleRequest o) { var result = new UpdateUserRoleResponse(o.RequestId); result.Application = o.Application; result.Updated = await Server.UpdateUserRole(o.Id, o.Name, o.Description); return(result); }
public async Task UpdateUserRole(UpdateUserRoleRequest request) { User user = await _unitOfWork.Users.All() .FirstOrDefaultAsync(w => w.Email == request.Email); if (user == null) { throw new NotFoundException(); } user.Role = request.Role; _unitOfWork.Users.Update(user); await _unitOfWork.SaveAsync(); }
public async Task Setup() { context = await TestDatabase.GetDatabaseContext(); mockUsersService = new MockUsersService(context); mockAppsService = new MockAppsService(context); mockWebHostEnvironment = new Mock <IWebHostEnvironment>(); baseRequest = new BaseRequest(); updateUserRequest = new UpdateUserRequest() { UserName = "******", FirstName = "FirstName", LastName = "LastName", NickName = "MyNickname", Email = "*****@*****.**", License = TestObjects.GetLicense(), RequestorId = 1, Paginator = new Paginator() }; updatePasswordRequest = new UpdatePasswordRequest() { UserId = 1, NewPassword = "******" }; updateUserRoleRequest = new UpdateUserRoleRequest() { RoleIds = new List <int>() { 3 }, License = TestObjects.GetLicense(), RequestorId = 1, Paginator = new Paginator() }; sutSuccess = new UsersController( mockUsersService.UsersServiceSuccessfulRequest.Object, mockAppsService.AppsServiceSuccessfulRequest.Object, mockWebHostEnvironment.Object); sutFailure = new UsersController( mockUsersService.UsersServiceFailedRequest.Object, mockAppsService.AppsServiceSuccessfulRequest.Object, mockWebHostEnvironment.Object); }
public async Task <UserWithRoleDto> UpdateUserRoleAsync(UpdateUserRoleRequest request) { this.userValidationService.ValidateUpdateUserRole(); var role = await Context.Roles.FirstAsync(x => x.Id == request.RoleId); var user = await GetByIdAsync(request.UserId); user.Role = role; user.RoleId = role.Id; await SaveChanges(); return(Mapper.Map <User, UserWithRoleDto>(user)); }
public async Task <IActionResult> Put([FromRoute] Request meta, [FromBody] UpdateUserRoleRequest request) { IActionResult result = null; var updated = await Server.UpdateUserRole(request.Id, request.Name, request.Description); if (updated) { result = Factory.CreateSuccessResponse(updated); } else { result = Factory.CreateNoContentResponse(); } return(result); }
public IHttpActionResult UpdateUserRole(UpdateUserRoleRequest request) { Responce <bool> responce = new Responce <bool>(); try { responce = _accountService.UpdateUserRole(request); return(Ok(responce)); } catch (Exception ex) { responce.Success = false; responce.Message = $"ERROR UpdateUserRole : {ex.InnerException}"; responce.ResponeContent = false; return(Content(HttpStatusCode.BadRequest, responce)); } }
public async Task <IActionResult> UpdateRole([FromRoute] int userId, [FromBody] UpdateUserRoleRequest request) { var user = await _userService.GetUserByIdAsync(userId); if (user == null) { return(NotFound()); } User updatedUser = _mapper.Map(request, user); bool successfullyUpdated = await _userService.UpdateUserAsync(updatedUser); if (!successfullyUpdated) { return(BadRequest(new ErrorResponse("There was a problem during role update"))); } return(Ok()); }
public async Task <bool> UpdateUserRole(string UserId, string RoleId) { try { UpdateUserRoleRequest updateUserRoleRequest = new UpdateUserRoleRequest(); updateUserRoleRequest.Email = ""; updateUserRoleRequest.UserId = UserId; updateUserRoleRequest.RoleId = RoleId; string Json = JsonConvert.SerializeObject(updateUserRoleRequest); var result = await restapiHelper.PosyAsync <Responce <bool> >(EndPoint.Account.UpdateUserRole, Json); return(result.ResponeContent); } catch (Exception ex) { return(false); } }
public Responce <bool> UpdateUserRole(UpdateUserRoleRequest request) { Responce <bool> responce = new Responce <bool>(); responce.Success = true; try { responce.Success = true; using (SSCEntities db = new SSCEntities()) { db.UpdateUserRole(request.RoleId, request.UserId); responce.ResponeContent = true; } } catch (Exception ex) { responce.Success = false; responce.Message = $"ERROR UpdateUserRole : {ex.InnerException}"; responce.ResponeContent = false; } return(responce); }
public async Task RemoveRolesFromUsers() { // Arrange var userId = 1; var user = context.Users .Include(u => u.Roles) .FirstOrDefault(u => u.Id == userId); var updateUserRoleRequest = new UpdateUserRoleRequest(); updateUserRoleRequest.RoleIds.Add(3); var license = TestObjects.GetLicense(); // Act var result = await sut.RemoveUserRoles( userId, updateUserRoleRequest.RoleIds, license); // Assert Assert.That(result.Success, Is.True); Assert.That(result.Message, Is.EqualTo("Roles Removed")); }
public async Task <HttpResponseMessage> UpdateUserRole([FromBody] UpdateUserRoleRequest request) { await _userService.UpdateUserRole(request); return(new HttpResponseMessage(HttpStatusCode.OK)); }
public async Task <UserWithRoleDto> UpdateUserRole([FromBody] UpdateUserRoleRequest updateUserRoleRequest) { return(await this.userService.UpdateUserRoleAsync(updateUserRoleRequest)); }
public async Task <IActionResult> UpdateUserRole([FromRoute] string id, [FromBody] UpdateUserRoleRequest request) { await _userService.UpdateUserRoleAsync(id, request.Role); return(Ok()); // }