POST /payment-requests
422186
def payment_request(options, &block)
      set_options(options, &block)
      post('payment-requests', options)
      @response.success? ? Instamojo::PaymentRequest.new(@response.body[:payment_request], self) : @response
    end
500303
def post(self, url, data, headers=None):
        
        return self._request('POST', url, data, headers=headers)
349093
def post(self, request, data=None):
        
        headers = {"Authorization": "Bearer " + self.token }
        logging.debug(json.dumps(data, indent=4))
        p = requests.post(self.url + request, headers=headers, data=json.dumps(data))
        return json.loads(p.text)
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
1134298
def payment_transaction_to_request(payment_transaction)
      request_fields = {}

      request_fields_definition.each do |field_name, property_path, _|
        field_value = PropertyAccessor.get_value payment_transaction, property_path

        if field_value
          request_fields[field_name] = field_value
        end
      end

      Request.new request_fields
    end
412184
def post(self, endpoint, params=None, version='1.1', json_encoded=False):
        """"""
        return self.request(endpoint, 'POST', params=params, version=version, json_encoded=json_encoded)
1301358
def post_request(path, options = {}, &block)
      loop do
        response = self.class.post(path, options, &block)

        if response.code == 400 && response.body =~ /Load in progress/
          # We can't send data too fast, when the previous request is still loaded we
          # have to wait so sleep 10 seconds and try again
          sleep(10)
        elsif response.code == 200
          return
        else
          raise('Bad Post')
        end
      end
    end
692683
public void order_orderId_pay_POST(Long orderId, OvhPayWithPaymentMethod paymentMethod) throws IOException {
		String qPath = "/me/order/{orderId}/pay";
		StringBuilder sb = path(qPath, orderId);
		HashMap<String, Object>o = new HashMap<String, Object>();
		addBody(o, "paymentMethod", paymentMethod);
		exec(qPath, "POST", sb.toString(), o);
	}
438440
def payment(*params, &block)
      options = {:query => {}}
      options[:query] = params[0] if params.length > 0
      response = self.class.post '/projects/jobs', options
      yield(response) if block_given?
      response
    end
1290356
def post(self, url, data=None, files=None, headers=None, raw=False,
             send_as_json=True, content_type=None, **request_kwargs):
        

        return self._secure_request(
            url, 'post', data=data, files=files, headers=headers, raw=raw,
            send_as_json=send_as_json, content_type=content_type,
            **request_kwargs
        )
508198
def _request(self, data):
        """"""
        return requests.post(self.endpoint, data=data.encode("ascii")).content
332287
def requests_post(url, data=None, json=None, **kwargs):
    """"""
    return requests_request('post', url, data=data, json=json, **kwargs)
488123
def post(self, uri_relative, request_bytes, custom_headers):
        

        return self._request(
            self._METHOD_POST,
            uri_relative,
            request_bytes,
            {},
            custom_headers
        )
1076026
def create_request(payment_transaction)
      request = super payment_transaction

      payment_transaction.payment.status  = payment_status
      payment_transaction.processor_type  = PaymentTransaction::PROCESSOR_QUERY
      payment_transaction.processor_name  = @api_method
      payment_transaction.status          = PaymentTransaction::STATUS_PROCESSING

      request
    end
1291881
def make_request(self, session, url, **kwargs):
        
        log.debug('Making request: POST %s %s' % (url, kwargs))
        return session.post(url, **kwargs)
604370
protected function submitPayment()
    {
        $this->data_token = $this->controller->getPosted('stripeToken', '', true, 'string');

        if (!empty($this->data_token)) {

            $params = array(
                'token' => $this->data_token,
                'currency' => $this->data_order['currency'],
                'amount' => $this->data_order['total_formatted_number']
            );

            $gateway = $this->getGateway();
            $gateway->setApiKey($this->getSecretKey());
            $this->response = $gateway->purchase($params)->send();
            $this->processResponse();
        }
    }
1205686
def do_POST(self):  # pylint: disable=g-bad-name
    """"""
    self._IncrementActiveCount()
    try:
      if self.path.startswith("/upload"):
        stats_collector_instance.Get().IncrementCounter(
            "frontend_http_requests", fields=["upload", "http"])

        logging.error("Requested no longer supported file upload through HTTP.")
        self.Send("File upload though HTTP is no longer supported", status=404)
      else:
        stats_collector_instance.Get().IncrementCounter(
            "frontend_http_requests", fields=["control", "http"])
        self.Control()

    except Exception as e:  # pylint: disable=broad-except
      if flags.FLAGS.pdb_post_mortem:
        pdb.post_mortem()

      logging.exception("Had to respond with status 500.")
      self.Send("Error: %s" % e, status=500)
    finally:
      self._DecrementActiveCount()