Instructions rapides : télécharger le script world2.zip et le décompresser.

 mysql -u root < world2-schema.sql
 mysql -u root < world2-data.sql 
 

Figure 5. tables

Voici une description SQL de la structure de la table « Country » (on aurait pu en choisir une autre)

  
mysql> describe Country;
+----------------+--------------------------------------+------+-----+---------+----------------+
| Field          | Type                                 | Null | Key | Default | Extra          |
+----------------+--------------------------------------+------+-----+---------+----------------+
| id             | int(11)                              | NO   | PRI | NULL    | auto_increment | 
| Code           | char(3)                              | YES  |     | NULL    |                | 
| Name           | char(52)                             | NO   |     |         |                | 
| Continent      | enum('Asia','Europe',                |      |     |         |                | 
|                | 'North America', 'Africa','Oceania', |      |     |         |                | 
|                | 'Antarctica','South America')        | NO   |     | Asia    |                | 
| Region         | char(26)                             | NO   |     |         |                | 
| SurfaceArea    | float(10,2)                          | NO   |     | 0.00    |                | 
| IndepYear      | smallint(6)                          | YES  |     | NULL    |                | 
| Population     | int(11)                              | NO   |     | 0       |                | 
| LifeExpectancy | float(3,1)                           | YES  |     | NULL    |                | 
| GNP            | float(10,2)                          | YES  |     | NULL    |                | 
| GNPOld         | float(10,2)                          | YES  |     | NULL    |                | 
| LocalName      | char(45)                             | NO   |     |         |                | 
| GovernmentForm | char(45)                             | NO   |     |         |                | 
| HeadOfState    | char(60)                             | YES  |     | NULL    |                | 
| Capital        | int(11)                              | YES  |     | NULL    |                | 
| Code2          | char(2)                              | NO   |     |         |                | 
+----------------+--------------------------------------+------+-----+---------+----------------+

Par simple commodité ici, nous utiliserons l'utilisateur 'root' alors que nous devrions créer d'un utilisateur ou plusieurs utilisateurs spécifiques pour cette base (par exemple via l'entrée "User Administration" de MySQL Administrator.

Combien de lignes contient cette table ?

$ mysql -u root world2

mysql> select count(*) as `nombre de pays` from Country;
+----------------+
| nombre de pays |
+----------------+
|            239 | 
+----------------+

Il est temps maintenant de configurer la connexion à la base de données.

Nous ajoutons quelques lignes à application/configs/application.ini (ZF utilise PDO pour l'accès aux données)

[production]
...
 
database.adapter = PDO_MYSQL
database.params.host = localhost
database.params.username = root
database.params.password = 
database.params.dbname = world2 
 

Puis nous exploitons ces informations au démarrage (dans index.php)

-- dans index.php

// Chargement automatique de Zend_Db_Adapter_Pdo_Mysql, et instanciation.
$config = new Zend_Config_Ini('./application/configs/application.ini', 'production');

$db = Zend_Db::factory($config->database->adapter,array(
  'host'      => $config->database->params->host, 
  'username'  => $config->database->params->username,
  'password'  => $config->database->params->password,
  'dbname'    => $config->database->params->dbname,
    )
);

// placons la connexion dans un registre global à l'application
$registry = Zend_Registry::getInstance();
$registry->set('db', $db);

// en faire la connexion par defaut
Zend_Db_Table::setDefaultAdapter($db);

Nous définissons un objet Zend_Db_Adapter (voir Manuel en ligne).

On remarquera la souplesse d'utilisation de Zend_Config_Ini : les clés du fichier de configuration sont traduites en propriétés public, ce qui nous permet de consulter une valeur associée à une clé par : instance_Zend_Confi_Ini->clé

Nous allons voir maintenant comment lier une classe à cette table.

Dans une application de gestion typique (interface avec un SGBDR), il n'est pas rare d'avoir un modèle qui colle aux tables concernées par les responsabilités de l'application.

Dans ce contexte, il parait alors logique de charger le modèle des responsabilités d'accès aux données : create, retreive, update, delete (CRUD).

Il est commode alors de faire hériter les classes du modèle par une classe prenant en charge les interactions typiques avec un SGBDR. ZF propose la classe Zend_Db_Table_Abstract comme parent de base des classes du modèle.

Nous avons avec la base de données (le SGBDR), deux types de structure à gérer : La table et ses lignes

ZF met à notre disposition deux super-classes Zend_Db_Table_Abstract et Zend_Db_Table_Row_Abstract

Concevons une classe modèle représentant une instance d'un pays : CountryRow (les raisons de ce nommage seront justifiées ultérieurement) :

Remarque : les classes du modèle seront placées dans le dossier « models »

     ZFQuickstart
     |-- application
     |   |-- controllers               
     |   |-- models      
     |   |    |--CountryRow.php
     |   `-- views 
     |-- library 
     |   `-- Zend (racine des librairies de ZF) 
     `-- public
         |-- styles 
         |-- images 
         `-- js 
    
 

 
 <?php

// CountryRow.php

class CountryRow extends Zend_Db_Table_Row_Abstract {
    
  public function getNbCities(){
    // TODO
    return -1;
  }

}

  
 

Nous concevons en plus la classe Country que nous lions à CountryRow :

// Country.php
 
class Country extends Zend_Db_Table_Abstract {    
  protected $_name = 'Country';
  protected $_primary = 'id';
  protected $_rowClass = 'CountryRow'; 
}


 

C'est tout ? Pour l'instant OUI. Les attributs de la classe CountryRow sont auto-générés à partir du nom des attributs de la table (les colonnes).

C'est ainsi que vous pouvez redéfinir l'ensemble des classes du modèle.

Une Méthode d'Action est une méthode d'une sous-classe de Zend_Controller_Action identifiée par un nom se terminant par Action. Par exemple : ajouterAction, supprimerAction.

Qu'est-ce qu'une « Action » ? C'est le « service » associé à une ressource. Par exemple, dans la requête suivante :

http://serveur/racineApplication/document/obtenir

la ressource demandée est document et le service sollicité est obtenir. Dans un contexte ZF de base, le contrôleur DocumentController.php (qui sera automatiquement chargé, suivi d'une instanciation) devra contenir la méthode obtenirAction, car c'est cette dernière qui sera appelée par le framework.

L'action par défaut : En abscence de nom de service l'action « indexAction » sera invoquée. Par exemple, dans la requête suivante :

http://serveur/racineApplication/document

la méthode indexAction de l'objet, instance de DocumentController (ou IndexController par défaut), sera appelée.

Il en va de même avec la ressource. En abscence de nom de ressource, c'est la ressource « index » qui sera sollicitée. Par exemple, dans la requête suivante :

http://serveur/racineApplication/

sera interprété comme:

http://serveur/racineApplication/index/index

Cela suppose donc que le contrôleur IndexController et sa méthode indexAction existent !

Sollicitons notre contrôleur CountryController :

Figure 6. Interaction avec le contrôleur

Nous avons droit à une erreur, c'est tout à fait NORMAL ! Explications :

En analysant la première ligne (voir encadré) du rapport d'erreur (pas d'affolement, l'analyse de la première ligne suffit dans la majorité des cas), nous constatons que le système recherche le fichier ./application/views/scripts/country/index.phtml.

C'est en fait le script responsable de la VUE (le V de MVC), le contrôleur de cas d'utilisation (le C de MVC) ne s'occupant que de la logique de type conversationnel et traitement.

En effet, il ne devrait pas y avoir d'instruction echo ou print dans un contrôleur (mais parfois des Zend_Debug::dump() ;-).

Comme on a pu le constater, ZF, par défaut, s'attend à ce que le développeur ait conçu des vues pour chaque méthode d'action.

 
     ZFQuickstart
     |-- application
     |   |-- controllers
     |   |    |--CountryController.php
     |   |               
     |   |-- models 
     |   `-- views 
     |   |    |--scripts
     |   |    |    |--country
     |   |    |    |    |--index.phtml
     |-- library 
     |   `-- Zend (racine des librairies de ZF) 
     `-- public
         |-- styles 
         |-- images 
         `-- js 
    
 

Les vues sont stockées dans la branche racine/application/views/scripts/xxx/yyy, ou xxx est le nom de la ressource sollicitée (en référence au contrôleur), et yyy le nom de la vue en relation, de la forme nomDuService.phtml . Le nom du service étant la partie gauche du nom de la méthode d'action. Par exemple :

http://serveur/racineApplication/document/ajouter

la métode ajouterAction de l'objet, instance de DocumentController, sera appelée, puis la vue application/views/scripts/document/ajouter.phtml sera traitée et retournée au client web.

Bien entendu, toute cette logique de traitement est entièrement prise en charge par le framework.

Voici un exemple de vue ./application/views/scripts/country/index.phtml :

<h1>Les pays</h1>

Sollicitons de nouveau notre contrôleur CountryController :

Figure 7. Interaction avec le contrôleur : http://.../zf-tuto/country

Nous avons vu :

Le contrôleur passera un objet de type "RowSet" (ens. de lignes) d'objets de type "Row" (ligne).

Les objets de type Zend_Db_Table_Row, sont automatiquement spécialisés par ZF en fonction du modèle.

Il est temps maintenant de coder le contrôleur :

require_once('Country.php');
class CountryController extends Zend_Controller_Action
{

  public function init()
  {   
        
  }

  public function indexAction()
  {
    // on retrouve le registre global  
    $registry = Zend_Registry::getInstance();
    // et notre connexion
    $db = $registry->get('db');
    
    // que l'on passe au constructeur (hérité) de notre modèle
    $ct = new Country($db);
    
    // obtenons un objet Zend_Db_Select (capable d'appliquer des restrictions)
    $select = $ct->select();
    
    // aucune clause where, donc cette variable est inutile ici
    
    // nous transmettons sous le nom 'countries' à la vue l'ensemble
    // des lignes de la table Country soit un objet Zend_Db_Table_Rowset 
    //    (colection d'objets CountryRow - des Zend_Db_Table_Row) 
    $this->view->countries=$ct->fetchAll($select);    
    $this->render();
  }
[...]

Connexion par défaut

Si l'application n'accède qu'à une seule base de données, on peut, par exemple dans le bootstrap (index.php), spécifier une connexion par défaut. Zend_Db_Table::setDefaultAdapter($db); Zend_Registry::set('dbAdapter', $db); Ainsi, dans le contrôleur, le code se trouve encore réduit : : // SANS connexion par défaut // on retrouve le registre global $registry = Zend_Registry::getInstance(); // et notre connexion $db = $registry->get('db'); // que l'on passe au constructeur (hérité) de notre modèle $ct = new Country($db); //AVEC connexion par défaut (une seule instruction !) // Aucun argument à la construction. // Liaison automatique via la connexion par défaut $ct = new Country(); $this->view->countries=$ct->fetchAll();

Le script de la vue associé à l'action est : views/country/index.phtml.

En effet, les attributs automatiques de notre modèle sont directement accessibles (non privés).

 
<table>
<?php foreach ($this->countries as $country) : ?>
   <tr>
      <td> <?php echo $this->escape($country->id) ?>   </td>
      <td> <?php echo $this->escape($country->Name) ?>   </td>
      <td> <?php echo $this->escape($country->Continent) ?>   </td>
      <td> <?php echo $this->escape($country->LocalName) ?>   </td>
  </tr>
<?php endforeach; ?>
</table> 

Ce script utilise la méthode « escape » pour échapper les caractères (Par défaut, la méthode escape() utilise la fonction PHP htmlspecialchar() pour l'échappement).

A noter la syntaxe à la « endif », voir doc syntaxe PHP qui favorise la lecture (les accolades ouvrantes et fermantes sont parfois difficiles à repérer dans la vue).

Figure 8. country/index.phtml

Ce script de vue exploite une collection d'objets de type Country.

Le contrat qui lie la vue et le contrôleur est simple : La vue considère qu'un contrôleur lui a mis à disposition, sous l'appellation countries, une collection d'objets de type Country.

Remarque : Dans cette configuration, Contrôleur et Vue sont dépendants du Modèle.

On a vu :

Par convention, les noms capitalisés sont associés à des noms où les caractères majuscule sont remplacés par le caractère minuscule correspondant précédé d'un tiret (voir doc ici).

  :action: MixedCase and camelCasedWords are separated by dashes; 
  non-alphanumeric characters are translated to dashes, 
  and the entire string cast to lower case. 
  Examples: "fooBar" becomes "foo-bar"; "foo-barBaz" becomes "foo-bar-baz". 
  

Fichier voir-pays.phtml

    
<style type="text/css">
<!--
.pays {
 margin-left: 40px; 
}
-->
</style>
<div class='pays'>
<h2>Pays</h2>
Pays : <?= $this->pays->Name ?> <br>
Continent : <?= $this->pays->Continent ?> <br>
Nombre de villes inscrites : <?= $this->pays->getNbCities() ?> <br>
</div>  
  
  

Le problème se pose côté contrôleur : Quel pays transmettre à la vue ?

Le service devra donc être paramétré. Le contrôleur attend donc une donnée lui permettant de déterminer le bon pays à transmettre à la vue. Par défaut le contrôleur transmettre le premier de la liste (id=1).

Voici la méthode d'action en charge de ce cas d'utilisation du contrôleur CountryController :

  
     
  public function voirPaysAction()
  {
    if ($this->_hasParam('id'))
       $index = $this->_getParam('id');
    else
       $index = 1;
    $ct = new Country();  
    $pays = $ct->find($index)->current();
    $this->view->pays=$pays;
    $this->render();
  }
  
  

La méthode vérifie qu'elle dispose bien d'un argument ('id'). Si ce n'est pas le cas, elle choisira le premier pays (index=1), sinon, elle utilise directement la valeur reçue index (très dangereux, à ne pas reproduire !)

Nous obtenons :

Figure 9. http://localhost/~kpu/zf-tuto/country/voir-pays

Noter que la doc API (method _getParam) nous indique que la méthode _getParam admet comme second argument optionnel un valeur par défaut. Ainsi aurions-nous pu écrire :

 $index = $this->_getParam('id', 0);

Nous passerons les arguments par l'URL. Le mode rewrite étant activé sur le serveur HTTP, les arguments peuvent être insrits dans une expression de chemin :

  http:// ... /zf-tuto/country/voir-pays/id/1
  

Équivalent à :

  http:// ... /zf-tuto/country/voir-pays?id=1
  

Sauf que l'expression de chemin est d'un apparence plus stable, donc plus facile à gérer pour les moteurs de recherche, entre autres.

La syntaxe générale de passage d'arguments : .../nom1/val1/nom2/val2/.../nomN/valN

Nous testons le contrôleur en demandant de consulter un autre pays (id=3)

Figure 10. http://localhost/.../zf-tuto/country/voir-pays/id/3

Enfin, voici les liens logiques liant les éléments de la requête et le contrôleur.

Figure 11. http://localhost/.../zf-tuto/country/voir-pays/id/3

Recherche le pays d'id = 1

// Fontion de niveau 'table' 
 $dt = new Country();  
 $pays = $dt->find(1)->current();  
 

La méthode find prend comme argument un identifiant (un ou plusieurs arguments selon le cas), et retourne un Rowset.

La méthode current d'un Rowset retourne l'élément courant sous la forme d'un objet Row (ou NULL s'il n'existe pas. Dans notre cas c'est le premier et unique CountryRow.

Modification de l'attribut 'HeadOfState' du pays d'id = 73

// Fontion de niveau 'tuple' 
 $dt = new Country();  
 $rowPays = $dt->find(73)->current();
 // en 2006, $rowPays->HeadOfState == 'Jacques Chirac'
 $rowPays->HeadOfState = "Nicolas Sarkozy";
 $rowPays->save();
 

La méthode save fait une mise à jour, dans la table Country, du tuple associé à notre objet.

création d'une ville

public function testAddAction(){
 require_once 'City.php';
// Fontion de niveau 'table' et 'tuple'
  $ct = new City(); 
  // les données sont représentées par un dictionnaire
  $data = array(  
    'Name' => 'Test',
    'LocalName' => 'local test',
     // pays concerné, car il en faut un.
    'idCountry' => 2,
    'District' => 'regionTest',
    'Population' => 1  // pas grand monde  
  ); 
  $cityRow=$ct->createRow($data);  
//  Zend_Debug::dump($cityRow);
  if ($cityRow) {
    $id=$cityRow->save();    
    // Ok, c'est fait ! 
    
    // en extra, on zappe de méthode d'action, afin de visualiser le résultat 
    // passage en argument de l'id du pays concerné par ce test
    $this->_setParam('id','2');
    // sous-traitance de service (function villesAction de ce
    // contrôleur, présentée un peu plus loin dans ce doc)
    $this->_forward('villes');    
  }    
}    
 

La méthode createRow crée un CityRow en mémoire.

La méthode save tente d'insérer le nouveau tuple dans la table City.

suppression d'une (ou des) ville(s) portant le nom 'Test'

 // Opération de niveau 'table'
 
public function testDeleteAction(){
 require_once 'City.php';
 $ct = new City();
 $where = $ct->getAdapter()->quoteInto('Name = ?', 'Test');
 // suppression dans la table
 $ct->delete($where);
 
 // en extra, on zappe de méthode d'action, afin de visualiser le résultat 
 // passage en argument de l'id du pays concerné par ce test (voir testAddAction)   
 $this->_setParam('id','2');
 $this->_forward('villes');    
}     
 

La méthode delete supprime, de la table City, le ou les tuples filtrés par la clause 'where'.

On se réfère à la connexion pour gérer une transaction :

 $db = Zend_Registry::get('dbAdapter');
 $db->beginTransaction();
 try {
    // insert pays
    [...]    
    
    // insert pays avec une clé primaire erronée 
    $data = array(
     'id' => 1,  
     'Name' => 'France',
     ...
    );   
    $ct = new Country();
    $ct->insert($data);
    
    // demande d'exécution du lot des opérations    
    $db->commit();    
    $this->render();
 } catch (Exception $e) {
    // annule toutes les opérations du lot
    $db->rollBack();
    $this->_redirect('/');
 }

En référence à notre schéma relationnel ('voir la définition des tables), nous intervenons dans la définition des classes de type 'Table'

 
//City.php
<?php

//Country.php
<?php
class Country extends Zend_Db_Table_Abstract {    
  protected $_name = 'Country';
  protected $_primary = 'id';
  protected $_rowClass = 'CountryRow';

  protected $_referenceMap    = array(
        'Capitale' => array(
            'columns'   	 => 'Capital',
            'refTableClass'  => 'City',
            'refColumns'     => 'id'
        ));
}


//City.php
<?php
class City extends Zend_Db_Table_Abstract {    
  protected $_name = 'City';
  protected $_primary = 'id';
  protected $_rowClass = 'CityRow'; 
  
  protected $_referenceMap    = array(
        'MonPays' => array(
            'columns'           => 'idCountry',
            'refTableClass'     => 'Country',
            'refColumns'        => 'id'
        ));
} 

//CountryLanguage.php 
<?php
class CountryLanguage extends Zend_Db_Table_Abstract {    
  protected $_name = 'CountryLanguage';
  protected $_primary = array('idCountry', 'idLanguage');
  
  protected $_referenceMap    = array(
        'Langue' => array(
            'columns'           => array('idLanguage'),
            'refTableClass'     => 'Language',
            'refColumns'        => array('id')
  ),
        'Pays' => array(
            'columns'           => array('idCountry'),
            'refTableClass'     => 'Country',
            'refColumns'        => array('id')
  )
  );
  
}
// la notation 'tableau' montre comment opérer en cas de clés multi-attributs ('id', ou array(id'))


?> 
 

$_referenceMap est une propriété héritée, qui permet de définir le rôle de chacune des clés étrangères de la table concernée. Chaque rôle est identifié par un :

Une cas typique consiste à exploiter le tuple associé à une clé étrangère. Par exemple, dans le tableau qui liste les pays, nous souhaiterions voir apparaître, non pas l'identifiant de la capitale, mais son nom.

Actuellement le code de la vue est :

 
<table>
<?php foreach ($this->countries as $country) : ?>
   <tr>
      <td> <?php echo $this->escape($country->id) ?>   </td>
      <td> <?php echo $this->escape($country->Name) ?>   </td>
      <td> <?php echo $this->escape($country->Continent) ?>   </td>
      <td> <?php echo $this->escape($country->LocalName) ?>   </td>
      <td> <?php echo $this->escape($country->Capital) ?>   </td>
  </tr>
<?php endforeach; ?>
</table> 

Figure 12. vue id capital

Nous souhaitons afficher le nom de la capitale, à la place de son identifiant.

Fidèle à nos principes (architecture MVC, patterns GRASP), ce n'est pas de la responsabilité de la vue de contenir le code d'extraction du nom du responsable dans le modèle : C'est « le pays qui connaît sa capitale », nous nous adresserons donc à ce dernier.

<?php
 <?php foreach ($this->countries as $country) : ?>
   <tr>
      <td> <?php echo $this->escape($country->id) ?> </td>
      <td> <?php echo $this->escape($country->Name) ?>  </td>
      <td> <?php echo $this->escape($country->Continent) ?>  </td>
      <td> <?php echo $this->escape($country->LocalName) ?>  </td>
      <td> <?php echo $this->escape($country->getCapitale()->Name) ?>   &bnsp; </td>
      <td> <a href=''> les villes </a> </td>            
  </tr>
<?php endforeach; ?> 
 }

Nous intervenons donc au niveau de la classe des objets de type Row, afin de "déréférencer" une clé étrangère.

Pour cela nous utiliserons la méthode findParentRow héritée de la classe Zend_Db_Table_Row_Abstract :

Figure 13. findParentRow

  
  <?php
class CountryRow extends Zend_Db_Table_Row_Abstract {

 public function getCapitale() {
   $city = $this->findParentRow('City', 'Capitale');
   // les arguments de findParentRow : 
   //  'City' -> c'est la table
   //  'Capitale' -> c'est le rôle défini dans $_referenceMap de County.php 
   return $city;
 }
  
  public function getNbCities(){
    // TODO
    return -1;
  }
}

?>    
  

La méthode findParentRow exploite les données de $_referenceMap pour sélectionner la ligne (Row) de la table City liée à l'instance courante (relative à une ligne de la table Country).

La méthode findParentRow attend deux arguments : Le premier est le nom d'une 'TableClass' et le deuxième (optionnel) est une clé de $_referenceMap, soit le nom du rôle de la relation.

Nous pouvons alors tester le résultat :

Figure 14. vue nom capitale

Nous venons de voir comment utiliser Zend Framework pour réaliser une jointure retournant au plus une ligne.

Nous nous intéressons maintenant à la relation Un-à-Plusieurs (One To Many) .

Je souhaite connaître l'ensensemble des villes référencées dans la base de données pour un pays donné.

Plusieurs alternatives s'offrent à nous :

Dans le respect du pattern Expert en Information, nous choisirons la deuxième solution.

Comme vous l'avez certainement constaté , le lien nommé 'voir les villes' : <a href='villes/id/$pays->id'>voir</a> fait référence à une méthode d'action du contrôleur courant 'country', que nous devons concevoir. Mais intéressons-nous en premier à sa vue :

<style>
<!--
table,th,td {
 border-style: solid;
 border-width: 1px;
}

table,caption {
 margin-left: auto;
 margin-right: auto;
 width: auto;
}
-->
</style>

<table>
 <caption>Les villes du pays &gt;?php echo =$this->nomPays; ?></caption>
 <thead>
  <tr>
   <th>Ville</th>
   <th>Région</th>  
   <th>Population</th>
  </tr>
 </thead>
 <tbody>
 <?php foreach ($this->villes as $ville) : ?>
   <tr><td> <?php echo $ville->Name; ?> </td>
       <td> <?php echo $ville->District    ?> &nbsp;</td>
       <td> <?php echo $ville->Population  ?> &nbsp; </td>   
   </tr>
 <?php endforeach; ?>
 </tbody>
</table>

 
 //CountryController.php
  public function villesAction()
    {
      $idPays=$this->_getParam('id', 1);

      $ct = new Country();
      $paysRow = $ct->find($idPays)->current();
      $villes=$paysRow->getVilles();
      $this->view->villes=$villes;
      $this->view->nomPays=$paysRow->Name;
      $this->render();
    }   

17.3.3. Méthode de liaison entre modèle

Sur cette base nous pouvons implémenter la méthode getVilles de la classe CountryRow.

Pour cela nous utiliserons la méthode findDependanteRowset héritée de la classe Zend_Db_Table_Row_Abstract :

Cette méthode permet d'obtenir l'ensemble des tuples d'une table référencant le tuple courant.

Figure 15. findDependanteRowset

Soit :

  
  
<?php  
class CountryRow extends Zend_Db_Table_Row_Abstract {

   public function getVilles() {
    return  $this->findDependentRowset('City');
  }  
  
  public function getCapitale() {
 	$city = $this->findParentRow('City', 'Capitale');
 	 // les arguments de findParentRow : 
 	 //  'City' -> c'est la table
 	 //  'Capitale' -> c'est le rôle défini dans $_referenceMap de County.php 
    return $city;
  }
  
  public function getCapitaleBis() {
  	$db = $this->getTable()->getAdapter();
  	// ou : -- voir index.php
  	//   $registry = Zend_Registry::getInstance();
  	//   $db = $registry.get('db');  
  	 
  	$res = $db->query("SELECT * FROM City WHERE id = ?", array($this->Capital));
  	require_once('CityRow.php');
  	$city = new CityRow();
  	$res->setFetchMode(PDO::FETCH_INTO, $city );
  	$city = $res->fetchObject();
    return $city;
  }
    
  public function getVillesBis() {
    // "SELECT * FROM City WHERE id = ?", array($this->id)
  }
 
  
  public function getNbCities(){
    // TODO
    return -1;
  }
}
 

La méthode findDependentRowset retourne un Rowset (et non pas un Row comme précédemment, qui est l'ensemble des objets CityRow (relatifs aux lignes) lignes de la table City qui sont en relation avec this.

	Le rôle des relations
	La méthode findDependentRowsetpeut prendre un deuxième argument, dont la valeur est un des noms de rôle (clé de $_referenceMap de la classe en premier argument - voir City.php) return $this->findDependentRowset('City', 'MonPays');

Cas d'une table relation porteuse ou non de propriétés

Une table relation, connue également sous l'appellation table intersection, est une table dont la principale raison d'être est de mettre en relation deux tuples (d'une même table ou de tables différentes). La clé étrangère d'une des deux tables est systématiquement "déréférencées".

Zend Framework fournit une façon directe d'exploiter des tables relation.

Figure 16. Many To Many

Prenons un exemple, si nous avions voulu prendre connaissance des pays où la langue française est parlée, tout en en connaissant en connaître les détails (officielle ou non, pourcentage parlé). C'est à dire que nous souhaitons obtenir la listes des pays (objet CountryRow) via CountryLanguageRow :

// LanguageRow.php

  // obtenir tous les pays parlant cette langue
  public function getPaysParlantCetteLangue() {
    return $this->findManyToManyRowset('Country', 'CountryLanguage');
  }

Nous utilisons ici la table relation « CountryLanguage » côté « Country » (prendre les informations des deux tables).

La méthode findManyToManyRowset prend en argument le nom de (ou un objet de) la classe correspondant au Rowset à retourner (ici se sera des objets Etudiant) et en deuxième argument, ce que la documentation zend.db.table.relationships.html nomme table intersection (connu aussi sous l'appelation 'table de relation'). La méthode reçoit optionnellement d'autres arguments comme le rôle dans $_referenceMap (sinon c'est le premier rôle qui est élu).

Voici un exemple d'utilisation : L'utilisateur demande la liste des pays où la langue française est représentée :

Figure 17. http://localhost/~kpu/zf-tuto/country/pays-langue/idlangue/23

Puis l'utilisateur souhaite connaître les langues référencées pour un pays donné :

Figure 18. http://localhost/~kpu/zf-tuto/country/langues/id/44

Les actions du controleur :

   
   public function languesAction()     {
      $idPays=$this->_getParam('id', 1);
      $ct = new Country();
      $paysRow = $ct->find($idPays)->current();
      $langues=$paysRow->getLanguesParlees();
      $this->view->langues=$langues;
      $this->view->nomPays=$paysRow->Name;
      $this->render();
   } 

   public function paysLangueAction()     {
      $idLangue=$this->_getParam('idlangue', 1);      
      //Zend_Debug::dump($this->getRequest()->getParams());
      $lt = new Language();
      $languageRow = $lt->find($idLangue)->current();         
      $lesPays=$languageRow->getPaysParlantCetteLangue();
      $this->view->lesPays=$lesPays;
      $this->view->nomLangue=$languageRow->Name;
      $this->render();
   } 

Les vues associées :

//pays-langue.phtml

<table>
 <caption>Pays ayant comme langue parlée: <?php echo $this->nomLangue ?></caption>
 <thead>
  <tr>
   <th>Pays</th>
   <th>Officielle</th>  
   <th>Pourcentage</th>
  </tr>
 </thead>
 <tbody>
 <?php foreach ($this->lesPays as $pays) : ?>
   <tr>
   <td> <?php echo $pays->Name; ?> </td>          
   <td> <?php echo $pays->IsOfficial; ?> </td>
   <td> <?php echo $pays->Percentage; ?> </td>
   </tr>
 <?php endforeach; ?>
 </tbody>
</table>

//langues.phtml

table>
 <caption>Les langues parlées du pays <?php echo $this->nomPays ?></caption>
 <thead>
  <tr>
   <th>Langue</th>
   <th>Officielle</th>  
   <th>Pourcentage</th>
   <th>autres pays</th>
  </tr>
 </thead>
 <tbody>
 <?php foreach ($this->langues as $langue) : ?>
   <tr>
      <td> <?php echo $langue->Name; ?> </td>          
      <td> <?php echo $langue->IsOfficial; ?> </td>
      <td> <?php echo $langue->Percentage; ?> </td>      
      <td> <a href='<?php 
         echo $this->url(array('controller'=>'country',
                               'action'=>'pays-langue', 
                               'idlangue'=> $langue->idLanguage), null, true) ?>'>voir</a> </td>
   </tr>
 <?php endforeach; ?>
 </tbody>
</table>

Les méthodes de niveau Row

//LanguageRow.php
<?php
class LanguageRow extends Zend_Db_Table_Row_Abstract {
  // obtenir tous les pays parlant cette langue
  public function getPaysParlantCetteLangue() {
    return $this->findManyToManyRowset('Country', 'CountryLanguage');
  }
}

//CountryRow.php
public function getLanguesParlees() {
  return $this->findManyToManyRowset('Language', 'CountryLanguage');
}

Si vous avez respecté les conventions de nommage utilisées dans ce support, pour pouvez alors utiliser les fonctions "magiques" de navigation dans le modèle.

Une méthode magique est une méthodes non déclarée par le développeur, mais respectant des conventions de nommage de sorte que Zend_Db_Table_Row_Abstract puisse en déduire les bons appels. Par exemple

// CountryRow.php
...

public function getVilles() {
  //return  $this->findDependentRowset('City', 'MonPays');
  return $this->findCity();
}

...   

sera interprété : $this->findDependentRowset('City')

Il en va de même avec les méthodes de type « findTableViaTableRelation » quie seront traduites avec findManyToManyRowset : Exemple

// CountryRow.php

public function getLanguesParlees() {
  //return $this->findManyToManyRowset('Language', 'CountryLanguage');
  return  $this->findLanguageViaCountryLanguage();		
}
...    

Plus d'information avec le guide du développeur et l'API

Un filtre est une fonction de transformation d'une donnée d'entrée, soumise par un client, en une donnée conforme pour le système : simplification, ajout de code d'échappement...

Il existe de nombreux filtres prêts à l'emploi. Un filtre est un objet, instance d'une classe qui implémente Zend_Filter_Interface.

Par exemple :

    $headstate = new Zend_Form_Element_Text('HeadOfState');
    $headstate->setLabel('HeadOfState');
    $headstate->setRequired(true);
    $filter = new Zend_Filter_StripTags();
    $headstate->addFilter($filter);                
 

Le filtre StripTags supprimera toute balise présente dans prénom (afin de se prémunir d'injection de code HTML).

Les filtres peuvent être chaînés :

    ...       
    $filter = new Zend_Filter_StripTags();
    $nom->addFilter($filter);          
    $nom->addFilter(new Zend_Filter_StringToUpper());
    ...      
 

Dans ce cas, les filtres sont appliqués par ordre d'insertion dans le composant. Ici, les balises seront supprimées avant la passage en majuscule.

Plus loin avec les filtres : Zend_Filter.

Un validateur est une fonction booléenne qui reçoit une donnée d'entrée, et retourne vrai si son argument est conforme aux règles de gestion prises en charge par le validateur, retourne faux sinon.

De plus, le validateur peut fournir des informations sur les règles non respectées, comme une chaîne vide, ou trop courte ou ne respectant pas une certaine syntaxe, etc.

Il existe de nombreux validateurs prêts à l'emploi. Un validateur est un objet, instance d'une classe qui implémente Zend_Validate_Interface.

Par exemple :

    $headstate = new Zend_Form_Element_Text('HeadOfState');
    $headstate->setLabel('HeadOfState');
    $headstate->setRequired(true);
 
    $headstate->addValidator(new Zend_Validate_NotEmpty());                
 

Les validateurs peuvent être chainés :

    ...       
    $headstate->addValidator(new Zend_Validate_StringLength(2));          
    $headstate->addValidator(new Zend_Validate_Alnum());
    // ou $headstate->addValidator('Alnum'); // le framework se chargeant de la correspondance
    ...      
 

Dans ce cas, les validations sont appliqués par ordre d'insertion dans le composant. Ici, le test de la longueur minimale est réalisé en premier, puis, quelqu'en soit le résultat le seconde test sera lui aussi évalué (caractères alphanumériques uniquement).

 $form = new PaysForm(); // instanciation du formulaire
 if ($this->_request->isGet()) {
   $id = $this->_getParam('id', -1);
   if ($id == -1)
     // rien à faire ici
     return $this->_helper->redirector('index', 'country');
   $ct=new Country();
   $rowPays=$ct->find($id)->current();
   if ($rowPays) {
     // initialisation du formulaire
     // Zend_Debug::dump($rowPays);
     $form->getElement('HeadOfState')->setValue($rowPays->HeadOfState);
     $form->getElement('id')->setValue($rowPays->id);
   }                            
 } 
 // reception de donnees ?       
 else if ($this->_request->isPost()) {
   $formData = $this->_request->getPost();
   // nous les affectons au formulaire 
   $form->populate($formData);            
   // qui applique les filtres
   $formData=$form->getValues();   
   $ct=new Country();
   $rowPays=$ct->find($formData['id'])->current();                       
   // activation des validateurs
   if ($rowPays && $form->isValid($formData)) {
      // ok, nous pouvons opérer              
      $rowPays->HeadOfState = $formData['HeadOfState'];
      // sauvegarde dans la BD
      $id=$rowPays->save();
      // make a "redirect after post"
      // @see http://en.wikipedia.org/wiki/Post/Redirect/Get
      return $this->_helper->redirector('index', 'country');                                  
   }
 }                
 // présentation du formulaire
 if ($rowPays) {
     $this->view->action = "Modifier le nom du chef d'état";
     $this->view->pays = $rowPays->Name;        
     $this->view->form = $form;
     $this->render();
 }
 else {
    //sinon, rien à faire ici !
   return $this->_helper->redirector('index', 'country');
 }
}  

 

Comme on peut le constater, en cas de non validation ou de requête non POST, le formulaire est retourné au client. Ci-dessous un exemple de retour avec informations transmises par les différents validateurs.

Figure 20. http://localhost/~kpu/zf-tuto/country/edit/id/73

Zend Framework est livré, entre autres, avec les modules permettant le gestion des authentifications (Zend_Auth) et des droits (Zend_Acl).

Vous trouverez ici un tutoriel Rob Allen sur la question, traduit en français.

Le module Zend_Session propose une alternative à l'utilisation brute du tableau $_SESSION. En effet, Zend_Session intègre la notion d'"espace de noms" dans la zone de stockage des données de session, limitant ainsi des conflits de noms. Voir Guide du programmeur : Zend_Session

Le module Zend_Layout permet d'encapsuler le contenu d'une vue dans une autre, bien que pouvant être utilisé sans MVC, le module est conçu pour s'intégrer avec ce dernier, utilise Zend_View. Voir Guide du programmeur : Zend_Layout