Create POST method with list of parameters
@param path Resource path, relative to repository baseURL
@param params Query parameters
@return PUT method
358923
public HttpPost createPostMethod(final String path, final Map<String, List<String>> params) {
        return new HttpPost(repositoryURL + path + queryString(params));
    }
85103
def post(path, params)
      headers = {}

      request('POST', path, params.to_json, headers) do |resp|
        yield(resp) if block_given?
      end
    end
767403
protected function post(string $path, array $params = [], array $headers = [])
    {
        $body = self::createJsonBody($params);

        if ($body) {
            $headers = self::addJsonContentType($headers);
        }

        return $this->postRaw($path, $body, $headers);
    }
354854
def add_put(self, path: str, handler: _WebHandler,
                **kwargs: Any) -> AbstractRoute:
        
        return self.add_route(hdrs.METH_PUT, path, handler, **kwargs)
817769
def post(path, params = {})
      headers = params.values.any? { |value| value.respond_to?(:to_io) } ? request_headers(:post, path, params, {}) : request_headers(:post, path, params)
      request(:post, path, params.to_json, headers)
    end
909911
public static function createFromPath(
        $path,
        $method = 'GET',
        $query = [],
        $post = []
    ) {
        $request = new ServerRequest(
            [],
            [],
            new Uri($path),
            $method ?: 'GET',
            'php://input',
            []
        );

        return $request
            ->withQueryParams($query)
            ->withParsedBody($post);
    }
336366
public function post($path, $parameters)
    {
        $request = $this->getRequest(static::HTTP_POST, $path, $parameters);

        return $this->sendRequest($request);
    }
1189140
def PUT(self, rest_path_list, **kwargs):
        
        fields = kwargs.pop("fields", None)
        if fields is not None:
            return self._send_mmp_stream("PUT", rest_path_list, fields, **kwargs)
        else:
            return self._request("PUT", rest_path_list, **kwargs)
1148657
def post_resource(self, path, body=None, json=None):
        
        url = '%s%s' % (path, self._param_list())
        headers = {
            'Accept': 'application/json;odata=minimalmetadata'
        }

        if json:
            headers['Content-Type'] = 'application/json'
            body = json_dumps(json)

        response = O365_DAO().postURL(self._url(url), headers, body)

        if not (response.status == 200 or response.status == 201 or
                response.status == 204):
            raise DataFailureException(url, response.status, response.data)

        return json_loads(response.data)
1052375
protected Postcard build(String path, String group) {
        if (TextUtils.isEmpty(path) || TextUtils.isEmpty(group)) {
            throw new HandlerException(Consts.TAG + "Parameter is invalid!");
        } else {
            PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
            if (null != pService) {
                path = pService.forString(path);
            }
            return new Postcard(path, group);
        }
    }
1084537
public HttpPut createContentPutMethod(final String path, final Map<String, List<String>> params,
                                          final FedoraContent content ) {
        String contentPath = path;
        if ( content != null && content.getChecksum() != null ) {
            contentPath += "?checksum=" + content.getChecksum();
        }

        final HttpPut put = createPutMethod( contentPath, params );

        // content stream
        if ( content != null ) {
            put.setEntity( new InputStreamEntity(content.getContent()) );
        }

        // filename
        if ( content != null && content.getFilename() != null ) {
            put.setHeader("Content-Disposition", "attachment; filename=\"" + content.getFilename() + "\"" );
        }

        // content type
        if ( content != null && content.getContentType() != null ) {
            put.setHeader("Content-Type", content.getContentType() );
        }

        return put;
    }
893272
public function put($path, $parameters = null, $version = null, $etag = null)
        {
            return $this->api('PUT', $path, $parameters, $version, $etag);
        }
824771
public String post(final String path, final byte[] jsonBytes) throws IOException, HttpException {
		return post(path, jsonBytes, false);
	}
1178958
public function post($path, $params)
    {
        $idempotencyKey = uniqid("", true);
        $paramsWithHeaders = array("headers" => array("Idempotency-Key" => $idempotencyKey));
        $params = array_replace_recursive($paramsWithHeaders, $params);

        $response = $this->http_client->request('POST', $path, $params);

        $this->handleErrors($response);
        return $response;
    }
643351
public function post($path, $params = []){
        $json = json_encode($params);
        
        return $this->_call('POST', $path, $json);
    }
1341210
def put(path, options={}, raw=false, unformatted=true)
      request(:put, path, options, raw, unformatted)
    end
1348766
def put(query_url,
            headers: {},
            parameters: {})
      HttpRequest.new(HttpMethodEnum::PUT,
                      query_url,
                      headers: headers,
                      parameters: parameters)
    end