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));
}
