$trustProxy
$trustProxy : boolean
Whether or not to trust HTTP_X headers set by most load balancers.
Only set to true if your application runs behind load balancers/proxies that you control.
A class that helps wrap Request information and particulars about a single request.
Provides methods commonly used to introspect on the request headers and request body.
$stream : \Psr\Http\Message\StreamInterface
Request body stream. Contains php://input unless `input` constructor option is used.
$uri : \Psr\Http\Message\UriInterface
Uri instance
$session : \Cake\Http\Session
Instance of a Session object relative to this request
__construct(string|array $config = array())
Create a new request object.
You can supply the data as either an array or as a string. If you use a string you can only supply the URL for the request. Using an array will let you provide the following keys:
post POST data or non query string dataquery Additional data from the query string.files Uploaded file data formatted like $_FILES.cookies Cookies for this request.environment $_SERVER and $_ENV data.url The URL without the base path for the request.uri The PSR7 UriInterface object. If null, one will be created.base The base URL for the request.webroot The webroot directory for the request.input The data that would come from php://input this is useful for simulating
requests with put, patch or delete data.session An instance of a Session object| string|array | $config | An array of request data to create a request with. The string version of this argument is deprecated and will be removed in 4.0.0 |
getSession() : \Cake\Http\Session
Returns the instance of the Session object for this request
session(\Cake\Http\Session|null $session = null) : \Cake\Http\Session
Returns the instance of the Session object for this request
If a session object is passed as first argument it will be set as the session to use for this request
| \Cake\Http\Session|null | $session | the session object to use |
__call(string $name, array $params) : mixed
Missing method handler, handles wrapping older style isAjax() type methods
| string | $name | The method called |
| array | $params | Array of parameters for the method call |
when an invalid method is called.
is(string|array $type, array ...$args) : boolean
Check whether or not a Request is a certain type.
Uses the built in detection rules as well as additional rules
defined with Cake\Http\ServerRequest::addDetector(). Any detector can be called
as is($type) or is$Type().
| string|array | $type | The type of request you want to check. If an array this method will return true if the request matches any type. |
| array | $args variadic | List of arguments |
Whether or not the request is the type you are checking.
addDetector(string $name, callable|array $callable) : void
Add a new detector to the list of detectors that a request can use.
There are several different formats and types of detectors that can be set.
Callback detectors allow you to provide a callable to handle the check. The callback will receive the request object as its only parameter.
addDetector('custom', function ($request) { //Return a boolean });
addDetector('custom', ['SomeClass', 'somemethod']);An environment value comparison, compares a value fetched from env() to a known value
the environment value is equality checked against the provided value.
e.g addDetector('post', ['env' => 'REQUEST_METHOD', 'value' => 'POST'])
Pattern value comparison allows you to compare a value fetched from env() to a regular expression.
addDetector('iphone', ['env' => 'HTTP_USER_AGENT', 'pattern' => '/iPhone/i']);Option based comparisons use a list of options to create a regular expression. Subsequent calls to add an already defined options detector will merge the options.
addDetector('mobile', ['env' => 'HTTP_USER_AGENT', 'options' => ['Fennec']]);Allows for custom detectors on the request parameters.
e.g addDetector('requested', ['param' => 'requested', 'value' => 1]
You can also make parameter detectors that accept multiple values
using the options key. This is useful when you want to check
if a request parameter is in a list of options.
addDetector('extension', ['param' => 'ext', 'options' => ['pdf', 'csv']]
| string | $name | The name of the detector. |
| callable|array | $callable | A callable or options array for the detector definition. |
addParams(array $params) : $this
Add parameters to the request's parsed parameter set. This will overwrite any existing parameters.
This modifies the parameters available through $request->getParam().
| array | $params | Array of parameters to merge in |
The current object, you can chain this method.
header(string $name) : string|null
Read an HTTP header from the Request information.
If the header is not defined in the request, this method will fallback to reading data from $_SERVER and $_ENV. This fallback behavior is deprecated, and will be removed in 4.0.0
| string | $name | Name of the header you want. |
Either null on no header being set or the value of the header.
getHeaders() : array
Get all headers in the request.
Returns an associative array where the header names are the keys and the values are a list of header values.
While header names are not case-sensitive, getHeaders() will normalize the headers.
An associative array of headers and their values.
getHeader(string $name) : array
Get a single header from the request.
Return the header value as an array. If the header is not present an empty array will be returned.
| string | $name | The header you want to get (case-insensitive) |
An associative array of headers and their values. If the header doesn't exist, an empty array will be returned.
withAddedHeader(string $name, string|array $value) : static
Get a modified request with the provided header.
Existing header values will be retained. The provided value will be appended into the existing values.
| string | $name | The header name. |
| string|array | $value | The header value |
getMethod() : string
Get the HTTP method used for this request.
There are a few ways to specify a method.
_methodAny of these 3 approaches can be used to set the HTTP method used by CakePHP internally, and will effect the result of this method.
The name of the HTTP method used.
getQueryParams() : array
Get all the query parameters in accordance to the PSR-7 specifications. To read specific query values use the alternative getQuery() method.
Retrieves the deserialized query string arguments, if any.
Note: the query params might not be in sync with the URI or server
params. If you need to ensure you are only getting the original
values, you may need to parse the query string from getUri()->getQuery()
or from the QUERY_STRING server param.
withQueryParams(array $query) : static
Update the query string data and get a new instance.
These values SHOULD remain immutable over the course of the incoming request. They MAY be injected during instantiation, such as from PHP's $_GET superglobal, or MAY be derived from some other value such as the URI. In cases where the arguments are parsed from the URI, the data MUST be compatible with what PHP's parse_str() would return for purposes of how duplicate query parameters are handled, and how nested sets are handled.
Setting query string arguments MUST NOT change the URI stored by the request, nor the values in the server params.
This method MUST be implemented in such a way as to retain the immutability of the message, and MUST return an instance that has the updated query string arguments.
| array | $query | The query string data to use |
A new instance with the updated query string data.
domain(integer $tldLength = 1) : string
Get the domain name and include $tldLength segments of the tld.
| integer | $tldLength | Number of segments your tld contains. For example: |
Domain name without subdomains.
accepts(string|null $type = null) : array|boolean
Find out which content types the client accepts or check if they accept a particular type of content.
$this->request->accepts();$this->request->accepts('application/json');This method will order the returned content types by the preference values indicated by the client.
| string|null | $type | The content type to check for. Leave null to get all types a client accepts. |
Either an array of all the types the client accepts or a boolean if they accept the provided type.
parseAccept() : array
Parse the HTTP_ACCEPT header and return a sorted array with content types as the keys, and pref values as the values.
Generally you want to use Cake\Http\ServerRequest::accept() to get a simple list of the accepted content types.
An array of prefValue => [content/types]
acceptLanguage(string|null $language = null) : array|boolean
Get the languages accepted by the client, or check if a specific language is accepted.
Get the list of accepted languages:
\Cake\Http\ServerRequest::acceptLanguage();
Check if a specific language is accepted:
\Cake\Http\ServerRequest::acceptLanguage('es-es');
| string|null | $language | The language to test. |
If a $language is provided, a boolean. Otherwise the array of accepted languages.
query(string|null $name = null) : string|array|null
Provides a read accessor for `$this->query`.
Allows you to use a Hash::get() compatible syntax for reading post data.
| string|null | $name | Query string variable name or null to read all. |
The value being read
getQuery(string|null $name = null, mixed $default = null) : null|string|array
Read a specific query value or dotted path.
Developers are encouraged to use getQueryParams() when possible as it is PSR-7 compliant, and this method is not.
$value = Hash::get($request->getQueryParams(), 'Post.id', null);| string|null | $name | The name or dotted path to the query param or null to read all. |
| mixed | $default | The default value if the named parameter is not set, and $name is not null. |
Query data.
data(string|null $name = null, mixed ...$args) : mixed|$this
Provides a read/write accessor for `$this->data`.
Allows you to use a Hash::get() compatible syntax for reading post data.
$request->data('Post.title');When reading values you will get null for keys/values that do not exist.
$request->data('Post.title', 'New post!');You can write to any value, even paths/keys that do not exist, and the arrays will be created for you.
| string|null | $name | Dot separated name of the value to read/write |
| mixed | $args variadic | The data to set (deprecated) |
Either the value being read, or this so you can chain consecutive writes.
getData(string|null $name = null, mixed $default = null) : null|string|array
Provides a safe accessor for request data. Allows you to use Hash::get() compatible paths.
// get all data
$request->getData();
// Read a specific field.
$request->getData('Post.title');
// With a default value.
$request->getData('Post.not there', 'default value');When reading values you will get null for keys/values that do not exist.
| string|null | $name | Dot separated name of the value to read. Or null to read all data. |
| mixed | $default | The default data. |
The value being read.
param(string $name, mixed ...$args) : mixed|$this
Safely access the values in $this->params.
| string | $name | The name of the parameter to get. |
| mixed | $args variadic | Value to set (deprecated). |
The value of the provided parameter. Will return false if the parameter doesn't exist or is falsey.
input(string|null $callback = null, array ...$args) : string
Read data from `php://input`. Useful when interacting with XML or JSON request body content.
Getting input with a decoding function:
$this->request->input('json_decode');Getting input using a decoding function, and additional params:
$this->request->input('Xml::build', ['return' => 'DOMDocument']);Any additional parameters are applied to the callback in the order they are given.
| string|null | $callback | A decoding callback that will convert the string data to another representation. Leave empty to access the raw input data. You can also supply additional parameters for the decoding callback using var args, see above. |
| array | $args variadic | The additional arguments |
The decoded/processed request data.
getCookie(string $key, string $default = null) : null|array|string
Read cookie data from the request's cookie data.
| string | $key | The key or dotted path you want to read. |
| string | $default | The default value if the cookie is not set. |
Either the cookie value, or null if the value doesn't exist.
getCookieCollection() : \Cake\Http\Cookie\CookieCollection
Get a cookie collection based on the request's cookies
The CookieCollection lets you interact with request cookies using
\Cake\Http\Cookie\Cookie objects and can make converting request cookies
into response cookies easier.
This method will create a new cookie collection each time it is called.
This is an optimization that allows fewer objects to be allocated until
the more complex CookieCollection is needed. In general you should prefer
getCookie() and getCookieParams() over this method. Using a CookieCollection
is ideal if your cookies contain complex JSON encoded data.
withCookieCollection(\Cake\Http\Cookie\CookieCollection $cookies) : static
Replace the cookies in the request with those contained in the provided CookieCollection.
| \Cake\Http\Cookie\CookieCollection | $cookies | The cookie collection |
withCookieParams(array $cookies) : static
Replace the cookies and get a new request instance.
The data IS NOT REQUIRED to come from the $_COOKIE superglobal, but MUST be compatible with the structure of $_COOKIE. Typically, this data will be injected at instantiation.
This method MUST NOT update the related Cookie header of the request instance, nor related values in the server params.
This method MUST be implemented in such a way as to retain the immutability of the message, and MUST return an instance that has the updated cookie values.
| array | $cookies | The new cookie data to use. |
getParsedBody() : null|array|object
Get the parsed request body data.
If the request Content-Type is either application/x-www-form-urlencoded or multipart/form-data, and the request method is POST, this will be the post data. For other content types, it may be the deserialized request body.
The deserialized body parameters, if any. These will typically be an array or object.
withParsedBody(null|array|object $data) : static
Update the parsed body and get a new instance.
These MAY be injected during instantiation.
If the request Content-Type is either application/x-www-form-urlencoded or multipart/form-data, and the request method is POST, use this method ONLY to inject the contents of $_POST.
The data IS NOT REQUIRED to come from $_POST, but MUST be the results of deserializing the request body content. Deserialization/parsing returns structured data, and, as such, this method ONLY accepts arrays or objects, or a null value if nothing was available to parse.
As an example, if content negotiation determines that the request data is a JSON payload, this method could be used to create a request instance with the deserialized parameters.
This method MUST be implemented in such a way as to retain the immutability of the message, and MUST return an instance that has the updated body parameters.
| null|array|object | $data | The deserialized body data. This will typically be in an array or object. |
getEnv(string $key, string|null $default = null) : string|null
Get a value from the request's environment data.
Fallback to using env() if the key is not set in the $environment property.
| string | $key | The key you want to read from. |
| string|null | $default | Default value when trying to retrieve an environment variable's value that does not exist. |
Either the environment value, or null if the value doesn't exist.
withEnv(string $key, string $value) : static
Update the request with a new environment data element.
Returns an updated request object. This method returns a new request object and does not mutate the request in-place.
| string | $key | The key you want to write to. |
| string | $value | Value to set |
env(string $key, string|null $value = null, string|null $default = null) : $this|string|null
Get/Set value from the request's environment data.
Fallback to using env() if key not set in $environment property.
| string | $key | The key you want to read/write from/to. |
| string|null | $value | Value to set. Default null. |
| string|null | $default | Default value when trying to retrieve an environment variable's value that does not exist. The value parameter must be null. |
This instance if used as setter, if used as getter either the environment value, or null if the value doesn't exist.
allowMethod(string|array $methods) : boolean
Allow only certain HTTP request methods, if the request method does not match a 405 error will be shown and the required "Allow" response header will be set.
Example:
$this->request->allowMethod('post'); or $this->request->allowMethod(['post', 'delete']);
If the request would be GET, response header "Allow: POST, DELETE" will be set and a 405 error will be returned.
| string|array | $methods | Allowed HTTP request methods. |
true
withData(string $name, mixed $value) : static
Update the request with a new request data element.
Returns an updated request object. This method returns a new request object and does not mutate the request in-place.
Use withParsedBody() if you need to replace the all request data.
| string | $name | The dot separated path to insert $value at. |
| mixed | $value | The value to insert into the request data. |
withParam(string $name, mixed $value) : static
Update the request with a new routing parameter
Returns an updated request object. This method returns a new request object and does not mutate the request in-place.
| string | $name | The dot separated path to insert $value at. |
| mixed | $value | The value to insert into the the request parameters. |
withAttribute(string $name, mixed $value) : static
Return an instance with the specified request attribute.
This method allows setting a single derived request attribute as described in getAttributes().
This method MUST be implemented in such a way as to retain the immutability of the message, and MUST return an instance that has the updated attribute.
| string | $name | The attribute name. |
| mixed | $value | The value of the attribute. |
withoutAttribute(string $name) : static
Return an instance without the specified request attribute.
This method allows removing a single derived request attribute as described in getAttributes().
This method MUST be implemented in such a way as to retain the immutability of the message, and MUST return an instance that removes the attribute.
| string | $name | The attribute name. |
getAttribute(string $name, mixed|null $default = null) : mixed
Read an attribute from the request, or get the default
Retrieves a single derived request attribute as described in getAttributes(). If the attribute has not been previously set, returns the default value as provided.
This method obviates the need for a hasAttribute() method, as it allows specifying a default value to return if the attribute is not found.
| string | $name | The attribute name. |
| mixed|null | $default | The default value if the attribute has not been set. |
getUploadedFile(string $path) : null|\Psr\Http\Message\UploadedFileInterface
Get the uploaded file from a dotted path.
| string | $path | The dot separated path to the file you want. |
getUploadedFiles() : array
Get the array of uploaded files from the request.
This method returns upload metadata in a normalized tree, with each leaf an instance of Psr\Http\Message\UploadedFileInterface.
These values MAY be prepared from $_FILES or the message body during instantiation, or MAY be injected via withUploadedFiles().
withUploadedFiles(array $files) : static
Update the request replacing the files, and creating a new instance.
This method MUST be implemented in such a way as to retain the immutability of the message, and MUST return an instance that has the updated body parameters.
| array | $files | An array of uploaded file objects. |
when $files contains an invalid object.
getBody() : \Psr\Http\Message\StreamInterface
Gets the body of the message.
Returns the body as a stream.
withBody(\Psr\Http\Message\StreamInterface $body) : static
Return an instance with the specified message body.
| \Psr\Http\Message\StreamInterface | $body | The new request body |
getUri() : \Psr\Http\Message\UriInterface
Retrieves the URI instance.
Returns a UriInterface instance representing the URI of the request.
withUri(\Psr\Http\Message\UriInterface $uri, boolean $preserveHost = false) : static
Return an instance with the specified uri
Warning Replacing the Uri will not update the base, webroot,
and url attributes.
| \Psr\Http\Message\UriInterface | $uri | The new request uri |
| boolean | $preserveHost | Whether or not the host should be retained. |
withRequestTarget(string $target) : static
Create a new instance with a specific request-target.
You can use this method to overwrite the request target that is inferred from the request's Uri. This also lets you change the request target's form to an absolute-form, authority-form or asterisk-form
| string | $target | The request target. |
getRequestTarget() : string
Retrieves the request's target.
Retrieves the message's request-target either as it was requested,
or as set with withRequestTarget(). By default this will return the
application relative path without base directory, and the query string
defined in the SERVER environment.
_processPost(array $data) : array
Sets the REQUEST_METHOD environment variable based on the simulated _method HTTP override value. The 'ORIGINAL_REQUEST_METHOD' is also preserved, if you want the read the non-simulated HTTP method the client used.
| array | $data | Array of post data. |
_processGet(array $query, string $queryString = '') : array
Process the GET parameters and move things into the object.
| array | $query | The array to which the parsed keys/values are being added. |
| string | $queryString | A query string from the URL if provided |
An array containing the parsed query string as keys/values.
_createUploadedFile(array $value) : array|\Psr\Http\Message\UploadedFileInterface
Create an UploadedFile instance from a $_FILES array.
If the value represents an array of values, this method will recursively process the data.
| array | $value | $_FILES struct |
_normalizeNestedFiles(array $files = array()) : array
Normalize an array of file specifications.
Loops through all nested files and returns a normalized array of UploadedFileInterface instances.
| array | $files | The file data to normalize & convert. |
An array of UploadedFileInterface objects.
validateUploadedFiles(array $uploadedFiles, string $path) : void
Recursively validate uploaded file data.
| array | $uploadedFiles | The new files array to validate. |
| string | $path | The path thus far. |
If any leaf elements are not valid files.