Il est très utile dans une application Web d’avoir un système de navigation capable de cartographier les pages d’un site et d’en déduire des plan de site, fils d’arianes, menus, sitemap.xml, …

Zend_Navigation a été conçu dans cette optique, il propose un système de gestion de pages et des helpers pour générer des composants graphiques.

Nous allons voir dans ce tutoriel une façon simple de mettre en place Zend_Navigation :

Tout d’abord il nous faut définir la navigation et le conteneur de donnée. Dans notre cas, on stockera l’arborescence dans un fichier XML appellé ‘navigation.xml’ dans le répertoire « config ».

protected function _initNavigation() {
$this->bootstrap('layout');
$layout = $this->getResource('layout');
$view = $layout->getView();
$config = new Zend_Config_Xml(APPLICATION_PATH . '/configs/navigation.xml', 'nav');
$container = new Zend_Navigation($config);
$view->navigation($container);
}
<div>

Ensuite, on remplit le fichier « navigation.xml » pour créer notre navigation, on y indiquera la page d’accueil et une page de listing.
On se basera sur le système de routes pour donner le lien.

<configdata>
 <nav>
 <home>
 <label>Accueil</label>
 <route>index</route>
 <pages>
 <listing>
 <label>Liste CRUD</label>
 <route>listing</route>
 </listing>
</pages>
</home>
</nav>
</configdata>

Et voilà la mise en place de Zend_Navigation est fini. Il ne vous reste plus qu’à utiliser des helpers pour appeler vos composants :
Pour le breadcrumb par exemple :

$this->navigation()->breadcrumbs()->setSeparator(" -> ");

Il existe d’autres façon d’intégrer Zend_Navigation sur une application notamment en intervenant directement sur le code. Cette méthode reste très simple mais très fonctionnelle. On y pourra voir des améliorations comme mettre en place un cache pour augmenter les performances.

L’extension est téléchargeable à cette adresse : https://chrome.google.com/extensions/detail/kfiahljocaflpaiopilgpiochncgdnhd

Les résultats de recherche sont identiques à ceux du moteur de recherche de PHP.NET

Une rumeur circule depuis quelques temps, à propos d’une ré-inventation de PHP par Facebook pour optimiser les performances de leurs applications. Cette dernière a été désormais par la firme, un ingénieur a travaillé sur une refonte de la runtime de PHP afin d’avoir un résultat compilé et non plus interprété comme c’est le cas actuellement avec la runtime de Zend.

Le projet s’appelle HipHop et il s’appuie non pas sur un compilateur mais plutôt sur un transcodeur qui permet de passer d’un code PHP à un code C++ très optimisé et ce dernier pouvant être compilé avec g++.

Ce travail a mis plus de 2 ans avant de voir le jour et ce travail verra le jour très bientôt dans un projet Open Source sous licence Creative-Commons.

Voici le processus de HipPop pour optimiser une application PHP :

Il s’agit d’une transformation de code qui part de sources PHP, le code est parsé et ensuite optimisé avant d’être traduit en C++. Le code C++ est lui aussi optimiser et ensuite il est compilé via G++ en langage machine.

Certaines fonctions trop gourmande comme « eval() » ne seront pas supportées mais la globalité du langage est supportée.

Les essais de Facebook révèleraient un gain de performance de l’ordre de 80 % coté processeur et l’application Facebook elle-même devrait migrer sur cette technologie d’ici quelques semaines ou quelques mois. Ils devraient réduire de 50 % l’utilisation du CPU pour héberger Facebook ce qui constitue une économie intéressante puisqu’au dernières nouvelles Facebook, utiliserait plus 30 000 machines pour héberger son réseau social.

La preuve c’est qu’ il s’agit du 3ème point qui influe le plus le référencement d’une page. Et puis on peut également avoir besoin internationaliser ses urls.

Zend Framework possède un routeur, qui permet de manipuler plus facilement les liens entre les pages au sein d’une application et également de faire de la réécriture.

Cette étape se fait au sein du Bootstrap d’une application Zend Framework et grâce à Zend_Controller.

Il faut tout d’abord surcharger la méthode _initAutoLoad() du Bootstrap et récupérer l’instance de Zend_Controller

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

// Surcharge de _initAutoLoad
protected function _initAutoload()

{
$moduleLoader = new Zend_Application_Module_Autoloader(array('namespace'=>'', 'basePath'=>APPLICATION_PATH));

$frontController = Zend_Controller_Front::getInstance();
$router = $frontController->getRouter();

return $moduleLoader;
}

}

Ensuite il suffit simplement de créer ses routes et de les rajouter au routeur du contrôleur.
Pour cela on a plusieurs possibilités, on peut créer des routes statiques, des routes basées sur les modules, etc …
Le plus efficace est de créer des routes à partir d’URL pré-formatées grâce à des expressions régulières.
On devra donc créer des instances de la classe Zend_Controller_Router_Route_Regex.

On la construira avec les arguments suivants :

1) La route : sous forme d’expression régulière (exemple : ‘produits/(.+)/(.+)/article-(.+)-(.+).html’)
2) Le lien MVC : il faut donner les éléments statiques pour accéder à la page, c’est à dire le module, le contrôleur et l’action cible (exemple : array(‘module’ => ‘default’, ‘controller’ => ‘products’, ‘action’ => ’showProduct’))
3)Le mapping des paramètre : on donne dans l’ordre le nom des paramètres que l’on passera dans l’Url (exemple : array(1 => ‘category’, 2=> ’subcategory’, 3 => ‘product_title’, 4 => ‘product_ref’))
4) Le chemin inverse : une version de l’url interprétable par la fonction sprintf() de PHP (exemple : ‘produits/%s/%s/article-%s-%d.html’)

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

// Surcharge de _initAutoLoad
protected function _initAutoload()

{
$moduleLoader = new Zend_Application_Module_Autoloader(array('namespace'=>'', 'basePath'=>APPLICATION_PATH));

$frontController = Zend_Controller_Front::getInstance();
$router = $frontController->getRouter();

// Nouvelle route pour accéder à produit
$article = new Zend_Controller_Router_Route_Regex(
 'produits/(.+)/(.+)/article-(.+)-(.+).html',
 array('module' => 'default', 'controller' => 'products', 'action' => 'showProduct'),
 array(1 => 'category', 2=> 'subcategory', 3 => 'product_title', 4 => 'product_ref'),
 'produits/%s/%s/article-%s-%d.html');
$router->addRoute($article);

return $moduleLoader;
}

}

Ainsi on pourra créer et appeler une url de type : « www.maboutique.com/produits/processeurs/dual-core/article-intelcore2duo-PI5421.html »

A l’heure où les environnements de développement pour PHP sont majoritairement basé sur Eclipse : PHP Development Tools, Aptana et Zend Studio, Netbeans quant à lui se faisait très discret dans le domaine des IDE PHP.

Voici la nouvelle version de NetBeans en release 6.8 avec des outils de développement pour PHP 5 fort intéressants :

Tout d’abord il existe une version de l’IDE entièrement dédié au développement PHP comme c’est le cas de la version All-In-One d’Eclipse.

- Il supporte également la version 5.3 de PHP

- Débugage de PHP dans l’IDE

- Exécution et pilotage de test-unitaires mis en place avec PHPUnit

- Support du Framework Symfony (autocompletion, exécution d’actions en ligne de commande depuis une console dans l’ide, support du YAML, …)

Nous allons nous intéresser au support de Symfony dans l’IDE et voir si son usage facile le développement avec le framework PHP français !

L’interface de NetBeans 6.8 est relativement simple, ergonome et traduite dans toutes les langues pour les non-anglophones.

1. Paramétrage de NetBeans pour PHP

Le paramétrage de NetBeans se fait en 3 étapes :

- Le chemin de l’exécutable « php.exe »
- Le chemin du script de PHPUnit (facultatif)
- Le chemin de la sandbox de symfony (symfony.bat ou symfony.sh)

Vous devez spécifier le chemin de votre serveur PHP, c’est à dire l’emplacement du « php.exe » de votre installation pour utiliser les fonctions de débugage, compilation et exécution de code PHP en « Command Line Interface ». Dans mon exemple, je donne le chemin d’accès de mon installation WAMP.

En suite, il vous faudra spécifier le chemin d’accès à la sandbox de Symfony, sous Windows il s’agit du fichier « symfony.bat ».

2. Création de votre projet Symfony

Pour créer votre projet Symfony, rien de plus simple, il suffit d’aller sur « Fichier -> Nouveau Projet » et de créer un nouveau projet « Application PHP ».

Donnez ensuite, un nom à votre projet, sélectionnez la version de PHP utilisée, dans notre cas, on pourra se contenter de la version 5.2.x.
N’oublier pas de donner le répertoire contenant le code source  du framework Symfony cela fonctionne avec n’importe quelle version du framework à priori sauf peut être pour la version en développement 2.0.

Pour ce qui est de la configuration de l’environnement de production pour le déploiement, nous n’avons pas à nous en soucier. On se contentera d’un environnement serveur en local.

Enfin on pourra spécifier que l’on veut utiliser le framework Symfony et que l’on veut générer une application « frontend » (application web principale destinée aux visiteurs du site) et une application « backend » (application dédiée à l’administration et au backoffice de l’application principale).

3. Dans la pratique

Voici comment se présente notre projet Symfony sous Netbeans 6.8. Nous avons un très bon éditeur de YML / YAML avec coloration syntaxique, autocompletion et schéma hiérarchique

On pourra également utiliser l’outil de génération de code en ligne de commande de Symfony en allant sur « MySymfonyProject -> click-droit -> Run Symfony Command ».

On a le résultat de l’exécution de la ligne de commande dans le partie console de NetBeans cet outil est très pratique pour exécuter les tests-unitaires de LIME le framework de test intégré à Symfony.

On niveau du développement « pur », on constate que l’autocompletion répond bien à la plupart des besoins de développeurs : les objets des vues, contrôleurs comme $sfWebRequest, $sfWebResponse, $view peuvent être appeler sans problème avec une intelliSense et même avec une petite documentation.

Conclusion

Ce support du framework Symfony est très intéressant à la fois pour la communauté des développeurs Symfony mais aussi pour NetBeans qui pourra peut être se faire une meilleure réputation dans le développement PHP car il faut le rappeler Symfony est le framework de développement PHP le plus utilisé avec Zend Framework . Les fonctionnalités de NetBeans vis à vis de ce framework sont très basiques mais relativement utiles. On regrettera peut être une meilleure intégration du framework de test unitaire et une génération de code plus importante. Peut-être vaut-il le coup d’être utiliser à la place d’Eclipse ou Aptana dans une optique de développement Symfony ? Ou aurons-nous du mal à nous séparer de nos bons vieux plugins sur Eclipse (pour Subversion, Database Explorer, PDT, Smarty, jQuery) ? Pour ma part, NetBeans a gagné ma confiance, je lui trouve une bonne ergonomie et une grande simplicité d’utilisation. Il existe une autre solution  pour le support de Symfony mais qui est quant-à-elle payante : il s’agit de PHPEdit il faut compter environ 219€ pour une version avec le support de Symfony et presque 300 € pour le support de PHPUnit et SVN.

Aptana PHP Theme

La sortie de cette nouvelle version s’accompagne d’une amélioration de la rubrique PhoogleMap sur le site avec des exemples téléchargeables, des sources mises à jour, une présentation approfondie, une PHP Doc en anglais, et des nouvelles ressources.

Très prochainement, je rajouterai une documentation complète en français et en anglais ainsi que de nouveaux exemples.

Aptana Studio est un IDE (Environnement de Développement orienté) Web 2.0 et basé sur les fondations d’Eclipse. Son principal avantage est qu’il n’utilise pas les plugin’s traditionnels d’Eclipse au profit de plugin’s développés par aptana qui sont beaucoup plus performants et plus astucieux.

Le logiciel est un environnement complet pour :

- PHP (sans passer le PDT d’Eclipse)

- Ruby On Rails

- Python Web

- Framework Javascript : jQuery, Prototype, Mootools, Adobe Spry, Dojo, …

- Javascript, HTML, CSS

- Application Adobe Air, Flex, …

De plus, vous pourrez installer tous vos plugins préférés sur Aptana ou bien inversement, installer les plugins d’Aptana sur votre Eclipse existant !

Aptana est totalement libre et disponible sur Windows, MacOS X, Linux. Certaines personnes pourront également le coupler à une version 64 bits d’Eclipse sous Linux.

Rendez-vous sur le site Officiel : http://www.aptana.com

Voici un tutorial pour créer une application « composant » sur Joomla! grâce à la nouvelle API basé sur Joomla framework MVC 1.5

Le gros avantage de la version 1.5 par rapport à la version 1.0, c’est qu’elle propose une API bien mieux construire et rend beaucoup plus agréable le développement d’applications. Le nouveau framework est basé sur le design-pattern MVC bien que la couche modèle est quelque peu inutile, étant donné que Joomla 1.5 ne fonctionne avec rien d’autre que MySQL, cela dit, on a le choix entre les drivers « mysql » ou « mysqli ».

Nous illustrerons une application simple qui saisie des utilisateurs dans une table et qui les affiche sous la forme d’une liste. Cette application nous permettra de voir d’une façon pragmatique la structure des applications Joomla! et les fonctions de base du framework : création d’une classe modèle (ajout, mise à jour, suppression et requêtes en base de données), création d’un controller avec les actions de base (une action pour création et édition et une autre pour le listing), gestion des templates, redirections et notifications des erreurs et succès.

Télécharger Joomla! 1.5.x : Joomla_1.5.15

Télécharger l’application : Joomla! Crud Tutoriel

Voici ci-dessous la hiérarchie de notre application, il s’agit d’un répertoire à créer dans le dossier « components » de Joomla! :

Voici le script SQL correspondant à la table « jos_crud_users » qui contient les données :

--
-- Structure de la table `jos_crud_users`
--

CREATE TABLE IF NOT EXISTS `jos_crud_users` (
 `user_id` int(11) NOT NULL AUTO_INCREMENT,
 `user_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL,
 `user_lastname` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL,
 `user_email` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL,
 PRIMARY KEY (`user_id`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;

Voici le premier fichier à créer, « crud.php » il s’agit du fichier d’entrée qui est exécuté dès qu’un utilisateur visite l’application :

<?php
/**
 * @package    Joomla.Crud
 * @subpackage Components
 * components/com_crud/crud.php
 * @link http://www.alexandre-julien.com
 * @author Alexandre JULIEN
 */

// Pas d'accès direct à la page
defined( '_JEXEC' ) or die( 'Restricted access' );

// Requiert la classe des contrôleurs

require_once( JPATH_COMPONENT.DS.'controller.php' );

// Requiert un contrôleur spécifique si demander
if($controller = JRequest::getVar('controller')) {
 $path = JPATH_COMPONENT.DS.'controllers'.DS.$controller.'.php';
 if (file_exists($path)) {
 require_once $path;
 } else {
 $controller = '';
 }
}

// Instanciation du contrôleur
$classname    = 'CrudController'.$controller;
$controller   = new $classname( );

// Execute la tâche demandée
$controller->execute( JRequest::getVar( 'task' ) );

// Redirection si elle est sollicitée par le contrôleur
$controller->redirect();
?>

Voici maintenant le contrôleur, chaque méthode correspond à une tâche accessible par l’url : « index.php?option=com_crud&task=lamethode »

<?php
/**
 * @package    Joomla.Crud
 * @subpackage Components
 * @link http://www.alexandre-julien.com
 * @license GNU / GPL
 * @author Alexandre JULIEN
 */

// No direct access

defined( '_JEXEC' ) or die( 'Restricted access' );

jimport('joomla.application.component.controller');

/**
 * Hello World Component Controller
 *
 * @package    Joomla.Tutorials
 * @subpackage Components
 */
class CrudController extends JController
{
 /**
 * Méthode d'affichage
 *
 * @access    public
 */
 function display()
 {
 $model = $this->getModel();
 $view = $this->getView('list', 'html');
 $view->users = $model->getAllUsers();
 $view->display();
 }

 /**
 * Formulaire de création d'un utilisateur
 * @return unknown_type
 */
 function add()
 {
 $view =& $this->getView('edit', 'html');
 $view->display();
 }

 /**
 * Formulaire d'édition d'un utilisateur
 * @return unknown_type
 */
 function edit()
 {
 if (isset($_GET) && isset($_GET['id']))
 {
 $view = $this->getView ('edit', 'html');
 $model =& $this->getModel();
 $view->data = $model->getUser($_GET['id']);
 $view->display();
 }
 else
 {
 $this->setRedirect('index.php?option=com_crud', "L'identifiant est manquant", 'error');
 }
 }

 /**
 * Sauvegarde d'un utilisateur
 * @return unknown_type
 */
 function save()
 {
 if (isset($_POST))
 {
 $model =& $this->getModel();
 if (isset($_POST['id']) && $model->getUser($_POST['id']))
 {
 $model->updateUser($_POST);
 }
 else
 {
 $model->addUser($_POST);
 }
 $this->setRedirect('index.php?option=com_crud', "Les modifications ont bien été enregistrées", 'message');
 }
 else
 {
 $this->setRedirect('index.php?option=com_crud', "Les données sont manquantes", 'error');
 }
 }

 /**
 * Suppression d'un utilisateur
 * @return unknown_type
 */
 function delete()
 {
 if (isset($_GET) && isset($_GET['id']))
 {
 $model =& $this->getModel();
 $model->removeUser($_GET['id']);
 $this->setRedirect('index.php?option=com_crud', "L'utilisateur a bien été supprimé", 'message');
 }
 else
 {
 $this->setRedirect('index.php?option=com_crud', "L'identifiant est manquant", 'error');
 }
 }
}
?>

La couche modèle qui gère les transactions avec la base de données dans le fichiers « models/crud.php » :

<?php
/**
 * Crud modèle pour le composant Crud
 *
 * @package    Joomla.Crud
 * @subpackage Components
 * @link http://www.alexandre-julien.com
 * @license    GNU/GPL
 * @author Alexandre JULIEN
 */

// Pas d'accès direct

defined( '_JEXEC' ) or die( 'Restricted access' );

jimport( 'joomla.application.component.model' );

/**
 * Modèle Crud
 *
 * @package    Joomla.Crud
 * @subpackage Components
 */
class CrudModelCrud extends JModel
{
 /**
 * Retourne tous les enregistrements de la table
 * @return unknown_type
 */
 function getAllUsers()
 {
 $query = 'SELECT * FROM #__crud_users';
 return $this->_getList ($query);
 }

 /**
 * Retourne l'enregistrement en fonction de l'identifiant de l'utilisateur
 * @param $user_id
 * @return unknown_type
 */
 function getUser ($user_id)
 {
 $query = 'SELECT * FROM #__crud_users WHERE user_id = '.(int)$user_id;
 $result = $this->_getList ($query);
 return $result[0];
 }

 /**
 * Ajoute un enregistrement
 * @param $values
 * @return unknown_type
 */
 function addUser ($values)
 {
 $db =& JFactory::getDBO();

 $row = new stdClass();
 $row->user_name = $values['user_name'];
 $row->user_lastname = $values['user_lastname'];
 $row->user_email = $values['user_email'];

 $db->insertObject ('#__crud_users', $row);
 }

 /**
 * Met à jour un enregistrement
 * @param $values
 * @return unknown_type
 */
 function updateUser ($values)
 {
 $db =& JFactory::getDBO();

 $row = new stdClass();
 $row->user_id = $values['user_id'];
 $row->user_name = $values['user_name'];
 $row->user_lastname = $values['user_lastname'];
 $row->user_email = $values['user_email'];

 $db->updateObject ('#__crud_users', $row, 'user_id');
 }

 /**
 * Supprime un enregistrement
 * @param $id
 * @return unknown_type
 */
 function removeUser ($id)
 {
 $db =& JFactory::getDBO();
 $query = 'DELETE FROM #__crud_users WHERE user_id = '.(int)$id;
 $db->setQuery($query);
 return $this->query();
 }
}
?>

Voici un exemple de fichier « View.html.php », il s’agit de celui de l’écran de listing :

<?php
/**
 * @package    Joomla.Crud
 * @subpackage Components
 * @link http://www.alexandre-julien.com
 * @license   GNU/GPL
 * @author Alexandre JULIEN
 */

// Pas d'accès direct

defined( '_JEXEC' ) or die( 'Restricted access' );

jimport( 'joomla.application.component.view');

/**
 * HTML View pour afficher la liste des utilisateurs
 *
 * @package    Crud
 */

class CrudViewList extends JView
{
 function display($tpl = null)
 {
 $this->assignRef('data', $this->users);
 parent::display($tpl);
 }
}
?>

Le template de la vue « edit » :

<?php

// Pas d'accès direct

defined('_JEXEC') or die('Restricted access'); ?>

<h1>Edition d'un utilisateur</h1>
<form name="utilisateur" method="POST"
	action="<?php echo JRoute::_('index.php?option=com_crud&task=save') ?>">
<input type="hidden" name="user_id" value="<?php echo $this->data->user_id ?>" />
<table>
	<tbody>
		<tr>
			<th>Prénom de l'utilisateur</th>
			<td><input type="text" name="user_name"
				value="<?php if (isset($this->data)) { echo $this->data->user_name; } ?>" /></td>
		</tr>
		<tr>
			<th>Nom de l'utilisateur</th>
			<td><input type="text" name="user_lastname"
				value="<?php if(isset($this->data)) { echo $this->data->user_lastname; } ?>" /></td>
		</tr>
		<tr>
			<th>Email de l'utilisateur</th>
			<td><input type="text" name="user_email"
				value="<?php if(isset($this->data)) { echo $this->data->user_email; } ?>"></input></td>
		</tr>
	</tbody>
</table>

<br />
<br />
<input type="submit" value="Enregistrer" /></form>

Le template de la vue « list » :

<?php

// Pas d'accès direct

defined('_JEXEC') or die('Restricted access'); ?>

<h1>Liste des utilisateurs</h1>

<table>
	<tbody>
		<tr>
			<th>Nom</th>
			<th>Prénom</th>
			<th>Adresse e-mail</th>
			<th>Actions</th>
		</tr>
		<?php foreach ($this->data as $key => $value) { ?>
		<tr>
			<td><?php echo $value->user_lastname ?></td>
			<td><?php echo $value->user_name ?></td>
			<td><?php echo $value->user_email ?></td>
			<td><a
				href="<?php echo JRoute::_('index.php?option=com_crud&task=edit&id='.(int)$value->user_id) ?>">
			Editer </a> | <a
				href="<?php echo JRoute::_('index.php?option=com_crud&task=delete&id='.(int)$value->user_id) ?>">Supprimer</a></td>
		</tr>
		<?php } ?>
	</tbody>
</table>
<br />
<a href="<?php echo JRoute::_('index.php?option=com_crud&task=add') ?>">
Créer un utilisateur </a>

On pourra également créer un package Joomla! qui automatisera l’installation des fichiers et des tables SQL grâce à un fichier de configuration d’installation « hello.xml » :

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE install SYSTEM "http://www.joomla.org/xml/dtd/1.5/component-install.dtd">
<install type="component" version="1.5.0">
  <name>crud</name>
  <!-- Les éléments suivants sont optionnels  -->
  <creationDate>2009 09 21</creationDate>
  <author>Alexandre JULIEN</author>
  <authorEmail>mail@alexandre.julien.com</authorEmail>
  <authorUrl>http://www.alexandre-julien.com</authorUrl>
  <copyright>Le blog d'Alex</copyright>
  <license>GNU / GPL</license>
  <!--  Version du composant -->
  <version>stable 1.0</version>
  <!-- Description du Composant -->
  <description>Petit tutoriel CRUD pour illustrer Joomla! MVC Framework</description>

  <!-- Fichiers d'installation -->
  <files folder="site">
    <filename>crud.php</filename>
    <filename>controller.php</filename>
    <filename>models/crud.php</filename>
    <filename>views/edit/view.html.php</filename>
    <filename>views/edit/tmpl/default.php</filename>
    <filename>views/list/view.html.php</filename>
    <filename>views/list/tmpl/default.php</filename>
  </files>
  <install>
    <sql>
      <file charset="uft8" driver="mysql">install.sql</file>
      <file charset="utf8" driver="mysqli">install.sql</file>
    </sql>
  </install>
  <uninstall>
    <sql>
      <file charset="utf8" driver="mysql">uninstall.sql</file>
      <file charset="utf8" driver="mysqli">uninstall.sql</file>
    </sql>
  </uninstall>
  <administration>
    <!-- Administration Menu Section -->
    <menu>Joomla! CRUD</menu>

    <!-- Fichiers de la partie administration -->
    <files folder="admin">
      <filename>index.html</filename>
      <filename>install.sql</filename>
      <filename>uninstall.sql</filename>
    </files>
  </administration>
</install>

Voici des « screenshots » de notre application finale :

L’application est disponible ici dans cette archive : Tutoriel Joomla! CRUD (installation package)

Zend Framework possède son propre outil pour gérer les formulaires correctement : Zend_Form est là pour ça !
Il s’agit d’une librairie qui gère vos composants de formulaires (y compris leur rendu), les validations, le filtrage des données, et la gestion de sous-formulaires.
La librairie Zend_Validate qui gère les validateurs sera aussi utiliser dans ce tutoriel afin d’illustrer les validations de formulaire et ce de façon personnalisé.

Tout d’abord nous allons voir les principes basiques des formulaires avec Zend Framework : il nous faudra ajouter un dossier « forms » dans notre répertoire « application ».

Voici un premier example de la création d’un formulaire dans notre fichier « Author.php ». Il s’agit d’une classe qui correspondra à un formulaire d’inscription d’un auteur :

class Form_Author extends Zend_Form
{
  /**
   * Surcharge du constructeur du formulaire
   */
  public function __construct($options = null)
  {
    parent::__construct($options = null)
    $this->setName('subscription'); // On nomme le formulaire

    $id = new Zend_Form_Element_Hidden('id'); // On rajoute un champs caché

    $email = new Zend_Form_Element_Text('email');
    $email->setRequired(true)
          ->setLabel('Veuillez saisir votre e-mail');

     // Nous avons rajouter un attribut obligatoire à notre email et nous lui avons donné un libellé avant le champs texte

    // Ensuite on peut insérer les composants (elements) dans le formulaire
    $this->addElements($id, $email);

  }
}

Nous avons réaliser une ébauche de formulaire, pour l’utiliser dans notre contrôleur et vue, rien de plus simple

AuthorController.php

function suscribeAction ()

{

$form = new Form_Author(); // On instancie le formulaire

$this->view->form = $form // On le renvoie à la vue

}

// Pour l'éditer il faut renvoyer les informations au formulaire

function editsubscriptionAction()

{

$form = new Form_Author();

$model = new Model_DbTable_Author();

$data = $model->getAuthor('5'); // On récupère toutes les données d'un auteur dans la base de données

$form->populate ($data); // On propulse les données dans le formulaire

$this->view->form = $form;

}

Ensuite dans la vue, on affiche le formulaire et on définit son action :

Author.phtml

echo $this->form;
$this->form>setAction(author/save); // On définit l'action qui récupère le formulaire

Voici un exemple beaucoup plus complet d’un formulaire avec des validateurs, internationalisation et un captcha :

<?php
class Form_Author extends Zend_Form
{
public function __construct($options = null)
{
parent::__construct($options);
$this->setName('Subscription');
$id = new Zend_Form_Element_Hidden('id');

$translate = Zend_Registry::get('translate');

$emptyValidator = new Zend_Validate_NotEmpty();
$emptyValidator->setMessage($translate->_("Ce champs est vide : vous devez le compléter"));

$emailValidator = new Zend_Validate_EmailAddress();
$emailValidator->setMessage($translate->_('L\'adresse email n\'est pas valide'));

$primaryValidator = new Zend_Validate_Db_NoRecordExists('users', 'username');
$primaryValidator->setMessage($translate->_("L'adresse email a déjà été utilisée"), Zend_Validate_Db_Abstract::ERROR_RECORD_FOUND);

$stringLengthValdiator = new Zend_Validate_StringLength(6, 12);
$stringLengthValdiator->setMessage($translate->_('La longueur du mot de pase doit être comprise entre 6 et 12 caractères'));

$email = new Zend_Form_Element_Text('email');
$email->setLabel($translate->_('Email'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emailValidator)
->addValidator($primaryValidator)
->addValidator($emptyValidator);

$password = new Zend_Form_Element_Password('password');
$password->setLabel($translate->_('mot de passe'));
$password->addValidator($stringLengthValdiator);
$password->addValidator($emptyValidator);

$password_verification = new Zend_Form_Element_Password ('password_confirm');
$password_verification->setLabel ($translate->_('retapez le mot de passe pour vérification'));
$password_verification->addValidator($emptyValidator);
if (isset($_POST['password'])) {
$passwordVerificationValidator = new Zend_Validate_Identical($_POST['password']);
$passwordVerificationValidator->setMessage($translate->_('Les mots de passe ne correspondent pas'));
$password_verification->addValidator($passwordVerificationValidator);
}

$sex = new Zend_Form_Element_Radio('sex', array('separator' => ' '));
$sex->setMultiOptions (array('male' => 'Homme', 'female' => 'Femme '))
->setLabel($translate->_('Sexe'))
-> isRequired(true);

$name = new Zend_Form_Element_Text('name');
$name->setLabel($translate->_('Prénom'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$surname = new Zend_Form_Element_Text('surname');
$surname->setLabel($translate->_('Nom'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$address = new Zend_Form_Element_Text('address_author');
$address->setLabel($translate->_('Adresse'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$zip_code = new Zend_Form_Element_Text('zip_code_author');
$zip_code->setLabel($translate->_('Code Postal'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$city = new Zend_Form_Element_Text('city_author');
$city->setLabel($translate->_('Ville'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$phone = new Zend_Form_Element_Text('phone');
$phone->setLabel($translate->_('Téléphone'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

}

$submit = new Zend_Form_Element_Submit('valid');
$submit->setAttrib('id', 'submitbutton')
->setLabel($translate->_('Enregistrer l\'annonce'));

 $this->addElements(array($id, $email,$password, $password_verification, $sex, $name, $surname, $address, $zip_code, $city, $phone, $submit));
}
}
?>

Dans le prochaine tutorial, nous verrons comment mettre en application tout ce que nous avons vu précédemment dans un « CRUD » (Create Read Update Delete) qui illustrera l’utilisateur du design-pattern MVC, Zend_Db, Zend_Form, Zend_Validate et Zend_Layout.