public async Task <Json> Update(long id, [FromBody] UserToUpdate user)
{
if (id <= 0 ||
user == null ||
!id.Equals(user.Id))
{
return(Json.BadRequest("Este usuáro não é válido!", user));
}
var repository = UserRepository.GetInstance(_context);
var userToUpdate = repository.GetById(id);
if (!repository.EmailValidation(user.Email) || userToUpdate == null)
{
return(Json.NotFound("Este usuáro não é válido!", user));
}
var userValidate = user.ToValidate();
if (userValidate.Erro)
{
return(Json.BadRequest("Erro ao validar usuário, verifique os erros", userValidate.Erros));
}
var resultUpdate = await repository.Update(user.ToUserData());
if (resultUpdate.Erro)
{
return(Json.BadRequest("Falha ao criar usuário!", resultUpdate.Description));
}
userToUpdate = repository.GetById(id);
return(Json.Ok("Usuário alterrado com sucesso!", userToUpdate));
}
public async Task <Result <UserView> > UpdateUserProfileAsync(UserToUpdate userToUpdate, string idFromIdentity, CancellationToken cancellationToken = default)
{
AppUser usersIdentity = await _userManager.FindByIdAsync(idFromIdentity);
if (usersIdentity is null)
{
return(Result <UserView> .Fail <UserView>(ExceptionConstants.USER_WAS_NOT_FOUND));
}
usersIdentity.Address = userToUpdate.Address;
usersIdentity.PhoneNumber = userToUpdate.PhoneNumber;
usersIdentity.Name = userToUpdate.Name;
usersIdentity.Surname = userToUpdate.Surname;
try
{
await _userManager.UpdateAsync(usersIdentity);
UserView view = GetUserByIdFromIdentityAsync(usersIdentity.Id).Result.Data;
return(Result <UserView> .Ok(view));
}
catch (DbUpdateConcurrencyException ex)
{
return(Result <UserView> .Fail <UserView>(ExceptionConstants.CANNOT_UPDATE_MODEL + ex.Message));
}
catch (DbUpdateException ex)
{
return(Result <UserView> .Fail <UserView>(ExceptionConstants.CANNOT_UPDATE_MODEL + ex.Message));
}
}
public async Task UpdateAsync(UserToUpdate model)
{
var entity = await _repository.GetByIdAsync(model.Id);
_mapper.Map(model, entity);
await _repository.UpdateAsync(entity);
}
public static UserModelData ToUserData(this UserToUpdate user)
=> new UserModelData
{
Id = user.Id,
Name = user.Name,
Email = user.Email,
Gender = user.Gender.ToGender()
};
public async Task <IActionResult> UpdateUser(string email, UserToUpdate aUser)
{
if (ModelState.IsValid)
{
return(Ok(await _accountServices.UpdateUser(email, aUser)));
}
return(NotFound());
}
private static UserEf ConvertFrom_UserToUpdate_To_Entity(UserToUpdate model, UserEf entity)
{
var instance = entity ?? new UserEf();
instance.Name = model.Name.RemoveSpace();
instance.Email = model.Email.RemoveSpace();
instance.Password = model.Password.RemoveSpace();
instance.LastName = model.LastName.RemoveSpace();
instance.CellPhone = model.CellPhone.RemoveSpace();
instance.LandPhone = model.LandPhone.RemoveSpace();
instance.UserRoles.Clear();
instance.UserRoles = model.Roles
.Select(roleId => new UserRoleEf {
RoleId = roleId, UserId = model.Id
}).ToList();
return(instance);
}
public async Task <IActionResult> UpdateUserProfileByAdmin([FromBody, CustomizeValidator] UserToUpdate user, string idFromIdentity, CancellationToken cancellationToken = default)
{
if (user is null || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _userService.UpdateUserProfileAsync(user, idFromIdentity, cancellationToken);
return(result.IsError ? throw new InvalidOperationException(result.Message) : (IActionResult)Ok(result.Data));
}
catch (InvalidOperationException ex)
{
Log.Error(ex, ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError, new CustumResult()
{
Status = StatusCodes.Status500InternalServerError, Message = ex.Message
}));
}
}
/// <summary>
/// Updates user information
/// </summary>
/// <param name="email">email of user to update</param>
/// <param name="aUser">new user information to update</param>
/// <returns>The returned result</returns>
public async Task <IdentityResult> UpdateUser(string email, UserToUpdate aUser)
{
var user = await UserManager.FindByEmailAsync(email);
if (user != null)
{
user.FirstName = aUser.FirstName;
user.LastName = aUser.LastName;
user.Photo = aUser.Photo;
user.Email = aUser.Email;
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
return(result);
}
throw new ApplicationException("Unable to update user");
}
throw new ApplicationException("User not found");
}
public UserV2 UpdateMyUser(string authToken, UserToUpdate userToUpdate)
{
return(PerformHttpRequest <UserToUpdate, UserV2>(authToken, "/UpdateMyUser", userToUpdate));
}
private static UserToUpdate ConvertFrom_Entity_To_UserToUpdate(UserEf entity, UserToUpdate model)
{
var instance = model ?? new UserToUpdate();
instance.Id = entity.Id;
instance.Name = entity.Name;
instance.Email = entity.Email;
instance.Password = entity.Password;
instance.LastName = entity.LastName;
instance.CellPhone = entity.CellPhone;
instance.LandPhone = entity.LandPhone;
instance.Roles = entity?.UserRoles.Select(x => x.RoleId).ToList();
return(instance);
}
public async Task <IActionResult> Update([FromRoute] int residentialId, [FromRoute] int userId, [FromBody] UserToUpdate user)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var loggedUser = User.GetUserId();
if (!await _userManager.IsAdminAsync(residentialId, loggedUser))
{
return(Forbid(_localizer.GetValue(LocalizationMessage.YouDoNotHavePermissionToAccessThisResource)));
}
if (!await _userManager.ExistsAsync(residentialId, userId))
{
return(NotFound(_localizer.GetValue(LocalizationMessage.UserNotFound)));
}
if (await _userManager.ExistsEmailAsync(residentialId, user.Id, user.Email))
{
return(BadRequest(_localizer.GetValue(LocalizationMessage.EmailAlreadyExists)));
}
await _userManager.UpdateAsync(user);
return(NoContent());
}
public Task <UserV2> UpdateMyUserAsync(string authToken, UserToUpdate userToUpdate)
{
return(PerformHttpRequestAsync <UserToUpdate, UserV2>(authToken, "/UpdateMyUser", userToUpdate));
}
public async Task <IActionResult> UserUpdate(int id, UserToUpdate usertoupdate)
{
// var user = await _dataContext.Customer.FirstOrDefaultAsync(x => x.CustomerId == id);
var user = await _repo.getProfile(id);
if (usertoupdate.newname != "")
{
user.Fullname = usertoupdate.newname;
}
if (usertoupdate.newemail != "")
{
user.Email = usertoupdate.newemail;
}
if (usertoupdate.newaddress1 != "")
{
user.Address1 = usertoupdate.newaddress1;
}
if (usertoupdate.newaddress2 != "")
{
user.Address2 = usertoupdate.newaddress2;
}
if (usertoupdate.newcity != "")
{
user.City = usertoupdate.newcity;
}
if (usertoupdate.newstate != "")
{
user.State = usertoupdate.newstate;
}
if (usertoupdate.newzip4 != "")
{
user.Zip4 = usertoupdate.newzip4;
}
if (usertoupdate.newzip5 != "")
{
user.Zip5 = usertoupdate.newzip5;
}
//create new pass hash & satl for new password
if (usertoupdate.newpassword != "")
{
byte[] salted = new byte[128 / 8];
using (var rng = RandomNumberGenerator.Create())
{
rng.GetBytes(salted);
}
string hashed = Convert.ToBase64String(KeyDerivation.Pbkdf2(
password: usertoupdate.newpassword,
salt: salted,
prf: KeyDerivationPrf.HMACSHA1,
iterationCount: 10000,
numBytesRequested: 256 / 8));
user.PasswordHashed = hashed;
user.PasswordSalt = salted;
}
// await _dataContext.SaveChangesAsync();
_repo.SaveAllChange();
return(Ok("update successful"));
}
public static User ToValidate(this UserToUpdate user) => User.Create(user.Name, user.Email, null, user.Dateborn.ToDate(), user.Gender.ToGender());
public async Task <Json> TurnUserAdmin(long id, [FromBody] UserToUpdate user)
{
user.Admin = true;
return(await Update(id, user));
}
