public IActionResult UpdateMember(int id, [FromBody] MemberUpdateDto member)
{
if (member == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var memberFromStore = VoxEventsDataStore.Current.Members.FirstOrDefault(m => m.Id == id);
if (memberFromStore == null)
{
return(NotFound());
}
memberFromStore.FirstName = member.FirstName;
memberFromStore.LastName = member.LastName;
memberFromStore.Email = member.Email;
memberFromStore.Phone = member.Phone;
memberFromStore.Part = member.Part;
return(NoContent());
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
// if u store d username in the token using : - new Claim(JwtRegisteredClaimNames.NameId, user.UserName),
// var username = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
// if u store d username in the token using : - new Claim("username", user.UserName),
// var username = User.FindFirst(claim => claim.Type == "username")?.Value;
var username = GetUsername();
//using the username gtin from d token, we find the user details from d db
var user = await _userRepository.GetUserByUsernameAsync(username);
// without autoMapper we will av to do this
// user.City = memberUpdateDto.City;
// user.Country = memberUpdateDto.Country;
// user.Introduction = memberUpdateDto.Introduction;
// user.LookingFor = memberUpdateDto.LookingFor;
// user.Interest = memberUpdateDto.Interest;
//With AutoMapper, ds is all we need to do
_mapper.Map(memberUpdateDto, user);
//we call d user repository to update the user details
_userRepository.UpdateUser(user);
if (await _userRepository.SaveAllAsync())
{
// we return 204 reponse so we do not need to return any data to the user....
return(NoContent());
}
return(BadRequest("Failed to update user"));
}
[ProducesDefaultResponseType] //Any error that doesn't fall above
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
//Get hold of the username from the token, not by username as we cant trust this.
//as someone could have stolen the token and is trying to use it to update a different user.
var username = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
//Get appUser from DB
var appUser = await _unitOfWork.AppUser.GetUserByUsernameAsync(username);
//User not found
if (appUser == null)
{
//404
return(NotFound());
}
//Map the input DTO to our User class
_mapper.Map(memberUpdateDto, appUser);
//User object is flagged as being updated by Entity Framework
_unitOfWork.AppUser.Update(appUser);
//Persist changes to DB
if (await _unitOfWork.AppUser.SaveAllAsync())
{
return(NoContent());
}
else
{
//400
return(BadRequest("Failed to update user."));
}
}
public async Task <ActionResult <MemberDto> > UpdateUser(MemberUpdateDto memberUpdated)
{
var username = User.GetUsername();
var user = await _userManager.Users.Include(x => x.Photos).IgnoreQueryFilters().SingleOrDefaultAsync(x => x.UserName == username.ToLower());
if (user == null)
{
return(BadRequest("Failed to update"));
}
foreach (var photo in memberUpdated.Photos)
{
if (photo.Id == 0)
{
photo.IsApproved = false;
}
}
_mapper.Map(memberUpdated, user);
if (!user.Photos.Any(x => x.IsMain))
{
user.Photos.FirstOrDefault().IsMain = true;
}
_unitOfWork.UserRepository.Update(user);
if (await _unitOfWork.Complete())
{
return(Ok(_mapper.Map <MemberDto>(user)));
}
return(BadRequest($"Failed to update {username}"));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUserName());
_mapper.Map(memberUpdateDto, user);
_unitOfWork.UserRepository.Update(user);
// var collegePrep = new CollegePrep
// {
// AcademicPlus = memberUpdateDto.AcademicPlus
// };
// user.CollegePreps.Add(collegePrep);
// user.CollegePreps.a Entry(user.CollegePreps.AcademicPlus).State = EntityState.Modified;
// _context.Entry(user).State = EntityState.Modified;
if (await _unitOfWork.Complete())
{
return(NoContent());
}
return(BadRequest("Failed to update user"));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
//var username = User.FindFirst(ClaimTypes.NameIdentifier)?.Value; //It will give us username for the token Api used to autenticate this user
var username = User.GetUsername();
var user = await _userRepository.GetUserByUsernameAsync(username);
//user.City = memberUpdateDto.City; //we do not need => we use AutoMaper
// ...
// or
_mapper.Map(memberUpdateDto, user);
_userRepository.Update(user);
if (await _userRepository.SaveAllAsync())
{
return(NoContent());
}
return(BadRequest("Failed to update user"));
// var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
// _mapper.Map(memberUpdateDto, user);
// _unitOfWork.UserRepository.Update(user);
// if (await _unitOfWork.Complete()) return NoContent();
// return BadRequest("Failed to update user");
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
// get the current user from the Claims Principal.
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
// use automapper to map the memberUpdateDto information to the user we returned from the UserRepository.
_mapper.Map(memberUpdateDto, user);
// Update these properties before saving to the DB.
user.UpdatedAt = DateTime.UtcNow;
user.FirstName = user.FirstName.ToLower();
user.LastName = user.LastName.ToLower();
user.CyclingFrequency = user.CyclingFrequency.ToLower();
user.CyclingCategory = user.CyclingCategory.ToLower();
user.SkillLevel = user.SkillLevel.ToLower();
// Update the database with the new changes.
_unitOfWork.UserRepository.Update(user);
// save changes to the db then return 204NoContent.
if (await _unitOfWork.Complete())
{
return(NoContent());
}
// return 400BadRequest if all fails.
return(BadRequest("Failed to update user"));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
/*below line will make use of the claim (username and token) which is being used by the API
* , to authenticate the user and get username from that*/
var username = User.GetUserName(); //Extension method
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username);
// user.Interest = memberUpdateDto.Interest;
// user.Introduction = memberUpdateDto.Introduction;
//In order to assign objects one by one(as above) we use map instead
_mapper.Map(memberUpdateDto, user);
_unitOfWork.UserRepository.UpdateProfile(user);
if (await _unitOfWork.Complete())
{
return(NoContent());
}
else
{
return(BadRequest("Failed to update user"));
}
}
public async Task <ActionResult> UpdateUser(string email, MemberUpdateDto memberUpdateDto)
{
var user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
return(NotFound("Could not find the user"));
}
if (!string.IsNullOrWhiteSpace(memberUpdateDto.Password))
{
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
var result = await _userManager.ResetPasswordAsync(user, token, memberUpdateDto.Password);
if (!result.Succeeded)
{
return(BadRequest("Failed to update password"));
}
}
// update user properties if provided
if (!string.IsNullOrWhiteSpace(memberUpdateDto.Firstname))
{
user.FirstName = memberUpdateDto.Firstname;
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(BadRequest("Failed to update Firstname"));
}
}
if (!string.IsNullOrWhiteSpace(memberUpdateDto.Lastname))
{
user.LastName = memberUpdateDto.Lastname;
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(BadRequest("Failed to update Lastname"));
}
}
if (memberUpdateDto.Active == true || memberUpdateDto.Active == false)
{
user.Active = memberUpdateDto.Active;
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(BadRequest("Failed to update active"));
}
}
return(Ok());
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
_mapper.Map(memberUpdateDto, user);
_unitOfWork.UserRepository.Update(user);
return(await _unitOfWork.Complete() ? NoContent() : BadRequest("Failed to update user"));
}
public void MapUpdateMemberDtoToAppUser_SetsAtLeastOneValue()
{
var source = new MemberUpdateDto {
City = "city"
};
var result = Mapper.Map <AppUser>(source);
Assert.Equal("city", result.City);
}
public async Task <bool> UpdateUserByUsernameAsync(string username, MemberUpdateDto memberUpdateDto)
{
var appUser = await GetUserByUsernameAsync(username);
_mapper.Map(memberUpdateDto, appUser);
Update(appUser);
return(await SaveAllAsync());
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var user = await _userRepository.GetUserByUsername(User.GetUserName());
_mapper.Map(memberUpdateDto, user);
await _userRepository.UpdateUser(user);
return(Ok());
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var saveSuccess = await _userRepository.UpdateUserByUsernameAsync(User.GetUsername(), memberUpdateDto);
if (saveSuccess)
{
return(NoContent());
}
return(BadRequest("Failed to save the user."));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var user = await _userRepository.GetUserByUsernameAsync(User.GetUserName());
_mapper.Map(memberUpdateDto, user);
_userRepository.Update(user);
if (await _userRepository.SaveAllAsync())
{
return(NoContent());
}
return(BadRequest("Failed to update user"));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var user = await unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
mapper.Map(memberUpdateDto, user); //we map dto to AppUser
unitOfWork.UserRepository.Update(user);
if (await unitOfWork.Complete())
{
return(NoContent());
}
return(BadRequest("Failed to update user"));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var userName = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
var user = await _userRepository.GetUserByUsernameAsync(userName);
_mapper.Map(memberUpdateDto, user);
if (await _userRepository.SaveAllAsync())
{
return(NoContent());
}
return(BadRequest("Failed to update user"));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var user = await _unitOfWork.UserRepository.GetUserByNameAsync(User.GetUserName());
_mapper.Map(memberUpdateDto, user);
_unitOfWork.UserRepository.Update(user);
if (await _unitOfWork.SaveChanges())
{
return(NoContent());
}
return(BadRequest("Failed to updated the profile"));
}
public async Task <ActionResult <MemberDto> > UpdateUser(MemberUpdateDto memberUpdateDto)
{
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
_mapper.Map(memberUpdateDto, user);
_unitOfWork.UserRepository.Update(user);
var result = await _unitOfWork.UserRepository.GetMemberAsync(user.UserName, false);
return(result);
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
// Now we have an extension method that returns the username we don't need to store it in a variable
//var username = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
var user = await _repo.GetUserByUsername(User.GetUsername());
_mapper.Map(memberUpdateDto, user);
_repo.Update(user);
return((await _repo.SaveAllAsync()) ? NoContent() : BadRequest("Failed to update user"));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
// get the username from the verified JWT token, not the client form
var user = await _userRepository.GetUserByUsernameAsync(User.GetUsername());
_mapper.Map(memberUpdateDto, user);
_userRepository.Update(user);
if (await _userRepository.SaveAllAsync())
{
return(NoContent());
}
return(BadRequest("Failed to update user"));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
_mapper.Map(memberUpdateDto, user);
_unitOfWork.UserRepository.Update(user);
if (await _unitOfWork.Complete())
{
return(NoContent());
}
return(BadRequest("Errore durante aggiornamento dati utente."));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var username = User.GetUsername();
var user = await _unitOfWork.UserRepository.GetUserByUserNameAsync(username);
_mapper.Map(memberUpdateDto, user);
_unitOfWork.UserRepository.Update(user);
if (await _unitOfWork.Complete())
{
return(NoContent());
}
return(BadRequest("error while updating user"));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto model)
{
var username = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username);
_mapster.Map(model, user);
_unitOfWork.UserRepository.Update(user);
if (await _unitOfWork.Complete())
{
return(NoContent());
}
return(BadRequest("Fail to update user"));
}
private UserProfileDto CreateUserProfileDto(MemberUpdateDto memberUpdateDto)
{
var info = _mappingService.Map <BasicMemberInfo>(memberUpdateDto);
var profile = new UserProfileDto
{
Body = _serializer.Serialize(info),
Key = Guid.NewGuid(),
UserKey = memberUpdateDto.Key,
UserProfileOriginator = _userProfileConfig.UserProfileOriginator
};
return(profile);
}
public async Task <ActionResult <MemberDto> > PutUser(MemberUpdateDto memberUpdateDto)
{
var user = await _userRepository.GetUserByUserNameAsync(User.GetUserName());
_mapper.Map(memberUpdateDto, user);
_userRepository.Update(user);
if (!await _unitOfWork.Complete())
{
return(BadRequest());
}
return(_mapper.Map <MemberDto>(user));
}
[HttpPut] //that's what we use for updating
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var username = User.FindFirst(ClaimTypes.NameIdentifier)?.Value; //This should give us the user's username from the token, that the API uses to authenticate this user
var user = await _userRepository.GetUserByUsernameAsync(username);
_mapper.Map(memberUpdateDto, user);
_userRepository.Update(user);
if (await _userRepository.SaveAllAsync())
{
return(NoContent());
}
return(BadRequest("Failed to update user"));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
var user = await _repo.GetUserByName(User.GetUsername());
var updatedUser = _mapper.Map(memberUpdateDto, user);
_repo.Update(updatedUser);
if (await _repo.SaveAllAsync())
{
return(NoContent());
}
return(BadRequest("Failed to update user"));
}
[HttpPut] // The HttpPut will allow us to update a respurce on our server. As the HttpPut different to the HttpGet, we can use the same end point as the HttpGet above (which is the default /users endpoint)
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{ // As the client already has the information we are updating and we don't need to receive anything back from the http request, we don't provide a return type like we do in the other methods above
var user = await _userRepository.GetUserByUsernameAsync(User.GetUsername()); // We need to get hold of the user and the users username. We don't want to trust the user to manually input their username when updating their profile. We want to get it from what we are authenticating against which is the token. Inside a controller we have access to a claims principle of the User. This contains information about their identity. The token contains this username as we specified this in our token service file. The 'User' claims principle is accessible in the controllers. See Claims principle extension method file
_mapper.Map(memberUpdateDto, user); // When we using mapper to update an object, we can use the Map method. So this will prevent us from manually maping our memberUpdateDto to our user object and it will handle this for this us
_userRepository.Update(user); // This update method will add a flag to our user object to say that this object has been updated by entity framework. This guarantees that we are not going to get an exception or an error when we update the user in our database
if (await _userRepository.SaveAllAsync())
{
return(NoContent()); // We use the NoContent when we don't need to receive any data back from the http request. The SaveAllAsync method returns either 1 or -1, hence we can use it in a conditional statement
}
return(BadRequest("Falied to update user"));
}
public async Task <ActionResult> UpdateUser(MemberUpdateDto memberUpdateDto)
{
//var username = User.GetUsername();//it will return username from the token being used to authenticate this user
var user = await _userRepository.GetUserByUsernameAsync(User.GetUsername());
_mapper.Map(memberUpdateDto, user); //mapping Dto to User entity
_userRepository.Update(user);
if (await _userRepository.SaveAllAsync())
{
return(NoContent());
}
return(BadRequest("Failed to update user"));
}
