Pour Commencer

Le framework CakePHP fournit une base robuste pour votre application. Il peut gérer tous les aspects, de la requête initiale de l’utilisateur et son cheminement jusqu’au rendu final de la page web. Et puisque le framework suit les principes du MVC, il vous permet de facilement personnaliser et offre la plupart des aspects de votre application.

Le framework fournit aussi une structure organisationnelle basique, des noms de fichier jusqu’aux noms des tables de la base de données, en gardant toute votre application cohérente et logique. Ce concept est simple mais puissant. Suivez les conventions et vous saurez toujours exactement où les choses se trouvent et comment elles sont organisées.

La meilleure façon de découvrir et d’apprendre CakePHP est de s’assoir et de construire quelque chose. Pour commencer, nous construirons une application simple de blog.

Tutoriel d’un Blog

Bienvenue sur CakePHP. Vous consultez probablement ce tutoriel parce que vous voulez en apprendre plus à propos du fonctionnement de CakePHP. C’est notre but d’améliorer la productivité et de rendre le développement plus agréable : nous espérons que vous le découvrirez au fur et à mesure que vous plongerez dans le code.

Ce tutoriel vous accompagnera à travers la création d’une simple application de blog. Nous récupérerons et installerons CakePHP, créerons et configurerons une base de données et ajouterons suffisamment de logique applicative pour lister, ajouter, éditer et supprimer des posts.

Voici ce dont vous aurez besoin :

  1. Un serveur web fonctionnel. Nous supposerons que vous utilisez Apache, bien que les instructions pour utiliser d’autres serveurs doivent être assez semblables. Nous aurons peut-être besoin de jouer un peu sur la configuration du serveur, mais la plupart des personnes peuvent faire fonctionner CakePHP sans aucune configuration préalable.
  2. Un serveur de base de données. Dans ce tutoriel, nous utiliserons MySQL. Vous aurez besoin d’un minimum de connaissance en SQL afin de créer une base de données : CakePHP prendra les rênes à partir de là.
  3. Des connaissances de base en PHP. Plus vous aurez d’expérience en programmation orienté objet, mieux ce sera ; mais n’ayez crainte, même si vous êtes adepte de la programmation procédurale.
  4. Enfin, vous aurez besoin de connaissances de base à propos du motif de conception MVC. Un bref aperçu de ce motif dans le chapitre Comprendre le système M-V-C (Model-View-Controller). Ne vous inquiétez pas : il n’y a qu’une demi-page de lecture.

Maintenant, lançons-nous !

Obtenir CakePHP

Tout d’abord, récupérons une copie récente de CakePHP.

Pour obtenir la dernière version, allez sur le site GitHub du projet CakePHP : https://github.com/cakephp/cakephp/tags et téléchargez la dernière version de la 2.0.

Vous pouvez aussi cloner le dépôt en utilisant git:

git clone -b 2.x git://github.com/cakephp/cakephp.git

Peu importe comment vous l’avez téléchargé, placez le code à l’intérieur du « DocumentRoot » de votre serveur. Une fois terminé, votre répertoire d’installation devrait ressembler à quelque chose comme cela:

/chemin_du_document_root
    /app
    /lib
    /plugins
    /vendors
    .htaccess
    index.php
    README

A présent, il est peut-être temps de voir un peu comment fonctionne la structure de fichiers de CakePHP : lisez le chapitre Structure du dossier de CakePHP.

Permissions du répertoire Tmp

Ensuite vous devrez mettre le répertoire app/tmp en écriture pour le serveur web. La meilleur façon de le faire est de trouver sous quel utilisateur votre serveur web tourne. Vous pouver mettre <?php echo exec('whoami'); ?> à l’intérieur de tout fichier PHP que votre serveur web execute. Vous devriez voir afficher un nom d’utilisateur. Changez le possesseur du répertoire app/tmp pour cet utilisateur. La commande finale que vous pouvez lancer (dans *nix) pourrait ressembler à ceci:

$ chown -R www-data app/tmp

Si pour une raison ou une autre, CakePHP ne peut écrire dans ce répertoire, vous verrez des avertissements et des exceptions attrapées vous disant que les données de cache n’ont pas pu être écrites.

Créer la base de données du blog

Maintenant, mettons en place la base de données pour notre blog. Si vous ne l’avez pas déjà fait, créez une base de données vide avec le nom de votre choix pour l’utiliser dans ce tutoriel. Pour le moment, nous allons juste créer une simple table pour stocker nos posts. Nous allons également insérer quelques posts à des fins de tests. Exécutez les requêtes SQL suivantes dans votre base de données :

/* D'abord, créons la table des posts : */
CREATE TABLE posts (
    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(50),
    body TEXT,
    created DATETIME DEFAULT NULL,
    modified DATETIME DEFAULT NULL
);

/* Puis insérons quelques posts pour les tests : */
INSERT INTO posts (title, body, created)
    VALUES ('Le titre', 'Voici le contenu du post.', NOW());
INSERT INTO posts (title, body, created)
    VALUES ('Encore un titre', 'Et le contenu du post qui suit.', NOW());
INSERT INTO posts (title, body, created)
    VALUES ('Le retour du titre', 'C\'est très excitant, non ?', NOW());

Le choix des noms pour les tables et les colonnes ne sont pas arbitraires. Si vous respectez les conventions de nommage de CakePHP pour les bases de données et les classes (toutes deux expliquées au chapitre Conventions de CakePHP), vous tirerez profit d’un grand nombre de fonctionnalités automatiques et vous éviterez des étapes de configurations. CakePHP est suffisamment souple pour implémenter les pires schémas de bases de données, mais respecter les conventions vous fera gagner du temps.

Consultez le chapitre Conventions de CakePHP pour plus d’informations, mais il suffit de comprendre que nommer notre table “posts” permet de la relier automatiquement à notre model Post, et qu’avoir des champs “modified” et “created” permet de les avoir gérés automagiquement par CakePHP.

Configurer la base de données CakePHP

En avant : indiquons à CakePHP où se trouve notre base de données et comment s’y connecter. Pour la plupart d’entre vous, c’est la première et dernière fois que vous configurerez quelque chose.

Une copie du fichier de configuration CakePHP pour la base de données se trouve dans /app/Config/database.php.default. Faites une copie de ce fichier dans le même répertoire mais nommez le database.php.

Le fichier de configuration devrait être assez simple : remplacez simplement les valeurs du tableau $default par celles qui correspondent à votre installation. Un exemple de tableau de configuration complet pourrait ressembler à ce qui suit:

public $default = array(
    'datasource' => 'Database/Mysql',
    'persistent' => false,
    'host' => 'localhost',
    'port' => '',
    'login' => 'cakeBlog',
    'password' => 'c4k3-rUl3Z',
    'database' => 'cake_blog_tutorial',
    'schema' => '',
    'prefix' => '',
    'encoding' => 'utf8'
);

Une fois votre nouveau fichier database.php sauvegardé, vous devriez être en mesure d’ouvrir votre navigateur internet et de voir la page d’accueil de CakePHP. Elle devrait également vous indiquer que votre fichier de connexion a été trouvé, et que CakePHP peut s’y connecter avec succès.

Note

Rappelez-vous que vous aurez besoin d’avoir PDO, et pdo_mysql activés dans votre php.ini.

Configuration facultative

Il y a quelques autres éléments qui peuvent être configurés. La plupart des développeurs configurent les éléments de cette petite liste, mais ils ne sont pas obligatoires pour ce tutoriel. Le premier consiste à définir une chaîne de caractères personnalisée (ou « grain de sel ») afin de sécuriser les hashs. Le second consiste à définir un nombre personnalisé (ou « graine ») à utiliser pour le chiffrage.

Le « grain de sel » est utilisé pour générer des hashes. Changez la valeur par défaut de Security.salt dans /app/Config/core.php à la ligne 187. La valeur de remplacement doit être longue, difficile à deviner et aussi aléatoire que possible:

/**
 * Une chaîne aléatoire utilisée dans les méthodes de hachage sécurisées.
 */
Configure::write('Security.salt', 'pl345e-P45s_7h3*S@l7!');

La « graine cipher » est utilisée pour le chiffrage/déchiffrage des chaînes de caractères. Changez la valeur par défaut de Security.cipherSeed dans /app/Config/core.php à la ligne 192. La valeur de remplacement doit être un grand nombre entier aléatoire:

/**
 * Une chaîne aléatoire de chiffre utilisée pour le chiffrage/déchiffrage
 * des chaînes de caractères.
 */
Configure::write('Security.cipherSeed', '7485712659625147843639846751');

Une note sur mod_rewrite

Occasionnellement, les nouveaux utilisateurs peuvent avoir des problèmes de mod_rewrite. Par exemple si la page d’accueil de CakePHP a l’air bizarre (pas d’images ou de styles CSS), cela signifie probablement que mod_rewrite ne fonctionne pas sur votre système. Merci de vous référer à la section suivante sur l’URL rewriting pour que votre serveur web fonctionne:

Maintenant continuez sur Blog Tutoriel - Ajouter la logique pour commencer à construire votre première application CakePHP.

Blog Tutoriel - Ajouter la logique

Créer un model Post

La classe Model est le pain quotidien des applications CakePHP. En créant un model CakePHP qui interagira avec notre base de données, nous aurons mis en place les fondations nécessaires pour faire plus tard nos opérations de lecture, d’insertion, d’édition et de suppression.

Les fichiers des classes Model de CakePHP se trouvent dans /app/Model, et le fichier que nous allons créer maintenant sera enregistré dans /app/Model/Post.php. Le fichier complet devrait ressembler à ceci:

class Post extends AppModel {
}

La convention de nommage est vraiment très importante dans CakePHP. En nommant notre model Post, CakePHP peut automatiquement déduire que ce model sera utilisé dans le controller PostsController, et sera lié à la table posts de la base de données.

Note

CakePHP créera dynamiquement un objet model pour vous, s’il ne trouve pas le fichier correspondant dans /app/Model. Cela veut aussi dire que si vous n’avez pas nommé correctement votre fichier (par ex. post.php ou posts.php au lieu de Post.php), CakePHP ne reconnaîtra pas votre configuration et utilisera ses objets model par défaut.

Pour plus d’informations sur les models, comme les préfixes des tables, les callbacks, et la validation, consultez le chapitre Models (Modèles) du manuel.

Créer un controller Posts

Nous allons maintenant créer un controller pour nos posts. Le controller est l’endroit où s’exécutera toute la logique métier pour l’intéraction du processus de post. En un mot, c’est l’endroit où vous jouerez avec les models et où les tâches liées aux posts s’exécutent. Nous placerons ce nouveau controller dans un fichier appelé PostsController.php à l’intérieur du dossier /app/Controller. Voici à quoi devrait ressembler le controller de base:

class PostsController extends AppController {
    public $helpers = array('Html', 'Form');
}

Maintenant, ajoutons une action à notre controller. Les actions représentent souvent une simple fonction ou une interface dans une application. Par exemple, quand les utilisateurs requêtent www.exemple.com/posts/index (qui est la même chose que www.exemple.com/posts/), ils pourraient s’attendre à voir une liste de posts. Le code pour cette action devrait ressembler à quelque chose comme ça:

class PostsController extends AppController {
    public $helpers = array('Html', 'Form');

    public function index() {
        $this->set('posts', $this->Post->find('all'));
    }
}

En définissant la fonction index() dans notre PostsController, les utilisateurs peuvent accéder à cette logique en demandant www.exemple.com/posts/index. De la même façon, si nous devions définir une fonction appelée foobar(), les utilisateurs pourrait y accéder en demandant www.exemple.com/posts/foobar.

Avertissement

Vous pourriez être tenté de nommer vos controllers et vos actions d’une certaine manière pour obtenir une certaine URL. Résistez à cette tentation. Suivez les conventions CakePHP (le nom des controllers au pluriel, etc.) et nommez vos actions de façon lisible et compréhensible. Vous pouvez lier les URLs à votre code en utilisant ce qu’on appelle des « routes », on le verra plus tard.

La seule instruction que cette action utilise est set(), pour transmettre les données du controller à la vue (que nous créerons à la prochaine étape). La ligne définit la variable de vue appelée “posts” qui est égale à la valeur de retour de la méthode find('all') du model Post. Notre model Post est automatiquement disponible via $this->Post, parce que nous avons suivi les conventions de nommage de CakePHP.

Pour en apprendre plus sur les controllers de CakePHP, consultez le chapitre Controllers (Contrôleurs).

Créer les Vues des Posts

Maintenant que nous avons nos données en provenance du model, ainsi que la logique applicative et les flux définis par notre controller, nous allons créer une vue pour l’action « index » que nous avons créé ci-dessus.

Les vues de CakePHP sont juste des fragments de présentation « assaisonnée », qui s’intègrent au sein d’un layout applicatif. Pour la plupart des applications, elles sont un mélange de HTML et PHP, mais les vues peuvent aussi être constituées de XML, CSV ou même de données binaires.

Un Layout est un code de présentation, encapsulé autour d’une vue. Ils peuvent être définis et interchangés, mais pour le moment, utilisons juste celui par défaut.

Vous souvenez-vous, dans la dernière section, comment nous avions assigné la variable “posts” à la vue en utilisant la méthode set() ? Cela devrait transmettre les données à la vue qui ressemblerait à quelque chose comme cela:

// print_r($posts) affiche:

Array
(
    [0] => Array
        (
            [Post] => Array
                (
                    [id] => 1
                    [title] => Le titre
                    [body] => Voici le contenu du post.
                    [created] => 2008-02-13 18:34:55
                    [modified] =>
                )
        )
    [1] => Array
        (
            [Post] => Array
                (
                    [id] => 2
                    [title] => Encore un titre
                    [body] => Et le contenu du post qui suit.
                    [created] => 2008-02-13 18:34:56
                    [modified] =>
                )
        )
    [2] => Array
        (
            [Post] => Array
                (
                    [id] => 3
                    [title] => Le retour du titre
                    [body] => C'est très excitant, non ?
                    [created] => 2008-02-13 18:34:57
                    [modified] =>
                )
        )
)

Les fichiers des vues de CakePHP sont stockés dans /app/View à l’intérieur d’un dossier dont le nom correspond à celui du controller (nous aurons à créer un dossier appelé “Posts” dans ce cas). Pour mettre en forme les données de ces posts dans un joli tableau, le code de notre vue devrait ressembler à quelque chose comme cela

<!-- File: /app/View/Posts/index.ctp -->

<h1>Blog posts</h1>
<table>
    <tr>
        <th>Id</th>
        <th>Titre</th>
        <th>Créé le</th>
    </tr>

    <!-- Here is where we loop through our $posts array, printing out post info -->

    <?php foreach ($posts as $post): ?>
    <tr>
        <td><?php echo $post['Post']['id']; ?></td>
        <td>
            <?php echo $this->Html->link($post['Post']['title'],
            array('controller' => 'posts', 'action' => 'view', $post['Post']['id'])); ?>
        </td>
        <td><?php echo $post['Post']['created']; ?></td>
    </tr>
    <?php endforeach; ?>
    <?php unset($post); ?>
</table>

Vous avez sans doute remarqué l’utilisation d’un objet appelé $this->Html. C’est une instance de la classe CakePHP HtmlHelper. CakePHP est livré avec un ensemble de « helpers » (des assistants) pour les vues, qui réalisent en un clin d’œil des choses comme le « linking » (mettre les liens dans un texte), l’affichage des formulaires, du JavaScript et de l’AJAX. Vous pouvez en apprendre plus sur la manière de les utiliser dans le chapitre Helpers (Assistants), mais ce qu’il est important de noter ici, c’est que la méthode link() génèrera un lien HTML à partir d’un titre (le premier paramètre) et d’une URL (le second paramètre).

Lorsque vous indiquez des URLs dans CakePHP, il est recommandé d’utiliser les tableaux. Ceci est expliqué dans le chapitre des Routes. Utiliser les tableaux dans les URLs vous permet de tirer profit des capacités de CakePHP à ré-inverser les routes. Vous pouvez aussi utiliser les URLs relatives depuis la base de l’application comme suit /controller/action/param1/param2.

A ce stade, vous devriez être en mesure de pointer votre navigateur sur la page http://www.exemple.com/posts/index. Vous devriez voir votre vue, correctement formatée avec le titre et le tableau listant les posts.

Si vous avez essayé de cliquer sur l’un des liens que nous avons créés dans cette vue (le lien sur le titre d’un post mène à l’URL : /posts/view/un_id_quelconque), vous avez sûrement été informé par CakePHP que l’action n’a pas encore été définie. Si vous n’avez pas été informé, soit quelque chose s’est mal passé, soit en fait vous aviez déjà défini l’action, auquel cas vous êtes vraiment sournois ! Sinon, nous allons la créer sans plus tarder dans le Controller Posts:

// File: /app/Controller/PostsController.php
class PostsController extends AppController {
    public $helpers = array('Html', 'Form');

    public function index() {
         $this->set('posts', $this->Post->find('all'));
    }

    public function view($id = null) {
        if (!$id) {
            throw new NotFoundException(__('Invalid post'));
        }

        $post = $this->Post->findById($id);
        if (!$post) {
            throw new NotFoundException(__('Invalid post'));
        }
        $this->set('post', $post);
    }
}

L’appel de set() devrait vous être familier. Notez que nous utilisons findById() plutôt que find('all') parce que nous voulons seulement récupérer les informations d’un seul post.

Notez que notre action « view » prend un paramètre : l’ID du post que nous aimerions voir. Ce paramètre est transmis à l’action grâce à l’URL demandée. Si un utilisateur demande /posts/view/3, alors la valeur “3” est transmise à la variable $id.

Nous faisons aussi une petite vérification d’erreurs pour nous assurer qu’un utilisateur accède bien à l’enregsitrement. Si un utilisateur requête /posts/view, nous lancerons un NotFoundException et laisserons le Gestionnaire d’Erreur de CakePHP ErrorHandler prendre le dessus. Nous exécutons aussi une vérification similaire pour nous assurer que l’utilisateur a accède à un enregistrement qui existe.

Maintenant, créons la vue pour notre nouvelle action « view » et plaçons-la dans /app/View/Posts/view.ctp.

<!-- Fichier : /app/View/Posts/view.ctp -->

<h1><?php echo h($post['Post']['title']); ?></h1>

<p><small>Créé le : <?php echo $post['Post']['created']; ?></small></p>

<p><?php echo h($post['Post']['body']); ?></p>

Vérifiez que cela fonctionne en testant les liens de la page /posts/index ou en affichant manuellement un post via /posts/view/1.

Ajouter des Posts

Lire depuis la base de données et nous afficher les posts est un bon début, mais lançons-nous dans l’ajout de nouveaux posts.

Premièrement, commençons par créer une action add() dans le PostsController:

class PostsController extends AppController {
    public $helpers = array('Html', 'Form', 'Flash');
    public $components = array('Flash');

    public function index() {
        $this->set('posts', $this->Post->find('all'));
    }

    public function view($id) {
        if (!$id) {
            throw new NotFoundException(__('Invalid post'));
        }

        $post = $this->Post->findById($id);
        if (!$post) {
            throw new NotFoundException(__('Invalid post'));
        }
        $this->set('post', $post);
    }

    public function add() {
        if ($this->request->is('post')) {
            $this->Post->create();
            if ($this->Post->save($this->request->data)) {
                $this->Flash->success(__('Your post has been saved.'));
                return $this->redirect(array('action' => 'index'));
            }
            $this->Flash->error(__('Unable to add your post.'));
        }
    }
}

Note

$this->request->is() prend un unique argument, qui peut être la METHOD request (get, put, post, delete) ou toute identifier de request (ajax). Ce n’est pas une façon de vérifier une data postée spécifique. Par exemple, $this->request->is('book') ne retournera pas true si les data du book ont été postées.

Note

Vous avez besoin d’inclure le component Flash (FlashComponent) et le helper Flash (FlashHelper) dans chaque controller que vous utiliserez. Si nécessaire, incluez-les dans le controller principal (AppController) pour qu’ils soient accessibles à tous les controllers.

Voici ce que fait l’action add() : si la requête HTTP est de type POST, essayez de sauvegarder les données en utilisant le model « Post ». Si pour une raison quelconque, la sauvegarde a échouée, affichez simplement la vue. Cela nous donne une chance de voir les erreurs de validation de l’utilisateur et d’autres avertissements.

Chaque requête de CakePHP contient un objet CakeRequest qui est accessible en utilisant $this->request. Cet objet contient des informations utiles sur la requête qui vient d’être reçue, et permet de contrôler les flux de votre application. Dans ce cas, nous utilisons la méthode CakeRequest::is() pour vérifier que la requête est de type POST.

Lorsqu’un utilisateur utilise un formulaire pour poster des données dans votre application, ces informations sont disponibles dans $this->request->data. Vous pouvez utiliser les fonctions pr() ou debug() pour les afficher si vous voulez voir à quoi cela ressemble.

Nous utilisons la méthode FlashComponent::success() du component Flash (FlashComponent) pour définir un message dans une variable session et qui sera affiché dans la page juste après la redirection. Dans le layout, nous trouvons la fonction FlashHelper::render() qui permet d’afficher et de nettoyer la variable correspondante. La méthode Controller::redirect du controller permet de rediriger vers une autre URL. Le paramètre array('action' => 'index') sera traduit vers l’URL /posts (dans notre cas l’action « index » du controller « Posts »). Vous pouvez vous référer à la fonction Router::url() dans l’API pour voir les différents formats d’URL acceptés dans les différentes fonctions de CakePHP.

L’appel de la méthode save() vérifiera les erreurs de validation et interrompra l’enregistrement si une erreur survient. Nous verrons la façon dont les erreurs sont traitées dans les sections suivantes.

Nous appelons la méthode create() en premier afin de réinitialiser l’état du model pour sauvegarder les nouvelles informations. Cela ne crée pas réellement un enregistrement dans la base de données mais réinitialise Model::$id et définit Model::$data en se basant sur le champ par défaut dans votre base de données.

Valider les données

Cake place la barre très haute pour briser la monotonie de la validation des champs de formulaires. Tout le monde déteste le dévelopement de formulaires interminables et leurs routines de validations. Cake rend tout cela plus facile et plus rapide.

Pour tirer profit des fonctionnalités de validation, vous devez utiliser le helper « Form » (FormHelper) dans vos vues. FormHelper est disponible par défaut dans toutes les vues avec la variables $this->Form.

Voici le code de notre vue « add » (ajout)

<!-- Fichier : /app/View/Posts/add.ctp -->

<h1>Ajouter un post</h1>
<?php
echo $this->Form->create('Post');
echo $this->Form->input('title');
echo $this->Form->input('body', array('rows' => '3'));
echo $this->Form->end('Sauvegarder le post');
?>

Nous utilisons le FormHelper pour générer la balise d’ouverture d’une formulaire HTML. Voici le code HTML généré par $this->Form->create():

.. code-block:: html
<form id= »PostAddForm » method= »post » action= »/posts/add »>

Si create() est appelée sans aucun paramètre, CakePHP suppose que vous construisez un formulaire qui envoie les données en POST à l’action add() (ou edit() quand id est dans les données du formulaire) du controller actuel.

La méthode $this->Form->input() est utilisée pour créer des éléments de formulaire du même nom. Le premier paramètre dit à CakePHP à quels champs ils correspondent et le second paramètre vous permet de spécifier un large éventail d’options - dans ce cas, le nombre de lignes du textarea. Il y a un peu d’introspection et « d’automagie » ici : input() affichera différents éléments de formulaire selon le champ spécifié du model.

L’appel de la méthode $this->Form->end() génère un bouton de soumission et ajoute la balise de fermeture du formulaire. Si une chaîne de caractères est passée comme premier paramètre de la méthode end(), le helper « Form » affichera un bouton de soumission dont le nom correspond à celle-ci. Encore une fois, référez-vous au chapitre Helpers (Assistants) pour en savoir plus sur les helpers.

A présent, revenons en arrière et modifions notre vue /app/View/Posts/index.ctp pour ajouter un lien « Ajouter un post ». Ajoutez la ligne suivante avant <table>:

<?php echo $this->Html->link(
    'Ajouter un Post',
    array('controller' => 'posts', 'action' => 'add')
); ?>

Vous vous demandez peut-être : comment je fais pour indiquer à CakePHP mes exigences de validation ? Les règles de validation sont définies dans le model. Retournons donc à notre model Post et procédons à quelques ajustements:

class Post extends AppModel {
    public $validate = array(
        'title' => array(
            'rule' => 'notBlank'
        ),
        'body' => array(
            'rule' => 'notBlank'
        )
    );
}

Le tableau $validate indique à CakePHP comment valider vos données lorsque la méthode save() est appelée. Ici, j’ai spécifié que les deux champs « body » et « title » ne doivent pas être vides. Le moteur de validation de CakePHP est puissant, il dispose d’un certain nombre de règles intégrées (code de carte bancaire, adresse emails, etc.) et d’une souplesse pour ajouter vos propres règles de validation. Pour plus d’informations sur cette configuration, consultez le chapitre Validation des Données.

Maintenant que vos règles de validation sont en place, utilisez l’application pour essayer d’ajouter un post avec un titre et un contenu vide afin de voir comment cela fonctionne. Puisque que nous avons utilisé la méthode FormHelper::input() du helper « Form » pour créer nos éléments de formulaire, nos messages d’erreurs de validation seront affichés automatiquement.

Editer des Posts

L’édition de posts : nous y voilà. Vous êtes un pro de CakePHP maintenant, vous devriez donc avoir adopté le principe. Créez d’abord l’action puis la vue. Voici à quoi l’action edit() du controller Posts (PostsController) devrait ressembler:

public function edit($id = null) {
    if (!$id) {
        throw new NotFoundException(__('Invalid post'));
    }

    $post = $this->Post->findById($id);
    if (!$post) {
        throw new NotFoundException(__('Invalid post'));
    }

    if ($this->request->is(array('post', 'put'))) {
        $this->Post->id = $id;
        if ($this->Post->save($this->request->data)) {
            $this->Flash->success(__('Your post has been updated.'));
            return $this->redirect(array('action' => 'index'));
        }
        $this->Flash->error(__('Unable to update your post.'));
    }

    if (!$this->request->data) {
        $this->request->data = $post;
    }
}

Cette action s’assure d’abord que l’utilisateur a essayé d’accéder à un enregistrement existant. S’il n’y a pas de paramètre $id passé, ou si le post n’existe pas, nous lançons une NotFoundException pour que le gestionnaire d’Erreurs ErrorHandler de CakePHP s’en occupe.

Ensuite l’action vérifie si la requête est une requête POST ou PUT. Si elle l’est, alors nous utilisons les données POST pour mettre à jour notre enregistrement Post, ou sortir et montrer les erreurs de validation à l’utilisateur.

S’il n’y a pas de données définies dans $this->request->data, nous le définissons simplement dans le post récupéré précédemment.

La vue d’édition devrait ressembler à quelque chose comme cela:

<!-- Fichier: /app/View/Posts/edit.ctp -->

<h1>Editer le post</h1>
<?php
echo $this->Form->create('Post');
echo $this->Form->input('title');
echo $this->Form->input('body', array('rows' => '3'));
echo $this->Form->input('id', array('type' => 'hidden'));
echo $this->Form->end('Save Post');
?>

Cette vue affiche le formulaire d’édition (avec les données pré-remplies) avec les messages d’erreur de validation nécessaires.

Une chose à noter ici : CakePHP supposera que vous éditez un model si le champ “id” est présent dans le tableau de données. S’il n’est pas présent (ce qui revient à notre vue « add »), CakePHP supposera que vous insérez un nouveau model lorsque save() sera appelée.

Vous pouvez maintenant mettre à jour votre vue « index » avec des liens pour éditer des posts :

<!-- Fichier: /app/View/Posts/index.ctp  (lien d\'édition ajouté) -->

<h1>Blog posts</h1>
<p><?php echo $this->Html->link("Ajouter un Post", array('action' => 'add')); ?></p>
<table>
    <tr>
        <th>Id</th>
        <th>Title</th>
        <th>Action</th>
        <th>Created</th>
    </tr>

<!-- Ici se trouve la boucle de notre tableau $posts, impression de l\'info du post -->

<?php foreach ($posts as $post): ?>
    <tr>
        <td><?php echo $post['Post']['id']; ?></td>
        <td>
            <?php echo $this->Html->link(
                $post['Post']['title'],
                array('action' => 'view', $post['Post']['id'])
            ); ?>
        </td>
        <td>
            <?php echo $this->Html->link(
                'Editer',
                array('action' => 'edit', $post['Post']['id'])
            ); ?>
        </td>
        <td>
            <?php echo $post['Post']['created']; ?>
        </td>
    </tr>
<?php endforeach; ?>

</table>

Supprimer des Posts

A présent, mettons en place un moyen de supprimer les posts pour les utilisateurs. Démarrons avec une action delete() dans le controller Posts (PostsController):

public function delete($id) {
    if ($this->request->is('get')) {
        throw new MethodNotAllowedException();
    }

    if ($this->Post->delete($id)) {
        $this->Flash->success(
            __('Le post avec id : %s a été supprimé.', h($id))
        );
    } else {
        $this->Flash->error(
            __('Le post avec l\'id: %s n\'a pas pu être supprimé.', h($id))
        );
    }

    return $this->redirect(array('action' => 'index'));
}

Cette logique supprime le Post spécifié par $id, et utilise $this->Flash->success() pour afficher à l’utilisateur un message de confirmation après l’avoir redirigé sur /posts. Si l’utilisateur tente une suppression en utilisant une requête GET, une exception est levée. Les exceptions manquées sont capturées par le gestionnaire d’exceptions de CakePHP et un joli message d’erreur est affiché. Il y a plusieurs Exceptions intégrées qui peuvent être utilisées pour indiquer les différentes erreurs HTTP que votre application pourrait rencontrer.

Etant donné que nous exécutons juste un peu de logique et de redirection, cette action n’a pas de vue. Vous voudrez peut-être mettre à jour votre vue « index » avec des liens pour permettre aux utilisateurs de supprimer des Posts, ainsi :

<!-- Fichier: /app/View/Posts/index.ctp -->

<h1>Blog posts</h1>
<p><?php echo $this->Html->link(
    'Ajouter un Post',
    array('action' => 'add')
); ?></p>
<table>
    <tr>
        <th>Id</th>
        <th>Titre</th>
        <th>Actions</th>
        <th>Créé le</th>
    </tr>

<!-- Ici, nous bouclons sur le tableau $post afin d'afficher les informations des posts -->

    <?php foreach ($posts as $post): ?>
    <tr>
        <td><?php echo $post['Post']['id']; ?></td>
        <td>
            <?php echo $this->Html->link(
                $post['Post']['title'],
                array('action' => 'view', $post['Post']['id'])
            ); ?>
        </td>
        <td>
            <?php echo $this->Form->postLink(
                'Supprimer',
                array('action' => 'delete', $post['Post']['id']),
                array('confirm' => 'Etes-vous sûr ?'));
            ?>
            <?php echo $this->Html->link(
                'Editer',
                array('action' => 'edit', $post['Post']['id'])
            ); ?>
        </td>
        <td>
            <?php echo $post['Post']['created']; ?>
        </td>
    </tr>
    <?php endforeach; ?>

</table>

Utiliser postLink() permet de créer un lien qui utilise du Javascript pour supprimer notre post en faisant une requête POST. Autoriser la suppression par une requête GET est dangereux à cause des robots d’indexation qui peuvent tous les supprimer.

Note

Ce code utilise aussi le helper « Form » pour demander à l’utilisateur une confirmation avant de supprimer le post.

Routes

Pour certains, le routage par défaut de CakePHP fonctionne suffisamment bien. Les développeurs qui sont sensibles à la facilité d’utilisation et à la compatibilité avec les moteurs de recherches apprécieront la manière dont CakePHP lie des URLs à des actions spécifiques. Nous allons donc faire une rapide modification des routes dans ce tutoriel.

Pour plus d’informations sur les techniques de routages, consultez le chapitre Configuration des Routes.

Par défaut, CakePHP effectue une redirection d’une personne visitant la racine de votre site (par ex: http://www.exemple.com) vers le controller Pages (PagesController) et affiche le rendu de la vue appelée « home ». Au lieu de cela, nous voudrions la remplacer avec notre controller Posts (PostsController).

Le routage de CakePHP se trouve dans /app/Config/routes.php. Vous devrez commenter ou supprimer la ligne qui définit la route par défaut. Elle ressemble à cela:

Router::connect(
    '/',
    array('controller' => 'pages', 'action' => 'display', 'home')
);

Cette ligne connecte l’URL “/” à la page d’accueil par défaut de CakePHP. Nous voulons que cette URL soit connectée à notre propre controller, remplacez donc la ligne par celle-ci:

Router::connect('/', array('controller' => 'posts', 'action' => 'index'));

Cela devrait connecter les utilisateurs demandant “/” à l’action index() de notre controller Posts (PostsController).

Note

CakePHP peut aussi faire du “reverse routing” (ou routage inversé). Par exemple, pour la route définie plus haut, en ajoutant array('controller' => 'posts', 'action' => 'index') à la fonction retournant un tableau, l’URL “/” sera utilisée. Il est d’ailleurs bien avisé de toujours utiliser un tableau pour les URLs afin que vos routes définissent où vont les URLs, mais aussi pour s’assurer qu’elles aillent dans la même direction.

Conclusion

Créer des applications de cette manière vous apportera, paix, honneur, amour et argent au-delà même de vos fantasmes les plus fous. Simple n’est ce pas ? Gardez à l’esprit que ce tutoriel était très basique. CakePHP a beaucoup plus de fonctionnalités à offrir et il est aussi souple dans d’autres domaines que nous n’avons pas souhaité couvrir ici pour simplifier les choses. Utilisez le reste de ce manuel comme un guide pour développer des applications plus riches en fonctionnalités.

Maintenant que vous avez créé une application CakePHP basique, vous êtes prêt pour les choses sérieuses. Commencez votre propre projet et lisez le reste du Cookbook et l”API.

Si vous avez besoin d’aide, il y a plusieurs façons d’obtenir de l’aide - merci de regarder la page Où obtenir de l’aide Bienvenue sur CakePHP !

Prochaines lectures suggérées

Voici les différents chapitres que les gens veulent souvent lire après :

  1. Layouts: Personnaliser les Layouts de votre application.
  2. Elements: Inclure et ré-utiliser les portions de vues.
  3. Scaffolding: Construire une ébauche d’application sans avoir à coder.
  4. Génération de code avec Bake Générer un code CRUD basique.
  5. Authentification Simple et Autorisation de l’Application: Tutoriel sur l’enregistrement et la connexion d’utilisateurs.