Qu’est-ce que Zend_Tool ?

Zend Tool est un outils qui s’utilise en ligne de commande (depuis une console) et qui permet de mettre en place la structure de son projet, d’ajouter des controllers, actions, vues, modules… D’après la roadmap de Zend, cet outils à pour objectif de devenir très puissant.

Introduction

Alors il va falloir commencer par télécharger le Zend Framework. On l’extrait, chez moi c’est dans le répertoire : « /home/lyrix/prog/php/Lib/Zend_librairie/ZendFramework-1.10.2/ ». On va donc créer un alias pour nous faciliter la vie.  Si vous avez la chance d’être sur un système linux (ou mac) une ligne de commande suffit :

alias zf="/home/lyrix/prog/php/Lib/Zend_librairie/ZendFramework-1.10.2/bin/zf.sh"

Vous pouvez aussi ajouter cette commande a votre fichier de configuration du bash (~/.bashrc), pour que l’alias soit toujours actif.
On va ensuite aller dans le dossier où l’on veut que notre projet soit crée.

cd /home/lyrix/prog/php/2010/

On nommera ce projet « zftuto ».
Création de projet avec Zend_Tool
on commence par créer notre projet :

zf create project ./zftuto/ zftuto

./zftuto/ représente le PATH de la racine de l’application.
zftuto représente le nom de l’application.
Il faut maintenant se déplacer dans le dossier contenant l’application.

cd zftuto/

Base de donnée

Zend_Tool peut se connecter à une base de donnée, pour ensuite nous créer les classes métiers représentant les tables de notre bases de données (ORM). On commence par configurer notre application pour qu’elle se connecte à la BDD. Puis ensuite on génère nos classes :

zf configure db-adapter "adapter=pdo_mysql&username=ecommerce&password=ecommerce&dbname=ecommerce"
zf create db-table.fromdatabase

Le nom des variables est assez explicite pour que je ne les détail pas.

Layout

On peut maintenant activer la gestion d’un layout depuis zend tool.

zf enable layout

Formulaire

On peut créer un formulaire en ligne de commande :

zf create form UserCU

Model

Pour créer un nouveau model (ou classe métier) :

zf create model TestModel

Controller, Action, Vue :

Et bien sur on peut toujours ajouter un controller (avec la vue associé) ;  une action (avec la vue associé) ; ou seulement une vue

zf create controller Users
zf create action read Users
zf create view read2 Users

Module :

On peut aussi créer des modules :

zf create module Moduletest

Aide :

Pour de l’aide, vous pouvez directement depuis votre console exécuter la commande suivante :

zf ?

Conclusion

Si on fait attention, le nommage des classes a changé. Il y a maintenant un namespace « application ». Ce qui a mon goût est plus propre, et anticipe peut être les changements qu’il va y avoir avec php 5.3 puis php 6

Articles en rapport : :

• Initialisation d’un projet Zend Framework Avec Zend_Tool
• Comment développer et tester son site en local
• Zend Framework
• Comment gérer la navigation de son site avec le Zend Framework
• Zend : Comment faire une vue

Auteur : © Greg pour LyRiX Blog.
Article publié le : 18-03-2010, dans : Zend Framework. Liens direct vers l'article (permalink)
Mot Clé : Architecture, Zend Framework, Zend_Tool

Dans ce dossier nous avons :

• application : c’est le dossier où tous notre code va se situer, il ne doit pas être accessible depuis l’extérieur.
  • configs : c’est le dossier qui va contenir tous nos fichiers de configuration
    • application.ini : C’est le fichier qui permet de définir les réglage de l’application comme les paramètre de base de données, les chemins par défaut …
  • controllers : c’est le dossier qui va contenir tous les controllers
  • forms : c’est un nouveau dossier qui contient maintenant tous les formulaires
  • layouts/scripts/ : c’est le dossier qui contient les fichiers de layout
    • layout.phtml : layout (ou template) de base de notre application
  • models : c’est le dossier qui contient tous les modèles, ou plus exactement tous notre code métier
    • DbTable : c’est le dossier qui contient toutes les représentation de nos tables (ORM).
  • Views : c’est le dossier qui contient tous ce qui touchent a l’affichage
    • helpers : c’est le dossier qui contient les aides de vues
    • scripts : c’est le dossier qui contient les dossiers contenant les vues
• docs : c’est le dossier qui contient la documentation (oui il en faut)
• library : c’est le dossier qui contient les librairies
• zend : c’est dans ce dossier qu’il faut mettre la librairie du Zend Framework
• public : c’est le seul dossier qui doit être accessible depuis l’extérieur.
  • index.php : c’est le fichier qui va démarrer notre application
• tests : c’est le dossier qui contient tous les fichiers pour faire des tests unitaires.

Articles en rapport : :

• Architecture de Zend Framework 1.8 en MVC
• Architecture de Zend Framework en MCV
• Comment mettre en place un Layout avec le Zend-Framework 1.8
• Css, JavaScript et Zend Framework
• Zend : Comment faire une vue

Auteur : © Greg pour LyRiX Blog.
Article publié le : 18-03-2010, dans : Zend Framework. Liens direct vers l'article (permalink)
Mot Clé : Architecture, Zend Framework

Quelques points techniques abordés dans cette application :

• Bootstrap (Zend_Application)
• Controller, View, Model (MVC)
• Mapping de base de données (ORM) (Zend_Db_Table)
• Formulaires, Validations, Décorateurs (Zend_Form, Zend_Validate)
• Layout et Aides de vue (Zend_View_Helper)
• Authentification (Zend_Auth)
• Session (Zend_Session)
• Cookie
• Zend_Text_Figlet (Bonus ca )

voila quelques screenshots :

Et enfin les sources à télécharger

Articles en rapport : :

• Gerer l’authentification avec Zend_Auth du Zend Framework
• Zend Framework
• Css, JavaScript et Zend Framework
• Zend Framework, Formulaire et Base de donnée, partie 2
• Zend Framework, Formulaire et Base de donnée, partie 1

Auteur : © Greg pour LyRiX Blog.
Article publié le : 18-03-2010, dans : Zend Framework. Liens direct vers l'article (permalink)
Mot Clé : Application, Code Source, Mysql, Php, Zend Framework

Sommaire :

• Sommaire
• Mise en place du formulaire
• Le controller
• Déconnexion
• Vérification
• Le controller de vue

Création du formulaire de login :

On va allé assez vite sur la création du formulaire dans la mesure ou j’explique dans un autre tutoriel comment faire un formulaire.

class Model_Form_User_Login extends Zend_Form  {

	public function init(){
		$this->setName('add_user');

		$email = new Model_Form_EText('email','Adresse Email : ');

		$password = new Zend_Form_Element_Password('password');
		$password->setLabel('Mot de pase : ')
			->setRequired(true)
			->addFilter('StripTags')
			->addFilter('StringTrim');

		$submit = new Zend_Form_Element_Submit('submit');
		$submit->setAttrib('id', 'submitbutton')
			->setLabel('Se connecter');

		$elements = array($email,$password, $submit);
		$this->addElements($elements);

		$this->setDecorators(array(
			'FormElements',
			array('HtmlTag', array('tag' => 'dl', 'class' => 'zend_form')),
			array('Errors', array('placement' => 'apend')),
			'Form'
		));
	}

}

On voit qu’on utilise un champ email et un champ password et bien sur un bouton valider. Si la classe de l’email vous parait bizarre je vous conseil de lire le tutoriel sur les formulaires. Enfin les dernières lignes concernent la mise en forme du formulaire ainsi que la position des messages d’erreurs qui seront envoyés (ajoutés) par le modèle pour la vérification du couple Email / Password.

Le controller

Le controller est dans la classe LoginController et l’action que nous allons utiliser est loginAction. On commence par donner une instance de notre formulaire à la vue pour qu’elle puisse l’afficher.

$form = new Model_Form_User_Login();
$this->view->formLogin = $form;

Ensuite on vérifie qu’il y ai des données postées, on les récupère et on les valide.

if ($this->_request->isPost ()) {
	$formData = $this->_request->getPost ();
	if ($form->isValid ( $formData )) {

Si elles sont valides, on récupère les données :

$email = $form->getValue ( 'email' );
$password = $form->getValue ( 'password' );

Enfin on arrive à la partie qui concerne Zend_Auth. Il faut commencer par créer ce qu’on appel un Zend_Auth_Adapter_DbTable, c’est un composant de Zend_Auth qui va pouvoir se connecter à la BDD. Cet nouvel objet va prendre en paramètre un Zend_Db_Adapter_Abstract, c’est à dire un connecteur à la base de donnée. Dans notre cas nous allons prendre le connecteur principal, celui qui est définit dans les paramètres globaux de Zend (application.ini)

$authAdapter = new Zend_Auth_Adapter_DbTable ( Zend_Db_Table::getDefaultAdapter () );

Enfin il faut donner quelques informations à cet adaptateur :

• Le nom de la table qui contient les utilisateurs (ici users)
• Le nom de la colonne qui contient les identifiants (ici email)
• Le nom de la colonne qui contient les mots de passe (ici password)
• Le type de hashage dans la base (ici MD5)
• La valeur de l’email
• La valeur du mot de passe

$authAdapter->setTableName ( 'users' )
	->setIdentityColumn ( 'email' )
	->setCredentialColumn ( 'password' )
	->setCredentialTreatment ( 'MD5(?)' )
	->setIdentity ( $email )
	->setCredential ( $password );

Enfin on essaye d’identifier l’utilisateur :

$authAuthenticate = $authAdapter->authenticate ();

Maintenant il faut regarder si cette authentification à réussi ou échoué.

if ($authAuthenticate->isValid ()) {

Si elle est valide, on va mettre en variable de session les informations de l’utilisateur. À ce moment vous pouvez mettre toutes les informations relatives à l’utilisateur. On peu même envisager de créer une classe pour stocker toutes ces informations. Dans le cas présent, seule les informations issu de la table users sont utiles. On commence donc par récupérer l’espace de stockage (storage) par défaut de l’application

$storage = Zend_Auth::getInstance ()->getStorage ();

Puis on y ajoute les informations de l’utilisateur, on y enlève bien sur le mot de passe :

$storage->write ( $authAdapter->getResultRowObject ( null, 'password' ) );

Et enfin on redirige l’utilisateur sur la page principale de l’application

$this->_helper->redirector ( 'index', 'index' );

Et pour finir si le couple login / password n’était pas bon, on ajoute une description au formulaire :

} else {
$form->addError ( 'Il n\'existe pas d\'utilisateur avec ce mot de passe' );
}

Voilà l’action du controller est faite on peu passer à la suite.

Déconnexion

Si l’utilisateur veut se déconnecter, il doit cliquer sur un lien qui map l’action suivante :
public function logoutAction() {

Zend_Auth::getInstance ()->clearIdentity ();
$this->helper->redirector ( 'index', 'index' );
}

Grâce à la ligne Zend_Auth::getInstance ()->clearIdentity (); on supprime l’identification de l’utilisateur.

Vérification de connexion

Il faut bien entendu vérifier (si l’on code proprement) si l’utilisateur est déjà connecté si il veut se déconnecter, et il faut aussi vérifier que l’utilisateur connecté puisse seulement se déconnecter dans ce controller. On va utiliser la méthode preDispatch du controller, cette méthode est systématiquement appelé à l’exécution d’une action du controller. Je vous donne le code et je l’explique après :

public function preDispatch() {
	if (Zend_Auth::getInstance ()->hasIdentity ()) {
		if ('logout' != $this->getRequest ()->getActionName ()) {
			$this->_helper->redirector ( 'index', 'index' );
		}
	} else {
		if ('logout' == $this->getRequest ()->getActionName ()) {
			$this->_helper->redirector ( 'index' );
		}
	}
}

On commence par vérifier si l’utilisateur est connecté, si il l’est et que l’action sur laquelle il veut aller est différente de ‘logout’ on le renvoi sur la page d’accueil du site. Sinon, si il n’est pas connecté et qu’il veut se déconnecter, on l’envoi sur l’action qui permet de se connecter.

Zend_View_Helper

Comment faire automatiquement un lien qui permet de se connecter si on ne l’est pas, ou alors de se deconnecter si on l’est ? Et bien on utilise ce qu’on appel un Zend_View_Helper, c’est un bout de code qui va être utilisable dans le layout.

class Zend_View_Helper_ProfileLink extends Zend_View_Helper_Abstract {
	public function profileLink() {
		$helperUrl = new Zend_View_Helper_Url ( );
		$auth = Zend_Auth::getInstance ();
		if ($auth->hasIdentity ()) {
			$username = $auth->getIdentity ()->prenom . ' ' . strtoupper ( substr ( $auth->getIdentity ()->nom, 0, 1 ) ) . '.';
			$logoutLink = $helperUrl->url ( array ('action' => 'logout', 'controller' => 'login' ) );
			return 'Salut ' . $username . ' (<a href="' . $logoutLink . '">Logout</a>)';
		}
		$loginLink = $helperUrl->url ( array ('action' => 'login', 'controller' => 'login' ) );
		return '<a href="' . $loginLink . '">Login</a>';
	}
}

On commence par créer un nouveau Zend_View_Helper_Url pour nous aider à construire les URL, puis on récupère une instance de Zend_Auth. Donc si il y a un utilisateur de connecté, on récupère son identité. Puis on construit l’URL de déconnexion, et enfin on retourne la chaine de caractère (message + lien). Si l’utilisateur n’est pas connecté, on construit le lien de connexion, et on retourne la chaine de caractère.
Si on veut utiliser ce script dans la vue, il va falloir faire :

echo $this->profileLink();

Et voila le code du controller en entier :

< ?php

class LoginController extends Zend_Controller_Action {

	public function init() {
		/* Initialize action controller here */
		Zend_Auth::getInstance ()->clearIdentity ();

	}

	public function preDispatch() {
		if (Zend_Auth::getInstance ()->hasIdentity ()) {
			if ('logout' != $this->getRequest ()->getActionName ()) {
				$this->_helper->redirector ( 'index', 'index' );
			}
		} else {
			if ('logout' == $this->getRequest ()->getActionName ()) {
				$this->_helper->redirector ( 'index' );
			}
		}
	}

	public function indexAction() {
		$this->_forward ( 'login' );
	}

	public function loginAction() {

		$form = new Model_Form_User_Login ( );
		$this->view->formLogin = $form;

		if ($this->_request->isPost ()) {
			$formData = $this->_request->getPost ();
			if ($form->isValid ( $formData )) {
				$email = $form->getValue ( 'email' );
				$password = $form->getValue ( 'password' );
				$authAdapter = new Zend_Auth_Adapter_DbTable ( Zend_Db_Table::getDefaultAdapter () );
				$authAdapter->setTableName ( 'users' )
					->setIdentityColumn ( 'email' )
					->setCredentialColumn ( 'password' )
					->setCredentialTreatment ( 'MD5(?)' )
					->setIdentity ( $email )
					->setCredential ( $password );
				$authAuthenticate = $authAdapter->authenticate ();
				if ($authAuthenticate->isValid ()) {
					$storage = Zend_Auth::getInstance ()->getStorage ();
					$storage->write ( $authAdapter->getResultRowObject ( null, 'password' ) );
					$this->_helper->redirector ( 'index', 'index' );
				} else {
					$form->addError ( 'Il n\'existe pas d\'utilisateur avec ce mot de passe' );
				}
			}
		}
		$this->render ( 'index' );
	}

	public function logoutAction() {
		Zend_Auth::getInstance ()->clearIdentity ();
		$this->_helper->redirector ( 'index', 'index' );
	}

}

Articles en rapport : :

• Zend Framework, Formulaire et Base de donnée, partie 2
• Zend Framework, Formulaire et Base de donnée, partie 1
• Application de site E-Commerce [Code-Source]
• Css, JavaScript et Zend Framework
• Comment gérer une base de donnée avec le Zend Frameworkls

Auteur : © Greg pour LyRiX Blog.
Article publié le : 23-12-2009, dans : Zend Framework. Liens direct vers l'article (permalink)
Mot Clé : Layout, View, Zend Framework, Zend_Auth, Zend_Db, Zend_View_Helper

On continue avec la deuxième partie de la gestion d’un formulaire, de la création de formulaire, et d’ajout de donnée en BDD dans le Zend Framework. Dans cette partie nous verrons comment afficher les données, les modifier à l’aide du même formulaire que pour l’ajout, et la suppression des données.

Sommaire

• Partie 1
  • Sommaire
  • Préparation de la BDD
  • Préparation du formulaire
  • Affichage du formulaire
  • Le Controller du formulaire
  • Gérer d’autres validateurs
  • Conclusion
• Partie 2
  • Sommaire
  • Afficher des enregistrement
  • Mettre a jour des enregistrement
  • Supprimer des enregistrement
  • Conclusion

Afficher les données de la base de données.

Il faut tout d’abord toucher a notre controller qui gère la page user pour donner à la vue une instance de la classe >Model_DbTable_Users(). Vu que j’utilise souvent cette classe, j’ai fait une méthode dans la classe controller : (application/modules/Frontend/controllers/UserController.php)

private function getUsersAll() {
	$dbUser = new Model_DbTable_Users();
	return $dbUser->fetchAll()->toArray();
}

Et maintenant on a juste a passer cette classe à la vue :

public function indexAction(){
	$this->view->usersAll = $this->getUsersAll();
}

On passe maintenant à la vue (application/modules/Frontend/views/scripts/user/index.phtml).

if (isset($this->usersAll)){ ?>
	<h2><?php echo $this->translate('view_user_modify')?> : </h2>
	<table>
		<tr>
	    	<th><?php echo $this->translate('view_user_firstname')?></th>
	    	<th><?php echo $this->translate('view_user_name')?></th>
	    	<th><?php echo $this->translate('view_user_email')?></th>
	    	<th><?php echo $this->translate('view_user_modify')?></th>

		</tr>
		<?php
		$users = $this->usersAll;
		foreach ($users as $user){
			if ($user['active'] == 1){
				echo '<tr>';
			}else{
				echo '<tr style="text-decoration:line-through">';
			}
			echo '<td>'.$user['nom'].'</td>';
			echo '<td>'.$user['prenom'].'</td>';
			echo '<td>'.$user['email'].'</td>';

			echo '<td><a href="'.$this->url(array('action'=>'edit','id'=>$user['idUser'])).'">Modifier</a> | <a href="'.$this->url(array('action'=>'del','id'=>$user['idUser'])).'" >Supprimer</a></td>';
			echo '</tr>';
		}
		?>
	</table>
<?php
}
?>

On commence par vérifier que la variable usersAll est bien définit. Dans ce cas la on construit notre tableau assez naturellement. Encore une fois j’utilise ici la traduction du framework (mais on n’est pas forcé de le faire).

			if ($user['active'] == 1){
				echo '<tr>';
			}else{
				echo '<tr style="text-decoration:line-through">';
			}

Ce code sert juste a vérifié que l’utilisateur est actif. Si il ne l’est pas on barre la ligne :

echo '<td><a href="'.$this->url(array('action'=>'edit','id'=>$user['idUser'])).'">Modifier</a> | <a href="'.$this->url(array('action'=>'del','id'=>$user['idUser'])).'" >Supprimer</a></td>';

Enfin cette ligne est assez sympa : en effet on veut pouvoir éditer et supprimer des utilisateurs. Il nous faut donc des liens pour le faire. Et bien pour fabriquer ces liens on va utiliser une aide de vues (View Helper : Zend_View_Helper_Url) qui va nous construire notre lien directement. On lui passe comme argument un tableau, avec comme clés l’action, le controller, le module et des paramètres. Tout ces champs ne sont pas obligatoires. Dans mon cas, je reste sur le même controller, et donc le même module. Donc je n’utilise que l’action et un paramètre id. Ce paramètre est passé en GET donc directement dans l’url. De plus zend> va gérer automatiquement l’url rewriting, qui est beaucoup plus user-friendly et seo-friendly. Voyons ce que donne le résultat : (il y a un peu de css)

Modification d’un enregistrement

Donc notre lien pour modifier un utilisateur est déjà fait, et comme on a pu le voir, il pointe sur l’action edit du controller UserController.php. Il va donc falloir modifier celui-ci, ainsi que la classe qui gère le formulaire et la vue. On commence avec le formulaire. En fait on va utiliser la même classe que pour l’ajout, mais on va y rajouter un peu de code (à la fin de la méthode).

Model

		$idUser = $this->getIdUser();
		if (isset ( $idUser ) && $idUser != "") {
			$user = new Model_DbTable_Users ( );
			$user = $user->fetchRow ( array ("idUser = ?" => $idUser ) );
			if ($user != null) {
				$user = $user->toArray ();
				$this->populate ( $user );
			} else {
				throw new Zend_Exception ( "Il n'y a pas de d'utilisateur avec l'id : " . $idUser );
			}
			$password->setDescription ( "form_user_update_password_change" );
			$password->setRequired ( false );
			$submit->setLabel ( 'form_user_update_submit' );
		}

On commence par récupérer la valeur de l’id de l’utilisateur. Bien entendu, il faut déclarer une variable (private) et faire le getter et le setter qui va bien. Si il y a bien une valeur et qu’elle est différente de null on récupère une instance de la classe Model_DbTable_Users. On sélectionne la ligne qui va bien en fonction de l’id. Si on a bien récupérer un utilisateur (c’est a dire qu’il y a bien un enregistrement avec cet id)> on peuple le formulaire, c’est a dire qu’on le rempli des données récupérer. Sinon on renvoi une erreur. Ensuite, ce n’est pas obligatoire, mais je laisse le choix a l’utilisateur : si il ne veut pas changer de mot de passe, il ne fait rien, sinon il en rentre un nouveau. Enfin on change le label du bouton envoyer>. Mais ce n’est pas finit. En effet il reste un problème de validateur> sur le champs email. Il vaut donc le supprimer, mais que si c’est le même email (saisi) que l’email qui est déjà dans la BDD. De la même marnière que dans la partie 1, on va devoir redéfinir la méthode isValid :

	public function isValid($data)
	{
	    $this->getElement('password')->addValidator(new App_Validate_PasswordMatch($data['password2']));
		if ($this->getElement('email')->getValue() == $data['email']){
				$this->getElement('email')->removeValidator ( "Zend_Validate_Db_NoRecordExists" );
		}
	    return parent::isValid($data);
	}

Par rapport au code de la partie 1, on a rajouté le bloc IF : Si la valeur en base est la même que la valeur saisi, on supprime le validateur>, sinon on ne fait rien (et donc on le laisse).
Voilà notre formulaire est enfin prêt. On passe maintenant au controller.

Controller

	public function editAction() {
		try {
			$form = new Model_Form_User_User ( );
			$form->setIdUser($this->getRequest ()->getParam ( 'id' ));
			$form->init();
			$this->view->formUserEdit = $form;
		} catch (Zend_Exception $e) {
			$this->view->formUserEdit = $e->getMessage();
		}
	}

On essaye d’instancier la classe Model_Form_User_User ( ). Ensuite on récupère la valeur du paramètre id (passer en GET) et on la passe a notre classe forme. On est obligé de refaire le formulaire puis on la passe a la vue. Si il y a un problème (pas d’utilisateur avec id X) on passe les erreurs a la vue.

		if ($this->_request->isPost ()) {
			$formData = $this->_request->getPost ();
			if ($form->isValid ( $formData )) {

Ensuite, comme dans la première partie, on vérifie qu’il y ai des données de poster, et les recupère puis on les passes au validateur.

				$user = new Model_DbTable_Users ( );
				if ($formData ['password'] == "") {
					unset ( $formData ['password'] );
					unset ( $formData ['password2'] );
				} else {
					$formData ['password'] = md5 ( $formData ['password'] );
					unset ( $formData ['password2'] );
				}
				unset ( $formData ['submit'] );
				$result = $user->update ( $formData, array ("idUser = ?" => $formData ['idUser'] ) );

Si elle sont valide, on instancie la classe Model_DbTable_Users. On vérifie la valeur du champs password : Si elle est nul, on enlève du tableau de donnée formData les champs password et password2, sinon on chiffre en md5 le champ password et en enlève password2. Enfin on enlève le champ submit. Et pour finir on met a jour la base de donnée.

$this->_helper->redirector ( 'index', 'user' );

Enfin on redirige vers l’action index du controller user.

Vue

Ici c’est le même principe que pour le formulaire d’ajout

if (isset($this->formUserEdit)){ ?>
	<h2><?php echo $this->translate('view_user_edit')?> : </h2>
	<?php echo $this->formUserEdit;
}

Supprimer un Enregistrement

La suppression d’un utilisateur va se faire en deux étape, la première servant à confirmer la demande de suppression. Donc on crée une action intermédiaire qui passe à la vue la valeur de l’id de l’utilisateur.
public function delAction() {

	public function delAction() {
		$id = $this->getRequest ()->getParam ( 'id' );
		$this->view->delUserId = $id;
		$this->render('index');
	}

Et on ajoute à la vue le code qui va générer notre demande de suppression. Encore ici on réutilise l’aide de vue url.

if (isset($this->delUserId)){ ?>
	<h2><?php echo $this->translate('are_you_sure')?> : </h2>
	<a href="<?php echo $this->url(array('action'=>'delete','id'=>$this->delUserId));?>"><?php echo $this->translate('yes')?></a>
	<a href="<?php echo $this->url(array('action'=>'index','controller'=>'user'),null,true)?>"><?php echo $this->translate('no')?></a>
	<?php
}

Enfin si l’utilisateur clique sur oui, on exécute l’action suivante :

	public function deleteAction() {
		public function deleteAction() {
		$id = $this->getRequest ()->getParam ( 'id' );
		$user = new Model_DbTable_Users ( );
		$result = $user->delete ( array ("idUser = ?" => $id ) );
		$this->_helper->redirector ( 'index', 'user' );
	}

Et voilà le tour est joué. On a bien supprimer notre utilisateur.

Conclusion

On à enfin finit la gestion d’une table de la base de donnée grâce a un seul formulaire. Je vous donne donc maintenant le code de tous les fichiers dont j’ai eu besoin. Il y a des petites différence dans la mesure ou j’ai ajouté des messages de confirmation ou d’échec. De plus la structure de l’archive n’est pas bonne du tout… Il y a bien tous les fichiers (enfin je pense, mais c’est plus a titre indicatif). Il ne fonctionneront pas sans le bootstrap, le fichier de config, le fichier de traduction et enfin la bdd. Je referais un gros package plus tard.
Fichiers

Articles en rapport : :

• Zend Framework, Formulaire et Base de donnée, partie 1
• Gerer l’authentification avec Zend_Auth du Zend Framework
• Comment gérer une base de donnée avec le Zend Frameworkls
• Comment bien démarrer un projet Zend Framework grâce aux Zend_Tool
• Zend Framework

Auteur : © Greg pour LyRiX Blog.
Article publié le : 20-11-2009, dans : Zend Framework. Liens direct vers l'article (permalink)
Mot Clé : Bootstrap, Controller, Model, Mysql, View, Zend Framework, Zend_Db, Zend_Form, Zend_Translate

Hello,
On va voir aujourd’hui comment construire et gérer un formulaire, ajouter les données récupéré dans une base de données, afficher ces données, et enfin modifier et supprimer celles-ci. En gros, on va utiliser les propriétés CRUD de Zend Framework en y associant une base de donnée et un formulaire.
P.S. : Pendant la rédaction de ce tuto, je me suis rendu compte qu’il allait être beaucoup trop gros, du coup j’ai décidé de le couper en deux parties, une première sur la création du formulaire et l’ajout en base, une deuxième sur la l’affichage, la modification et la suppression.

Sommaire

• Partie 1
  • Sommaire
  • Préparation de la BDD
  • Préparation du formulaire
  • Affichage du formulaire
  • Le Controller du formulaire
  • Gérer d’autres validateurs
  • Conclusion
• Partie 2
  • Sommaire
  • Afficher des enregistrement
  • Mettre a jour des enregistrement
  • Supprimer des enregistrement
  • Conclusion

Préparation de la base de donnée :

CREATE  TABLE IF NOT EXISTS `Budget`.`users` (
`idUser` INT NOT NULL AUTO_INCREMENT ,
`nom` VARCHAR(20) NULL ,
`prenom` VARCHAR(20) NULL ,
`email` VARCHAR(30) NULL ,
`active` INT NULL ,
`level` INT NULL ,
`password` BIGINT NOT NULL ,
PRIMARY KEY (`idUser`) )
ENGINE = InnoDB
DEFAULT CHARACTER SET = utf8
PACK_KEYS = DEFAULT

Comme on a vu dans un précédant tutoriel, il faut créer une classe qui va nous mapper les informations de la table (ORM du Zend Framework).

<?php
class Model_DbTable_Users extends Zend_Db_Table_Abstract {
	protected $_name = 'users';
	protected $_primary = array('idUser');
}

Préparation du formulaire

Il existe plusieurs façons de faire un formulaire : soit en utilisant des tableaux php, des objets php, un fichier xml etc… Pour ma part j’utilise des objets php et j’implémente pour chaque formulaire la classe Zend_Form (je vais y revenir). Pour plus de clarté dans mon arborescence de fichiers, je place tous mes formulaires, dans le dossier : application/models/Form/ et comme ce formulaire ci concerne l’ajout et/ou la modification d’un utilisateur, mon fichier User.php est dans le dossier : application/models/Form/User. Donc le fichier de base doit ressembler à ça :

<?php
class Model_Form_User_User extends Zend_Form {
	public function init() {
	}
}

Comme on peut le voir, il faut étendre la classe Zend_Form, et mettre tout notre code qui ajoute des éléments dans la méthode init(). Ce code sera directement exécuter lors de la création d’un nouveau formulaire. Mais on va très vite ajouter des éléments à notre formulaire, sinon il ne va pas servir à grand chose. On peut, par exemple, ajouter un champ input texte grâce a ce code (le principe reste le même pour tous les types d’éléments) :

$champText = new Zend_Form_Element_Text('champText');
$champText->setLabel('un champ texte')
	->setRequired(true)
	->addValidator('notEmpty')
	->addFilter('StripTags')
        ->addFilter('StringTrim');

On commence par créer un nouvel élément de type input texte, puis on ajoute un label, on ajoute ensuite un validateur qui (dans ce cas) oblige la valeur à être rempli, puis on ajoute deux filtres. Il existe un grand nombre de validateurs et de filtres. On en verra quelques un ici. Mais comme on peut se douter, on va très souvent répéter le même code. Donc on peut se créer une petite classe qui ne va servir qu’a ajouter un champ de type input texte : (application/models/Form/EText.php)

<?php
/**
 * @author lyrix
 *
 */
class Model_Form_EText extends Zend_Form_Element_Text {

	public function __construct($options = null,$label){
        	parent::__construct($options);
        	$this->setLabel($label)
			->setRequired(true)
			->addFilter('StripTags')
			->addFilter('StringTrim');
	}
}

Voilà, je vous donne maintenant une partie du code du formulaire et j’explique les points nouveaux.

<?php
class Model_Form_User_User extends Zend_Form {

	public function init() {
		$this->setName ( 'add_user' );

		$id = new Zend_Form_Element_Hidden ( 'idUser' );

		$nom = new Model_Form_EText ( 'nom', 'form_user_add_name' );

		$prenom = new Model_Form_EText ( 'prenom', 'form_user_add_firstname' );

		$email = new Model_Form_EText ( 'email', 'form_user_add_mail' );
		$email->addValidator ( 'EmailAddress' )->addValidator ( new Zend_Validate_Db_NoRecordExists ( 'users', 'email' ) );

		$password = new Zend_Form_Element_Password ( 'password' );
		$password->setLabel ( 'form_user_add_password' )->addFilter ( 'StripTags' )->addFilter ( 'StringTrim' )->setRequired ( true );

		$password2 = new Zend_Form_Element_Password ( 'password2' );
		$password2->setLabel ( 'form_user_add_password2' )->addFilter ( 'StripTags' )->addFilter ( 'StringTrim' );

		$active = new Zend_Form_Element_Checkbox ( 'active' );
		$active->setLabel ( 'form_user_add_enable' )->addFilter ( 'StripTags' )->addFilter ( 'StringTrim' )->setValue ( 1 );

		$level = new Zend_Form_Element_Select ( 'level' );
		$level->setLabel ( 'form_user_add_level' )->addFilter ( 'StripTags' )->addFilter ( 'StringTrim' );
		$levelOptions = array ();
		for($i = 0; $i <= 9; $i ++) {
			$levelOptions [$i] = array ('key' => $i, 'value' => $i );
		}
		$level->addMultiOptions ( $levelOptions );

		$submit = new Zend_Form_Element_Submit ( 'submit' );
		$submit->setAttrib ( 'id', 'submitbutton' )->setLabel ( 'form_user_add_submit' );

		$elements = array ($id, $nom, $prenom, $email, $password, $password2, $active, $level, $submit );
		$this->addElements ( $elements );
	}
}
?>

Pour commencer je donne un nom a mon formulaire, ce qui peut être pratique pour le retrouver, en effet le nom du formulaire correspond a son id dans le code html et css. On peut aussi ajouter d’autre options, comme l’action du controller, mais dans notre cas, le formulaire et sa page de destination (l’action) sont les mêmes, donc on pas besoin de le définir.
Ensuite, comme on peut le voir, on crée plusieurs éléments :

• l’id qui est un élément de type hidden, qui nous servira lors des mises à jour d’un utilisateur.
• nom, prenom qui sont des éléments de type Etext, les éléments qu’on a crée un peu plus haut.
• email

• Le champ email est aussi un champs de type Etext,
• On a ajouter un validateur d’adresse mail, pratique, le boulot est déjà fait ! ( ->addValidator (‘EmailAddress’) )
• On ajoute un second validateur qui vérifie que l’adresse mail n’est pas déjà dans la base de donnée ( addValidator (new Zend_Validate_Db_NoRecordExists (‘users’,'email’)) ). Le premier paramètre est le nom de la table, le second l’attribut qui doit être unique.

• De type Select
• On ajoute dans un tableau des correspondances key = > value qui représentent les options du select
• On ajoute le tableau au select

Les labels ne sont pas très significatifs ou user-friendly, c’est normale, j’utilise la traduction du zend framework. Enfin il ne reste plus qu’a ajouter tous ces éléments dans le formulaire lui même et le tours est joué, on a notre formulaire. Je tiens a rappelé qu’il existe vraiment un grand nombre de façon de fabriquer un formulaire, d’ajouter des filtres, des validateurs. Il y a quelques exemples ici, mais je ne peux pas faire un exemple pour chaque cas. Je vous recommande donc d’aller faire un tour sur sur le doc du zf.

Affichage du formulaire

Je ne vais pas m’occuper ici de styler le formulaire. Juste de l’afficher comme il vient. Par défaut zf utilise ce qu’on appel des décorateurs, il est possible de les personnaliser, mais ce n’est pas le but ici. Vous pouvez aller faire un tours sur le site de dator pour avoir un exemple de ce qu’on peut faire (même si je ne suis pas fan de sa technique, mais elle reste valide à 100% … huhu). Pour les décorateurs, le code a ajouter / modifier doit se trouver dans la classe qui fabrique notre formulaire.
Donc il va falloir éditer la vu qui affichera le formulaire. Chez moi c’est application/modules/Frontend/views/scripts/user/index.phtml car c’est le controller userController.php qui va être appelé ici. Voilà a quoi doit ressembler la vues au minimum :

if (isset($this->formUser)){ ?>
	<h2><?php echo $this->translate('view_user_add')?> : </h2>
	<?php echo $this->formUser;
}

On fait une simple vérification pour voir sur le formulaire a bien était envoyé par le controller à la vue et on l’affiche.

Le controller du formulaire

Bon on arrive la gestion du controller de notre formulaire. Je vous livre le code et je l’explique ensuite : (application/modules/Frontend/controllers/UserController.php)

<?php
class UserController extends Zend_Controller_Action
{
    public function indexAction(){
        $form = new Model_Form_User_User();
        $this->view->formUser = $form;
        if ($this->_request->isPost()) {
            $formData = $this->_request->getPost();
            if ($form->isValid($formData)) {
                $users = new Model_DbTable_Users();
                $row = $users->createRow();
                $row->nom = $form->getValue('nom');
                $row->prenom = $form->getValue('prenom');
                $row->email = $form->getValue('email');
                $row->password = md5($form->getValue('password'));
                $row->active = $form->getValue('active');
                $row->level = $form->getValue('level');
                $result = $row->save();
//On gere le resultat et l'action qui s'en suit.
                $form->reset();
            }
        }
    }
}

Petit apercu avant de continuer

$form = new Model_Form_User_User();
$this>view->formUser = $form;

On commence par instancier la classe du formulaire et on le donne à la vue. A partir de ce moment on peut déjà tester si notre formulaire s’affiche bien. Bien entendu ça ne sert a rien de cliquer sur envoyer, ça ne fonctionnera pas ! Comme on a pu le voir plus haut, la page de destination du formulaire est elle même. Donc le controller est le même. C’est donc dans la même méthode du même controller qu’on teste en premier si notre formulaire est valide et qu’ensuite on traite le résultat.

if ($this->_request->isPost()) {
     $formData = $this->_request->getPost();
}

On commence avec le IF pour voir si il y a eu des données de type POST, POST étant le type d’envoi par défaut pour les formulaires. On peut bien entendu envoyer notre formulaire en GET en modifiant la classe user.php. Ensuite on récupère nos données.

if ($form->isValid($formData)) {
}

Ce point est très intéressant, car il va automatiquement voir si notre formulaire est valide. C’est a dire qu’il va exécuter chaque validateurs de nos élement composant le formulaire. Si il y a au moins une erreur la validation ne passera pas, mais zf va automatiquement refaire notre formulaire en reprenant les valeurs insérer, et en ajouter un message ou il y a eu des erreurs (par exemple « la valeur est requise »). Ici encore on peut personnaliser le message. Dans mon cas j’utilise encore une fois la traduction. Bon et si le formulaire est valide ?

 $users = new Model_DbTable_Users();
$row = $users->createRow();
$row->nom = $form->getValue('nom');
$row->prenom = $form->getValue('prenom');
$row->email = $form->getValue('email');
$row->password = md5($form->getValue('password'));
$row->active = $form->getValue('active');
$row->level = $form->getValue('level');
$result = $row->save();

Comme on veut (à la base) que notre formulaire nous serve à ajouter des utilisateurs en base, et bien on reprend le même code que dans le tutoriel sur la gestion des BDD ; On instancie la classe Model_DbTable_Users, on crée un nouvelle ligne, on ajoute tous nos champs, et enfin on sauvegarde. Bien entendu, on peut mettre la ligne $row->save() dans un bloque try-catch, mais si on a bien fait notre boulot sur les validateurs, normalement, il n’y a pas besoin.

$form->reset();

Enfin on remet a zéro notre formulaire, c’est a dire qu’on vide tout les champs. On peut par la suite ajouter un message (pour l’ergonomie) qui s’affichera expliquant que l’ajout s’est bien effectué. Ici c’est donc juste un passage de variable à la vue. Voilà notre formulaire fonctionne mais il y reste encore des choses a voir.

Double vérification du password ; Validation avec données.

Du fait qu’il faille vérifier que l’utilisateur a bien rentré deux fois le même password, on va avoir besoin d’au moins un des deux password. On va donc redéfinir la méthode isValid de la classe Model_Form_User_User qui étend Zend_Form je vous rappel. Cette classe, comme on a vu plus haut, est systématiquement appelé, et elle appel à son tour tous les validateurs de tous les éléments. On va utiliser pour vérifier que l’utilisateur a bien rentré deux fois le même password grâce une classe de validation réalisé par l’ami dator :

class App_Validate_PasswordMatch extends Zend_Validate_Abstract
{
    const PASSWORD_MISMATCH = 'passwordMismatch';
    protected $_compare;
    protected $_messageTemplates = array(
        self::PASSWORD_MISMATCH => "PASSWORD_MISMATCH"
    );
    public function __construct($compare){
        $this->_compare = $compare;
    }
    public function isValid($value){
        $this->_setValue((string) $value);
        if ($value !== $this->_compare)  {
            $this->_error(self::PASSWORD_MISMATCH);
            return false;
        }
        return true;
    }
}

On peut la mettre en bas de la classe Model_Form_User_User, ça ne pose pas de problème. Du coup il ne nous reste plus qu’a l’utiliser :

public function isValid($data)
	{
	    $this->getElement('password')->addValidator(new App_Validate_PasswordMatch($data['password2']));
		if ($this->getElement('email')->getValue() == $data['email']){
				$this->getElement('email')->removeValidator ( "Zend_Validate_Db_NoRecordExists" );
		}
	    return parent::isValid($data);
	}

On commence par récupérer l’élément password, auquel on ajoute notre validateur personnalisé en lui donnée comme paramètre le password2 rentré par l’utilisateur. Ensuite on appelle la méthode « classique ».

Conclusion

Et voilà, on a finit avec notre formulaire. On peut bien sur l’améliorer et surtout le rendre plus joli. Je vous redonnerai tous les fichiers nécessaires lors de la deuxième et on peut continuer avec la 2eme partie : affichage, modification et suppression.

Articles en rapport : :

• Zend Framework, Formulaire et Base de donnée, partie 2
• Gerer l’authentification avec Zend_Auth du Zend Framework
• Zend Framework
• Comment bien démarrer un projet Zend Framework grâce aux Zend_Tool
• Application de site E-Commerce [Code-Source]

Auteur : © Greg pour LyRiX Blog.
Article publié le : 19-11-2009, dans : Zend Framework. Liens direct vers l'article (permalink)
Mot Clé : Bootstrap, Controller, Model, Mysql, View, Zend Framework, Zend_Db, Zend_Form, Zend_Translate

• Soit on lance Zend studio en ligne de commande :

GDK_NATIVE_WINDOWS=1 ./ZendStudio

• Soit on se fait un petit script :

#!/bin/bash
export GDK_NATIVE_WINDOWS=1
/usr/local/Zend/ZendStudio-7.1.0/ZendStudio '$@'

Pensez a remplacer votre path (chemin) vers le lanceur de zend.

Pour les puristes, le problème vient d’une incompatibilité entre les libraires GTK et SWT utilisées dans Eclipse 3.5.x et Ubuntu 9.10.

source

Articles en rapport : :

• Comment résoudre les conflits entre VNC et Compiz Fusion
• Installation et parametrage d’un serveur @home sous linux ubuntu – partie 2
• Comment passer de WP-codebox à Syntax Highlighter ?
• Des liens en vrac
• Retour sur Zend Studio 7 beta

Auteur : © Greg pour LyRiX Blog.
Article publié le : 12-11-2009, dans : Zend Framework. Liens direct vers l'article (permalink)
Mot Clé : Bouton, Gui, HotFix, Ubuntu, Zend Studio

Sommaire

• Sommaire
• Connexion a la base de donnée
• Schémas de la table
• Préparation de la classe métier
• Obtenir et récupérer des enregistrements
• Ajouter des enregistrements
• Modifier des enregistrements
• Supprimer des enregistrement
• Etendre la classe métier
• Conclusion

Connexion a la base de donnée.

La connexion à la base de donnée principale se fait toute seule. Je m’explique, c’est le bootstrap qui va initialiser notre connexion à la base de donnée. En fait le bootstrap va charger le fichier de configuration de l’application et c’est dans ce fichier que l’on va définir les paramètres de connexion a la BDD. Il faut donc éditer le fichier application/configs/application.ini

; DATABASE
resources.db.adapter = "MYSQLI"
resources.db.params.host = "localhost"
resources.db.params.username = "budget"
resources.db.params.password = "budget"
resources.db.params.dbname = "budget"
resources.db.params.date_format = "YYYY-MM-ddTHH:mm:ss"
resources.db.isDefaultTableAdapter = true

Si on veut que notre connexion à la BDD soit géré automatiquement, le schémas (ci dessus) est très rigide. En effet zend va chercher automatiquement si dans le fichier de configuration il y a des constantes « ressources.db.* » de défini, et si oui il va essayé de se connecter à la base de donnée. Il est bien sur possible d’avoir plusieurs connexions à différente SGBD (mysql, orable, DB2 …).
Si vous utiliser mysql, il suffit de copier / coller le schémas ci dessus, et de bien remplacer les lignes : host, username, password et dbname qui signifie respectivement : hôte, nom d’utilisateur, mot de passe, nom de la BDD. Sinon l’adpater est le driver à utiliser pour se connecter (mysql, orable, DB2… ; se référer a la doc) ; date_format est le format de la date ; et isDefaultTableAdapter est pour savoir si cette connexion est la principale.

Schémas de la table

On va utiliser un exemple pour bien mettre en place ce tuto. On va utiliser une table d’utilisateur. Voilà le schémas :

CREATE TABLE IF NOT EXISTS `users` (
  id int(50) NOT NULL auto_increment,
  `name` varchar(50) NOT NULL,
  firstname varchar(50) NOT NULL,
  email varchar(255) NOT NULL,
  `password` varchar(255) NOT NULL,
  phonenumber varchar(20) NOT NULL,
  `enable` int(1) NOT NULL,
  `level` int(1) NOT NULL,
  PRIMARY KEY  (id),
  UNIQUE KEY email (email)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

On a donc :

• Un id en auto-increment
• Un nom
• Un prénom
• Une adresse email
• Un mot de passe
• Un numéro de téléphone
• Un booléen pour savoir si l’utilisateur est activé
• Un entier pour avoir le niveau d’administration
• Une clé primaire et un index sur l’id
• Une clé unique et un index sur l’email

Préparation de la classe métier.

Zend commence à gérer de façon assez autonome et automatique les BDD. Il y a maintenant un gestionnaire CRUD (Create, Read, Update, Delete => Ajouter, Lire, Mettre a jour, Supprimer des enregistrements). Pour se faire il faut créer une class php. On est assez libre pour le nom des class et pour leurs emplacements, mais je vous recommanderai d’être assez logique et rigoureux. En fait il va falloir faire une class par table de votre base de donnée. Pour ma part, je mets presque toujours un « s » a la fin du nom de mes tables, car elles contiennent plusieurs enregistrements. Par exemple la table users contient plusieurs utilisateurs. Il faut maintenant créer une class qui représente cette table. On peut organiser ses class comme on veut, mais en général sur le petits projets je mets toutes mes class dans le dossier application/models/DbTable/. De plus je nomme toujours ma class avec le même nom que la table. A quoi doit ressembler la class (Voir la convention de nommage des models) :

<?php
class Model_DbTable_Users extends Zend_Db_Table {
	protected $_name = 'users';
}

Pour le nom de la class, il faut se référer au model dans le Zend Framework. Il faut étendre la class Zend_Db_Table. Enfin il faut ajouter l’attribut protected $_name qui a pour valeur le nom de la table dans la base de donnée. Et voilà, le plus dur est fait. On a maintenant une class qui possède un bon nombre de méthode CRUD.

Obtenir et récupérer des enregistrements

Comment obtenir tous les tuples d’une table ? Si il n’y a pas de close particulières, c’est super simple , on exécute le petit bout de code suivant :

private function getUsersAll() {
	$dbUser = new Model_DbTable_Users();
	return $dbUser->fetchAll()->toArray();
}

Donc on instancie un nouveau Model_DbTable_Users, et on lui demande la retourner tous les enregistrements grâce a la méthode fetchAll, et enfin on convertit le résultats en tableau. Voilà le tours est joué !
Comment obtenir que certains enregistrements ?

private function getUsersByName($name = '') {
	$dbUser = new Model_DbTable_Users();
	return $dbUser->fetchAll()->toArray(array('name = ?'=> $name));
}

Voilà, la méthode fetchAll possède 4 arguments: $where,$order,$count,$offset qui représente respectivement la clause where, le clause order by, et la clause limit (combien d’enregistrement et à partir de l’enregistrement numéro n ). Pour une utilisation plus poussé, je vous recommande de lire la doc du Zend Framework.

Ajouter un enregistrement

Comment ajouter un enregistrement dans la base de donnée ? Comme dans l’exemple précédant, on va ajouter un nouvel utilisateur.

$users = new Model_DbTable_Users();
$row = $users->createRow();
$row->name = 'Nom';
$row->firstname = 'Prenom';
$row->email = 'email';
$row->password = md5('password');
$row->phonenumber = '0102030405';
$row->enable = 1;
$row->level = 9;
$result = $row->save();

On commence par instanciée un nouveau Model_DbTable_Users. Ensuite on crée une ligne, puis on ajoute a cette ligne les différents attributs, et enfin on sauvegarde cette ligne en table.
On peut aussi faire la même chose en donnant a la méthode createRow un tableau en argument. :

$users = new Model_DbTable_Users();
$datas = array(
	'name'=>'Nom',
	'firstname'=>'Prenom',
	'email'=>'email2',
	'password'=>md5('password'),
	'phonenumber'=>'0102030405',
	'enable'=>1,
	'level'=>9,
);
$row = $users->createRow($datas);
$row->save();

Enfin on peut faire beaucoup plus simple. Je ne connais pas bien la différence entre les deux méthodes (la précédente et la suivante), si quelqu’un peut m’éclairer, je suis preneur.

$users = new Model_DbTable_Users();
$datas = array(
	'name'=>'Nom',
	'firstname'=>'Prenom',
	'email'=>'email3',
	'password'=>md5('password'),
	'phonenumber'=>'0102030405',
	'enable'=>1,
	'level'=>9,
);
$row = $users->insert($datas);

Bon, c’est assez simple d’ajouter un enregistrement en table ? On va un peu plus loin. Comment protéger ses enregistrements en table grâce a une transaction SQL :

$users = new Model_DbTable_Users();
$datas = array(
	'name'=>'Nom',
	'firstname'=>'Prenom',
	'email'=>'email3',
	'password'=>md5('password'),
	'phonenumber'=>'0102030405',
	'enable'=>1,
	'level'=>9,
);
$defaultAdaptateur = Zend_Db_Table::getDefaultAdapter();
$defaultAdaptateur->beginTransaction();
try {
	$defaultAdaptateur->insert('users', $datas);
	$defaultAdaptateur->commit();
} catch (Exception $e) {
	$defaultAdaptateur->rollBack();
	echo $e->getMessage();
}

On commence de la même façon que pour la dernière méthode. Ensuite on récupère l’adaptateur de la base de donnée principale puis on commence une transaction. Il faut ensuite en-capsuler notre ajout à la base dans un bloque try-catch. On essaye d’insérer notre enregistrement puis si ça fonctionne on commit. Si ça ne fonctionne pas on fait un rollback et on affiche les messages. Bien sur il est possible de n’utiliser qu’un bloque try-catch.

Mettre a jour un enregistrement

La méthode ici est très similaire à l’ajout d’un enregistrement. On peut mettre a jour uniquement qu’une seule ligne ou tout un groupes de ligne. Dans cet exemple on remplace tous les enregistrements ou l’attribut name est « Nom » par « Nom2 ».

$users = new Model_DbTable_Users();
$datas = array('name'=>'Nom2');
$users->update($datas,array('name = ?'=>'Nom'));
$this->render('index');

Ici les $datas sont les données qu’on va mettre a jour. La méthode updates va tout faire. Le premier arguments est le tableau de donnée, le second argument correspond aux conditions de la clause where. Dans ce cas la on explicite que l’attribut name doit correspondre a Nom.

Supprimer un enregistrement

Cette dernier action est la plus simple, il suffit de bien formuler la clause where.

$users = new Model_DbTable_Users();
$users->delete(array('name = ?'=>'Nom2'));

Ici on supprimer tous les utilisateurs qui ont pour valeur d’attribut name : Nom2.

Extension de la class métier

Bien entendu, on peut ajouter des méthodes particulières a notre class métier. Comme par exemple pour avoir le nombre d’enregistrement :

public function getUserCount(){
	$sql = 'select count(1) cnt from users';
	$stmt = $this->_db->query($sql);
	$results = $stmt->fetchAll();
	if ((sizeof($results) > 0) && (isset($results[0]['cnt']))) {
		return $results[0]['cnt'];
	}
	throw new Exception("Erreur : impossible d'obtenir le nombre d'utilisateur");
}

Conclusion

On peut bien sur en-capsuler un update, une suppression dans un block try-catch et de plus on est pas obligé d’utiliser les transaction sql qui sont quand même plus lourde. On verra dans un prochain tuto comme utiliser les clés étrangères.
[header]

Articles en rapport : :

• Zend Framework, Formulaire et Base de donnée, partie 2
• Gerer l’authentification avec Zend_Auth du Zend Framework
• Zend Framework, Formulaire et Base de donnée, partie 1
• Application de site E-Commerce [Code-Source]
• Zend : Comment utiliser un model ?

Auteur : © Greg pour LyRiX Blog.
Article publié le : 19-10-2009, dans : Zend Framework. Liens direct vers l'article (permalink)
Mot Clé : CRUD, Mysql, Zend Framework, Zend_Db

Avoir un site, c’est bien, mais c’est encore mieux si on peut le traduire facilement dans plusieurs langues. On va voir ensemble comment mettre en place un fichier de traduction avec Zend_Translate dans notre application. Il y a plusieurs moyens de gérer les traductions avec Zend Framework. Chacun a ses avantages et inconvénients. La je vais utiliser un simple fichier php qui va contenir un tableau (array) avec les traductions. L’avantage du tableau php : on peut facilement le mettre a jour, il est lisible par un humain. Par contre il a un inconvénient : Si l’application est énorme, on aura des problème de performance. A vous de bien choisir la gestion de la traduction.

Le fichier de traduction :

Il faut le placer dans le dossier : application/languages/. Pour le nom on va être créatif et l’appeler fr.php pour la traduction en français. Il ressemble a ça :

<?php
return array(
	'key_1'=>'Traduction 1',
	'key_2'=>'Traduction 2',
);

Donc quand on va utiliser la pseudo-variable ‘key_1‘, l’application traduira automatiquement ‘key_1‘ en ‘Traduction 1‘ (bien sur si on est en français dans l’application. Sinon j’ai dit pseudo-variable car on utilise ‘key_1‘ d’une façon bien particulières. Tout dépend du contexte. On va y venir…

Le bootstrap

Il faut bien entendu « dire » à notre application qu’il faut qu’elle utilise les traductions et il faut aussi lui donner une langue par défaut. On peut même faire en sorte que l’application choisisse elle même la langue en fonction de la position géographique de l’utilisateur final, mais la j’y reviendrais dans un prochain tuto.
Voilà, on ajoute ce code dans notre bootstrap :

	/**
	* Initialize Translation
	*
	* @return Zend_Translate
	*/
	public function _initTranslate()
	{
		$translate = new Zend_Translate('array', APPLICATION_PATH . '/languages/fr.php', 'fr');
		Zend_Registry::set('Zend_Translate', $translate);
		return $translate;
	}

voilà on peut maintenant utiliser notre fichier de traduction :

Dans un model :

Ici c’est (relativement extrêmement) simple. Par exemple si on veut mettre un label a un élément d’un formulaire (Zend_Element, Zend_Form), et bien sur le traduire il n’y a rien a faire, il suffit de donner a la méthode setLabel la clé de notre tableau qui est dans le fichier fr.php. Par exemple pour un champs password :

$password = new Zend_Form_Element_Password(‘password’);
$password->setLabel(‘form_user_add_password’);[/code]

Et dans notre fichier fr.php :

'form_user_add_password'=>'Mot de passe : ',

Petit tips : Si on a besoin de traduire des messages d'erreurs liés aux validateurs (Zend_Validate) d'éléments du formulaire il faut ajouter dans le fichier de traduction, le message original renvoyé par le validateur. On peu trouvé les messages originaux ici (merci guiton)

//Pour la validation : valeur requise
'Value is required and can\'t be empty'=>'la valeur est requise',
//Pour la validation : Le champs values est deja dans la BDD
'A record matching %value% was found'=>'Il y a déja  \'%value%\' dans la BDD',

Comme on peut le voir sur le deuxième exemple, on peut récupérer le paramètre %value% directement dans le message traduit. C'est la valeur qui a été saisi par l'utilisateur.

Dans une vue (view) :

Si on a besoin d'une traduction dans une vue, la c'est un tout petit peu plus compliqué :

<?php echo $this->translate('view_user_add')?>

Et dans notre fichier fr.php :

'view_user_add'=>'Ajouter un utilisateur',

Voilà, c'est assez simple, si on veut la traduction de 'key_1' il suffit de faire

$this->translate('key_1')

Bon voilà on a fait le tours ! Enfin il me semble. Il y a des questions ou des remarques ?

Articles en rapport : :

• Comment gérer la navigation de son site avec le Zend Framework
• Zend Framework
• Initialisation d’un projet Zend Framework Avec Zend_Tool
• Zend : Comment utiliser un layout ?
• Architecture du Zend Framework 1.10 en MVC

Auteur : © Greg pour LyRiX Blog.
Article publié le : 15-10-2009, dans : Zend Framework. Liens direct vers l'article (permalink)
Mot Clé : Bootstrap, Traduction, Zend Framework, Zend_Translate

Dans ce tuto on va voir comment mettre en place un système automatique de navigation dans le Zend Framework. C’est a dire que notre menu de navigation soit dynamique et flexible. On pourra par exemple avoir notre chemin de navigation ou fil de navigation. On va donc utiliser le composant Zend_Navigation. On a plusieurs possibilité pour la gestion et le stockage de l’arbre (ou graphe) de navigation. Moi j’ai choisit le XML pour le stockage, et la gestion par module, controller et action. Enfin on utilise aussi la traduction automatique

Sommaire

• Sommaire
• Introduction
• Bootstrap
• Layout
• Hiérarchie de pages
• Classe css de la page en cours
• Fil de Navigation ou breadcrumbs

Introduction

On commence par un aperçu de notre fichier de navigation :

<?xml version="1.0" encoding="UTF-8"?>
<configdata>
<nav>
	<home>
		<label>nav_home</label>
		<controller>index</controller>
	</home>
</nav>
</configdata>

Petite explication : la balise configdata ne sert que de nœud racine, la balise nav sert a repérer notre section de la gestion de la navigation. Dans mon cas je n’utilise le fichier navigation.xml que pour gérer la navigation, pour on pourrait envisager de n’avoir qu’un seul gros fichier xml pour gérer toutes nos données et variables de l’application.
Ensuite on a une balise home, elle représente un lien du menu, on lui donne le nom qu’on veut, elle va représenter dans notre cas la page d’accueil. Elle a pour classe fille une balise label qui définit le nom du lien. J’utilise nav_home car dans mon fichier de traduction j’ai une clé nav_home qui fait référence a home. Enfin il y a une balise controller qui définit sur quel controller pointe le futur lien. Il est bien sur possible de sélectionner une action avec la balise action et un module avec la balise module. C’est bien fait non ? Sinon il est possible aussi d’avoir un liens direct grâce a la balise uri. Un petit exemple qui regroupe tout les cas :

<?xml version="1.0" encoding="UTF-8"?>
<configdata>
<nav>
	<home>
		<label>nav_home</label>
		<controller>index</controller>
	</home>
	<page2>
		<label>Page 2</label>
		<module>mon_module</module>
		<controller>mon_controller</controller>
		<action>mon_action</action>
	</home>
	<home>
		<label>nav_home</label>
		<uri>/foo/bar/</uri>
	</home>
</nav>
</configdata>

Bootstrap

Il faut rajouter une méthode a notre bootstrap :

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

La seule chose a retenir ici est le premier argument de la méthode Zend_Config_Xml : c’est le chemin de notre fichier de navigation et le deuxième argument représente la balise mère de notre section de navigation dans le fichier xml.
Voilà, on a notre fonction de navigation disponible dans notre application. Il suffit maintenant de l’utiliser.

Layout

Histoire de faire le plus simple possible, on va ajouter notre barre de navigation directement dans le layout, histoire de le retrouver sur toutes les pages. Il suffit de rajouter ce bout de code dans le fichier layout.phtml à l’endroit ou vous voulez que le menu s’affiche :

<?php echo $this->navigation()->menu(); ?>

Hiérarchie de pages

On va voir maintenant un exemple de fichier xml ou il y a plusieurs pages et sous pages

<?xml version="1.0" encoding="UTF-8"?>
<configdata>
<nav>
	<home>
		<label>nav_home</label>
		<controller>index</controller>
		<pages>
			<add>
				<label>nav_fact_add</label>
				<controller>fact</controller>
				<action>add</action>
			</add>
			<list>
				<label>nav_fact_list</label>
				<controller>fact</controller>
			</list>
			<calc>
				<label>nav_calc</label>
				<controller>calc</controller>
			</calc>
			<user>
				<label>nav_user</label>
				<controller>user</controller>
			</user>
			<stats>
				<label>nav_sats</label>
				<controller>stats</controller>
			</stats>
		</pages>
	</home>
</nav>
</configdata>

Voilà, la balise a retenir est la balise pages qui permet de définir des sous pages ou sous menu. Et bien sur on peut en imbriquer autant qu’on veut.
Enfin il faut savoir que le code html des liens sur la page suit une hiérarchie de balise ul/li.

Classe css de la page en cours

Comment ajouter une classe au lien qui pointe vers la page en cours ? Et bien il suffit de rajouter ce bout de code en haut de chaque controller (dans la méthode init) :

	public function init()
	{
		/* Initialize action controller here */
		$activeNav = $this->view->navigation()->findByController('index');
		$activeNav->active = true;
		$activeNav->setClass("active");
	}

Et voilà maintenant quand on est sur une page du controller index (dans ce cas la) et bien le lien aura (entre autre) la classe active. Il suffit après de toucher au css pour ajouter un petit effet

Vous en voulez encore plus ?

Fil de Navigation ou breadcrumbs

Et bien avec Zend_Navigation on peut retracer notre chemin de navigation, qui soit dit en passant est très bon en terme d’ergonomie, mais aussi en terme de référencement. Donc je vous invite vraiment à le mettre en place. Encore une fois, il suffit de rajouter une ligne de php dans le fichier layout.phtml :

<?php echo $this->navigation()->breadcrumbs()->setMinDepth(0)->setLinkLast(true)->setSeparator(" >> "); ?>

Alors on décortique le bousin :

• $this->navigation()->breadcrumbs() va afficher le fil de navigation.
• ->setMinDepth(0) va définir si il faut ou pas afficher ce fil ; il est en accord direct avec la profondeur du xml.
• ->setLinkLast(true) définit si il faut ou pas mettre un liens sur le dernier fils du fil de navigation qui correspond à la page en cours
• ->setSeparator( » >> « ) définit par quelle chaine de caractère est séparer notre liste de liens.

Voilà, comme on a pu voir, le plus dur est de faire le fichier xml ainsi que le css des menus. Après c’est un jeux d’enfant pour avoir de beau menu
[Header]

Articles en rapport : :

• Initialisation d’un projet Zend Framework Avec Zend_Tool
• Comment mettre en place un Layout avec le Zend-Framework 1.8
• Zend : Qu’est ce qu’un controller ?
• Comment bien démarrer un projet Zend Framework grâce aux Zend_Tool
• Zend : Comment faire une vue

Auteur : © Greg pour LyRiX Blog.
Article publié le : 08-10-2009, dans : Zend Framework. Liens direct vers l'article (permalink)
Mot Clé : Bootstrap, Zend Framework, Zend_Navigation, Zend_Translate