Cours CAKEPHP

Introduction au CakePHP : le framework pour développer des applications


Télécharger Introduction au CakePHP : le framework pour développer des applications

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


CakePHP

le framework pour développer rapidement vos applications

Démarré en 2005 lorsque Ruby On Rails devenait populaire, le projet CakePHP compte désormais de nombreux utilisateurs et une communauté toujours plus active. Le framework se veut avant tout simple et efficace, en se basant sur le paradigme des conventions plutôt que de la configuration.


Cet article explique :

•   Les principales conventions utilisées par CakePHP.

•   La génération automatique des actions de base (CRUD) d'une application.

•   Les opérations usuelles sur les modèles et leurs relations.

•   Les principaux composants livrés avec le framework … pour se simplifier la vie dans les actions courantes (modélisation, formulaires, authentification, gestion des droits, i18n).

Niveau de difficulté

V

oici une présentation des points clés de CakePHP permettant de se lancer dans son apprentissage.

CakePHP a été conçu afin de faciliter au maximum la vie du développeur qui l'utilise. Cependant il faut au préalable comprendre la philosophie du framework et la suivre au départ de manière presque aveugle. Ce n'est qu'une fois les principes clés assimilés et les applications de base réalisées avec succès que l'on pourra se rendre compte de la réelle valeur ajoutée de CakePHP et de tous ces composants. Voici donc les points qui vous permettront de débuter sans encombre.

Des conventions plutôt que de la configuration

Un des principaux atouts de CakePHP contribuant à la mise en place rapide et à la magie du framework est son fonctionnement par conventions. En effet, le framework ne nécessite que très peu de configuration comme nous le verrons plus tard et se base sur une découverte intelligente de l'application d'après certaines conventions.

re actuelle le code d'une application est ame-

Ce qu'il faut savoir :

•   Connaissance du langage PHP 4+.

•   Notions de l'architecture MVC.

né à être maintenu, réutilisé ou partagé avec d'autres développeurs. D'autre part, la lecture d'un code développé par une autre personne peut s'avérer initialement difficile car la manière de développer (le style, l'organisation des fichiers …) est rarement documentée.

C'est là tout l'intérêt des conventions ! Elles permettent d'avoir une base commune et d'éviter de sur-documenter une application afin de se focaliser sur la valeur ajoutée et les parties importantes du code. À l'échelle d'une entreprise, ces conventions de codage

et de nommage sont bien souvent en place en Les conventions permettent également de interne … avec CakePHP cependant, vos consous-traiter certaines tâches classiques et ré- ventions seront désormais compréhensibles barbatives (intégrité des relations, récupéra- par tous !

tion et associations des modèles, mise à jour de Enfin, le respect des conventions permet une champs …) à CakePHP qui est livré avec un bon réduction non négligeable du code produit ce nombre de fonctionnalités utiles. qui augmente la lisibilité de celui-ci. Finis les

Avantages des conventions

En tant que développeur, chacun a pu se créer ses propres règles de codage et façons de travailler au fur et à mesure de ses expériences. Il est ainsi vu comme difficile (ou d'un intérêt limité) de changer sa manière de coder afin de se plier à une technologie (en l'occurrence CakePHP), mais nous espérons que ce paragraphe et toutes les belles choses décrites ci-après vous feront tenter l'expérience : vous avez beaucoup à y gagner !

Les conventions sont tout d'abord le meilleur moyen de pérenniser un code. En effet, à l'heu-

fichiers de configuration à rallonge, les bibliothèques de fonctions pratiques qui passent d'un projet à un autre, les bugs issus de méthodes de ces bibliothèques … CakePHP est livré avec de nombreuses fonctionnalités pratiques, grandement testées et bien documentées !

Principales conventions

Nous détaillerons ci-après la plupart des conventions à suivre dans un projet CakePHP, dans un but de compréhension et d'apprentissage. Cette liste n'est cependant pas exhaustive, nous vous invitons

De base, l'anglais est préférable

CakePHP est livré avec des mécanismes de reconnaissance singulier / pluriel optimisés pour la langue anglaise (exemple : people / person). Ainsi, afin de ne pas avoir de mauvaise surprise il est recommandé d'utiliser des mots anglais. C'est également une bonne chose pour le partage de votre code !

Bien que la plupart des mots français soient gérés (exemple : personnes / personne), des cas propres à notre langue ne pourront être reconnus (exemple : choux / chou ou bases_de_donnees / base_de_donnees) dans la version actuelle du framework. Par un système de configuration d'inflexions il est néanmoins possible de tenir compte de ces cas particuliers et la communauté française travaille actuellement en ce sens afin de proposer une version francisée du framework.

majuscule … comme les bosses d’un chameau !). De plus, les modèles doivent hériter de la classe

AppModel.

De même, les contrôleurs doivent se nommer comme les modèles mais au pluriel (également CamelCased), suivis du mot Controller et doivent hériter de la classe AppController.

Par exemple : la table my_messages aura pour modèle la classe MyMessage extends AppModel et le contrôleur sera MyMessagesController extends AppController.

Organisation des fichiers

Étant dans un framework MVC, les fichiers sont répartis dans 3 principaux dossiers à la racine de l'application : /models, views et controllers ! Un dossier /webroot contiendra toutes les ressources utilisées (javascript, css …) et tiendra lieu de racine de documents. Les noms de fichiers doivent être en minuscule et les mots séparés par des underscores_»). Le nom du fichier correspond en général à la classe qu'il contient (modèle ou contrôleur), ou à la vue à laquelle il est associé.

Base de données et champs automagiques

La modélisation de la base de données est l'élément primordial d'un projet. Si les conventions sont respectées, il sera ensuite possible de générer la plus grande partie du code (CRUD) associé en quelques minutes ! Nous détaillerons ceci plus loin.

Concernant les conventions, elles sont les suivantes :

Listing 1.Création de la base de données

CREATE TABLE 'users' (       'id' INT UNSIGNED NOTNULL AUTO_INCREMENT PRIMARYKEY ,

      'name' VARCHAR( 100 ) NOTNULL ,       'email' VARCHAR( 100 ) NOTNULL ) ;

CREATE TABLE 'messages' (       'id' INT UNSIGNED NOTNULL AUTO_INCREMENT PRIMARYKEY ,

      'title' VARCHAR( 150 ) NOTNULL ,

      'content' TEXT NOTNULL ,

      'user_id' INT UNSIGNED NOTNULL ,

      'created' DATETIME NOTNULL ,

      'modified' DATETIME NOTNULL ) ;

Listing 2.Création du modèle user dans le fichier

class User extends AppModel {       var $name = 'User';

   }

?>

Listing 3.Création du modèle message dans le fichier

<?php

class Message extends AppModel {       var $name = 'Message';       var $belongsTo = 'User';

   }

?>

Listing 4.Création du contrôleur user dans le fichier

<?php

class UsersController extends AppController {

var $scaffold; // Cette ligne permet de passer en mode prototypage

                     // rapide pour ce contrôleur

   }

?>

Listing 5.Création du contrôleur message dans le fichier

<?php

class MessagesController extends AppController {       var $scaffold;

   }

?>

•     le nom de la table doit être en minuscules et au pluriel (exemple : my_messages),

•     un champ id devra être présent et pourra être de deux types : entier auto-incrémentable ou une chaîne de 36 caractères (CHAR(36)) auquel cas l'identifiant généré sera un UUID,

•     une clé étrangère devra porter le nom du modèle référencé au singulier suivi de _id (exemple : user_id).

D'autre part on trouve des champs automagiques. On les nomme de cette manière car ces champs seront renseignés automatiquement par Cake lors de la sauvegarde d'informations (ils ne sont en aucun cas obligatoires !).

•     le champ created de type DATETIME contiendra la date de création de l'élément,

•     le champ modified ou updated contiendra la date de dernière modification de celui-ci,



•     le champ title ou name sera utilisé comme intitulé de l'élément lors de son affichage sur le site. Dans le cas où aucun de ces champs n'existe, c'est l'identifiant qui sera utilisé,

Un dernier exemple un peu plus poussé : si un utilisateur est associé à plusieurs messages (c'est-à- dire que la table messages contient un champ user_id), il suffit d'ajouter un champ de type entier (INT) nommé message_count dans la table users afin que celui-ci soit automatiquement incrémenté et décrémenté … et contienne à tout instant le nombre de messages associés à l'utilisateur.

Modèles et contrôleurs : nommage des classes

Afin d'utiliser votre base de données, vous aurez besoin d'une classe de modèle qui gérera tous les aspects liés à votre modèle (validation, associations, actions métier …) et une classe contrôleur chargée de gérer les évènements et d'appeler les méthodes adéquates du modèle pour transmettre les informations utiles à la vue. Renseignez-vous sur le modèle MVC pour mieux comprendre ces concepts !

Pour CakePHP les classes de modèle doivent porter le nom de la table associée au modèle, au singulier et CamelCased (c’est-à-dire que l’on supprime les underscores du nom de fichier et on met la première lettre de chaque mot en


Chargement automatique de fichiers

Ainsi, rien qu'en suivant les conventions précédentes et sans ligne de code supplémentaire votre application est prête à être exécutée ! (Note : en réalité il faudra simplement relier votre application au coeur de CakePHP et configurer la connexion à la base de données dans un fichier ). Voyons ce qui se passera à l'appel d'une page :

•     appel de l'URL my_messages/hello,

Le prototypage rapide est une fonctionnalité permettant d'analyser votre base de données et de vous fournir des formulaires permettant toutes les actions CRUD (ajout, visualisation, mise à jour et suppression) d'un objet et de ceux qui y sont associés. Prenons l'exemple d'une base de données gérant des utilisateurs

et leurs messages de manière simpliste. Nous devrons donc créer 2 tables telles que décrit dans le Listing 1.

Le plus difficile est effectué, analysons désormais les modèles associés dans lesquels nous indiquons qu'un message appartient à un utilisateur. Cette étape est présentée dans les Listing

•     exécution de la méthode hello() de la classe MyMessagesController située dans le fichier /controllers/my_messages_ ,

•     le contrôleur fera sans doute appel à une méthode du modèle MyMessage située dans le fichier qu'il connaîtra automatiquement,

Listing 6.Méthode classique de création d'un nouvel objet en base de données

function add() {

if(!empty($this->data)) {       $this->Recette->create();

if ($this->Recette->save($this->data)) {          $this->Session->setFlash(__('The Recette has been saved', true)); $this->redirect(array('action'=>'index'));

      } else {

         $this->Session->setFlash(__('The Recette could not be saved. Please, try

again.', true));

      }

   }

}

Listing 7.Exemple de récupération de tous les utilisateurs existants

class RecettesController extends AppController {    function add() {

      $utilisateurs = $this->Recette->Utilisateur->find('all');    ...

Listing 8.Récupération d'une entrée de la base de données et des informations associées

class RecettesController extends AppController {    function view($id) {       $this->Recette->id = $id;

      $this->Recette->recursive = 1;

      $recette = $this->Recette->read();

Listing 9.Association du comportement Translate à un modèle et paramétrage

class Recette extends AppModel {    var $actsAs = array(       'Translate' => array(

            'titre' => 'Titres', 'description' => 'Descriptions' ) );

•     le modèle interagira avec la table my_ messages de la base de données et renverra des données au contrôleur,

•     enfin le contrôleur transmettra ces informations à la vue pour un affichage de la page, ce qui affichera le contenu du fichier .

Nous voyons par ce simple exemple qu'il est ainsi possible de séparer clairement chaque partie de l'application. Ceci rend plus simple le travail collaboratif, la rédaction de tests unitaires et la recherche d'une ligne de code : suivant ce que l'on cherche on sait exactement dans quel fichier chercher. Note avancée : à chaque étape de ce processus il est possible d'intercaler des actions grâce à l'existence de méthodes de callback, pour une meilleure souplesse.

Si vous ne voulez pas des conventions

Il faut cependant noter que le suivi des conventions n'est pas obligatoire (de la même manière qu'une personne peut construire sa maison tout seul !). Les plus rebelles ou ceux qui n'ont pas la main sur les conventions de nommage utilisées, dans le cas de la reprise d'une application existante par exemple, trouveront donc une solution à leur situation.

Nous ne pouvons tout détailler ici, mais sachez qu'il est possible de modifier le comportement du framework et de se servir de sa puissance sur un code ne respectant pas les conventions … il suffira simplement de rajouter un peu de configuration à votre application !

Le scaffolding ou prototypage rapide

CakePHP est avant tout une application facilitant la mise en place rapide d'une application (framework de RAD). Comme nous l'avons vu précédemment, une bonne modélisation de la base de données respectant certaines conventions peut vous faire gagner un temps précieux. Il est désormais temps de voir tout ce que CakePHP vous propose !

Tableau 1.Relations possibles entre différents modèles

Relation

Nom de la relation

Exemple

1 à 1

hasOne

Un utilisateur a un profil

1 à n

hasMany

Un utilisateur peut être l'auteur de plusieurs recettes

n à 1

belongsTo

Une recette appartient à un utilisateur

n à n

hasAndBelongsToMany

Une recette est associée à plusieurs tags, et un tag est associé à plusieurs recettes


La console propose ensuite de définir les associations existant entre cette table et les autres tables de la base. Quatre types d'associations sont gérés par CakePHP : hasOne (possède un seul), hasMany (possède plusieurs), belongsTo (appartient à) et hasAndBelongsToMany (possède et appartient à plusieurs).

Si nous respectons les conventions de nom-


2 et 3, notez au passage la simplicité de définition des associations (Listing 3).

Enfin demandons à Cake de faire le travail de prototypage rapide, ceci depuis les contrôleurs associés aux Utilisateurs (Listing 4) et aux Messages (Listing 5).

C'est tout ! Désormais, en vous rendant sur les pages et http:// vous pourrez tout gérer. Les formulaires permettant les actions CRUD sont disponibles.

La Figure 1 est une capture d'écran du formulaire d'ajout d'un nouveau message. Nous voyons que la liste des utilisateurs existants (un utilisateur a été créé auparavant) s'affiche, afin de relier le message à son auteur. La Figure 2 quant à elle montre le résultat de la création : le lien avec l'utilisateur est bien sauvegardé et les champs automatiques ont été renseignés. Magique n'est-ce pas

CakePHP en ligne de commande

CakePHP offre une interface en ligne de commande permettant de réaliser certaines tâches très rapidement, comme la création du squelette d'application, la génération interactive des fichiers pour chaque entité (modèle, contrôleur et vues) ou encore l'extraction des chaînes gettext présentes dans tous les fichiers de l'application dans le cadre d'une application multilingue. Il est également possible de créer ses propres scripts exécutables via cette console, les shells et les tasks.

Squelette d'application

Après avoir ajouté l'exécutable php dans les variables d'environnement (sous Windows) et créé une nouvelle base de données, nous pouvons ouvrir un terminal (Démarrer > Exécuter > ) et appeler la console : cake bake

Le script nous propose de créer une nouvelle application : il suffit d'indiquer le répertoire de destination et la console crée toute l'arborescence de base, et génère une nouvelle clé de sécurité dans le fichier qui servira lors de la mise en place d'un système d'authentification.

Le script nous demande ensuite les codes d'accès à la base de données, puis se termine. Nous pouvons nous rendre à la racine de l'application dans un navigateur, et nous voyons apparaître la page d'accueil de notre nouvelle application.




Création d'un modèle

Contrairement au scaffolding, qui ne crée pas les fichiers nécessaires dans l'application, la console permet de générer effectivement ces fichiers de manière interactive. Appelons à nouveau la console, de la même manière que plus haut : cake bake

Cette fois la console a détecté que notre application existe, et nous propose une liste d'actions possibles : ajouter une configuration de base de données, créer un modèle, une vue, un contrôleur ou un nouveau projet. Nous choisissons de créer un modèle : la console propose la liste des tables de la base de données. Nous choisissons l'une des tables : la console demande si nous voulons définir des règles de validation pour les champs de cette table. Nous répondons oui : pour chaque champ, nous pouvons choisir parmi 28 règles prédéfinies (notEmpty, alphaNumeric, email, etc.), écrire notre propre expression régulière, ou bien ne pas définir de règle de validation.

mage des tables et des champs (nom des tables au pluriel, 'id' pour les clés primaires, nom de table au singulier suivi de '_id' pour les clés étrangères), CakePHP détecte seul les paramètres de chaque association, mais il reste tout à fait possible de créer les modèles à partir de tables venant d'une ancienne application qui ne respecte pas ces conventions. Notre premier modèle est créé !

Création d'un contrôleur

Passons maintenant à la génération d'un contrôleur : la console nous donne la liste des contrôleurs possibles en fonction des tables de la base, puis propose de créer dans ce nouveau contrôleur les actions de base (index, add, edit et delete), et éventuellement les actions de base d'administration (admin_index, admin_add, admin_edit et admin_delete).

Création d'une vue

Terminons par la création des vues : CakePHP se charge de créer une vue pour chaque action du Nous pouvons à présent parcourir l'applica-

Figure 1.Formulaire de création de message généré par CakePHP

Une fois les relations définies dans le modèle, on peut accéder directement à l'un des modèles associé : si par exemple dans l'action add() du contrôleur des recettes, nous souhaitons obtenir la liste des utilisateurs nous utiliserons l'instruction présentée dans le Listing 7.

La gestion de ces relations permet aussi de rapatrier en un seul appel les données d'un ou plusieurs enregistrements du modèle ainsi que des modèles associés. La distance jusqu'à laquelle CakePHP doit parcourir les associations peut être réglée grâce à la variable de modèle $recursive.

Analysons l'action view() de notre contrôleur des recettes dans le Listing 8.

La variable $recette contiendra non seulement les données de la recette d'identifiant $id, mais aussi les informations sur l'utilisateur qui l'a écrite et les tags associés à la recette !

Ce formidable automatisme se retrouve également dans la sauvegarde des enregistrements, puisque l'on peut sauvegarder l'enregistrement d'un modèle et de ses modèles associés en un seul appel à aussi (méthodes save() ou saveAll()).

Les callbacks

Les callbacks sont des méthodes spéciales qui sont déclenchées automatiquement par le fra-

tion dans un navigateur : tout est déjà prêt, il ne reste qu'à affiner la présentation des données ou certains traitements, mais l'application en l'état est totalement fonctionnelle, après avoir tapé une ligne de commande et répondu à quelques questions !

Les modèles

Listing 10.Formulaire d'ajout d'un «message» dans le fichier « »

<?php

echo $form->create('Message');

?>

<fieldset>

   <legend><?php __('Add Message');?></legend>

   <?php

echo $form->input('title'); // Affichera un "input text"echo $form->input('content'); // Affichera un "textarea"echo $form->input('user_id'); // Affichera un "select" contenant

// les couples id/name des utilisateurs existants

   ?>

</fieldset> <?php

echo $form->end('Submit');

?>

Listing 11.Configuration du composant d'Authentification et restriction des pages d'administration

class AppController extends Controller {    var $components = array('Auth'); function beforeFilter() {       $this->Auth->loginAction = '/users/login';       $this->Auth->loginRedirect = '/admin/recettes/index';

      $this->Auth->logoutRedirect = '/';

      $this->Auth->loginError = "Identifiant ou mot de passe incorrects.";

      $this->Auth->authError = "Vous n'avez pas accès à cette page.";

if(empty($this->params['prefix']) or $this->params['prefix'] != Configure::

read('Routing.admin')) {

         $this->Auth->allow();

      }

   } }

Listing 12: Contrôleur basique de gestion des utilisateurs, tout est fait par Cake !

class UsersController extends AppController {    function login() { }    function logout() {

      $this->Session->setFlash("Vous êtes maintenant déconnecté.");       $this->redirect($this->Auth->logout());

   }

}

Les modèles, l'une des trois couches du modèle MVC, constituent le cœur de l'application. Ils encapsulent l'accès aux tables de la base de données et sont responsables de la plupart des manipulations de ces données : lecture, écriture, suppression et validation du format des données avant sauvegarde. Le framework est prévu pour pouvoir travailler avec un grand nombre de SGBD différents de façon transparente (MySQL 4 et 5, Postgres, Firebird, SQL Server, Oracle, SQLite, ODBC et ADOdb).

Les modèles sont conçus dans l'optique d'une grande souplesse puisqu'il est possible d'utiliser un modèle sans table (gestion d'un formulaire de contact par exemple), que l'on peut spécifier des bases de données différentes d'un modèle à l'autre, et qu'un modèle peut manipuler des données issues d'une autre source qu'une table de base de données, par exemple une API externe. Il suffit pour cela de créer sa propre datasource et de brancher le modèle dessus.

Note : toutes les classes de modèles de l'application étendent la classe AppModel, il est donc facile de factoriser certaines actions redondantes sur plusieurs modèles à l'intérieur de cette classe mère.

Opérations usuelles sur les données

Examinons un contrôleur créé plus tôt via la console : nous avions demandé à CakePHP de créer pour nous les actions de base de manipulation de données; penchons-nous dans le Listing 6 sur l'action add() permettant d'ajouter une entrée à la base de données.

À l'intérieur d'une action d'un contrôleur, les données issues d'un formulaire présent dans la vue de cette action sont toutes regroupées dans $this->data. La première étape vérifie donc si cette variable existe (le formulaire a été soumis) et dans ce cas, la méthode create() du modèle Recette est appelée : CakePHP prépare une enveloppe vierge qui va accueillir les données à sauvegarder. Il essaie ensuite de sauvegarder effectivement les données soumises, et redirige sur l'index du contrôleur en cas de succès (c'est-à-dire d'une part que les données ont passé tous les tests de validation, et d'autre part que la ligne a bien été ajoutée dans la base).

Relations entre modèles

Une des grandes forces de CakePHP réside dans la gestion automatique des relations entre les modèles. Les quatre relations possibles sont décrites dans le Tableau 1.


mework lors de chaque appel à une page. On trouve par exemple les méthodes de modèle beforeSave() ou afterFind(), qui peuvent accueillir des traitements supplémentaires en plus des méthodes de base. D'autres callbacks sont disponibles dans les contrôleurs (beforeFilter, beforeRender...).

Extensions de modèle

Dans l'optique de produire du code le plus réutilisable possible, CakePHP permet d'étendre les fonctionnalités de base d'un modèle avec des Behaviors (Comportements), qui ajoutent des méthodes à un modèle existant ou utilisent les callbacks pour effectuer des traitements supplémentaires. CakePHP en fournit quelques uns, comme par exemple le comportement Tree qui permet de gérer une table comme une arborescence. La gestion des nœuds se fait en toute simplicité : la logique se trouve dans des callbacks du Comportement, appelés avant et après la sauvegarde classique d'un enregistrement.

Exemple de Behavior : Translate

Ce comportement, inclus dans le framework, permet de gérer une application multilingue. Il faut avant tout préparer la base de données à accueillir plusieurs langues : pour ce faire nous devons créer une table i18n (dont le schéma est fourni dans le répertoire config/sql) qui va contenir tous les champs textuels des autres tables, et ces autres tables ne doivent pas contenir de champs susceptibles d'être traduits.

Nous associons ensuite le comportement Translate au modèle en précisant quels champs textuels devront être traduits grâce à l'attribut

$actAs du modèle, tel que présenté dans le Listing 9.

La gestion des traductions se fait ensuite de manière transparente : avant toute action sur un enregistrement, il suffit de préciser sur quelle(s) langue(s) on travaille, et Translate s'occupe du reste. Ainsi pour afficher une recette en anglais :



function view($id) {    $this->Recette->locale = 'eng';

   $this->Recette->id = $id;    $recette = $this->Recette->read();

Et CakePHP renvoie un enregistrement avec les champs 'titre' et 'description' traduits, comme si nous avions affaire à la table recettes avec les champs traduits en anglais, alors qu'en réalité ces deux champs n'existent pas dans la table recettes mais dans la table i18n.

Les vues

Les vues de CakePHP n'utilisent pas de langage spécifique, et sont donc du pur (x)HTML au milieu duquel on utilise le PHP classique pour afficher les données dynamiques. Il est cependant possible d'utiliser des moteurs de templates comme Smarty, mais c'est en pratique très peu utilisé à cause des nombreux helpers disponibles qui permettent de garder un code propre, minimal, réutilisable et facile à prendre en main !

Différents éléments composant une vue

Dans un but de réutilisabilité du code et pour diminuer la redondance, les vues sont composées de plusieurs fichiers.

•     Layouts : un fichier gabarit qui contient toute la structure commune aux pages du site (menus, en-tête et pied de page …), il est donc très simple de changer radicalement de structure de page entre sections du site ou versions.

•     Elements : certains éléments communs à plusieurs pages (exemple : formulaires de connexion) peuvent être mis sous forme d'un fichier séparé qui sera inclus dans chacune des pages, avec possibilité de passage de paramètres,

•     Corps de la page : associés à chacune des actions, les fichiers de vue contiennent le code de la page strictement nécessaire à l'action demandée (formulaire, affichage des informations) ce qui permet de les réutiliser simplement d'un projet sur l'autre.

Des helpers pour se simplifier la vie

Comme vous commencez à le voir, le framework contient énormément de fonctionnalités n'ayant qu'un seul but : faciliter le développement en s'abstrayant des tâches rébarbatives !

Ainsi, CakePHP est livré avec des classes contenant des méthodes vraiment pratiques : les helpers.


Figure 3.Aperçu de l'application créée en ligne de commande


RecettesController, avec comme paramètre

12, l'identifiant de la recette à éditer.

Toujours dans l'esprit convention au lieu de configuration, CakePHP attend que les utilisateurs autorisés soient stockés dans une table

'users' avec un champ 'user_name' (le login) et un champ 'password'. Ce dernier devra être de type varchar (40) pour stocker la clé de hashage du mot de passe, composée de la clé de sécurité générée lors de la création de l'application avec la console, suivie du mot de passe, le tout crypté en SHA1 ce qui nous donne une chaîne de 40 caractères.

Afin de restreindre l'accès à toutes les actions de nos contrôleurs commençant par admin_ aux seuls utilisateurs logués, nous allons placer la logique d'authentification dans la classe AppController (Listing 11) dont héritent tous les autres contrôleurs. Comme cette logique doit intervenir avant toute autre opération lors de l'appel à une action, nous utiliserons le callbackbeforeFilter, qui comme son nom l'indique est appelé avant l'action elle-même.

Il suffit de définir quelques propriétés du composant Auth (les URL de connexion, de déconnexion et de redirection en cas de succès, les messages d'erreur, la condition d'autorisation ou de refus) et l'accès à une action d'administration demande maintenant de

Le FormHelper

Afin de gérer simplement les formulaires affichés sur votre site et leur lien avec les données issues ou destinées à la base de données, une classe vous fournit un tas de méthodes automatiques. Voici dans le Listing 10, à titre d'exemple, le code permettant de générer le formulaire d'ajout de la Figure 1 (code généré automatiquement depuis la ligne de commande).

Nous pouvons voir dans cette portion de code que la création d'un formulaire se fait en définissant le modèle associé, et que Cake se chargera ensuite de déterminer le type d'élément de formulaire à afficher en fonction du type de données de la base de données : ici le champ title est un VARCHAR, content un TEXT et user_id une clé étrangère vers une entrée de la table users. Sachez également que vous pourrez insérer directement un type d'élément précis (select, radio, checkbox …) par l'appel de la méthode correspondante du helper … et qu'il existe beaucoup d'autres méthodes et options pour faire ce que vous voudrez !

1. Le HTMLHelper

De la même manière, une autre classe contient de nombreuses méthodes utiles pour vous faciliter l'affichage de code HTML. Quelques exemples : insérer des balises doctype conformes, un charset uniforme au site, des liens (vers des pages, images, fichiers) qui ne seront pas cassés par un changement de schéma d'URL rewriting, créer simplement des tableaux de données et bien d'autres choses.

CakePHP contient un système de gestion d'URL très fin (les routes) qui vous permettra de personnaliser entièrement vos urls en modifiant quelques lignes dans le fichier /config/ . L'intérêt du HTMLHelper est qu'il se chargera de générer automatiquement un lien correspondant à ces paramètres afin de

pouvoir modifier très simplement votre système d'URL.

Le AjaxHelper

Basé sur la librairie prototype, le AJAX Helper vous permet de mettre en place des formulaires, liens, auto-complétion, glisser-déposer et autres effets en un seul appel de méthode. Il existe également un équivalent jQuery.

… et bien d'autres : RSS, JavaScript, RSS, Paginator (pour paginer simplement vos résultats), Number, Session, XML … vous permettront de mettre en place en toute simplicité des fonctionnalités pratiques et répandues. Ceci est une liste non exhaustive se basant sur les helpers du cœur du framework : la communauté en propose beaucoup d'autres, et vous pouvez en toute simplicité créer les vôtres !

Des composants livrés avec le framework

Au même titre que les Behaviors sont des extensions de modèle, les Components (composants) sont des extensions de contrôleur. Parmi ceux livrés avec CakePHP (Cookies, Sessions, Email, Security, etc.), nous en aborderons deux : Auth et ACL.

Auth

Le composant Auth permet de mettre en place une authentification par login / mot de passe sur certaines parties du site. L'utilisation typique de cette fonctionnalité est la protection d'un espace d'administration du site, c'est-àdire l'authentification requise pour les actions préfixées par 'admin_'. Commençons pas activer le routage automatique des actions réservées à l'administration en décommentant une ligne dans :

Configure::write('Routing.admin', 'admin');

/admin/recettes/edit/12' renverra sur l'action admin_edit($id = null) du contrôleur

s'identifier. Il ne nous reste qu'à créer les actions de login et logout dans le contrôleur des utilisateurs, UsersController présenté dans le Listing 12.

L'action login reste vide, CakePHP se charge lui-même de vérifier si le couple login / mot de passe, qui sera fourni par le biais du formulaire à créer dans la vue de cette action, correspond bien à un utilisateur de la table users. L'action logout ne fait que rediriger sur l'URL définie comme URL de déconnexion dans le beforeFilter, avec un message.

ACL

Le composant ACL (Access Control List) permet un contrôle poussé des autorisations d'accès en considérant d'une part des rôles (aros) et d'autre part des ressources (acos), avec des relations d'autorisation ou d'interdiction entre un rôle et une ressource donnés. Notons bien qu'il ne s'agit pas de la même chose que l'authentification vue plus haut, mais d'un processus de contrôle d'accès aux ressources une fois qu'un utilisateur a été reconnu.

La solution proposée par CakePHP offre une granularité importante, puisqu'il est possible qu'un rôle soit un utilisateur ou un groupe d'utilisateurs, et qu'une ressource soit un enregistrement précis d'une table, une action, un contrôleur complet ou même l'application dans son ensemble. Le framework gère ces données sous forme de deux arborescences, une pour les rôles et une pour les ressources, il est donc possible (et préférable !)




158