Il codice del nostro bootstrap attualmente è contenuto all’interno del file index.php, che di fatto è il nostro bootstrap. In questo articolo vedremo come realizzare una classe Bootstrap dove ogni metodo si occuperà di inizializzare qualcosa di specifico sullo Zend Framework, donando all’applicazione un pizzico di leggibilità e organizzazione in più.

Attualmente il file index.php, nostro attuale bootstrap, è organizzato in questo modo, come potete anche vedere in alcuni altri articoli della categoria Php -> Zend Framework

index.php

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

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

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

  // Blocco 2b
  Zend_Layout::startMvc(array('layoutPath' => ZEND_ROOT.'/application/views/layouts'));

  // Blocco 3
  $front = Zend_Controller_Front::getInstance();
  $front->registerPlugin(new Zend_Controller_Plugin_ErrorHandler());
  //$front->throwExceptions(true);
  //$frontController->setParam('useDefaultControllerAlways', true);
  $front->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);
  Zend_Registry::set('config', $config);

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

  Zend_Search_Lucene_Search_QueryParser::setDefaultEncoding('UTF-8');
  Zend_Search_Lucene_Analysis_Analyzer::setDefault(new Zend_Search_Lucene_Analysis_Analyzer_Common_Utf8());
  SearchIndexer::setIndexDirectory(ZEND_ROOT.'/var/search_index');
  Paesidelmondo_Db_Table_Row_Observerable::attachObserver('SearchIndexer'); 

  Zend_Controller_Action_HelperBroker::addPrefix('Paesidelmondo_Controller_Action_Helper_');

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

D’ora in poi invece il seguente sarà il nostro file index.php

  $rootDir = dirname(__FILE__);
  define( 'CONTAINER', 'paesidelmondo/' );
  define( 'ROOT_DIR', $rootDir.'/'.CONTAINER );
  set_include_path(ROOT_DIR.'library'.PATH_SEPARATOR.get_include_path());
  set_include_path(ROOT_DIR.'application/models'.PATH_SEPARATOR.get_include_path());
  //echo get_include_path();
  require(ROOT_DIR.'\application\bootstrap.php');
  require_once('Zend/Loader.php');
  Bootstrap::run('prova');

Come potete vedere tutte inizializzazioni dei vari componenti sono state rimosse, lasciando tutto il lavoro al metodo statico run della classe Bootstrap. Siccome non ho visto la necessità di creare una istanza della classe, per ora ho deciso di trattarla staticamente, infatti anche tutti gli altri metodi della classe sono statici. Il metodo run accetta un argomento che determina con quali configurazioni l’applicazione sarà avviata. Come potete vedere voi stessi, il Bootstrap.php sarà salvato all’interno della directory ‘application’ ( la stessa che contiene le dir Models/Views/Controllers ).

  class Bootstrap {
    public static $config = null;
    public static $configSection = null;
    public static $frontController = null;
    public static $registry = null;

    public static function run($configSection = 'generale'){
      self::$configSection = $configSection;
      self::prepare();
      $response = self::$frontController->dispatch();
      self::sendResponse($response);
    }

    public static function prepare(){
      Zend_Loader::registerAutoload();
      self::setupRegistry();
      self::setupConfiguration();
      self::setupEnvironment();
      self::setupFrontController();
      self::setupView();
      self::setupDatabase();
      self::setupACL();
      self::setupLucene();
    }

    public static function setupRegistry(){
      self::$registry = new Zend_Registry(array(), ArrayObject::ARRAY_AS_PROPS);
      Zend_Registry::setInstance(self::$registry);
    }

    public static function setupConfiguration(){
      $config = new Zend_Config_Ini(ROOT_DIR.'configuration/config.ini', self::$configSection);
      self::$registry->config = $config;
    }

    public static function setupEnvironment(){
      error_reporting(E_ALL|E_STRICT);
      ini_set('display_errors', (bool)self::$registry->config->ini->display_errors);
      date_default_timezone_set(self::$registry->config->date_default_timezone);
    }

    public static function setupFrontController(){
      self::$frontController = Zend_Controller_Front::getInstance();
      self::$frontController->throwExceptions((bool)self::$registry->config->front->throwExceptions);
      self::$frontController->returnResponse((bool)self::$registry->config->front->returnResponse);
      self::$frontController->registerPlugin(new Zend_Controller_Plugin_ErrorHandler());
      self::$frontController->setControllerDirectory(ROOT_DIR.'/application/controllers');
    }

    public static function setupView(){
      $view = new Zend_View;
      $view->setEncoding('UTF-8');
      $viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer($view);
      Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);
      Zend_Layout::startMvc(array('layoutPath' => ROOT_DIR.'/application/views/layouts'));
    }

    public static function setupDatabase(){
      $db = Zend_Db::factory(self::$registry->config->db->adapter, self::$registry->config->db->config->toArray());
      $db->query("SET NAMES 'utf8'");
      Zend_Db_Table::setDefaultAdapter($db);
      self::$registry->db = $db;
    }

    public static function setupACL(){
      $acl = new Paesidelmondo_Acl();
      $aclHelper = new Paesidelmondo_Controller_Action_Helper_Acl(null, array('acl'=> $acl));
      Zend_Controller_Action_HelperBroker::addHelper($aclHelper);
    }

    public static function setupLucene(){
      Zend_Search_Lucene_Search_QueryParser::setDefaultEncoding('UTF-8');
      Zend_Search_Lucene_Analysis_Analyzer::setDefault(new Zend_Search_Lucene_Analysis_Analyzer_Common_Utf8());
      SearchIndexer::setIndexDirectory(ROOT_DIR.'/var/search_index');
      Paesidelmondo_Db_Table_Row_Observerable::attachObserver('SearchIndexer');
    }

    public static function sendResponse(Zend_Controller_Response_Http $response){
      $response->setHeader('Content-Type', 'text/html; charset=UTF-8', true);
      $response->sendResponse();
    }
  }

Il codice, se avete seguito tutti gli altri articoli non merita particolari spiegazioni, ma c’è una cosa importante da notare: subito dopo aver istanziato l’oggetto $db effettuiamo una query, SET NAMES ‘utf8′. Questa query è utile perchè imposta il charset utf8 per la gestione dell’interazione con il database. Purtroppo questa modifica, ci obbliga a eliminare alcune modifiche delle quali vi avevo parlato in questo articolo: sto parlando dell’aggiunta delle funzioni utf8_encode e utf8_decode. Queste, utilizzando la query SET NAMES ‘utf8′ nel bootstrap, non sono più necessarie, anzi, effettuano una codifica/decodifica non necessaria causando un malfunzionamento nella visualizzazione dei testi. Il vantaggio di questo approccio è anche la visione corretta dei testi usando PhpMyAdmin: i testi contenenti caratteri unicode saranno perfettamente visibilie e modificabili direttamente da li senza dover subire nessun encoding.

Per quanto riguarda Lucene, una volta effettuate le modifiche sopra descritte vi è la necessità di reindicizzare tutti i documenti per farlo funzionare correttamente.

Si conclude qui questo articolo sulla gestione del Bootstrap Object Oriented.

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 è...

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

In ogni applicazione possono avvenire dei bug più o meno gravi e quando questo avviene dobbiamo avere qualcosa che tenga nota che l’errore è avvenuto o perchè no, che ci avverta tramite email o sms. In questo articolo vedremo come gestire con Zend Framework un file di log dell’applicazione in modo che qualsiasi comportamento imprevisto sia loggato in modo tale da poter essere successivamente risolto. Inoltre, vedremo come gestire l’errore 404 pagina non trovata, in modo tale che la nostra applicazione restituisca delle pagine formattate con il layout del sito alla richiesta di una qualsiasi url non esistente piuttosto che ricevere un errore del server.

L’applicazione

L’applicazione dell agestione degli errori è relativamente semplice. Prendiamo il nostro file di bootstrap, index.php e commentiamo o eliminiamo, se presente, la linea

$front->throwExceptions(true);

ed aggiungiamo

$front->registerPlugin(new Zend_Controller_Plugin_ErrorHandler());

dove $front è ovviamente l’instanza di Zend_Controller_Front. Così facendo, allo scatenarsi di uno degli eventi citati, l’output sarà redirezionato all’ErrorController.

L’ErrorController

Nell’ErrorController, al metodo errorAction, inseriremo un codice di controllo in modo tale da gestire le due casistiche ( ripeto: errore 404 ed errore dell’applicazione ) e inserire un contenuto differente all’interno delle proprietà $content dipendentemente dall’evento scatenante. Infine, tramite l’utilizzo del componente Zend_Log, registreremo in un file chiamato applicationException.log il contenuto dell’eccezione.

ErrorController.php

  class ErrorController 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->_forward('error');
    }

    public function errorAction(){
      $errors = $this->_getParam('error_handler');

      switch ($errors->type) {
        case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
        case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
          // 404 error -- controller or action not found
            $this->getResponse()->setRawHeader('HTTP/1.1 404 Not Found');
            $content = "
\n";
            $content.= "
404

\n";
            $content.= "

La pagina ricercata non esiste!

\n";
            $content.= "

\n";
        break;

        default:
          // application error
          $content = "
\n";
          $content.= "
Errore!

\n";
          $content.= "

".utf8_encode("E' avvenuto un errore interno dell'applicazione, si prega di riprovare più tardi.")."

\n";
          $content.= "

\n";
        break;
      }

      // Log the exception:
      $exception = $errors->exception;
      $log = new Zend_Log(new Zend_Log_Writer_Stream(ZEND_ROOT.'/tmp/applicationException.log'));
      $log->debug($exception->getMessage()."\n".$exception->getTraceAsString());

      // Clear previous content
      //$this->getResponse()->clearBody();
      $this->view->content = $content;
    }
  }

error.phtml

<?php print $this->content; ?>

Si conclude qui questa breve guida alla gestione degli errori e 404, per domande o suggerimenti postate un commento.

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: introduzione al componente Zend_Form Creare form web con Zend Form Con Zend Framework possiamo...
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.

In questo articolo parleremo del componente Zend_Mail, illustrando alcune delle sue peculiarità ed implementando nella nostra applicazione di prova un semplicissimo form dei contatti.

Zend_Mail per molti aspetti ricorda molto Php Mailer ( chi non l’ha usato? ) e come questo ci semplifica molto il lavoro quando abbiamo a che vedere con l’invio di email. Con Zend_Mail possiamo scegliere di inviare usando sendmail e il mailserver locale ( che a sua volta utilizza la funzione mail() di Php ) o utilizzando un account SMTP. Se lavorate in locale il mio consiglio è di utilizzare un account SMTP, personalmente sono riuscito ad inviare in locale utilizzando il mio account su libero.it. Ma vediamo il codice da utilizzarsi per entrambe questi metodi:

Sendmail

  $mail = new Zend_Mail();
  $mail->setFrom('supporto@somewebsite.com', 'Sender');
  $mail->addTo('somename@someothersite.com', 'Receiver');
  $mail->setSubject('Oggetto della email');
  $mail->setBodyText('Corpo della mail.');
  $mail->send();

SMTP

  $dati = array(
    'username' => 'myusername',
    'password' => 'mypassword'
  );
  $transport = new Zend_Mail_Transport_Smtp('mail.our-smtp-server.com', $dati);
  Zend_Mail::setDefaultTransport($transport);    

  // Segue stesso codice di sendmail

Implementazione

Ciò che andremo ad implementare potrebbe essere una buona base per la creazione di un ticket system, creeremo un form con il quale gli utenti potranno contattare il team di supporto. Ogni richiesta sarà salvata sul database, e la tabella che conterrà questi dati è la seguente:

CREATE TABLE `supporto` (
  `id` int(11) unsigned NOT NULL auto_increment,
  `tipo` enum('generale','errore') collate utf8_unicode_ci NOT NULL default 'generale',
  `priorita` smallint(3) NOT NULL,
  `stato` enum('aperto','elaborazione','chiuso') collate utf8_unicode_ci NOT NULL default 'aperto',
  `titolo` varchar(99) collate utf8_unicode_ci NOT NULL,
  `corpo` text collate utf8_unicode_ci NOT NULL,
  `corpo_formattato` text collate utf8_unicode_ci NOT NULL,
  `inserimento_data` datetime NOT NULL,
  `inserimento_user_id` int(11) NOT NULL,
  `inserimento_ip` varchar(15) collate utf8_unicode_ci NOT NULL,
  `modifica_data` timestamp NULL default NULL on update CURRENT_TIMESTAMP,
  `modifica_user_id` int(11) default NULL,
  `modifica_ip` varchar(15) collate utf8_unicode_ci default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=1 ;

Un nuovo controller gestirà le richieste di supporto, il controller Supporto:

  class SupportoController extends Zend_Controller_Action
  {
    public function init(){
      // codice per la gestione layout e controllo acl
    }

    public function indexAction(){}

    public function createAction(){
      $filterInt = new Zend_Filter_Int;
      $filterStripTags = new Zend_Filter_StripTags;
      $filterFormat = new Zend_Filter;
      $filterFormat->addFilter(new Zend_Filter_StripTags)
                  ->addFilter(new ThirdParty_Filter_Markdown);

      $support = new Supporto;
      $newSupport = $support->createRow();
      $newSupport->inserimento_user_id = Zend_Auth::getInstance()->getIdentity() !== null ? Zend_Auth::getInstance()->getIdentity()->id : 0;
      $newSupport->tipo = $filterStripTags->filter($this->_getParam('tipo'));
      $newSupport->priorita = $filterInt->filter($this->_getParam('priorita'));
      $newSupport->stato  = $filterStripTags->filter($this->_getParam('stato'));
      $newSupport->titolo = $filterStripTags->filter($this->_getParam('titolo'));
      $newSupport->inserimento_data = date('Y-m-d H:i:s');
      $newSupport->corpo = $filterStripTags->filter($this->_getParam('corpo'));
      $newSupport->corpo_formattato = $filterFormat->filter($this->_getParam('corpo'));
      $id = $newSupport->save();
      $this->_redirect('supporto');
    }
  }

La action ‘create’ istanzia tutti i filtri necessari al filtraggio dei dati inviati dal form. Uno di questi filtri è Php Markdown, una classe open source che potete scaricare cliccando qui. Per includere questa classe in Zend Framework creiamo la classe ThirdParty_Filter_Markdown, locata in library/ThirdParty/Filter, dove includeremo anche la classe Markdown, rinominandola MarkdownExtra.php.

  class ThirdParty_Filter_Markdown implements Zend_Filter_Interface
  {
    public function filter($string){
      $parser = new MarkdownExtra_Parser;
      return $parser->transform($string);
    }
  }

I dati vengono inseriti nel database dal metodo ’save’ chiamato da una istanza di Zend_Db_Table_Row_Abstract, nel nostra caso il modello Ticket, la classe row level del modello Supporto ( che tra poco vedremo ), istanziata tramite la chiamata del metodo createRow di Supporto. La indexAction non fa nulla, tranne che renderizzare il contenuto del relativo file della vista, index.phtml, ovvero il form che invierà i dati.

script/supporto/index.phtml

<div id="supporto">
  <form action="<?php echo $this->baseUrl;?>/supporto/create" method="post">
    <fieldset>
      <legend>Richiesta di supporto</legend>
      <label for="tipo">Tipo [*]</label><select name="tipo"><option value="generale">Generale</option><option value="errore">Errore</option></select><br />
      <label for="priorita">Priorità [*]</label><select name="priorita"><option value="1">Highest</option><option value="2">High</option><option value="3">Normal</option><option value="4">Low</option><option value="5">Lowest</option></select><br />
      <label for="titolo">Titolo [*]</label><input type="text" name="titolo" value="" /><br />
      <textarea name="corpo" rows="12" cols="12"></textarea>
      <input type="submit" value="Invia" />
    </fieldset>
  </form>
</div>

I Modelli

L’omonimo modello Supporto conterrà la reference map relativa alla tabella utenti e, come già detto, avrà una classe row level chiamata Ticket, dove effettueremo un overload del metodo save in modo tale che, oltre che salvare i dati nel database, si occupi anche di inviare la email.

models/Supporto.php

  class Supporto extends Zend_Db_Table_Abstract
  {
    protected $_name = 'supporto';
    protected $_rowClass = 'Ticket';
    protected $_referenceMap = array(
      'Supporto' => array(
        'columns'        => array('inserimento_user_id'),
        'refTableClass'  => 'Utenti',
        'refColumns'     => array('id')
      )
    );
  }

models/Ticket.php

  class Ticket extends Zend_Db_Table_Row_Abstract
  {
    public function save(){
      parent::save();
      SupportoMailer::send($this);
    }
  }

Il metodo save() effettuerà il salvataggio dei dati inviati dal form ed invierà le email, ma il codice di invio sarà incluso in una nuova classe modello che chiameremo SupportoMailer, questo più che altro per agevolare l’eventuale modifica futura del codice di invio email. L’argomento passato, $this, è una istanza di Zend_Db_Table_Row_Abstract e conterrà tutti i dati inviati dal form.

models/SupportoMailer.php

  class SupportoMailer
  {
    public static function send(Zend_Db_Table_Row_Abstract $Ticket){
      if(Zend_Auth::getInstance()->getIdentity() !== null){
        $utenti = new Utenti();
        $utenti->find(Zend_Auth::getInstance()->getIdentity()->id);
        $submitter = $utenti->current();
      }
      $view = Zend_Layout::getMvcInstance()->getView();
      $authDetails = array(
        'port' => 25,
        'username' => 'myusername',
        'password' => 'mypassword'
      );
      $view->ticket_id = $Ticket->id;
      $view->user_name = isset($submitter) ? $submitter->username : 'Unknown';
      $view->mail_body = $Ticket->corpo_formattato;
      $transport = new Zend_Mail_Transport_Smtp('some.smtp.com',$authDetails);
      Zend_Mail::setDefaultTransport($transport);
      $mail = new Zend_Mail();
      $mail->addHeader('X-Priority', $Ticket->priorita, false);
      //$mail->setBodyText(Zend_Layout::getMvcInstance()->getView()->render('supporto/text-email.phtml'));
      $mail->setBodyHtml($view->render('supporto/html-email.phtml'));
      $mail->setFrom('supporto@somewebsite.com', 'Sender');
      $mail->addTo('somename@someothersite.com', 'Receiver');
      if(isset($submitter)){
        $mail->addCC($submitter->email, $submitter->username);
      }
      $mail->setSubject(strtoupper($Ticket->tipo).': '.$Ticket->titolo);
      $mail->send();
    }
  }

SupportoMailer, in questo caso, utilizzerà un account smtp per inviare la mail al destinatario. Già, ma il destinatario una volta ricevuta la mail, cosa visualizzerà? A questa problematica ci viene incontro Zend_View: infatti, come layout della email possiamo utilizzare un view file passandolo come argomento al metodo setBody di Zend_Mail. Possiamo creare diversi layout, per esempio uno che utilizzi la formattazione html ed uno solamente testuale, questa funzionalità che sarebbe utile nel caso della creazione di una newsletter che dia all’utente la possibilità di scegliere tra l’una e l’altra.

script/supporto/html-email.phtml

<p>Ciao  <b><?php echo $this->user_name; ?></b>,</p> 

<p>Il tuo ticket è il numero <b><?php echo $this->ticket_id; ?></b></p> 

<p>La tua richiesta: </p> 

<i><?php echo $this->mail_body; ?> </i>

<p>Prenderemo in esame la tua richiesta il prima possibile.</p> 

<p>Grazie, </p> 

<p><b>lo Staff. </b></p>

script/supporto/text-email.phtml

Ciao <?php echo $this->user_name; ?>, 

Il tuo ticket è il numero <?php echo $this->ticket_id; ?>
La tua richiesta: 

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

Prenderemo in esame la tua richiesta il prima possibile.

Grazie, 

lo Staff.

Tralasciamo volontariamente la creazione del css per la visualizzazione del form che credo nn sia un problema.

Si conclude qui l’articolo relativo all’invio di email con Zend_Mail, non tutte le funzionalità sono state viste ( come del resto Sempre succede ), come per esempio l’aggiunta di allegati. Per ulteriori informazone vi rimando alla documentazione ufficiale.

Related posts:

1. Zend Framework: introduzione al componente Zend_Form Creare form web con Zend Form Con Zend Framework possiamo...
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.

L’autenticazione è il processo in cui bisogna capire se qualcuno è realmente chi dice di essere. Per identificare l’individuo, solitamente si usa l’accoppiata username e password. Altri metodi di autenticazione sono esistenti, ad esempio, quando si paga in un negozio con la carta di credito, l’username è sostituito dal possesso materiale della carta di credito, altri metodi potrebbero essere la lettura delle impronte digitali ecc..

In Zend Framework il processo di autenticazione è gestito da un oggetto, Zend_Auth. In questo articolo, procederemo a creare un nuovo controller, AuthController e la sua rispettiva view, che visualizzerà il form per l’inserimento di username e password ed eventualmente dei messaggi di errore.

AuthController.php

< ?php

  class AuthController 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->_forward('login');
    } 

    public function loginAction() {
      $auth = Zend_Auth::getInstance();
      if ($auth->hasIdentity()) {
        $this->_redirect('/');
      }
      $flashMessenger = $this->_helper->FlashMessenger;
      $flashMessenger->setNamespace('actionErrors');
      $this->view->actionErrors = $flashMessenger->getMessages();
    }

    public function identifyAction(){
      $success = false;
      $message = '';
      if ($this->_request->isPost()){
        $formData = $this->_getFormData();

        if (empty($formData['username']) || empty($formData['password'])){
          $message = 'Please provide a username and password.';
        }else{
          $authAdapter = $this->_getAuthAdapter($formData);
          $auth = Zend_Auth::getInstance();
          $result = $auth->authenticate($authAdapter);
          if($result->isValid()) {
            $data = $authAdapter->getResultRowObject(null,'password');
            $auth->getStorage()->write($data);
            $success = true;
            $redirectUrl = $this->_redirectUrl;
          }else{
            $message = 'Login failed';
          }
        }
      }

      if(!$success){
        $flashMessenger = $this->_helper->FlashMessenger;
        $flashMessenger->setNamespace('actionErrors');
        $flashMessenger->addMessage($message);
        $redirectUrl = '/auth/login';
      }
      $this->_redirect($redirectUrl);
    }

    protected function _getAuthAdapter($formData){
      $dbAdapter = Zend_Registry::get('db');
      $authAdapter = new Zend_Auth_Adapter_DbTable($dbAdapter);
      $authAdapter->setTableName('utenti')
                  ->setIdentityColumn('username')
                  ->setCredentialColumn('password');     

      $config = Zend_Registry::get('config');
      $salt = $config->auth->salt;
      $password = sha1($salt.$formData['password']);   

      $authAdapter->setIdentity($formData['username']);
      $authAdapter->setCredential($password);         

      return $authAdapter;
    }

    protected function _getFormData(){
      $data = array();
      $filterChain = new Zend_Filter;
      $filterChain->addFilter(new Zend_Filter_StripTags);
      $filterChain->addFilter(new Zend_Filter_StringTrim);

      $data['username'] = $filterChain->filter($this->_request->getPost('username'));
      $data['password'] = $filterChain->filter($this->_request->getPost('password'));
      return $data;
    }

    public function logoutAction() {
      $auth = Zend_Auth::getInstance();
      $auth->clearIdentity();
      $this->_redirect('/');
    }
  }

Come per l’IndexController anche questo AuthController contiene il metodo init() utile all’inserimento nell’output delle parti comuni del layout (header, footer ecc.. ).

L’indexAction altro non contiene che una redirezione alla loginAction, in modo tale che entrando nella pagina di autorizzazione senza specificare una action, login venga eseguita. La LoginAction redireziona l’output nell’IndexController ( quindi nella homepage ) del sito nel caso in cui l’utente sia già autorizzato, ovvero nel caso in cui $auth->hasIdentity() ritorni true. Inoltre viene recuperato l’helper FlashMessenger, che contiene eventuali messaggi salvati da una precedente azione, salvati nella proprietà $this->view->actionErrors, in modo tale da poterli visualizzare nella vista.
Alla loginAction è legata la view login.phtml, il seguente è il codice:

login.phtml

<h1>Log in</h1>
<p>Please log in here</p>
<?php echo isset($this->actionErrors[0]) && !empty($this->actionErrors[0]) ? "<p class='error'>" . $this->escape($this->actionErrors[0]) . "</p>" : ""; ?>

<form method="POST"
        action="<?php echo $this->LinkTo('auth/identify'); ?>">
    <div>
        <label>Username</label>
        <input type="text" name="username" value="" />
    </div>
    <div>
        <label>Password</label>
        <input type="password" name="password" value="" />
    </div>
    <div>
        <input type="submit" name="login" value="Login" />
    </div>
</form>

L’unico particolare degno di nota di questo file è l’attributo action del form. Questo è generato da un view helper, LinkTo che si occupa di creare la corretta url per la identifyAction, recuperando il valore corretto di $baseUrl.

LinkTo.php

< ?php

  class Zend_View_Helper_LinkTo
  {
    protected static $baseUrl = null; 

    public function linkTo($path){
      if(self::$baseUrl === null){
        $request = Zend_Controller_Front::getInstance()->getRequest();
        $root = '/' . trim($request->getBaseUrl(), '/');
        if ($root == '/'){
          $root = '';
        }
        self::$baseUrl = $root . '/';
      }
      return self::$baseUrl . ltrim($path, '/');
    }
  }

Procedendo con le action dell’AuthController troviamo l’identifyAction, che controlla l’esistenza di una richiesta POST, quindi filtra il contenuto dell’array POST passandolo al metodo _getFormData

, che filtra il suo contenuto utilizzando l’oggetto Zend_Filter e aggiungendo come filtri gli oggetti Zend_Filter_StripTags e Zend_Filter_StringTrim, il cui compito è il medesimo delle funzioni built in del linguaggio trim() e strip_tags.

I dati inviati vengono quindi passati al metodo _getAuthAdapter che si occupa di istanziare la classe Zend_Auth_Adapter_DbTable a quale passeremo l’oggetto $db recuperato dal registro ed indicheremo la tabella e i campi in cui dovranno essere verificati l’username e la password inviate. Per rendere il tutto più sicuro la password, oltre ad essere salvata criptata sul database tramite l’algoritmo SHA1, è unita ad un salt, una stringa casuale salvata nel nostro file di configurazione, il che rende estremamente difficile, se non impossibile, recuperare il valore della password conoscendo il suo valore criptato e cercando di effettuare un reverse engineering.

L’oggetto Zend_Auth_Adapter_DbTable ritornato dal nostro metodo _getAuthAdapter sarà quindi passato a Zend_Auth, che ci confermerà o meno l’esistenza dell’utente tramite la chiamata del metodo sValid(). In caso di fallimento l’output sarà redirezionato alla medesima pagina di autenticazione accompagnata dal messaggio indicante la non riuscita dell’operazione. In caso di successo, i dati utente recuperati saranno salvati nella sessione, fatta eccezione che per la password.

Messaggio di benvenuto

In ogni sito che si rispetti, una volta autenticati il sistema ci da un messaggio di benvenuto, indicante il nostro nome. Ebbene, anche il nostro sistema godrà di questa caratteristica, utilizzando un nuovo view helper, LoggedInUser.

LoggedInUser

< ?php
  class Zend_View_Helper_LoggedInUser {
    protected $_view; 

    function setView($view) {
      $this->_view = $view;
    }

    function loggedInUser(){
      $auth = Zend_Auth::getInstance();
      if($auth->hasIdentity()){
        $logoutUrl = $this->_view->linkTo('auth/logout');
        $user = $auth->getIdentity();
        $username = $this->_view->escape(ucfirst($user->username));
        $string = 'Loggato come ' . $username . ' | Log out';
      }else{
        $loginUrl = $this->_view->linkTo('auth/login');
        $string = 'Log in';
      }
      return $string;
    }
  }

La stringa ritornata sarà visualizzata, per esempio, nell’header.

header.phtml

Paesidelmondo Header

 

  
Registratione
  Nome Utente:

 



< ?php echo $this->LoggedInUser();?>

Con questo si conclude il tutorial all’autenticazione con Zend Framework. I commenti, aggiunte, correzioni o altro sono sempre graditi.

Related posts:

1. Zend Framework: introduzione al componente Zend_Form Creare form web con Zend Form Con Zend Framework possiamo...
2. 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.