In questo articolo riprendiamo ciò che si era detto in quest’altro articolo a proposito del componente Zend_Search_Lucene, facendo delle importanti aggiunte riguardo la gestione dell’indicizzazione e ricerca di stringhe multibyte, ovvero di quelle stringhe contenenti testo in lingue tipo russo, cinese, giapponese ecc… Inoltre anche il noto problema dei caratteri accentati è eliminato per sempre.

Prima però vedremo come implementare la corretta visualizzazione di queste effettuando alcune modifiche al codice php ed html ma anche al database.

Questo articolo non vuole essere una spiegazione approfondita su cosa sia un stringa multibyte, sui charset esistenti e sulla loro storia, se non siete a conoscenza di cosa stia parlando forse è meglo effettuare prima una ricerca.

Al termine di questo articolo è presente il progetto completo di tutti gli sviluppi e modifiche discusse sino ad oggi

Database ed UTF-8

UTF-8 è una codifica Unicode multi-byte ASCII-compatibile, ed è la codifica che utilizzeremo come standard per il nostro progetto. Per creare un database MySql che utilizzi UTF-8 dovremo specificare il set di caratteri MySQL utf8_unicode_ci come collation all’atto della creazione del database.

CREATE DATABASE `miodb` DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;

Lo stesso genere di collation dovrà essere specificato per i campi di testo contenuti all’interno delle tabelle del database, in ogni caso è una cosa che avviene automaticamente utilizzando PhpMyAdmin.

Salvataggio dei dati

All’atto dell’inserimento e modifica dei dati, dovremmo fare molta attenzione che questi siano encodati prima di essere inseriti. In una normale applicazione potremmo ricorrere all’utilizzo delle funzioni utf8_encode ed utf8_decode, rispettivamente per la codifica ( prima del salvataggio ) e la decodifica ( dopo essere state recuperati dal db ), in Zend Framework la codifica UTF-8 viene gestita internamente, quindi non dovremo utilizzare queste funzioni per inserire dati nel database. Tuttavia le utilizzeremo per decodificare i record estratti dal database prima dell’inserimento nell’indice di Lucene.

Il codice HTML

Infine dovremmo specificare nel tag HEAD il corretto META per il charset

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

Modifiche al codice di Lucene

Qui di seguito vedremo passo passo le modifiche effettuate al codice in qualche modo relazionato con la gestione di Zend_Search_Lucene. Tutte queste modifiche sono incluse nel file in download, quindi non inserirò il file nella sua completezza.

Per prima cosa modifichiamo il metodo getSearchIndexFields nella classe Paese, la classe row level di Paesi.

    public function getSearchIndexFields(){
      $user = $this->findParentRow('Utenti');
      $reviews = $this->findRecensioni();
      $result = array();
      $result['class'] = 'Paese';
      $result['key'] = $this->id;
      $result['title'] = $this->nome;
      $result['contents'] = $this->provincia;
      $result['summary'] = "";
      if(count($reviews) > 0){
        foreach($reviews as $review) {
          $result['contents'] .= "\n".utf8_decode($review->descrizione);
          $result['summary'] .= "\n".mb_substr($review->descrizione,0,40);
        }
      }
      $result['createdBy'] = $user->name;
      $result['dateCreated'] = $this->inserimento_data;
      return $result;
    }

Per fare in modo di indicizzare correttamente il contenuto del database, codificato in UTF-8, dobbiamo prima decodificarlo. Il campo testuale che subisce la decodifica è il campo contenente il corpo di una probabile recensione. Da notare che la chiave ’summary’ contiene un’anteprima di quello che contiene la recensione, ovvero i primi 40 caratteri. Siccome si tratta di un campo multibyte, utilizziamo la funzione mb_substr. Notate che l’utilizzo delle funzioni multibyte richiede che sia installata la relativa estensione per php ( per chi usa WampServer in locale: PHP -> PHP Extension -> php_mbstring ).

Infine aggiungiamo 2 righe di codice al bootstrap index.php:

  Zend_Search_Lucene_Search_QueryParser::setDefaultEncoding('UTF-8');
  Zend_Search_Lucene_Analysis_Analyzer::setDefault(new Zend_Search_Lucene_Analysis_Analyzer_Common_Utf8());

Con questo codice diciamo a Lucene di interpretare le eventuali stringhe di ricerca come stringhe UTF-8 e di utilizzare il medesimo encoding per la gestione dei documenti nel suo indice, per maggiori informazioni potete consultare la guida ufficiale.

Conclusione

Ho apportato diverse altre modifiche al codice, ad esempio allo stile e ad alcune views. Inoltre ho aggiunto il supporto per la gestione degli errori 404 ( file non trovato ) e degli errori dell’applicazione, che vedremo in un prossimo articolo.

Come annunciato, potete tra poco scaricare il progetto comprensivo di database con alcuni dati di esempio in 4 lingue diverse, italiano, giapponese, russo e hindi ( o almento credo.. )

Non sono presenti link che rimandano ai controllers presenti ma se avete letto gli articoli passati dovreste sapere quali sono… in ogni caso i controller attualmente presenti sono:

• index ( ovviamente )
• search
• supporto
• paese
• auth
• ajax

Avete inoltre bisogno delle seguenti informazioni:

• username e password per accedere sono Admin – admin
• il controller supporto invia email ( anche da locale ) se inserite le credenziali di un account email compatibile
• prima di effettuare ricerche dovete richiamare la reindex action del search controller

DOWNLOAD

Related posts:

1. Luke: Lucene Index Toolbox di Andrzej Bialecki per Zend_Search_Lucene Verificare il contenuto dell'indice di Lucene Se avete seguito questo...
2. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...
3. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...

Related posts brought to you by Yet Another Related Posts Plugin.

La possibilità di poter effettuare una ricerca che restituisca quello che stavamo cercando con il minimo sforzo è una caratteristica essenziale per un sito che si rispetti. Zend Framework ci viene incontro con il componente Zend_Search_Lucene, un motore di ricerca di tipo full text basato sull’ Apache Lucene project, un motore di ricerca per Java.

Zend_Search_Lucene crea un indice di documenti. Questo indice viene salvato direttamente nel filesystem, in una directory a nostra scelta, senza la necessità di avere a disposizione un database server. Tra le caratteristiche possiamo elencare:

• Ricerca per indice di coerenza: i risultati di maggior rilievo vengono restituiti in cima alla lista
• Possibilità di utilizzo di numerosi metodi di ricerca: phrase queries, boolean queries, wildcard queries, proximity queries, range queries e molte altre.
• Ricerca per un campo specifico (ad esempio titolo, autore, descrizione )

Tipi di campo

Questa tabella ci mostra i tipi di campo che possiamo inserire nell’indice di Zend_Search_Lucene e come questi vengono trattati. Vediamoli più nel dettaglio:

• Keyword I campi indicati come keyword sono memorizzati e indicizzati, il che significa che possono essere ricercati e visualizzati tra i risultati di ricerca. Le parole dei campi keyword devono essere separate. Dei buoni candidati per questo tipo di campo sono ad esempio i campi enumerated.
• UnIndexed I campi UnIndexed non sono ricercabili ma vengono ritornati tra i risultati di ricerca. Buoni candidati ad appartenere a questa tipologia di campo sono, ad esempio, i campi chiave primaria, i timestamps, percorsi di filesystem.
• Binary I campi Binary non sono indicizzati ma possono essere ritrovati tra i risultati di ricerca. Vi appartengono quei dati salvati come stringa binaria, ad esempio una icona o una thumbnail.
• Text I campi Text sono memorizzati ed indicizzati, quindi saranno utili ai fini della ricerca ed inoltre saranno restituiti tra i risultati. Ne fanno parte, per eempio, quei campi che contengono titoli, descrizioni ecc, quindi varchar, text ecc.
• UnStored I campi di tipo UnStored sono indicizzati ma non sono memorizzati nell’indice. Questo genere di campo è da utilizzarsi per testi molto lunghi, in quanto, pur essendo ricercabili, non occupano spazio su disco. Nel caso si utilizzi un database, i dati per la visualizzazione potranno essere recuperati da questo.

Come Funziona

Il funzionamento di Zend_Search_Lucene e del suo indice è rappresentato dal seguente schema

Ogni documento inserito nell’indice è una istanza di Zend_Search_Lucene_Document, ed ogni documento contiene degli oggetti di tipo Zend_Search_Lucene_Field, che contengono i dati. Dopo aver effettuato la query il risultato ritornato è un array contenente dei risultati, ognuno di questi un oggetto di tipo Zend_Search_Lucene_Search_QueryHit.

Unificare i documenti

L’indice può contenere dei documenti di tipi differenti, come pagine, recensioni, profili utente ecc. Per fare in modo che i risultati di ricerca siano comprensibili per l’utente dobbiamo unificarli, ovvero scegliere quali campi comuni inserire nel documento dell’indice. Il seguente un esempio di unificazione dei documenti da aggiungere all’indice:

Creazione di un documento

Come detto in precedenza, ogni documento è una istanza della classe Zend_Search_Lucene_Document. Siccome siamo giunti al punto di avere il design del documento ben definito ( la tabella di qui sopra ), possiamo procedere con il creare una classe personalizzata che estenda Zend_Search_Lucene_Document che ci semplifichi la creazione di un documento. La classe in questione si chiamerà Paesidelmondo_Search_Lucene_Document

Paesidelmondo_Search_Lucene_Document

  class Paesidelmondo_Search_Lucene_Document extends Zend_Search_Lucene_Document {
    public function __construct($class, $key, $title,  $contents, $summary, $createdBy, $dateCreated) {
      $this->addField(Zend_Search_Lucene_Field::Keyword( 'docRef', $class.":".$key));
      $this->addField(Zend_Search_Lucene_Field::UnIndexed( 'class', $class));
      $this->addField(Zend_Search_Lucene_Field::UnIndexed( 'key', $key));
      $this->addField(Zend_Search_Lucene_Field::Text( 'title', $title));
      $this->addField(Zend_Search_Lucene_Field::UnStored( 'contents', $contents));
      $this->addField(Zend_Search_Lucene_Field::UnIndexed( 'summary', $summary));
      $this->addField(Zend_Search_Lucene_Field::Keyword( 'createdBy', $createdBy));
      $this->addField(Zend_Search_Lucene_Field::Keyword( 'dateCreated', $dateCreated));
    }
  }

La classe è molto semplice e contiene solo il costruttore a cui passeremo il valore dei campi del documento.

Il problema successivo è creare i documenti ed aggiungerli all’indice. Il seguente esempio, mostra come fare:

$index = Zend_Search_Lucene::open($path);
$doc = new Paesidelmondo_Search_Lucene_Document(
  $class, $key,
  $title, $contents,
  $summary, $createdBy, $dateCreated
);
$index->addDocument($doc);

Quello che adesso bisogna fare è ripetere questo codice per ogni classe modello a cui la funzionalità di ricerca debba essere applicata. Ogni modelo chiaramente conosce tutto a proposito dei dati da ricercare, quello che non sa è come aggiungere questi dati all’indice del motore di ricerca, in quanto, se lo sapesse, sarebbe troppo strettamente legato ad esso e renderebbe difficile un eventuale sostituzione del motore di ricerca con un altro. La soluzione di questo problema è l’utilizzo di un design pattern chiamato Observer Pattern

Observer Pattern

L’Observer Pattern utilizza il concetto di notifica. Un oggetto detto observer registra interesse verso un altro oggetto, detto observable e quando qualcosa succede ad observable, l’oggetto observer prende le azioni appropriate. Le nostre classi observable sono i nostri modelli ed i dati a cui siamo interessati sono istanze di Zend_Db_Table_Row_Abstract, quindi la estendiamo creando Paesidelmondo_Db_Table_Row_Observerable.

  class Paesidelmondo_Db_Table_Row_Observerable extends Zend_Db_Table_Row_Abstract {
    protected static $_observers = array();

    public static function attachObserver($class){
      if (!is_string($class) || !class_exists($class) || !is_callable(array($class , 'observeTableRow'))) {
        return false;
      }
      if (!isset(self::$_observers[$class])) {
        self::$_observers[$class] = true;
      }
      return true;
    }

    public static function detachObserver($class){
      if (!isset(self::$_observers[$class])) {
        return false;
      }
      unset(self::$_observers[$class]);
      return true;
    }

    protected function notifyObservers($event){
      if (!empty(self::$_observers)) {
        foreach (array_keys(self::$_observers) as $observer) {
          call_user_func(array($observer , 'observeTableRow'), $event, $this);
        }
      }
    }

    protected function _insert(){
      self::notifyObservers('pre-insert');
    }

    protected function _postInsert(){
      self::notifyObservers('post-insert');
    }

    protected function _update(){
      self::notifyObservers('pre-update');
    }

    protected function _postUpdate(){
      self::notifyObservers('post-update');
    }

    protected function _delete(){
      self::notifyObservers('pre-delete');
    }

    protected function _postDelete(){
      self::notifyObservers('post-delete');
    }
  }

Questa classe contiene la proprietà statica $_observers in quanto la lista degli observers è indipendente dal modello, quindi per qualsiasi modello deve poter essere recuperata la stassa lista di observers. Il metodo statico attachObserver è quello che registra un oggetto observer e lo inserisce all’interno dell’array statico solo dopo aver effettuato alcuni controlli. La registrazione dell’oggetto observer dev’essere fatta nel bootstrap, vedremo tra non molto l’oggetto observer ed il codice da inserire nel bootstrap.

Il metodo detachObserver serve a rimuovere un observer precedentemente registrato e quindi giungiamo al metodo notifyObservers che richiama il metodo observeTableRow per ogni observer presente nell’array degli observer registrati, passandogli inoltre, il nome dell’evento e l’istanza del modello che ha scatenato l’evento.

L’oggetto Observer

L’oggetto che utilizzeremo come observer si chiamerà SearchIndexer ed in quanto è un modelo sarà salvato in application/models

application/models/SearchIndexer

  class SearchIndexer { 

    protected static $_indexDirectory;

    public static function setIndexDirectory($directory){
    	if(!is_dir($directory)) {
    		throw new Exception('Directory for SearchIndexer is invalid ('. $directory .')');
    	}
    	self::$_indexDirectory = $directory;
    }

    public static function getIndexDirectory(){
    	return self::$_indexDirectory;
    }

    public static function observeTableRow($event, $row){
      switch($event){
        case 'post-insert':
        case 'post-update':
          $doc = self::getDocument($row);
          if ($doc !== false){
            self::_addToIndex($doc);
          }
        break;
      }
    }

    public static function getDocument($row) {
      if(method_exists($row, 'getSearchIndexFields')){
        $fields = $row->getSearchIndexFields($row);
        $doc = new Paesidelmondo_Search_Lucene_Document(
          $fields['class'], $fields['key'],
          $fields['title'], $fields['contents'],
          $fields['summary'], $fields['createdBy'],
          $fields['dateCreated']
        );
        return $doc;
      }
      return false;
    }

    protected static function _addToIndex($doc){
      try {
        $index = Paesidelmondo_Search_Lucene::open(self::$_indexDirectory);
      } catch (Exception $e) {
        $index = Paesidelmondo_Search_Lucene::create(self::$_indexDirectory);
      }
      $index->addDocument($doc);
      $index->commit();
    }
  }

L’oggetto SearchIndexer è l’oggetto observer dell’oggetto Paesidelmondo_Db_Table_Row_Observerable, che quindi è l’oggetto observable. I modelli row level per cui vogliamo implementare la funzionalità di ricerca estendono Paesidelmondo_Db_Table_Row_Observerable, quindi ognuno di essi è un oggetto observable.

SearchIndexer contiene al suo interno i seguenti etodi statici, vediamoli nel dettaglio:

• setIndexDirectory definisce dove nel filesystem sarà memorizzato l’indice. Da utilizzarsi nel bootstrap.
• observeTableRow ogni volta che un oggetto observable viene modificato o creato, observeTableRow viene avvisato, rendendo disponibili il tipo di evento scatenato e l’oggetto observable. Quindi, in base all’evento, possono essere effettuate delle modifiche all’indice, come per esempio l’aggiunta all’indice.
• getDocument questo metodo controlla se l’oggetto $row ( oggetto observable ) possiede un metodo getSearchIndexField. In caso positivo un documento valido per l’aggiunta all’indice viene ritornato.
• _addToIndex questo metodo si occupa di aggiungere il documento al’indice

Ora non ci resta che vedere un esempio di un modello observable che estenda Paesidelmondo_Db_Table_Row_Observerable, a questo scopo creeremo la classe Paese, il modello row level dell’oggetto Paesi.

application/models/Paese

  class Paese extends Paesidelmondo_Db_Table_Row_Observerable
  {
    public function getSearchIndexFields(){
      $user = $this->findParentRow('Utenti');
      $reviews = $this->findRecensioni();
      $result = array();
      $result['class'] = 'Paese';
      $result['key'] = $this->id;
      $result['title'] = $this->nome;
      $result['contents'] = $this->provincia;
      foreach ($reviews as $review) {
        $result['contents'] .= "\n".$review->descrizione;
      }
      $result['summary'] = substr($review->descrizione,0,40);
      $result['createdBy'] = $user->name;
      $result['dateCreated'] = $this->inserimento_data;
      return $result;
    }

    protected function _insert(){
      if(is_null($this->created_by)) {
        $user = Zend_Auth::getInstance()->getIdentity();
        $this->created_by = (int)$user->id;
      }
      if(is_null($this->date_created)) {
        $this->date_created = date('Y-m-d H:i:s');
      }
      if(is_null($this->date_updated)) {
        $this->date_updated = date('Y-m-d H:i:s');
      }
      parent::_insert();
    }

    protected function _update(){
      $this->date_updated = date('Y-m-d H:i:s');
      parent::_update();
    }
  }

Il metodo getSearchIndexFields() ritorna un array contenente i dati utili per la creazione di una istanza di Zend_Search_Lucene_Document. Ogni modello contenente dati indicizzabili dovrebbe contenere questo metodo, in quanto è quello che si occupa di unificare i campi dei dati con i campi del design dell’indice. Questo metodo è quello che viene richiamato dal metodo SearchIndexer::getDocument ogni volta che un oggetto observable avverte l’observe che una modifica è avvenuta. Ad ogni chiamata dei metodi _insert e _update, l’omonimo metodo della classe parente ( Paesidelmondo_Db_Table_Row_Observerable ) viene chiamato, e questo si occuperà di inviare notifica all’observer indicado l’evento scatenante.

Il Bootstrap

Nel nostro file di bootstrap ( index.php nella root ), dovremo aggiungere le seguenti linee di codice:

  SearchIndexer::setIndexDirectory(ZEND_ROOT.'/var/search_index');
  Paesidelmondo_Db_Table_Row_Observerable::attachObserver('SearchIndexer');

Queste definiscono dove nel filesystem salvare l’indice e registrano l’oggetto SearchIndexer come oggetto observer per le istanze di Paesidelmondo_Db_Table_Row_Observerable, i modelli observable.

Infine, avrete sicuramente notato che sia per l’evento di inserimento che per l’evento di modifica SearchIndexer::observeTableRow aggiunge l’oggetto nell’indice, ma non lo modifica mai. Questo comportamento perchè Zend_Search_Lucene lo estenderemo in modo tale che il metodo addDocument, prima di effettuare un inserimento di un documento nell’indice controlli la sua esistenza, ed in caso, lo elimini prima di reinserirlo.

  class Paesidelmondo_Search_Lucene extends Zend_Search_Lucene { 

    public static function create($directory){
      return new Zend_Search_Lucene_Proxy(new Paesidelmondo_Search_Lucene($directory, true));
    }

    public static function open($directory){
      return new Zend_Search_Lucene_Proxy(new Paesidelmondo_Search_Lucene($directory, false));
    }

    public function addDocument(Zend_Search_Lucene_Document $document){
      // check document doesn't already exist - docRef should be unique
      $docRef = $document->docRef;
      $term = new Zend_Search_Lucene_Index_Term($docRef, 'docRef');
      $query = new Zend_Search_Lucene_Search_Query_Term($term);
      $results = $this->find($query);
      if(count($results) > 0) {
        foreach($results as $result){
          $this->delete($result->id);
        }
      }
      return parent::addDocument($document);
    }
  }

Nel caso non lo abbiate notato, sarà chiamato Paesidelmondo_Search_Lucene piuttosto che Zend_Search_Lucene in quanto in SearchIndexer::_addToIndex viene richiamata la prima e non la seconda, quindi la nuova funzionalità di addDocument è già presente nel codice postato senza dover effettuare altre modifiche.

Il controller searchController

Ogni volta che si effettuerà una ricerca, il risultato di questa sarà visualizzato dall’index action del searchController. Inoltre il searchController conterrà la reindexAction, action con la quale si potranno reindicizzare tutti i documenti indicizzabili.

application/controllers/SearchController.php

  class SearchController extends Zend_Controller_Action {
    public function init(){
      $response = $this->getResponse();
      $response->insert('header', $this->view->render('header.phtml'));
      $response->insert('menu', $this->view->render('menu.phtml'));
      $response->insert('columnLeft', $this->view->render('columnLeft.phtml'));
      $response->insert('columnRight', $this->view->render('columnRight.phtml'));
      $response->insert('footer', $this->view->render('footer.phtml')); 

      // [ eventuale controllo di verifica ACL ]
    }

    public function indexAction() {
      $this->view->title = 'Search Results';
      $filters = array('q' => array('StringTrim' , 'StripTags'));
      $validators = array('q' => array('presence' => 'required'));
      $input = new Zend_Filter_Input($filters, $validators, $_GET);
      if ($input->isValid()) {
        $this->view->messages = '';
        $q = $input->getEscaped('q');
        $this->view->q = $q;
        try {
          $index = Paesidelmondo_Search_Lucene::open(SearchIndexer::getIndexDirectory());
          $results = $index->find($q);
        } catch (Exception $e) {
          $results = array();
        }
        $this->view->results = $results;
      } else {
        $this->view->messages = $input->getMessages();
      }
    }

    public function reindexAction(){
    	$this->view->title = 'Search Reindex';
    	$messages = array();
    	$index = Paesidelmondo_Search_Lucene::create(SearchIndexer::getIndexDirectory());
    	$paesidelmondo = new Paesi();
    	$paesi = $paesidelmondo->fetchAll();
    	foreach($paesi as $paese) {
    		$doc = SearchIndexer::getDocument($paese);
    		$index->addDocument($doc);
    		$messages[] = 'Added Place: ' . $doc->title . ' - docRef: ' . $doc->docRef;
    	}
    	$messages[] = '';
    	$index->commit();
    	$messages[] = 'Total documents in index: ' . $index->numDocs();
    	$this->view->messages = $messages;
    }
  }

Le seguenti sono le view rispettivamente per la index e la reindex action

index.phtml

  <h1><?php echo $this->escape($this->title);?></h1>

  <?php if ($this->messages) : ?>
    <div id="error">
      There was a problem:
      <ul>
        <?php foreach ($this->messages['q'] as $message) : ?>
        <li><?php echo $message;?></li>
        <?php endforeach; ?>
      </ul>
    </div>
  <?php else  >
    <p>You searched for <?php echo $this->escape($this->q); ?>.
    <?php echo count($this->results);?> results found.
    </p>

    <ul>
      <?php foreach ($this->results as $result) : ?>
      <li><a href="<?php echo $this->getSearchResultUrl($result->class, $result->key); ?>">
        <?php echo $this->escape($result->title);?></a>
        <div class="summary">
        <?php echo $this->escape($result->summary);?>
        (<?php echo $result->score;?>) </div>
      </li>
      <?php endforeach; ?>
    </ul>

  <?php endif; ?>

reindex.phtml

<h1><?php echo $this->escape($this->title);?></h1>

<?php foreach ($this->messages as $message) : ?>
<?php echo $this->escape($message); ?><br />
<?php endforeach; ?>

Per concludere ecco il codice del form da inserire dove volete, per esempio nell’header.php, in modo tale che sia sempre visibile in ogni pagina

<div style="float: right;">
<h3>Search:</h3>
<form method="get" action="<?php echo $this->baseUrl;?>/search">
 <fieldset>
  <legend>Ricerca</legend>
  <label for="text">Nome Utente:</label><input type="text" name="q" value="">
  <input type="submit" name="search" value="Go">
 </fieldset>
</form>
</div>

Si conclude qui la guida al componente Zend_Search_Lucene, ma come spesso accade, non tutto è stato detto! La parte sui possibili identificatori utilizzabili nelle stringhe query e su come effettuare i vari tipi di queries ( Multi-Term Query, Wildcard ecc ) è stata volutamente tralasciata e sarà ripresa in futuro.

Related posts:

1. Luke: Lucene Index Toolbox di Andrzej Bialecki per Zend_Search_Lucene Verificare il contenuto dell'indice di Lucene Se avete seguito questo...
2. Neobazaar annunci gratuiti: esempio di una applicazione sviluppata con Zend Framework Nasce Neobazaar.com, annunci gratuiti in Italia: interamente sviluppato con Zend...
3. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...

Related posts brought to you by Yet Another Related Posts Plugin.

L’autorizzazione è quel processo in cui il sistema stabilisce se un utente loggato ha o meno accesso ad una determinata risorsa. In Zend Framework il processo di autorizzazione è gestito dall’oggetto Zend_Acl ( Access Control List ) .

Prima di procedere con l’implementazione vera e propria, introduciamo alcuni termini che saranno spesso utilizzati parlando di autorizzazione:

• Role: con il termine Role ( Ruolo o Gruppo ) si indica un gruppo di utenti
• Resource: con il termine si indica una risorsa del sistema, come una determinata action di un certo controller o anche solo un dato record, come potrebbe essere una pagina di un sito.
• Privilege: il tipo di accesso richiesto. Per privilegio si intende read, update, insert ecc

Un ruolo definisce il livello di attività che un utente può compiere all’interno del sistema, i ruoli in zend framework sono gestiti dall’oggetto Zend_Acl_Role, come nel seguente esempio:

$gruppoUtente = new Zend_Acl_Role('utente'); 

Con la precedente linea di codice abbiamo creato un oggetto che definisce un nuovo gruppo all’interno del sistema, il gruppo ‘utenti’ nel nostro caso, che successivamente andrà aggiunto all’oggetto Zend_Acl. Da notare che il nome del gruppo una volta creato non può essere più modificato e deve essere un nome unico.

$acl = new Zend_Acl();
$acl->addRole($gruppoUtente);

Per ogni ruolo può essere definito un ruolo padre, in modo tale che, il nuovo ruolo creato potrà fare tutto quello che il ruolo parent poteva fare seguendo il concetto di ereditarietà.

$acl = new Zend_Acl();
$acl->addRole(new Zend_Acl_Role('utente'));
$acl->addRole(new Zend_Acl_Role('moderatore'), 'utente');

In questa situazione il gruppo ‘moderatore’ può compiere qualsiasi azione legata al gruppo ‘utente’ oltre che compiere tutte le azioni ad esso direttamente legate.

Una risorsa è un contenuto in cui vogliamo stabilire e differenziare le regole di accesso. La creazione di una risorsa segue lo stesso procedimento della creazione di un ruolo, l’oggetto che gestisce le risorse è Zend_Acl_Resource. Poniamo il caso di voler creare la risorsa di un possibile forum del nostro sistema:

$forumResource = new Zend_Acl_Resource('forum');

Come per quanto riguarda i ruoli, anche le risorse vanno aggiunte all’oggetto Zend_Acl, in maniera molto simile per i ruoli, come da questo esempio:

$acl = new Zend_Acl();
$acl->addRole(new Zend_Acl_Role('utente'));
$acl->addRole(new Zend_Acl_Role('moderatore'), 'utente');
$acl->addResource(new Zend_Acl_Resource('forum'));
$acl->addResource(new Zend_Acl_Resource('posts'), 'forum');
$acl->addResource(new Zend_Acl_Resource('threads'), 'forum');

In questo esempio abbiamo creato la risorsa forum, da cui discendono le risorse post e threads. Se noi volessimo mappare le risorse all’interno del nosro sistema, la risorsa ‘forum’ sarebbe il controller, ‘posts’ e ‘threads’ sarebbero le actions.

La parte finale del settaggio dello Zend_Acl riguarda la gestione dei privilegi, che vengono attribuiti tramite lìutilizzo dei metodi allow() e deny() come nel seguente esempio

$acl->allow('utente', 'forum', 'read');
$acl->allow('moderatore', 'forum', array('update', 'blacklist');

In questo esempio abbiamo attribuito il permesso di lettura al forum per il gruppo ‘utente’ ed inoltre i permessi ‘update’ e ‘blacklist’ per il gruppo ‘moderatore’. Essendo direttamente discendente dal gruppo ‘utente’, il gruppo ‘moderatore’ eredita i permessi del gruppo padre, in modo tale da aver attribuito il permesso di lettura per la risorsa forum.

Applicazione della teoria

Il seguente è un esempio dello schema delle tabelle da utilizzare per l’integrazione pratica di Zend_Acl all’interno del sistema.

Niente paura, qui potete scaricare il file sql contenente il codice per la creazione di queste tabelle con inclusi i record dei roles, della risorsa index_index in lettura ed eliminazione e l’attribuzione del privilegio lettura per il gruppo superadministrator ( a voi inserire il resto ).

Passiamo ora alla implementazione vera e propria. Prima di tutto dovremo creare una directory all’interno della directory ‘library’ di Zend Framework, questa cartella dovrà avere lo stesso nome del nostro progetto, in questo caso Paesidelmondo. All’interno di questa directory creiamo un file chiamato Acl.php che conterrà l’oggetto Paesidelmondo_Acl che estenderà Zend_Acl.

Paesidelmondo_Acl si occuperà di inserire i ruoli presenti nel database all’interno dell’oggetto Zend_Acl.

Acl.php

< ?php

  class Paesidelmondo_Acl extends Zend_Acl
  {
    public function __construct() {
      $db = Zend_Registry::get('db');
      $rolesArray = Array();
      $query = "SELECT a.acl_role_name, b.acl_role_name AS acl_role_parent_name FROM
      ( acl_role a LEFT JOIN acl_role b ON a.acl_role_parent_id = b.acl_role_id ) ORDER BY a.acl_role_sort ASC";
      $tbRoleRowset = $db->fetchAll($query);
      foreach($tbRoleRowset AS $k => $v){
        if(!array_key_exists($v["acl_role_name"],$rolesArray)){
          $rolesArray[$v["acl_role_name"]] = Array($v["acl_role_parent_name"]);
        }else{
         array_push($rolesArray[$v["acl_role_name"]],$v["acl_role_parent_name"]);
        }
      }
      $this->_addRoles($rolesArray);
    }

    protected function _addRoles($roles){
      foreach($roles as $name => $parents){
        if (!$this->hasRole($name)){
          $parents = $parents[0] === null ? null : $parents;
          $this->addRole(new Zend_Acl_Role($name), $parents);
        }
      }
    }
  }

Il codice di questo oggetto non credo abbia bisogno di molte spiegazioni, segue le regole dette in precedenza sull’aggiunta dei ruoli all’interno di Zend_Acl, recuperandoli dal database. Questo oggetto sarà istanziato nel nostro file bootstrap, tramite l’aggiunta di questa linea di codice:

$acl = new Paesidelmondo_Acl();

A questo punto sorge spontanea una domanda: e le risorse?

Per evitare inutili sprechi di memoria e di elaborazioni le risorse non saranno caricate in Zend_Acl nella loro totalità ad ogni nuova chiamata. Invece, le risorse saranno inserite in Zend_Acl tenendo conto del controller e dell’action richiesta dall’utente. L’applicazione di questa teoria può essere svolta tramite la creazione di un action helper.

Un Action Helper si inserisce nell’MVC dispatch system al controller level, permettendoci di accedere alle regole dell’Acl prima che il metodo preDispatch() del controller sia chiamato. Questo avviene prima della esecuzione della action e quindi è il luogo ideale per effettuare il controllo.
Inoltre possiamo utilizzare sempre il medesimo helper per inserire la risorsa corrente all’interno di Zend_Acl nonchè abilitare i privilegi per il gruppo a cui appartiene l’utente corrente.

L’action controller si chimerà Paesidelmondo_Controller_Action_Helper_Acl ed estenderà Zend_Controller_Action_Helper_Abstract

Paesidelmondo/Controller/Action/Helper/Acl.php

< ?php

  class Paesidelmondo_Controller_Action_Helper_Acl extends Zend_Controller_Action_Helper_Abstract
  {
    protected $_db;
    protected $_action;
    protected $_auth;
    protected $_acl;
    protected $_controllerName;
    protected $_actionName;
    protected $_resourceName;
    protected $_privileges = Array();
    protected $_roleIds = Array();

    public function __construct(Zend_View_Interface $view = null, array $options = array() ) {
      $this->_auth = Zend_Auth::getInstance();
      $this->_db = Zend_Registry::get('db');
      $this->_acl = $options['acl'];
    }

    public function init(){
      // Ricaviamo controller, action e creiamo il nome risorsa
      $this->_action = $this->getActionController();
      $this->_controllerName = $this->_action->getRequest()->getControllerName();
      $this->_actionName = $this->_action->getRequest()->getActionName();
      $this->_resourceName = $this->_controllerName."_".$this->_actionName;

      // Aggiungiamo la risorsa in Zend_Acl
      // ATTENZIONE: la possibilità di indicare il parent non è stata presa in considerazione!
      if(!$this->_acl->has($this->_resourceName)){
        $this->_acl->add(new Zend_Acl_Resource($this->_resourceName));
      }

      // Ricaviamo il ruolo dell'utente loggato, altrimenti gli attribuiamo 'guest' id = 1
      list($roleId,$userRole) = $this->getUserRole();

      // Aggiungiamo $roleId nell'array che comprenderà anche i suoi id parente
      $this->_roleIds[] = $roleId;

      // Aggiungiamo gli id parente in $this->_roleIds
      $this->fillRoleIds($userRole);

      // Inseriamo i privilegi per l'utente corrente in $this->_privileges
      $this->fillPrivileges($this->_roleIds);

      // Cicliamo l'array ottenuto per inserire i privilegi di questo gruppo per la risorsa corente all'interno di Zend_Acl
      foreach($this->_privileges AS $k => $v){
        $this->$k($userRole,$v);
      }
    }

    public function getUserRole(){
      if($this->_auth->hasIdentity()){
        $user = $this->_auth->getIdentity();
        $roleId = (int)$user->id_gruppo;
        $query = "SELECT acl_role_name FROM acl_role WHERE acl_role_id = '".$roleId."' ";
        $tbRoleRowset = $this->_db->fetchAll($query);
        $userRole = $tbRoleRowset[0]["acl_role_name"];
      }else{
        $roleId = 1;
        $userRole = 'guest';
      }
      return array($roleId,$userRole);
    }

    protected function fillPrivileges($roleIds){
      $roleIds = is_array($roleIds) ? implode(",",$roleIds) : $roleIds;
      $query = "SELECT c.acl_privilege_name AS privilege, c.acl_privilege_type AS type, e.acl_role_parent_id AS parent FROM (((( acl_controller a LEFT JOIN acl_resource b ON a.acl_controller_id = b.acl_controller_id )
                LEFT JOIN acl_privilege c ON b.acl_resource_id = c.acl_resource_id )
                LEFT JOIN acl_role_privilege d ON c.acl_privilege_id = d.acl_privilege_id )
                LEFT JOIN acl_role e ON d.acl_role_id = e.acl_role_id )
                WHERE a.acl_controller_name = '".$this->_controllerName."' AND b.acl_resource_name = '".$this->_actionName."'
                AND e.acl_role_id IN(".$roleIds.") ";
      $privileges = $this->_db->fetchAll($query);
      foreach($privileges AS $k => $v){
        $this->_privileges[$v['type']][] = $v['privilege'];
      }
    }

    protected function fillRoleIds($roleName){
      $query = "SELECT a.acl_role_parent_id, b.acl_role_name FROM acl_role a LEFT JOIN acl_role b ON a.acl_role_parent_id = b.acl_role_id WHERE a.acl_role_name = '".$roleName."' ";
      $parents = $this->_db->fetchAll($query);
      foreach($parents AS $k => $v){
        if(!in_array($v['acl_role_parent_id'],$this->_roleIds)){
          $this->_roleIds[] = $v['acl_role_parent_id'];
        }
        if($v['acl_role_parent_id'] > 0){
          $this->fillRoleIds($v['acl_role_name']);
        }
      }
    }

    public function allow($roles = null, $actions = null) {
      $resource = $this->_resourceName;
      //echo 'allow '.$roles.' to '.implode(',',$actions).' '.$resource.'';
      $this->_acl->allow($roles, $resource, $actions);
      return $this;
    }

    public function deny($roles = null, $actions = null) {
      $resource = $this->_resourceName;
      //echo 'deny '.$roles.' to '.implode(',',$actions).' '.$resource.'';
      $this->_acl->deny($roles, $resource, $actions);
      return $this;
    }

    public function getAcl(){
      return $this->_acl;
    }
  }

Il codice è commentato e quindi dovrebbe essere abbastanza comprensibile. L’unica nota è per il metodo fillRoleIds, che si ricava tutti i parent dell’attuale gruppo utente in modo da ereditare eventuali privilegi ad essi associati.

Per poter utilizzare questo helper dobbiamo registrarlo. Subito dopo aver creato l’oggetto acl nel bootstrap aggiungiamo le seguenti 2 righe di codice:

  $aclHelper = new Paesidelmondo_Controller_Action_Helper_Acl(null, array('acl'=> $acl));
  Zend_Controller_Action_HelperBroker::addHelper($aclHelper);

Infine non ci manca che modificare il metodo init dei controller in cui vogliamo effettuare il controllo dei permessi. Il seguente è il codice del metodo init() dell’indexController:

    public function init(){
      $response = $this->getResponse();
      $response->insert('header', $this->view->render('header.phtml'));
      $response->insert('menu', $this->view->render('menu.phtml'));
      $response->insert('columnLeft', $this->view->render('columnLeft.phtml'));
      $response->insert('columnRight', $this->view->render('columnRight.phtml'));
      $response->insert('footer', $this->view->render('footer.phtml')); 

      $request = $this->getRequest();
      $resourceName = $request->getControllerName().'_'.$request->getActionName();

      $errorMessage = "";
      $acl = $this->_helper->_acl->getAcl();
      list($roleId,$userRole) = $this->_helper->_acl->getUserRole();
      $readPrivilege = $acl->isAllowed($userRole, $resourceName, 'read');

      if(!$acl->hasRole($userRole)){
        $errorMessage.= "

Il ruolo utente non esiste, permesso negato

";
      }
      if(!$readPrivilege){
        $errorMessage.= "

ERRORE: Accesso Negato

";
      }
      /*
      if(!$acl->has($resourceName)){
        $errorMessage.= "

La risorsa ".str_replace("_","/",$resourceName). "non esiste!

";
      }
      */

      if(!empty($errorMessage)){
        Zend_Layout::getMvcInstance()->getView()->errorMessage = $errorMessage;
        $request->setControllerName('error');
        $request->setDispatched(false);
      }
    }

In questo caso abbiamo verificato se il gruppo dell’attuale utente possiede i permessi in lettura per la risorsa. Nel database non abbiamo attribuito questo permesso a nessun ruolo, quindi inevitabilmente saremo redirezionati all’errorController che visualizzerà il messaggio di errore ( se non lo avete, create il file index.phtml negli script della vista relativi all’errorController ).

Come potete notare abbiamo utilizzato 2 metodi mai visti prima d’ora di Zend_Acl: hasRole e has. Il primo controlla se il gruppo utente è realmente esistente ( quindi se è stato inserito in Zend_Acl quando questo è stato istanziato OVVERO se è presente nel database ), mentre il secondo controlla se la risorsa è effettivamente presente. In questo caso ho commentato quella porzione di codice in quanto il nostro acl helper attualmente aggiunge la risorsa senza controllare della sua esistenza nel database. Questo perchè non sarebbe di utilità, infatti se la risorsa non esistesse non arriveremo mai a eseguire quel codice ma il sistema ci avvertirebbe della non presenza dello script ( ma solo alla situazione attuale, in cui abbiamo settato $frontController->throwExceptions(true); nel nostro bootstrap ). Vedremo prossimamente come reindirizzare eventuali chiamate a controller non esistenti.

Con questo si conclude questo tutorial, che non voleva spiegare l’implementazione definitiva di Zend_Acl per ogni caso, ma solo una possibile sua implementazione ( funzionante ). Alcune cose sono state volutamente tralasciate, come l’ereditarietà tra risorse o la creazione dei modelli per le nuove tabelle del database. Per eventuali domande, dimenticanze o suggerimenti il consiglio è sempre quello di scrivere qui sotto.

Related posts:

1. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...
2. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...
3. Zend Framework: introduzione al componente Zend_Form Creare form web con Zend Form Con Zend Framework possiamo...

Related posts brought to you by Yet Another Related Posts Plugin.

Nel codice che componeva le classi per la gestione delle tabelle del nostro database avrete notato la presenza delle proprietà $_name, $_referenceMap e $_dependentTables.
Vediamole nel dettaglio

La proprietà $_name serve a salvare internamente ad una classe il nome della tabella a cui questa è relazionata. Infatti, in caso di omissione di questa proprietà, il sistema andrebbe a cercare una tabella con lo stesso nome della classe, preservando le lettere maiuscole/minuscole. Per fare un esempio, se $_name fosse omessa nella classe Utenti, la tabella Utenti sarebbe ricercata dal sistema e questo genererebbe un errore. Siccome per convenzione nominiamo le nostre classi con la prima lettera maiuscola , la proprietà $_name ci viene incontro per salvare il nome corretto della tabella.

Vediamo adesso il codice della classe Recensioni. Questa classe è l’unica a contenere la proprietà $_referenceMap. Questa proprietà è un array che serve ad indicare a quale classe relazionare le foreign keys presente nella tabella in questione e nel nostro caso, la tabella recensioni è l’unica a contenere foreign keys. Le chiavi di questo array conterranno il nome della relazione ( rules ) ed il loro valore sarà un array contenente la foreign key, il nome della classe a cui la relazione si riferisce ed il nome della colonna di relazione, rispettivamente columns, refTableClass e refColumns.

$_referenceMap in Recensioni

    protected $_referenceMap = array(
      'Paesi' => array(
        'columns'           => array('id_paese'),
        'refTableClass'     => 'Paesi',
        'refColumns'        => array('id')
      ),
      'Utenti' => array(
        'columns'           => array('id_utente'),
        'refTableClass'     => 'Utenti',
        'refColumns'        => array('id')
      ) ,
      'Abilitazione' => array(
        'columns'           => array('id_utente_abilitazione'),
        'refTableClass'     => 'Utenti',
        'refColumns'        => array('id')
      )
    );

Infine $_dependentTables è un array che definisce la o le classi ( tabelle ) direttamente dipendenti. Nel caso di Utenti e Paesi il valore di $_dependentTables è un array contenente Recensioni

Esempi di utilizzo

Inseriamo quindi qualche esempio nel nostro IndexController, il seguente codice è un esempio di accesso ai dati del database al row level

$utenti = new Utenti;
$myself = $utenti->fetchRow('id = 1');
$this->view->myself = $myself->name;

Il metodo fetchRow() ritorna una istanza della classe Utente, mentre name richiama l’omonimo metodo, la possibilità di effettuare una chiamata ad un metodo come se si trattasse di una proprietà l’abbiamo aggiunta tramite l’overload del metodo magico __get() ( ricordate? ne abbiamo parlato lo scorso articolo ). Per visualizzare la variabile ottenuta aggiungeremo in index.phtml la seguente linea

<p>Utente ID 1: <?php echo $this->myself;?> </p>

Il metodo findDependentRowset

Questo metodo serve per effettuare una relazione uno a molti ed utilizza le proprietà $_referenceMap e $_dependentTables. Di seguito un esempio di utilizzo

$paesi = new Paesi;
$paese= $paesi->fetchRow('id = 1');
$resOne = $paese->findDependentRowset( 'Recensioni');

Il metodo findManyToManyRowset

Questo metodo serve per effettuare una relazione molti a molti ed utilizza anch’esso le proprietà $_referenceMap e $_dependentTables di cui abbiamo parlato. Il primo argomento è la tabella di destinazione, metre il secondo argomento è la tabella di incrocio.

$utenti = new Utenti;
$myself = $utenti->fetchRow('id = 1');
$resOne = $myself->findManyToManyRowset( 'Paesi','Recensioni');

Il rowset risultante sarà composto da tutti i campi della tabella recensioni e da tutti i campi della tabella paesi, le righe selezionate ovviamente saranno quelle dove id_utente in recensioni è = a 1 ( l’utente selezionato da fetchRow() ). Questo metodo accetta eventuali regole definite in $_referenceMap. Infatti, in caso volessimo selezionare non le recensioni scritte dall’id 1 ma bensi le recensioni abilitate dall’utente id 1, il codice sarebbe il seguente

$utenti = new Utenti;
$myself = $utenti->fetchRow('id = 1');
$resOne = $myself->findManyToManyRowset( 'Paesi','Recensioni','Abilitazione');

Testate entrambe i casi eventualmente aggiungendo degli altri record al vostro database. Questo è il codice da inserire in index.phtml

<?php if(count($this->resOne)): ?>
<table>
<tr>
  <td>Id</td>
  <td>Nome</td>
  <td>Descrizione</td>
</tr>
<?php foreach($this->resOne as $p): ?>
<tr>
  <td><?php  echo $p->id; ?></td>
  <td><?php  echo $p->nome; ?></td>
  <td><?php echo $p->descrizione; ?></td>
</tr>
<?php endforeach;?>
</table>
<?php endif;?>

Si conclude così questa settima parte. Per ogni dubbio siete invitati ad utilizzare la funzionalità commento al termine di ogni articolo

Related posts:

1. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...
2. Zend Framework: introduzione al componente Zend_Form Creare form web con Zend Form Con Zend Framework possiamo...

Related posts brought to you by Yet Another Related Posts Plugin.

Ritorniamo sull’argomento modelli iniziato qualche articolo fa, in questo articolo tratteremo come recuperare i dati dal database con Zend Framework. Una volta creato l’oggetto $db tramite chiamata al metodo statico factory, potremo procedere in diversi modi.

Effettuare una query

Tramitel’utilizzo del metodo ‘query’ potremo eseguire direttamente la query da noi specificata sul database, ad esempio:

$data = $db->quote('1990-01-01');
$sql = 'SELECT * FROM utenti WHERE data_di_nascita > ' . $date;
$result = $db->query($sql);

Nel codice precedente abbiamo utilizzato il metodo ‘quote’ che effettua per noi l’inserimento degli apici in modo da creare una query corretta ed esente da pericoli di SqlInjections.
Tuttavia potrebbe capitare di dimenticare di usare quote quindi l’ideale potrebbe essere utilizzare il seguente metodo per scrivere una query corretta e sicura:

$sql = 'SELECT * FROM utenti WHERE data_di_nascita > ?'
$result = $db->query($sql, array('1990-01-01'));

In ogni caso, il $result sarà un oggetto su cui potremo effettuare le chiamate dei metodi fetch() e fetchAll() per il recupero dei dati.

Zend_Db_Select

Zend_Db_Select è un oggetto che ci viene in aiuto per costruire delle query per la selezione di dati utilizzando maggiormente il linguaggio php piuttosto che SQL. Prendendo in considerazione l’esempio precedente, il codice qui di seguito mostra come ottenere lo stesso risultato utilizzando questa classe:

$select = new Zend_Db_Select($db);
$select->from('utenti');
$select->where('data_di_nascita > ?', '1990-01-01');
$result = $select->query();

Inserimento, Modifica ed Eliminazione dei dati con Zend_Db_Adapter

Per effettuare queste operazioni, la classe Zend_Db_Adapter ci offre i metodi insert(), update() e delete() rispettivamente. Il loro utilizzo è decisamente semplice, creare un array associatico con chiave il nome del campo della nostra tabella e come valore appunto il valore che dovrà avere questo campo, e passarlo ai vari metodi sopra citati nei seguenti modi:

inserimento

  $data = array(,
    'nome' => 'Mark',
    'cognome' => 'Hollis',
    'inserimento_data' => date('Y-m-d')
  ); 

  $table = 'utenti';
  $rows_affected = $db->insert($table, $data);
  $last_insert_id = $db->lastInsertId();

modifica

  $data = array(,
    'paese' => 'United Kingdom'
  ); 

  $table = 'utenti';
  $where = $db->quoteInto('country = ?', 'UK');
  $db->update($table, $data, $where);

elimina

  $table = 'utenti';
  $where = 'id = 2';
  $rows_affected = $db->delete($table, $where);

Inserimento, Modifica ed Eliminazione dei dati con Zend_Db_Table

Un’interessante metodo per la gestione del database ci viene offerto dalla classe Zend_Db_Table. Questa classe gestisce ogni tabella del database come se fosse un oggetto. Prima di cominciare con gli esempi aggiungiamo una nuova tabella al nostro database

CREATE TABLE `utenti` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(99) NOT NULL,
  `password` varchar(32) NOT NULL,
  `nome` varchar(99) NOT NULL,
  `cognome` varchar(99) NOT NULL,
  `sesso` enum('M','F') default NULL,
  `data_di_nascita` datetime NOT NULL,
  `paese` varchar(99) default NULL,
  `cap` varchar(20) NOT NULL,
  `inserimento_data` datetime NOT NULL,
  `inserimento_user_id` int(11) NOT NULL,
  `inserimento_ip` varchar(15) NOT NULL,
  `modifica_data` timestamp NULL default NULL on update CURRENT_TIMESTAMP,
  `modifica_user_id` int(11) default NULL,
  `modifica_ip` varchar(15) default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=2 ;

INSERT INTO `utenti` (`id`, `username`, `password`, `nome`, `cognome`, `sesso`, `data_di_nascita`, `paese`, `cap`, `inserimento_data`, `inserimento_user_id`, `inserimento_ip`, `modifica_data`, `modifica_user_id`, `modifica_ip`) VALUES
(1, 'Razorblade', '0c88028bf3aa6a6a143ed846f2be1ea4', 'Sergio', 'Rinaudo', 'M', '1982-03-26 20:56:22', NULL, '10023', '2008-08-16 20:56:51', 1, '127.0.0.1', '2008-08-16 20:57:01', NULL, NULL);

Abbiamo dunque creato la tabella utenti, quindi possiamo procedere alla creazione della relativa classe. Questo nuovo file andrà salvato nella directory models

Utenti.php

<?php

  class Utenti extends Zend_Db_Table_Abstract
  {
    protected $_name = 'utenti';
    protected $_rowClass = 'Utente';
    protected $_dependentTables = array('Recensioni');
  }

In quanto Utenti estende Zend_Db_Table_Abstract come potete immaginare ne eredita i vari metodi e proprietà. Prima di procedere alla spiegazione di cosa siano le proprietà presenti all’interno della classe Utenti diamo uno sguardo su come effettuare le medesime operazioni di inserimento, modifica e update utilizzando Zend_Db_Table_Abstract

inserimento

  $utenti = new Utenti(); 

  $data = array(,
    'nome' => 'Mark',
    'cognome' => 'Hollis',
    'inserimento_data' => date('Y-m-d')
  ); 

  $id = $utenti->insert($data);

modifica

  $utenti = new Utenti(); 

  $data = array(,
    'paese' => 'United Kingdom'
  ); 

  $where = $db->quoteInto('country = ?', 'UK');
  $utenti->update($data, $where);

elimina

  $utenti = new Utenti(); 

  $where = 'id = 2';
  $utenti->delete($where);

Creazione dei nuovi modelli per l’applicazione

Prima di listare il codice delle classi delle altre tabelle del nostro database, ovvero recensioni e paesi, dobbiamo fare una precisazione sui livelli di accesso al database, che possono essere di due tipi: tabella e riga. Il primo livello di accesso è utlizzato quando dobbiamo creare dei listati di record, il secondo livello è utilizzato quando abbiamo a che fare con un singolo record della tabella.

Lavorando al secondo livello di accesso è inoltre possibile utilizzare il metodo save() in sostituzione di insert e update, il codice per effettuare entrambe le operazioni è molto simile:

inserimento

  $utenti = new Utenti();
  $riga = $utenti->fetchNew(); 

  $riga->nome = 'Mark';
  $riga->cognome = 'Hollis'; 

  $riga->save();

modifica

  $utenti = new Utenti();
  $riga = $utenti->fetchRow('id=2'); 

  $riga->nome = 'Mark';
  $riga->cognome = 'Hollis'; 

  $riga->save();

La classe Utenti da noi creata poco sopra agisce a livello di tabella. Al suo interno si trova una proprietà, $_rowClass, che indica il nome della classe per la gestione del secondo livello di accesso, ovvero Utente. Il seguente è il codice che ha attualmente Utente:

<?php

  class Utente extends Zend_Db_Table_Row_Abstract
  {
    public function name(){
      $name = trim($this->nome . ' ' . $this->cognome);
      if (empty($name)) {
        $name = $this->username;
      }
      return $name;
    }

    function __get($key)
    {
      if(method_exists($this, $key)){
        return $this->$key();
      }
      return parent::__get($key);
    }
  }

Come avrete sicuramente notato, il primo livello di accesso è gestito dalla classe Zend_Db_Table_Abstract mentre il secondo è gestito da Zend_Db_Table_Row_Abstract . Nella classe Utente abbiamo inserito due metodi, il primo serve a ricavare il nome dell’utente selezionato, il secondo è un metodo magico ( presto disponibile un articolo sui metodi magici su questo blog, fino ad allora vi consiglio una ricerca su google per saperne di più ) che ci da la possibilità di richiamare il metodo name come se fosse una proprietà ( omettendo le parentesi ).

Di seguito trovate il codice attuale delle classi Paesi e Recensioni, da inserire all’interno della directory models, assieme ad Utenti e Utente

Paesi

<?php

  class Paesi extends Zend_Db_Table
  {
    protected $_name = 'paesi';
    protected $_dependentTables = array('Recensioni');

    function fetchLatest($count = 10){
      return $this->fetchAll(null,'inserimento_data DESC', $count);
    }
  }

Recensioni

<?php 

  class Recensioni extends Zend_Db_Table_Abstract
  {
    protected $_name = 'recensioni';
    protected $_referenceMap = array(
      'Paesi' => array(
        'columns'           => array('id_paese'),
        'refTableClass'     => 'Paesi',
        'refColumns'        => array('id')
      ),
      'Utenti' => array(
        'columns'           => array('id_utente'),
        'refTableClass'     => 'Utenti',
        'refColumns'        => array('id')
      ) ,
      'Abilitazione' => array(
        'columns'           => array('id_utente_abilitazione'),
        'refTableClass'     => 'Utenti',
        'refColumns'        => array('id')
      )
    );
  }

Nel prossimo articolo continueremo il discorso sui modelli, spiegando nel dettaglio a cosa servono le proprietà $_referenceMap e $_dependentTables ed effettueremo dei test di visualizzazione.

Related posts:

1. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...
2. Neobazaar annunci gratuiti: esempio di una applicazione sviluppata con Zend Framework Nasce Neobazaar.com, annunci gratuiti in Italia: interamente sviluppato con Zend...
3. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...

Related posts brought to you by Yet Another Related Posts Plugin.

Premetto che il seguente è solo uno dei possibili metodi di usare ajax all’interno della vostra applicazione sviluppata con Zend Framework, ma sicuramente è il metodo che più mantiene il concetto di MVC. In questo articolo integreremo le richieste asincrone tramite l’uso di un framework javascript. Tra i vari framework javascript esistenti quello che personalmente preferisco è JQuery ed è quindi quello che utilizzerò in questo articolo. Purtroppo ad oggi non ho ancora scritto nessun articolo su questo fantastico framework, quindi se volete saperne di più o volete vedere subito qualche esempio non vi rimane che cercare su internet.

Giusto per completezza, esistono diversi altri framework javascript che gestiscono le richieste asincrone, tra cui Prototype, Script.aculo.us, YUI library di Yahoo! e diversi altri.

Recuperare JQuery

Potete scaricare l’ultima versione di JQuery dal sito ufficiale jquery.com/. Una volta scaricato il file questo dev’essere inserito nella cartella js presente nella web root del nostro progetto.

Layout.phtml

Il primo passo sarà l’aggiunta del framework javascript all’interno dell’applicazione. Per fare ciò aggiungeremo due righe di codice nel nostro file layout.phtml, che vi ricordo si trova all’interno di application\views\layouts

    <script type="text/javascript" src="<?php echo $this->baseUrl(); ?>/js/jquery.js" />
    <script type="text/javascript" src="<?php echo $this->baseUrl(); ?>/js/ajax.js" />

Header.phtml

Il prossimo file a subire modifiche sarà header.phtml. In questo file andremo ad aggiungere un breve form con un input di testo dove poter inserire il nome utente.

<h1>Paesidelmondo Header</h1>

<form action="#">
 <fieldset>
  <legend>Registratione</legend>
  <label for="name">Nome Utente:</label><input id="name" name="name" type="text" autocomplete="off" />
 </fieldset>
</form>
<div id="message"></div>

Ajax.js

Creiamo un file e chiamiamolo per comodità ajax.js. Questo conterrà il codice javascript che metterà in ascolto l’input di testo con l’evento keyup e che gestirà la richiesta asincrona, codice che ovviamente utilizza il framework JQuery che abbiamo aggiunto poco fa. Questo file è da salvare all’interno della cartella js. Il seguente è il codice.

  $(document).ready(function(){
    $("#name").bind('keyup',function(){
      var baseUrl = "http://localhost";
      var nome = $(this).val();
      var destUrl = baseUrl + "/asyncrequest/username/nome/" + nome;
      $.ajax({
        url: destUrl,
        type: 'GET',
        success:  function(responseText){
          $("#message").html(responseText);
        }
      });
    });
  });

Come potete notare voi stessi all’interno del codice è presente la stringa ‘/asyncrequest/username/nome/’, questo significa che nella nostra applicazione è presente un nuovo controller, asyncrequest che contiene una action chiamata username.

AsyncRequestController.php

Creiamo un nuovo file controller e chiamiamolo AsyncRequestController.php, che salveremo nella directory dei controllers, application\controllers. Il seguente sarà il suo contenuto

<?php
  class AsyncRequestController extends Zend_Controller_Action {

    public function usernameAction(){
      $utenti = array('zend', 'jquery', 'javascript');
      $username = $this->_request->getParam('nome');
      if ($username == ''){
        $return = '';
      }elseif (strlen($username) < 4){
        $return = '
Nome Utente troppo corto!';
      }elseif (in_array($username, $utenti)){
        $return = '
Utente già esistente

';
      }else{
        $return = '
Nome Utente Valido

';
      }
      $this->_response->appendBody($return);
      $this->_helper->layout->disableLayout();
    }

  }

Principalmente sono 2 i punti degni di nota in questo codice, $this->_response->appendBody($return); che inserisce nell’output il contenuto ritornato e $this->_helper->layout->disableLayout(); che disabilita il layout. Questo è indispensabile in quanto non vogliamo che ad ogni richiesta asincrona il sistema ci restituisca anche il layout.

Procediamo quindi con la creazione della view per la action che abbiamo appena creato, ovvero username.phtml.

username.phtml

Come abbiamo creato la directory index

all’interno della directory views\scripts per la gestione delle action dell’IndexController, procederemo a creare la directory asyncRequest nella stessa locazione, per la gestione delle views delle relative action.
La action username.phtml dovrà semplicemente visualizzare il contenuto di result, quindi il suo codice sarà semplicemente

<?php echo $this->result; ?>

main.css

Per concludere aggiungiamo una piccola porzione di codice nel nostro css per la gestione di due nuove classi che abbiamo appena inserito all’interno di ajax.js

	/**************************************************************************
	* Stili Generici
	**/

	.ok {
		color: green;
	}

    .error {
		color: red;
	}

Se avete eseguito correttamente ogni passaggio potrete amirare nel vostro header un form che vi restituirà un messaggio man mano che inserite dei caratteri all’interno dell’input di testo presente!

Termina così la quinta parte sullo sviluppo di una vera applicazione con zend framework, se qualcuno di voi ha domande può inviare un commento al termine di ogni articolo.

Related posts:

1. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...
2. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...
3. Zend Framework: introduzione al componente Zend_Form Creare form web con Zend Form Con Zend Framework possiamo...

Related posts brought to you by Yet Another Related Posts Plugin.

Eccoci giunti alla realizzazione del nostro primo modello.
Se non l’avete ancora fatto, dovrete creare il database paesidelmondo in cui andrete a creare 2 tabelle ed inserire alcuni dati. Niente paura, basta far eseguire la seguente query al vostro db e tutto sarà pronto per cominciare:

CREATE TABLE `paesi` (
  `id` int(11) NOT NULL auto_increment,
  `nome` varchar(99) NOT NULL,
  `provincia` varchar(99) NOT NULL,
  `inserimento_data` datetime NOT NULL,
  `inserimento_user_id` int(11) NOT NULL,
  `inserimento_ip` varchar(15) NOT NULL,
  `modifica_data` timestamp NULL default NULL on update CURRENT_TIMESTAMP,
  `modifica_user_id` varchar(11) default NULL,
  `modifica_ip` varchar(15) default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=3 ;

--
-- Dump dei dati per la tabella `paesi`
-- 

INSERT INTO `paesi` (`id`, `nome`, `provincia`, `inserimento_data`, `inserimento_user_id`, `inserimento_ip`, `modifica_data`, `modifica_user_id`, `modifica_ip`) VALUES
(1, 'Chieri', 'Torino', '2008-08-06 17:26:05', 1, '127.0.0.1', '2008-08-06 17:26:41', NULL, NULL),
(2, 'Pessione', 'Torino', '2008-08-06 17:26:32', 1, '127.0.0.1', '2008-08-06 17:26:41', NULL, NULL);

-- --------------------------------------------------------

--
-- Struttura della tabella `recensioni`
-- 

CREATE TABLE `recensioni` (
  `id` int(11) NOT NULL auto_increment,
  `id_paesi` int(11) NOT NULL,
  `descrizione` mediumtext NOT NULL,
  `inserimento_data` datetime NOT NULL,
  `inserimento_user_id` int(11) NOT NULL,
  `inserimento_ip` varchar(15) NOT NULL,
  `modifica_data` timestamp NOT NULL default '0000-00-00 00:00:00' on update CURRENT_TIMESTAMP,
  `modifica_user_id` int(11) default NULL,
  `modifica_ip` varchar(15) default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=3 ;

--
-- Dump dei dati per la tabella `recensioni`
-- 

INSERT INTO `recensioni` (`id`, `id_paesi`, `descrizione`, `inserimento_data`, `inserimento_user_id`, `inserimento_ip`, `modifica_data`, `modifica_user_id`, `modifica_ip`) VALUES
(1, 1, '

Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right at the coast of the Semantics, a large language ocean. A small river named Duden flows by their place and supplies it with the necessary regelialia.

\r\n\r\n

 It is a paradisematic country, in which roasted parts of sentences fly into your mouth. Even the all-powerful Pointing has no control about the blind texts it is an almost unorthographic life One day however a small line of blind text by the name of Lorem Ipsum decided to leave for the far World of Grammar.

\r\n\r\n

 The Big Oxmox advised her not to do so, because there were thousands of bad Commas, wild Question Marks and devious Semikoli, but the Little Blind Text didn’t listen. She packed her seven versalia, put her initial into the belt and made herself on the way. When she reached the first hills of the Italic Mountains, she had a last view back on the skyline of her hometown Bookmarksgrove, the headline of Alphabet Village and the subline of her own road, the Line Lane. Pityful a rethoric question ran over her cheek, then 

', '2008-08-06 17:27:44', 1, '127.0.0.1', '0000-00-00 00:00:00', NULL, NULL),
(2, 2, '

 Li Europan lingues es membres del sam familie. Lor separat existentie es un myth. Por scientie, musica, sport etc, litot Europa usa li sam vocabular. Li lingues differe solmen in li grammatica, li pronunciation e li plu commun vocabules. Omnicos directe al desirabilite de un nov lingua franca: On refusa continuar payar custosi traductores.

\r\n\r\n

 At solmen va esser necessi far uniform grammatica, pronunciation e plu sommun paroles. Ma quande lingues coalesce, li grammatica del resultant lingue es plu simplic e regulari quam ti del coalescent lingues. Li nov lingua franca va esser plu simplic e regulari quam li existent Europan lingues.

\r\n\r\n

 It va esser tam simplic quam Occidental in fact, it va esser Occidental. A un Angleso it va semblar un simplificat Angles, quam un skeptic Cambridge amico dit me que Occidental es. Li Europan lingues es membres del sam familie. Lor separat existentie es un myth. Por scientie, musica, sport etc, litot Europa usa li sam vocabular. Li lingues differe solmen in li grammatica, li pronunciation e li plu commun vocabules. Omnicos directe al desirabilite de un nov lingua franca: On refusa continuar payar custosi traductores. At solmen va esser necessi far uniform grammatica, pronunciation e plu sommun paroles. 

', '2008-08-06 17:28:21', 1, '127.0.0.1', '0000-00-00 00:00:00', NULL, NULL);

Il primo modello

Il primo modello che andremo ad implementare recupererà i dati all’interno della tabella ‘paesi’. Il file, chiamato Paesi.php deve essere creato all’interno di application\models. Il seguente è il suo contenuto:

< ?php

  class Paesi extends Zend_Db_Table
  {
    function fetchLatest($count = 10) {
      return $this->fetchAll(null,'inserimento_data DESC', $count);
    }
  }

Per fare in modo che tutto funzioni, il motore php sul nostro server dovrà avere caricato le estensioni php_pdo e php_pdo_mysql, in quanto, per questa applicazione, abbiamo specificato l’utilizzo del driver pdo nel file di configurazione config.ini.

Il metodo fetchAll

Il metodo fetchAll recupera tutte le righe e tutte le colonne di un resultset. Sintassi:

fetchAll($where, $order, $count, $offset);

Nel nostro esempio abbiamo inserito questo metodo all’interno di fetchLatest, nome che abbiamo dato ad un metodo che recupera gli ultimi X record inseriti ( 10 di default ).

IndexController

Modifichiamo quindi la indexAction del nostro IndexController.

    public function indexAction(){
      $this->view->pageTitle = 'Paesidelmondo Application Example';
      $this->view->bodyTitle = 'Paesidelmondo';
      $paesi = new Paesi();
      $this->view->paesi = $paesi->fetchLatest();
    }

In questo modo creiamo la variabile paesi all’interno della view ( $this->view->paesi ), contenente un array di oggetti che potremo ciclare nel nostro index.phtml.

Index.phtml

Il seguente è il nuovo contenuto di index.html

<h2>< ?php echo $this->escape($this->bodyTitle);?></h2>
< ?php // echo $this->bodyContent;?>

< ?php if(count($this->paesi)): ?>
<table>
< ?php foreach($this->paesi as $paese): ?>
<tr>
  <td><a href="<?php echo $this->baseUrl;?>/paese/< ?php
    echo $paese->id; ?>">< ?php
    echo $this->escape($paese->nome); ?></a></td>
  <td>< ?php echo $this->displayDate($paese->modifica_data); ?></td>
</tr>
< ?php endforeach;?>
</table>
< ?php endif;?>

Per comodità ho eliminato dalla visualizzazione il contenuto di bodyContent in modo da concentrarci meglio sui dati estrapolati dal database.
Il codice credo che sia autoesplicativo, l’unica nota da fare è sul metodo displayDate, metodo facente parte di un nuovo helper, DisplayDate.php da inserire all’interno di application\views\helpers

Display date

Il seguente è il codice di DisplyDate.php

< ?php

  class Zend_View_Helper_DisplayDate {
    function displayDate($time, $format='%d %B %Y'){
      $timestamp = strtotime($time);
      return strftime($format, $timestamp);
    }
  }

Questo metodo trasforma le date ritornate dal db in una data più facilmente leggibile.
Infine, prima di poter testare il tutto, aggiungiamo una semplice linea di codice al nostro bootstrap index.php, ovvero una nuova include_path, quella per i modelli.

  // Blocco 1
  [ ... ]

  // Blocco 1b
  set_include_path(ZEND_ROOT.'application/models'.PATH_SEPARATOR.get_include_path());

  [ ... ]

Non ci rimane che testare il tutto. Per qualsiasi domanda potete postare i vostri commenti al termine di ogni articolo.

Ovviamente non è finita qui.
Ancora non ho deciso cosa tratterà la quinta parte, che comunque sarà disponibile il più presto possibile.

Related posts:

1. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...
2. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...
3. Zend Framework: introduzione al componente Zend_Form Creare form web con Zend Form Con Zend Framework possiamo...

Related posts brought to you by Yet Another Related Posts Plugin.

Utilizzando le conoscenze acquisite, implementeremo ora un layout leggermente più complesso in modo da prendere realmente domestichezza con la Two Step View per poter quindi passare al vero passo successivo, ovvero la realizzazione del primo modello.

Aprimo il nostro IndexController, modificando il contenuto esistente con questo nuovo contenuto:

  class IndexController extends Zend_Controller_Action {
    public function init(){
      $response = $this->getResponse();
      $response->insert('header', $this->view->render('header.phtml'));
      $response->insert('menu', $this->view->render('menu.phtml'));
      $response->insert('columnLeft', $this->view->render('columnLeft.phtml'));
      $response->insert('columnRight', $this->view->render('columnRight.phtml'));
      $response->insert('footer', $this->view->render('footer.phtml'));
    }

    public function indexAction(){
      $this->view->pageTitle = 'Paesidelmondo Application Example';
      $this->view->bodyTitle = 'Paesidelmondo';
      $this->view->bodyContent = '

One morning, when Gregor Samsa woke [...]

';
    }
  }

Per evitare spreco di spazio ho omesso il contenuto di $this->view->bodyContent, che potete sostituire con ciò che vi pare. Abbiamo modificato il metodo init() inserendo all’interno del $response il contenuto dei file header.phtml, menu.phtml, columnLeft.phtml, columnRight.phtml e footer.phtml, file che creeremo all’interno di views\scripts e che conterranno:

header.phtml

Paesidelmondo Header

menu.phtml

Pagina 17
Pagina 18
Pagina 19
Pagina 20

columnLeft.phtml

Menù Sx

Pagina 1
Pagina 2
Pagina 3
Pagina 4
Pagina 5
Pagina 6
Pagina 7
Pagina 8

columnRight.phtml

Menù Dx

Pagina 9
Pagina 10
Pagina 11
Pagina 12
Pagina 13
Pagina 14
Pagina 15
Pagina 16

footer.phtml

Powered By Razorblade

layout.phtml

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
    <title><?php echo $this->escape($this->pageTitle); ?></title>
    <link rel="stylesheet" href="<?php echo $this->baseUrl(); ?>/css/main.css" type="text/css">
  </head>
  <body>
    <!-- start container -->
    <div id="container">

      <!-- start subContainer -->
      <div id="subContainer">

        <!-- start header -->
        <div id="header"><?php echo $this->layout()->header;?></div>
        <!-- end header -->

        <!-- start menu -->
        <div id="menu"><?php echo $this->layout()->menu;?></div>
        <!-- end menu -->

        <!-- start columnLeft -->
        <div id="columnLeft"><?php echo $this->layout()->columnLeft;?></div>
        <!-- end columnLeft -->

        <!-- start content -->
        <div id="content"><?php echo $this->layout()->content ?></div>
        <!-- end content -->

        <!-- start columnRight -->
        <div id="columnRight"><?php echo $this->layout()->columnRight;?></div>
        <!-- end columnRight -->

        <!-- start footer -->
        <div id="footer"><?php echo $this->layout()->footer;?></div>
        <!-- end footer -->

      </div>
      <!-- end subContainer -->

    </div>
    <!-- end container -->
  </body>
</html>

L’index.phtml può restare invariato, per completezza comunque questo è il codice che lo compone:

index.phtml

< ?php echo $this->bodyTitle ;?>

< ?php echo $this->bodyContent ;?>

Per finire posto il codice css:

main.css

	/**************************************************************************
	* Layout CSS
	* Scritto da Sergio Rinaudo
	* Validato W3C
	**/

	/**************************************************************************
	* Stili Generici
	**/

	* {
		margin:0;
		padding:0;
		border:0;
		border-style:solid;
	}  

	body {
		height: 100%;
		color: #85859c;
		font-family: tahoma, arial, sans-serif;
		font-size: 10px;
		text-align: center;
	}  

	h1 {
		margin:0px;
		padding:0px;
	}

	h2{
		margin:0px;
		padding:0px;
	}

	h3 {
		margin:0px;
		padding:0px;
	}

	h4 {
		margin:0px;
		padding:0px;
	}

	h5 {
		margin:0px;
		padding:0px;
	}

	h6 {
		padding:0px;
		margin:0px;
	}

	ul {
		list-style-type:none;
		margin:0px;
		padding:0px;
	}

	li {
		margin:0px;
		padding:0px;
		list-style-type:none;
	}

	div {
		margin:0px;
		padding:0px;
	}

	p {
		margin:0px;
		padding:0px;
	}

	a {
		text-decoration:none;
		color:#0e7bb7;
	}

	a:hover {
		margin:0px ;
		padding:0px;
		color:#5488cc;
		text-decoration:none;
	}

	a:visited {
		margin:0px ;
		padding:0px;
		color:#5488cc;
		text-decoration:none;
	}

	br {
		margin:0px;
		padding:0px;
	}

	img {
		margin:0px;
		padding:0px;
	}

	b {
		margin:0px;
		padding:0px;
	}

	i {
		margin:0px;
		padding:0px;
	}

	u {
		margin:0px;
		padding:0px;
	}

	table {
		margin:0px;
		padding:0px;
	}

	tr {
		margin:0px;
		padding:0px;
	}

	td {
		margin:0px;
		padding:0px;
	}

	form {
		margin:0px;
		padding:0px;
	}

	input {
		margin:0px;
		padding:0px;
	}

	fieldset {
		margin:0px;
		padding:0px;
	}

	legend {
		margin:0px;
		padding:0px;
	}

	label {
		margin:0px;
		padding:0px;
	}

	textarea {
		margin:0px;
		padding:0px;
	}

	span {
		display: none;
	}

	/**************************************************************************
	* Stili Sito
	**/

	#container {
		margin: 0px auto;
		width: 100%;
		border-color: #9e9ec3;
		border-width: 0px 0px 0px;
		border-style: solid;
	}

	#subContainer {
		margin: 0px auto;
		width: 100%;
		border: 0px solid #9e9ec3;
	}

	#container #subContainer #header {
		height: 80px;
		overflow: hidden;
		width: 100%;
		border: 0px solid #000000;
	}

	#container #subContainer #menu {
		margin-bottom: 1px;
		width: 100%;
		height: 21px;
		border-top: 1px solid #9e9ec3;
		border-bottom: 1px solid #9e9ec3;

	}

	#container #subContainer #menu ul {
		list-style-type: none;
		float: left;
		width: auto;
		border: 0px solid #000000;
		overflow: hidden;
		width: 100%;
	}

	#container #subContainer #menu li {
		width: 25%;
		height: 19px;
		float: left;
		overflow: hidden;
		text-align: center;
		font-size: 11px;
		font-weight: bold;
		padding-top: 3px;
	}

	#container #subContainer #menu li a {
		padding-top: 3px;
		width: 129px;
		height: 19px;
	}

	#container #subContainer #columnLeft {
		float:left;
		width: 20%;
		margin: 0px;
		border: 0px solid #48c000;
		text-align: center;
	}

	#container #subContainer #columnLeft ul {
		font-weight:bold;
		width: 100%;
		border-right: 1px solid #9e9ec3;
	}

	#container #subContainer #columnLeft ul li {
		padding: 2px 0px 2px 0px;
		width: 100%;
		border-bottom: 1px solid #9e9ec3;
		margin: 0px auto;
	}

	#container #subContainer #columnLeft ul li a {
		width: 100%;
		padding: 2px;
		color: #9e9ec3;
	}

	#container #subContainer #content {
		width: 60%;
		height: auto;
		margin: 0px;
		border: 0px solid #ff0000;
		float:left;
		text-align:center;
	}

	#container #subContainer #content p {
		padding: 10px ;
	}

	#container #subContainer #columnRight {
		float: right;
		width: 20%;
		margin: 0px;
		border: 0px solid black;
	}

	#container #subContainer #columnRight ul {
		font-weight:bold;
		width: 100%;
		border-left: 1px solid #9e9ec3;
	}

	#container #subContainer #columnRight ul li {
		padding: 2px 0px 2px 0px;
		width: 100%;
		border-bottom: 1px solid #9e9ec3;
		margin: 0px auto;
	}

	#container #subContainer #columnRight ul li a {
		width: 100%;
		padding: 2px;
		color: #9e9ec3;
	}

	#container #subContainer #footer {
		border: 0px solid black;
		clear: both;
		width: 100%;
		height: 90px;
	}

	#container #subContainer #footer p {
		width: 100%;
		border: 0px solid black;
		padding: 2px;
	}

Un’ultima nota prima di chiudere: non possiamo utilizzare $this->nomeVariabile all’interno dei file inclusi in init.

Related posts:

1. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...
2. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...
3. Neobazaar annunci gratuiti: esempio di una applicazione sviluppata con Zend Framework Nasce Neobazaar.com, annunci gratuiti in Italia: interamente sviluppato con Zend...

Related posts brought to you by Yet Another Related Posts Plugin.

In un gran numero di siti accade che alcune parti del layout cambino poco o non cambino proprio al cambiare della pagina. Per ogni azione richiesta si avrà il relativo controller che avrà la relativa vista che sarà un file .phtml. Per mantenere il sito uniforme, una possibile soluzione sarebbe di includere all’interno di ogni file .phtml un codice del genere:

< ?php echo $this->render('header.phtml'); ?>
< ?php echo $this->title; ?>
< ?php echo $this->content; ?>
< ?php echo $this->render('footer.phtml'); ?>

Siccome la ridondanza del codice è una cosa che ai programmatori non dovrebbe piacere per vari motivi, giunge in nostro aiuto la Two Step View.
La Two Step View consiste nel separare le parti comuni del nostro layout con la parte che effettivamente sarà aggiornata al cambiare della pagina.
Apriamo quindi il file IndexController.php e modifichiamo il suo contenuto con il seguente:

  class IndexController extends Zend_Controller_Action {
    public function init(){
      $response = $this->getResponse();
      $response->insert('sidebar', $this->view->render('sidebar.phtml'));
    }

    public function indexAction(){
      $this->view->pageTitle = 'Paesidelmondo Application Example';
      $this->view->bodyTitle = '
Paesidelmondo

';
      $this->view->bodyContent = '

One morning, when Gregor Samsa woke from troubled dreams, he found himself transformed in his bed into a horrible
      vermin. He lay on his armour-like back, and if he lifted his head a little he could see his brown belly, slightly domed and divided by arches
      into stiff sections. The bedding was hardly able to cover it and seemed ready to slide off any moment. His many legs, pitifully thin compared
      with the size of the rest of him, waved about helplessly as he looked. "What\'s happened to me? " he thought. It wasn\'t a dream.

 His room, a proper human room although a little too small, lay peacefully between its four familiar walls. A collection of textile samples
      lay spread out on the table - Samsa was a travelling salesman - and above it there hung a picture that he had recently cut out of an illustrated
      magazine and housed in a nice, gilded frame. It showed a lady fitted out with a fur hat and fur boa who sat upright, raising a heavy fur muff
      that covered the whole of her lower arm towards the viewer. Gregor then turned to look out the window at the dull weather.

 Drops of rain could be heard hitting the pane, which made him feel quite sad. "How about if I sleep a little bit longer and forget all
      this nonsense", he thought, but that was something he was unable to do because he was used to sleeping on his right, and in his present state
      couldn\'t get into that position. However hard he threw himself onto his right, he always rolled back to where he was. He must have tried it
      a hundred times, shut his eyes so that he wouldn\'t have to look at the floundering legs, and only stopped when he began to feel a mild, dull
      pain there that he had never felt before. "Oh, God", he thought, "what a strenuous career it is that I\'ve chosen! Travelling day in and day
      out. Doing business like this takes much more effort than doing your own business at home, and on top of that there\'s the curse of travelling,
      worries about making train connections, bad and irregular food, contact with different people all the time so that you can never get to know
      anyone or become friendly with them. It can all go to Hell! " He felt a slight itch 

';
    }
  }

Apriamo o creiamo in caso ancora non l’avessimo fatto il file sidebar.phtml all’interno di views/scripts.
Per questo esempio, creeremo un file molto molto semplice:

Menù

Pagina 1
Pagina 2
Pagina 3
Pagina 4
Pagina 5
Pagina 6
Pagina 7
Pagina 8

Il file index.phtml su views\scripts sarà composto da 2 linee di codice:

< ?php echo $this->bodyTitle ;?>
< ?php echo $this->bodyContent ;?>

Ed infine il file layout.phtml salvato all’interno di views\layouts :

< !DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
    <title>< ?php echo $this->escape($this->pageTitle); ?></title>
    <link rel="stylesheet" href="<?php echo $this->baseUrl(); ?>/css/main.css" type="text/css">
  </link></head>
  <body>
    <!-- start sidebar -->
    <div id="sidebar">< ?php echo $this->layout()->sidebar; ?></div>
    <!-- end sidebar -->

    <!-- start content -->
    <div id="content">< ?php echo $this->layout()->content ?></div>
    <!-- end content -->
  </body>
</html>

Che cosa è successo? Come potete notare nel file IndexController.php, abbiamo aggiunto il metodo init, che intercetta l’oggetto $response e gli inietta sidebar.phtml al cui contenuto potremo accedere tramite la chiamata $this->layout()->sidebar; all’interno del file layout.phtml.
Abbiamo quindi risolto il problema della ridondanza del codice in maniera elegante.

Nel nostro layout abbiamo inoltre utilizzato un view helper, baseUrl, utile per caricare il css.
Il seguente è il codice del baseUrl view helper, da inserire nella directory degli helper, che di default su zend framewor si trova in application\views\helpers

BaseUrl.php

< ?php

  class Zend_View_Helper_BaseUrl
  {
    function baseUrl(){
      $fc = Zend_Controller_Front::getInstance();
      $request = $fc->getRequest();
      return $request->getBaseUrl();
    }
  }

Infine, per concludere con questa seconda parte, l’ultima modifica da implementare risiede nel file index.php, ovvero il nostro file di bootstrap. Sostituite questo codice:

  // Blocco 4
  $frontController->dispatch();

con questo codice:

 // Blocco 4
 try {
   $frontController->dispatch();
  } catch(Exception $e) {
      echo nl2br($e->__toString());
  }

Questa modifica è autoesplicativa, non fa altro che inserire il metodo dispatch() all’interno di un costrutto try/catch in modo da catturare un errore nell’eventualità che si presenti.

Links

akrabat.com

framework.zend.com

Related posts:

1. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...
2. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...
3. Neobazaar annunci gratuiti: esempio di una applicazione sviluppata con Zend Framework Nasce Neobazaar.com, annunci gratuiti in Italia: interamente sviluppato con Zend...

Related posts brought to you by Yet Another Related Posts Plugin.

Iniziamo con il modificare e aggiungere alcune directory all’albero della nostra applicazione. Per questo progetto avremo bisogno di rinominare la directory ‘zend’ in ‘paesidelmondo’, nome che daremo al nostro vero progetto. Aggiungiamo quindi ‘db’ all’interno di questa directory. Quindi aggiungeremo le directories ‘css’, ‘img’ e ‘js’ all’interno della root. La seguente è la rappresentazione grafica dell’albero dell’applicazione:

• paesidelmondo
  • application
    • controllers
    • models
    • views
      • scripts
        • index
        • error
      • layouts
      • filters
      • helpers
  • db
  • library
    • Zend
  • tests
    • controllers
    • models
• web_root (www)
  • css
  • img
  • js

Caricamento automatico delle classi

Il file di bootstrap della nostra applicazione Hello World è un buon inizio.
Tuttavia dobbiamo procedere ad effettuare diverse modifiche, tra le quali il caricamento automatico delle classi.

require_once(’Zend/Loader.php’);
Zend_Loader::loadClass(’Zend_Debug’);
Zend_Loader::loadClass(’Zend_Controller_Front’);

Come potete notare da questa porzione di codice, quello che abbiamo definito ‘blocco 2′, il caricamento delle classi avviene tramite una chiamata statica, Zend_Loader::loadClass(). In una vera applicazione esiste la necessità di dover caricare un
gran numero di classi. Per questo progetto useremo la funzionalità del metodo magico __autoload() di Php 5. Questo metodo usa in modo automatico la funzionalità spl_autoload_register() della
Standard PHP Library (SPL).
Questa funzionalità, usando Zend Framework, la si può utilizzare effettuando la seguente chiamata:

Zend_Loader::registerAutoload()

In questo modo, ogni qual volta dovremo utilizzare una cerca classe, il file che la definisce sarà caricato in automatico.

Configurazione

La configurazione della nostra applicazione è gestita dalla classe Zend_Config e può essere nei formati XML, Arrays o un file di configurazione INI. In questo articolo utilizzeremo quest’ultimo metodo.
Creiamo quindi il file di configurazione, config.ini ed inseriamolo all’interno della directory ‘zend’. Il seguente è un esempio di cosa potrebbe contenere il file di configurazione:

[db]
adapter = PDO_MYSQL
database.host = localhost
database.username = mio_utente
database.password = mia_password
database.name = mio_db

Questi dati sono accessibili tramite una interfaccia Object Oriented, utilizzando la classe Zend_Config_Ini

$config = new Zend_Config_Ini(ZEND_ROOT.'config.ini', 'db');
$adapter = $config->adapter;
$databaseHost = $config->database->host;

Da notare che il ‘.’ funge come separatore gerarchico, difatti ‘host’ di database.host è figlio di ‘database’. Un altro tipo di operatore può essere utilizzato all’interno del file di configurazione, i due punti ‘:’ ,
come separatore di sezione in modo tale da poter definire un set di configurazioni standard e quindi poterle modificare in base a quale sezione è la sezione di provenienza.

[generale]
db.adapter = PDO_MYSQL
db.config.host = localhost
db.config.username = mio_utente
db.config.password = mia_password
db.config.dbname = mio_db

[produzione : generale]
db.config.host = produzione_db.miosito.it

[sviluppo : generale]
db.config.host = sviluppo_db.miosito.it

Potremo quindi caricare queste configurazioni in diversi modi, per il sistema in produzione:

$config = new Zend_Config_Ini(ZEND_ROOT.'config.ini', 'produzione');

E per il sistema in sviluppo

$config = new Zend_Config_Ini(ZEND_ROOT.'config.ini', 'sviluppo');

In pratica, Zend Framework carica tutte le impostazioni di default ( quelle da cui sia produzione che sviluppo derivano ), quindi applica le modifiche in base al tipo di configurazione richiesta.

Ed ecco infine quello che sarà il nostro file di configurazione per questo articolo:

[generale]
db.adapter = PDO_MYSQL
db.config.host = localhost
db.config.username = root
db.config.password =
db.config.dbname = xyz

[produzione : generale]

[sviluppo : generale]

[prova : generale]
db.config.dbname = zend

Il Registro

Per applicazioni di grandi dimensioni è sconsigliato usare variabili globali in quanto potrebbero sorgere problemi di sovrascrittura della variabile ( coupling of global variables ). Per ovviare a questo problema Zend Framework offre la classe Zend_Registry. Zend_Registry implementa il Registry design pattern è quindi un ottima soluzione per salvare oggetti che serviranno in diversi punti della nostra applicazione.
Principalmente, gli oggetti che andremo a salvare all’interno di Zend_Registry saranno $config e $db.
Per salvare un oggetto useremo il metodo Zend_Registry::set(), che salverà l’oggetto passato ad argomento in un array associativo interno, una chiave per identificare l’oggetto dovrà quindi essere fornita. Per recuperare un oggetto salvato useremo il metodo Zend_Registry::get(). Inoltre è diponibile la funzionalità Zend_Registry::isRegistered() per verificare che l’oggetto esista all’interno del registro.

Inizializzazione del Database

Per inizializzare il database dovremo creare un oggetto di tipo Zend_Db_Adapter, che ci verrà restituito da una chiamata al metodo factory della classe Zend_Db. In questo caso, l’oggetto che ci verrà restituito sarà di tipo Zend_Db_Adapter_Pdo_Mysql. Per far ciò passeremo il nome dell’adapter e un array di configurazioni come argomenti.
Registriamo quindi l’oggetto nel registro:

// set up database
$db = Zend_Db::factory($config->db->adapter, $config->db->config->toArray());
Zend_Db_Table::setDefaultAdapter($db);
Zend_Registry::set('db', $db);

Bootstrap Aggiornato

Il nostro file di bootstrap, index.php, risulterà così strutturato

  // Blocco 1
  error_reporting(E_ALL|E_STRICT);
  ini_set('display_errors', true);
  date_default_timezone_set('Europe/Rome');
  $rootDir = dirname(dirname(__FILE__));
  define( 'CONTAINER', 'paesidelmondo/' );
  define( 'ZEND_ROOT', $rootDir.'/'.CONTAINER );
  set_include_path(ZEND_ROOT.'library'.PATH_SEPARATOR.get_include_path());

  // Blocco 2
  require_once('Zend/Loader.php');
  Zend_Loader::registerAutoload();

  // Blocco 3
  $frontController = Zend_Controller_Front::getInstance();
  $frontController->throwExceptions(true);
  $frontController->setControllerDirectory(ZEND_ROOT.'application\controllers');

  // Blocco 3b
  $config = new Zend_Config_Ini(ZEND_ROOT.'config.ini', 'prova');  

  // Blocco 3c
  $db = Zend_Db::factory($config->db->adapter, $config->db->config->toArray());
  Zend_Db_Table::setDefaultAdapter($db);
  Zend_Registry::set('db', $db);

  // Blocco 4
  $frontController->dispatch();

Con questo si conclude la prima parte sul come costruire un’applicazione reale con Zend Framework. Nella seconda parte dell’articolo parleremo della Two Step View e della sua implementazione all’interno di Zend Framework.

Related posts:

1. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...
2. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...
3. Neobazaar annunci gratuiti: esempio di una applicazione sviluppata con Zend Framework Nasce Neobazaar.com, annunci gratuiti in Italia: interamente sviluppato con Zend...

Related posts brought to you by Yet Another Related Posts Plugin.