public async Task <IActionResult> Update(int id, [FromBody] UserUpdateDTO userToUpdate)
{
var validator = new UserUpdateDTOValidator();
var results = await validator.ValidateAsync(userToUpdate);
results.AddToModelState(ModelState, "UserUpdateDTO");
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
if (id != userToUpdate.Id)
{
return(BadRequest());
}
User oldUser = await this._userService.GetByEmail(userToUpdate.Email);
if (oldUser == null)
{
return(BadRequest("No corresponding user !"));
}
UserDTO user = await _userService.Update(userToUpdate);
return(Ok(user));
}
public async Task <UserDTO> UpdateUser(UserUpdateDTO userDto)
{
var userToUpdate = await _userRepo.GetAsync(userDto.DodId);
var currentUserDodId = GetCurrentUserId();
if (userToUpdate == null)
{
throw new ArgumentException("User account does not exist");
}
var oldUser = new User(userToUpdate);
_domainMapper.GetMapper <UserUpdateDTO, User>(userDto, userToUpdate).Map();
if (currentUserDodId == userToUpdate.DodId)
{
_userDomainService.UpdateUser(userToUpdate, oldUser);
}
else
{
await _userDomainService.AdminUpdateUser(currentUserDodId, userToUpdate, oldUser);
}
await _userRepo.SaveAsync();
return(_autoMapper.Map <UserDTO>(userToUpdate));
}
public async Task <ActionResult> Put([FromBody] UserUpdateDTO user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _userService.Put(user);
if (result != null)
{
return(Ok(result));
}
else
{
return(BadRequest());
}
}
catch (ArgumentException e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task <IActionResult> UpdateUsersAsync([FromRoute] int id, [FromBody] UserUpdateDTO UserModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var users = await uow.User.GetUserByIdT(id);
if (users != null)
{
users.firstname = UserModel.Firstname;
users.surname = UserModel.Surname;
users.state = UserModel.State;
users.gender = UserModel.Gender;
users.age = UserModel.Age;
users.updated_at = DateTime.Now;
users.email = UserModel.Email;
users.username = UserModel.Username;
users.country = UserModel.Country;
uow.User.Update(users);
await uow.save();
return(Ok(new { success = true, message = "Profile Data Updated Successfully" }));
}
return(Ok(new { success = false, Message = "Failed to update" }));
}
catch (Exception ex)
{
return(Ok(ex.Message));
}
}
public IHttpActionResult Update(UserUpdateDTO userDTO)
{
if (ModelState.IsValid)
{
try
{
var user = userService.GetByUsername(userDTO.Username);
if (user == null)
{
return(NotFound());
}
user.Firstname = userDTO.Firstname;
user.Lastname = userDTO.Lastname;
user.Age = userDTO.Age;
user.City = userDTO.City;
user.Country = userDTO.Country;
user.Address = userDTO.Address;
user.AboutMe = userDTO.AboutMe;
userService.Update(user);
return(Ok("User succesfully updated."));
}
catch (Exception ex)
{
return(BadRequest("Something went wrong."));
}
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <ActionResult> Edit([FromBody] UserUpdateDTO userDTO)
{
try
{
if (!ModelState.IsValid)
{
return(UnprocessableEntity(ModelState));
}
User user = await _userManager.FindByIdAsync(userDTO.Id.ToString());
CurrentUser currentUser = new CurrentUser(this.User);
if (user == null || currentUser.Id != user.Id)
{
return(NotFound());
}
user = _userAppService.UpdateEntity(currentUser, user, userDTO);
if (user != null)
{
await _userManager.UpdateAsync(user);
return(Ok(new ObjectResult(userDTO)));
}
return(UnprocessableEntity(user));
}
catch (Exception)
{
throw;
}
}
public async Task E_Possivel_Invocar_a_Controller_Update()
{
var serviceMock = new Mock <IUserService>();
var nome = Faker.Name.FullName();
var email = Faker.Internet.Email();
serviceMock.Setup(m => m.Put(It.IsAny <UserUpdateDTO>())).ReturnsAsync(
new UserUpdateResultDTO
{
Id = Guid.NewGuid(),
Name = nome,
Email = email,
UpdateAt = DateTime.UtcNow
}
);
_controller = new UsersController(serviceMock.Object);
_controller.ModelState.AddModelError("Email", "É um campo obrigatorio");
var userDtoUpdate = new UserUpdateDTO
{
Id = Guid.NewGuid(),
Name = nome,
Email = email,
};
var result = await _controller.Put(userDtoUpdate);
Assert.True(result is BadRequestObjectResult);
Assert.False(_controller.ModelState.IsValid);
}
public ValidateUserDTO Update(UserUpdateDTO user)
{
var result = new ValidateUserDTO()
{
};
if (this.userRepository.Exists(user.Login, user.Id))
{
var errors = new List <string>()
{
"The given login '" + user.Login + "' is already in use."
};
result.OverallErrors = errors;
return(result);
}
var applicationUser = this.userRepository.Get(user.Id);
applicationUser.Name = user.Name;
applicationUser.Login = user.Login;
applicationUser.Password = PasswordEncryptor.Encrypt(user.Password);
this.userRepository.Update(applicationUser);
result.ValidatedUser = this.Get(user.Id);
return(result);
}
public async Task <User> UpdateFromDTOAsync(UserUpdateDTO dto)
{
var user = await this.Find(u => u.ID == dto.ID).FirstAsync();
if (user == null)
{
throw new Exception($"The user {dto.ID} was not found.");
}
if (dto.Name != null)
{
user.Name = dto.Name;
}
if (dto.Email != null)
{
user.Email = dto.Email;
}
if (dto.DepartmentName != null)
{
var department = await _departmentRepository.Find(d => d.Name == dto.DepartmentName).FirstAsync();
if (department == null)
{
throw new Exception($"Department {dto.DepartmentName} is not found.");
}
user.Department = department;
}
return(await this.Update(user));
}
public async Task <ActionResult> UpdateUser(int id, [FromBody] UserUpdateDTO updateInfo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var currentUser = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var repositoryUser = await _connection.GetUser(id);
if (repositoryUser == null)
{
return(NotFound($"the user with {id} is not available"));
}
if (currentUser != repositoryUser.Id)
{
return(Unauthorized());
}
_mapper.Map(updateInfo, repositoryUser);
if (await _connection.SaveAll())
{
return(NoContent());
}
throw new Exception($"User updation Failed for {id}");
}
public async Task <IActionResult> UpdateUser(int id, UserUpdateDTO userToUpdate)
{
/*Dodać sprawdzanie roli*/
//if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
//return Unauthorized();
var userEmpl = await _repo.GetUserEmployment(id);
var empDTO = new EmplUpdateDTO
{
WorkingHours = userToUpdate.WorkingHours,
CurrentyEmployed = userToUpdate.CurrentyEmployed,
FireDate = userToUpdate.FireDate
};
_mapper.Map(empDTO, userEmpl);
var userFromRepo = await _repo.GetUser(id);
_mapper.Map(userToUpdate, userFromRepo);
var userToReturn = _mapper.Map <UserReturnDTO>(userFromRepo);
if (await _repo.SaveAll())
{
return(Ok(userToReturn));
}
return(Content($"Błąd aktualizacji danych użytkownika o id: {id}"));
}
public async Task <UserDTO> Update(UserUpdateDTO userToUpdate)
{
//validator sur userToUpdate
User userInDb = await this.GetToTransformInDTO(userToUpdate.Id);
if (userInDb == null)
{
return(null);
}
userInDb.DeepCopy(userToUpdate);
if (!string.IsNullOrEmpty(userToUpdate.Password))
{
userInDb.CreatePasswordHash(userToUpdate.Password);
}
//validator sur user
string tokenSecret = this._appSettings.GetSection("Settings:Secret").Value;
userInDb.CreateToken(tokenSecret);
await userRepository.Update(userInDb);
User test = await this.userRepository.Get(userInDb.Id);
return(userInDb.ToDTO());
}
public ActionResult PutUser(int id, UserUpdateDTO user)
{
var identity = HttpContext.User.Identity as ClaimsIdentity;
if (identity != null)
{
if (identity.FindFirst("Id").Value != id.ToString() && !HttpContext.User.IsInRole(Policies.Admin))
{
return(Forbid());
}
}
var user1 = _repository.GetUserById(id);
if (user1 == null)
{
return(NotFound());
}
else if (user.Email == null || user.Password == null || user.Username == null)
{
return(BadRequest());
}
else
{
var userMapped = _mapper.Map <User>(user);
_repository.PutUser(id, userMapped);
user1 = _repository.GetUserById(id);
return(Ok(_mapper.Map <UserReadDTO>(user1)));
}
}
public async Task <IActionResult> UpdateUser([FromBody] UserUpdateDTO userDto, [FromRoute] string userId)
{
if (UserId == userId || IsAdmin)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApplicationUser userModel = await userService.GetUserById(userId);
if (userDto.HasNameOnly())
{
userModel.UserName = userDto.UserName;
}
else
{
mapper.Map(userDto, userModel);
}
await userService.UpdateUser(userModel);
return(new OkObjectResult("User updated"));
}
else
{
return(BadRequest("Can not update this user"));
}
}
public async Task E_Possivel_Invocar_a_Controller_Update()
{
var serviceMock = new Mock <IUserService>();
var nome = Faker.Name.FullName();
var email = Faker.Internet.Email();
serviceMock.Setup(m => m.Put(It.IsAny <UserUpdateDTO>())).ReturnsAsync(
new UserUpdateResultDTO
{
Id = Guid.NewGuid(),
Name = nome,
Email = email,
UpdateAt = DateTime.UtcNow
}
);
_controller = new UsersController(serviceMock.Object);
var userDtoUpdate = new UserUpdateDTO
{
Id = Guid.NewGuid(),
Name = nome,
Email = email,
};
var result = await _controller.Put(userDtoUpdate);
Assert.True(result is OkObjectResult);
UserUpdateResultDTO resultValue = ((OkObjectResult)result).Value as UserUpdateResultDTO;
Assert.NotNull(resultValue);
Assert.Equal(userDtoUpdate.Name, resultValue.Name);
Assert.Equal(userDtoUpdate.Email, resultValue.Email);
}
public async Task <Response <UserDTO> > UpdateUser(Guid id, UserUpdateDTO dto)
{
var userEntity = await _repository.GetById(id);
if (userEntity == null)
{
return(new BusinessConflictErrorResponse <UserDTO>(new []
{
new Error
{
Code = ErrorCodes.Business.UserDoesNotExists,
Message = ErrorMessages.Business.UserDoesNotExists,
Field = ErrorFields.User.Id
}
}));
}
userEntity.Name = dto.Name;
userEntity = await _repository.Update(userEntity);
var result = _mapper.Map <UserModel, UserDTO>(userEntity);
return(new Response <UserDTO>
{
Data = result
});
}
public async Task <IActionResult> UpdateUser(int id, [FromBody] UserUpdateDTO userDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var userFromRepo = await dataContext.GetUserAsync(id);
if (userFromRepo == null)
{
return(NotFound($"Couldn't find user {id}"));
}
if (currentUserId != userFromRepo.Id)
{
return(Unauthorized());
}
mapper.Map(userDTO, userFromRepo);
if (await dataContext.SaveAllAsync())
{
return(NoContent());
}
throw new Exception($"Update failed for user {id}");
}
public async Task <IActionResult> PutUser(string id, UserUpdateDTO model)
{
if (id != User.FindFirst(JwtRegisteredClaimNames.Jti).Value.ToString())
{
return(Unauthorized());
}
var user = await _context.Users.FindAsync(id);
_mapper.Map(model, user);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutUser(int id, UserUpdateDTO userUpdate)
{
/* if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
* {
* return Unauthorized();
* }*/
var userFromRepo = await _userRepository.GetUser(id);
_mapper.Map(userUpdate, userFromRepo);
try
{
var result = await _userRepository.SaveAll();
if (result)
{
return(NoContent());
}
else
{
throw new Exception($"Canot save a user data");
}
}
catch (DbUpdateConcurrencyException)
{
if (_userRepository.GetUser(id) == null)
{
return(NotFound());
}
else
{
throw;
}
}
}
public async Task <IActionResult> UpdateUser(int id, [FromBody] UserUpdateDTO userUpdate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var userFromRepo = await _repo.GetUser(id);
if (userFromRepo == null)
{
return(NotFound($"NF user w Id of {id}"));
}
if (currentUserId != userFromRepo.Id)
{
return(Unauthorized());
}
_mapper.Map(userUpdate, userFromRepo);
if (await _repo.SaveAll())
{
return(NoContent());
}
throw new Exception($"updating user {id} was failed");
}
public async Task Put_given_User_id_same_as_claim_calls_update()
{
var dto = new UserUpdateDTO
{
UserId = 1,
FirstName = "test",
};
var repository = new Mock <IUserRepository>();
var logger = new Mock <ILogger <UsersController> >();
var controller = new UsersController(repository.Object, logger.Object);
// Needs HttpContext to mock it.
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var cp = MockClaimsSecurity(dto.UserId);
//Update the HttpContext to use mocked claim
controller.ControllerContext.HttpContext.User = cp.Object;
await controller.Put(dto);
repository.Verify(s => s.UpdateAsync(dto));
}
public ActionResult Edit(int id, UserUpdateDTO request)
{
LoadData();
LoadById(id);
try
{
if (request.Password != null)
{
string passwordValue = request.Password;
request.Password = passwordService.HashPassword(passwordValue);
}
request.UserId = id;
updateCommand.Execute(request);
return(RedirectToAction(nameof(Index)));
}
catch (EntityAlreadyExistsException e)
{
TempData["error"] = e.Message;
return(View());
}
catch (EntityNotFoundException e)
{
TempData["error"] = e.Message;
return(View());
}
catch (Exception)
{
TempData["error"] = "Please fill up all field in this form.";
return(View());
}
}
public async Task Put_given_different_User_id_as_claim_returns_Forbidden()
{
var dto = new UserUpdateDTO
{
UserId = 1,
FirstName = "test",
};
var repository = new Mock <IUserRepository>();
var logger = new Mock <ILogger <UsersController> >();
var controller = new UsersController(repository.Object, logger.Object);
// Needs HttpContext to mock it.
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var cp = MockClaimsSecurity(42);
//Update the HttpContext to use mocked claim
controller.ControllerContext.HttpContext.User = cp.Object;
var put = await controller.Put(dto);
Assert.IsType <ForbidResult>(put);
}
public async Task <ActionResult> PartialUpdateCustomer(int id, JsonPatchDocument <UserUpdateDTO> patchDoc)
{
var customerModelFromRepo = await _userService.GetUser(id);
if (customerModelFromRepo == null)
{
return(NotFound());
}
var customerToPatch = new UserUpdateDTO
{
Firstname = customerModelFromRepo.Firstname,
Lastname = customerModelFromRepo.Lastname,
Email = customerModelFromRepo.Email
};
patchDoc.ApplyTo(customerToPatch, ModelState);
if (!TryValidateModel(customerToPatch))
{
return(ValidationProblem(ModelState));
}
customerModelFromRepo.SetFirstname(customerToPatch.Firstname);
customerModelFromRepo.SetLastname(customerToPatch.Lastname);
customerModelFromRepo.SetEmail(customerToPatch.Email);
await _userService.UpdateUser(customerModelFromRepo);
return(NoContent());
}
public async Task Put_given_non_existing_id_returns_NotFound()
{
var dto = new UserUpdateDTO
{
UserId = 1,
FirstName = "test",
NewPassword = "******"
};
var repository = new Mock <IUserRepository>();
repository.Setup(m => m.UpdateAsync(dto)).ReturnsAsync(false);
var logger = new Mock <ILogger <UsersController> >();
var controller = new UsersController(repository.Object, logger.Object);
// Needs HttpContext to mock it.
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var cp = MockClaimsSecurity(dto.UserId);
//Update the HttpContext to use mocked claim
controller.ControllerContext.HttpContext.User = cp.Object;
var put = await controller.Put(dto);
Assert.IsType <NotFoundResult>(put);
}
public async Task <IActionResult> UpdateUser(UserUpdateDTO userUpdateDTO)
{
try
{
bool ok = await _userService.UpdateUser(userUpdateDTO);
return(Ok(new Response <bool>
{
Error = false,
ErrorDescription = null,
ResponseModel = ok,
StatusCode = StatusCodes.Status200OK
}));
}
catch (Exception ex)
{
return(Ok(new Response <bool>
{
Error = true,
ErrorDescription = ex.Message,
ResponseModel = false,
StatusCode = StatusCodes.Status400BadRequest
}));
}
}
public async Task <IActionResult> Update(int Id, UserUpdateDTO userUpdate)
{
try
{
var user = await this._userManager.FindByIdAsync(Id.ToString());
if (user == null)
{
return(this.StatusCode(StatusCodes.Status404NotFound, "Usuário não encontrado"));
}
this._mapper.Map(userUpdate, user);
var result = await this._userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(Created($"/api/user/{userUpdate.Id}", this._mapper.Map <UserDTO>(user)));
}
return(BadRequest(result.Errors));
}
catch (System.Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Banco de dados falhou"));
}
}
public async Task <IActionResult> Update([FromForm] UserUpdateDTO model)
{
try
{
if (ModelState.IsValid)
{
await _identityService.UpdateAsync(mapper.Map <UserUpdateDTO, UserDTO>(model));
return(RedirectToAction(nameof(Index)));
}
ViewData["Position"] = new SelectList(_unitOfWork.EmployeePositions.GetAll(), "Id", "Title");
ViewData["Roles"] = new SelectList(_identityService.GetAllRoles(), "Name", "Name");
ViewData["Error"] = "Model is not correct";
return(View(model));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
ViewData["Position"] = new SelectList(_unitOfWork.EmployeePositions.GetAll(), "Id", "Title");
ViewData["Roles"] = new SelectList(_identityService.GetAllRoles(), "Name", "Name");
ViewData["Error"] = "Unexpected error";
return(View(model));
}
}
public async Task <UserDTO> UpdateUser(UserUpdateDTO userDto)
{
var userEntity = await repository.GetById(userDto.Id);
if (userEntity == null)
{
throw new NotFoundException(nameof(User), userDto.Id);
}
if (userEntity.TeamId != null && userEntity.TeamId != 0)
{
await teamService.GetTeamById((int)userEntity.TeamId);
}
else
{
userEntity.TeamId = null;
}
userEntity.FirstName = userDto.FirstName;
userEntity.LastName = userDto.LastName;
userEntity.Email = userDto.Email;
userEntity.Birthday = userDto.Birthday;
userEntity.TeamId = userDto.TeamId;
await repository.Update(userEntity);
await unitOfWork.SaveChangesAsync();
return((await GetAllUsers()).FirstOrDefault(u => u.Id == userEntity.Id));
}
public async Task <UserDTOUpdateResult> Update(UserUpdateDTO userInfo)
{
var model = _Mapper.Map <UserModel>(userInfo);
var entity = _Mapper.Map <UserEntity>(model);
var result = await _Repository.UpdateAsync(entity);
return(_Mapper.Map <UserDTOUpdateResult>(result));
}
