1. Génération du suffixe dans les Vues

Voyons d’abord comment définir les liens vers nos fiches produits, par exemple dans la liste des produits, soit l’action index du Contrôleur Produits.
Nous allons utiliser la méthode statique Inflector::slug() qui prend en paramètre :

• une chaîne de caractères et la retourne exempte de tout caractère “interdit” dans une URL (accents, espaces, ponctuation) ;
• éventuellement un caractère séparateur, l’underscore _ par défaut.

// {app}/views/produits/index.ctp
<ul>
<?php foreach($produits as $produit): ?>
	<li>
	<?php echo $html->link(
		$produit['Produit']['nom'],
		array(
			'controller' => 'produits',
			'action' => 'view',
			'id' => $produit['Produit']['id'],
			'suffixe' => Inflector::slug($produit['Produit']['nom'], '-')
		)
	); ?>
	</li>
<?php endforeach; ?>
</ul>

Nous obtenons une URL du style : /produits/view/12/suffixe:Livre-de-recettes. Nous progressons, mais nous voulons changer le mot “produits” en “article”, supprimer le nom de l’action, qui n’apporte rien, et le mot “suffixe:” qui n’est pas des plus esthétiques. Pour y parvenir, nous allons tirer parti de la puissance des Routes.

2. Une route personnalisée

Rendons-nous dans le Router :

// {app}/config/routes.php
Router::connect(
	'/article/:id/:suffixe',
	array('controller' => 'produits', 'action' => 'view'),
	array('id' => $ID, 'suffixe' => '[a-zA-Z0-9_-]+')
);

Voyons un peu les trois arguments que nous donnons à la méthode Router::connect() :

• '/article/:id/:suffixe' : c’est le format d’URL que nous attendons ;
• array('controller' => 'produits', 'action' => 'view') : lorsque le Router va reconnaître une URL ressemblant à notre premier argument, il devra renvoyer sur l’action view du Contrôleur Produits
• array('id' => $ID, 'suffixe' => '[a-zA-Z0-9_-]+’) : nous définissons ce que nous entendions dans le premier argument par “:id” et “:suffixe” :
  • $ID contient une expression régulière prédéfinie dans le cœur de Cake, correspondant à un ou plusieurs chiffres ;
  • '[a-zA-Z0-9_-]+’ est l’expression régulière que nous définissons pour que le Router reconnaissent nos suffixes d’URL : ce suffixe peut contenir des lettres minuscules ou majuscules, des chiffres, des underscores ou des tirets.

Rafraîchissons notre page /produits/index, et nous constatons que nos URL sont bien de la forme /article/12/Livre-de-recettes !

3. Contrôler la validité d’un suffixe d’URL

Mais que se passe-t-il si un visiteur poste un lien vers notre site dans un forum, et qu’il tronque le suffixe, ou le modifie ? Cela va pénaliser le référencement de la page ciblée, car les moteurs de recherche vont enregistrer plusieurs URL pointant vers la même page : la bonne (/article/12/Livre-de-recettes) et les éventuelles mauvaises (/article/12/Suffixe_incorrect, /article/12, etc.).
Pour pallier à cette éventualité, nous devons nous assurer que le suffixe de l’URL qui arrive est bien celui attendu. Nous allons effectuer un petit contrôle dans l’action view du Contrôleur Produits :

// {app}/controllers/produits_controller.php
function view($id = null, $suffixe = '')
{
	$produit = $this->Produit->read(null, $id);
 
	// Produit inexistant : erreur 404
	if(empty($produit))
	{
		$this->cakeError('error404', array(array('url' => $this->action)));
	}
 
	// Suffixe incorrect : redirection 301 vers la bonne URL
	$suffixe_attendu = Inflector::slug($produit['Produit']['nom'], '-');
 
	if($suffixe != $suffixe_attendu)
	{
		$this->redirect(array('id' => $id, 'suffixe' => $suffixe_attendu), 301);
	}
 
	$this->set(compact('produit'));
}

Ainsi nous nous assurons que toute URL mal formée sera redirigée vers la bonne URL avec un code HTTP 301 : ce code va forcer les moteurs de recherche qui suivront les liens, éventuellement mal formés, vers cette page, à ne prendre en considération que la bonne URL.

[CDI / STAGE] Offre d’emploi, développeur PHP (H/F) à Paris

L’entreprise :

Filiale informatique d’un grand groupe de presse français créé il y a plus de 15 ans, l’Agence MRJ est une PME innovante reconnue par ses clients pour ses compétences et son savoir-faire. Nous accompagnons nos clients dans la conception, le développement, le déploiement et le suivi de leurs outils de gestion de contenu Web (Portails Internet, Intranet d’entreprise, Extranets de gestion…), de Gestion Documentaire, de travail collaboratif, d’Ebusiness et de Gestion de la Relation Client.

Quelques références : Azzaro Homme, Arrow, Française des jeux, etc.

Dans le cadre de la croissance de son activité et pour accompagner le lancement de nouveaux projets innovants, l’agence recherche un développeur PHP / MYSQL (H/F) en stage et un CDI.

De formation Bac+2 minimum, vous justifiez d’une première expérience réussie sur des projets web (portails, e-commerce, e-CRM, etc). Vous maîtrisez l’intégration HTML (Javascript inclus), PHP orienté objet et au minimum MySQL.

Vous connaissez ou à défaut possédez un grand intérêt pour :
Administration d’un serveur web (Debian), Versionning (SVN), PostgreSQL, Framework de développement.

Vous serez formé à nos méthodes et outils de travail, et nous vous offrons un environnement à taille humaine, jeune et expérimenté, où vos initiatives sont valorisées !

Candidature :
Si vous désirez rejoindre notre équipe dynamique, n’hésitez pas à nous transmettre votre candidature à : recrut-dev0809[at]mrj-webagency.com.

1. Détermination du chemin parcouru

Nous allons appeler la méthode getpath, automatiquement ajoutée au Modèle Category par le Comportement Tree, qui renvoie un tableau avec tous les ancêtres d’une catégorie, elle-même incluse à la fin du tableau. Nous plaçons cette logique dans l’action view du Controller Categories :

// {app}/controllers/categories_controller.php
function view($id = null)
{
	// La catégorie
	$this->set('category', $this->Category->read(null, $id));
 
	// La liste de ses ancêtres
	$this->set('path', $this->Category->getpath($id));
}

Nous passons à la vue les données de la catégorie choisie, sous le nom $category, et le tableau de ses ancêtres, sous le nom $path.

2. Affichage

2.1 La méthode HtmlHelper::addCrumb

Cette méthode du Helper Html permet d’ajouter une “tranche” au chemin parcouru, sous forme d’un lien ou d’un texte simple. Nous voulons dans notre cas que le chemin permette de remonter facilement dans l’arborescence, les ancêtres de la catégorie en cours devront donc être cliquables, mais pas la catégorie elle-même puisque nous y sommes déjà.

// {app}/views/categories/view.ctp
foreach($path as $crumb)
{
	$url = null;
 
	// Catégorie en cours ?
	if($crumb['Category']['id'] != $category['Category']['id'])
	{
		$url = $html->url(array($crumb['Category']['id']));
	}
 
	$html->addCrumb($crumb['Category']['libelle'], $url);
}

2.2 La méthode HtmlHelper::getCrumb

Nous n’avons plus qu’à afficher notre chemin avec la méthode getCrumb, à qui nous indiquons que nous souhaitons séparer les tranches du chemin par le signe “>” ou “strictement supérieur à”, dont l’entité html s’écrit “>”.

// {app}/views/categories/view.ctp
<div id="breadcrumbs">
	<strong>Vous êtes ici :</strong> <?php echo $html->getCrumbs(' &gt; '); ?>
</div>

Nous obtenons un joli chemin sous la forme :
Vous êtes ici : Catégorie 1 > Catégorie 1.2 > Catégorie 1.2.8.

1. Le traitement javascript devra être non-obstrusif ;
2. Lorsqu’une catégorie est cliquée, la page d’arrivée doit faire apparaître la branche de la catégorie choisie dépliée (enfants éventuels + ancêtres) et les autres repliées.

1. Installation du plugin jQuery, TreeView

Nous choisissons d’utiliser la librairie javascript jQuery et l’un de ses plugins, TreeView. Le plugin offre plusieurs styles pour la présentation de l’arborescence que nous pouvons voir sur cette page d’exemples. Nous choisissons le premier exemple, “Sample 0″.

Nous téléchargeons l’archive et répartissons son contenu de la façon suivante :

• jquery.treeview.pack.js (la version la plus compacte) dans le dossier {app}/webroot/js/
• jquery.treeview.css dans le dossier {app}/webroot/css/
• images/treeview-default-line.gif et images/treeview-default.gif dans le dossier {app}/img/ (les deux images nécessaires à la présentation du “Sample 0″)

2. Génération de l’arbre

Comme nous souhaitons que l’ajout du javascript soit non-obstrusif, la navigation dans l’arborescence doit être possible si le javascript est désactivé ou indisponible sur le navigateur client. Nous reprenons donc le code présenté dans le sujet précédent, quasiment à l’identique :

// {app}/app_controller.php
class AppController extends Controller
{
	var $helpers = array('Html', 'Form', 'Tree');
	var $uses = array('Category');
 
	function beforeRender()
	{
		$this->Category->recursive = -1;
		$layout_categories = $this->Category->children(false);
		$this->set('layout_categories', $layout_categories);
	}
}

// /views/layout/default.ctp
echo $tree->generate(
	$layout_categories,
	array(
		'model'   => 'Category',
		'element' => 'category_layout',
		'id'      => 'arborescence',
	)
);

Seul différence ici, l’ajout de l’identifiant ‘arborescence’ au premier <ul> de la liste, qui va permettre au plugin TreeView d’identifier l’élément à transformer en arbre.

// /views/elements/category_layout.ctp
echo $html->link(
	$data['Category']['libelle'],
	array(
		'controller' => 'categories',
		'action'     => 'view',
		$data['Category']['id']
	)
);

// {app}/controllers/categories_controller.php
function view($id = null)
{
	$category = $this->Category->read(null, $id);
 
	$this->set(compact('category'));
}

Dans l’action du Contrôleur Categories, nous n’essayons plus de retrouver le chemin parcouru jusqu’à la catégorie cliquée, le plugin sera en effet capable d’afficher lui-même la catégorie choisie dépliée avec ses enfants et ses ancêtres en se basant sur l’url de la page.

3. Mis en place du plugin

Il ne nous reste qu’à appeler la librairie jQuery et le plugin TreeView dans le header du layout.

// /views/layout/default.ctp
<head>
<?php e($javascript->link('http://www.google.com/jsapi')); ?> 
<script type="text/javascript">google.load("jquery", "1.2.6");</script>
<?php
e($javascript->link('jquery.treeview.pack.js'));
e($javascript->link('jquery.treeview.init.js'));
e($html->css('jquery.treeview.css', null, array('media' => 'screen')));
?> 
</head>

Voyons l’effet de ces 5 lignes :

• Les deux premières lignes servent à inclure la librairie javascript jQuery en se servant d’un service gratuit de Google, qui se charge de mettre à disposition du site la version choisie de jQuery, ici la 1.2.6. Nous économisons un peu de bande passante, mais surtout nous profitons de la vitesse de réponse des serveurs de Google, et du fait qu’il est possible que le navigateur client ait déjà visité un site qui profite de ce service avant d’arriver sur le nôtre, et donc que la librairie soit déjà présente dans le cache ;
• la 3ème ligne inclut le plugin TreeView ;
• la 4ème ligne inclut un petit bout de code javascript que nous allons créer juste après pour initialiser le plugin ;
• la 5ème ligne inclut la feuille de style CSS pour présenter l’arborescence.

4. Initialisation du plugin TreeView

Il ne nous reste qu’à créer un petit fichier javascript pour initialiser le plugin :

// {app}/webroot/js/jquery.treeview.init.js
$(document).ready(function(){
	$('#arborescence').treeview({
		persist:   'location',
		collapsed: true,
		animated:  'fast'
	});
});

Voyons les options définies :

• persist : cette option peut prendre deux valeurs : ‘cookie’ et ‘location’. Avec ‘cookie’, le plugin se sert d’un cookie pour savoir quelle branche afficher, avec ‘location’, le plugin compare l’url en cours avec chaque url de l’arbre ;
• collapsed : si vrai, l’arbre est affiché replié sauf la branche de la catégorie choisie ; si faux, l’arbre est affiché déplié par défaut, quelle que soit la catégorie cliquée ;
• animated : définie la vitesse d’animation lors de l’ouverture ou la fermeture d’une branche. Si cette option n’est pas définie, il n’y aura pas d’animation.

Nous laissons le lecteur explorer les autres options du plugin sur cette page : TreeView options.

1. Passage de l’arborescence au layout

Comme pour l’administration de l’arbre, nous allons utiliser dans les Vues le Helper Tree créé par AD7six, mais cette fois nous allons nous en servir pour afficher l’arborescence sur toute la partie publique du site. C’est pourquoi nous devons changer l’appel au Helper, nous le passons du Contrôleur Categories au Contrôleur général.

C’est également ce Contrôleur général qui va se charger de passer l’arborescence au layout public. Le meilleur endroit pour effectuer cette opération est sans doute la méthode beforeRender qui sera appelée avant la génération des Vues.

// {app}/app_controller.php
class AppController extends Controller
{
	var $helpers = array('Html', 'Form', 'Tree');
	var $uses = array('Category');
 
	function beforeRender()
	{
		$this->Category->recursive = -1;
		$layout_categories = $this->Category->children(false);
		$this->set('layout_categories', $layout_categories);
	}
}

Rappelons que la méthode children(), ajoutée par le Comportement Tree, renvoie l’arborescence complète quand elle est appelée avec le seul paramètre false.

2. Le layout public

Affichons maintenant notre arborescence dans le layout principal :

// /views/layout/default.ctp
echo $tree->generate(
	$layout_categories,
	array(
		'model'   => 'Category',
		'element' => 'category_layout'
	)
);

N’oublions pas ici de préciser quel Modèle est concerné, sinon le Helper ne pourra pas afficher l’arbre correctement.

3. L’élément d’affichage d’une catégorie

Le Helper permet d’appeler un élément pour chaque branche, découvrons-le :

// /views/elements/category_layout.ctp
echo $html->link(
	$data['Category']['libelle'],
	array(
		'controller' => 'categories',
		'action'     => 'view',
		$data['Category']['id']
	)
);

Nous avançons, mais toutes les catégories sont affichées, quel que soit leur niveau. Or nous ne voulons afficher que les catégories de premier niveau, plus les enfants d’une catégorie, si l’une d’elle a été cliquée.

Nous devons commencer par savoir si une catégorie a été cliquée, et si oui, laquelle. Cette logique s’effectue dans le Contrôleur Categories, dans l’action view qui est la destination de tous les liens de notre menu. Mais attention, la catégorie cliquée peut ne pas être de premier niveau, mais se trouver profondément dans l’arbre, nous devons donc pour une catégorie donnée remonter toute l’arborescence pour identifier ses parents :

// {app}/controllers/categories_controller.php
function view($id = null)
{
	$category = $this->Category->read(null, $id);
 
	$path_ids = $this->Category->get_path_ids($id);
 
	$this->set(compact('category', 'path_ids'));
}

Voyons la méthode get_path_ids, que nous plaçons dans le Modèle Category :

// {app}/models/category.php
function get_path_ids($id = null)
{
	$path = $this->getpath($id);
 
	return Set::extract('/Category/id', $path);
}

La méthode getpath a été ajoutée automatiquement par le Comportement Tree au Modèle Category, et renvoie un tableau des parents d’un élément de l’arbre (ainsi que l’élément lui-même, en dernier). Seuls les id des catégories nous intéressent, nous les extrayons donc avec la méthode statique extract de la class Set. Grâce à cette liste d’id de catégories, nous pouvons boucler sur les éléments de l’arbre et voir si l’id de catégorie en cours appartient à cette liste, auquel cas nous devons l’afficher ainsi que ses filles éventuelles.

4. Affichage de l’arborescence

Nous avons ici deux possibilités pour parvenir au même résultat visuel : soit nous continuons d’afficher toutes les branches dans le source HTML et cachons les catégories qui doivent l’être avec une propriété CSS, soit nous effectuons un traitement préalable du tableau des catégories avant le boucler dessus.

4.1. Méthode 1 : Arborescence complète et camouflage CSS

Commençons par la méthode la plus simple : reprenons simplement l’élément d’affichage d’une catégorie, appelé par le Helper Tree, et ajoutons un petit test :

// /views/elements/category_layout.ctp
if(!isset($path_ids)) $path_ids = array();
 
if($hasChildren && !in_array($data['Category']['id'], $path_ids))
{
	$tree->addTypeAttribute('style', 'display', 'none');
}
 
echo $html->link(
	$data['Category']['libelle'],
	array(
		'controller' => 'categories',
		'action'     => 'view',
		$data['Category']['id']
	)
);

Le test est assez limpide : si la catégorie en train d’être analysée a des enfants (la variable $hasChildren nous est automatiquement fournie par le Helper Tree) et que l’id de la catégorie n’est pas dans la liste $path_ids (la catégorie cliquée et ses parents), alors nous ajoutons un style CSS grâce à la méthode addTypeAttribute pour cacher les enfants. Nous obtenons bien le résultat attendu, mais ce n’est que visuel, les catégories cachées sont toujours dans le code source HTML.

4.2. Méthode 2 : Suppression des catégories non voulues dans l’arbre à postériori

Pour cette deuxième méthode, revenons en arrière et reprenons l’élément tel qu’il l’était au début.

// /views/elements/category_layout.ctp
echo $html->link(
	$data['Category']['libelle'],
	array(
		'controller' => 'categories',
		'action'     => 'view',
		$data['Category']['id']
	)
);

La logique va intervenir avant de passer l’arborescence au layout, dans le Contrôleur général.

// {app}/app_controller.php
class AppController extends Controller
{
	var $helpers = array('Html', 'Form', 'Tree');
	var $uses = array('Category');
 
	var $path_ids = array();
 
	function beforeRender()
	{
		$this->Category->recursive = -1;
		$layout_categories = $this->Category->children(false);
 
		foreach($layout_categories as $i => $cat)
		{
			if(!empty($cat['Category']['parent_id']) && !in_array($cat['Category']['id'], $this->path_ids) && !in_array($cat['Category']['parent_id'], $this->path_ids))
			{
				unset($layout_categories[$i]);
			}
		}
 
		$this->set('layout_categories', $layout_categories);
	}
}

Notons l’ajout de la variable de classe $path_ids, un tableau vide par défaut.
Le raisonnement est le même : pour chaque catégorie de l’arbre, si le parent n’est pas nul (catégorie qui n’est pas de premier niveau), que l’id du parent n’est pas dans la liste $path_ids et que l’id de la catégorie n’est pas dans la liste $path_ids, alors nous enlevons la catégorie du tableau.

Il ne nous reste qu’à changer légèrement le comportement de l’action view dans le Contrôleur Categories :

// {app}/controllers/categories_controller.php
function view($id = null)
{
	$category = $this->Category->read(null, $id);
 
	$this->path_ids = $this->Category->get_path_ids($id);
 
	$this->set(compact('category'));
}

Cette fois nous n’avons plus besoin de passer la liste des id des parents à la Vue, mais nous la passons à la variable de classe pour que le Contrôleur général puisse y accéder.

Notre arborescence est terminée. Nous verrons dans un prochain sujet comment faire une présentation sous forme d’arbre interactif avec jQuery.

1. La table categories

Le Comportement Tree utilise la méthode dite de “représentation intervallaire” pour gérer l’arborescence (en anglais, Modified Preorder Tree Traversal). Nous sortons ici du cadre de CakePHP, et laissons le lecteur découvrir cette méthode de représentation en lisant l’excellent article de SQL Pro : Gestion d’arbres par représentation intervallaire. Retenons simplement que le Comportement Tree impose la présence de 3 champs dans la table de l’arborescence :

• parent_id : l’id du parent
• lft : borne basse
• rght : borne haute

Voici donc la déclaration complète de notre table des catégories :

CREATE TABLE `categories` (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  `parent_id` int(10) UNSIGNED DEFAULT NULL,
  `lft` int(10) UNSIGNED NOT NULL,
  `rght` int(10) UNSIGNED NOT NULL,
  `libelle` varchar(50) collate utf8_unicode_ci NOT NULL,
  PRIMARY KEY  (`id`),
  KEY `parent_id` (`parent_id`),
  KEY `lft` (`lft`)
)

2. Le Modèle Category

Voyons le Modèle associé à notre table :

class Category extends AppModel
{
	var $displayField = 'libelle';
 
	var $hasMany = array('Product');
 
	var $actsAs = array('Tree');
 
	var $validate = array(
		'libelle' => array(
			'rule'       => '/\S+/',
			'required'   => true,
			'allowEmpty' => false,
			'message'    => "Le libellé de la catégorie doit être renseigné."
		),
		'parent_id' => array(
			'rule'    => 'checkParadox',
			'on'      => 'update',
			'message' => "Une catégorie ne peut pas devenir sa propre fille !"
		)
	);
 
	/**
	 * Retourne faux si l'id est égal au nouvel id parent
	 *
	 * @param array $data Données à valider, en provenance du formulaire.
	 * @return boolean Faux si id == parent_id, vrai sinon.
	 */
	function checkParadox($data)
	{
		if(isset($this->data[$this->alias]['id']))
		{
			return $data['parent_id'] != $this->data[$this->alias]['id'];
		}
		return true;
	}
}

Quelques éclaircissements :

• la variable $displayField sera nécessaire pour présenter correctement les catégories sous forme d’une liste déroulante dans un <select> ;
• nous définissons une relation hasMany entre une catégorie et un produit ;
• $actsAs : nous indiquons à Cake que le Modèle Category doit se comporter comme une arborescence ;
• $validate : deux règles de validation sont mises en place : la première indique que le libellé d’une catégorie ne doit jamais être vide, la deuxième fait appel à une méthode définie juste après qui garantie qu’une catégorie ne peut pas s’avoir elle-même comme parent.

3. Les Vues

Nous n’allons voir que les Vues de l’administration des catégories, à savoir la vue d’ajout/édition, et la vue des catégories sous forme d’un arbre avec la possibilité de monter ou descendre une catégorie dans l’arborescence.

3.1. La Vue d’ajout/édition

<?php
// {app}/views/categories/admin_edit.ctp
$this->pageTitle = "Ajouter";
 
if(!empty($this->data['Category']['id'])) {
	$this->pageTitle = "Modifier";
};
 
$this->pageTitle .= " une catégorie";
 
e($form->create('Category', array('action' => 'edit')));
e($form->input('id'));
?>
 
<fieldset>
	<legend><?php e($this->pageTitle); ?></legend>
 
	<?php
	e($form->input('parent_id', array('label' => "Parent :", 'empty' => "Racine")));
	e($form->input('libelle', array('label' => "Nom de la catégorie :")));
	?>
</fieldset>
 
<?php e($form->end('Valider')); ?>
 
<p><?php e($html->link("Liste des catégories", 'index')); ?></p>

3.2. La Vue des catégories

Nous allons utiliser pour cette Vue un formidable Helper créé par AD7six (Andy Dawson), que nous récupérons ici : Tree Helper et recopions dans un nouveau fichier {app}/views/helpers/tree.php

<?php
// {app}/views/categories/admin_index.ctp
$this->pageTitle = "Arborescence des catégories";
 
echo $tree->generate(
	$categories,
	array('element' => 'categories_admin_index')
);
?>

La superbe simplicité de ce Helper réside dans la possibilité d’utiliser un Elément qui sera appelé pour chaque catégorie de l’arborescence, le tout entouré par les balises <ul>…</ul>. Voyons sans attendre ce fameux élément :

<?php
// {app}/views/elements/categories_admin_index.ctp
$id = $data['Category']['id'];
?>
<h4><?php e($data['Category']['libelle']); ?></h4>
<ul class="options">
	<li><?php e($html->link('Monter', 'move_up/'.$id)); ?></li>
	<li><?php e($html->link('Descendre', 'move_down/'.$id)); ?></li>
	<li><?php e($html->link("Modifier", 'edit/'.$id)); ?></li>
	<li><?php e($html->link("Supprimer", 'delete/'.$id, null, "Etes-vous sûr ?")); ?></li>
</ul>

Résultat : moyennant quelques petites règles CSS, nous obtenons une belle arborescence sous forme de listes non-ordonnées imbriquées !

4. Le Contrôleur Categories

Nous terminons par les actions d’administration dans le Contrôleur :

<?php
// {app}/controllers/categories_controller.php
class CategoriesController extends AppController
{
	// Appel du Helper Tree
	var $helpers = array ('Tree');
 
	/**
	 * Liste des catégories
	 */
	function admin_index()
	{
		$this->Category->recursive = -1;
		$categories = $this->Category->children(false);
 
		$this->set(compact('categories'));
	}
 
	/**
	 * Ajout/édition d'une catégorie
	 *
	 * @param int $id Id de la catégorie
	 */
	function admin_edit($id = null)
	{
		if(isset($this->data))
		{
			$this->Category->set($this->data);
 
			if (!$this->Category->validates())
			{
				$this->Session->setFlash("Corrigez les erreurs mentionnées.", 'message_notice');
				return;
			}
 
			$this->Category->save(null, false);
 
			$this->Session->setFlash("Données enregistrées.", 'message_ok');
			$this->redirect('index');
		}
 
		$this->data = $this->Category->read(null, $id);
		$this->set('parents', $this->Category->generatetreelist());
	}
 
 
	/**
	 * Monte une catégorie d'un cran
	 *
	 * @param int $id Id de la catégorie
	 */
	function admin_move_up($id = null)
	{
		if(!$this->Category->moveup($id))
		{
			$this->Session->setFlash("La catégorie ne peut pas aller plus haut.", 'message_notice');
		}
		else
		{
			$this->Session->setFlash("Ordre mis à jour.", 'message_ok');
		}
 
		$this->redirect($this->referer());
	}
 
	/**
	 * Descend une catégorie d'un cran
	 *
	 * @param int $id Id de la catégorie
	 */
	function admin_move_down($id = null)
	{
		if(!$this->Category->movedown($id))
		{
			$this->Session->setFlash("La catégorie ne peut pas aller plus bas.", 'message_notice');
		}
		else
		{
			$this->Session->setFlash("Ordre mis à jour.", 'message_ok');
		}
 
		$this->redirect($this->referer());
	}
 
	/**
	 * Suppression d'une catégorie
	 *
	 * @param int $id Id de la catégorie
	 */
	function admin_delete($id = null)
	{
		$this->Category->id = $id;
 
		if(!$this->Category->exists())
		{
			$this->Session->setFlash("Enregistrement introuvable.",'message_error');
		}
		else
		{
			$this->Category->del();
			$this->Session->setFlash("Données supprimées.",'message_ok');
		}
 
		$this->redirect($this->referer());
	}
}

Quelques points intéressants :

• admin_index : nous faisons appel à la méthode children, ajoutée par le Comportement, et qui appelée avec le seul argument false renvoie l’arborescence complète ;
• admin_edit : rappelons que dans la Vue de cette action, nous affichons la liste déroulante des catégories déjà existantes pour pouvoir définir le parent de la catégorie en train d’être créée ou modifiée. Pour obtenir cette liste, nous faisons appel à la méthode generatetreelist, ajoutée par le Comportement Tree au Modèle Category. Dans la Vue d’ajout/édition, l’arborescence pour le choix du parent sera sommairement représentée par des underscores _ :
  • Racine (ajouté dans la définition du <select>)
  • Catégorie 1
    • _Catégorie 1.1
    • _Catégorie 1.2
      • __Catégorie 1.2.1

  Notons l’utilisation d’un petit raccourci qui fait aimer CakePHP : une fois que nous avons passé la liste des parents à la vue avec $this->set('parents',...), il n’est même pas besoin de le dire dans la définition du <select>, la méthode $form->input('parent_id') s’en charge !

• admin_move_up et admin_move_down : ces deux petites actions font appel là encore à deux méthodes ajoutées automatiquement par le Comportement : moveup et movedown qui permettent de modifier l’ordre des catégories partageant le même parent.
• admin_delete : nous procédons exactement comme avec n’importe quelle suppression, le Comportement se charge seul de mettre l’arborescence à jour.

Nous verrons très prochainement comme présenter une telle arborescence, tout d’abord de manière statique avec l’affichage des catégories filles au fur et à mesure de la progression dans l’arbre, puis de manière dynamique où la navigation dans l’arbre se fera en javascript avec jQuery, sans recharger la page.

1. Pré-requis

Pour faire fonctionner le Helper, nous devons commencer par télécharger la dernière version de SWFObject : Télécharger SWFObject
Nous récupérons une archive dans laquelle nous trouvons le fichier swfobject.js à placer dans {app}/www/js/, et le fichier expressInstall.swf à placer où bon nous semble dans {app}/www/ (nous choisissons de le placer dans {app}/www/img/).

2. SwfobjectHelper

Voici sans plus tarder le Helper Swfobject, à recopier dans un fichier {app}/views/helpers/swfobject.php :

<?php
/**
 * Insertion d'une animation Flash avec SWFObject
 * http://code.google.com/p/swfobject/
 */
class SwfobjectHelper extends Helper
{
/**
* Swfobject Flash vars.
*
* @var array
*/
    var $__flashvars = array();
/**
* Swfobject params.
*
* @var array
*/
    var $__swfparams = array();
/**
* Swfobject Attributes.
* 
* @var array
*/
    var $__attributes = array();
 
/**
* Options par défaut
*
* @var array
*/
    var $__baseOptions = array(
    	'width'   => '640',
    	'height'  => '480',
    	'version' => '9.0.0',
    	'express' => 'expressInstall.swf'
    );  
 
/**
* Création de l'objet Flash
*
* @param string $path Chemin vers l'animation Flash
* @param string $id Id de l'élément HTML qui sera remplacé par l'animation
* @param array $options
* @return Code HTML à insérer entre <head>...</head>
*/
	function create($path, $id = 'flashcontent', $options = array())
	{
		$options = am($this->__baseOptions, $options);
 
		$out = '<script type="text/javascript">';
		$out .= "\n";
 
		// Flashvars
		$out .= $this->javascriptObject('flashvars', $this->__flashvars);
 
		// Params
		$out .= $this->javascriptObject('params', $this