Updates Entity with its data from the API
15873
def get_data
      response = proxy.get_data(handle)
      update_properties(response)
      self.partial = false
      self.persisted = true
    end
244071
protected function update()
    {
        $key = $this->aggregate->getEntityKeyName();
        $value = $this->aggregate->getEntityKeyValue();

        $this->query->where($key, $value);

        $dirtyAttributes = $this->aggregate->getDirtyRawAttributes();

        if (count($dirtyAttributes) > 0) {
            $this->query->update($dirtyAttributes);
        }
    }
642452
@Override
	public boolean update(T entity) {
		if(entity == null) {
			return false;
		}
		
		X primaryID = getPrimaryID(entity);
		if(primaryID == null) {
			return false;
		}
		
		if(!allowEmptyOrZeroID() && AssertUtils.isEmpty(primaryID)) {
			return false;
		}
		
		this.mongoTemplate.save(entity);
		return true;
	}
666790
public ApiSuccessResponse updateContact(String id, UpdateContactData updateContactData) throws ApiException {
        ApiResponse<ApiSuccessResponse> resp = updateContactWithHttpInfo(id, updateContactData);
        return resp.getData();
    }
559577
def update_user(self):
        
        # First create a copy of the current user
        user_dict = self.serialize()
        # Then delete the entities in the description field
        del user_dict['description']['entities']
        # Then upload user_dict
        user, meta = self._api.update_user('me', data=user_dict)
653140
protected function update()
    {
        $this->preUpdate();
        $this->data = $this->api->update($this->id, $this->data);
        $this->postUpdate();

        return $this;
    }
790527
@Transactional
  @PutMapping("/{entityTypeId}/{id}")
  @ResponseStatus(OK)
  public void update(
      @PathVariable("entityTypeId") String entityTypeId,
      @PathVariable("id") String untypedId,
      @RequestBody Map<String, Object> entityMap) {
    updateInternal(entityTypeId, untypedId, entityMap);
  }
600084
protected <C extends CrudResponse, T extends UpdateEntity> C handleUpdateEntity(T entity) {
        Map<String, String> uriVariables = restUriVariablesFactory.getUriVariablesForEntityUpdate(
                BullhornEntityInfo.getTypesRestEntityName(entity.getClass()), entity.getId());
        String url = restUrlFactory.assembleEntityUrlForUpdate();

        CrudResponse response;

        try {
            String jsonString = restJsonConverter.convertEntityToJsonString(entity);
            response = this.performPostRequest(url, jsonString, UpdateResponse.class, uriVariables);
        } catch (HttpStatusCodeException error) {
            response = restErrorHandler.handleHttpFourAndFiveHundredErrors(new UpdateResponse(), error, entity.getId());
        }

        return (C) response;
    }
145710
@Override
	public void update(Object entity) {
		if (entity == null) {
			throw new IllegalArgumentException("'entity' must not be [" + entity + "]");
		}
		
		assertTransactional();
		List<Log> logs = transaction.get().logs();
		
		if (logs.isEmpty()) {
			throw new IllegalStateException("Log ["
					+ Log.Operation.UPDATE
					+ "] is not allowed: previous operation must be ["
					+ Log.Operation.GET + "]");
		}
		
		for (int i = logs.size() - 1; i >= 0; i--) {
			Log log = logs.get(i);
			
			if (keyValue(entity).equals(keyValue(log.entity()))) {
				if (log.operation() == Log.Operation.GET) {
					break;
				} else {
					throw new IllegalStateException("Log [" + log.operation() 
							+ "] -> [" + Log.Operation.UPDATE
							+ "] is not allowed: previous operation must be ["
							+ Log.Operation.GET + "]");
				}
			}
		}
		
		Transaction tx = transaction.get().transaction();
		datastore.put(tx, Translation.toEntities(entity));
		Log log = new Log(logs.size() + 1, Log.Operation.UPDATE, entity);
		log.state(State.UNCOMMITTED);
		logs.add(log);
	}
882697
def update(self):
        '''
        
        '''
        self._json = self._request(
            method='GET',
            url=self.API
        )._json
946367
public void update(Entity entity) {
        entityCache.put(entity,
                        false); // false -> we don't store state, meaning it will always be seen as changed
        entity.setUpdated(true);
    }
531822
public function updateApiURL()
    {
        $this->apiURL  = $this->getEvidenceURL();
        $rowIdentifier = $this->getRecordID();
        if (empty($rowIdentifier)) {
            $rowIdentifier = $this->getRecordCode();
            if (empty($rowIdentifier)) {
                $rowIdentifier = $this->getExternalID();
            }
        }
        if (!empty($rowIdentifier)) {
            $this->apiURL .= '/'.self::urlEncode($rowIdentifier);
        }
        $this->apiURL .= '.'.$this->format;
    }
715340
def update(self, eid, entity, note=None):
		
		# fetch the current entity
		newentity = self.get(eid)
		for field in ('createdAtDate', 'id', 'isActive', 'parentRevision', 'revisionNr', 'updatedAtDate', 'updatedByUserName','updatedFromIp'):
			if field in newentity: del newentity[field]

		# replace fields as specified in entity
		for field in entity:
			if field=='metadata':
				for mfield in entity['metadata']:
					newentity['metadata'][mfield] = entity['metadata'][mfield]
			else:
				newentity[field] = entity[field]

		result = self.replace(eid,newentity,note=note)
		return result
612004
@Transactional
  @PostMapping(value = "/{entityTypeId}/{id}", params = "_method=PUT")
  @ResponseStatus(OK)
  public void updatePost(
      @PathVariable("entityTypeId") String entityTypeId,
      @PathVariable("id") String untypedId,
      @RequestBody Map<String, Object> entityMap) {
    updateInternal(entityTypeId, untypedId, entityMap);
  }
654594
public function update($api, $id, array $data = [])
    {
        return $this->checkException($this->callHttpMethod($this->normalizeUri($api, $id), Request::METHOD_PUT, $data));
    }
1035822
public void refresh(Object entity)
    {
        if (contains(entity))
        {
            MainCache mainCache = (MainCache) getPersistenceCache().getMainCache();
            Node node = mainCache.getNodeFromCache(entity, getMetadata(entity.getClass()), this);
            // Locking as it might read from persistence context.

            try
            {
                lock.readLock().lock();
                node.setPersistenceDelegator(this);
                node.refresh();
            }
            finally
            {
                lock.readLock().unlock();
            }
        }
        else
        {
            throw new IllegalArgumentException("This is not a valid or managed entity, can't be refreshed");
        }
    }
688023
def update(object_type, id, data)
      url = generate_rest_url(:update, object_type, id)
      object_name = object_name_for(object_type, :update)
      xml_data = data.to_xml(:root => object_name, :skip_instruct => true, :dasherize => false)
      result = retrieve(url.path, url.method, {'Content-type' => 'application/xml'}, xml_data)
      find_object_in_result(result, object_type, :update)
    end