public IActionResult UpdateUser(int id, UserUpdateDto info) { //authorization if (!Int32.TryParse(User.FindFirst("userId").Value, out int userId)) { return(Unauthorized()); } ; if (userId != id) { return(Forbid()); } //info id validation if (id != info.Id) { return(BadRequest("Id not match.")); } try { var user = userManager.UpdateUser(info); return(Ok(user)); } catch (CustomDbException e) { return(BadRequest(e.Message)); } }
public IActionResult UpdateUserInfo(int id, [FromBody] UserUpdateDto model) { var currentUser = int.Parse(User.Identity.Name); if (id != currentUser) { return(Forbid()); } // map model to entity and set id var user = _mapper.Map <User>(model); user.Id = id; try { // update user _userService.UpdateUser(user, model.Password); return(Ok()); } catch (AppException ex) { // return error message if there was an exception return(BadRequest(new { message = ex.Message })); } }
public async Task <string> CreateToken(UserUpdateDto userUpdateDto) { var user = _mapper.Map <User>(userUpdateDto); var claims = new List <Claim> { new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()), new Claim(ClaimTypes.Name, user.UserName) }; var roles = await _userManager.GetRolesAsync(user); claims.AddRange(roles.Select(role => new Claim(ClaimTypes.Role, role))); var creds = new SigningCredentials(_key, SecurityAlgorithms.HmacSha512Signature); var tokenDescription = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(claims), Expires = DateTime.Now.AddDays(1), SigningCredentials = creds }; var tokenHandler = new JwtSecurityTokenHandler(); var token = tokenHandler.CreateToken(tokenDescription); return(tokenHandler.WriteToken(token)); }
public async Task UpdateUser_Returns403ForbiddenStatusResultWhenUserNotOwner() { // Arrange var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, "joggeruser"), new Claim(ClaimTypes.Role, "Jogger") })); _controller.ControllerContext = new ControllerContext(); _controller.ControllerContext.HttpContext = new DefaultHttpContext { User = user }; _controller.ControllerContext.HttpContext.Items.Add("user", new User { Id = 2000, UserName = "******" }); var userUpdateDto = new UserUpdateDto { FirstName = "admin user firstName", LastName = "admin user lastName", UserName = "******", Email = "*****@*****.**", PhoneNumber = "333333333" }; // Act var result = await _controller.UpdateUser(2000, userUpdateDto) as StatusCodeResult; //Assert Assert.Equal(403, result.StatusCode); }
public async Task <IActionResult> Update(UserUpdateDto model) { model.Id = User.GetUserId(); return(View( await _userService.Update(model) )); }
public IActionResult UserUpdate(int id, [FromBody] UserUpdateDto updateUser) { var userEntity = _transActionRepo.GetUser(id); if (userEntity == null) { return(NotFound()); } if (updateUser == null) { return(NotFound()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } Mapper.Map(updateUser, userEntity); if (!_transActionRepo.Save()) { return(StatusCode(500, "A problem happened while handling your request.")); } return(NoContent()); }
public async Task <IActionResult> UpdateUser(int id, UserUpdateDto editedUser) { var user = await Repository.FindAsync <USER>(id); await BaseService.UpdateAsync <USER, UserUpdateDto>(id, editedUser); await _userService.SaveUserRoles(id, editedUser.RoleIds); if (!string.IsNullOrEmpty(editedUser.NewPassword)) { var token = await _userManager.GeneratePasswordResetTokenAsync(user); var result = await _userManager.ResetPasswordAsync(user, token, editedUser.NewPassword); if (!result.Succeeded) { return(BadRequest(string.Join(".", result.Errors.Select(x => x.Description)))); } else { // Must log manually if not using BaseService Logger.Log(Microsoft.Extensions.Logging.LogLevel.Information, default(EventId), string.Format("User {0} has changed password for user {1}", UserIdentity.Username, user.ToString()), null, ExtraPropertyLogger.Formatter); } } return(Ok(true)); }
public static void Run() { try { //add tran var tranSet = MySqlDb.GetInstance().TransactionSet; var tran = new Transaction() { BuyerID = 1, SellerID = 2, Amount = 100 }; tranSet.Add(tran); var msg1 = new UserUpdateDto() { Type = 1, UserID = tran.SellerID, Amount = tran.Amount }; var msg2 = new UserUpdateDto() { Type = 2, UserID = tran.BuyerID, Amount = tran.Amount }; Rbmq.PublishMsg(obj: msg1); Rbmq.PublishMsg(obj: msg2); MySqlDb.GetInstance().SaveChanges(); } catch (Exception ex) { Console.WriteLine(""); } }
public async Task <ActionResult> UpdateUser(UserUpdateDto user) { if (user == null) { return(BadRequest()); } var currentUserClaim = HttpContext.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.PrimarySid); if (currentUserClaim == null) { return(BadRequest()); } var result = await _service.UpdateUserInfo(currentUserClaim.Value, user); if (result == null) { return(Ok()); } var state = new ModelStateDictionary(); foreach (var(key, value) in result) { state.AddModelError(key, value); } return(ValidationProblem(new ValidationProblemDetails(state))); }
public async Task UpdateUser() { var iUserServiceMock = new Mock <IUserService>(); var name = Faker.Name.FullName(); var email = Faker.Internet.Email(); iUserServiceMock.Setup(m => m.Put(It.IsAny <UserUpdateDto>())).ReturnsAsync( new UserDto { Id = Guid.NewGuid(), Name = name, Email = email, UpdatedAt = DateTime.UtcNow } ); _controller = new UsersController(iUserServiceMock.Object); var userUpdateDto = new UserUpdateDto { Id = Guid.NewGuid(), Name = name, Email = email }; var result = await _controller.Put(userUpdateDto); Assert.True(result is OkObjectResult); var resultValue = ((OkObjectResult)result).Value as UserDto; Assert.NotNull(resultValue); Assert.Equal(email, resultValue.Email); Assert.Equal(name, resultValue.Name); }
public async Task UpdateUserBadRequest() { var iUserServiceMock = new Mock <IUserService>(); var name = Faker.Name.FullName(); var email = Faker.Internet.Email(); iUserServiceMock.Setup(m => m.Put(It.IsAny <UserUpdateDto>())).ReturnsAsync( new UserDto { Id = Guid.NewGuid(), Name = name, Email = email, UpdatedAt = DateTime.UtcNow } ); _controller = new UsersController(iUserServiceMock.Object); _controller.ModelState.AddModelError("Name", "is required"); var userUpdateDto = new UserUpdateDto { Id = Guid.NewGuid(), Name = name, Email = email }; var result = await _controller.Put(userUpdateDto); Assert.True(result is BadRequestObjectResult); }
/// <summary> /// Update the user. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='body'> /// The user. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <UserDto> UpdateUserAsync(this IUser operations, UserUpdateDto body = default(UserUpdateDto), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.UpdateUserWithHttpMessagesAsync(body, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public IActionResult UpdateUser(int id, [FromBody] UserUpdateDto userDto) { if (userDto == null || !ModelState.IsValid) { return(BadRequest()); } try { var user = _userService.UpdateUser(id, userDto); if (user != null) { return(Ok(user)); } _logger.LogInformation($"User with id {id} was not found."); return(NotFound()); } catch (Exception ex) { _logger.LogCritical($"Exception while getting user with id {id}", ex); return(StatusCode(500, "A problem happened while handling your request.")); } }
public async Task <UserDto> UpdateUserAsync(int userId, UserUpdateDto userUpdateDto) { try { var user = await _userRepository.FindAsync(userId); if (user == null) { throw new Exception($"user not found for userId = {userId}"); } user = userUpdateDto.UserUpdateDtoToUser(user, userId); var user2 = await _userRepository.UpdateAsync(user); throw new Exception("sddddf"); return(user2.UserToUserDtoForResultUpdate()); } catch (Exception ex) { //Log Error ex.message; throw ex;; } }
public async Task <UserDto> UpdateAsync(UserUpdateDto user) { var userToUpdate = await userRepository.GetOrDefaultAsync(user.Id); if (userToUpdate == null) { throw new NotFoundException("No user found with this id"); } //checking whether user is request for update the name if (userToUpdate.Name != user.Name) { var isRequestUserNameExist = userRepository.GetAsQueryable() .Where(u => u.Name == user.Name) .Any(); if (isRequestUserNameExist) { throw new BadRequestException("A user already exist with this username"); } } userToUpdate.Type = user.Type; userToUpdate.Name = user.Name; userToUpdate.LastModifedDate = DateTime.Now; var updatedUser = await userRepository.UpdateAsync(userToUpdate); var userDto = mapper.Map <UserDto>(updatedUser); return(userDto); }
public async Task <IActionResult> UpdateUser(int id, [FromBody] UserUpdateDto userUpdateDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } //get current user var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); //get user from repo var user = await this._connectRepository.GetUser(id); if (user == null) { return(NotFound($"could not find user with an id of {id}")); } if (currentUserId != user.Id) { return(Unauthorized()); } this._mapper.Map(userUpdateDto, user); if (await this._connectRepository.SaveAll()) { return(NoContent()); } throw new Exception($"Upating user {id} failed on save"); }
public ActionResult UpdateUser(int id, UserUpdateDto userUpdateDto) { var user = _repository.GetUserById(id); if (user == null) { return(NotFound()); } if (!HttpContext.Items["User"].Equals(user)) { return(Unauthorized()); } userUpdateDto.Username = Regex.Replace(userUpdateDto.Username, @" ", ""); _mapper.Map(userUpdateDto, user); try { _repository.UpdateUser(user); } catch (DuplicateUserException e) { var message = e.Message; return(BadRequest(new { message = $"{message} is already in use." })); } _repository.SaveChanges(); return(NoContent()); }
public async Task <ServiceResponse <UserGetDto> > UpdateUser(UserUpdateDto updatedUser) { ServiceResponse <UserGetDto> serviceResponse = new ServiceResponse <UserGetDto>(); try{ User user = await _context.Users.FirstOrDefaultAsync(u => u.id == updatedUser.id); user.fName = updatedUser.fName; user.lName = updatedUser.lName; user.email = updatedUser.email; _authRepo.CreatePasswordHash(updatedUser.password, out byte[] passwordHash, out byte[] passwordSalt); user.passwordHash = passwordHash; user.passwordSalt = passwordSalt; user.typeid = updatedUser.type; // user.type = await _context.UserTypes.FirstOrDefaultAsync(u => u.id == updatedUser.type); _context.Users.Update(user); await _context.SaveChangesAsync(); serviceResponse.Data = _mapper.Map <UserGetDto>(user); } catch (Exception ex) { serviceResponse.Success = false; serviceResponse.Message = ex.Message; } return(serviceResponse); }
public async Task <ActionResult <UserGetDto> > UpdateIgnorePassword([FromServices] IUserRepository userRepository, [FromServices] IUnitOfWork unitOfWork, [FromBody] UserUpdateDto model) { try { var user = await userRepository.GetEntityById(model.Id.Value); if (user == null) { return(BadRequest("Usuário não encontrado.")); } var userGetDto = await userRepository.Update(model); if (await unitOfWork.Commit()) { return(userGetDto); } else { return(BadRequest()); } } catch (Exception ex) { return(BadRequest($"Erro: {ex.Message}")); } }
public async Task <IActionResult> UpdateUser(string userId, [FromBody] UserUpdateDto userDto) { if (userDto == null) { return(BadRequest()); } var currentUserId = this.User.GetUserId(); if (userId != currentUserId) { return(NotFound(new { message = $"User {userId} not allowed to modify {currentUserId}." })); } var userExist = await _userService.UserExist(userId); if (!userExist) { return(NotFound(new { message = $"User {userId} not found" })); } var user = _mapper.Map <UserUpdateDto, User>(userDto); user.Id = currentUserId; var success = await _userService.UpdateUser(user); if (!success) { throw new Exception("Failed to update the user"); } // In case no additional information is changed at serverside (like timestamp), don't return the updated object return(Ok(new { message = "User successfully updated" })); }
public async Task UpdateUser_ReturnsNoContentObjectResultOnSuccess() { // Arrange var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, "adminuser"), new Claim(ClaimTypes.Role, "Admin") })); _controller.ControllerContext = new ControllerContext(); _controller.ControllerContext.HttpContext = new DefaultHttpContext { User = user }; _controller.ControllerContext.HttpContext.Items.Add("user", new User { Id = 2000, UserName = "******" }); var userUpdateDto = new UserUpdateDto { FirstName = "admin user firstName", LastName = "admin user lastName", UserName = "******", Email = "*****@*****.**", PhoneNumber = "333333333" }; // Act var result = await _controller.UpdateUser(2000, userUpdateDto); //Assert Assert.IsType <NoContentResult>(result); }
public async Task <ActionResult <UserDto> > Put(Guid id, [FromBody] UserUpdateDto userDto) { var existingUser = service.GetUser(id); if (existingUser == null) { return(NotFound()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } Mapper.Map(userDto, existingUser); var updatedUser = await service.UpdateUserAsync(existingUser); if (updatedUser == null) { throw new Exception("Something went wrong updating the user."); } return(updatedUser); }
public async Task <ActionResult> PartialUpdateUser(int userId, JsonPatchDocument <UserUpdateDto> patchDocument) { var userEntity = await _userRepository.FindAsync(userId); if (userEntity == null) { var userDto = new UserUpdateDto(); patchDocument.ApplyTo(userDto, ModelState); if (!TryValidateModel(userDto)) { return(ValidationProblem(ModelState)); } var userToAdd = _mapper.Map <Users>(userDto); userToAdd.Id = userId; await _userRepository.InsertAsync(userToAdd); var toReturnDto = _mapper.Map <UserDto>(userToAdd); return(CreatedAtRoute(nameof(GetUser), new { userId = userToAdd.Id }, toReturnDto)); } var dtoToPatch = _mapper.Map <UserUpdateDto>(userEntity); patchDocument.ApplyTo(dtoToPatch, ModelState); if (!TryValidateModel(dtoToPatch)) { return(ValidationProblem(ModelState)); } _mapper.Map(dtoToPatch, userEntity); await _userRepository.UpdateAsync(userEntity); return(NoContent()); }
public async Task <IActionResult> PutUserWithSkills(string userId, UserUpdateDto user) { // Create response object CommonResponse <UserUpdateDto> respons = new CommonResponse <UserUpdateDto>(); User userModel = await _context.Users.Include(s => s.Skills).FirstOrDefaultAsync(u => u.UserId == userId); if (userId != user.UserId) { respons.Error = new Error { Status = 400, Message = "There was a mismatch with the provided id and the object." }; return(BadRequest(respons)); } userModel.Description = user.Description; userModel.ImageUrl = user.ImageUrl; userModel.Hidden = user.Hidden; foreach (SkillCreateDto skillName in user.Skills) { Skill skill = await _context.Skills.Where(s => s.Name == skillName.Name).FirstOrDefaultAsync(); if (skill == null) { skill = _mapper.Map <Skill>(skillName); userModel.Skills.Add(skill); } userModel.Skills.Add(skill); } // Save changes to commit to db await _context.SaveChangesAsync(); return(NoContent()); }
public async Task <ActionResult <UserDto> > UpdateUser(string username, UserUpdateDto user) { if (!await _userRepository.UserExistsAsync(user.UserName, user.OldPassword)) { return(NotFound()); } var userEntity = await _userRepository.GetUserAsync(user.UserName); if (userEntity == null) { var userToAddEntity = _mapper.Map <User>(user); userToAddEntity.UserName = user.UserName; _userRepository.AddUser(userToAddEntity); await _userRepository.SaveAsync(); var dtoToReturn = _mapper.Map <UserDto>(userToAddEntity); return(CreatedAtRoute(nameof(GetUser), new { username = dtoToReturn.UserName }, dtoToReturn)); } _mapper.Map(user, userEntity); _userRepository.UpdateUser(userEntity); await _userRepository.SaveAsync(); return(NoContent()); }
public async Task <ActionResult> Put(int id, UserUpdateDto dto) { User model = null; try { model = await _repo.GetUserById(id); if (model == null) { return(NotFound()); } _mapper.Map(dto, model); _repo.UpdateUser(model); await _repo.SaveChanges(); _logger.LogInformation($"User,name:{model.Name} updated"); return(NoContent()); } catch (Exception ex) { _logger.LogError(ex, $"user:{model?.Name} update operation cause exception"); throw ex; } }
public async Task <IActionResult> UpdateUser(int id, UserUpdateDto userModel) { try { if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } var dbUser = await _datingrepo.GetUser(id); _mapper.Map(userModel, dbUser); if (await _datingrepo.SaveAll()) { return(NoContent()); } throw new Exception($"Error updating user {userModel.UserID} !"); } catch (Exception ex) { throw new Exception($"Error updating user {userModel.UserID} !"); } }
public IActionResult UpdateUser([FromRoute] Guid userId, [FromBody] UserUpdateDto user) { if (userId.Equals(Guid.Empty) || user == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(UnprocessableEntity(ModelState)); } user.Id = userId; var userEntity = mapper.Map <UserEntity>(user); userRepository.UpdateOrInsert(userEntity, out var isInserted); if (isInserted) { return(CreatedAtRoute(nameof(UpdateUser), new { userId = userEntity.Id }, userEntity.Id)); } return(NoContent()); }
public async Task <ApiResponse> updateUser([FromBody] UserUpdateDto dto) { try { //create if (dto.Id == Guid.Empty) { return(new ApiResponse("Không tìm thấy Id: ", dto.Id, 400)); } var user = await _userService.GetByIdAsync(dto.Id); if (user == null) { return(new ApiResponse("User không tồn tại", user, 404)); } user.UpdatedDate = DateTime.Now; var userDto = _mapper.Map(dto, user); await _userService.UpdateAsync(userDto); var userViewModel = _mapper.Map <UserViewModel>(userDto); return(new ApiResponse("Update date user success: ", userViewModel, 201)); }catch (Exception ex) { return(new ApiResponse($"{ex}", ex, 200)); } }
public async Task Update(UserUpdateDto request) { var user = await GetById(request.Id); if (user == null) { throw new NotFoundException(); } user.Account = request.Account; user.Sex = request.Sex; user.Phone = request.Phone; user.Name = request.Name; user.Email = request.Email; user.Deptid = request.Deptid; user.Birthday = request.Birthday; user.Status = request.Status; user.Version = user.Version + 1 ?? 1; user.ModifyBy = request.ModifyBy; user.ModifyTime = DateTime.Now; _unitOfWork.UserRepository.Update(user); _unitOfWork.Commit(); _cacheManager.Remove(GetUserCacheKey(user.Id)); }