Configuration¶

Méthodes de la classe Configure¶

write(string $key, mixed $value)

Configure::write('Societe.nom','Pizza');
Configure::write('Societe.slogan','Pizza pour votre corps et votre âme');

Configure::write(
    'Societe',array('nom'=>'Pizza','slogan'=>'Pizza pour votre corps et votre âme')
);

Configure::read('Societe.nom');    // retourne : 'Pizza'
Configure::read('Societe.slogan'); // retourne : 'Pizza pour votre corps et votre âme'

Configure::read('Societe');

// retourne :
array('nom' => 'Pizza', 'slogan' => 'Pizza pour votre corps et votre âme');

Configure::delete('Societe.nom');

// /app/config/messages.php:
<?php
$config['Societe']['nom'] = 'Pizza';
$config['Societe']['slogan'] = 'Pizza votre corps et votre âme';
$config['Societe']['telephone'] = '01-02-03-04-05';
?>

<?php
Configure::load('messages');
Configure::read('Societe.nom');
?>

Variables de configuration du cœur de CakePHP¶

La classe Configure est utilisée pour gérer un ensemble de variables de configuration du cœur de CakePHP. Ces variables peuvent être trouvées dans app/config/core.php. Ci-dessous se trouve une description de chaque variable et des effets que leur utilisation entraîne pour votre application CakePHP.

Variable de Configure

Description

debug

Modifie la sortie de debug CakePHP.

0 = Mode production. Pas de sortie. 1 = Montre les erreurs et les alertes. 2 = Montre les erreurs, les alertes et le SQL.

App.baseUrl

Décommentez cette définition si vous ne prévoyez pas d’utiliser le mod_rewrite d’Apache avec CakePHP. N’oubliez pas de supprimer également vos fichiers .htaccess.

Routing.prefixes

Décommentez cette définition si vous aimeriez tirer profit des routes préfixées de CakePHP comme admin. Définissez cette variable comme un tableau des noms des préfixes de routes que vous souhaiteriez utiliser. Plus d’informations sur celà ultérieurement.

Cache.disable

Quand il est réglé à true, le cache est désactivé pour l’ensemble du site.

Cache.check

Si réglé à true, active le cache de vue. L’activation est encore requise dans les contrôleurs, mais cette variable permet la détection de ces paramètres.

Session.save

Indique à CakePHP quel mécanisme de stockage des sessions utiliser.

utile en conjonction avec Memcache (dans une configuration comportant plusieurs serveurs) afin de stocker à la fois les données et sessions du cache.

données. Assurez-vous de configurer correctement la table en utilisant le fichier SQL situé dans /app/config/sql/sessions.sql.

Session.table

Le nom de la table (sans inclure aucun préfixe) qui enregistre les informations de session.

Session.database

Le nom de la base de données qui enregistre les informations de session.

Session.cookie

Le nom du cookie utilisé pour tracer les sessions.

Session.timeout

Base du temps de déconnexion de la session, en secondes. La valeur réelle dépend du paramètre Security.level.

Session.start

Démarre automatiquement les sessions quand réglé à true.

Session.checkAgent

Quand réglé à false, les sessions CakePHP n’effectueront pas d’analyse pour s’assurer que l’agent utilisateur ne change pas entre les requêtes.

Security.level

Le niveau de sécurité CakePHP. Le temps de déconnexion de la session, défini par le paramètre “Session.timeout”, est multiplié par le paramètre indiqué ici.

“high” = x 10 “medium” = x 100 “low” = x 300 “high” et “medium” active également session.referer_check

“Security.level” est défini à “high”.

Security.salt

Une chaîne aléatoire utilisée par le hash de sécurité.

Asset.timestamp

Ajoute le timestamp de la dernière modification du fichier à la fin des urls fichiers ressources (CSS, JavaScript, Image) quand les bons helpers sont utilisés.

Valeurs possibles:

(bool) false - Rien n’est fait (par défaut) (bool) true - Ajoute le timestamp quand debug > 0 (string) “force” - Ajoute le timestamps quand debug >= 0

Acl.classname, Acl.database

Constantes utilisées par les fonctionnalités de Listes de Contrôle d’Accès (Access Control List - ACL) de CakePHP. Voyez le chapitre sur les ACL pour plus d’informations.

La configuration du cache se trouve aussi dans le fichier core.php — Nous le couvrirons plus tard, donc restez à l’écoute.

La classe Configure peut être utilisée pour lire et écrire des paramètres de configuration du cœur à la volée. Ceci est particulièrement pratique si vous voulez, par exemple, activer des paramètres de debug pour une section limitée de votre logique applicative.

Constantes de configuration¶

Alors que la plupart des options de configuration sont prises en charge par Configure, il y a quelques constantes que CakePHP utilise à l’exécution.

Utiliser App::import()¶

App::import($type, $name, $parent, $search, $file, $return)

A première vue, App::import semble complexe, pourtant, dans la plupart des cas d’utilisation, seuls 2 arguments sont requis.

Importer les librairies du cœur¶

Les librairies du cœur de Cake, comme Sanitize et Xml peuvent être chargées via :

<?php App::import('Core', 'Sanitize') ?>

Ceci rendra la classe Sanitize disponible.

Importer des Contrôleurs, des Modèles, des Composants, des Comportements et des Assistants¶

Toute classe relative à l’application devrait aussi être chargée avec App::import(). Les exemples suivants illustrent comment s’y prendre.

<?php
// Identique à : require('controllers/utilisateurs_controller.php');
App::import('Controller', 'Utilisateurs');

// Nous avons besoin de charger la classe
$Users = new UsersController;

// Si nous voulons que les associations de modèle, les components, etc. soient chargés
$Users->constructClasses();
?>

Charger depuis les Plugins¶

Charger des classes de plugins fonctionne à peu près de la même manière que le chargement des classes du cœur ou de l’application, excepté que vous devez préciser le plugin depuis lequel vous chargez.

App::import('Model', 'MonPlugin.Pomme');

Pour charger APP/plugins/mon_plugin/vendors/flickr/flickr.php

App::import('Vendor', 'MonPlugin.flickr/flickr');

Charger les fichiers Vendor¶

La fonction vendor() a été dépréciée. Les fichiers Vendor devraient maintenant être chargés via App::import(). La syntaxe et les arguments additionnels sont légèrement différents, car les structures du fichier vendor peuvent différer grandement et tous les fichiers vendor ne contiennent pas de classes.

Les exemples suivants illustrent comment charger les fichiers vendor depuis divers structures de chemins. Ces fichiers vendor pourraient être localisés dans n’importe quels dossiers de vendor.

App::import('Vendor', 'geshi');

App::import('Vendor', 'flickr/flickr');

App::import('Vendor', 'UnNom', array('file' => 'un.nom.php'));

App::import('Vendor', 'BienDit', array('file' => 'services'.DS.'bien.dit.php'));

App::import('Vendor', 'unIdentifiantUnique', array('file' =>;'nomVendeur'.DS.'libFichier.php'));

Routage par défaut¶

Avant d’apprendre comment configurer vos propres routes, vous devriez savoir que CakePHP arrive configuré avec un ensemble de routes par défaut. Le routage par défaut de CakePHP vous emmènera assez loin dans toute application. Vous pouvez accéder à une action directement via l’URL en insérant son nom dans la requête. Vous pouvez aussi passer des paramètres aux action de votre contrôleur en utilisant l’URL.

URL motif de routes par défaut :
http://exemple.com/controleur/action/param1/param2/param3

L’URL /posts/voir correspond à l’action voir() du contrôleur PostsController et /produits/voir_autorisation correspond à l’action voir_autorisation() du contrôleur ProduitsController. Si aucune action n’est spécifiée dans l’URL, la méthode index() est sous-entendue.

La configuration du routage par défaut vous permet également de passer des paramètres aux actions en utilisant l’URL. Par exemple, une requête pour /posts/voir/25 serait équivalente à l’appel de voir(25) dans le contrôleur PostsController.

Arguments passés¶

Les arguments passés sont des arguments additionnels ou des segments du chemin qui sont utilisés lors d’une requête. Ils sont souvent utilisés pour transmettre des paramètres aux méthodes de vos contrôleurs.

http://localhost/calendriers/voir/recents/mark

Dans l’exemple ci-dessus, recents et marksont tous deux des arguments passés à CalendriersController::voir(). Les arguments passés sont transmis aux contrôleurs de deux manières. D’abord comme arguments de la méthode de l’action appelée, mais aussi en étant accessibles dans $this->params['pass'] sous la forme d’un tableau indexé numériquement. Lorsque vous utilisez des routes personnalisées il est possible de forcer des paramètres particuliers comme étant des paramètres passés égalements. Voir passer des paramètres à une action pour plus d’informations.

Paramètres nommés¶

Vous pouvez nommer les paramètres et envoyer leurs valeurs en utilisant l’URL. Une requête pour « /posts/voir/titre:premier+post/categorie:general » résultera en un appel à l’action « voir() » du contrôleur PostsController. Dans cette action, vous trouverez les valeurs des paramètres « titre » et « categorie » respectivement dans $this->passedArgs[‘titre’] et $this->passedArgs[‘categorie’]. Vous pouvez également accéder aux paramètres nommés depuis $this->params['named']. $this->params['named'] contient un tableau de paramètres nommés indexés par leurs nom.

Quelques exemples de routes par défaut seront plus parlants.

URL correspondant à une action de contrôleur en utilisant les routes par défaut :

URL : /singes/saute
Correspond à : SingesController->saute();

URL : /produits
Correspond à : ProduitsController->index();

URL: /taches/voir/45
Correspond à : TachesController->voir(45);

URL: /donations/voir/recentes/2001
Correspond à : DonationsController->voir('recentes', '2001');

URL: /contenus/voir/chapitre:modeles/rubrique:associations
Correspond à : ContenusController->voir();
$this->passedArgs['chapitre'] = 'modeles';
$this->passedArgs['rubrique'] = 'associations';
$this->params['named']['chapitre'] = 'modeles';
$this->params['named']['rubrique'] = 'associations';

Lorsque l’on fait des routes personnalisées, un piège classique est d’utiliser des paramètres nommés qui casseront vos routes. Pour résoudre celà vous devez informer le Router des paramètres qui sont censés être des paramètres nommés. Sans cette information le Router est incapable de déterminer si les paramètres nommés doivent en effet être des paramètres nommés ou des paramètres à router, et supposera par défaut que ce sont des paramètres à router. Pour connecter des paramètres nommés dans le routeur utilisez Router::connectNamed().

Définir des Routes¶

Définir vos propres routes vous permet de déterminer comment votre application répondra à une URL donnée. Définissez vos propres routes dans le fichier /app/config/routes.php en utilisant la méthode Router::connect().

La méthode connect() prend jusqu’à trois paramètres : l’URL que vous souhaitez détecter, les valeurs par défaut pour les éléments personnalisés de la route et des règles à base d’expression régulière pour aider le routeur à trouver les éléments dans l’URL.

Le format de base pour la définition d’une route est :

Router::connect(
    'URL',
    array('nomParametre' => 'valeur_par_defaut'),
    array('nomParametre' => 'expression_a_detecter')
)

Le premier paramètre est utilisé pour indiquer au routeur quelle sorte d’URL vous essayez de contrôler. L’URL est une chaîne normale délimitée par des slash, mais elle peut aussi contenir un joker (*) ou des éléments de route personnalisés (noms de variables préfixés par deux points). L’utilisation d’un joker indique au routeur quels types d’URLs vous voulez détecter et en spécifiant des éléments de route cela vous permet de rassembler les paramètres pour les actions de vos contrôleurs.

Une fois que vous avez spécifié une URL, vous utilisez les deux derniers paramètres de connect() pour indiquer à CakePHP que faire avec une requête une fois qu’elle a été détectée. Le second paramètre est un tableau associatif. Les clés du tableau devraient être nommées d’après les éléments de route dans l’URL ou d’après les éléments par défauts « :controller », « :action » et « :plugin ». Les valeurs du tableau sont les valeurs par défaut pour ces clés. Regardons quelques exemples simples avant de commencer à utiliser le troisième paramètre de connect().

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

Cette route se trouve dans le fichier routes.php distribué avec CakePHP (ligne 40). Cette route intercepte toute URL commençant par /pages/ et la transmet à la méthode display() du contrôleur PagesController();. La requéte /pages/produits devrait correspondre à PagesController->display('produits'), par exemple.

Router::connect(
    '/gouvernement',
    array('controller' => 'produits', 'action' => 'display', 5)
);

Ce second exemple montre comment vous pouvez utiliser le deuxième paramètre de connect() pour définir des paramètres par défaut. Si vous construisez un site qui propose des produits pour différentes catégories de consommateurs, vous pourriez envisager de créer une route. Cela vous permet d’avoir un lien vers /gouvernement plutôt que vers /produits/display/5.

Une autre utilisation courante du routeur est de définir un « alias » pour un contrôleur. Disons qu’au lieu d’accéder à notre URL régulière /utilisateurs/une_action/5, nous aimerions être en mesure d’y accéder par /cuisiniers/une_action/5. La route suivante s’occupe facilement de cela :

Router::connect(
    '/cuisiniers/:action/*', array('controller' => 'utilisateurs', 'action' => 'index')
);

Ceci indique au routeur que toute URL commençant par /cuisiniers/ devra être envoyée au contrôleur « utilisateurs ».

Quand on génère des urls, les routes sont utilisées aussi. Utiliser array('controller' => 'utilisateurs', 'action' => 'uneAction', 5) comme une url affichera /cuisiniers/uneAction/5 si la route ci-dessus est la première trouvée.

Si nous comptons utiliser des paramètres personnalisés dans notre route, il faut le spécifier au routeur en utilisant la fonction Router::connectNamed. Donc si vous voulez la route spécifiée plus haut de reconnaître des URL comme/cuisiniers/uneAction/type:chef, nous devons:

Router::connectNamed(array('type'));
Router::connect(
    '/cuisiniers/:action/*', array('controller' => 'utilisateurs', 'action' => 'index')
);

Pour plus de flexibilité, vous pouvez spécifier des éléments personnalisés de route. Faire cela vous donne le pouvoir de définir les positions des paramètres dans l’URL pour qu’ils correspondent à ceux des actions du contrôleur. Quand une requête est faite, les valeurs pour ces éléments de route personnalisés se trouvent dans la variable $this->params du contrôleur. Ceci est différent de la façon dont sont traités les paramètres nommés, notez la distinction : les paramètres nommés (/controller/action/nom:valeur) se trouve dans $this->passedArgs, alors que les données des éléments personnalisés de route se trouve dans $this->params. Quand vous définissez un élément personnalisé de route, vous devez aussi spécifier une expression régulière - cela indique à CakePHP comment savoir si l’URL est correctement formée ou pas.

Router::connect(
    '/:controller/:id',
    array('action' => 'voir'),
    array('id' => '[0-9]+')
);

Ce simple exemple illustre comment créer une voie rapide pour voir les modèles depuis tout contrôleur, en façonnant une URL qui ressemble à /nom_controleur/id. L’URL fournie à connect() spécifie deux éléments de route : « :controller » et « :id ». L’élément « :controller » est un élément de route par défaut de CakePHP, donc le routeur sait comment intercepter et identifier les noms de contrôleur dans les URLs. L’élément « :id » est élément de route personnalisé et doit être davantage clarifier en spécifiant une expression régulière détectable dans le troisième paramètre de connect(). Cela indique à CakePHP comment reconnaître l’ID dans l’URL par opposition à tout autre chose, comme par exemple le nom d’une action.

Une fois que cette route a été définie, requêter /pommes/5 est la même chose que /pommes/voir/5. Les deux appelleront la méthode voir() du contrôleur PommesController. A l’intérieur de la méthode voir(), vous aurez besoin d’accéder à l’ID passé par $this->params[“id”].

Encore un exemple et vous serez un pro du routage.

Router::connect(
    '/:controller/:annee/:mois/:jour',
    array('action' => 'index', 'jour' => null),
    array(
        'annee' => '[12][0-9]{3}',
        'mois' => '0[1-9]|1[012]',
        'jour' => '0[1-9]|[12][0-9]|3[01]'
    )
);

Ceci est plutôt compliqué, mais montre comment les routes peuvent vraiment devenir puissantes. L’URL soumise a 4 éléments de route. Le premier nous est familier : c’est un élément de route par défaut qui indique à CakePHP d’attendre un nom de contrôleur.

Ensuite, nous spécifions quelques valeurs par défaut. Sans tenir compte du contrôleur, nous voulons appeler l’action index(). Nous définissons le paramètre jour à null (le quatrième élément dans l’URL) pour signaler qu’il est optionnel.

Finalement, nous spécifions quelques expressions régulières qui correspondront aux années, mois et jours sous forme numérique. Notez que les parenthèses (groupements) ne sont pas supportées dans les expressions régulières. Vous pouvez quand même en spécifier d’autres, comme ci-dessus, mais ne les groupez pas avec des parenthèses.

Une fois définie, cette route détectera /articles/2007/02/01, /posts/2004/11/16 et /produits/2001/05 (tel que défini, le paramètre jour est optionnel car il a une valeur par défaut), transmettant les requêtes aux actions index() de leurs contrôleurs respectifs, avec les paramètres personnalisés de date dans $this->params.

Passer des paramètres à une action¶

Considérons que votre action a été définie comme ceci et que vous voulez accéder aux arguments en utilisant $articleID plutôt que $this->params['id'], ajoutez simplement un tableau supplémentaire dans le 3eme paramètre de Router::connect().

// un_controller.php
function voir($articleID = null, $slug = null) {
    // un peu de code ici...
}

// routes.php
Router::connect(
    // Exemple /blog/3-CakePHP_Rocks
    '/blog/:id-:slug',
    array('controller' => 'blog', 'action' => 'voir'),
    array(
        // rien de compliqué, puisque ceci fera simplement correspondre ":id" à $articleID dans votre action
        'pass' => array('id', 'slug'),
        'id' => '[0-9]+'
    )
)

Et maintenant, merci aux capacités de routage inverse, vous pouvez passer dans le tableau d’url comme ci-dessous et Cake saura comment formé l’URL telle que définie dans les routes.

// voir.ctp
// ceci retourne un lien vers /blog/3-CakePHP_Rocks
<?= $html->link('CakePHP Rocks', array(
    'controller' => 'blog',
    'action' => 'voir',
    'id' => 3,
    'slug' => Inflector::slug('CakePHP Rocks')
)) ?>

Préfixe de routage¶

De nombreuses applications nécessitent une section d’administration dans laquelle les utilisateurs privilégiés peuvent faire des modifications. Ceci est souvent réalisé grâce à une URL spéciale telle que /admin/utilisateurs/editer/5. Dans CakePHP, le routage admin peut être activé depuis le fichier de configuration du cœur en réglant le chemin d’admin via Routing.admin.

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

Dans votre contrôleur, toute action avec le préfixe admin_ sera appelée. En utilisant notre exemple des utilisateurs, accéder à l’url /admin/utilisateurs/editer/5 devrait appeler la méthode admin_editer de notre UtilisateursController en passant 5 comme premier paramètre. Le fichier de vue correspondant devra être app/views/utilisateurs/admin_editer.ctp

Vous pouvez faire correspondre l’url /admin à votre action admin_index du contrôleur Pages en utilisant la route suivante :

Router::connect('/admin', array('controller' => 'pages', 'action' => 'index', 'admin' => true));

Vous pouvez aussi vous servir du Router pour utiliser des préfixes à destination d’autres choses que du routage d’admin.

Router::connect('/profils/:controller/:action/*', array('prefix' => 'profils', 'profils' => true));

Tout appel à la section « profils » devrait entraîner la recherche du préfixe profils_ dans les appels de méthode. Notre exemple d’utilisateurs aurait une structure d’url qui ressemble à /profils/utilisateurs/editer/5 qui appelerait la méthode profils_editer du UtilisateursController. Une autre chose importante à retenir, l’utilisation du helper HTML pour construire vos liens aidera à maintenir les appels de préfixe. Voici construire ce lien en utilisant le helper HTML :

echo $html->link('Editer votre profil', array('profils' => true, 'controller' => 'utilisateurs', 'action' => 'editer', 'id' => 5));

Vous pouvez définir plusieurs routes préfixées en utilisant cette approche afin de créer une structure d’URL flexible pour votre application.

Routage des Plugins¶

Le routage des Plugins utilise la clé plugin. Vous pouvez créer des liens qui pointent vers un plugin, mais en ajoutant la clé plugin à votre tableau d’url.

echo $html->link('Nouveau todo', array('plugin' => 'todo', 'controller' => 'todo_items', 'action' => 'creer'));

Inversement, si la requête active est une requête de plugin et que vous voulez créer un lien qui ne pointe pas vers un plugin, vous pouvez faire ce qui suit.

echo $html->link('Nouveau todo', array('plugin' => null, 'controller' => 'utilisateurs', 'action' => 'profil'));

En définissant plugin => null, vous indiquez au Routeur que vous souhaitez créer un lien qui n’est pas une partie d’un plugin.

Extensions de fichier¶

Pour manipuler différentes extensions de fichier avec vos routes, vous avez besoin d’une ligne supplémentaire dans votre fichier de config des routes :

Router::parseExtensions('html', 'rss');

Ceci indiquera au routeur de supprimer toutes extensions de fichiers correspondantes et ensuite d’analyser ce qui reste.

Si vous voulez créer une URL comme /page/titre-de-page.html, vous devriez créer votre route comme illustré ci-dessous :

Router::connect(
    '/page/:titre',
    array('controller' => 'pages', 'action' => 'voir'),
    array(
        'pass' => array('titre')
    )
);

Ensuite pour créer des liens qui s’adapteront aux routes utilisez simplement :

$html->link('Titre du lien', array('controller' => 'pages', 'action' => 'voir', 'titre' => Inflector::slug('texte à transformer', '-'), 'ext' => 'html'))

Classes de route personnalisés¶

Les classes de route personnalisés vous permettent d’étendre et de modifier la façon dont certaines routes demandes d’analyser et de traiter des routes inversés. Une classe de la route devrait hériter de la classe CakeRoute et mettre en œuvre un ou des deux match() et parse(). Parse est utilisée pour analyser les demandes et correspondance et il est utilisée pour traiter les routes inversés.

Vous pouvez utiliser une classe de route personnalisée lors d’un création d’une route à l’aide des options de la classe routeClass, et en chargeant le fichier contenant votre routes avant d’essayer de l’utiliser.

Router::connect(
     '/:slug',
     array('controller' => 'posts', 'action' => 'view'),
     array('routeClass' => 'SlugRoute')
);

Cette route créerait une instance de la classe `` SlugRoute `` et vous permettent de mettre en œuvre la gestion des paramètres personnalisés