Builds a new update request using an existing AppProfile.
543352
public static UpdateAppProfileRequest of(
      @Nonnull String instanceId, @Nonnull String appProfileId) {
    return new UpdateAppProfileRequest(
        instanceId,
        appProfileId,
        com.google.bigtable.admin.v2.UpdateAppProfileRequest.newBuilder());
  }
228451
def update(self, app_model, forbidden_keys=None, inverse=False):
        
        if forbidden_keys is None:
            forbidden_keys = []

        update_model(self, app_model, forbidden_keys, inverse)
703345
public static base_response update(nitro_service client, appqoeparameter resource) throws Exception {
		appqoeparameter updateresource = new appqoeparameter();
		updateresource.sessionlife = resource.sessionlife;
		updateresource.avgwaitingclient = resource.avgwaitingclient;
		updateresource.maxaltrespbandwidth = resource.maxaltrespbandwidth;
		updateresource.dosattackthresh = resource.dosattackthresh;
		return updateresource.update_resource(client);
	}
920773
function update(req, res, next) {
  var params = {
    appId: req.params.id || req.body._id,
    forms: req.body.forms || []
  };
  forms.updateAppForms(req.connectionOptions, params, formsResultHandlers(constants.resultTypes.formProjects, req, next));
}
122954
public static base_responses update(nitro_service client, appfwlearningsettings resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			appfwlearningsettings updateresources[] = new appfwlearningsettings[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new appfwlearningsettings();
				updateresources[i].profilename = resources[i].profilename;
				updateresources[i].starturlminthreshold = resources[i].starturlminthreshold;
				updateresources[i].starturlpercentthreshold = resources[i].starturlpercentthreshold;
				updateresources[i].cookieconsistencyminthreshold = resources[i].cookieconsistencyminthreshold;
				updateresources[i].cookieconsistencypercentthreshold = resources[i].cookieconsistencypercentthreshold;
				updateresources[i].csrftagminthreshold = resources[i].csrftagminthreshold;
				updateresources[i].csrftagpercentthreshold = resources[i].csrftagpercentthreshold;
				updateresources[i].fieldconsistencyminthreshold = resources[i].fieldconsistencyminthreshold;
				updateresources[i].fieldconsistencypercentthreshold = resources[i].fieldconsistencypercentthreshold;
				updateresources[i].crosssitescriptingminthreshold = resources[i].crosssitescriptingminthreshold;
				updateresources[i].crosssitescriptingpercentthreshold = resources[i].crosssitescriptingpercentthreshold;
				updateresources[i].sqlinjectionminthreshold = resources[i].sqlinjectionminthreshold;
				updateresources[i].sqlinjectionpercentthreshold = resources[i].sqlinjectionpercentthreshold;
				updateresources[i].fieldformatminthreshold = resources[i].fieldformatminthreshold;
				updateresources[i].fieldformatpercentthreshold = resources[i].fieldformatpercentthreshold;
				updateresources[i].xmlwsiminthreshold = resources[i].xmlwsiminthreshold;
				updateresources[i].xmlwsipercentthreshold = resources[i].xmlwsipercentthreshold;
				updateresources[i].xmlattachmentminthreshold = resources[i].xmlattachmentminthreshold;
				updateresources[i].xmlattachmentpercentthreshold = resources[i].xmlattachmentpercentthreshold;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
1346641
def new(self, name=None, stack='cedar', region=None):
        """"""

        payload = {}

        if name:
            payload['app[name]'] = name

        if stack:
            payload['app[stack]'] = stack

        if region:
            payload['app[region]'] = region

        r = self._h._http_resource(
            method='POST',
            resource=('apps',),
            data=payload
        )

        name = json.loads(r.content).get('name')
        return self._h.apps.get(name)
708337
function onUpdateProfile() {
  var displayName = $('#display-name').val();
  var photoURL = $('#photo-url').val();
  activeUser().updateProfile({
    'displayName': displayName,
    'photoURL': photoURL
  }).then(function() {
    refreshUserData();
    alertSuccess('Profile updated!');
  }, onAuthError);
}
468897
def request_run():
    """"""
    build = g.build
    current_release, current_run = _get_or_create_run(build)

    current_url = request.form.get('url', type=str)
    config_data = request.form.get('config', default='{}', type=str)
    utils.jsonify_assert(current_url, 'url to capture required')
    utils.jsonify_assert(config_data, 'config document required')

    config_artifact = _enqueue_capture(
        build, current_release, current_run, current_url, config_data)

    ref_url = request.form.get('ref_url', type=str)
    ref_config_data = request.form.get('ref_config', type=str)
    utils.jsonify_assert(
        bool(ref_url) == bool(ref_config_data),
        'ref_url and ref_config must both be specified or not specified')

    if ref_url and ref_config_data:
        ref_config_artifact = _enqueue_capture(
            build, current_release, current_run, ref_url, ref_config_data,
            baseline=True)
    else:
        _, last_good_run = _find_last_good_run(build)
        if last_good_run:
            current_run.ref_url = last_good_run.url
            current_run.ref_image = last_good_run.image
            current_run.ref_log = last_good_run.log
            current_run.ref_config = last_good_run.config

    db.session.add(current_run)
    db.session.commit()

    signals.run_updated_via_api.send(
        app, build=build, release=current_release, run=current_run)

    return flask.jsonify(
        success=True,
        build_id=build.id,
        release_name=current_release.name,
        release_number=current_release.number,
        run_name=current_run.name,
        url=current_run.url,
        config=current_run.config,
        ref_url=current_run.ref_url,
        ref_config=current_run.ref_config)
179340
public static Response getBatchUpdateResponse(App app, Map<String, ParaObject> oldObjects,
			List<Map<String, Object>> newProperties) {
		try (final Metrics.Context context = Metrics.time(app == null ? null : app.getAppid(),
				RestUtils.class, "batch", "update")) {
			if (app != null && oldObjects != null && newProperties != null) {
				LinkedList<ParaObject> updatedObjects = new LinkedList<>();
				boolean hasPositiveVersions = false;
				for (Map<String, Object> newProps : newProperties) {
					if (newProps != null && newProps.containsKey(Config._ID)) {
						ParaObject oldObject = oldObjects.get((String) newProps.get(Config._ID));
						// updating apps in batch is not allowed
						if (oldObject != null && checkImplicitAppPermissions(app, oldObject)) {
							ParaObject updatedObject = ParaObjectUtils.setAnnotatedFields(oldObject, newProps, Locked.class);
							if (isValidObject(app, updatedObject) && checkIfUserCanModifyObject(app, updatedObject)) {
								updatedObject.setAppid(app.getAppIdentifier());
								updatedObjects.add(updatedObject);
								if (updatedObject.getVersion() != null && updatedObject.getVersion() > 0) {
									hasPositiveVersions = true;
								}
							}
						}
					}
				}
				Para.getDAO().updateAll(app.getAppIdentifier(), updatedObjects);
				// check if any or all updates failed due to optimistic locking
				return handleFailedUpdates(hasPositiveVersions, updatedObjects);
			} else {
				return getStatusResponse(Response.Status.BAD_REQUEST);
			}
		}
	}
1321160
def add_or_update(user_id, app_id, value):
        '''
        
        '''
        rec = MEvaluation.get_by_signature(user_id, app_id)
        if rec:
            entry = TabEvaluation.update(
                value=value,
            ).where(TabEvaluation.uid == rec.uid)
            entry.execute()
        else:
            TabEvaluation.create(
                uid=tools.get_uuid(),
                user_id=user_id,
                post_id=app_id,
                value=value,
            )
1331745
public static base_response update(nitro_service client, authenticationauthnprofile resource) throws Exception {
		authenticationauthnprofile updateresource = new authenticationauthnprofile();
		updateresource.name = resource.name;
		updateresource.authnvsname = resource.authnvsname;
		updateresource.authenticationhost = resource.authenticationhost;
		updateresource.authenticationdomain = resource.authenticationdomain;
		updateresource.authenticationlevel = resource.authenticationlevel;
		return updateresource.update_resource(client);
	}
1301706
def upgrade(self, name, params=None):
        """"""
        # Allow non-namespaced upgrades. (e.g. advanced vs logging:advanced)
        if ':' not in name:
            name = '{0}:{1}'.format(self.type, name)

        r = self._h._http_resource(
            method='PUT',
            resource=('apps', self.app.name, 'addons', quote(name)),
            params=params,
            data=' '   # Server weirdness.
        )
        r.raise_for_status()
        return self.app.addons[name]
657259
public static base_response update(nitro_service client, appfwconfidfield resource) throws Exception {
		appfwconfidfield updateresource = new appfwconfidfield();
		updateresource.fieldname = resource.fieldname;
		updateresource.url = resource.url;
		updateresource.comment = resource.comment;
		updateresource.state = resource.state;
		return updateresource.update_resource(client);
	}
1161892
public static base_response update(nitro_service client, appflowparam resource) throws Exception {
		appflowparam updateresource = new appflowparam();
		updateresource.templaterefresh = resource.templaterefresh;
		updateresource.appnamerefresh = resource.appnamerefresh;
		updateresource.flowrecordinterval = resource.flowrecordinterval;
		updateresource.udppmtu = resource.udppmtu;
		updateresource.httpurl = resource.httpurl;
		updateresource.aaausername = resource.aaausername;
		updateresource.httpcookie = resource.httpcookie;
		updateresource.httpreferer = resource.httpreferer;
		updateresource.httpmethod = resource.httpmethod;
		updateresource.httphost = resource.httphost;
		updateresource.httpuseragent = resource.httpuseragent;
		updateresource.clienttrafficonly = resource.clienttrafficonly;
		updateresource.httpcontenttype = resource.httpcontenttype;
		updateresource.httpauthorization = resource.httpauthorization;
		updateresource.httpvia = resource.httpvia;
		updateresource.httpxforwardedfor = resource.httpxforwardedfor;
		updateresource.httplocation = resource.httplocation;
		updateresource.httpsetcookie = resource.httpsetcookie;
		updateresource.httpsetcookie2 = resource.httpsetcookie2;
		updateresource.connectionchaining = resource.connectionchaining;
		return updateresource.update_resource(client);
	}
1201221
func (ac *APIController) AppProfileUpdate(oldProf, newProf *contivModel.AppProfile) error {
	log.Infof("Received AppProfileUpdate: %+v, newProf: %+v", oldProf, newProf)

	// handle any epg addition
	for _, epg := range newProf.EndpointGroups {
		epgKey := newProf.TenantName + ":" + epg
		log.Infof("Add %s to %s", epgKey, newProf.AppProfileName)
		epgObj := contivModel.FindEndpointGroup(epgKey)
		if epgObj == nil {
			return core.Errorf("EndpointGroup %s not found", epgKey)
		}
		modeldb.AddLinkSet(&newProf.LinkSets.EndpointGroups, epgObj)

		// workaround for objdb update problem
		modeldb.AddLinkSet(&oldProf.LinkSets.EndpointGroups, epgObj)

		modeldb.AddLink(&epgObj.Links.AppProfile, newProf)
		err := epgObj.Write()
		if err != nil {
			log.Errorf("Error updating epg state(%+v). Err: %v", epgObj, err)
			return err
		}
	}

	// handle any epg removal
	for _, epg := range oldProf.EndpointGroups {
		if !stringInSlice(epg, newProf.EndpointGroups) {
			epgKey := newProf.TenantName + ":" + epg
			log.Infof("Remove %s from %s", epgKey, newProf.AppProfileName)
			epgObj := contivModel.FindEndpointGroup(epgKey)
			if epgObj == nil {
				return core.Errorf("EndpointGroup %s not found", epgKey)
			}
			modeldb.RemoveLink(&epgObj.Links.AppProfile, oldProf)
			err := epgObj.Write()
			if err != nil {
				log.Errorf("Error updating epg state(%+v). Err: %v",
					epgObj, err)
				return err
			}

			// workaround for objdb update problem
			modeldb.RemoveLinkSet(&oldProf.LinkSets.EndpointGroups, epgObj)
		}
	}

	// workaround for objdb update problem -- should fix model
	oldProf.EndpointGroups = newProf.EndpointGroups

	// update the app nw
	DeleteAppNw(oldProf)
	lErr := CreateAppNw(oldProf)
	return lErr
}
528486
def project_update(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/update' % object_id, input_params, always_retry=always_retry, **kwargs)
678775
public static base_response add(nitro_service client, appfwprofile resource) throws Exception {
		appfwprofile addresource = new appfwprofile();
		addresource.name = resource.name;
		addresource.defaults = resource.defaults;
		addresource.starturlaction = resource.starturlaction;
		addresource.starturlclosure = resource.starturlclosure;
		addresource.denyurlaction = resource.denyurlaction;
		addresource.refererheadercheck = resource.refererheadercheck;
		addresource.cookieconsistencyaction = resource.cookieconsistencyaction;
		addresource.cookietransforms = resource.cookietransforms;
		addresource.cookieencryption = resource.cookieencryption;
		addresource.cookieproxying = resource.cookieproxying;
		addresource.addcookieflags = resource.addcookieflags;
		addresource.fieldconsistencyaction = resource.fieldconsistencyaction;
		addresource.csrftagaction = resource.csrftagaction;
		addresource.crosssitescriptingaction = resource.crosssitescriptingaction;
		addresource.crosssitescriptingtransformunsafehtml = resource.crosssitescriptingtransformunsafehtml;
		addresource.crosssitescriptingcheckcompleteurls = resource.crosssitescriptingcheckcompleteurls;
		addresource.sqlinjectionaction = resource.sqlinjectionaction;
		addresource.sqlinjectiontransformspecialchars = resource.sqlinjectiontransformspecialchars;
		addresource.sqlinjectiononlycheckfieldswithsqlchars = resource.sqlinjectiononlycheckfieldswithsqlchars;
		addresource.fieldformataction = resource.fieldformataction;
		addresource.defaultfieldformattype = resource.defaultfieldformattype;
		addresource.defaultfieldformatminlength = resource.defaultfieldformatminlength;
		addresource.defaultfieldformatmaxlength = resource.defaultfieldformatmaxlength;
		addresource.bufferoverflowaction = resource.bufferoverflowaction;
		addresource.bufferoverflowmaxurllength = resource.bufferoverflowmaxurllength;
		addresource.bufferoverflowmaxheaderlength = resource.bufferoverflowmaxheaderlength;
		addresource.bufferoverflowmaxcookielength = resource.bufferoverflowmaxcookielength;
		addresource.creditcardaction = resource.creditcardaction;
		addresource.creditcard = resource.creditcard;
		addresource.creditcardmaxallowed = resource.creditcardmaxallowed;
		addresource.creditcardxout = resource.creditcardxout;
		addresource.requestcontenttype = resource.requestcontenttype;
		addresource.responsecontenttype = resource.responsecontenttype;
		addresource.xmldosaction = resource.xmldosaction;
		addresource.xmlformataction = resource.xmlformataction;
		addresource.xmlsqlinjectionaction = resource.xmlsqlinjectionaction;
		addresource.xmlsqlinjectiononlycheckfieldswithsqlchars = resource.xmlsqlinjectiononlycheckfieldswithsqlchars;
		addresource.xmlsqlinjectionparsecomments = resource.xmlsqlinjectionparsecomments;
		addresource.xmlxssaction = resource.xmlxssaction;
		addresource.xmlwsiaction = resource.xmlwsiaction;
		addresource.xmlattachmentaction = resource.xmlattachmentaction;
		addresource.xmlvalidationaction = resource.xmlvalidationaction;
		addresource.xmlerrorobject = resource.xmlerrorobject;
		addresource.customsettings = resource.customsettings;
		addresource.signatures = resource.signatures;
		addresource.xmlsoapfaultaction = resource.xmlsoapfaultaction;
		addresource.usehtmlerrorobject = resource.usehtmlerrorobject;
		addresource.errorurl = resource.errorurl;
		addresource.htmlerrorobject = resource.htmlerrorobject;
		addresource.logeverypolicyhit = resource.logeverypolicyhit;
		addresource.stripcomments = resource.stripcomments;
		addresource.striphtmlcomments = resource.striphtmlcomments;
		addresource.stripxmlcomments = resource.stripxmlcomments;
		addresource.exemptclosureurlsfromsecuritychecks = resource.exemptclosureurlsfromsecuritychecks;
		addresource.defaultcharset = resource.defaultcharset;
		addresource.postbodylimit = resource.postbodylimit;
		addresource.fileuploadmaxnum = resource.fileuploadmaxnum;
		addresource.canonicalizehtmlresponse = resource.canonicalizehtmlresponse;
		addresource.enableformtagging = resource.enableformtagging;
		addresource.sessionlessfieldconsistency = resource.sessionlessfieldconsistency;
		addresource.sessionlessurlclosure = resource.sessionlessurlclosure;
		addresource.semicolonfieldseparator = resource.semicolonfieldseparator;
		addresource.excludefileuploadfromchecks = resource.excludefileuploadfromchecks;
		addresource.sqlinjectionparsecomments = resource.sqlinjectionparsecomments;
		addresource.invalidpercenthandling = resource.invalidpercenthandling;
		addresource.type = resource.type;
		addresource.checkrequestheaders = resource.checkrequestheaders;
		addresource.comment = resource.comment;
		return addresource.add_resource(client);
	}