Namespace | Phalcon\Http | Uses | Phalcon\Di\DiInterface, Phalcon\Di\AbstractInjectionAware, Phalcon\Crypt\CryptInterface, Phalcon\Crypt\Mismatch, Phalcon\Filter\FilterInterface, Phalcon\Helper\Arr, Phalcon\Http\Response\Exception, Phalcon\Http\Cookie\CookieInterface, Phalcon\Http\Cookie\Exception, Phalcon\Session\ManagerInterface | Extends | AbstractInjectionAware | Implements | CookieInterface |
Proporciona envolturas OO para gestionar una cookie HTTP.
/**
* @var string
*/
protected domain;
/**
* @var int
*/
protected expire;
//
protected filter;
/**
* @var bool
*/
protected httpOnly;
/**
* @var string
*/
protected name;
/**
* @var array
*/
protected options;
/**
* @var string
*/
protected path;
/**
* @var bool
*/
protected read = false;
/**
* @var bool
*/
protected restored = false;
/**
* @var bool
*/
protected secure;
/**
* The cookie's sign key.
* @var string|null
*/
protected signKey;
/**
* @var bool
*/
protected useEncryption = false;
/**
* @var mixed
*/
protected value;
public function __construct( string $name, mixed $value = null, int $expire = int, string $path = string, bool $secure = null, string $domain = null, bool $httpOnly = bool, array $options = [] );
Constructor Phalcon\Http\Cookie.
public function __toString(): string;
Método mágico __toString convierte el valor de la cookie a cadena
public function delete();
Elimina la cookie estableciendo un tiempo de caducidad en el pasado
public function getDomain(): string;
Devuelve el dominio para el que la cookie está disponible
public function getExpiration(): string;
Devuelve el tiempo de caducidad actual
public function getHttpOnly(): bool;
Devuelve si la cookie está accesible sólo mediante el protocolo HTTP
public function getName(): string;
Devuelve el nombre actual de la cookie
public function getOptions(): array;
Devuelve las opciones actuales de la cookie
public function getPath(): string;
Devuelve la ruta actual de la cookie
public function getSecure(): bool;
Devuelve si la cookie debe ser enviada solo cuando la conexión es segura (HTTPS)
public function getValue( mixed $filters = null, mixed $defaultValue = null ): mixed;
Devuelve el valor de la cookie.
public function isUsingEncryption(): bool;
Comprueba si la cookie está usando encriptación implícita
public function restore(): CookieInterface;
Lee la información relacionada con las cookie desde la SESSION para restaurar la cookie tal como fue configurada.
Este método se llama de forma automática internamente, por lo que normalmente no necesita llamarlo.
public function send(): CookieInterface;
Envía la cookie al cliente HTTP.
Almacena la definición de la cookie en sesión.
public function setDomain( string $domain ): CookieInterface;
Establece el dominio para el que está disponible la cookie
public function setExpiration( int $expire ): CookieInterface;
Establece el tiempo de caducidad de la cookie
public function setHttpOnly( bool $httpOnly ): CookieInterface;
Establece si la cookie está accesible sólo mediante el protocolo HTTP
public function setOptions( array $options ): CookieInterface;
Establece las opciones de la cookie
public function setPath( string $path ): CookieInterface;
Establece la ruta de la cookie
public function setSecure( bool $secure ): CookieInterface;
Establece si la cookie se debe enviar solo cuando la conexión es segura (HTTPS)
public function setSignKey( string $signKey = null ): CookieInterface;
Establece la clave de firma de la cookie.
`$signKey’ DEBE tener al menos 32 caracteres de longitud y generarse usando un generador pseudoaleatorio seguro criptográficamente.
Use NULL para deshabilitar la firma de cookies.
@see \Phalcon\Security\Random @throws \Phalcon\Http\Cookie\Exception
public function setValue( mixed $value ): CookieInterface;
Establece el valor de la cookie
public function useEncryption( bool $useEncryption ): CookieInterface;
Establece si la cookie se debe encriptar/desencriptar automáticamente
protected function assertSignKeyIsLongEnough( string $signKey ): void;
Afirma que la clave de la cookie es suficientemente larga.
@throws \Phalcon\Http\Cookie\Exception
Namespace | Phalcon\Http\Cookie |
Interfaz para Phalcon\Http\Cookie
public function delete();
Elimina la cookie
public function getDomain(): string;
Devuelve el dominio para el que la cookie está disponible
public function getExpiration(): string;
Devuelve el tiempo de caducidad actual
public function getHttpOnly(): bool;
Devuelve si la cookie está accesible sólo mediante el protocolo HTTP
public function getName(): string;
Devuelve el nombre actual de la cookie
public function getOptions(): array;
Devuelve las opciones actuales de la cookie
public function getPath(): string;
Devuelve la ruta actual de la cookie
public function getSecure(): bool;
Devuelve si la cookie debe ser enviada solo cuando la conexión es segura (HTTPS)
public function getValue( mixed $filters = null, mixed $defaultValue = null ): mixed;
Devuelve el valor de la cookie.
public function isUsingEncryption(): bool;
Comprueba si la cookie está usando encriptación implícita
public function send(): CookieInterface;
Envía la cookie al cliente HTTP
public function setDomain( string $domain ): CookieInterface;
Establece el dominio para el que está disponible la cookie
public function setExpiration( int $expire ): CookieInterface;
Establece el tiempo de caducidad de la cookie
public function setHttpOnly( bool $httpOnly ): CookieInterface;
Establece si la cookie está accesible sólo mediante el protocolo HTTP
public function setOptions( array $options ): CookieInterface;
Establece las opciones de la cookie
public function setPath( string $path ): CookieInterface;
Establece el tiempo de caducidad de la cookie
public function setSecure( bool $secure ): CookieInterface;
Establece si la cookie se debe enviar solo cuando la conexión es segura (HTTPS)
public function setValue( mixed $value ): CookieInterface;
Establece el valor de la cookie
public function useEncryption( bool $useEncryption ): CookieInterface;
Establece si la cookie se debe encriptar/desencriptar automáticamente
Namespace | Phalcon\Http\Cookie | Extends | \Phalcon\Exception |
Phalcon\Http\Cookie\Exception
Las excepciones lanzadas en Phalcon\Http\Cookie usarán esta clase.
Namespace | Phalcon\Http\Message | Uses | Phalcon\Http\Message\Exception\InvalidArgumentException |
Métodos comunes
final protected function checkStringParameter( mixed $element ): void;
Comprueba el elemento pasado si es una cadena
final protected function cloneInstance( mixed $element, string $property ): mixed;
Devuelve una nueva instancia al establecer el parámetro
final protected function processWith( mixed $element, string $property ): mixed;
Comprueba el elemento pasado; lo asigna a la propiedad y devuelve un clon del objeto de vuelta
Namespace | Phalcon\Http\Message | Uses | Phalcon\Collection, Phalcon\Collection\CollectionInterface, Phalcon\Http\Message\Exception\InvalidArgumentException, Psr\Http\Message\StreamInterface, Psr\Http\Message\UriInterface | Extends | AbstractCommon |
Métodos de mensaje
/**
* Gets the body of the message.
*
* @var StreamInterface
*/
protected body;
/**
* @var Collection|CollectionInterface
*/
protected headers;
/**
* Retrieves the HTTP protocol version as a string.
*
* The string MUST contain only the HTTP version number (e.g., '1.1',
* '1.0').
*
* @return string HTTP protocol version.
*
* @var string
*/
protected protocolVersion = 1.1;
/**
* Retrieves the URI instance.
*
* This method MUST return a UriInterface instance.
*
* @see https://tools.ietf.org/html/rfc3986#section-4.3
*
* @var UriInterface
*/
protected uri;
public function getBody(): StreamInterface
public function getHeader( mixed $name ): array;
Recupera un valor de cabecera de mensaje por el nombre dado insensible a mayúsculas y minúsculas.
Este método devuelve un vector de todos los valores de cabecera del nombre de cabecera dado insensible a mayúsculas y minúsculas.
Si la cabecera no aparece en el mensaje, este método DEBE devolver un vector vacío.
public function getHeaderLine( mixed $name ): string;
Obtiene una cadena separada por comas de los valores para una única cabecera.
Este método devuelve todos los valores de cabecera de un nombre de cabecera dado insensible a mayúsculas y minúsculas como una cadena concatenada junta usando una coma.
NOTA: No todos los valores de cabecera pueden ser representados apropiadamente usando la concatenación por coma. Para esas cabeceras, use getHeader() en su lugar y proporcione su propio delimitador al concatenar.
Si la cabecera no aparece en el mensaje, este método DEBE devolver una cadena vacía.
public function getHeaders(): array;
Obtiene todos los valores de cabecera del mensaje.
Las claves representan el nombre de la cabecera tal y como se enviarán, y cada valor es un vector de cadenas asociadas con la cabecera.
// Represent the headers as a string
foreach ($message->getHeaders() as $name => $values) {
echo $name . ': ' . implode(', ', $values);
}
// Emit headers iteratively:
foreach ($message->getHeaders() as $name => $values) {
foreach ($values as $value) {
header(sprintf('%s: %s', $name, $value), false);
}
}
Mientras que los nombres de la cabecera son insensibles a mayúsculas, getHeaders() preservará intactas las mayúsculas y minúsculas en el que las cabeceras fueron especificadas originalmente.
public function getProtocolVersion(): string
public function getUri(): UriInterface
public function hasHeader( mixed $name ): bool;
Comprueba si existe una cabecera por el nombre dado insensible a mayúsculas y minúsculas.
public function withAddedHeader( mixed $name, mixed $value ): mixed;
Devuelve una instancia con la cabecera especificada añadida con el valor dado.
Se mantendrán los valores existentes para la cabecera especificada. El/los nuevo/s valor/es será/n añadido/s a la lista existente. Si la cabecera no existía previamente, será añadida.
Este método DEBE ser implementado de tal forma que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que tenga la nueva cabecera y/o valor.
public function withBody( StreamInterface $body ): mixed;
Devuelve una instancia con el cuerpo de mensaje especificado.
El cuerpo DEBE ser un objeto StreamInterface
.
Este método DEBE ser implementado de tal manera que conserve la inmutabilidad del mensaje, y DEBE devolver una nueva instancia con el nuevo flujo de cuerpo.
public function withHeader( mixed $name, mixed $value ): mixed;
Devuelve una instancia con el valor proporcionado reemplazando la cabecera especificada.
Mientras que los nombres de cabecera son insensibles a mayúsculas, esta función mantendrá las mayúsculas y minúsculas de la cabecera, y se devolverán con getHeaders().
Este método DEBE ser implementado de tal forma que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que tenga la nueva y/o actualizada cabecera y valor.
public function withProtocolVersion( mixed $version ): mixed;
Devuelve una instancia con la versión de protocolo HTTP especificada.
La cadena de versión DEBE contener sólo el número de versión HTTP (ej, ‘1.1’, ‘1.0’).
Este método DEBE ser implementado de tal manera que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que tenga la nueva versión de protocolo.
public function withoutHeader( mixed $name ): mixed;
Devuelve una instancia sin la cabecera especificada.
La resolución de cabecera se DEBE hacer sin sensibilidad a mayúsculas y minúsculas.
Este método DEBE implementarse de tal manera que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que elimine la cabecera nombrada.
final protected function checkHeaderHost( CollectionInterface $collection ): CollectionInterface;
Asegura que Host
es la primera cabecera.
@see: https://tools.ietf.org/html/rfc7230#section-5.4
final protected function checkHeaderName( mixed $name ): void;
Comprueba el nombre de la cabecera. Lanza excepción si no es válida
@see https://tools.ietf.org/html/rfc7230#section-3.2
final protected function checkHeaderValue( mixed $value ): void;
Valida un valor de cabecera
La mayoría de los valores de campo de cabecera se definen usando componentes de sintaxis común (token, cadena entre comillas, y comentario) separados por espacios en blanco o caracteres específicos de delimitación. Los delimitadores se eligen del conjunto de caracteres visuales US-ASCII no permitidos en un token (DQUOTE and ‘(),/:;<=>?@[]{}’).
token = 1*tchar
tchar = '!' / '#' / '$' / '%' / '&' / ''' / '*'
/ '+' / '-' / '.' / '^' / '_' / '`' / '|' / '~'
/ DIGIT / ALPHA
; any VCHAR, except delimiters
Una cadena de texto se analiza como un valor único si escribe usando comillas dobles.
quoted-string = DQUOTE( qdtext / quoted-pair ) DQUOTE
qdtext = HTAB / SP /%x21 / %x23-5B / %x5D-7E / obs-text
obs-text = %x80-FF
Los comentarios se pueden incluir en algunos campos de cabecera HTTP rodeando el texto del comentario con paréntesis. Los comentarios sólo se permiten en campos que contienen ‘comment’ como parte de su definición del valor de campo.
comment = '('( ctext / quoted-pair / comment ) ')'
ctext = HTAB / SP / %x21-27 / %x2A-5B / %x5D-7E / obs-text
El octeto de barra inversa (‘') se puede usar como mecanismo de cita de un sólo octeto en construcciones de cadenas-entrecomilladas y comentarios. Los recipientes que procesan el valor de una cadena entrecomillada DEBE gestionar un par entrecomillado como si fuera sustituido por el octeto que sigue a la barra invertida.
quoted-pair = '\' ( HTAB / SP / VCHAR / obs-text )
Un remitente NO DEBERÍA generar un par entrecomillado en una cadena entrecomillada excepto donde sea necesario entrecomillar octetos de DQUOTE y barra invertida que ocurran dentro de esa cadena. Un remitente NO DEBERÍA generar un par entrecomillado en un comentario excepto donde sea necesario entrecomillar paréntesis [’(‘ y ‘)’] y octetos de barra invertida que ocurran dentro de ese comentario.
@see https://tools.ietf.org/html/rfc7230#section-3.2.6
final protected function getHeaderValue( mixed $values ): array;
Devuelve los valores de cabecera comprobados para su validez
final protected function getUriHost( UriInterface $uri ): string;
Devuelve el servidor, y, si es aplicable, el puerto
final protected function populateHeaderCollection( array $headers ): CollectionInterface;
Rellena la colección de cabeceras
final protected function processBody( mixed $body = string, string $mode = string ): StreamInterface;
Establece un flujo válido
final protected function processHeaders( mixed $headers ): CollectionInterface;
Establece las cabeceras
final protected function processProtocol( mixed $protocol = string ): string;
Comprueba el protocolo
Namespace | Phalcon\Http\Message | Uses | Phalcon\Http\Message\Exception\InvalidArgumentException, Psr\Http\Message\UriInterface | Extends | AbstractMessage |
Métodos de solicitud
/**
* Retrieves the HTTP method of the request.
*
* @var string
*/
protected method = GET;
/**
* The request-target, if it has been provided or calculated.
*
* @var null|string
*/
protected requestTarget;
/**
* Retrieves the URI instance.
*
* This method MUST return a UriInterface instance.
*
* @see https://tools.ietf.org/html/rfc3986#section-4.3
*
* @var UriInterface
*/
protected uri;
public function getMethod(): string
public function getRequestTarget(): string;
Obtiene el destino de la petición del mensaje.
Obtiene el destino de la petición del mensaje tal y como aparecerá (para clientes), como apareció en la petición (para servidores), o como fue especificado por la instancia (ver withRequestTarget()).
En la mayoría de casos, esta será la forma original de la URL compuesta, a no ser que se proporcione un valor para la implementación concreta (ver withRequestTarget() más abajo).
public function getUri(): UriInterface
public function withMethod( mixed $method ): mixed;
Devuelve una instancia con el método HTTP proporcionado.
Mientras que los nombres de método HTTP son típicamente todos caracteres mayúsculas, los nombres de método HTTP son sensibles a mayúsculas y minúsculas y por lo tanto las implementaciones NO DEBERÍAN modificar la cadena dada.
Este método DEBE ser implementado de tal manera que conserve al inmutabilidad del mensaje, y DEBE devolver una instancia que tenga el método de petición cambiado.
public function withRequestTarget( mixed $requestTarget ): mixed;
Devuelve una instancia con el destino especificado de la petición.
Si la petición necesita un destino de petición no en la forma original — ej., para especificar una forma absoluta, una forma de autoridad, o una forma de asterisco — este método se podría usar para crear una instancia con el destino de petición especificado, literalmente.
Este método se DEBE implementar de tal forma que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que tenga el destino de la petición cambiado.
@see https://tools.ietf.org/html/rfc7230#section-5.3 (for the various request-target forms allowed in request messages)
public function withUri( UriInterface $uri, mixed $preserveHost = bool ): mixed;
Devuelve una instancia con la URL proporcionada.
Este método DEBE actualizar la cabecera Host
de la petición devuelta por defecto si la URI contiene un componente servidor. If the URI does not contain a host component, any pre-existing Host header MUST be carried over to the returned request.
Puede optar por preservar el estado original de la cabecera Host
estableciendo $preserveHost
a true
. Cuando $preserveHost
se establece a true
, este método interactúa con la cabecera Host
de la siguiente manera:
Host
no está o está vacía, y la nueva URI contiene un componente servidor, este método DEBE actualizar la cabecera Host
en la petición devuelta.Host
no está o está vacía, y la nueva URI no contiene un componente servidor, este método NO DEBE actualizar la cabecera Host
en la petición devuelta.Host
en la petición devuelta.Este método se DEBE implementar de tal forma que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que tenga la nueva instancia UriInterface.
@see https://tools.ietf.org/html/rfc3986#section-4.3
final protected function processMethod( mixed $method = string ): string;
Comprueba el método
final protected function processUri( mixed $uri ): UriInterface;
Establece una Uri válida
Namespace | Phalcon\Http\Message\Exception | Uses | Throwable | Extends | \InvalidArgumentException | Implements | Throwable |
Este fichero es parte del Framework Phalcon.
(c) Phalcon Team [email protected]
Para obtener toda la información sobre derechos de autor y licencias, por favor vea el archivo LICENSE.txt que se distribuyó con este código fuente.
Namespace | Phalcon\Http\Message | Uses | Phalcon\Http\Message\Stream\Input, Phalcon\Http\Message\AbstractRequest, Psr\Http\Message\RequestInterface, Psr\Http\Message\StreamInterface, Psr\Http\Message\UriInterface | Extends | AbstractRequest | Implements | RequestInterface |
PSR-7 Request
public function __construct( string $method = string, mixed $uri = null, mixed $body = string, mixed $headers = [] );
Constructor Request.
Namespace | Phalcon\Http\Message | Uses | Psr\Http\Message\RequestInterface, Psr\Http\Message\RequestFactoryInterface, Psr\Http\Message\UriInterface | Implements | RequestFactoryInterface |
PSR-17 RequestFactory
public function createRequest( string $method, mixed $uri ): RequestInterface;
Crea una nueva petición.
Namespace | Phalcon\Http\Message | Uses | Phalcon\Helper\Number, Phalcon\Http\Message\AbstractMessage, Phalcon\Http\Message\Exception\InvalidArgumentException, Psr\Http\Message\ResponseInterface | Extends | AbstractMessage | Implements | ResponseInterface |
PSR-7 Response
/**
* Gets the response reason phrase associated with the status code.
*
* Because a reason phrase is not a required element in a response
* status line, the reason phrase value MAY be empty. Implementations MAY
* choose to return the default RFC 7231 recommended reason phrase (or
* those
* listed in the IANA HTTP Status Code Registry) for the response's
* status code.
*
* @see https://tools.ietf.org/html/rfc7231#section-6
* @see https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
*
* @var string
*/
protected reasonPhrase = ;
/**
* Gets the response status code.
*
* The status code is a 3-digit integer result code of the server's attempt
* to understand and satisfy the request.
*
* @var int
*/
protected statusCode = 200;
public function __construct( mixed $body = string, int $code = int, array $headers = [] );
Constructor Response.
public function getReasonPhrase(): string
public function getStatusCode(): int
public function withStatus( mixed $code, mixed $reasonPhrase = string ): Response;
Devuelve una instancia con el código de estado especificado y, opcionalmente, la frase de razón.
Si no se especifica una frase de razón, las implementaciones PUEDEN elegir por defecto la frase de razón recomendada por RFC 7231 o IANA para el código de estado de la respuesta.
Este método DEBE implementarse de tal manera que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que tiene el estado y frase de razón actualizados.
@see https://tools.ietf.org/html/rfc7231#section-6 @see https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
protected function getPhrases(): array;
Devuelve la lista de códigos de estado disponibles
protected function processCode( mixed $code, mixed $phrase = string ): void;
Establece un código de estado y frase válidos
Namespace | Phalcon\Http\Message | Uses | Psr\Http\Message\ResponseInterface, Psr\Http\Message\ResponseFactoryInterface | Implements | ResponseFactoryInterface |
PSR-17 ResponseFactory
public function createResponse( int $code = int, string $reasonPhrase = string ): ResponseInterface;
Crea una nueva respuesta.
Namespace | Phalcon\Http\Message | Uses | Phalcon\Collection, Phalcon\Collection\CollectionInterface, Phalcon\Http\Message\Exception\InvalidArgumentException, Phalcon\Http\Message\Stream\Input, Psr\Http\Message\ServerRequestInterface, Psr\Http\Message\StreamInterface, Psr\Http\Message\UploadedFileInterface, Psr\Http\Message\UriInterface | Extends | AbstractRequest | Implements | ServerRequestInterface |
PSR-7 ServerRequest
/**
* @var Collection|CollectionInterface
*/
protected attributes;
/**
* Retrieve cookies.
*
* Retrieves cookies sent by the client to the server.
*
* The data MUST be compatible with the structure of the $_COOKIE
* superglobal.
*
* @var array
*/
protected cookieParams;
/**
* Retrieve any parameters provided in the request body.
*
* If the request Content-Type is either application/x-www-form-urlencoded
* or multipart/form-data, and the request method is POST, this method MUST
* return the contents of $_POST.
*
* Otherwise, this method may return any results of deserializing
* the request body content; as parsing returns structured content, the
* potential types MUST be arrays or objects only. A null value indicates
* the absence of body content.
*
* @var mixed
*/
protected parsedBody;
/**
* Retrieve query string arguments.
*
* 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.
*
* @var array
*/
protected queryParams;
/**
* Retrieve server parameters.
*
* Retrieves data related to the incoming request environment,
* typically derived from PHP's $_SERVER superglobal. The data IS NOT
* REQUIRED to originate from $_SERVER.
*
* @var array
*/
protected serverParams;
/**
* Retrieve normalized file upload data.
*
* 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().
*
* @var array
*/
protected uploadedFiles;
public function __construct( string $method = string, mixed $uri = null, array $serverParams = [], mixed $body = string, mixed $headers = [], array $cookies = [], array $queryParams = [], array $uploadFiles = [], mixed $parsedBody = null, string $protocol = string );
Constructor ServerRequest.
public function getAttribute( mixed $name, mixed $defaultValue = null ): mixed;
Devuelve un único atributo de la petición derivada.
Rescupera un único atributo de la petición derivada como se describe en getAttributes(). Si el atributo no se ha establecido previamente, devuelve el valor predeterminado tal como se haya proporcionado.
Este método evita la necesidad del método hasAttribute(), ya que permite especificar un valor predeterminado a devolver si el atributo no se encuentra.
public function getAttributes(): array;
Recupera atributos derivados de la petición.
Los ‘atributos’ de la petición se pueden usar para permitir la inyección de cualquier parámetro derivado de la petición: ej, los resultados de operaciones de coincidencia de rutas; los resultados de desencriptar cookies; los resultados de deserializar cuerpos de mensajes no-codificado-form; etc. Los atributos serán específicos de la aplicación y la petición, y PUEDEN ser mutables.
public function getCookieParams(): array
public function getParsedBody(): mixed
public function getQueryParams(): array
public function getServerParams(): array
public function getUploadedFiles(): array
public function withAttribute( mixed $name, mixed $value ): ServerRequest;
Devuelve una instancia con el atributo especificado de la petición derivada.
Este método permite establecer un único atributo de la petición derivada como se describe en getAttributes().
Este método se DEBE implementar de tal manera que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que tenga el atributo actualizado.
public function withCookieParams( array $cookies ): ServerRequest;
Devuelve una instancia con las cookies especificadas.
NO ES NECESARIO que los datos vengan del superglobal $_COOKIE, pero DEBEN ser compatibles con la estructura de $_COOKIE. Normalmente, estos datos serán inyectados en la instanciación.
Este método NO DEBE actualizar la cabecera Cookie
relacionada de la petición, ni los valores relacionados en los parámetros del servidor.
Este método se DEBE implementar de tal manera que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que tenga los valores de cookie actualizados.
public function withParsedBody( mixed $data ): ServerRequest;
Devuelve una instancia con los parámetros del cuerpo especificados.
Estos se PUEDE inyectar durante la instanciación.
Si el Content-Type
de la petición es application/x-www-form-urlencoded
o multipart/form-data
, y el método de la petición es POST, use este método SOLO para inyectar los contenidos de $_POST.
NO ES NECESARIO que los datos vengan de $_POST, pero DEBEN ser el resultado de deserializar el contenido del cuerpo de la petición. La deserialización/análisis devuelve datos estructurados, y, como tal, este método SOLO acepta vectores u objetos, o un valor nulo si no hay nada disponible para analizar.
Como ejemplo, si la negociación de contenido determina que los datos solicitados son una carga útil JSON, este método se podría usar para crear una instancia de petición con los parámetros deserializados.
Este método se DEBE implementar de tal forma que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que tenga los parámetros del cuerpo actualizados.
public function withQueryParams( array $query ): ServerRequest;
Devuelve una instancia con los argumentos de cadena de la consulta especificados.
Estos valores DEBERÍAN permanecer inmutables durante el transcurso de la petición entrante. Se PUEDEN inyectar durante la instanciación, como por ejemplo desde el superglobal $_GET de PHP, o se PUEDEN derivar desde algún otro valor como la URI. En los casos donde los argumentos son analizados desde la URI, los datos DEBEN ser compatibles con lo que la función parse_str()
de PHP devolvería para fijarse en cómo se manejan los parámetros de consulta duplicados, y como se manejan los conjuntos anidados.
Establecer argumentos de cadena de consulta NO DEBE cambiar la URI almacenada por la petición, ni los valores en los parámetros del servidor.
Este método se DEBE implementar de tal forma que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que tenga los argumentos de cadena de consulta actualizados.
public function withUploadedFiles( array $uploadedFiles ): ServerRequest;
Crea una nueva instancia con los ficheros subidos especificados.
Este método se DEBE implementar de tal forma que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que tenga los parámetros del cuerpo actualizados.
public function withoutAttribute( mixed $name ): ServerRequest;
Devuelve una instancia que elimina el atributo especificado de la petición derivada.
Este método permite eliminar un único atributo de la petición derivada como se describe en getAttributes().
Este método se DEBE implementar de tal manera que conserve la inmutabilidad del mensaje, y DEBE devolver una instancia que elimine el atributo.
Namespace | Phalcon\Http\Message | Uses | Phalcon\Collection, Phalcon\Collection\CollectionInterface, Phalcon\Helper\Arr, Phalcon\Http\Message\Exception\InvalidArgumentException, Psr\Http\Message\ServerRequestFactoryInterface, Psr\Http\Message\ServerRequestInterface, Psr\Http\Message\UriInterface, Psr\Http\Message\UploadedFileInterface | Implements | ServerRequestFactoryInterface |
PSR-17 ServerRequestFactory
public function createServerRequest( string $method, mixed $uri, array $serverParams = [] ): ServerRequestInterface;
Crea una nueva petición de servidor.
Tenga en cuenta que los parámetros de servidor se toman exactamente tal como se dan - no se realiza ningún análisis/procesamiento de los valores dados, y, en particular, no se intenta determinar el método HTTP o URI, que se debe proporcionar explícitamente.
public function load( array $server = null, array $get = null, array $post = null, array $cookies = null, array $files = null ): ServerRequest;
Crea una petición a partir de los valores superglobales proporcionados.
Si no se proporciona algún argumento, se usará el valor superglobal correspondiente.
protected function getHeaders();
Devuelve el apache_request_headers si existe
Namespace | Phalcon\Http\Message | Uses | Phalcon\Helper\Arr, Exception, Psr\Http\Message\StreamInterface, RuntimeException | Implements | StreamInterface |
PSR-7 Stream
/**
* @var resource | null
*/
protected handle;
/**
* @var resource | string
*/
protected stream;
public function __construct( mixed $stream, string $mode = string );
Constructor Stream.
public function __destruct();
Cierra el flujo cuando se destruye.
public function __toString(): string;
Lee todos los datos del flujo en un cadena, de principio a fin.
Este método DEBE intentar buscar el principio del flujo antes de leer datos y leer el flujo hasta alcanzar el final.
Advertencia: Esto podría intentar cargar una gran cantidad de datos en memoria.
Este método NO DEBE lanzar una excepción para cumplir con las operaciones de casting de cadena de PHP.
@see https://php.net/manual/en/language.oop5.magic.php#object.tostring
public function close(): void;
Cierra el flujo y cualquier recurso subyacente.
public function detach(): resource | null;
Separa cualquier recurso subyacente del flujo.
Después de que el flujo haya sido desvinculado, el flujo queda en un estado inutilizable.
public function eof(): bool;
Devuelve true
si el flujo está al final del flujo.
public function getContents(): string;
Devuelve el contenido restante en una cadena
public function getMetadata( mixed $key = null );
Obtiene metadatos del flujo como vector asociativo u obtiene una clave específica.
Las claves devueltas son idénticas a las claves devueltas por la función stream_get_meta_data() de PHP.
public function getSize(): null | int;
Obtiene el tamaño del flujo si se conoce.
public function isReadable(): bool;
Devuelve si el flujo es legible o no.
public function isSeekable(): bool;
Devuelve si el flujo es buscable o no.
public function isWritable(): bool;
Devuelve si el flujo es escribible o no.
public function read( mixed $length ): string;
Lee datos desde el flujo.
public function rewind(): void;
Busca el principio del flujo.
Si el flujo no se puede buscar, éste método lanzará una excepción; de lo contrario, realizará un seek(0).
public function seek( mixed $offset, mixed $whence = int ): void;
Intenta colocarse en una posición del flujo.
public function setStream( mixed $stream, string $mode = string ): void;
Establece el flujo - instancia existente
public function tell(): int;
Devuelve la posición actual del puntero de lectura/escritura del fichero
public function write( mixed $data ): int;
Escribe datos al flujo.
Namespace | Phalcon\Http\Message\Stream | Uses | Phalcon\Http\Message\Stream | Extends | Stream |
Describe un flujo de datos de “php://input”
Por lo general, una instancia envolverá un flujo PHP; esta interfaz proporciona una envoltura sobre las operaciones más comunes, incluyendo la serialización de todo el flujo a una cadena.
/**
* @var string
*/
private data = ;
/**
* @var bool
*/
private eof = false;
public function __construct();
Constructor Input.
public function __toString(): string;
Lee todos los datos del flujo en un cadena, de principio a fin.
Este método DEBE intentar buscar el principio del flujo antes de leer datos y leer el flujo hasta alcanzar el final.
Advertencia: Esto podría intentar cargar una gran cantidad de datos en memoria.
Este método NO DEBE lanzar una excepción para cumplir con las operaciones de casting de cadena de PHP.
@see https://php.net/manual/en/language.oop5.magic.php#object.tostring
public function getContents( int $length = int ): string;
Devuelve el contenido restante en una cadena
@throws RuntimeException if unable to read. @throws RuntimeException if error occurs while reading.
public function isWritable(): bool;
Devuelve si el flujo es escribible o no.
public function read( mixed $length ): string;
Lee datos desde el flujo.
Namespace | Phalcon\Http\Message\Stream | Uses | Phalcon\Http\Message\Stream | Extends | Stream |
Describe un flujo de datos de “php://memory”
Por lo general, una instancia envolverá un flujo PHP; esta interfaz proporciona una envoltura sobre las operaciones más comunes, incluyendo la serialización de todo el flujo a una cadena.
public function __construct( mixed $mode = string );
Constructor
Namespace | Phalcon\Http\Message\Stream | Uses | Phalcon\Http\Message\Stream | Extends | Stream |
Describe un flujo de datos de “php://temp”
Por lo general, una instancia envolverá un flujo PHP; esta interfaz proporciona una envoltura sobre las operaciones más comunes, incluyendo la serialización de todo el flujo a una cadena.
public function __construct( mixed $mode = string );
Constructor
Namespace | Phalcon\Http\Message | Uses | Phalcon\Http\Message\Exception\InvalidArgumentException, Psr\Http\Message\StreamFactoryInterface, Psr\Http\Message\StreamInterface | Implements | StreamFactoryInterface |
PSR-17 StreamFactory
public function createStream( string $content = string ): StreamInterface;
Crea un nuevo flujo a partir de una cadena.
El flujo se DEBERÍA crear con un recurso temporal.
public function createStreamFromFile( string $filename, string $mode = string ): StreamInterface;
Crea un flujo desde un fichero existente.
El fichero se DEBE abrir usando el modo dado, que puede ser cualquier modo soportado por la función fopen
.
$filename
PUEDE ser cualquier cadena soportada por fopen()
.
public function createStreamFromResource( mixed $phpResource ): StreamInterface;
Crea un nuevo flujo desde un recurso existente.
El flujo DEBE ser legible y puede ser escribible.
Namespace | Phalcon\Http\Message | Uses | Phalcon\Helper\Number, Phalcon\Helper\Arr, Phalcon\Helper\Str, Phalcon\Http\Message\Exception\InvalidArgumentException, Psr\Http\Message\StreamInterface, Psr\Http\Message\UploadedFileInterface, RuntimeException | Implements | UploadedFileInterface |
PSR-7 UploadedFile
/**
* If the file has already been moved, we hold that status here
*
* @var bool
*/
private alreadyMoved = false;
/**
* Retrieve the filename sent by the client.
*
* Do not trust the value returned by this method. A client could send
* a malicious filename with the intention to corrupt or hack your
* application.
*
* Implementations SHOULD return the value stored in the 'name' key of
* the file in the $_FILES array.
*
* @var string | null
*/
private clientFilename;
/**
* Retrieve the media type sent by the client.
*
* Do not trust the value returned by this method. A client could send
* a malicious media type with the intention to corrupt or hack your
* application.
*
* Implementations SHOULD return the value stored in the 'type' key of
* the file in the $_FILES array.
*
* @var string | null
*/
private clientMediaType;
/**
* Retrieve the error associated with the uploaded file.
*
* The return value MUST be one of PHP's UPLOAD_ERR_XXX constants.
*
* If the file was uploaded successfully, this method MUST return
* UPLOAD_ERR_OK.
*
* Implementations SHOULD return the value stored in the 'error' key of
* the file in the $_FILES array.
*
* @see https://php.net/manual/en/features.file-upload.errors.php
*
* @var int
*/
private error = 0;
/**
* If the stream is a string (file name) we store it here
*
* @var string
*/
private fileName = ;
/**
* Retrieve the file size.
*
* Implementations SHOULD return the value stored in the 'size' key of
* the file in the $_FILES array if available, as PHP calculates this based
* on the actual size transmitted.
*
* @var int | null
*/
private size;
/**
* Holds the stream/string for the uploaded file
*
* @var StreamInterface|string|null
*/
private stream;
public function __construct( mixed $stream, int $size = null, int $error = int, string $clientFilename = null, string $clientMediaType = null );
Constructor UploadedFile.
public function getClientFilename(): string | null
public function getClientMediaType(): string | null
public function getError(): int
public function getSize(): int | null
public function getStream(): mixed;
Devuelve un flujo que representa al fichero subido.
Este método DEBE devolver una instancia StreamInterface
, que representa al fichero subido. El propósito de este método es permitir utilizar funcionalidad de flujo de PHP nativa para manipular la subida de ficheros, tal como stream_copy_to_stream() (aunque el resultado necesitará ser decorado en un contenedor nativo de flujo de PHP para trabajar con tales funciones).
Si se ha llamado anteriormente al método moveTo(), este método DEBE lanzar una excepción.
public function moveTo( mixed $targetPath ): void;
Mueve un fichero subido a una nueva ubicación.
Use este método como alternativa a move_uploaded_file(). Se garantiza que este método funciona tanto en entornos SAPI como no SAPI. Las implementaciones debe determinar en qué entorno están, y usar el método apropiado (move_uploaded_file(), rename(), o una operación de flujo) para realizar la operación.
$targetPath puede ser una ruta absoluta, o una ruta relativa. Si es una ruta relativa, la resolución debería ser la misma que la usada por la función rename()
de PHP.
El fichero original o flujo se DEBE eliminar al completarse.
Si este método se llama más de una vez, cualquier llamada posterior DEBE lanzar una excepción.
Cuando se usa un entorno SAPI donde se rellena $_FILES, cuando se escriben los ficheros vía moveTo(), is_uploaded_file() y move_uploaded_file() se DEBERÍAN usar para asegurar que los permisos y el estado de subida son verificados correctamente.
Si desea moverse a un flujo, use getStream(), ya que las operaciones SAPI no pueden garantizar la escritura a destinos de flujo.
@see https://php.net/is_uploaded_file @see https://php.net/move_uploaded_file
Namespace | Phalcon\Http\Message | Uses | Psr\Http\Message\StreamInterface, Psr\Http\Message\UploadedFileInterface, Psr\Http\Message\UploadedFileFactoryInterface | Implements | UploadedFileFactoryInterface |
PSR-17 UploadedFileFactory
public function createUploadedFile( StreamInterface $stream, int $size = null, int $error = int, string $clientFilename = null, string $clientMediaType = null ): UploadedFileInterface;
Crea un nuevo fichero subido.
Si no se proporciona un tamaño, se determinará comprobando el tamaño del flujo.
@link https://php.net/manual/features.file-upload.post-method.php @link https://php.net/manual/features.file-upload.errors.php
Namespace | Phalcon\Http\Message | Uses | Phalcon\Helper\Arr, Phalcon\Helper\Str, Phalcon\Http\Message\Exception\InvalidArgumentException, Psr\Http\Message\UriInterface | Extends | AbstractCommon | Implements | UriInterface |
PSR-7 Uri
/**
* Returns the fragment of the URL
*
* @return string
*/
protected fragment = ;
/**
* Retrieve the host component of the URI.
*
* If no host is present, this method MUST return an empty string.
*
* The value returned MUST be normalized to lowercase, per RFC 3986
* Section 3.2.2.
*
* @see https://tools.ietf.org/html/rfc3986#section-3.2.2
*
* @return string
*/
protected host = ;
/**
* @var string
*/
protected pass = ;
/**
* Returns the path of the URL
*
* @return string
*/
protected path = ;
/**
* Retrieve the port component of the URI.
*
* If a port is present, and it is non-standard for the current scheme,
* this method MUST return it as an integer. If the port is the standard
* port used with the current scheme, this method SHOULD return null.
*
* If no port is present, and no scheme is present, this method MUST return
* a null value.
*
* If no port is present, but a scheme is present, this method MAY return
* the standard port for that scheme, but SHOULD return null.
*
* @return int|null
*/
protected port;
/**
* Returns the query of the URL
*
* @return string
*/
protected query = ;
/**
* Retrieve the scheme component of the URI.
*
* If no scheme is present, this method MUST return an empty string.
*
* The value returned MUST be normalized to lowercase, per RFC 3986
* Section 3.1.
*
* The trailing ":" character is not part of the scheme and MUST NOT be
* added.
*
* @see https://tools.ietf.org/html/rfc3986#section-3.1
*
* @return string
*/
protected scheme = https;
/**
* @var string
*/
protected user = ;
public function __construct( string $uri = string );
Constructor Uri.
public function __toString(): string;
Devuelve la representación de cadena como referencia URI.
Dependiendo de qué componentes de la URI estén presentes, la cadena resultante es una referencia completa o relativa de URI según RFC 3986, Sección 4.1. Este método concatena los distintos componentes de la URI, usando los delimitadores apropiados
public function getAuthority(): string;
Obtiene el componente autoridad de la URI.
public function getFragment()
public function getHost()
public function getPath()
public function getPort()
public function getQuery()
public function getScheme()
public function getUserInfo(): string;
Devuelve el componente de información de usuario de la URI.
Si no está presente la información de usuario, este método DEBE devolver una cadena vacía.
Si un usuario está presente en la URI, se devolverá ese valor; adicionalmente, si la contraseña también está presente, se añadirá al valor del usuario, con dos puntos (“:”) separando los valores.
El caracter “@” final no es parte de la información de usuario y NO DEBE ser añadido.
public function withFragment( mixed $fragment ): Uri;
Devuelve una instancia con el fragmento de URI especificado.
Este método DEBE mantener el estado de la instancia actual, y devolver una instancia que contenga el fragmento URI especificado.
Los usuarios pueden proporcionar tanto caracteres de fragmento codificados como decodificados. Las implementaciones aseguran la correcta codificación como se describe en getFragment()
.
Un valor de fragmento vacío es equivalente a eliminar el fragmento.
public function withHost( mixed $host ): Uri;
Devuelve una instancia con el servidor especificado.
Este método DEBE conservar el estado de la instancia actual, y devolver una instancia que contenga el servidor especificado.
Un valor de servidor vacío es equivalente a eliminar el servidor.
public function withPath( mixed $path ): Uri;
Devuelve una instancia con la ruta especificada.
Este método DEBE conservar el estado de la instancia actual, y devolver una instancia que contenga la ruta especificada.
La ruta puede estar vacía o ser absoluta (empezando con una barra) o sin raíz (no empezando con una barra). Las implementaciones DEBEN soportar las tres sintaxis.
Si una ruta HTTP está destinada a ser relativa al servidor en lugar de relativa a la ruta entonces debe empezar con una barra (“/”). Las rutas HTTP que no empiezan con una barra son relativas a alguna ruta base conocida por la aplicación o consumidor.
Los usuarios pueden proporcionar tanto caracteres de ruta codificados como decodificados. Las implementaciones se aseguran de la correcta codificación como se describe en getPath()
.
public function withPort( mixed $port ): Uri;
Devuelve una instancia con el puerto especificado.
Este método DEBE conservar el estado de la instancia actual, y devolver una instancia que contenga el puerto especificado.
Las implementaciones DEBEN lanzar una excepción para puertos fuera de los rangos de puertos TCP y UDP establecidos.
Un valor nulo proporcionado para el puerto es equivalente a eliminar la información del puerto.
public function withQuery( mixed $query ): Uri;
Devuelve una instancia con la cadena de consulta especificada.
Este método DEBE conservar el estado de la instancia actual, y devolver una instancia que contenga la cadena de consulta especificada.
Los usuarios pueden proporcionar tanto caracteres de consulta codificados como decodificados. Las implementaciones aseguran la correcta codificación como se describe en getQuery()
.
Una cadena de consulta vacía es equivalente a eliminar la cadena de consulta.
public function withScheme( mixed $scheme ): Uri;
Devuelve una instancia con el esquema especificado.
Este método DEBE conservar el estado de la instancia actual, y devolver una instancia que contenga el esquema especificado.
Las implementaciones DEBEN soportar los esquemas “http” y “https” insensibles a mayúsculas y minúsculas, y PUEDEN incluir otros esquemas si se requiere.
Un esquema vacío es equivalente a eliminar el esquema.
public function withUserInfo( mixed $user, mixed $password = null ): Uri;
Devuelve una instancia con la información de usuario especificada.
Namespace | Phalcon\Http\Message | Uses | Psr\Http\Message\UriFactoryInterface, Psr\Http\Message\UriInterface | Implements | UriFactoryInterface |
PSR-17 UriFactory
public function createUri( string $uri = string ): UriInterface;
Devuelve un objeto Localizador con todos los ayudantes definidos en funciones anónimas
Namespace | Phalcon\Http | Uses | Phalcon\Di\DiInterface, Phalcon\Di\AbstractInjectionAware, Phalcon\Events\ManagerInterface, Phalcon\Filter\FilterInterface, Phalcon\Helper\Json, Phalcon\Http\Request\File, Phalcon\Http\Request\FileInterface, Phalcon\Http\Request\Exception, UnexpectedValueException, stdClass | Extends | AbstractInjectionAware | Implements | RequestInterface |
Encapsula la información de la solicitud para un acceso fácil y seguro desde los controladores de la aplicación.
El objeto de solicitud es un objeto de valor simple que se pasa entre las clases del despachador y controlador. Empaqueta el entorno de solicitud HTTP.
use Phalcon\Http\Request;
$request = new Request();
if ($request->isPost() && $request->isAjax()) {
echo "Request was made using POST and AJAX";
}
// Retrieve SERVER variables
$request->getServer("HTTP_HOST");
// GET, POST, PUT, DELETE, HEAD, OPTIONS, PATCH, PURGE, TRACE, CONNECT
$request->getMethod();
// An array of languages the client accepts
$request->getLanguages();
//
private filterService;
/**
* @var bool
*/
private httpMethodParameterOverride = false;
/**
* @var array
*/
private queryFilters;
//
private putCache;
//
private rawBody;
/**
* @var bool
*/
private strictHostCheck = false;
public function get( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Obtiene una variable del superglobal $_REQUEST aplicando filtros si es necesario. Si no se pasan parámetros se devuelve el superglobal $_REQUEST
// Returns value from $_REQUEST["user_email"] without sanitizing
$userEmail = $request->get("user_email");
// Returns value from $_REQUEST["user_email"] with sanitizing
$userEmail = $request->get("user_email", "email");
public function getAcceptableContent(): array;
Obtiene un vector con tipos mime y su calidad aceptada por el navegador/cliente desde _SERVER[“HTTP_ACCEPT”]
public function getBasicAuth(): array | null;
Obtiene información de autenticación aceptada por el navegador/cliente desde $_SERVER[“PHP_AUTH_USER”]
public function getBestAccept(): string;
Obtiene el mejor tipo mime aceptado por el navegador/cliente desde _SERVER[“HTTP_ACCEPT”]
public function getBestCharset(): string;
Obtiene el mejor conjunto de caracteres aceptado por el navegador/cliente desde _SERVER[“HTTP_ACCEPT_CHARSET”]
public function getBestLanguage(): string;
Obtiene el mejor idioma aceptado por el navegador/cliente desde _SERVER[“HTTP_ACCEPT_LANGUAGE”]
public function getClientAddress( bool $trustForwardedHeader = bool ): string | bool;
Obtiene la mayoría posible de direcciones IPv4 de clientes. Este método busca en $_SERVER["REMOTE_ADDR"]
y opcionalmente en $_SERVER["HTTP_X_FORWARDED_FOR"]
public function getClientCharsets(): array;
Obtiene un vector del conjunto de caracteres y su calidad aceptada por el navegador/cliente desde _SERVER[“HTTP_ACCEPT_CHARSET”]
public function getContentType(): string | null;
Obtiene el tipo de contenido en el que se hizo la solicitud
public function getDigestAuth(): array;
Obtiene información de autenticación aceptada por el navegador/cliente desde $_SERVER[“PHP_AUTH_DIGEST”]
public function getFilteredPost( string $name = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Obtiene un valor post
siempre saneado con los filtros preestablecidos
public function getFilteredPut( string $name = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Obtiene un valor put
siempre saneado con los filtros preestablecidos
public function getFilteredQuery( string $name = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Obtiene una valor de consulta o get
siempre saneado con los filtros preestablecidos
public function getHTTPReferer(): string;
Obtiene la página web de referencia en la petición activa. ie: https://www.google.com
final public function getHeader( string $header ): string;
Obtiene la cabecera HTTP de los datos de la solicitud
public function getHeaders(): array;
Devuelve las cabeceras disponibles en la petición
$_SERVER = [
"PHP_AUTH_USER" => "phalcon",
"PHP_AUTH_PW" => "secret",
];</p>
<p>$headers = $request->getHeaders();</p>
<p>echo $headers[“Authorization”]; // Basic cGhhbGNvbjpzZWNyZXQ= </code>
public function getHttpHost(): string;
Obtiene el nombre de servidor usado por la petición.
Request::getHttpHost
intenta encontrar el nombre del servidor en el siguiente orden:
$_SERVER["HTTP_HOST"]
$_SERVER["SERVER_NAME"]
$_SERVER["SERVER_ADDR"]
Opcionalmente Request::getHttpHost
valida y limpia el nombre del servidor. Se puede usar Request::$strictHostCheck
para validar el nombre del servidor.
Nota: la validación y limpieza pueden tener un impacto negativo en el rendimiento porque usan expresiones regulares.
use Phalcon\Http\Request;
$request = new Request;
$_SERVER["HTTP_HOST"] = "example.com";
$request->getHttpHost(); // example.com
$_SERVER["HTTP_HOST"] = "example.com:8080";
$request->getHttpHost(); // example.com:8080
$request->setStrictHostCheck(true);
$_SERVER["HTTP_HOST"] = "ex=am~ple.com";
$request->getHttpHost(); // UnexpectedValueException
$_SERVER["HTTP_HOST"] = "ExAmPlE.com";
$request->getHttpHost(); // example.com
public function getHttpMethodParameterOverride(): bool
public function getJsonRawBody( bool $associative = bool ): \stdClass | array | bool;
Obtiene el cuerpo de la petición HTTP sin procesar decodificado en JSON
public function getLanguages(): array;
Obtiene el vector de idiomas y su calidad aceptada por el navegador/cliente desde _SERVER[“HTTP_ACCEPT_LANGUAGE”]
final public function getMethod(): string;
Obtiene el método HTTP en el que se ha hecho la petición
Si se establece la cabecera X-HTTP-Method-Override, y el método es POST, entonces se usa para determinar el método HTTP previsto “real”.
El parámetro de petición _method también se puede usar para determinar el método HTTP, pero sólo si se ha llamado a setHttpMethodParameterOverride(true).
El método siempre es una cadena en mayúscula.
public function getPort(): int;
Obtiene información sobre el puerto en el cual se realizó la solicitud.
public function getPost( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Obtiene una variable del superglobal $_POST aplicando filtros si es necesario. Si no se proporcionan parámetros se devuelve el superglobal $_POST
// Returns value from $_POST["user_email"] without sanitizing
$userEmail = $request->getPost("user_email");
// Returns value from $_POST["user_email"] with sanitizing
$userEmail = $request->getPost("user_email", "email");
public function getPreferredIsoLocaleVariant(): string;
Obtiene la variante de configuración regional ISO preferida.
Obtiene la variante de configuración regional preferida aceptada por el cliente desde la cabecera HTTP de la solicitud “Accept-Language” y devuelve parte de su base, ej. en
en vez de en-US
.
Nota: Este método depende de la cabecera $_SERVER["HTTP_ACCEPT_LANGUAGE"]
.
@link https://www.iso.org/standard/50707.html
public function getPut( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Obtiene una variable de la solicitud put
// Returns value from $_PUT["user_email"] without sanitizing
$userEmail = $request->getPut("user_email");
// Returns value from $_PUT["user_email"] with sanitizing
$userEmail = $request->getPut("user_email", "email");
public function getQuery( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Obtiene una variable del superglobal $_GET aplicando filtros si es necesario. Si no se proporcionan parámetros se devuelve el superglobal $_GET
// Returns value from $_GET["id"] without sanitizing
$id = $request->getQuery("id");
// Returns value from $_GET["id"] with sanitizing
$id = $request->getQuery("id", "int");
// Returns value from $_GET["id"] with a default value
$id = $request->getQuery("id", null, 150);
public function getRawBody(): string;
Obtiene el cuerpo de solicitud HTTP sin procesar
public function getScheme(): string;
Obtiene el esquema HTTP (http/https)
public function getServer( string $name ): string | null;
Obtiene una variable del superglobal $_SERVER
public function getServerAddress(): string;
Obtiene la IP de la dirección del servidor activo
public function getServerName(): string;
Obtiene el nombre del servidor activo
final public function getURI( bool $onlyPath = bool ): string;
Obtiene el HTTP URI en el cual se hizo la solicitud
// Returns /some/path?with=queryParams
$uri = $request->getURI();
// Returns /some/path
$uri = $request->getURI(true);
public function getUploadedFiles( bool $onlySuccessful = bool, bool $namedKeys = bool ): FileInterface[];
Obtiene los archivos adjuntos como instancias Phalcon\Http\Request\File
public function getUserAgent(): string;
Obtiene el agente de usuario HTTP utilizado para hacer la solicitud
public function has( string $name ): bool;
Comprueba si el superglobal $_REQUEST tiene un determinado índice
public function hasFiles(): bool;
Devuelve si la solicitud tiene archivos o no
final public function hasHeader( string $header ): bool;
Comprueba si las cabeceras tienen un cierto índice
public function hasPost( string $name ): bool;
Comprueba si el superglobal $_POST tiene un cierto índice
public function hasPut( string $name ): bool;
Comprueba si los datos PUT tienen un cierto índice
public function hasQuery( string $name ): bool;
Comprueba si el superglobal $_GET tiene un cierto índice
final public function hasServer( string $name ): bool;
Comprueba si el superglobal $_SERVER tiene un cierto índice
public function isAjax(): bool;
Comprueba si la petición se ha hecho usando ajax
public function isConnect(): bool;
Comprueba si el método HTTP es CONNECT. if _SERVER[“REQUEST_METHOD”]===”CONNECT”
public function isDelete(): bool;
Comprueba si el método HTTP es DELETE. if _SERVER[“REQUEST_METHOD”]===”DELETE”
public function isGet(): bool;
Comprueba si el método HTTP es GET. if _SERVER[“REQUEST_METHOD”]===”GET”
public function isHead(): bool;
Comprueba si el método HTTP es HEAD. if _SERVER[“REQUEST_METHOD”]===”HEAD”
public function isMethod( mixed $methods, bool $strict = bool ): bool;
Comprueba si el método HTTP coincide con cualquiera de los métodos pasados. Cuando strict
es true
comprueba si los métodos validados son métodos HTTP reales
public function isOptions(): bool;
Comprueba si el método HTTP es OPTIONS. if _SERVER[“REQUEST_METHOD”]===”OPTIONS”
public function isPatch(): bool;
Comprueba si el método HTTP es PATCH. if _SERVER[“REQUEST_METHOD”]===”PATCH”
public function isPost(): bool;
Comprueba si el método HTTP es POST. if _SERVER[“REQUEST_METHOD”]===”POST”
public function isPurge(): bool;
Comprueba si el método HTTP es PURGE (soporte Squid y Varnish). if _SERVER[“REQUEST_METHOD”]===”PURGE”
public function isPut(): bool;
Comprueba si el método HTTP es PUT. if _SERVER[“REQUEST_METHOD”]===”PUT”
public function isSecure(): bool;
Comprueba si la petición se ha hecho usando alguna capa segura
public function isSoap(): bool;
Comprueba si la petición se ha hecho usando SOAP
public function isStrictHostCheck(): bool;
Comprueba si el método Request::getHttpHost
usará validación estricta del nombre del servidor o no
public function isTrace(): bool;
Comprueba si el método HTTP es TRACE. if _SERVER[“REQUEST_METHOD”]===”TRACE”
public function isValidHttpMethod( string $method ): bool;
Comprueba si un método es un método HTTP válido
public function numFiles( bool $onlySuccessful = bool ): long;
Devuelve el número de archivos disponibles
public function setHttpMethodParameterOverride( bool $httpMethodParameterOverride )
public function setParameterFilters( string $name, array $filters = [], array $scope = [] ): RequestInterface;
Establece saneadores/filtros automáticos para un campo particular y para métodos particulares
public function setStrictHostCheck( bool $flag = bool ): RequestInterface;
Establece si el método Request::getHttpHost
debe usar validación estricta del nombre de servidor o no
final protected function getBestQuality( array $qualityParts, string $name ): string;
Procesa una cabecera de solicitud y devuelve la de mejor calidad
final protected function getHelper( array $source, string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Ayudante para obtener datos de los superglobales, aplicando filtros si es necesario. Si no se dan parámetros se devuelve el superglobal.
final protected function getQualityHeader( string $serverIndex, string $name ): array;
Procesa una cabecera de petición y devuelve un vector de valores con sus calidades
final protected function hasFileHelper( mixed $data, bool $onlySuccessful ): long;
Cuenta recursivamente ficheros en un vector de ficheros
protected function resolveAuthorizationHeaders(): array;
Resuelve cabeceras de autorización.
final protected function smoothFiles( array $names, array $types, array $tmp_names, array $sizes, array $errors, string $prefix ): array;
Simplifica $_FILES para tener un vector simple con todos los ficheros subidos
Namespace | Phalcon\Http\Request | Extends | \Phalcon\Exception |
Phalcon\Http\Request\Exception
Las excepciones lanzadas en Phalcon\Http\Request usarán esta clase
Namespace | Phalcon\Http\Request | Uses | Phalcon\Helper\Arr | Implements | FileInterface |
Phalcon\Http\Request\File
Provee envolturas OO al superglobal $_FILES
use Phalcon\Mvc\Controller;
class PostsController extends Controller
{
public function uploadAction()
{
// Check if the user has uploaded files
if ($this->request->hasFiles() == true) {
// Print the real file names and their sizes
foreach ($this->request->getUploadedFiles() as $file) {
echo $file->getName(), " ", $file->getSize(), "\n";
}
}
}
}
/**
* @var string|null
*/
protected error;
/**
* @var string
*/
protected extension;
/**
* @var string|null
*/
protected key;
//
protected name;
//
protected realType;
//
protected size;
//
protected tmp;
//
protected type;
public function __construct( array $file, mixed $key = null );
Constructor Phalcon\Http\Request\File
public function getError(): string|null
public function getExtension(): string
public function getKey(): string|null
public function getName(): string;
Devuelve el nombre real del fichero subido
public function getRealType(): string;
Obtiene el tipo mime real del fichero subido usando finfo
public function getSize(): int;
Devuelve el tamaño de fichero del fichero subido
public function getTempName(): string;
Devuelve el nombre temporal del fichero subido
public function getType(): string;
Devuelve el tipo mime notificado por el navegador. Este tipo mime no es completamente seguro, use getRealType() en su lugar
public function isUploadedFile(): bool;
Comprueba si el fichero se ha subido mediante Post.
public function moveTo( string $destination ): bool;
Mueve el fichero temporal a una ubicación dentro de la aplicación
Namespace | Phalcon\Http\Request |
Phalcon\Http\Request\FileInterface
Interfaz para Phalcon\Http\Request\File
public function getError(): string | null;
Devuelve el error, si lo hay
public function getName(): string;
Devuelve el nombre real del fichero subido
public function getRealType(): string;
Obtiene el tipo mime real del fichero subido usando finfo
public function getSize(): int;
Devuelve el tamaño de fichero del fichero subido
public function getTempName(): string;
Devuelve el nombre temporal del fichero subido
public function getType(): string;
Devuelve el tipo mime notificado por el navegador. Este tipo mime no es completamente seguro, use getRealType() en su lugar
public function moveTo( string $destination ): bool;
Mueve el fichero temporal a una ubicación
Namespace | Phalcon\Http | Uses | Phalcon\Http\Request\FileInterface, stdClass |
Interfaz para Phalcon\Http\Request
public function get( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Obtiene una variable del superglobal $_REQUEST aplicando filtros si es necesario. Si no se pasan parámetros se devuelve el superglobal $_REQUEST
// Returns value from $_REQUEST["user_email"] without sanitizing
$userEmail = $request->get("user_email");
// Returns value from $_REQUEST["user_email"] with sanitizing
$userEmail = $request->get("user_email", "email");
public function getAcceptableContent(): array;
Obtiene un vector con tipos mime y su calidad aceptada por el navegador/cliente desde _SERVER[“HTTP_ACCEPT”]
public function getBasicAuth(): array | null;
Obtiene información de autenticación aceptada por el navegador/cliente desde $_SERVER[“PHP_AUTH_USER”]
public function getBestAccept(): string;
Obtiene el mejor tipo mime aceptado por el navegador/cliente desde _SERVER[“HTTP_ACCEPT”]
public function getBestCharset(): string;
Obtiene el mejor conjunto de caracteres aceptado por el navegador/cliente desde _SERVER[“HTTP_ACCEPT_CHARSET”]
public function getBestLanguage(): string;
Obtiene el mejor idioma aceptado por el navegador/cliente desde _SERVER[“HTTP_ACCEPT_LANGUAGE”]
public function getClientAddress( bool $trustForwardedHeader = bool ): string | bool;
Obtiene la mayoría posible de direcciones IPv4 de clientes. Este método busca en $_SERVER[“REMOTE_ADDR”] y opcionalmente en $_SERVER[“HTTP_X_FORWARDED_FOR”]
public function getClientCharsets(): array;
Obtiene un vector del conjunto de caracteres y su calidad aceptada por el navegador/cliente desde _SERVER[“HTTP_ACCEPT_CHARSET”]
public function getContentType(): string | null;
Obtiene el tipo de contenido en el que se hizo la solicitud
public function getDigestAuth(): array;
Obtiene información de autenticación aceptada por el navegador/cliente desde $_SERVER[“PHP_AUTH_DIGEST”]
public function getHTTPReferer(): string;
Obtiene la página web de referencia en la petición activa. ie: https://www.google.com
public function getHeader( string $header ): string;
Obtiene la cabecera HTTP de los datos de la solicitud
public function getHeaders(): array;
Devuelve las cabeceras disponibles en la petición
$_SERVER = [
"PHP_AUTH_USER" => "phalcon",
"PHP_AUTH_PW" => "secret",
];
$headers = $request->getHeaders();
echo $headers["Authorization"]; // Basic cGhhbGNvbjpzZWNyZXQ=
public function getHttpHost(): string;
Obtiene el nombre de servidor usado por la petición.
Request::getHttpHost
intenta encontrar el nombre del servidor en el siguiente orden:
$_SERVER["HTTP_HOST"]
$_SERVER["SERVER_NAME"]
$_SERVER["SERVER_ADDR"]
Opcionalmente Request::getHttpHost
valida y limpia el nombre del servidor. Request::$_strictHostCheck
se puede usar para validar el nombre de servidor.
Nota: la validación y limpieza pueden tener un impacto negativo en el rendimiento porque usan expresiones regulares.
use Phalcon\Http\Request;
$request = new Request;
$_SERVER["HTTP_HOST"] = "example.com";
$request->getHttpHost(); // example.com
$_SERVER["HTTP_HOST"] = "example.com:8080";
$request->getHttpHost(); // example.com:8080
$request->setStrictHostCheck(true);
$_SERVER["HTTP_HOST"] = "ex=am~ple.com";
$request->getHttpHost(); // UnexpectedValueException
$_SERVER["HTTP_HOST"] = "ExAmPlE.com";
$request->getHttpHost(); // example.com
public function getJsonRawBody( bool $associative = bool ): stdClass | array | bool;
Obtiene el cuerpo de la petición HTTP sin procesar decodificado en JSON
public function getLanguages(): array;
Obtiene el vector de idiomas y su calidad aceptada por el navegador/cliente desde _SERVER[“HTTP_ACCEPT_LANGUAGE”]
public function getMethod(): string;
Obtiene el método HTTP en el que se ha hecho la petición
Si se establece la cabecera X-HTTP-Method-Override, y el método es POST, entonces se usa para determinar el método HTTP previsto “real”.
El parámetro de petición _method también se puede usar para determinar el método HTTP, pero sólo si se ha llamado a setHttpMethodParameterOverride(true).
El método siempre es una cadena en mayúscula.
public function getPort(): int;
Obtiene información sobre el puerto en el que se ha hecho la petición
public function getPost( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Obtiene una variable del superglobal $_POST aplicando filtros si es necesario. Si no se proporcionan parámetros se devuelve el superglobal $_POST
// Returns value from $_POST["user_email"] without sanitizing
$userEmail = $request->getPost("user_email");
// Returns value from $_POST["user_email"] with sanitizing
$userEmail = $request->getPost("user_email", "email");
public function getPut( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Obtiene una variable de la solicitud put
// Returns value from $_PUT["user_email"] without sanitizing
$userEmail = $request->getPut("user_email");
// Returns value from $_PUT["user_email"] with sanitizing
$userEmail = $request->getPut("user_email", "email");
public function getQuery( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;
Obtiene una variable del superglobal $_GET aplicando filtros si es necesario. Si no se proporcionan parámetros se devuelve el superglobal $_GET
// Returns value from $_GET["id"] without sanitizing
$id = $request->getQuery("id");
// Returns value from $_GET["id"] with sanitizing
$id = $request->getQuery("id", "int");
// Returns value from $_GET["id"] with a default value
$id = $request->getQuery("id", null, 150);
public function getRawBody(): string;
Obtiene el cuerpo de solicitud HTTP sin procesar
public function getScheme(): string;
Obtiene el esquema HTTP (http/https)
public function getServer( string $name ): string | null;
Obtiene una variable del superglobal $_SERVER
public function getServerAddress(): string;
Obtiene la IP de la dirección del servidor activo
public function getServerName(): string;
Obtiene el nombre del servidor activo
public function getURI( bool $onlyPath = bool ): string;
Obtiene el HTTP URI en el cual se hizo la solicitud
// Returns /some/path?with=queryParams
$uri = $request->getURI();
// Returns /some/path
$uri = $request->getURI(true);
public function getUploadedFiles( bool $onlySuccessful = bool, bool $namedKeys = bool ): FileInterface[];
Obtiene los archivos adjuntos como instancias compatibles con Phalcon\Http\Request\FileInterface
public function getUserAgent(): string;
Obtiene el agente de usuario HTTP utilizado para hacer la solicitud
public function has( string $name ): bool;
Comprueba si el superglobal $_REQUEST tiene un determinado índice
public function hasFiles(): bool;
Comprueba si la petición incluye ficheros adjuntos
public function hasHeader( string $header ): bool;
Comprueba si las cabeceras tienen un cierto índice
public function hasPost( string $name ): bool;
Comprueba si el superglobal $_POST tiene un cierto índice
public function hasPut( string $name ): bool;
Comprueba si los datos PUT tienen un cierto índice
public function hasQuery( string $name ): bool;
Comprueba si el superglobal $_GET tiene un cierto índice
public function hasServer( string $name ): bool;
Comprueba si el superglobal $_SERVER tiene un cierto índice
public function isAjax(): bool;
Comprueba si la petición se ha hecho usando ajax. Comprueba si $_SERVER[“HTTP_X_REQUESTED_WITH”] === “XMLHttpRequest”
public function isConnect(): bool;
Comprueba si el método HTTP es CONNECT. if $_SERVER[“REQUEST_METHOD”] === “CONNECT”
public function isDelete(): bool;
Comprueba si el método HTTP es DELETE. if $_SERVER[“REQUEST_METHOD”] === “DELETE”
public function isGet(): bool;
Comprueba si el método HTTP es GET. if $_SERVER[“REQUEST_METHOD”] === “GET”
public function isHead(): bool;
Comprueba si el método HTTP es HEAD. if $_SERVER[“REQUEST_METHOD”] === “HEAD”
public function isMethod( mixed $methods, bool $strict = bool ): bool;
Comprueba si el método HTTP coincide con alguno de los métodos pasados
public function isOptions(): bool;
Comprueba si el método HTTP es OPTIONS. if $_SERVER[“REQUEST_METHOD”] === “OPTIONS”
public function isPost(): bool;
Comprueba si el método HTTP es POST. if $_SERVER[“REQUEST_METHOD”] === “POST”
public function isPurge(): bool;
Comprueba si el método HTTP es PURGE (soporte Squid y Varnish). if $_SERVER[“REQUEST_METHOD”] === “PURGE”
public function isPut(): bool;
Comprueba si el método HTTP es PUT. if $_SERVER[“REQUEST_METHOD”] === “PUT”
public function isSecure(): bool;
Comprueba si la petición se ha hecho usando alguna capa segura
public function isSoap(): bool;
Comprueba si la petición se ha hecho usando SOAP
public function isTrace(): bool;
Comprueba si el método HTTP es TRACE. if $_SERVER[“REQUEST_METHOD”] === “TRACE”
public function numFiles( bool $onlySuccessful = bool ): long;
Devuelve el número de archivos disponibles
Namespace | Phalcon\Http | Uses | DateTime, DateTimeZone, Phalcon\Di, Phalcon\Di\DiInterface, Phalcon\Helper\Fs, Phalcon\Helper\Json, Phalcon\Http\Response\Exception, Phalcon\Http\Response\HeadersInterface, Phalcon\Http\Response\CookiesInterface, Phalcon\Url\UrlInterface, Phalcon\Mvc\ViewInterface, Phalcon\Http\Response\Headers, Phalcon\Di\InjectionAwareInterface, Phalcon\Events\EventsAwareInterface, Phalcon\Events\ManagerInterface | Implements | ResponseInterface, InjectionAwareInterface, EventsAwareInterface |
Parte del ciclo HTTP es devolver respuestas a los clientes. Phalcon\HTTP\Response es el componente Phalcon responsable de realizar esta tarea. Las respuestas HTTP suelen estar compuestas por cabeceras y cuerpo.
$response = new \Phalcon\Http\Response();
$response->setStatusCode(200, "OK");
$response->setContent("<html><body>Hello</body></html>");
$response->send();
//
protected container;
//
protected content;
//
protected cookies;
//
protected eventsManager;
//
protected file;
//
protected headers;
/**
* @var bool
*/
protected sent = false;
//
protected statusCodes;
public function __construct( string $content = null, mixed $code = null, mixed $status = null );
Constructor Phalcon\Http\Response
public function appendContent( mixed $content ): ResponseInterface;
Añade una cadena al cuerpo de respuesta HTTP
public function getContent(): string;
Obtiene el cuerpo de la respuesta HTTP
public function getCookies(): CookiesInterface;
Devuelve las cookies establecidas por el usuario
public function getDI(): DiInterface;
Devuelve el inyector de dependencias interno
public function getEventsManager(): ManagerInterface;
Devuelve el administrador de eventos interno
public function getHeaders(): HeadersInterface;
Devuelve las cabeceras establecidas por el usuario
public function getReasonPhrase(): string | null;
Devuelve la frase de razón
echo $response->getReasonPhrase();
public function getStatusCode(): int | null;
Devuelve el código de estado
echo $response->getStatusCode();
public function hasHeader( string $name ): bool;
Comprueba si existe una cabecera
$response->hasHeader("Content-Type");
public function isSent(): bool;
Comprueba si la respuesta ya se ha enviado
public function redirect( mixed $location = null, bool $externalRedirect = bool, int $statusCode = int ): ResponseInterface;
Redirige por HTTP a otra acción o URL
// Using a string redirect (internal/external)
$response->redirect("posts/index");
$response->redirect("http://en.wikipedia.org", true);
$response->redirect("http://www.example.com/new-location", true, 301);
// Making a redirection based on a named route
$response->redirect(
[
"for" => "index-lang",
"lang" => "jp",
"controller" => "index",
]
);
public function removeHeader( string $name ): ResponseInterface;
Elimina una cabecera en la respuesta
$response->removeHeader("Expires");
public function resetHeaders(): ResponseInterface;
Resetea todas las cabeceras establecidas
public function send(): ResponseInterface;
Muestra la respuesta HTTP al cliente
public function sendCookies(): ResponseInterface;
Envía las cookies al cliente
public function sendHeaders(): ResponseInterface | bool;
Envía las cabeceras al cliente
public function setCache( int $minutes ): ResponseInterface;
Establece las cabeceras de caché para usar la caché HTTP
$this->response->setCache(60);
public function setContent( string $content ): ResponseInterface;
Establece el cuerpo de respuesta HTTP
$response->setContent("<h1>Hello!</h1>");
public function setContentLength( int $contentLength ): ResponseInterface;
Establece la longitud del contenido de la respuesta
$response->setContentLength(2048);
public function setContentType( string $contentType, mixed $charset = null ): ResponseInterface;
Establece el tipo mime del contenido de la respuesta, opcionalmente el conjunto de caracteres
$response->setContentType("application/pdf");
$response->setContentType("text/plain", "UTF-8");
public function setCookies( CookiesInterface $cookies ): ResponseInterface;
Establece externamente una bolsa de cookies para la respuesta
public function setDI( DiInterface $container ): void;
Configura el inyector de dependencia
public function setEtag( string $etag ): ResponseInterface;
Establece un ETag personalizado
$response->setEtag(
md5(
time()
)
);
public function setEventsManager( ManagerInterface $eventsManager ): void;
Establece el administrador de eventos
public function setExpires( DateTime $datetime ): ResponseInterface;
Establece una cabecera Expires
en la respuesta que permite usar el caché HTTP
$this->response->setExpires(
new DateTime()
);
public function setFileToSend( string $filePath, mixed $attachmentName = null, mixed $attachment = bool ): ResponseInterface;
Establece un fichero adjunto a enviar al final de la petición
public function setHeader( string $name, mixed $value ): ResponseInterface;
Sobreescribe una cabecera en la respuesta
$response->setHeader("Content-Type", "text/plain");
public function setHeaders( HeadersInterface $headers ): ResponseInterface;
Establece externamente una bolsa de cabeceras para la respuesta
public function setJsonContent( mixed $content, int $jsonOptions = int, int $depth = int ): ResponseInterface;
Establece el cuerpo de respuesta HTTP. El parámetro se convierte automáticamente a JSON y también establece la cabecera predeterminada: Content-Type: “application/json; charset=UTF-8”
$response->setJsonContent(
[
"status" => "OK",
]
);
public function setLastModified( DateTime $datetime ): ResponseInterface;
Establece la cabecera Last-Modified
$this->response->setLastModified(
new DateTime()
);
public function setNotModified(): ResponseInterface;
Envía una respuesta Not-Modified
public function setRawHeader( string $header ): ResponseInterface;
Envía una cabecera en bruto a la respuesta
$response->setRawHeader("HTTP/1.1 404 Not Found");
public function setStatusCode( int $code, string $message = null ): ResponseInterface;
Establece el código de respuesta HTTP
$response->setStatusCode(404, "Not Found");
Namespace | Phalcon\Http\Response | Uses | Phalcon\Di\DiInterface, Phalcon\Di\AbstractInjectionAware, Phalcon\Http\Cookie\Exception, Phalcon\Http\Cookie\CookieInterface | Extends | AbstractInjectionAware | Implements | CookiesInterface |
Phalcon\Http\Response\Cookies
Esta clase es una bolsa para gestionar las cookies.
Una bolsa de cookies se registra automáticamente como parte del servicio ‘response’ en el DI. Por defecto, las cookies automáticamente se encriptan antes de enviarse al cliente y son desencriptadas cuando se recuperan desde el usuario. Para establecer la clave de firma a usar para generar un código de autenticación de mensaje use Phalcon\Http\Response\Cookies::setSignKey()
.
use Phalcon\Di;
use Phalcon\Crypt;
use Phalcon\Http\Response\Cookies;
$di = new Di();
$di->set(
'crypt',
function () {
$crypt = new Crypt();
// The `$key' should have been previously generated in a cryptographically safe way.
$key = "T4\xb1\x8d\xa9\x98\x05\\\x8c\xbe\x1d\x07&[\x99\x18\xa4~Lc1\xbeW\xb3";
$crypt->setKey($key);
return $crypt;
}
);
$di->set(
'cookies',
function () {
$cookies = new Cookies();
// The `$key' MUST be at least 32 characters long and generated using a
// cryptographically secure pseudo random generator.
$key = "#1dj8$=dp?.ak//j1V$~%*0XaK\xb1\x8d\xa9\x98\x054t7w!z%C*F-Jk\x98\x05\\\x5c";
$cookies->setSignKey($key);
return $cookies;
}
);
//
protected cookies;
//
protected registered = false;
/**
* The cookie's sign key.
* @var string|null
*/
protected signKey;
//
protected useEncryption = true;
public function __construct( bool $useEncryption = bool, string $signKey = null );
Constructor Phalcon\Http\Response\Cookies
public function delete( string $name ): bool;
Elimina una cookie por su nombre Este método no elimina las cookies del superglobal _COOKIE
public function get( string $name ): CookieInterface;
Obtiene una cookie de la bolsa
public function getCookies(): array;
Obtiene todas las cookies de la bolsa
public function has( string $name ): bool;
Comprueba si una cookie está definida en la bolsa o existe en el superglobal _COOKIE
public function isUsingEncryption(): bool;
Devuelve si la bolsa está encriptando/desencriptando cookies automáticamente
public function reset(): CookiesInterface;
Resetea las cookies establecidas
public function send(): bool;
Envía las cookies al cliente Las cookies no se envían si ya se han enviado las cabeceras en la petición actual
public function set( string $name, mixed $value = null, int $expire = int, string $path = string, bool $secure = null, string $domain = null, bool $httpOnly = null, array $options = [] ): CookiesInterface;
Establece una cookie a enviar al final de la petición.
Este método sobreescribe cualquier cookie establecida antes con el mismo nombre.
use Phalcon\Http\Response\Cookies;
$now = new DateTimeImmutable();
$tomorrow = $now->modify('tomorrow');
$cookies = new Cookies();
$cookies->set(
'remember-me',
json_encode(['user_id' => 1]),
(int) $tomorrow->format('U'),
);
public function setSignKey( string $signKey = null ): CookiesInterface;
Establece la clave de firma de la cookie.
`$signKey’ DEBE tener al menos 32 caracteres de longitud y generarse usando un generador pseudoaleatorio seguro criptográficamente.
Use NULL para deshabilitar la firma de cookies.
@see \Phalcon\Security\Random
public function useEncryption( bool $useEncryption ): CookiesInterface;
Establece si las cookies de la bolsa se deben encriptar/desencriptar automáticamente
Namespace | Phalcon\Http\Response | Uses | Phalcon\Http\Cookie\CookieInterface |
Phalcon\Http\Response\CookiesInterface
Interfaz para Phalcon\Http\Response\Cookies
public function delete( string $name ): bool;
Elimina una cookie por su nombre Este método no elimina las cookies del superglobal _COOKIE
public function get( string $name ): CookieInterface;
Obtiene una cookie de la bolsa
public function has( string $name ): bool;
Comprueba si una cookie está definida en la bolsa o existe en el superglobal _COOKIE
public function isUsingEncryption(): bool;
Devuelve si la bolsa está encriptando/desencriptando cookies automáticamente
public function reset(): CookiesInterface;
Resetea las cookies establecidas
public function send(): bool;
Envía las cookies al cliente
public function set( string $name, mixed $value = null, int $expire = int, string $path = string, bool $secure = null, string $domain = null, bool $httpOnly = null, array $options = [] ): CookiesInterface;
Establece una cookie para ser enviada al final de la petición
public function useEncryption( bool $useEncryption ): CookiesInterface;
Establece si las cookies de la bolsa se deben encriptar/desencriptar automáticamente
Namespace | Phalcon\Http\Response | Extends | \Phalcon\Exception |
Phalcon\Http\Response\Exception
Las excepciones lanzadas en Phalcon\Http\Response usarán esta clase.
Namespace | Phalcon\Http\Response | Implements | HeadersInterface |
Phalcon\Http\Response\Headers
Esta clase es una bolsa para gestionar las cabeceras de la respuesta
//
protected headers;
public function get( string $name ): string | bool;
Obtiene un valor de cabecera desde la bolsa interna
public function has( string $name ): bool;
Comprueba si existe una cabecera
public function remove( string $header ): HeadersInterface;
Elimina una cabecera que será enviada al final de la solicitud
public function reset();
Resetea las cabeceras establecidas
public function send(): bool;
Envía las cabeceras al cliente
public function set( string $name, string $value ): HeadersInterface;
Establece una cabecera para enviar al final de la petición
public function setRaw( string $header ): HeadersInterface;
Establece una cabecera en bruto para enviar al final de la petición
public function toArray(): array;
Devuelve las cabeceras actuales como un vector
Namespace | Phalcon\Http\Response |
Phalcon\Http\Response\HeadersInterface
Interfaz para bolsas compatibles con Phalcon\Http\Response\Headers
public function get( string $name ): string | bool;
Obtiene un valor de cabecera desde la bolsa interna
public function has( string $name ): bool;
Comprueba si existe una cabecera
public function reset();
Resetea las cabeceras establecidas
public function send(): bool;
Envía las cabeceras al cliente
public function set( string $name, string $value );
Establece una cabecera para enviar al final de la petición
public function setRaw( string $header );
Establece una cabecera en bruto para enviar al final de la petición
Namespace | Phalcon\Http | Uses | DateTime, Phalcon\Http\Response\HeadersInterface |
Phalcon\Http\Response
Interfaz para Phalcon\Http\Response
public function appendContent( mixed $content ): ResponseInterface;
Añade una cadena al cuerpo de respuesta HTTP
public function getContent(): string;
Obtiene el cuerpo de la respuesta HTTP
public function getHeaders(): HeadersInterface;
Devuelve las cabeceras establecidas por el usuario
public function getStatusCode(): int | null;
Devuelve el código de estado
public function hasHeader( string $name ): bool;
Comprueba si existe una cabecera
public function isSent(): bool;
Comprueba si la respuesta ya se ha enviado
public function redirect( mixed $location = null, bool $externalRedirect = bool, int $statusCode = int ): ResponseInterface;
Redirige por HTTP a otra acción o URL
public function resetHeaders(): ResponseInterface;
Resetea todas las cabeceras establecidas
public function send(): ResponseInterface;
Muestra la respuesta HTTP al cliente
public function sendCookies(): ResponseInterface;
Envía las cookies al cliente
public function sendHeaders(): ResponseInterface | bool;
Envía las cabeceras al cliente
public function setContent( string $content ): ResponseInterface;
Establece el cuerpo de respuesta HTTP
public function setContentLength( int $contentLength ): ResponseInterface;
Establece la longitud del contenido de la respuesta
public function setContentType( string $contentType, mixed $charset = null ): ResponseInterface;
Establece el tipo mime del contenido de la respuesta, opcionalmente el conjunto de caracteres
public function setExpires( DateTime $datetime ): ResponseInterface;
Establece la salida de la cabecera de tiempo de expiración
public function setFileToSend( string $filePath, mixed $attachmentName = null ): ResponseInterface;
Establece un fichero adjunto a enviar al final de la petición
public function setHeader( string $name, mixed $value ): ResponseInterface;
Sobreescribe una cabecera en la respuesta
public function setJsonContent( mixed $content ): ResponseInterface;
Establece el cuerpo de respuesta HTTP. El parámetro se convierte automáticamente a JSON
$response->setJsonContent(
[
"status" => "OK",
]
);
public function setNotModified(): ResponseInterface;
Envía una respuesta Not-Modified
public function setRawHeader( string $header ): ResponseInterface;
Envía una cabecera en bruto a la respuesta
public function setStatusCode( int $code, string $message = null ): ResponseInterface;
Establece el código de respuesta HTTP
Namespace | Phalcon\Http\Server | Uses | Psr\Http\Message\ResponseInterface, Psr\Http\Message\ServerRequestInterface, Psr\Http\Server\MiddlewareInterface, Psr\Http\Server\RequestHandlerInterface | Implements | MiddlewareInterface |
Participante en el procesamiento de una petición y respuesta del servidor.
Un componente middleware
HTTP participa en el procesamiento de un mensaje HTTP: actuando en la petición, generando la respuesta, o reenviando la petición a un middleware
posterior y posiblemente actuando en su respuesta.
abstract public function process( ServerRequestInterface $request, RequestHandlerInterface $handler ): ResponseInterface;
Procesa una petición de servidor entrante.
Procesa una petición de servidor entrante para producir una respuesta. Si es incapaz de producir una respuesta por sí mismo, puede delegar al gestor de la solicitud proporcionado para hacerlo.
Namespace | Phalcon\Http\Server | Uses | Psr\Http\Message\ResponseInterface, Psr\Http\Message\ServerRequestInterface, Psr\Http\Server\RequestHandlerInterface | Implements | RequestHandlerInterface |
Gestiona una petición del servidor y produce una respuesta.
Una gestor de petición HTTP procesa una petición HTTP para producir una respuesta HTTP.
abstract public function handle( ServerRequestInterface $request ): ResponseInterface;
Gestiona una petición y produce una respuesta.
Puede llamar a otro código colaborador para generar la respuesta.