Contrôleurs¶

form¶

$this->params['form']

Toute donnée transmise par POST depuis tout formulaire est stockée dans cette variable, incluant également les informations trouvées dans $_FILES.

admin¶

$this->params['admin']

Il est défini à 1 si l’action courante a été invoquée via le routage d’admin.

bare¶

$this->params['bare']

Stocke 1 si le layout courant est vide, 0 s’il ne l’est pas.

isAjax¶

$this->params['isAjax']

Vaut 1 si la requête courante est un appel ajax, 0 sinon. Cette variable est seulement définie si le Composant RequestHandler est utilisé par le contrôleur.

controller¶

$this->params['controller']

Stocke le nom du contrôleur courant qui manipule la requête. Par exemple, si l’URL /posts/voir/1 était appelée, $this->params['controller'] serait égal à « posts ».

action¶

$this->params['action']

Stocke le nom de l’action courante exécutant la requête. Par exemple, si l’URL /posts/voir/1 était interrogée, $this->params['action'] serait égal à « voir ».

pass¶

$this->params['pass']

Retourne un tableau (indexé numériquement) des paramètres d’URL situés après le nom de l’action.

// URL: /posts/voir/12/imprimer/reduire

Array
(
    [0] => 12
    [1] => imprimer
    [2] => reduire
)

url¶

$this->params['url']

Stocke l’URL courante interrogée, ainsi que les paires clé-valeur des variables passées en GET. Par exemple, si l’URL /posts/voir/?var1=3&var2=4 était appelée, $this->params['url'] devrait contenir :

[url] => Array
(
    [url] => posts/voir
    [var1] => 3
    [var2] => 4
)

data¶

$this->data

Utilisé pour traiter les données transmises au contrôleur, en POST, depuis les formulaires du Helper Form.

<?php

// Le Helper Form est utilisé pour créer un élément de formulaire
$form->text('Utilisateur.prenom');

Lequel, une fois affiché, ressemble à quelque chose comme :

<input name="data[Utilisateur][prenom]" value="" type="text" />

Quand le formulaire est soumis au contrôleur via POST, les données sont visibles dans this->data.

// Le prénom renseigné peut se trouver ici :
$this->data['Utilisateur']['prenom'];
?>

prefix¶

$this->params['prefix']

Rempli par le préfixe de routage. Par exemple, cet attribut contiendrait la chaîne « admin » durant une requête à /admin/posts/uneaction.

named¶

$this->params['named']

Stocke tout paramètre nommé dans la chaîne de requête, sous la forme /clé:valeur/. Par exemple, si l’URL /posts/voir/var1:3/var2:4 était demandée, $this->params['named'] serait un tableau contenant :

[named] => Array
(
    [var1] => 3
    [var2] => 4
)

set¶

set(string $variable, mixed $valeur)

La méthode set() est la voie principale utilisée pour transmettre des données de votre contrôleur à votre vue. Une fois set() utilisée, la variable de votre contrôleur devient accessible par la vue.

<?php

// Dans un premier temps vous passez les données depuis le contrôleur :
$this->set('couleur', 'rose');

// Ensuite vous pouvez les utiliser dans la vue de cette manière :
?>
Vous avez sélectionné un glaçage <?php echo $couleur; ?> pour le gâteau.

La méthode set() peut également prendre un tableau associatif comme premier paramètre. Cela peut souvent être une manière rapide d’affecter en une seule fois un jeu complet d’informations à la vue.

Les clefs de votre tableau ne seront plus infléchies avant d’être assignées à la vue (‘clef_avec_underscore’ ne devient plus ‘clefAvecUnderscore’, etc.).

<?php

$data = array(
    'couleur' => 'rose',
    'type' => 'sucré',
    'prix_de_base' => 23.95
);

//rend $couleur, $type, and $prixDeBase
//disponibles dans la vue:

$this->set($data);

?>

L’attribut $pageTitle n’existe plus, utilisez set() pour définir le titre.

<?php
$this->set('title_for_layout', 'Ceci est le titre de la page');
?>

render¶

render(string $action, string $layout, string $fichier)

La méthode render() est automatiquement appelée à la fin de chaque action exécutée par le contrôleur. Cette méthode exécute toute la logique liée à la présentation (en utilisant les variables transmises via la méthode set()), place le contenu de la vue à l’intérieur de sa mise en page et transmet le tout à l’utilisateur final.

Le fichier de vue utilisé par défaut est déterminé par convention. Ainsi, si l’action rechercher() de notre contrôleur RecettesController est demandée, le fichier de vue situé dans /app/view/recettes/rechercher.ctp sera utilisé.

class RecettesController extends AppController {
...
function rechercher() {
    // Affiche la vue située dans /views/recettes/rechercher.ctp
    $this->render();
}
...
}

Bien que CakePHP appellera cette fonction automatiquement à la fin de chaque action (à moins que vous n’ayez défini $this->autoRender à false), vous pouvez l’utiliser pour spécifier un fichier de vue alternatif en précisant le nom d’une action dans le contrôleur, via le paramètre $action.

Si $action commence avec un “/” on suppose que c’est un fichier de vue ou un élément dont le chemin est relatif au dossier /app/views. Cela permet un affichage direct des éléments, ce qui est très pratique lors d’appels ajax.

// Affiche l'élement situé dans /views/elements/ajaxretour.ctp
$this->render('/elements/ajaxretour');

Vous pouvez également spécifier un fichier alternatif en utilisant le troisième paramètre $file. Quant vous utilisez $file, n’oubliez pas d’utiliser les constantes globales de CakePHP (comme VIEWS).

Le second paramètre $layout vous permet de spécifier le fichier de mise en page qui sera utilisée pour afficher la vue.

Rendering a specific view¶

Si vous voulez afficher une autre vue de celle prévue par convention, vous pouvez le faire en appelant la méthode render() directement dans votre contrôleur. Une fois que vous avez appelée cette méthode, CakePHP chargera la vue que vous avez demandé d’afficher mais pas la vue prévue par convention.

class PostsController extends AppController {
    function mon_action() {
        $this->render('autre_vue');
    }
}

Ce code chargera la vue app/views/posts/autre_vue.ctp au lieu de la vue app/views/posts/mon_action.ctp

redirect¶

redirect(string $url, integer $status, boolean $exit)

La méthode de contrôle de flux que vous utiliserez le plus souvent est redirect(). Cette méthode prend son premier paramètre sous la forme d’une URL relative à votre application CakePHP. Quand un utilisateur a réalisé un paiement avec succès, vous aimeriez le rediriger vers un écran affichant le reçu.

<?php
function reglerAchats() {
    // Placez ici la logique pour finaliser l'achat...
    if($succes) {
        $this->redirect(array('controller'=>'paiements', 'action'=>'remerciements'));
    } else {
        $this->redirect(array('controller'=>'paiements', 'action'=>'confirmation'));
    }
}
?>

Vous pouvez aussi utiliser une URL relative ou absolue avec le paramètre $url :

$this->redirect('/paiements/remerciements'));
$this->redirect('http://www.exemple.com');

Vous pouvez aussi passer des données à l’action :

$this->redirect(array('action' => 'editer', $id));

Le second paramètre de la fonction redirect() vous permet de définir un code de statut HTTP accompagnant la redirection. Vous aurez peut-être besoin d’utiliser le code 301 (document déplacé de façon permanente) ou 303 (voir ailleurs), en fonction de la nature de la redirection.

Cette méthode réalise un exit() après la redirection, tant que vous ne mettez pas le troisième paramètre à false.

Si vous avez besoin de rediriger à la page appelante, vous pouvez utiliser :

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

flash¶

flash(string $message, string $url, integer $pause)

Tout comme redirect(), la méthode flash() est utilisée pour rediriger un utilisateur vers une autre page à la fin d’une opération. La méthode flash() est toutefois différente en ce sens qu’elle affiche un message avant de diriger l’utilisateur vers une autre url.

Le premier paramètre devrait contenir le message qui sera affiché et le second paramètre une URL relative à votre application CakePHP. CakePHP affichera le $message pendant $pause secondes avant de rediriger l’utilisateur.

Pour définir des messages flash dans une page, regardez du côté de la méthode setFlash() du composant Session (SessionComponent).

constructClasses¶

Cette méthode charge en mémoire les modèles requis par le contrôleur. Cette procédure de chargement est normalement effectuée par CakePHP, mais cette méthode est à garder sous le coude quand vous avez besoin d’accéder à certains contrôleurs depuis une perspective différente. Si vous avez besoin de CakePHP dans un script utilisable en ligne de commande ou d’autres utilisations externes, constructClasses() peut devenir pratique.

referer¶

Retourne l’URL référente de la requête courante.

disableCache¶

Utilisée pour indiquer au navigateur de l’utilisateur de ne pas mettre en cache le résultat de la requête courante. Ceci est différent du système de cache de vue couvert dans le chapitre suivant.

Les entêtes HTTP envoyés à cet effet sont :

• Expires: Mon, 26 Jul 1997 05:00:00 GMT

• Last-Modified: [current datetime] GMT

• Cache-Control: no-store, no-cache, must-revalidate

• Cache-Control: post-check=0, pre-check=0

• Pragma: no-cache

postConditions¶

postConditions(array $donnees, mixed $op, string $bool, boolean $exclusif)

Utilisez cette méthode pour transformer des données de formulaire, transmises par POST (depuis les inputs du Helper Form), en des conditions de recherche pour un modèle. Cette fonction offre un raccourci appréciable pour la construction de la logique de recherche. Par exemple, un administrateur aimerait pouvoir chercher des commandes dans le but de connaître quels produits doivent être emballés. Vous pouvez utiliser les Helpers Form et Html pour construire un formulaire rapide basé sur le modèle Commande. Ensuite une action du contrôleur peut utiliser les données postées par ce formulaire pour construire automatiquement les conditions de la recherche :

function index() {
    $conditions=$this->postConditions($this->data);
    $commandes = $this->Commande->find('all',compact('conditions'));
    $this->set('commandes', $orders);
}

Si $this->data[‘Commande’][‘destination’] vaut « Boulangerie du village », postConditions convertit cette condition en un tableau compatible avec la méthode Model->find(). Soit dans notre cas, array(« Commande.destination » => « Boulangerie du village »).

Si vous voulez utiliser un opérateur SQL différent entre chaque terme, remplacez-le en utilisant le second paramètre :

/*
Contenu de $this->data
array(
    'Commande' => array(
        'nb_items' => '4',
        'referrer' => 'Ye Olde'
    )
)
*/

//Trouvons les commandes qui ont au moins 4 items et qui contiennent ‘Ye Olde’
$conditions = $this->postConditions(
    $this->data,
    array(
        'nb_items' => '>=',
        'referrer' => 'LIKE'
    )
));
);
$commandes = $this->Commande->find("all",compact('conditions'));

Le troisième paramètre vous permet de dire à CakePHP quel opérateur booléen SQL utilisé entre les conditions de recherche. Les chaînes comme « AND », « OR » et « XOR » sont des valeurs possibles.

Enfin, si le dernier paramètre est défini à vrai et que $op est un tableau, les champs non-inclus dans $op ne seront pas inclus dans les conditions retournées.

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. Consultez la section pagination pour plus de détails sur l’utilisation de la pagination.

requestAction¶

requestAction(string $url, array $options)

Cette fonction appelle l’action d’un contrôleur depuis tout endroit du code et retourne les données associées à cette action. L”$url passée est une adresse relative à votre application CakePHP (/contrôleur/action/paramètres). Pour passer des données supplémentaires au contrôleur destinataire ajoutez le tableau $options.

Vous pouvez utiliser requestAction() pour récupérer l’intégralité de l’affichage d’une vue en passant la valeur “return” dans les options : requestAction($url, array('return'));

Si elle est utilisée sans cache, la méthode requestAction peut engendrer des faibles performances. Il est rarement approprié de l’utiliser dans un contrôleur ou un modèle.

requestAction est plutôt utilisé en conjonction avec des éléments (mis en cache) - comme moyen de récupérer les données pour un élément avant de l’afficher. Prenons l’exemple de la mise en place d’un élément « derniers commentaires » dans le gabarit (layout). Nous devons d’abord créer une méthode de controller qui retourne les données.

// controllers/commentaires_controller.php
class CommentairesController extends AppController {
    function derniers() {
        return $this->Commentaire->find('all', array('order' => 'Commentaire.created DESC', 'limit' => 10));
    }
}

Si nous créons un élément simple pour appeler cette fonction :

// views/elements/derniers_commentaires.ctp

$commentaires = $this->requestAction('/commentaires/derniers');
foreach($commentaires as $commentaire) {
    echo $commentaire['Commentaire']['title'];
}

On peut ensuite placer cet élément n’importe où pour obtenir la sortie en utilisant :

echo $this->element('derniers_commentaires');

Ecrit de cette manière, dès que l’élément est affiché, une requête sera faite au contrôleur pour obtenir les données, les données seront traitées, et retournées. Cependant, compte tenu de l’avertissement ci-dessus il vaut mieux utiliser des éléments mis en cache pour anticiper des traitements inutiles. En modifiant l’appel à l’élément pour qu’il ressemble à ceci :

echo $this->element('derniers_commentaires', array('cache'=>'+1 hour'));

L’appel à requestAction ne sera pas effectué tant que le fichier de vue de l’élément en cache existe et est valide.

De plus, requestAction prends désormais des urls basées sur des tableau dans le style de cake :

echo $this->requestAction(array('controller' => 'articles', 'action' => 'particuliers'), array('return'));

Cela permet à l’appel de requestAction d’éviter l’utilisation de Router::url ce qui peut améliorer la performance. Les url basées sur des tableaux sont les mêmes que celles utilisées par HtmlHelper::link avec une seule différence. Si vous utilisez des paramètres nommés ou passés dans vos url, vous devez les mettre dans un second tableau et les inclures dans la clé correcte. La raison de cela est que requestAction fusionne seulement le tableau des arguments nommés avec les membres du tableau de Controller::params et ne place pas les arguments nommés dans la clé “named”.

echo $this->requestAction('/articles/particuliers/limit:3');
echo $this->requestAction('/articles/voir/5');

Ceci en tant que tableau dans le requestAction serait alors :

echo $this->requestAction(array('controller' => 'articles', 'action' => 'particuliers'), array('named' => array('limit' => 3)));

echo $this->requestAction(array('controller' => 'articles', 'action' => 'voir'), array('pass' => array(5)));

A la différence d’autres endroits où les tableaux d’urls sont identiques aux chaînes d’url, requestAction les manipule différemment.

Lors de l’utilisation d’un tableau d’url en conjonction avec requestAction() vous devez spécifier tous les paramètres dont vous aurez besoin dans l’action demandée. Ceci inclut des paramètres comme $this->data et $this->params['form']. De plus, en passant tous les paramètres requis, named et pass doivent êtres conformes dans le second tableau, comme vu ci-dessus.

loadModel¶

loadModel(string $modelClass, mixed $id)

La fonction loadModel est très pratique quand vous avez besoin d’utiliser un modèle qui n’est pas le modèle par défaut du contrôleur ou ses modèles associés.

$this->loadModel('Article');
$articles_recents = $this->Article->find('all', array('limit' => 5, 'order' => 'Article.created DESC'));

$this->loadModel('Utilisateur', 2);
$utilisateur = $this->Utilisateur->read();