Request.php
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Tue, Nov 26, 06:41

Request.php
View Options

	<?php

	namespace Httpful;

	use Httpful\Exception\ConnectionErrorException;

	/**
	* Clean, simple class for sending HTTP requests
	* in PHP.
	*
	* There is an emphasis of readability without loosing concise
	* syntax. As such, you will notice that the library lends
	* itself very nicely to "chaining". You will see several "alias"
	* methods: more readable method definitions that wrap
	* their more concise counterparts. You will also notice
	* no public constructor. This two adds to the readability
	* and "chainabilty" of the library.
	*
	* @author Nate Good <me@nategood.com>
	*/
	class Request
	{

	// Option constants
	const SERIALIZE_PAYLOAD_NEVER = 0;
	const SERIALIZE_PAYLOAD_ALWAYS = 1;
	const SERIALIZE_PAYLOAD_SMART = 2;

	const MAX_REDIRECTS_DEFAULT = 25;

	public $uri,
	$method = Http::GET,
	$headers = array(),
	$raw_headers = '',
	$strict_ssl = false,
	$content_type,
	$expected_type,
	$additional_curl_opts = array(),
	$auto_parse = true,
	$serialize_payload_method = self::SERIALIZE_PAYLOAD_SMART,
	$username,
	$password,
	$serialized_payload,
	$payload,
	$parse_callback,
	$error_callback,
	$follow_redirects = false,
	$max_redirects = self::MAX_REDIRECTS_DEFAULT,
	$payload_serializers = array();

	// Options
	// private $_options = array(
	// 'serialize_payload_method' => self::SERIALIZE_PAYLOAD_SMART
	// 'auto_parse' => true
	// );

	// Curl Handle
	public $_ch,
	$_debug;

	// Template Request object
	private static $_template;

	/**
	* We made the constructor private to force the factory style. This was
	* done to keep the syntax cleaner and better the support the idea of
	* "default templates". Very basic and flexible as it is only intended
	* for internal use.
	* @param array $attrs hash of initial attribute values
	*/
	private function __construct($attrs = null)
	{
	if (!is_array($attrs)) return;
	foreach ($attrs as $attr => $value) {
	$this->$attr = $value;
	}
	}

	// Defaults Management

	/**
	* Let's you configure default settings for this
	* class from a template Request object. Simply construct a
	* Request object as much as you want to and then pass it to
	* this method. It will then lock in those settings from
	* that template object.
	* The most common of which may be default mime
	* settings or strict ssl settings.
	* Again some slight memory overhead incurred here but in the grand
	* scheme of things as it typically only occurs once
	* @param Request $template
	*/
	public static function ini(Request $template)
	{
	self::$_template = clone $template;
	}

	/**
	* Reset the default template back to the
	* library defaults.
	*/
	public static function resetIni()
	{
	self::_initializeDefaults();
	}

	/**
	* Get default for a value based on the template object
	* @return mixed default value
	* @param string\|null $attr Name of attribute (e.g. mime, headers)
	* if null just return the whole template object;
	*/
	public static function d($attr)
	{
	return isset($attr) ? self::$_template->$attr : self::$_template;
	}

	// Accessors

	/**
	* @return bool does the request have a timeout?
	*/
	public function hasTimeout()
	{
	return isset($this->timeout);
	}

	/**
	* @return bool has the internal curl request been initialized?
	*/
	public function hasBeenInitialized()
	{
	return isset($this->_ch);
	}

	/**
	* @return bool Is this request setup for basic auth?
	*/
	public function hasBasicAuth()
	{
	return isset($this->password) && isset($this->username);
	}

	/**
	* @return bool Is this request setup for digest auth?
	*/
	public function hasDigestAuth()
	{
	return isset($this->password) && isset($this->username) && $this->additional_curl_opts['CURLOPT_HTTPAUTH'] = CURLAUTH_DIGEST;
	}

	/**
	* Specify a HTTP timeout
	* @return Request $this
	* @param \|int $timeout seconds to timeout the HTTP call
	*/
	public function timeout($timeout)
	{
	$this->timeout = $timeout;
	return $this;
	}

	/**
	* If the response is a 301 or 302 redirect, automatically
	* send off another request to that location
	* @return Request $this
	* @param bool\|int $follow follow or not to follow or maximal number of redirects
	*/
	public function followRedirects($follow = true)
	{
	$this->max_redirects = $follow === true ? self::MAX_REDIRECTS_DEFAULT : max(0, $follow);
	$this->follow_redirects = (bool) $follow;
	return $this;
	}

	/**
	* @return Request $this
	* @see Request::followRedirects()
	*/
	public function doNotFollowRedirects()
	{
	return $this->followRedirects(false);
	}

	/**
	* Actually send off the request, and parse the response
	* @return string\|associative array of parsed results
	* @throws ConnectionErrorException when unable to parse or communicate w server
	*/
	public function send()
	{
	if (!$this->hasBeenInitialized())
	$this->_curlPrep();

	$result = curl_exec($this->_ch);

	if ($result === false) {
	$this->_error(curl_error($this->_ch));
	throw new ConnectionErrorException('Unable to connect.');
	}

	$info = curl_getinfo($this->_ch);
	$response = explode("\r\n\r\n", $result, 2 + $info['redirect_count']);

	$body = array_pop($response);
	$headers = array_pop($response);

	return new Response($body, $headers, $this);
	}
	public function sendIt()
	{
	return $this->send();
	}

	// Setters

	/**
	* @return Request this
	* @param string $uri
	*/
	public function uri($uri)
	{
	$this->uri = $uri;
	return $this;
	}

	/**
	* User Basic Auth.
	* Only use when over SSL/TSL/HTTPS.
	* @return Request this
	* @param string $username
	* @param string $password
	*/
	public function basicAuth($username, $password)
	{
	$this->username = $username;
	$this->password = $password;
	return $this;
	}
	// @alias of basicAuth
	public function authenticateWith($username, $password)
	{
	return $this->basicAuth($username, $password);
	}
	// @alias of basicAuth
	public function authenticateWithBasic($username, $password)
	{
	return $this->basicAuth($username, $password);
	}

	/**
	* User Digest Auth.
	* @return Request this
	* @param string $username
	* @param string $password
	*/
	public function digestAuth($username, $password)
	{
	$this->addOnCurlOption(CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
	return $this->basicAuth($username, $password);
	}

	// @alias of digestAuth
	public function authenticateWithDigest($username, $password)
	{
	return $this->digestAuth($username, $password);
	}

	/**
	* @return is this request setup for client side cert?
	*/
	public function hasClientSideCert() {
	return isset($this->client_cert) && isset($this->client_key);
	}

	/**
	* Use Client Side Cert Authentication
	* @return Response $this
	* @param string $key file path to client key
	* @param string $cert file path to client cert
	* @param string $passphrase for client key
	* @param string $encoding default PEM
	*/
	public function clientSideCert($cert, $key, $passphrase = null, $encoding = 'PEM')
	{
	$this->client_cert = $cert;
	$this->client_key = $key;
	$this->client_passphrase = $passphrase;
	$this->client_encoding = $encoding;

	return $this;
	}
	// @alias of basicAuth
	public function authenticateWithCert($cert, $key, $passphrase = null, $encoding = 'PEM')
	{
	return $this->clientSideCert($cert, $key, $passphrase, $encoding);
	}

	/**
	* Set the body of the request
	* @return Request this
	* @param mixed $payload
	* @param string $mimeType
	*/
	public function body($payload, $mimeType = null)
	{
	$this->mime($mimeType);
	$this->payload = $payload;
	// Iserntentially don't call _serializePayload yet. Wait until
	// we actually send off the request to convert payload to string.
	// At that time, the `serialized_payload` is set accordingly.
	return $this;
	}

	/**
	* Helper function to set the Content type and Expected as same in
	* one swoop
	* @return Request this
	* @param string $mime mime type to use for content type and expected return type
	*/
	public function mime($mime)
	{
	if (empty($mime)) return $this;
	$this->content_type = $this->expected_type = Mime::getFullMime($mime);
	return $this;
	}
	// @alias of mime
	public function sendsAndExpectsType($mime)
	{
	return $this->mime($mime);
	}
	// @alias of mime
	public function sendsAndExpects($mime)
	{
	return $this->mime($mime);
	}

	/**
	* Set the method. Shouldn't be called often as the preferred syntax
	* for instantiation is the method specific factory methods.
	* @return Request this
	* @param string $method
	*/
	public function method($method)
	{
	if (empty($method)) return $this;
	$this->method = $method;
	return $this;
	}

	/**
	* @return Request this
	* @param string $mime
	*/
	public function expects($mime)
	{
	if (empty($mime)) return $this;
	$this->expected_type = Mime::getFullMime($mime);
	return $this;
	}
	// @alias of expects
	public function expectsType($mime)
	{
	return $this->expects($mime);
	}

	/**
	* @return Request this
	* @param string $mime
	*/
	public function contentType($mime)
	{
	if (empty($mime)) return $this;
	$this->content_type = Mime::getFullMime($mime);
	return $this;
	}
	// @alias of contentType
	public function sends($mime)
	{
	return $this->contentType($mime);
	}
	// @alias of contentType
	public function sendsType($mime)
	{
	return $this->contentType($mime);
	}

	/**
	* Do we strictly enforce SSL verification?
	* @return Request this
	* @param bool $strict
	*/
	public function strictSSL($strict)
	{
	$this->strict_ssl = $strict;
	return $this;
	}
	public function withoutStrictSSL()
	{
	return $this->strictSSL(false);
	}
	public function withStrictSSL()
	{
	return $this->strictSSL(true);
	}

	/**
	* Determine how/if we use the built in serialization by
	* setting the serialize_payload_method
	* The default (SERIALIZE_PAYLOAD_SMART) is...
	* - if payload is not a scalar (object/array)
	* use the appropriate serialize method according to
	* the Content-Type of this request.
	* - if the payload IS a scalar (int, float, string, bool)
	* than just return it as is.
	* When this option is set SERIALIZE_PAYLOAD_ALWAYS,
	* it will always use the appropriate
	* serialize option regardless of whether payload is scalar or not
	* When this option is set SERIALIZE_PAYLOAD_NEVER,
	* it will never use any of the serialization methods.
	* Really the only use for this is if you want the serialize methods
	* to handle strings or not (e.g. Blah is not valid JSON, but "Blah"
	* is). Forcing the serialization helps prevent that kind of error from
	* happening.
	* @return Request $this
	* @param int $mode
	*/
	public function serializePayload($mode)
	{
	$this->serialize_payload_method = $mode;
	return $this;
	}

	/**
	* @see Request::serializePayload()
	* @return Request
	*/
	public function neverSerializePayload()
	{
	return $this->serializePayload(self::SERIALIZE_PAYLOAD_NEVER);
	}

	/**
	* This method is the default behavior
	* @see Request::serializePayload()
	* @return Request
	*/
	public function smartSerializePayload()
	{
	return $this->serializePayload(self::SERIALIZE_PAYLOAD_SMART);
	}

	/**
	* @see Request::serializePayload()
	* @return Request
	*/
	public function alwaysSerializePayload()
	{
	return $this->serializePayload(self::SERIALIZE_PAYLOAD_ALWAYS);
	}

	/**
	* Add an additional header to the request
	* Can also use the cleaner syntax of
	* $Request->withMyHeaderName($my_value);
	* @see Request::__call()
	*
	* @return Request this
	* @param string $header_name
	* @param string $value
	*/
	public function addHeader($header_name, $value)
	{
	$this->headers[$header_name] = $value;
	return $this;
	}

	/**
	* Add group of headers all at once. Note: This is
	* here just as a convenience in very specific cases.
	* The preferred "readable" way would be to leverage
	* the support for custom header methods.
	* @return Response $this
	* @param array $headers
	*/
	public function addHeaders(array $headers)
	{
	foreach ($headers as $header => $value) {
	$this->addHeader($header, $value);
	}
	return $this;
	}

	/**
	* @return Request
	* @param bool $auto_parse perform automatic "smart"
	* parsing based on Content-Type or "expectedType"
	* If not auto parsing, Response->body returns the body
	* as a string.
	*/
	public function autoParse($auto_parse = true)
	{
	$this->auto_parse = $auto_parse;
	return $this;
	}

	/**
	* @see Request::autoParse()
	* @return Request
	*/
	public function withoutAutoParsing()
	{
	return $this->autoParse(false);
	}

	/**
	* @see Request::autoParse()
	* @return Request
	*/
	public function withAutoParsing()
	{
	return $this->autoParse(true);
	}

	/**
	* Use a custom function to parse the response.
	* @return Request this
	* @param \Closure $callback Takes the raw body of
	* the http response and returns a mixed
	*/
	public function parseWith(\Closure $callback)
	{
	$this->parse_callback = $callback;
	return $this;
	}

	/**
	* @see Request::parseResponsesWith()
	* @return Request $this
	* @param \Closure $callback
	*/
	public function parseResponsesWith(\Closure $callback)
	{
	return $this->parseWith($callback);
	}

	/**
	* Register a callback that will be used to serialize the payload
	* for a particular mime type. When using "*" for the mime
	* type, it will use that parser for all responses regardless of the mime
	* type. If a custom '*' and 'application/json' exist, the custom
	* 'application/json' would take precedence over the '*' callback.
	*
	* @return Request $this
	* @param string $mime mime type we're registering
	* @param Closure $callback takes one argument, $payload,
	* which is the payload that we'll be
	*/
	public function registerPayloadSerializer($mime, \Closure $callback)
	{
	$this->payload_serializers[Mime::getFullMime($mime)] = $callback;
	return $this;
	}

	/**
	* @see Request::registerPayloadSerializer()
	* @return Request $this
	* @param Closure $callback
	*/
	public function serializePayloadWith(\Closure $callback)
	{
	return $this->regregisterPayloadSerializer('*', $callback);
	}

	/**
	* Magic method allows for neatly setting other headers in a
	* similar syntax as the other setters. This method also allows
	* for the sends* syntax.
	* @return Request this
	* @param string $method "missing" method name called
	* the method name called should be the name of the header that you
	* are trying to set in camel case without dashes e.g. to set a
	* header for Content-Type you would use contentType() or more commonly
	* to add a custom header like X-My-Header, you would use xMyHeader().
	* To promote readability, you can optionally prefix these methods with
	* "with" (e.g. withXMyHeader("blah") instead of xMyHeader("blah")).
	* @param array $args in this case, there should only ever be 1 argument provided
	* and that argument should be a string value of the header we're setting
	*/
	public function __call($method, $args)
	{
	// This method supports the sends* methods
	// like sendsJSON, sendsForm
	//!method_exists($this, $method) &&
	if (substr($method, 0, 5) === 'sends') {
	$mime = strtolower(substr($method, 5));
	if (Mime::supportsMimeType($mime)) {
	$this->sends(Mime::getFullMime($mime));
	return $this;
	}
	// else {
	// throw new \Exception("Unsupported Content-Type $mime");
	// }
	}
	if (substr($method, 0, 7) === 'expects') {
	$mime = strtolower(substr($method, 7));
	if (Mime::supportsMimeType($mime)) {
	$this->expects(Mime::getFullMime($mime));
	return $this;
	}
	// else {
	// throw new \Exception("Unsupported Content-Type $mime");
	// }
	}

	// This method also adds the custom header support as described in the
	// method comments
	if (count($args) === 0)
	return;

	// Strip the sugar. If it leads with "with", strip.
	// This is okay because: No defined HTTP headers begin with with,
	// and if you are defining a custom header, the standard is to prefix it
	// with an "X-", so that should take care of any collisions.
	if (substr($method, 0, 4) === 'with')
	$method = substr($method, 4);

	// Precede upper case letters with dashes, uppercase the first letter of method
	$header = ucwords(implode('-', preg_split('/([A-Z][^A-Z]*)/', $method, -1, PREG_SPLIT_DELIM_CAPTURE \| PREG_SPLIT_NO_EMPTY)));
	$this->addHeader($header, $args[0]);
	return $this;
	}

	// Internal Functions

	/**
	* This is the default template to use if no
	* template has been provided. The template
	* tells the class which default values to use.
	* While there is a slight overhead for object
	* creation once per execution (not once per
	* Request instantiation), it promotes readability
	* and flexibility within the class.
	*/
	private static function _initializeDefaults()
	{
	// This is the only place you will
	// see this constructor syntax. It
	// is only done here to prevent infinite
	// recusion. Do not use this syntax elsewhere.
	// It goes against the whole readability
	// and transparency idea.
	self::$_template = new Request(array('method' => Http::GET));

	// This is more like it...
	self::$_template
	->withoutStrictSSL();
	}

	/**
	* Set the defaults on a newly instantiated object
	* Doesn't copy variables prefixed with _
	* @return Request this
	*/
	private function _setDefaults()
	{
	if (!isset(self::$_template))
	self::_initializeDefaults();
	foreach (self::$_template as $k=>$v) {
	if ($k[0] != '_')
	$this->$k = $v;
	}
	return $this;
	}

	private function _error($error)
	{
	// Default actions write to error log
	// TODO add in support for various Loggers
	error_log($error);
	}

	/**
	* Factory style constructor works nicer for chaining. This
	* should also really only be used internally. The Request::get,
	* Request::post syntax is preferred as it is more readable.
	* @return Request
	* @param string $method Http Method
	* @param string $mime Mime Type to Use
	*/
	public static function init($method = null, $mime = null)
	{
	// Setup our handlers, can call it here as it's idempotent
	Bootstrap::init();

	// Setup the default template if need be
	if (!isset(self::$_template))
	self::_initializeDefaults();

	$request = new Request();
	return $request
	->_setDefaults()
	->method($method)
	->sendsType($mime)
	->expectsType($mime);
	}

	/**
	* Does the heavy lifting. Uses de facto HTTP
	* library cURL to set up the HTTP request.
	* Note: It does NOT actually send the request
	* @return Request $this;
	*/
	public function _curlPrep()
	{
	// Check for required stuff
	if (!isset($this->uri))
	throw new \Exception('Attempting to send a request before defining a URI endpoint.');

	$ch = curl_init($this->uri);

	curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $this->method);

	if ($this->hasBasicAuth()) {
	curl_setopt($ch, CURLOPT_USERPWD, $this->username . ':' . $this->password);
	}

	if ($this->hasClientSideCert()) {

	if (!file_exists($this->client_key))
	throw new \Exception('Could not read Client Key');

	if (!file_exists($this->client_cert))
	throw new \Exception('Could not read Client Certificate');

	curl_setopt($ch, CURLOPT_SSLCERTTYPE, $this->client_encoding);
	curl_setopt($ch, CURLOPT_SSLKEYTYPE, $this->client_encoding);
	curl_setopt($ch, CURLOPT_SSLCERT, $this->client_cert);
	curl_setopt($ch, CURLOPT_SSLKEY, $this->client_key);
	curl_setopt($ch, CURLOPT_SSLKEYPASSWD, $this->client_passphrase);
	// curl_setopt($ch, CURLOPT_SSLCERTPASSWD, $this->client_cert_passphrase);
	}

	if ($this->hasTimeout()) {
	curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeout);
	}

	if ($this->follow_redirects) {
	curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
	curl_setopt($ch, CURLOPT_MAXREDIRS, $this->max_redirects);
	}

	curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, $this->strict_ssl);
	curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

	$headers = array();
	// https://github.com/nategood/httpful/issues/37
	// Except header removes any HTTP 1.1 Continue from response headers
	$headers[] = 'Expect:';

	if (!isset($this->headers['User-Agent'])) {
	$headers[] = $this->buildUserAgent();
	}

	$headers[] = "Content-Type: {$this->content_type}";

	// allow custom Accept header if set
	if (!isset($this->headers['Accept'])) {
	// http://pretty-rfc.herokuapp.com/RFC2616#header.accept
	$accept = 'Accept: /; q=0.5, text/plain; q=0.8, text/html;level=3;';

	if (!empty($this->expected_type)) {
	$accept .= "q=0.9, {$this->expected_type}";
	}

	$headers[] = $accept;
	}

	foreach ($this->headers as $header => $value) {
	$headers[] = "$header: $value";
	}

	$url = \parse_url($this->uri);
	$path = (isset($url['path']) ? $url['path'] : '/').(isset($url['query']) ? '?'.$url['query'] : '');
	$this->raw_headers = "{$this->method} $path HTTP/1.1\r\n";
	$host = (isset($url['host']) ? $url['host'] : 'localhost').(isset($url['port']) ? ':'.$url['port'] : '');
	$this->raw_headers .= "Host: $host\r\n";
	$this->raw_headers .= \implode("\r\n", $headers);
	$this->raw_headers .= "\r\n";

	curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

	if (isset($this->payload)) {
	$this->serialized_payload = $this->_serializePayload($this->payload);
	curl_setopt($ch, CURLOPT_POSTFIELDS, $this->serialized_payload);
	}

	if ($this->_debug) {
	curl_setopt($ch, CURLOPT_VERBOSE, true);
	}

	curl_setopt($ch, CURLOPT_HEADER, 1);

	// If there are some additional curl opts that the user wants
	// to set, we can tack them in here
	foreach ($this->additional_curl_opts as $curlopt => $curlval) {
	curl_setopt($ch, $curlopt, $curlval);
	}

	$this->_ch = $ch;

	return $this;
	}

	public function buildUserAgent() {
	$user_agent = 'User-Agent: Httpful/' . Httpful::VERSION . ' (cURL/';
	$curl = \curl_version();

	if (isset($curl['version'])) {
	$user_agent .= $curl['version'];
	} else {
	$user_agent .= '?.?.?';
	}

	$user_agent .= ' PHP/'. PHP_VERSION . ' (' . PHP_OS . ')';

	if (isset($_SERVER['SERVER_SOFTWARE'])) {
	$user_agent .= ' ' . \preg_replace('~PHP/[\d\.]+~U', '',
	$_SERVER['SERVER_SOFTWARE']);
	} else {
	if (isset($_SERVER['TERM_PROGRAM'])) {
	$user_agent .= " {$_SERVER['TERM_PROGRAM']}";
	}

	if (isset($_SERVER['TERM_PROGRAM_VERSION'])) {
	$user_agent .= "/{$_SERVER['TERM_PROGRAM_VERSION']}";
	}
	}

	if (isset($_SERVER['HTTP_USER_AGENT'])) {
	$user_agent .= " {$_SERVER['HTTP_USER_AGENT']}";
	}

	$user_agent .= ')';

	return $user_agent;
	}

	/**
	* Semi-reluctantly added this as a way to add in curl opts
	* that are not otherwise accessible from the rest of the API.
	* @return Request $this
	* @param string $curlopt
	* @param mixed $curloptval
	*/
	public function addOnCurlOption($curlopt, $curloptval)
	{
	$this->additional_curl_opts[$curlopt] = $curloptval;
	return $this;
	}

	/**
	* Turn payload from structured data into
	* a string based on the current Mime type.
	* This uses the auto_serialize option to determine
	* it's course of action. See serialize method for more.
	* Renamed from _detectPayload to _serializePayload as of
	* 2012-02-15.
	*
	* Added in support for custom payload serializers.
	* The serialize_payload_method stuff still holds true though.
	* @see Request::registerPayloadSerializer()
	*
	* @return string
	* @param mixed $payload
	*/
	private function _serializePayload($payload)
	{
	if (empty($payload) \|\| $this->serialize_payload_method === self::SERIALIZE_PAYLOAD_NEVER)
	return $payload;

	// When we are in "smart" mode, don't serialize strings/scalars, assume they are already serialized
	if ($this->serialize_payload_method === self::SERIALIZE_PAYLOAD_SMART && is_scalar($payload))
	return $payload;

	// Use a custom serializer if one is registered for this mime type
	if (isset($this->payload_serializers['*']) \|\| isset($this->payload_serializers[$this->content_type])) {
	$key = isset($this->payload_serializers[$this->content_type]) ? $this->content_type : '*';
	return call_user_func($this->payload_serializers[$key], $payload);
	}

	return Httpful::get($this->content_type)->serialize($payload);
	}

	/**
	* HTTP Method Get
	* @return Request
	* @param string $uri optional uri to use
	* @param string $mime expected
	*/
	public static function get($uri, $mime = null)
	{
	return self::init(Http::GET)->uri($uri)->mime($mime);
	}


	/**
	* Like Request:::get, except that it sends off the request as well
	* returning a response
	* @return Response
	* @param string $uri optional uri to use
	* @param string $mime expected
	*/
	public static function getQuick($uri, $mime = null)
	{
	return self::get($uri, $mime)->send();
	}

	/**
	* HTTP Method Post
	* @return Request
	* @param string $uri optional uri to use
	* @param string $payload data to send in body of request
	* @param string $mime MIME to use for Content-Type
	*/
	public static function post($uri, $payload = null, $mime = null)
	{
	return self::init(Http::POST)->uri($uri)->body($payload, $mime);
	}

	/**
	* HTTP Method Put
	* @return Request
	* @param string $uri optional uri to use
	* @param string $payload data to send in body of request
	* @param string $mime MIME to use for Content-Type
	*/
	public static function put($uri, $payload = null, $mime = null)
	{
	return self::init(Http::PUT)->uri($uri)->body($payload, $mime);
	}

	/**
	* HTTP Method Patch
	* @return Request
	* @param string $uri optional uri to use
	* @param string $payload data to send in body of request
	* @param string $mime MIME to use for Content-Type
	*/
	public static function patch($uri, $payload = null, $mime = null)
	{
	return self::init(Http::PATCH)->uri($uri)->body($payload, $mime);
	}

	/**
	* HTTP Method Delete
	* @return Request
	* @param string $uri optional uri to use
	*/
	public static function delete($uri, $mime = null)
	{
	return self::init(Http::DELETE)->uri($uri)->mime($mime);
	}

	/**
	* HTTP Method Head
	* @return Request
	* @param string $uri optional uri to use
	*/
	public static function head($uri)
	{
	return self::init(Http::HEAD)->uri($uri);
	}

	/**
	* HTTP Method Options
	* @return Request
	* @param string $uri optional uri to use
	*/
	public static function options($uri)
	{
	return self::init(Http::OPTIONS)->uri($uri);
	}
	}

Request.phpNo OneTemporaryActions

File Metadata

Request.phpView Options

Event Timeline

Request.php
No OneTemporary
Actions

Request.php
View Options