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