Updates the active user. The old and new password can be left out, in
which case the password will not be changed. If the mail is changed, the
old password has to be supplied as well.
184119
public void updateUser(UserUpdate update) {
		getResourceFactory().getApiResource("/user/")
				.entity(update, MediaType.APPLICATION_JSON_TYPE).put();
	}
637951
def change_password(self, user, password):
        
        if not self.__contains__(user):
            raise UserNotExists
        self.new_users[user] = self._encrypt_password(password) + "\n"
1156212
def allow_password_change?
        if params[:old_password]
          unless @user.authenticate(params[:old_password])
            raise ApplicationController::UNAUTHORIZED_ERROR 
          end
        else
          unless @token == @user.reset_token
            raise ApplicationController::UNAUTHORIZED_ERROR
          end
        end
        return true
      end
756410
protected static function updateUserPassword($users)
    {
        if (!empty($users)) {
            foreach ($users as $i => $user) {
                if (isset($user['password'])) {
                    /** @type User $model */
                    $model = User::where('email', '=', $user['email'])->first();
                    $model->updatePasswordHash($user['password']);
                }
            }
        }
    }
412956
public function actionUpdate() {
		
		try {
			\App::$domain->rbac->role->update();
		} catch(NotAuthenticatedException $e) {
			\App::$domain->account->auth->breakSession();
			echo 'NotAuthenticatedException';
			return;
		} catch(UnauthorizedHttpException $e) {
			\App::$domain->account->auth->breakSession();
			echo 'UnauthorizedHttpException';
			return;
		}
		echo 'success';
	}
1033310
def change_password(self, previous, new_password):
        
        if not self.verify_password(previous):
            raise exceptions.Unauthorized('Incorrect password')

        if len(new_password) < options.min_length_password:
            msg = ('Passwords must be at least {} characters'
                   .format(options.min_length_password))
            raise exceptions.ValidationError(msg)

        if len(new_password) > options.max_length_password:
            msg = ('Passwords must be at no more than {} characters'
                   .format(options.max_length_password))
            raise exceptions.ValidationError(msg)

        self.password = self.hash_password(new_password)
        yield self._save()
456450
public function updateUserWithAmazonData()
    {
        $billingAddress = $this->getAmazonBillingAddress();

        if ($billingAddress !== null) {
            $oUser = $this->getUser();
            $oUser->assign($billingAddress);
            $oUser->save();
        }
    }
150515
def update(self, password=values.unset):
        
        return self._proxy.update(password=password, )
990409
def change_password(self, previous_password, proposed_password):
        
        self.check_token()
        response = self.client.change_password(
            PreviousPassword=previous_password,
            ProposedPassword=proposed_password,
            AccessToken=self.access_token
        )
        self._set_attributes(response, {'password': proposed_password})
183084
private void updateUser(CmsUser user) {

        setUserPasswordStatus(user, m_forceResetPassword.getValue().booleanValue());
        user.setDescription(m_description.getValue());
        user.setManaged(!m_selfmanagement.getValue().booleanValue());
        user.setEnabled(m_enabled.getValue().booleanValue());
        m_userdata.submit(user, m_cms, new Runnable() {

            public void run() {
                //
            }
        }, true);
    }
158129
def update_user(update_user_params)
        if @user.update_attributes(update_user_params)
          render json: @user, except: [:password_digest]
        else
          render_errors 400, @user.errors.full_messages
        end
      end
352097
def refresh(self):
        
        newuser = self.bugzilla.getuser(self.email)
        self.__dict__.update(newuser.__dict__)
658407
function(oldPassword, newPassword, options) {
        var route = 'users/' + this.id + '/updatePassword';
        var params = {
          old_password: oldPassword,
          new_password: newPassword,
        };
        var request = AVRequest(route, null, null, 'PUT', params, options);
        return request;
      }
491157
def update(gandi, email, password, quota, fallback, alias_add, alias_del):
    """"""
    options = {}

    if password:
        password = click.prompt('password', hide_input=True,
                                confirmation_prompt=True)
        options['password'] = password

    if quota is not None:
        options['quota'] = quota

    if fallback is not None:
        options['fallback_email'] = fallback

    login, domain = email

    result = gandi.mail.update(domain, login, options, alias_add, alias_del)

    return result
1251569
def update_credential_password(username, password)
      raise ArgumentError, "The new password cannot be nil"   unless password
      raise ArgumentError, "The new username cannot be nil"   unless username
      raise ArgumentError, "The new password cannot be empty" if password.empty?
      raise ArgumentError, "The new username cannot be empty" if username.empty?

      self.service.editCredential(username.to_s, password.to_s)

      @credentials = nil
    end
512020
protected void save() {

        boolean newUser = false;
        try {
            if (m_user == null) {
                createNewUser();
                newUser = true;
            } else {

                saveUser();
            }
            saveUserSettings();
            if (m_sendEmail.getValue().booleanValue() & m_sendEmail.isEnabled()) {
                sendMail(m_cms, m_pw.getPassword1(), m_user, newUser, m_forceResetPassword.getValue().booleanValue());
            }
        } catch (CmsException e) {
            LOG.error("Unable to save user", e);
        }
    }
1023659
public function changePassword()
    {
        if ($this->validate() && $this->new_password == $this->new_password_confirm && $this->new_password) {
            $this->user->setPassword($this->new_password);
            return $this->user->save(false);
        } else {
            return false;
        }
    }