Requisições HTTP

Para usar primeiro adicione Inphinit\Http\Request no seu arquivo, por exemplo:

<?php
use Inphinit\Http\Request;

Obtendo o caminho HTTP

Pegando o caminho relativo/rota

<?php
namespace Controller;
use Inphinit\Http\Request;
class Examples
{
    public function foo()
    {
        return 'Caminho/rota atual: ' . Request::path(true);
    }
}

Pegando o caminho absoluto da URL:

public function foo()
{
    return 'Caminho completo: ' . Request::path();
}

Cabeçalhos

Pegando um cabeçalho especifico:

public function foo()
{
    return 'Seu navegador aceita as seguintes linguagens: ' . Request::header('accept-language');
}

Pegando todos os cabeçalhos:

public function foo()
{
    App::on('ready', function () {
        $headers = Request::header();
foreach($headers as $name => $value) {
            echo 'Nome: ', $name, ' - Valor: ', $value, '<br>', EOL;
        }
    });
}

Verificando HTTP

Verificando o verbo HTTP:

public function foo()
{
    if (Request::is('post')) {
        return 'Você está usando POST';
    }
return 'Você não está usando POST';
}

Variações:

Request::is('post');
Request::is('get');
Request::is('put');
Request::is('head');
Request::is('options');

Verificando se a requisição Ajax/Xhr (requer definir o cabeçalho X-Requested-With no XmlHttpRequest no front-end)

public function foo()
{
    if (Request::is('xhr')) {
        //algo aqui...
    }

Verifica se está usando Pjax (requer definir o cabeçalho X-Pjax no XmlHttpRequest no front-end)

public function foo()
{
    if (Request::is('pjax')) {
        //algo aqui...
    }

Verifica se está usando HTTPS:

public function foo()
{
    if (Request::is('secure')) {
        //algo aqui...
    }

Obtêm Querystring

Obtêm a querystring, é equivalente ao $_SERVER['QUERY_STRING'], but it avoids a problem with IIS.

public function foo()
{
    return 'Querystring: ' . Request::query();
}

Usando $_GET

Se você chamar http://example/bar?foo=123 retorna "123", se não definido retorna false

var_dump(Request::get('foo')); //Equals to $_GET['foo']

Você pode customizar o valor alternativo acaso o GET não for definido, por exemplo se foo= não for definido na URL retorna uma string com o valor alternativo, exemplo:

var_dump(Request::get('foo', 'valor alternativo'));

Para obter o valor de uma $_GET multi-dimensional você pode usar . (pontos, semelhante ao Xpath), então se você navegar para http://example/?foo[a][b][c]=123 você pode usar:

//Retorna uma string contendo "123"
Request::get('foo.a.b.c');
/*
 * Retorna uma array contendo algo como:
 * array(
 *     'a' => array(
 *         'b' => array(
 *             'b' => 123
 *         )
 *     )
 * )
 */
Request::get('foo');

Usando $_POST

É semelhante ao Inphinit\Http\Request::get, mas retorna os valores de $_POST

var_dump(Request::post('foo')); //O mesmo que $_POST['foo']

Você pode usar . em $_POST multi-dimensionais e também valores alternativos acaso a variável não exista

Request::post('foo.a.b.c');
Request::post('bar', 'valor alternativo');

Usando $_COOKIE

É semelhante ao Inphinit\Http\Request::get e ao Inphinit\Http\Request::post, mas retorna os valores de $_COOKIE

var_dump(Request::cookie('foo')); //O mesmo que $_COOKIE['foo']

Você pode usar . em $_COOKIE multi-dimensionais e também valores alternativos acaso a variável não exista

Request::cookie('foo.a.b.c');
Request::cookie('bar', 'valor alternativo');

Usando dados Raw POST

É equivalente ao $HTTP_RAW_POST_DATA e php://input, retorna um ponteiro ou false. Copiando o conteúdo para um arquivo:

<?php
namespace Controller;
use Inphinit\Storage;
use Inphinit\Http\Request;
class Examples
{
    public function foo()
    {
        $handle = Request::raw();
if ($handle && Storage::put('fotos/1.jpg', $handle)) {
            return 'Sucesso';
        }
return 'Erro';
    }
}

Usando $_FILES

Para obter os os arquivos de upload vindo da requisição:

Request::file('foo'); //Get from <input type="file" name="foo">
Request::file('foo.a.b.c'); //Get from <input type="file[a][b][c]" name="foo">

Este método não tem valor alternativo pois isto sempre retorna algo como:

array(
    'tmp_name' => <arquivo no servidor>,
    'name'     => <nome do arquivo definido no front-end>,
    'type'     => <type do arquivo definido no front-end (não é seguro)>,
    'error'    => <retorna o tipo de erro, acaso o ocorra>,
    'size'     => <tamanho do arquivo>
)