Aller au contenu principal
Version: Canary 🚧

Requêtes HTTP

Introduction​

Une requête HTTP est le message que l'utilisateur envoie à l'application Bow via son navigateur ou d'autres outils tels que curl, httpie, etc.

Ce message est traité par Bow à travers la classe Bow\Http\Request. Cette classe vous permet d'avoir les informations sur la requête envoyée par l'utilisateur comme son adresse IP, le type du message, les informations d'un formulaire, etc.

Accéder à la requête​

Pour capturer un message ou requête HTTP, vous pouvez premièrement utiliser le helper request() qui vous donne une instance de Bow\Http\Request, deuxièmement vous pouvez passer par l'injecteur de dépendance via une action de contrôleur.

Récupération des données​

En utilisant quelques méthodes simples, vous pouvez accéder à toutes les entrées utilisateur de votre application.

Via des Closures de route​

  • Avec le helper request:
$app->get('/', function () {
  $request = request();

  $name = $request->get('name');
  // code ici
});
  • Par l'injection de dépendance
routes/app.php
use Bow\Http\Request;

$app->get('/', function (Request $request) {
  return $request->get('name');
});

Via un controller​

Si votre méthode de contrôleur attend également une entrée d'un paramètre de route, vous devez répertorier les paramètres de votre route après vos autres dépendances. Par exemple, si votre route est définie comme suit :

$app->get('/users/:id', 'UserController::show');

Vous pouvez toujours taper la requête Bow\Http\Request et accéder à l'id de votre paramètre de route en définissant votre méthode de contrôleur comme suit:

namespace App\Controllers;

use App\Controllers\Controller;
use App\Models\User;
use Bow\Http\Request;

class UserController extends Controller
{
  /**
   * Afficher le profil pour l'utilisateur donné
   *
   * @param Request $request
   * @return mixed
   */
  public function show(Request $request, $id)
  {
    $user = User::where('id', $id)->first();

    $user->name = $request->get('name');

    $user->save();

    return $this->render('user/profile', ['user' => $user]);
  }
}

Chemin de requête et méthode​

Récupérer le chemin de requête​

La méthode path renvoie les informations de chemin de la requête. Ainsi, si la requête entrante est ciblée sur http://example.com/bar/zar, la méthode path retournera bar/zar:

$uri = $request->path();

La méthode is vous permet de vérifier que le chemin de requête entrant correspond à un modèle donné. Vous pouvez utiliser le caractère * comme caractère générique lorsque vous utilisez cette méthode:

if ($request->is('users/*')) {
  //
}

Récupérer la méthode de requête​

La méthode method retournera le verbe HTTP pour la requête. Vous pouvez utiliser les méthodes isPost, isGet, isPut, isDelete, isOptions, isPatch pour vérifier que le verbe HTTP correspond à une méthode HTTP de la requête donnée :

$method = $request->method();

if ($request->isPost()) {
  $filename = $request->file('filename');
  $filename->moveTo('/some/directory');
}

Vérifier si la requête est en AJAX​

Pour déterminer si une requête a été envoyée via AJAX, la méthode isAjax vous permet de vérifier cela.

if ($request->isAjax()) {
  //
}

Vérifier si la requête attend une réponse JSON​

La méthode wantsJson vous permet de vérifier si la requête attend une réponse au format JSON. Souvent, les requêtes AJAX sont envoyées avec l'en-tête Accept: application/json, la méthode wantsJson vérifie si cet en-tête est présent dans la requête.

if ($request->wantsJson()) {
  // code ici
}

Récupérer une entrée​

Souvent, la requête envoyée par le client HTTP contient des données souvent demandées pour actionner un mécanisme, par exemple celui d'une inscription.

Optimisation des données

Bow Framework, dans son démarrage, optimise les données envoyées au serveur en remplaçant les valeurs vides par null et en supprimant les espaces dans les valeurs de chaque champ avec la fonction PHP trim.

$name = $request->get('name');

// Récupérer directement la valeur via le nom du champ
$name = $request->name;
Valeur par défaut

Vous pouvez aussi définir une valeur par défaut à get.

$name = $request->get('name', 'Papac');

$name = $request->get('name', function () {
  return User::first()->name;
});

Ceci permet justement de récupérer le contenu du champ name d'un formulaire ou d'une URL en fonction du type de requête.

Récupération d'une partie des données d'entrée​

Si vous devez extraire un sous-ensemble des données d'entrée, vous pouvez utiliser les méthodes ignore et only. Ces deux méthodes acceptent un seul tableau ou une liste d'arguments dynamique:

$input = $request->only(['name', 'lastname']);

$input = $request->only('name', 'lastname');

$input = $request->ignore(['password']);

$input = $request->ignore('password');

Déterminer si une valeur d'entrée est présente​

Vous devez utiliser la méthode has pour déterminer si une valeur est présente sur la requête. La méthode has renvoie true si la valeur est présente dans la requête:

if ($request->has('name')) {
  //
}

Déterminer l'adresse IP du client​

Souvent, vous allez vouloir récupérer l'adresse IP du client ayant envoyé la requête. La méthode ip permet, comme son nom l'indique, de récupérer l'adresse IP du client :

$ip = $request->ip();

if ($ip == 'xxx.xxx.xxx.xxx') {
  // code ici
}

Déterminer le port du client​

La méthode port permet, comme son nom l'indique, de récupérer le port du client :

$port = $request->port();

// Code ici

Déterminer le protocole du client​

La méthode protocol permet, comme son nom l'indique, de récupérer le protocole du client :

$protocol = $request->protocol();

// Code ici

Il y a aussi la méthode isProtocol qui permet de faire de la vérification sur le protocole :

if ($request->isProtocol('http')) {
  //
}

Et isSecure vous permet de vérifier si la requête est sécurisée.

if ($request->isSecure()) {
  //
}

Récupérer les en-têtes HTTP​

Vous avez la possibilité de récupérer les en-têtes HTTP du client avec la méthode getHeader et hasHeader pour vérifier l'existence d'un en-tête HTTP.

$header = $request->getHeader('content-type');

echo $header;
// text/html

if ($request->hasHeader('x-proxy-key')) {
  // code ici
}

Récupérer l'IP du serveur​

Vous avez la possibilité de récupérer l'adresse IP du serveur sur lequel votre application Bow est hébergée.

$hostname = $request->hostname();

echo $hostname;
// exemple.com

Récupérer le domaine Origin​

Le domaine dit origin est l'adresse récupérée avec la méthode hostname ensuite associée au protocole de la requête.

$hostname = $request->origin();

echo $hostname;
// https://exemple.com

Récupérer le temps de la requête​

Il est souvent intéressant de voir combien de temps a pris une requête. La méthode time permet de le faire et elle retourne un timestamp.

$time = $request->time();

echo $time;

Récupérer une instance de la session​

Il est souvent intéressant de manipuler la session directement. La méthode session permet de le faire et elle retourne l'instance de la session.

$session = $request->session();

var_dump($session);
En savoir plus

Pour plus d'informations sur la session, visitez la page HTTP Session.

Récupérer l'authentification courante​

Vous pouvez aussi avoir l'authentification en cours si vous avez utilisé le système d'authentification native de Bow Framework.

$user = $request->user();

// Définir le guard
$user = $request->user('api');

Il manque quelque chose ?

Si vous rencontrez des problèmes avec la documentation ou si vous avez des suggestions pour améliorer la documentation ou le projet en général, veuillez déposer une issue pour nous, ou envoyer un tweet mentionnant le compte Twitter @bowframework ou sur directement sur le github.