Updates the given user.
@param partnerId The id of the partner the user belongs to
@param accountId The id of the account for the user
@param user The user to update
@return The user that was updated
963819
public Optional<PartnerUser> update(long partnerId, long accountId, PartnerUser user)
    {
        return Optional.of(HTTP.PUT(String.format("/v2/partners/%d/accounts/%d/users", partnerId, accountId), user, PARTNER_USERS).get().iterator().next());
    }
239408
@Route(method = HttpMethod.POST, uri = "/{id}")
    public Result updateBundle(@Parameter("id") long id) {
        final Bundle bundle = context.getBundle(id);
        if (bundle == null) {
            return notFound("Bundle " + id + " not found");
        } else {
            return async(new Callable<Result>() {
                @Override
                public Result call() throws Exception {
                    try {
                        logger().info("Updating bundle {} from {}", bundle.getSymbolicName(), bundle.getLocation());
                        bundle.update();
                        return ok();
                    } catch (BundleException e) {
                        logger().error("Cannot update bundle {}", bundle.getSymbolicName(), e);
                        return badRequest(e);
                    }
                }
            });
        }
    }
893488
public void updateClientId(String clientId) {
        if (configForVM != null) {
            configForVM.withClientId(clientId);
        } else {
            configForAppService.withClientId(clientId);
        }
    }
1293933
protected void updatePartnerServiceData() throws Exception {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "updatePartnerServiceData");

        try {
            //
            // Check we have a recoverableUnit and three sections to add the data.
            // On recovery we check that all service data sections were recovered.
            //
            if (_partnerServiceData == null) {
                if (_recoverXaLog != null)
                    _partnerServiceData = _recoverXaLog.createRecoverableUnit();
                else
                    _partnerServiceData = _xaLog.createRecoverableUnit();

                _partnerServerSection = _partnerServiceData.createSection(TransactionImpl.SERVER_DATA_SECTION, true);
                _partnerApplIdSection = _partnerServiceData.createSection(TransactionImpl.APPLID_DATA_SECTION, true);
                _partnerEpochSection = _partnerServiceData.createSection(TransactionImpl.EPOCH_DATA_SECTION, true);
                _partnerLowWatermarkSection = _partnerServiceData.createSection(TransactionImpl.LOW_WATERMARK_SECTION, true); /* @MD18134A */
                _partnerNextIdSection = _partnerServiceData.createSection(TransactionImpl.NEXT_ID_SECTION, true); /* @MD18134A */

                // Log this server name
                _partnerServerSection.addData(Utils.byteArray(_failureScopeController.serverName()));
                // Log our ApplId
                _partnerApplIdSection.addData(_ourApplId);

                // Low watermark will start at 1
                _partnerEntryLowWatermark = 1; /* @MD18134A */
                _partnerLowWatermarkSection.addData(Util.intToBytes(_partnerEntryLowWatermark)); /* @MD18134A */

                // Next ID will start at 2.
                _partnerEntryNextId = 2; /* @MD18134A */
                _partnerNextIdSection.addData(Util.intToBytes(_partnerEntryNextId)); /* @MD18134A */
            }

            // Always update this server's current epoch
            _partnerEpochSection.addData(Util.intToBytes(_ourEpoch));

            // Update the server state in the log
            updateServerState(STARTING);

            _partnerServiceData.forceSections();
        } catch (Exception e) {
            FFDCFilter.processException(e, "com.ibm.tx.jta.impl.RecoveryManager.updatePartnerSeviceData", "1224", this);
            if (tc.isEntryEnabled())
                Tr.exit(tc, "updatePartnerServiceData", e);
            throw e;
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "updatePartnerServiceData");
    }
969054
@Path("/{accountSid}")
    @Consumes(APPLICATION_FORM_URLENCODED)
    @POST
    @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
    public Response updateAccountAsXmlPost(@PathParam("accountSid") final String accountSid,
            final MultivaluedMap<String, String> data,
            @HeaderParam("Accept") String accept,
            @Context SecurityContext sec) {
        return updateAccount(accountSid, data, retrieveMediaType(accept), ContextUtil.convert(sec));
    }
1016907
public Optional<PartnerUser> create(long partnerId, long accountId, PartnerUser user)
    {
        return Optional.of(HTTP.POST(String.format("/v2/partners/%d/accounts/%d/users", partnerId, accountId), user, PARTNER_USERS).get().iterator().next());
    }
417306
public function saveAccountId($accountId, $id = false)
    {
        $em = $this->getEntityManager();
        $config = $id ? $this->find($id) : $this->findFirst();
        $config->setAccountId($accountId);
        $em->persist($config);
        $em->flush();
    }
101699
private String updateAccount(Long userId) {
    String email = get("mail");
    String pwd = get("password");
    Map<String, Object> valueMap = CollectUtils.newHashMap();
    valueMap.put("password", pwd);
    valueMap.put("mail", email);
    entityDao.update(User.class, "id", new Object[] { userId }, valueMap);
    return redirect("infolet", "ok.passwordChanged", "&id=" + userId);
  }
1180118
public function createUser(PartnerInterface $partner, $username, $password)
    {
        $email = $partner->getPrimaryContact()->getEmail();
        $user = $this->userManipulator->create($username, $password, $email, true, false);

        $user->setPartner($partner);
        //Setup user roles
        $userRoles = $this->mapPartnerToUserRoles($partner->getRoles());

        foreach ($userRoles as $userRole) {
            $user->addRole($userRole);
        }

        return $user;
    }
377961
public boolean updatePostAuthor(final long postId, final long authorId) throws SQLException {

      Connection conn = null;
      PreparedStatement stmt = null;
      try {
         conn = connectionSupplier.getConnection();
         stmt = conn.prepareStatement(updatePostAuthorSQL);
         stmt.setLong(1, authorId);
         stmt.setLong(2, postId);
         return stmt.executeUpdate() > 0;
      } finally {
         SQLUtil.closeQuietly(conn, stmt);
      }
   }
832540
def add_federation(self, provider, federated_id):
        
        models.AuthUserFederation.new(user=self,
                                      provider=provider,
                                      federated_id=federated_id)
365538
public function setAccountID($accountID)
    {
        if (trim($accountID) == null)
        {
            throw new InvalidArgumentException("You must supply an account ID.");
        }

        if (!is_numeric($accountID))
        {
            throw new InvalidArgumentException("Account ID must be numeric.");
        }
        $this->accountID = intval($accountID);
    }
953773
@Deprecated
    User updateUser(String id, UpdateUser updateUser, AccessToken accessToken) {
        if (updateUser == null) {
            throw new IllegalArgumentException("The given updateUser can't be null.");
        }
        return updateResource(id, updateUser.getScimConformUpdateUser(), accessToken);
    }
656757
public Optional<PartnerSubscription> show(long partnerId, long accountId, long subscriptionId)
    {
        return HTTP.GET(String.format("/v2/partners/%d/accounts/%d/subscriptions/%d", partnerId, accountId, subscriptionId), PARTNER_SUBSCRIPTION);
    }
148433
public PartnerAccountService delete(long partnerId, long accountId)
    {
        HTTP.DELETE(String.format("/v2/partners/%d/accounts/%d", partnerId, accountId));       
        return this;
    }
504177
public ChunkedUploadResponse updateChunkedUpload(String accountId, String chunkedUploadId) throws ApiException {
    return updateChunkedUpload(accountId, chunkedUploadId, null);
  }
63956
@RequestMapping(value = "groups/{groupId}/update", method = RequestMethod.PUT)
    public AccountGroup updateGroup(@PathVariable ID groupId, @RequestBody @Valid NameDescription input) {
        return accountService.updateGroup(groupId, input);

    }