Create a FactorUpdater to execute update.

@param pathServiceSid Service Sid.
@param pathIdentity Unique identity of the Entity
@param pathSid A string that uniquely identifies this Factor.
@return FactorUpdater capable of executing the update
509646
public static FactorUpdater updater(final String pathServiceSid, 
                                        final String pathIdentity, 
                                        final String pathSid) {
        return new FactorUpdater(pathServiceSid, pathIdentity, pathSid);
    }
148720
public FutureData<PushSubscription> update(String id, PushConnector connector, String name) {
        if (id == null || id.isEmpty() || connector == null) {
            throw new IllegalArgumentException("A push subscription ID and output parameters is required");
        }
        FutureData<PushSubscription> future = new FutureData<>();
        URI uri = newParams().forURL(config.newAPIEndpointURI(UPDATE));
        POST request = config.http()
                .POST(uri, new PageReader(newRequestCallback(future, new PushSubscription(), config)))
                .form("id", id);
        for (Map.Entry<String, String> e : connector.parameters().verifyAndGet().entrySet()) {
            request.form(e.getKey(), e.getValue());
        }
        if (name != null && !name.isEmpty()) {
            request.form("name", name);
        }
        performRequest(future, request);
        return future;
    }
359499
public ActionFuture<UpdateResponse>
    upsertDataASyncWithObjectMapper(Object sourceObject, String index,
            String type, String id) {
        return upsertDataAsync(
                JMElasticsearchUtil.buildSourceByJsonMapper(sourceObject),
                index, type, id);
    }
1178002
public static int getProfileIdFromPathID(int path_id) throws Exception {
        return (Integer) SQLService.getInstance().getFromTable(Constants.GENERIC_PROFILE_ID, Constants.GENERIC_ID, path_id, Constants.DB_TABLE_PATH);
    }
540638
public ActionFuture<UpdateResponse> upsertDataAsync(
            String jsonSource, String index, String type, String id) {
        return upsertQueryAsync(
                buildPrepareUpsert(index, type, id, jsonSource));
    }
925368
public static WorkerChannelUpdater updater(final String pathWorkspaceSid, 
                                               final String pathWorkerSid, 
                                               final String pathSid) {
        return new WorkerChannelUpdater(pathWorkspaceSid, pathWorkerSid, pathSid);
    }
1224697
public static ReservationUpdater updater(final String pathWorkspaceSid, 
                                             final String pathTaskSid, 
                                             final String pathSid) {
        return new ReservationUpdater(pathWorkspaceSid, pathTaskSid, pathSid);
    }
772733
public static FunctionUpdater updater(final String pathServiceSid, 
                                          final String pathSid, 
                                          final String friendlyName) {
        return new FunctionUpdater(pathServiceSid, pathSid, friendlyName);
    }
1171208
@RequestMapping(value = "/pathname/{profileId}/{pathId}", method = RequestMethod.GET)
    public String editPathname(Model model,
                               @PathVariable int pathId, @PathVariable int profileId) throws Exception {
        model.addAttribute("profile_id", profileId);
        model.addAttribute("profile_name", ProfileService.getInstance().getNamefromId(profileId));
        model.addAttribute("endpoint", pathOverrideService.getPath(pathId));
        model.addAttribute("groups_in_path", pathOverrideService.getGroupsInPathProfile(profileId, pathId));
        model.addAttribute("groups_not_in_path", pathOverrideService.getGroupsNotInPathProfile(profileId, pathId));
        return "editPathname";
    }
1210666
public static <I extends Request, O extends Response>
    CompositeServiceEntry<I, O> of(PathMapping pathMapping, Service<I, O> service) {
        return new CompositeServiceEntry<>(pathMapping, service);
    }
994195
public void setName(int pathId, String pathName) {
        PreparedStatement statement = null;
        try (Connection sqlConnection = sqlService.getConnection()) {
            statement = sqlConnection.prepareStatement(
                "UPDATE " + Constants.DB_TABLE_PATH +
                    " SET " + Constants.PATH_PROFILE_PATHNAME + " = ?" +
                    " WHERE " + Constants.GENERIC_ID + " = ?"
            );
            statement.setString(1, pathName);
            statement.setInt(2, pathId);
            statement.executeUpdate();
            statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }
    }
554409
public static SyncMapItemFetcher fetcher(final String pathServiceSid, 
                                             final String pathMapSid, 
                                             final String pathKey) {
        return new SyncMapItemFetcher(pathServiceSid, pathMapSid, pathKey);
    }
1329420
public static base_response update(nitro_service client, appfwprofile resource) throws Exception {
		appfwprofile updateresource = new appfwprofile();
		updateresource.name = resource.name;
		updateresource.starturlaction = resource.starturlaction;
		updateresource.starturlclosure = resource.starturlclosure;
		updateresource.denyurlaction = resource.denyurlaction;
		updateresource.refererheadercheck = resource.refererheadercheck;
		updateresource.cookieconsistencyaction = resource.cookieconsistencyaction;
		updateresource.cookietransforms = resource.cookietransforms;
		updateresource.cookieencryption = resource.cookieencryption;
		updateresource.cookieproxying = resource.cookieproxying;
		updateresource.addcookieflags = resource.addcookieflags;
		updateresource.fieldconsistencyaction = resource.fieldconsistencyaction;
		updateresource.csrftagaction = resource.csrftagaction;
		updateresource.crosssitescriptingaction = resource.crosssitescriptingaction;
		updateresource.crosssitescriptingtransformunsafehtml = resource.crosssitescriptingtransformunsafehtml;
		updateresource.crosssitescriptingcheckcompleteurls = resource.crosssitescriptingcheckcompleteurls;
		updateresource.sqlinjectionaction = resource.sqlinjectionaction;
		updateresource.sqlinjectiontransformspecialchars = resource.sqlinjectiontransformspecialchars;
		updateresource.sqlinjectiononlycheckfieldswithsqlchars = resource.sqlinjectiononlycheckfieldswithsqlchars;
		updateresource.fieldformataction = resource.fieldformataction;
		updateresource.defaultfieldformattype = resource.defaultfieldformattype;
		updateresource.defaultfieldformatminlength = resource.defaultfieldformatminlength;
		updateresource.defaultfieldformatmaxlength = resource.defaultfieldformatmaxlength;
		updateresource.bufferoverflowaction = resource.bufferoverflowaction;
		updateresource.bufferoverflowmaxurllength = resource.bufferoverflowmaxurllength;
		updateresource.bufferoverflowmaxheaderlength = resource.bufferoverflowmaxheaderlength;
		updateresource.bufferoverflowmaxcookielength = resource.bufferoverflowmaxcookielength;
		updateresource.creditcardaction = resource.creditcardaction;
		updateresource.creditcard = resource.creditcard;
		updateresource.creditcardmaxallowed = resource.creditcardmaxallowed;
		updateresource.creditcardxout = resource.creditcardxout;
		updateresource.requestcontenttype = resource.requestcontenttype;
		updateresource.responsecontenttype = resource.responsecontenttype;
		updateresource.xmldosaction = resource.xmldosaction;
		updateresource.xmlformataction = resource.xmlformataction;
		updateresource.xmlsqlinjectionaction = resource.xmlsqlinjectionaction;
		updateresource.xmlsqlinjectiononlycheckfieldswithsqlchars = resource.xmlsqlinjectiononlycheckfieldswithsqlchars;
		updateresource.xmlsqlinjectionparsecomments = resource.xmlsqlinjectionparsecomments;
		updateresource.xmlxssaction = resource.xmlxssaction;
		updateresource.xmlwsiaction = resource.xmlwsiaction;
		updateresource.xmlattachmentaction = resource.xmlattachmentaction;
		updateresource.xmlvalidationaction = resource.xmlvalidationaction;
		updateresource.xmlerrorobject = resource.xmlerrorobject;
		updateresource.customsettings = resource.customsettings;
		updateresource.signatures = resource.signatures;
		updateresource.xmlsoapfaultaction = resource.xmlsoapfaultaction;
		updateresource.usehtmlerrorobject = resource.usehtmlerrorobject;
		updateresource.errorurl = resource.errorurl;
		updateresource.htmlerrorobject = resource.htmlerrorobject;
		updateresource.logeverypolicyhit = resource.logeverypolicyhit;
		updateresource.stripcomments = resource.stripcomments;
		updateresource.striphtmlcomments = resource.striphtmlcomments;
		updateresource.stripxmlcomments = resource.stripxmlcomments;
		updateresource.exemptclosureurlsfromsecuritychecks = resource.exemptclosureurlsfromsecuritychecks;
		updateresource.defaultcharset = resource.defaultcharset;
		updateresource.postbodylimit = resource.postbodylimit;
		updateresource.fileuploadmaxnum = resource.fileuploadmaxnum;
		updateresource.canonicalizehtmlresponse = resource.canonicalizehtmlresponse;
		updateresource.enableformtagging = resource.enableformtagging;
		updateresource.sessionlessfieldconsistency = resource.sessionlessfieldconsistency;
		updateresource.sessionlessurlclosure = resource.sessionlessurlclosure;
		updateresource.semicolonfieldseparator = resource.semicolonfieldseparator;
		updateresource.excludefileuploadfromchecks = resource.excludefileuploadfromchecks;
		updateresource.sqlinjectionparsecomments = resource.sqlinjectionparsecomments;
		updateresource.invalidpercenthandling = resource.invalidpercenthandling;
		updateresource.type = resource.type;
		updateresource.checkrequestheaders = resource.checkrequestheaders;
		updateresource.comment = resource.comment;
		return updateresource.update_resource(client);
	}
415337
public static ReservationFetcher fetcher(final String pathWorkspaceSid, 
                                             final String pathWorkerSid, 
                                             final String pathSid) {
        return new ReservationFetcher(pathWorkspaceSid, pathWorkerSid, pathSid);
    }
151361
protected Credential getKeyEncryptionCredential(final String peerEntityId,
                                                    final SamlRegisteredServiceServiceProviderMetadataFacade adaptor,
                                                    final SamlRegisteredService service) throws Exception {
        val config = DefaultSecurityConfigurationBootstrap.buildDefaultEncryptionConfiguration();

        val overrideDataEncryptionAlgorithms = samlIdPProperties.getAlgs().getOverrideDataEncryptionAlgorithms();
        val overrideKeyEncryptionAlgorithms = samlIdPProperties.getAlgs().getOverrideKeyEncryptionAlgorithms();
        val overrideBlackListedEncryptionAlgorithms = samlIdPProperties.getAlgs().getOverrideBlackListedEncryptionAlgorithms();
        val overrideWhiteListedAlgorithms = samlIdPProperties.getAlgs().getOverrideWhiteListedAlgorithms();

        if (overrideBlackListedEncryptionAlgorithms != null && !overrideBlackListedEncryptionAlgorithms.isEmpty()) {
            config.setBlacklistedAlgorithms(overrideBlackListedEncryptionAlgorithms);
        }

        if (overrideWhiteListedAlgorithms != null && !overrideWhiteListedAlgorithms.isEmpty()) {
            config.setWhitelistedAlgorithms(overrideWhiteListedAlgorithms);
        }

        if (overrideDataEncryptionAlgorithms != null && !overrideDataEncryptionAlgorithms.isEmpty()) {
            config.setDataEncryptionAlgorithms(overrideDataEncryptionAlgorithms);
        }

        if (overrideKeyEncryptionAlgorithms != null && !overrideKeyEncryptionAlgorithms.isEmpty()) {
            config.setKeyTransportEncryptionAlgorithms(overrideKeyEncryptionAlgorithms);
        }

        LOGGER.debug("Encryption blacklisted algorithms: [{}]", config.getBlacklistedAlgorithms());
        LOGGER.debug("Encryption key algorithms: [{}]", config.getKeyTransportEncryptionAlgorithms());
        LOGGER.debug("Signature data algorithms: [{}]", config.getDataEncryptionAlgorithms());
        LOGGER.debug("Encryption whitelisted algorithms: [{}]", config.getWhitelistedAlgorithms());

        val kekCredentialResolver = new MetadataCredentialResolver();

        val providers = new ArrayList<KeyInfoProvider>();
        providers.add(new RSAKeyValueProvider());
        providers.add(new DSAKeyValueProvider());
        providers.add(new InlineX509DataProvider());
        providers.add(new DEREncodedKeyValueProvider());
        providers.add(new KeyInfoReferenceProvider());

        val keyInfoResolver = new BasicProviderKeyInfoCredentialResolver(providers);
        kekCredentialResolver.setKeyInfoCredentialResolver(keyInfoResolver);

        val roleDescriptorResolver = SamlIdPUtils.getRoleDescriptorResolver(adaptor, samlIdPProperties.getMetadata().isRequireValidMetadata());

        kekCredentialResolver.setRoleDescriptorResolver(roleDescriptorResolver);
        kekCredentialResolver.initialize();

        val criteriaSet = new CriteriaSet();
        criteriaSet.add(new EncryptionConfigurationCriterion(config));
        criteriaSet.add(new EntityIdCriterion(peerEntityId));
        criteriaSet.add(new EntityRoleCriterion(SPSSODescriptor.DEFAULT_ELEMENT_NAME));
        criteriaSet.add(new UsageCriterion(UsageType.ENCRYPTION));

        LOGGER.debug("Attempting to resolve the encryption key for entity id [{}]", peerEntityId);
        return kekCredentialResolver.resolveSingle(criteriaSet);
    }
105912
public static base_responses update(nitro_service client, vpnclientlessaccessprofile resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			vpnclientlessaccessprofile updateresources[] = new vpnclientlessaccessprofile[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new vpnclientlessaccessprofile();
				updateresources[i].profilename = resources[i].profilename;
				updateresources[i].urlrewritepolicylabel = resources[i].urlrewritepolicylabel;
				updateresources[i].javascriptrewritepolicylabel = resources[i].javascriptrewritepolicylabel;
				updateresources[i].reqhdrrewritepolicylabel = resources[i].reqhdrrewritepolicylabel;
				updateresources[i].reshdrrewritepolicylabel = resources[i].reshdrrewritepolicylabel;
				updateresources[i].regexforfindingurlinjavascript = resources[i].regexforfindingurlinjavascript;
				updateresources[i].regexforfindingurlincss = resources[i].regexforfindingurlincss;
				updateresources[i].regexforfindingurlinxcomponent = resources[i].regexforfindingurlinxcomponent;
				updateresources[i].regexforfindingurlinxml = resources[i].regexforfindingurlinxml;
				updateresources[i].regexforfindingcustomurls = resources[i].regexforfindingcustomurls;
				updateresources[i].clientconsumedcookies = resources[i].clientconsumedcookies;
				updateresources[i].requirepersistentcookie = resources[i].requirepersistentcookie;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
53674
public static SyncListItemUpdater updater(final String pathServiceSid, 
                                              final String pathListSid, 
                                              final Integer pathIndex) {
        return new SyncListItemUpdater(pathServiceSid, pathListSid, pathIndex);
    }