Controllers (Contrôleurs)¶

Le Controller App¶

Comme indiqué dans l’introduction, la classe AppController est la classe mère de tous les controllers de votre application. AppController étend elle-même la classe Cake\Controller\Controller incluse dans la librairie du cœur de CakePHP. AppController est définie dans src/Controller/AppController.php comme ceci:

namespace App\Controller;

use Cake\Controller\Controller;

class AppController extends Controller
{
}

Les attributs et méthodes de controller créés dans AppController seront disponibles dans tous les controllers de votre application. Les Components (que vous découvrirez plus loin) sont plus appropriés pour du code utilisé dans la plupart des controllers (mais pas nécessairement tous).

Vous pouvez utiliser AppController pour charger les components qui seront utilisés dans tous les controllers de votre application. CakePHP fournit une méthode initialize() qui est appelée à la fin du constructeur du Controller pour ce type d’utilisation:

namespace App\Controller;

use Cake\Controller\Controller;

class AppController extends Controller
{

    public function initialize(): void
    {
        // Active toujours le component CSRF.
        $this->loadComponent('Csrf');
    }

}

En plus de la méthode initialize(), l’ancienne propriété $components vous permettra aussi de déclarer les components qui doivent être chargés. Bien que les règles d’héritage en orienté objet s’appliquent, les components et les helpers utilisés par un controller sont traités spécifiquement. Dans ces cas, les valeurs de la propriété de AppController sont fusionnées avec les tableaux de la classe de controller enfant. Les valeurs dans la classe enfant surchargeront toujours celles de AppController.

Déroulement d’une Requête¶

Quand une requête est faîte dans une application CakePHP, les classes Cake\Routing\Router et Cake\Routing\Dispatcher de CakePHP utilisent la fonctionnalité Connecter les Routes pour trouver et créer le bon controller. La requête de données est encapsulée dans un objet request. CakePHP met toutes les informations importantes de la requête dans la propriété $this->request. Consultez la section ServerRequest pour plus d’informations sur l’objet request de CakePHP.

Les Actions du Controller¶

Les actions du Controller sont responsables de la conversion des paramètres de la requête dans une réponse pour le navigateur/utilisateur faisant la requête. CakePHP utilise des conventions pour automatiser le processus et retirer quelques codes boiler-plate que vous auriez besoin d’écrire autrement.

Par convention, CakePHP rend une vue avec une version inflectée du nom de l’action. Revenons à notre boulangerie en ligne par exemple, notre RecipesController pourrait contenir les actions view(), share(), et search(). Le controller serait trouvé dans src/Controller/RecipesController.php et contiendrait:

// src/Controller/RecipesController.php

class RecipesController extends AppController
{
    public function view($id)
    {
        //la logique de l'action va ici.
    }

    public function share($customerId, $recipeId)
    {
        //la logique de l'action va ici.
    }

    public function search($query)
    {
        //la logique de l'action va ici.
    }
}

Les fichiers de template pour ces actions seraient templates/Recipes/view.php, templates/Recipes/share.php, et templates/Recipes/search.php. Le nom du fichier de vue est par convention le nom de l’action en minuscules et avec des underscores.

Les actions du Controller utilisent généralement Controller::set() pour créer un contexte que View utilise pour afficher la couche de vue. Du fait des conventions que CakePHP utilise, vous n’avez pas à créer et rendre la vue manuellement. Au lieu de ça, une fois qu’une action du controller est terminée, CakePHP va gérer le rendu et la livraison de la Vue.

Si pour certaines raisons, vous voulez éviter le comportement par défaut, vous pouvez retourner un objet de Cake\Http\Response de l’action avec la response complètement créée.

Afin que vous utilisiez efficacement le controller dans votre propre application, nous allons détailler certains des attributs et méthodes du cœur fournis par les controllers de CakePHP.

Interactions avec les Vues¶

Les Controllers interagissent avec les vues de plusieurs façons. Premièrement, ils sont capables de passer des données aux vues, en utilisant Controller::set(). Vous pouvez aussi décider quelle classe de vue utiliser, et quel fichier de vue doit être rendu à partir du controller.

// Dans un premier temps vous passez les données depuis le controller:

$this->set('couleur', 'rose');

// Ensuite vous pouvez les utiliser dans la vue de cette manière:
?>

Vous avez sélectionné un glaçage <?= $couleur; ?> pour le gâteau.

$data = [
    'couleur' => 'rose',
    'type' => 'sucre',
    'prix_de_base' => 23.95
];

// donne $couleur, $type, et $prix_de_base
// disponible dans la vue:

$this->set($data);

$this->viewBuilder()
    ->helpers(['MyCustom'])
    ->theme('Modern')
    ->className('Modern.Admin');

namespace App\Controller;

class RecipesController extends AppController
{
// ...
    public function search()
    {
        // Rend la vue située dans  templates/Recipes/search.php
        $this->render();
    }
// ...
}

// Rend un élément dans templates/element/ajaxreturn.php
$this->render('/element/ajaxreturn');

namespace App\Controller;

class PostsController extends AppController
{
    public function myAction()
    {
        $this->render('custom_file');
    }
}

namespace App\Controller;

class PostsController extends AppController
{
    public function my_action()
    {
        $this->render('Users.UserDetails/custom_file');
    }
}

Négociation de Contenu¶

Les controllers peuvent définir une liste des classes de vue qu’ils proposent. Une fois l’action du controller terminée, CakePHP utilisera cette liste de vues pour réaliser une négociation de contenu. Ainsi, votre application peut réutiliser la même action de controller pour rendre une vue HTML, ou une réponse JSON ou XML. La liste des classes de vue supportées par un controller est définie par la méthode viewClasses():

namespace App\Controller;

use Cake\View\JsonView;
use Cake\View\XmlView;

class PostsController extends AppController
{
    public function viewClasses()
    {
        return [JsonView::class, XmlView::class];
    }
}

Si aucune autre vue ne peut être sélectionnée d’après l’en-tête Accept des requêtes ou l’extension de routage, la classe basique View sera automatiquement utilisée comme classe de repli. Si votre application a besoin d’effectuer une logique différente selon les différents formats de réponse, vous pouvez utiliser $this->request->is() pour construire la logique conditionnelle dont vous avez besoin.

Rediriger vers d’Autres Pages¶

Cake\Controller\Controller::redirect(string|array $url, integer $status)¶

La méthode redirect() ajoute un en-tête Location et définit le code d’état de la réponse et la renvoie. Vous devez renvoyer la réponse créée par redirect() pour que CakePHP envoie la redirection au lieu de terminer l’action du contrôleur et rendre la vue.

vous pouvez rediriger en utilisant les valeurs du tableau de routing:

return $this->redirect([
    'controller' => 'Orders',
    'action' => 'confirm',
    $order->id,
    '?' => [
        'product' => 'pizza',
        'quantity' => 5
    ],
    '#' => 'top'
]);

Ou utiliser une URL relative ou absolue:

return $this->redirect('/orders/confirm');

return $this->redirect('http://www.example.com');

Ou rediriger vers l’URL appelante (referer):

return $this->redirect($this->referer());

En utilisant le deuxième paramètre, vous pouvez définir un code d’état pour votre redirection:

// Effectue un 301 (moved permanently)
return $this->redirect('/order/confirm', 301);

// Effectue un 303 (see other)
return $this->redirect('/order/confirm', 303);

Voir la section Utiliser des Redirections dans les Events des Components pour savoir comment rediriger hors de un gestionnaire de cycle de vie.

// Depuis l'action delete, vous pouvez rendre
// la liste mise à jour.
$this->setAction('index');

Chargement des Modèles Supplémentaires¶

Cake\Controller\Controller::fetchTable(string $alias, array $config = [])¶

La fonction fetchTable() devient pratique quand vous avez besoin d’utiliser une table autre que la table par défaut du controller:

// Dans une méthode de controller.
$recentArticles = $this->fetchTable('Articles')->find('all', [
    'limit' => 5,
    'order' => 'Articles.created DESC'
]);

Paginer un Modèle¶

Cake\Controller\Controller::paginate()¶

Cette méthode est utilisée pour paginer les résultats retournés par vos modèles. Vous pouvez définir les tailles de la page, les conditions à utiliser pour la recherche de ces données et bien plus encore. Consultez la section pagination pour plus de détails sur l’utilisation de la pagination.

L’attribut $paginate vous permet de de personnaliser le comportement de paginate():

class ArticlesController extends AppController
{
    public $paginate = [
        'Articles' => [
            'conditions' => ['published' => 1]
        ]
    ];
}

Configurer les Components à Charger¶

Cake\Controller\Controller::loadComponent($name, $config = [])¶

Dans la méthode initialize() de votre Controller, vous pouvez définir tout component que vous voulez charger et toute donnée de configuration pour eux:

public function initialize(): void
{
    parent::initialize();
    $this->loadComponent('Csrf');
    $this->loadComponent('Comments', Configure::read('Comments'));
}

Cycle de Vie des Callbacks de la Requête¶

Les controllers de CakePHP lancent plusieurs events/callbacks (méthodes de rappel) que vous pouvez utiliser pour insérer de la logique durant tout le cycle de vie de la requête:

//use Cake\Event\EventInterface;
public function beforeFilter(EventInterface $event)
{
    parent::beforeFilter($event);
}

Middleware de Controller¶

Cake\Controller\Controller::middleware($middleware, array $options = [])¶

Les Middlewares peuvent être définis globalement, dans le scope d’une routine ou dans un contrôleur. Pour définir un middleware pour un contrôleur spécifique, utilisez la méthode middleware() depuis l’intérieur de la méthode initialize() de votre contrôleur:

public function initialize(): void
{
    parent::initialize();

    $this->middleware(function ($request, $handler) {
        // Faire la logique du middleware.

        // Assurez-vous de renvoyer une réponse ou d'appeler handle()
        return $handler->handle($request);
    });
}

Les middlewares définis par un contrôleur seront appelés avant que beforeFilter() les méthodes d’action ne soient appelées.

Plus sur les Controllers¶