Zend Framework è un framework open source per PHP. Zend Framework separa la logica e le azioni usando il pattern MVC (Model View Controller).

Cosa è lo Zend Framework?
  • Framework per la costruzione di siti web più veloci e robusti.
  • Creato dalla casa madre PHP e da sostenitori Zend.
  • Supporta il web 2.0 e la tecnologia cloud computing.
Perché Zend Framework?
  • Framework gratuito e open source
  • Semplicità estrema
  • Alta produttività
  • Architettura flessibile
  • Supportato da oltre 300 collaboratori, comprendono anche grandi aziende IBM e altri
Dove si può ottenere?
Quando si ha bisogno di Zend Framework?
  • Quando si costruisce il web con una complessità sufficiente
Zend Framework viene così descritto...
Zend Framework è un framework open source per lo sviluppo di applicazioni e servizi web con PHP 5. Il framework ha un’implementazione completamente orientata agli oggetti. La struttura dei componenti di Zend Framework è in un certo senso unica: ciascun componente è stato concepito per essere indipendente dagli altri. Questa architettura permette agli sviluppatori di usare i componenti singolarmente. Viene spesso definito come un design in cui si usa un componente solo se si vuole farlo.
[nextpage title=”Zend Framework Intro”]
Struttura delle cartelle
⤽
Zend Framework è uno dei framework PHP più popolari a livello mondiale. Questo framework viene rilasciato da Zend, un fornitore importante per PHP. In questo post, impareremo a usare Zend framework da zero. Costruiremo una semplice applicazione denominata “ciaoMondo”. In questo framework, si usa MVC (Model View Controller).

MVC: Model View Controller

È una applicazione costituita da tre componenti:

  • Model – Questa è la parte dell’applicazione che definisce le funzionalità di base con un insieme di astrazioni. L’accesso ai dati e le routine relatibe possono essere definite nel Model.
  • View – Le view definiscono esattamente quello che viene presentato all’utente. Di solito i controller passano dati a ciascuna view per essere visualizzati in un dato formato, Le view ricevono anche dati dagli utenti. La marcatura HTML viene di solito inserita nelle view.
  • Controller – I controller tengono insieme l’intero pattern MVC. Manipolano i model, decidono quale view visualizzare in base alle richieste degli utenti e ad altri fattori, forniscono dati alle view o passano il controllo ad un altro controller. Molti sviluppatori consigliano di mantenere i controller il più semplici possibile.

Il nostro obiettivo è di creare un’applicazione semplice come questa:

Per prima cosa, creare la struttura come questa nella vostra cartella del server web (io l’ho creata sotto www/test/zend. È possibile crearla sotto www/test o semplicemente sotto www).


Quindi, scaricare Zend Framework da qui. Estrarre file compressi. Si ottiene una struttura come questa::


Copiare la libreria (cartella denominata “zend” sotto la cartella library) nella libreria di ciaoMondo/library. Quindi, l’applicazione diventerebbe come questa:
Nell’articolo successivo, spiegherò il significato delle cartelle.

Anatomia di un'applicazione Zend Framework
⤽
Abbiamo creato la struttura delle cartelle per l’applicazione ciaoMondo per lo Zend framework. Quello che abbiamo creato è lo standard per il modello Model View Controller in applicazioni Zend Framework. In questo post, vedremo la funzione di ogni cartella.
Ci sono 4 cartelle di livello superiore all’interno della cartella dell’applicazione:
  1. application
  2. library
  3. test
  4. web_root

La cartella application

La cartella dell’applicazione contiene tutto il codice necessario per eseguire l’applicazione. L’utente non può accedere direttamente. Questa è la separazione tra il display, il business e il controllo logico del modelo. In questa applicazione, ci sono modelli, visualizzazioni e cartelle controllori. Queste cartelle contengono il modello, la vista e file di controllo. Altre cartelle possono essere create, per esempio per i files di configurazione.

La cartella library

Tutte le applicazioni utilizza la libreria Zend. Abbiamo posto Zend Framework qui, ma, sostanzialmente, possiamo memorizzare biblioteca ovunque. Ma assicuriamoci che l’applicazione riesca a trovarla. È possibile memorizzarla in una directory globale includono accessibile per l’applicazione php sul server, come /usr/php_include o c:\code\php_include. Assicurarsi di configurare il file di php.ini (o è possibile utilizzare la funzione set_include_path()).

La cartella test

Questa cartella viene utilizzata per memorizzare tutti gli unit test che sono state scritte. Se ancora non conoscete lo unit testing, è possibile leggere qualche informazione da qui. Molti programmatori PHP non danno importanza allo unit test come passo speciale. E voi?

La cartella web_root

Tutte le richieste web fatte dagli utenti vengono convogliati attraverso un unico file, di solito chiamato index.php. Questo file è l’unico file php che deve essere accessibile da web server. Questo file si trova nella web_root. Altri file comuni che è possibile accedere direttamente sono i file per le immagini, i file CSS e i file JavaScript. Ognuno di loro ha una sotto-directory all’interno della directory web_root.
Successivamente, sarà scritto il codice per la semplice applicazione chiamata ciaoMondo.

Accesso singolo al file index.php
⤽
Come si sa’ a Zend Framework, il file index.php è un file che ci deve essere nella cartella web_root. Questo file è usato per tutte le richieste nella pagina. Viene utilizzato per la configurazione dell’ambiente (environtment) dell’applicazione, il sistema di controllo di Zend Framework, quindi esegue l’applicazione stessa. Questo è il modello Front Controller.
Creare un file denominato “index.php” all’interno di ciaoMondo/web_root e inserire il seguente codice:
Copia codice 

<?php
error_reporting(E_ALL|E_STRICT);
ini_set('display_errors', true);
date_default_timezone_set('Europe/Berlin');
$rootDir = dirname(dirname(__FILE__));
set_include_path($rootDir . '/library' . PATH_SEPARATOR . get_include_path());
require_once 'Zend/Controller/Front.php';
Zend_Controller_Front::run('../application/controllers');
?>
Ok, diamo un’occhiata a questo file in modo più dettagliato.
Le line3 2-3-4 sono utilizzate per l’environtment installazione.
Linea 3 per garantire che tutti gli errori o avvisi vengano visualizzati.
Linea 4 per il fuso orario di default l’installazione.
include_path() specifica una lista di cartelle in cui le funzioni require(), include() e fopen_with_path() hanno il percorso per cercare i files. È possibile impostarlo nel file php.ini. Ma, se non possiamo farlo, possiamo usare set_include_path(). Si può vedere alla linea 7.
Questo è il file di bootstrap. Bootstrap è il termine usato per descrivere l’avvio dell’applicazione. Il nucleo di questo codice si trova alle righe 9-10. Questo istanzierà e spedirà il front controller. E sarà indirizzata la richiesta ai action controllers.
Apache .htaccess
⤽
Abbiamo bisogno di indirizzare qualsiasi richiesta al front controller. Possiamo di utilizzare il modulo di apache chiamato “mod_rewrite“. Poi, lavoreremo con il file .htaccess. Questo file farà il routing di lavoro.
Creare un file chiamato “.htaccess” all’interno di web_root. Quindi, scrivete al suo interno il codice seguente:
Copia codice 

RewriteEngine On
RewriteRule .* index.php
Alla linea 2, come possiamo vedere, Apache indirizzerà tutte le richieste a index.php. Codice semplice, non è vero?
Un’altra opzione: è possibile configurare la cartella direttamente nel file httpd.conf di Apache. Si sa’ che non è così facile se non abbiamo proprio server. Così, configurare in una locale configurazione di Apache un file chiamato .htaccess è migliore opzione.
Creando il Controller
⤽
Il modello del front controller mappa le richieste dell’URL dall’utente ad una particolare funzione o metodo membro all’interno di una specifica classe controller. Viene chiamato come il routing e la spedizione (dispatching). Le classi controller hanno per convenzione un rigoroso requisito per la sua denominazione. Il router chiama un metodo denominato {nomeAzione}Action() all’interno della classe {nomeControllore}Controller. Questa classe deve esistere all’interno di un file chiamato {nomeControllore}.php Se non si fornisce, verrà utilizzato index. Ancora confuso? Date un’occhiata a questo esempio:
Creare un file denominato “IndexController.php” all’interno di application/controller. Inserire il seguente codice:
Copia codice 

<?php
require_once 'Zend/Controller/Action.php';
class IndexController extends Zend_Controller_Action
{
  public function indexAction()
  {
    $this->view->assign('title', 'Ciao, Mondo!');
  }
}
?>
All’interno del sistema front controller, il dispatcher si aspetta di trovare un file chiamato IndexController.php all’interno della cartella applicazione/controller. Questo file deve contenere una classe chiamata IndexController e, come minimo, contenere un metodo chiamato indexAction().
Creando il View
⤽
Ora, abbiamo bisogno di fornire un modello del view per la visualizzazione della pagina. Creeremo quindi un file index.phtml per questo scopo. Questo file dodrà essere memorizzato all’interno della cartella views/scripts/index. Il modello di view, richiede una cartella separata per ogni controller.
Creare quindi un file denominato “index.phtml” all’interno della cartella views/scripts/index. Inserire il seguente codice:
Copia codice 

<!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">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title><? echo $this->escape($this->title); ?></title>
</head>
<body>
  <h1><? echo $this->escape($this->title); ?></h1>
</body>
</html>
Il modello del file viene eseguito all’interno di una funzione membro di Zend_View e così l’oggetto $this è disponibile all’interno del modello del file che diventa il gateway per le funzionalità di Zend_View. Tutte le variabili che sono state valorizzate nella view all’interno del controller sono disponibili direttamente come proprietà di $this. Si può vedere di sopra come viene usata la variabile $this->title.

[nextpage title=”Zend Framework Action”]

Contenuto dinamico
⤽
Nel precedente post, si è parlato poco su come assegnare un parametro alla vista. Questo valore viene inviato dal controller. Ciò accade grazie Action Controller. Non voglio parlare molto nel dettaglio di Action Controller, ma impareremo a implementare l’Action Controller nello sviluppo web.
In primo luogo, ricordiamoci semplicemente di passare dal valore del controller per la visualizzazione. Abbiamo scritto un codice come questo:
Copia codice 

<?php
require_once 'Zend/Controller/Action.php';
class IndexController extends Zend_Controller_Action
{
  public function indexAction()
  {
    $this->view->assign('title', 'Ciao, Mondo!');
  }
}
?>
View lo prenderà con questo modo:
Copia codice 

  <? echo $this->escape($this->title); ?>
Se ancora non si sa di cosa si parla, si prega di leggere questa sezione: Zend Framework Intro.
Ok, ora, aggiungiamo uno o più parametri quali:
Copia codice 

<?php
require_once 'Zend/Controller/Action.php';
class IndexController extends Zend_Controller_Action
{
  public function indexAction()
  {
    $this->view->assign('title', 'Ciao, Mondo!');
	$this->view->assign('wellcome','Benvenuti nel mio sito. Questo sito è realizzato con Zend Framework. Buon divertimento!');
	$this->view->assign('webmaster','Manager');
  }
}
?>
Poi, cambiare il file “index.phtml” sotto la cartella application/views/scripts/index.
Copia codice 

<!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">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title><? echo $this->escape($this->title); ?></title>
</head>
<body>
  <h1><? echo $this->escape($this->title); ?></h1>
  <?=$this->escape($this->wellcome);?>
   
  <?=$this->escape($this->webmaster);?>
</body>
</html>
Puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/, o dove l’avete creata l’applicazione web. Si potrebbe recuperare qualcosa come il seguente output:

Struttura URL e Controller
⤽
L’URL è una parte importante quando si sviluppano applicazioni web. Li usiamo per saltare tra le pagine. Come sappiamo, ogni framework ha le sue regole per gli URL. Si tratta di una chiave per comprendere come funziona il framework. Ora, parleremo delle regole in Zend Framework.
Zend Framework rompe l’URL in mille pezzi. I pezzi sono disposti come segue: http://hostname/controller/action/parametri. Guardate i nostri url che abbiamo usato per accedere alla ciao pagina: http://localhost/test/zend/ciaoMondo/web_root/. Assumere che http://hostname sia lo stesso che http://localhost/test/zend/ciaoMondo/web_root/. Percorso successivo è il controller. Provate a puntare il browser a http://localhost/test/zend/ciaoMondo/web_root/index. Otteniamo lo stesso con http://localhost/test/zend/ciaoMondo/web_root/. Perché? di default, http://localhost/test/zend/ciaoMondo/web_root/ accederà al controller index. S’inizia a prendere l’idea?
Lo so, non sei paziente e testare subito con un altro controller. Che ne dici di usare altro controller chiamato “user”? Non importa. Dalla teoria di cui sopra, si accederà con http://localhost/test/zend/ciaoMondo/web_root/user. Facciamolo.
In primo luogo, creare il nome del controller “UserController“. Creare un file denominato “UserController” all’interno application/controller. Inserire il seguente codice:
Copia codice 

<?php
require_once 'Zend/Controller/Action.php';
class UserController extends Zend_Controller_Action
{
  public function indexAction()
  {
    $this->view->assign('name', 'Manager');
    $this->view->assign('title', 'Ciao');
  }
}
?>
Successivamente, creare una cartella denominata “user” sotto la cartella ciaoMondo\application\views\scripts. Creare un file denominato “index.phtml” all’interno della cartella user. Inserire il seguente codice:
Copia codice 

<!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">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title><? echo $this->escape($this->title); ?></title>
</head>
<body>
  <h1><?=$this->escape($this->title);?>, <?=$this->escape($this->name);?></h1>
</body>
</html>
Ora, puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/user.
Struttura URL e Action
⤽
Basta ricordare, abbiamo una regola come questa: http://hostname/controller/action/parametri.
Per semplicità, action è il metodo che si trova nella nostra classe sotto la cartella controller. Guardate il nostro codice:
Copia codice 

<?php
require_once 'Zend/Controller/Action.php';
class UserController extends Zend_Controller_Action
{
  public function indexAction()
  {
    $this->view->assign('name', 'Manager');
    $this->view->assign('title', 'Ciao');
  }
}
?>
Sopra, abbiamo il nome di action come “index“. Denominazione in Zend Framework, per aggiungere l’azione. Così, abbiamo un’azione “indexAction“. Quando si chiama questo controller (come user) e non si specifica azione, sarà chiamato indexAction di default.
Ora, aggiungiamo un’altro metodo alla ckasse, ad esempio “nameAction” come segue:
Copia codice 

  public function nameAction()
  {
    $this->view->assign('name', 'Manager');
    $this->view->assign('title', 'User Name');
  }
Qui di seguito, il nostro UserController completo:
Copia codice 

<?php
require_once 'Zend/Controller/Action.php';
class UserController extends Zend_Controller_Action
{
  public function indexAction()
  {
    $this->view->assign('name', 'Manager');
    $this->view->assign('title', 'Ciao');
  }
  public function nameAction()
  {
    $this->view->assign('name', 'Manager');
    $this->view->assign('title', 'Nome Utente');
  } 
}
?>
Successivamente, creare un file chiamato “name.phtml” all’interno della cartella views/scrips/user . Inserire il seguente codice:
Copia codice 

<!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">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title><? echo $this->escape($this->title); ?></title>
</head>
<body>
  <h1><?=$this->escape($this->title);?>, <?=$this->escape($this->name);?></h1>
</body>
</html>
Ora, puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/user/name
I parametri GET
⤽
Ora, l’ultima parte o i parametri URL nella Zend Framework. Ok, quale è la norma in Zend Framework? Guardate l’URL di questo esempio:
Copia codice 

http://hostname/user/name/username/Manager/gender/man
Siamo in grado di interpretarlo in questo modo:

  1. Controller = user
  2. Action = name
  3. username = Manager
  4. gender = man

Qual è la vostra conclusione? Sì, che abbiamo formula generale come questa:

Copia codice 

http://hostname/controller/action/var1/value1/var2/value2/...
Come catturare i parametri? Ok, possiamo impararlo da un esempio. Aprire UserController.php all’interno della cartella application/controller. Aggiornando il file diventa in questo modo:
Copia codice 

<?php
require_once 'Zend/Controller/Action.php';
class UserController extends Zend_Controller_Action
{
  public function indexAction()
  {
    $this->view->assign('name', 'Manager');
    $this->view->assign('title', 'Ciao');
  }
  public function nameAction()
  {
    $request = $this->getRequest();
    $this->view->assign('name', $request->getParam('username'));
    $this->view->assign('gender', $request->getParam('gender'));	  
    $this->view->assign('title', 'Nome Utente');
  }
}
?>
Fare attenzione alle linee 15-17. È chiaro, non è vero?
Per ultimo aggiornare la view: “name.phtml“:
Copia codice 

<!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">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title><? echo $this->escape($this->title); ?></title>
</head>
<body>
  <h1><?=$this->escape($this->title);?>, <?=$this->escape($this->name);?></h1>
  <h2>Gender: <?=$this->escape($this->gender);?></h2>
</body>
</html>
Includendo Header e Footer
⤽
Ultimo post di questa serie, si descriverà come includere i modelli per lo header e il footer. Lo so, questo non ha alcun rapporto con l’Action dello Zend Framework, ma questa conoscenza può diventare utile per voi per costruire un sito web.
Creare un file denominato “header.phtml” sotto la cartella views/scripts/user. Inserire il seguente codice:
Copia codice 

<!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">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title><? echo $this->escape($this->title); ?></title>
</head>
<body>
<div id="header">
Mio Zend Framework
</div>
Ora, creare un file denominato “footer.phtml” sotto la cartella views/scripts/user. Inserire il seguente codice:
Copia codice 

<div id="footer">
By miosito.net
</div>
</body>
</html>
Per ultimo, aggiornare “name.phtml” sotto la cartella views/scripts/user con il seguente codice:

Copia codice 

<? include "header.phtml"; ?>
  <h1><?=$this->escape($this->title);?>, <?=$this->escape($this->name);?></h1>
  <h2>Gender: <?=$this->escape($this->gender);?></h2>
<? include "footer.phtml"; ?>
Ora, puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/user/name/username/Manager/gender/man

[nextpage title=”Zend Framework Database”]
Introduzione
⤽
Zend Framework fornisce classi per il supporto del database. Il nome di tale classe è Zend_Db. Altri benefici utilizzando questa classe e le classi correlate sono le caratteristiche che offre un’interfaccia semplice per il database SQL.
Se parliamo di database in Zend Framework, possiamo parlare di ciò che è Zend_Db_Adapter. Questa è classe di base da utilizzare per connettere l’applicazione PHP e il RDBMS. Come sappiamo, c’è una classe diversa di adattatori per ogni tipo di RDBMS. Lo Zend_Db_Adapters è un ponte da parte del fornitore estensioni specifiche di PHP per un interfaccia comune. Con questa classe, è possibile scrivere applicazioni PHP per per molti RDBMS (con il minimo sforzo).
Si può ricordate ci sono dell’estensioni in PHP che hanno come delle funzioni similare a Zend_Db_Adapter, PHP Data Object (PDO). PDO fornire un’interfaccia per database multipli in PHP 5. In PHP 4, c’è una libreria, ADOdb.
Nel seguente esercizio, useremo PDO per mysql (pdo_mysql). Prima fare una prova per verificare se pdo_mysql è disponibile nel vostro sistema. Controllare il file php.ini. Decommentare extension = php_pdo.dll, extension = php_pdo_mysql.dll e riavviare il server Apache.
Ok, basta ricordare gli esercizi di base sui nostri post precedenti nei capitoli Zend Framework Intro e Struttura URL e Action. Quindi, assicuratevi di aver capito tali capitoli.
Per questo esempio, creare un database denominato “zend“. Quindi creare una tabella denominata “user“. È possibile utilizzare la seguente query:
Copia codice 

CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `first_name` varchar(50) NOT NULL,
  `last_name` varchar(50) NOT NULL,
  `user_name` varchar(50) NOT NULL,
  `password` varchar(255) NOT NULL,
  PRIMARY KEY  (`id`),
  UNIQUE KEY `user_name` (`user_name`)
);
Creazione Modulo di input
⤽
Primo passo, creeremo un modulo per l’input dei dati. Creiamo questo modulo dentro de la classe User Controller. Dobbiamo solo aggiungere un metodo denominato “registerAction” come azione per questo controller.
Aprire “UserController.php” sotto la cartella application/controllers. Aggiungere il seguente metodo:
Copia codice 

  public function registerAction()
  {
    $request = $this->getRequest();
	$this->view->assign('action',"process");
    $this->view->assign('title','Registrazione Membri');
	$this->view->assign('label_fname','Nome');
	$this->view->assign('label_lname','Cognome');
	$this->view->assign('label_uname','Nome Utente');
	$this->view->assign('label_pass','Password');
	$this->view->assign('label_submit','Registra');
	$this->view->assign('description','Compilare questo modulo completamente:');
  }
Come sappiamo, se creiamo un’azione con il nome “registerAction“, dobbiamo creare una vista con il nome “register.phtml“. Ok, allora creare un file denominato “register.phtml” sotto la cartella application/views/scripts/user. Inserire il seguente codice:
Copia codice 

<? include "header.phtml"; ?>
  <h1><?=$this->escape($this->title);?></h1>
  <div id="description">
    <?=$this->escape($this->description);?>
  </div>
  <form name="register" method="post" action="<?=$this->escape($this->action)?>">
  <table>
    <tr>
	  <td><?=$this->escape($this->label_fname)?></td>
	  <td><input type="text" name="first_name"></td>
	</tr>
    <tr>
	  <td><?=$this->escape($this->label_lname)?></td>
	  <td><input type="text" name="last_name"></td>
	</tr>
    <tr>
	  <td><?=$this->escape($this->label_uname)?></td>
	  <td><input type="text" name="user_name"></td>
	</tr>
    <tr>
	  <td><?=$this->escape($this->label_pass)?></td>
	  <td><input type="password" name="password"></td>
	</tr>
  </table>
  <input type="submit" name="submit" value="<?=$this->escape($this->label_submit);?>">
  </form>
<? include "footer.phtml"; ?>
Ora, puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/user/register

Inserendo i dati nel database
⤽
Dopo di aver creato il modulo, ora, creiamo l’azione per inserire i dati nel database. Per questo lavoro, aprire il file “UserController.php” sotto la cartella application/controllers. Aggiungere un metodo denominato “processAction“, come nel seguente codice:
Copia codice 

  public function processAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
    $request = $this->getRequest();
	$sql = "INSERT INTO `user`
			(`first_name` , `last_name` ,`user_name` ,`password`)
			VALUES
			('".$request->getParam('first_name')."', '".$request->getParam('last_name')."', '".$request->getParam('user_name')."', MD5('".$request->getParam('password')."'))";
	$DB->query($sql);
    $this->view->assign('title','Processo di registrazione');
	$this->view->assign('description','Registrazione avvenuta');  	
  }
È semplice da capire, non è vero?

Successivamente, creare la vista per questo processAction. creare un file denominato “process.phtml” sotto la cartella application/views/scripts/user. Inserire il seguente codice:

Copia codice 

<? include "header.phtml"; ?>
  <h1><?=$this->escape($this->title);?></h1>
  <h2><?=$this->escape($this->description);?></h2>
  <a href="list">Member List</a>
<? include "footer.phtml"; ?>
Ora, puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/user/register. Quindi, immettere un informazioni utente, quali:
Now, point your browser to http://localhost:8050/test/zend/ciaoMondo/web_root/user/register. Quindi, immettere un informazioni utente, quali:
Fare clic sul pulsante di registrazione. Otterrete questo risultato:

Inserendo espressioni a una tabella
⤽
Al post precedente, abbiamo usato um’ordinaria query per i dati di input. Zend Framework ha un modo molto semplice per le query di inserimento. È una buona alternativa, perché è semplice e più pulito.
Si può usare la query in questo modo:
Copia codice 

	$data = array('first_name' => $request->getParam('first_name'),
	  'last_name' => $request->getParam('last_name'),
				  'user_name' => $request->getParam('user_name'),
				  'password' => md5($request->getParam('password'))
	  );
   $DB->insert('user', $data);
LA vecchia query è come questa:
Copia codice 

	$sql = "INSERT INTO `user`
			(`first_name` , `last_name` ,`user_name` ,`password`)
			VALUES (
				'".$request->getParam('first_name')."',
				'".$request->getParam('last_name')."',
				'".$request->getParam('user_name')."',
				MD5('".$request->getParam('password')."'))";
	$DB->query($sql);
Ok, sostituiamo il nostro processAction per farlo diventare come questo:
Copia codice 

  public function processAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
    $request = $this->getRequest();
	$data = array('first_name' => $request->getParam('first_name'),
	  'last_name' => $request->getParam('last_name'),
				  'user_name' => $request->getParam('user_name'),
				  'password' => md5($request->getParam('password'))
	  );
    $DB->insert('user', $data);
    $this->view->assign('title','Processo di registrazione');
	$this->view->assign('description','Registrazione avventa');  	
  }
Creazione Lista dei dati
⤽
Ora, creiamo una lista per visualizzare i dati che abbiamo inseriti nella tabella. Per questo lavoro, creiamo un metodo chiamato “listAction” all’interno del controller. Quindi, creiamo una vista per questa lista.
Aprire “UserController.php” sotto la cartella application/controllers. Aggiungere il seguente metodo:
Copia codice 

  public function listAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
	$DB->setFetchMode(Zend_Db::FETCH_OBJ);
	$sql = "SELECT * FROM `user` ORDER BY user_name ASC";
	$result = $DB->fetchAssoc($sql);
    $this->view->assign('title','Lista membri');
	$this->view->assign('description','Sotto, nostri membri:');
	$this->view->assign('datas',$result);		
  }
Quindi, creare un file chiamato “list.phtml” sotto la cartella application/views/scripts/user. Inserire il seguente codice:
Copia codice 

<? include "header.phtml"; ?>
  <h1><?=$this->escape($this->title);?></h1>
  <h2><?=$this->escape($this->description);?></h2>
  <a href="register">Registrazione</a>
  <table border="1">
    <tr>
	  <th>ID</th>
	  <th>Nome Utente</th>
	  <th>Nome</th>
	  <th>Cognome</th>
	  <th>Azione</th>
	</tr>
  <? $datas = $this->datas;
     for($i = 1; $i<= count($datas);$i++){ ?>
    <tr>
	  <td><?=$datas[$i]['id']?></td>
	  <td><?=$datas[$i]['user_name']?></td>
	  <td><?=$datas[$i]['first_name']?></td>
	  <td><?=$datas[$i]['last_name']?></td>
	  <td>
	    <a href="edit/id/<?=$datas[$i]['id']?>">Edita</a> |
		<a href="del/id/<?=$datas[$i]['id']?>">Elimina</a>
	  </td>
	</tr>
  <? } ?>
  </table>
<? include "footer.phtml"; ?>
Ora, puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/user/list

Creazione form di modifica
⤽
Per creare un modulo per l’edizione, aggiungere un metodo al controller. In questo esercizio, si aggiunge una azione denominata “editAction“. Questa azione mostrerà i dati individuali filtrati dal parametro GET nel protocollo HTTP.
Aprire il file “UserController.php” sotto la cartella application/controllers. Aggiungere il seguente metodo:
Copia codice 

  public function editAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
    $request = $this->getRequest();
	$id 	 = $request->getParam("id");
	$sql = "SELECT * FROM `user` WHERE id='".$id."'";
	$result = $DB->fetchRow($sql);
	$this->view->assign('data',$result);
	$this->view->assign('action', $request->getBaseURL()."/user/processedit");
    $this->view->assign('title','Modifica Membri');
	$this->view->assign('label_fname','Nome');
	$this->view->assign('label_lname','Cognome');
	$this->view->assign('label_uname','Nome Utente');
	$this->view->assign('label_pass','Password');
	$this->view->assign('label_submit','Edita');
	$this->view->assign('description','Compilare questo modulo completamente');
  }
Quindi, creare un file chiamato “edit.phtml” sotto la cartella application/views/scripts/user. Inserire il seguente codice:
Copia codice 

<? include "header.phtml"; ?>
  <h1><?=$this->escape($this->title);?></h1>
  <div id="description">
    <?=$this->escape($this->description);?>
  </div>
  <form name="edit" method="post" action="<?=$this->escape($this->action)?>">
  <input type="hidden" name="id" value="<?=$this->data['id']?>">
  <table>
    <tr>
	  <td><?=$this->escape($this->label_fname)?></td>
	  <td><input type="text" name="first_name" value="<?=$this->data['first_name']?>"></td>
	</tr>
    <tr>
	  <td><?=$this->escape($this->label_lname)?></td>
	  <td><input type="text" name="last_name" value="<?=$this->data['last_name']?>"></td>
	</tr>
    <tr>
	  <td><?=$this->escape($this->label_uname)?></td>
	  <td><input type="text" name="user_name" value="<?=$this->data['user_name']?>"></td>
	</tr>
  </table>
  <input type="submit" name="submit" value="<?=$this->escape($this->label_submit);?>">
  </form>
<? include "footer.phtml"; ?>
Ora, aprire un’altra volta la tabella puntando il browser su http://localhost/test/zend/ciaoMondo/web_root/user/list Clicca il link edit in una delle righe. La pagina aprirà il modulo per per la sua modifica come segue:

Aggiornamento dei dati
⤽
In questo post, creeremo un’azione per l’aggiornamento dei dati. Aprite il vostro “UserController.php” sotto la cartella application/controller. Inserisci la seguente nuova azione:
Copia codice 

  public function processeditAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
	$request = $this->getRequest();
	$sql = "UPDATE `user` SET  `first_name` = '".$request->getParam('first_name')."',
	   `last_name` = '".$request->getParam('last_name')."',
							   `user_name` = '".$request->getParam('user_name')."'
	  WHERE id = '".$request->getParam('id')."'";
	$DB->query($sql);
    $this->view->assign('title','Processo di modifica');
	$this->view->assign('description','Modifica eseguita');  	
  }
Quindi, creare un file chiamato “processedit.phtml” sotto la cartella views/scripts/user. Inserire poi il seguente codice:
Copia codice 

<? include "header.phtml"; ?>
  <h1><?=$this->escape($this->title);?></h1>
  <h2><?=$this->escape($this->description);?></h2>
  <a href="list">Lista membri</a>
<? include "footer.phtml"; ?>
Ok, tenta ora di aggiornare i dati dal modulo di modifica.
Così come le query di inserimento, Zend Framework ha un’altra possibilità per creare delle query di aggiornamento. È più semplice e ordinato. Si può usare in questo modo:
Copia codice 

$data = array(
			'first_name' => $request->getParam('first_name'),
			'last_name' => $request->getParam('last_name'),
			'user_name' => $request->getParam('user_name'),
			'password' => md5($request->getParam('password'))
		);
$DB->update('user', $data,'id = 1');
Di seguito il codice completo per il metodo processeditAction:
Copia codice 

  public function processeditAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
	$request = $this->getRequest();
	$data = array(
				'first_name' => $request->getParam('first_name'),
				'last_name' => $request->getParam('last_name'),
				'user_name' => $request->getParam('user_name'),
				'password' => md5($request->getParam('password'))
			);
    $DB->update('user', $data,'id = '.$request->getParam('id'));	
    $this->view->assign('title','Processo di modifica');
	$this->view->assign('description','Modifica eseguita');  	
  }
Eliminazione di dati
⤽
Ultima azione di questa serie è la cancellazione dei dati. Per questo lavoro, creare un nuovo metodo nel controller.
Apriree il file “UserController.php” sotto la cartella application/controllers. Aggiungere un nuovo metodo per l’azione di eliminazione alla classe (io darei il nome “delAction“):
Copia codice 

  public function delAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
	$request = $this->getRequest();
	$sql = "DELETE FROM `user` WHERE id='".$request->getParam('id')."'";
	$DB->query($sql);
    $this->view->assign('title','Eliminazione Dati');
	$this->view->assign('description','Eliminazione avvenuta');
    $this->view->assign('list',$request->getBaseURL()."/user/list");
Quindi, creare una nuova view per questa azione con un file chiamato “del.phtml” sotto la cartella application/views/scripts/user. Inserire poi il seguente codice:
Copia codice 

<? include "header.phtml"; ?>
  <h1><?=$this->escape($this->title);?></h1>
  <h2><?=$this->escape($this->description);?></h2>
  <a href="<?=$this->escape($this->list);?>">Member List</a>
<? include "footer.phtml"; ?>
Ora, provate a verificare dai dati della tabella. Clicca il link presso una delle righe.
Eliminazione di dati stile query
⤽
Come le query per l’inserimento e aggiornamento, Zend Framework ha un’altra opzione per le query di eliminazione. È possibile utilizzare questo stile, e sono sicuro che sarà come:
Copia codice 
>
$DB->delete('user', 'id = 3');
Ok, tenta di aggiornare il vostro delAction per farlo diventare come questo:
Copia codice 

  public function delAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
	$request = $this->getRequest();
    $DB->delete('user', 'id = '.$request->getParam('id'));	
    $this->view->assign('title','Eliminazione Dati');
	$this->view->assign('description','Eliminazione avvenuta');
    $this->view->assign('list',$request->getBaseURL()."/user/list");  
  }
Ok, ora, siete pronti a documentarvi di più sullo stile di Zend Framework per le query consultando la guida a Zend Framework.
Riassumendo Action Controller
⤽
Questo è all’ultimo post del capitolo Zend Framework Database. In questo post, si può guardare l’azione completa che avevamo parlato.
Copia codice 

<?php
require_once 'Zend/Db/Adapter/Pdo/Mysql.php';
require_once 'Zend/Controller/Action.php';
class UserController extends Zend_Controller_Action
{
  public function indexAction()
  {
    $this->view->assign('name', 'Manager');
    $this->view->assign('title', 'Ciao');
  }
  public function nameAction()
  {
    $request = $this->getRequest();
    $this->view->assign('name', $request->getParam('username'));
    $this->view->assign('gender', $request->getParam('gender'));	  
    $this->view->assign('title', 'Nome Utente');
  }  
  public function registerAction()
  {
    $request = $this->getRequest();
	$this->view->assign('action',"process");
    $this->view->assign('title','Registrazione Membri');
	$this->view->assign('label_fname','Nome');
	$this->view->assign('label_lname','Cognome');
	$this->view->assign('label_uname','Nome Utente');
	$this->view->assign('label_pass','Password');
	$this->view->assign('label_submit','Registra');
	$this->view->assign('description','Compilare questo modulo completamente:');
  }
  public function editAction()
  {
    $params = array('host'	=>'localhost',
	'username'	=>'root',
		    'password'  =>'password',
		    'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
    $request = $this->getRequest();
	$id 	 = $request->getParam("id");
	$sql = "SELECT * FROM `user` WHERE id='".$id."'";
	$result = $DB->fetchRow($sql);
	$this->view->assign('data',$result);
	$this->view->assign('action', $request->getBaseURL()."/user/processedit");
    $this->view->assign('title','Modifica Membri');
	$this->view->assign('label_fname','Nome');
	$this->view->assign('label_lname','Cognome');
	$this->view->assign('label_uname','Nome Utente');
	$this->view->assign('label_pass','Password');
	$this->view->assign('label_submit','Edita');
	$this->view->assign('description','Compilare questo modulo completamente:');
  }  
  public function processAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
    $request = $this->getRequest();
	$data = array('first_name' => $request->getParam('first_name'),
	  'last_name' => $request->getParam('last_name'),
				  'user_name' => $request->getParam('user_name'),
				  'password' => md5($request->getParam('password'))
	  );
    $DB->insert('user', $data);
    $this->view->assign('title','Processo di registrazione');
	$this->view->assign('description','Registrazione avventa');	
  }
  public function listAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
	$DB->setFetchMode(Zend_Db::FETCH_OBJ);
	$sql = "SELECT * FROM `user` ORDER BY user_name ASC";
	$result = $DB->fetchAssoc($sql);
    $this->view->assign('title','Lista membri');
	$this->view->assign('description','Sotto, nostri membri:');
	$this->view->assign('datas',$result);		
  }
  public function processeditAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
	$request = $this->getRequest();
	$data = array('first_name' => $request->getParam('first_name'),
	  'last_name' => $request->getParam('last_name'),
				  'user_name' => $request->getParam('user_name'),
				  'password' => md5($request->getParam('password'))
	  );
    $DB->update('user', $data,'id = '.$request->getParam('id'));	
    $this->view->assign('title','Processo di modifica');
	$this->view->assign('description','Modifica eseguita');
  }
  public function delAction()
  {
    $params = array('host'		=>'localhost',
	    'username'	=>'root',
					'password'  =>'password',
					'dbname'	=>'zend'
	   );
	$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
	$request = $this->getRequest();
    $DB->delete('user', 'id = '.$request->getParam('id'));	
    $this->view->assign('title','Eliminazione Dati');
	$this->view->assign('description','Eliminazione avvenuta');
    $this->view->assign('list',$request->getBaseURL()."/user/list");
  }
}
?>

[nextpage title=”Zend Framework Registry”]
Impostazione e lettura dei valori
⤽
Cosa sono i Registri? È come un memorizzare globale. Dobbiamo solo registrare valori e allora si possono utilizzare in tutta l’applicazione. Per esempio, possiamo memorizzare il nome dell’applicazione, così ogni volta che abbiamo bisogno di visualizzare il nome dell’applicazione, facciamo una chiamata al Registro.
Per utilizzare il Registro, dobbiamo inserire il file registry.php di Zend Framework nell’applicazione:
Copia codice 

require_once 'Zend/Registry.php';
Ok, ora faremo un po’ di pratica utilizzando il Registro. Usiamo ancora il nostro precedente esercizio. Si prega di leggere che il post di prima. Poi, seguire la seguente procedura:

  1. Aprire quindi il file “index.php” sotto “web_root“. Inserire le linee 09 – 12:
    Copia codice 
    
<?php
error_reporting(E_ALL|E_STRICT);
ini_set('display_errors', true);
date_default_timezone_set('Europe/Berlin');
$rootDir = dirname(dirname(__FILE__));
set_include_path($rootDir . '/library' . PATH_SEPARATOR . get_include_path());
require_once 'Zend/Controller/Front.php';
require_once 'Zend/Registry.php';
Zend_Registry::set('title',"Mia prima applicazione");
Zend_Controller_Front::run('../application/controllers');
?>
    Abbiamo impostato nel registro un parametro denominato “title” e abbiamo messo un valore a questo parametro.
  2. Quindi, proviamo a chiamare/leggere questo registro. Apri il tuo UserController.php sotto la cartella application/controller.
  3. Aggiornare il metodo indexAction come segue:
    Copia codice 
    
public function indexAction()
{
    $title = Zend_Registry::get('title');
    $this->view->assign('name', 'Manager');
    $this->view->assign('title', $title);
}

Testare le modifiche puntando il browser a: http://localhost/test/zend/ciaoMondo/web_root/user/.

Memorizzare i valori in array
⤽
In questa parte si parla di come registrare un valore di array e come leggerli? Ogni valore conservarto nel registro può essere letto come array. Ok, per capire meglio seguire questa procedura.
Quindi, Apriamo di nuovo il file index.php sotto la cartella web_root.
Copia codice 

<?php
error_reporting(E_ALL|E_STRICT);
ini_set('display_errors', true);
date_default_timezone_set('Europe/Berlin');
$rootDir = dirname(dirname(__FILE__));
set_include_path($rootDir . '/library' . PATH_SEPARATOR . get_include_path());
require_once 'Zend/Controller/Front.php';
require_once 'Zend/Registry.php';
Zend_Registry::set('title',"Mia prima applicazione");
$arrName = array('Mario Balducci', 'Federico Rossi',
     'Sergio Parilli', 'Francesco Belli');
Zend_Registry::set('credits',$arrName);
Zend_Controller_Front::run('../application/controllers');
?>
Si registra un parametro di un array denominato “credits” sulle righe riga 15-17. Come leggerlo?
Ok, proviamo nuovamente ad aggiornare “UserController.php“. Aggiornando indexAction diventa:
Copia codice 

  public function indexAction()
  {
    $registry = Zend_Registry::getInstance();
	$title 		= $registry['title'];
	$credits 	= $registry['credits'];
	$strCredit = implode(", ",$credits);
    $this->view->assign('name', 'Manager');
    $this->view->assign('title', $title);
    $this->view->assign('credits', $strCredit);
  }
Questo è un altro modo di leggere il registro. Si può usare per leggere diversi valori dal registro.
Ok, prima di provarlo aggiornare la vista in index.phtml sotto la cartella application/views/scripts/user. Aggiorna con il seguente codice:
Copia codice 

<!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">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title><? echo $this->escape($this->title); ?></title>
</head>
<body>
  <h1><?=$this->escape($this->title);?>, <?=$this->escape($this->name);?></h1>
  credits: <?=$this->escape($this->credits);?>
</body>
</html>
Prova da puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/user/.
Lavorare con gli oggetti
⤽
Siamo in grado di memorizzare oggetti nel Zend_Registry. Come applicarla? E per cosa? Ricordate, nel nostro esercizio nel capitolo Zend Framework Database stavamo sempre a scrivere i dati di configurazione del database e la sua connessione svariate più volte. Ogni volta che c’era la connessione al database, dovevamo scrivere la connessione. Siamo in grado di risparmiare (energia), scrivendola una sola volta e memorizzarla nel registro.
Per registrare la connessione al database, si può usare questo modo:
Copia codice 

$params = array('host'=>'localhost',
	'username'=>'root',
				'password' =>'password',
				'dbname'=>'zend'
	);
$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
$DB->setFetchMode(Zend_Db::FETCH_OBJ);
Zend_Registry::set('DB',$DB);
Poi, per leggerlo:
Copia codice 

    $registry = Zend_Registry::getInstance();
    $DB = $registry['DB'];
Ok, per la pratica, apriamo il file index.php sotto la cartella web_root. Il suo aggiornamento diventerebbe come segue:
Copia codice 

<?php
error_reporting(E_ALL|E_STRICT);
ini_set('display_errors', true);
date_default_timezone_set('Europe/Berlin');
$rootDir = dirname(dirname(__FILE__));
set_include_path($rootDir . '/library' . PATH_SEPARATOR . get_include_path());
require_once 'Zend/Controller/Front.php';
require_once 'Zend/Registry.php';
require_once 'Zend/Db/Adapter/Pdo/Mysql.php';
Zend_Registry::set('title',"Mia prima applicazione");
$arrName = array('Mario Balducci', 'Federico Rossi',
     'Sergio Parilli', 'Francesco Belli');
Zend_Registry::set('credits',$arrName);
$params = array('host'=>'localhost',
	  'username'=>'root',
		'password'=>'password',
		'dbname'=>'zend'
	  );
$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
$DB->setFetchMode(Zend_Db::FETCH_OBJ);
Zend_Registry::set('DB',$DB);
Zend_Controller_Front::run('../application/controllers');
?>
Successivamente, aggiorniamo “UserController.php” sotto la cartella application/controllers per farlo diventare come questo:
Copia codice 

<?php
require_once 'Zend/Controller/Action.php';
class UserController extends Zend_Controller_Action
{
  public function indexAction()
  {
    $registry = Zend_Registry::getInstance();
	$title 		= $registry['title'];
	$credits 	= $registry['credits'];
	$strCredit = implode(", ",$credits);
    $this->view->assign('name', 'Manager');
    $this->view->assign('title', $title);
    $this->view->assign('credits', $strCredit);
  }
  public function nameAction()
  {
    $request = $this->getRequest();
    $this->view->assign('name', $request->getParam('username'));
    $this->view->assign('gender', $request->getParam('gender'));
    $this->view->assign('title', 'Nome Utente');
  }  
  public function registerAction()
  {
    $request = $this->getRequest();
	$this->view->assign('action',"process");
    $this->view->assign('title','Registrazione Membri');
	$this->view->assign('label_fname','Nome');
	$this->view->assign('label_lname','Cognome');
	$this->view->assign('label_uname','Nome Utente');
	$this->view->assign('label_pass','Password');
	$this->view->assign('label_submit','Registra');
	$this->view->assign('description','Compilare questo modulo completamente:');
  }
  public function editAction()
  {
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
    $request = $this->getRequest();
	$id 	 = $request->getParam("id");
	$sql = "SELECT * FROM `user` WHERE id='".$id."'";
	$result = $DB->fetchRow($sql);
	$this->view->assign('data',$result);
	$this->view->assign('action', $request->getBaseURL()."/user/processedit");
    $this->view->assign('title','Modifica Membri');
	$this->view->assign('label_fname','Nome');
	$this->view->assign('label_lname','Cognome');
	$this->view->assign('label_uname','Nome Utente');
	$this->view->assign('label_pass','Password');
	$this->view->assign('label_submit','Edita');
	$this->view->assign('description','Compilare questo modulo completamente:');
  }  
  public function processAction()
  {
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
    $request = $this->getRequest();
	$data = array('first_name' => $request->getParam('first_name'),
	  'last_name' => $request->getParam('last_name'),
				  'user_name' => $request->getParam('user_name'),
				  'password' => md5($request->getParam('password'))
	  );
    $DB->insert('user', $data);
    $this->view->assign('title','Processo di registrazione');
	$this->view->assign('description','Registrazione avventa');
  }
  public function listAction()
  {
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
	$sql = "SELECT * FROM `user` ORDER BY user_name ASC";
	$result = $DB->fetchAssoc($sql);
    $this->view->assign('title','Lista membri');
	$this->view->assign('description','Sotto, nostri membri:');
	$this->view->assign('datas',$result);
  }
  public function processeditAction()
  {
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
	$request = $this->getRequest();
	$data = array('first_name' => $request->getParam('first_name'),
	  'last_name' => $request->getParam('last_name'),
				  'user_name' => $request->getParam('user_name'),
				  'password' => md5($request->getParam('password'))
	  );
    $DB->update('user', $data,'id = '.$request->getParam('id'));	
    $this->view->assign('title','Processo di modifica');
	$this->view->assign('description','Modifica eseguita');
  }
  public function delAction()
  {
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
	$request = $this->getRequest();
    $DB->delete('user', 'id = '.$request->getParam('id'));	
    $this->view->assign('title','Eliminazione Dati');
	$this->view->assign('description','Eliminazione avvenuta');
    $this->view->assign('list',$request->getBaseURL()."/user/list");
  }
}
?>
Riesci a vederlo? È semplice, non è vero?

[nextpage title=”Zend Framework Config”]
Utilizzo di array nella configuration
⤽
Ci sono informazioni importanti per costruire un’applicazione con il database, come lo host del database, il nome del database, l’utente, database, il nome di applicazione, e così via. Queste informazioni vengono recuperati estensivamente. Sarebbe conciso se li mettiamo da qualche parte nella configurazione. Zend Framework ha Zend_Config, ch’è stato progettato per semplificare l’accesso e l’utilizzo dei dati di configurazione all’interno delle applicazioni.
In questo post, vediamo come implementare Zend_Config usando un array. Per caso, vedetee il nostro codice nel tutorial precedente:
Copia codice 

<?php
error_reporting(E_ALL|E_STRICT);
ini_set('display_errors', true);
date_default_timezone_set('Europe/Berlin');
$rootDir = dirname(dirname(__FILE__));
set_include_path($rootDir . '/library' . PATH_SEPARATOR . get_include_path());
require_once 'Zend/Controller/Front.php';
require_once 'Zend/Registry.php';
require_once 'Zend/Db/Adapter/Pdo/Mysql.php';
Zend_Registry::set('title',"Mia prima applicazione");
$arrName = array('Mario Balducci', 'Federico Rossi',
     'Sergio Parilli', 'Francesco Belli');
Zend_Registry::set('credits',$arrName);
$params = array('host'=>'localhost',
		'username'	=>'root',
		'password'  =>'password',
		'dbname'	=>'zend'
				);
$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
$DB->setFetchMode(Zend_Db::FETCH_OBJ);
Zend_Registry::set('DB',$DB);
Zend_Controller_Front::run('../application/controllers');
?>
Questo è il file index.php posizionato sotto la cartella web_root. Le linee 15 e 20-25 sono utilizzati spesso lungo l’applicazione. Possiamo mettere la configurazione in un array in questo modo:
Copia codice 

<?php
error_reporting(E_ALL|E_STRICT);
ini_set('display_errors', true);
date_default_timezone_set('Europe/Berlin');
$rootDir = dirname(dirname(__FILE__));
set_include_path($rootDir . '/library' . PATH_SEPARATOR . get_include_path());
require_once 'Zend/Controller/Front.php';
require_once 'Zend/Registry.php';
require_once 'Zend/Db/Adapter/Pdo/Mysql.php';
require_once 'Zend/Config.php';
$arrConfig = array(
'webhost'=>'localhost',
	  'appName'=>'Mia prima applicazione',
	  'database'=>array(
	'dbhost'=>'localhost',
		  'dbname'=>'zend',
		  'dbuser'=>'root',
		  'dbpass'=>'password'
	)
);
$config = new Zend_Config($arrConfig);
$title  = $config->appName;
$params = array('host'		=>$config->database->dbhost,
	'username'	=>$config->database->dbuser,
			    'password'  =>$config->database->dbpass,
				'dbname'	=>$config->database->dbname
	);
Zend_Registry::set('title',$title);
$arrName = array('Mario Balducci', 'Federico Rossi',
     'Sergio Parilli', 'Francesco Belli');
Zend_Registry::set('credits',$arrName);
$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
$DB->setFetchMode(Zend_Db::FETCH_OBJ);
Zend_Registry::set('DB',$DB);
Zend_Controller_Front::run('../application/controllers');
?>
In primo luogo, carichiamo Zend/Config.php (vedi linea 12). Quindi creare un array per contenere la configurazione (vedi linea 14-23). Successivamente, creare l’object-oriented wrapper sui dati di configurazione (vedi linea 28). Per ultimo, usiamo i dati di configurazione per l’accesso al database (vedi linea 28-32).
Creazione File di configurazione
⤽
Per una facile manutenzione, abbiamo messo i dati di configurazione nel file separati. Per esempio, in un file config.php. Facciamolo.
Creare un file chiamato “config.php” all’interno dell’applicazione. Inserisci il seguente codice:
Copia codice 

<?
return array(
'webhost'=>'localhost',
	  'appName'=>'Mia prima applicazione',
	  'database'=>array(
	'host'=>'localhost',
		  'dbname'=>'zend',
		  'username'=>'root',
		  'password'=>'password'
	  )
   );
?>
Per chiamare questo file, possiamo usare in questo modo:
Copia codice 

$config = new Zend_Config(require '../application/config.php');
Questo è il codice completo:
Copia codice 

<?php
error_reporting(E_ALL|E_STRICT);
ini_set('display_errors', true);
date_default_timezone_set('Europe/Berlin');
$rootDir = dirname(dirname(__FILE__));
set_include_path($rootDir . '/library' . PATH_SEPARATOR . get_include_path());
require_once 'Zend/Controller/Front.php';
require_once 'Zend/Registry.php';
require_once 'Zend/Db/Adapter/Pdo/Mysql.php';
require_once 'Zend/Config.php';
$config = new Zend_Config(require '../application/config.php');
$title  = $config->appName;
$params = $config->database->toArray();
Zend_Registry::set('title',$title);
$arrName = array('Mario Balducci', 'Federico Rossi',
     'Sergio Parilli', 'Francesco Belli');
Zend_Registry::set('credits',$arrName);
$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
$DB->setFetchMode(Zend_Db::FETCH_OBJ);
Zend_Registry::set('DB',$DB);
Zend_Controller_Front::run('../application/controllers');
?>
Utilizzo del file di configurazione INI
⤽
Abbiamo imparato come utilizzare Zend_Config al post precedente. Ora, cerchiamo di realizzarlo tramite un file ini.
Creare un file chiamato “config.ini” all’interno dell’applicazione. Inserisci il seguente esempio di configurazione:
Copia codice 

; Sito in produzione. Dati di configurazione
[app]
webhost     = www.esempio.com
title			  = Mia prima applicazione
database.host     = localhost
database.username = root
database.password = password
database.dbname   = zend
Per leggere questo tipo di configurazione, usiamo in questo modo:
Copia codice 

<?php
require_once 'Zend/Config/Ini.php';
$config = new Zend_Config_Ini('../application/config.ini','app');
$title  = $config->appName;
$params = $config->database->toArray();
Segue il codice completo:
Copia codice 

<?php
error_reporting(E_ALL|E_STRICT);
ini_set('display_errors', true);
date_default_timezone_set('Europe/Berlin');
$rootDir = dirname(dirname(__FILE__));
set_include_path($rootDir . '/library' . PATH_SEPARATOR . get_include_path());
require_once 'Zend/Controller/Front.php';
require_once 'Zend/Registry.php';
require_once 'Zend/Db/Adapter/Pdo/Mysql.php';
require_once 'Zend/Config/Ini.php';
$config = new Zend_Config_Ini('../application/config.ini','app');
$title  = $config->appName;
$params = $config->database->toArray();
Zend_Registry::set('title',$title);
$arrName = array('Mario Balducci', 'Federico Rossi',
     'Sergio Parilli', 'Francesco Belli');
Zend_Registry::set('credits',$arrName);
$DB = new Zend_Db_Adapter_Pdo_Mysql($params);
$DB->setFetchMode(Zend_Db::FETCH_OBJ);
Zend_Registry::set('DB',$DB);
Zend_Controller_Front::run('../application/controllers');
?>
Utilizzo del file di configurazione XML
⤽
Questa è un’altra alternativa per creare un file di configurazione. Possiamo memorizzare i dati di configurazione in un semplice formato XML. Per leggerlo, si usa Zend_Config_Xml().
In primo luogo, creare un file XML denominato “config.xml” all’interno dell’applicazione. Inserire il seguente codice:
Copia codice 

<?xml version="1.0"?>
<configdata>
  <app>
    <webhost>www.esempio.com</webhost>
    <title>Mia prima applicazione</title>
	<database>
	  <host>localhost</host>
	  <username>root</username>
	  <password>password</password>
	  <dbname>zend</dbname>
	</database>
  </app>
</configdata>
Per accedervi, si può usare:
Copia codice 

require_once 'Zend/Config/Xml.php';
$config = new Zend_Config_Xml('../application/config.xml','app');

[nextpage title=”Zend Framework Login”]
Preparando il Database
⤽
La pagina di login è una parte importante per un’applicazione con un database. In questo capitolo, parleremo di come creare semplice sistema di accesso con Zend Framework. Ci sono diversi scenari possibili, ma si sceglierà il login con il database. Questo vuol dire che abbiamo bisogno di un database per memorizzare i dati dei membri.
Useremo ancora lo stesso database dell’esercizio precedente. Il nome del database è “zend“. Ora, creare la tabella per memorizzare le informazioni membri. Il nome della tabella è “users“. È possibile utilizzare la seguente query:
Copia codice 

CREATE TABLE `users` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(50) NOT NULL,
  `password` varchar(255) NOT NULL,
  `real_name` varchar(50) NOT NULL,
  PRIMARY KEY  (`id`),
  UNIQUE KEY `username` (`username`)
);
Ora, provate a inserire i dati di un membro come campione, ad esempio:
Copia codice 

INSERT INTO `users`
(`id`, `username`, `password`, `real_name`)
VALUES
(1, 'admin', '21232f297a57a5a743894a0e4a801fc3', 'Administrator');
Nella query di sopra, inseriamo un membro con il nome utente “admin”. In realtà, la sua password è admin. Ma, per motivi di sicurezza, si usa MD5(), per questo motivo, la password che viene memorizzata nel database diventa 21232f297a57a5a743894a0e4a801fc3.
Copia codice 

INSERT INTO `users` (`id` ,`username` ,`password` ,`real_name`)
VALUES (NULL , 'admin', MD5( 'admin' ) , 'Administrator');
Questa è l’immagine se usiamo phpMyAdmin.
create user for zend framework login system
Creazione Login Form
⤽
Per costruire sistema di login, abbiamo bisogno di form per il login. In questo post, impareremo a costruire semplice form per il login.
In primo luogo, creare un file denominato “loginform.phtml” sotto la cartella application/views/scripts/user. Inserire il seguente codice:
Copia codice 

<? include "header.phtml"; ?>
  <h1><?=$this->escape($this->title);?></h1>
  <form method='post' action='<?=$this->escape($this->action);?>'>
  <table>
    <tr>
	  <td><?=$this->escape($this->username);?></td>
	  <td><input type='text' name='username'></td>
	</tr>
    <tr>
	  <td><?=$this->escape($this->password);?></td>
	  <td><input type='password' name='password'></td>
	</tr>
  </table>
  <input type='submit' name='login' value='Login'>
  </form>
<? include "footer.phtml"; ?>
Successivamente, creare loginformAction al controller. Aprire il file UserController.php sotto la cartella application/controllers. Aggiungi il metodo loginFormAction():
Copia codice 

  public function loginformAction()
  {
    $request = $this->getRequest();
	$this->view->assign('action', $request->getBaseURL()."/user/auth");
    $this->view->assign('title', 'Login Form');
    $this->view->assign('username', 'Nome Utente');
    $this->view->assign('password', 'Password');
  }
Questo form invia due parametri: username e password. Essi vengono inviati alla pagina user/auth.
Ora, puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/user/loginform. Si ottiene qualcosa come questo:

Creazione di autenticazione
⤽
Dopo la creazione del form di login, abbiamo bisogno dell’autenticazione. I dati verranno controllati con i dati esistenti al database.
Basta ricordare, che form di login invia due parametri: username e password. Essi vengono inviati alla pagina user/auth. Quindi, dobbiamo costruire il metodo authAction() in UserController.
authAction() serve per la convalida dei dati. I dati inviati dal modulo di login saranno verificate a authAction(). Aprite il file “UserController.php“. Prima, caricare Zend/Auth.php e Zend/Auth/Adapter/DbTable.php. Quindi includere all’inizio prima di ogni metodo():
Copia codice 

<?php
require_once 'Zend/Auth.php';
require_once 'Zend/Auth/Adapter/DbTable.php';
...
?>
Aggiungere authAction() come segue:
Copia codice 

<?php
  public function authAction(){
    $request 	= $this->getRequest();
    $registry 	= Zend_Registry::getInstance();
	$auth		= Zend_Auth::getInstance(); 
	$DB = $registry['DB'];
    $authAdapter = new Zend_Auth_Adapter_DbTable($DB);
    $authAdapter->setTableName('users')
    ->setIdentityColumn('username')
    ->setCredentialColumn('password');    
	// Impostare i valori di input delle credenziali
	$uname = $request->getParam('username');
	$paswd = $request->getParam('password');
    $authAdapter->setIdentity($uname);
    $authAdapter->setCredential(md5($paswd));
    // Eseguire la query di autenticazione
    // salvando il risultato
    $result = $auth->authenticate($authAdapter);
    if($result->isValid()){
	  $data = $authAdapter->getResultRowObject(null,'password');
	  $auth->getStorage()->write($data);
	  $this->_redirect('/user/userpage');
	}else{
	  $this->_redirect('/user/loginform');
	}
 }
In primo luogo, carichiamo l’adattatore del database dal registro di sistema (linee 3, 6). Se ancora non si capisce questo codice, si prega di leggere i capitoli su Zend Framework Database e Zend Framework Registry.
Poi, defininiamo l’adattatore per l’autenticazione:
Copia codice 

$authAdapter = new Zend_Auth_Adapter_DbTable($DB);
Quindi, possiamo definire il nome della tabella e la colonna che contiene username e password.
Copia codice 

    $authAdapter->setTableName('users')
    ->setIdentityColumn('username')
    ->setCredentialColumn('password');
Quindi, prendiamo i parametri HTTP che contengono username e password:
Copia codice 

	$uname = $request->getParam('username');
	$paswd = $request->getParam('password');
    $authAdapter->setIdentity($uname);
    $authAdapter->setCredential(md5($paswd));
Quindi, fare l’autenticazione:
Copia codice 

    $result = $auth->authenticate($authAdapter);
    if($result->isValid()){
	  $data = $authAdapter->getResultRowObject(null,'password');
	  $auth->getStorage()->write($data);
	  $this->_redirect('/user/userpage');
	}else{
	  $this->_redirect('/user/loginform');
	}
 }
Se l’utente è valido, salveremo i dati dell’utente durante la sessione utilizzando:
Copia codice 

	  $data = $authAdapter->getResultRowObject(null,'password');
	  $auth->getStorage()->write($data);
Poi, pagina sarà reindirizzata alla pagina protetta (chiamata pagina utente in questo tutorial). Prossimo post, parleremo di pagina protetta. È semplice, non è vero?
Ok, questo è il nostro metodo UserController completo:
Copia codice 

<?php
require_once 'Zend/Controller/Action.php';
require_once 'Zend/Auth.php';
require_once 'Zend/Auth/Adapter/DbTable.php';
class UserController extends Zend_Controller_Action
{
  public function loginFormAction()
  {
    $request = $this->getRequest();
	$this->view->assign('action', $request->getBaseURL()."/user/auth");
    $this->view->assign('title', 'Login Form');
    $this->view->assign('username', 'Nome Utente');
    $this->view->assign('password', 'Password');
  }
  public function authAction(){
    $request 	= $this->getRequest();
    $registry 	= Zend_Registry::getInstance();
	$auth		= Zend_Auth::getInstance(); 
	$DB = $registry['DB'];
	$authAdapter = new Zend_Auth_Adapter_DbTable($DB);
    $authAdapter->setTableName('users')
    ->setIdentityColumn('username')
    ->setCredentialColumn('password');    
	// Impostare i valori di input delle credenziali
	$uname = $request->getParam('username');
	$paswd = $request->getParam('password');
    $authAdapter->setIdentity($uname);
    $authAdapter->setCredential(md5($paswd));
    // Eseguire la query di autenticazione
    // salvando il risultato
    $result = $auth->authenticate($authAdapter);
    if($result->isValid()){
//print_r($result);
	  $data = $authAdapter->getResultRowObject(null,'password');
	  $auth->getStorage()->write($data);
	  $this->_redirect('/user');
	}else{
	  $this->_redirect('/user/loginform');
	}
  }  
  public function nameAction()
  {
    $request = $this->getRequest();
    $this->view->assign('name', $request->getParam('username'));
    $this->view->assign('gender', $request->getParam('gender'));	  
    $this->view->assign('title', 'Nome Utente');
  }  
  public function registerAction()
  {
    $request = $this->getRequest();
	$this->view->assign('action',"process");
    $this->view->assign('title','Registrazione Membri');
	$this->view->assign('label_fname','Nome');
	$this->view->assign('label_lname','Cognome');
	$this->view->assign('label_uname','Nome Utente');
	$this->view->assign('label_pass','Password');
	$this->view->assign('label_submit','Registra');
	$this->view->assign('description','Compilare questo modulo completamente:');
  }
  public function editAction()
  {
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
    $request = $this->getRequest();
	$id 	 = $request->getParam("id");
	$sql = "SELECT * FROM `user` WHERE id='".$id."'";
	$result = $DB->fetchRow($sql);
	$this->view->assign('data',$result);
	$this->view->assign('action', $request->getBaseURL()."/user/processedit");
    $this->view->assign('title','Modifica Membri');
	$this->view->assign('label_fname','Nome');
	$this->view->assign('label_lname','Cognome');
	$this->view->assign('label_uname','Nome Utente');
	$this->view->assign('label_pass','Password');
	$this->view->assign('label_submit','Edita');
	$this->view->assign('description','Compilare questo modulo completamente:');
  }  
  public function processAction()
  {
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
    $request = $this->getRequest();
	$data = array('first_name' => $request->getParam('first_name'),
	  'last_name' => $request->getParam('last_name'),
				  'user_name' => $request->getParam('user_name'),
				  'password' => md5($request->getParam('password'))
	  );
    $DB->insert('user', $data);	
    $this->view->assign('title','Processo di registrazione');
	$this->view->assign('description','Registrazione avventa');  	
  }
  public function listAction()
  {
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
	$sql = "SELECT * FROM `user` ORDER BY user_name ASC";
	$result = $DB->fetchAssoc($sql);
    $this->view->assign('title','Lista membri');
	$this->view->assign('description','Sotto, nostri membri:');
	$this->view->assign('datas',$result);		
  }
  public function processeditAction()
  {
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
	$request = $this->getRequest();
	$data = array('first_name' => $request->getParam('first_name'),
	  'last_name' => $request->getParam('last_name'),
				  'user_name' => $request->getParam('user_name'),
				  'password' => md5($request->getParam('password'))
	  );
    $DB->update('user', $data,'id = '.$request->getParam('id'));	
    $this->view->assign('title','Processo di modifica');
	$this->view->assign('description','Modifica eseguita');		
  }
  public function delAction()
  {
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
	$request = $this->getRequest();
    $DB->delete('user', 'id = '.$request->getParam('id'));	
    $this->view->assign('title','Eliminazione Dati');
	$this->view->assign('description','Eliminazione avvenuta');
    $this->view->assign('list',$request->getBaseURL()."/user/list");  
  }
}
?>
Impossibile utilizzare oggetti di tipo stdClass come array
⤽
Se eseguiamo l’esempio precedente e riceviamo il seguente messaggio di errore: C:\AppServ5\www\test\zend\ciaoMondo\library\Zend\Auth\Adapter\DbTable.php on line 340 Se avete lo stesso messaggio di errore, cerchiamo di risolvere questo problema. Saltare questo capitolo se non avete lo stesso errore.
Purtroppo, ancora non ho avuto molto tempo per sapere come risolvere questo errore quando stavo scrivendo questo post. Così, ho deciso di fissarlo al cuore della libreria Zend. Vi dirò dopo se trovo la correzione per questo errore.
Ok, Aprire il file DbTable.php sotto la cartella library\Zend\Auth\Adapter\. Aggiornare la linea 340:
Prima:
Copia codice 

if ($resultIdentity['zend_auth_credential_match'] != '1') {
Dopo:
Copia codice 

if ($resultIdentity->zend_auth_credential_match != '1') {
Quindi, aggiornare la linea 346:
Copia codice 

unset($resultIdentity['zend_auth_credential_match']);
Diventa:
Copia codice 

unset($resultIdentity->zend_auth_credential_match);

Nota

Andando a cercare una soluzione semplice senza modificare lo Zend Framework ho trovato una funzione ricorsiva che garantisce il recupero dei dati come ci si aspetta

Copia codice 

<?php
function objectToArray($d) {
	if (is_object($d)) {
		// Ottiene le proprietà dell'oggetto
		// data con funzione get_object_vars()
		$d = get_object_vars($d);
	}
	if (is_array($d)) {
		/*
		* Restituisce un'array convertito
		* in oggetto usando
		*  __FUNCTION__ (costante magica)
		* con la chiamata ricorsiva
		*/
		return array_map(__FUNCTION__, $d);
	}
	else {
		// ritorna l'array
		return $d;
	}
}
?>
Questo metodo lo possiamo inserire nel file “UserController.php” sotto la cartella application/controllers e utizzarlo come segue:
Copia codice 

<?php
$data = $this->objectToArray($this->data);
?>

Pagina protetta
⤽
Abbiamo creato l’autenticazione nel capitolo precedente. Ora, cerchiamo di proteggere una pagina. Così, quando i non membri tentano di entrare nella pagina, verrà reindirizzato alla form di login.
In primo luogo, creiamo la view. Creare un file denominato “userpage.phtml” sotto la cartella application/views/scripts/user. Inserire il seguente codice:
Copia codice 

<? include "header.phtml"; ?>
<h1>Ciao, <?=$this->escape($this->username);?></h1>
<a href='<?=$this->escape($this->urllogout);?>'>Logout</a>
<? include "footer.phtml"; ?>
Poi, si aggiunge un metodo al controller.
Aprire il file “UserController.php“. Aggiungere il seguente metodo:

Copia codice 

public function userpageAction(){
    $auth		= Zend_Auth::getInstance(); 
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}
    $request = $this->getRequest();
	$user		= $auth->getIdentity();
	$real_name	= $user->real_name;
	$username	= $user->username;
	$logoutUrl  = $request->getBaseURL().'/user/logout';
	$this->view->assign('username', $real_name);
	$this->view->assign('urllogout',$logoutUrl);
}
Line 2 – 6 abbiamo bisogno di proteggere gli utenti nella pagina protetta.
Prova a effettuare il login. Puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/user/loginform. Effettuare il login.
Creazione Logout
⤽
Nella pagina protetta (nel post precedente, avevamo creato un collegamento al logout. Questo è il discorso del post sulla pagina di logout.
Innanzitutto, creare la view per il logout. Creare un file denominato “logout.phtml” sotto la cartella application/views/scripts/user. Lascia in bianco (perché non vogliamo dimostrare nulla).
Poi, creiamo un metodo per il controller denominato LogoutAction(). Apri il file “UserController.php” sotto la cartella application/controllers. Aggiungere il seguente metodo:
Copia codice 

  public function logoutAction()
  {
    $auth = Zend_Auth::getInstance();
	$auth->clearIdentity();
	$this->_redirect('/user');
  }
Ci basta usare clearIdentity(). Poi farà redirect ad un’altra pagina (in questo esempio per l’utente).
Creazione di commutazione per il Front Page
⤽
Questo è l’ultimo post di questo capitolo. Noi modificheremo prima pagina (user/index). Quando i visitatori accederanno a questa pagina, saranno reindirizzati al form di login.
Aprire il file “UserController.php” sotto la cartella application/controllers. Aggiornare indexAction():
Copia codice 

  public function indexAction()
  {
    $request = $this->getRequest();
    $auth		= Zend_Auth::getInstance();
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}else{
$this->_redirect('/user/userpage');
	}
  }
Ok, qui di seguito codice completo per il controller di questa sessione:
Copia codice 

<?php
require_once 'Zend/Controller/Action.php';
require_once 'Zend/Auth.php';
require_once 'Zend/Auth/Adapter/DbTable.php';
class UserController extends Zend_Controller_Action
{
  public function indexAction()
  {
    $request = $this->getRequest();
    $auth		= Zend_Auth::getInstance();
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}else{
$this->_redirect('/user/userpage');
	}
  }
  public function userpageAction(){
    $auth		= Zend_Auth::getInstance(); 
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}
    $request = $this->getRequest();
	$user		= $auth->getIdentity();
	$real_name	= $user->real_name;
	$username	= $user->username;
	$logoutUrl  = $request->getBaseURL().'/user/logout';
	$this->view->assign('real_name', $real_name);
	$this->view->assign('urllogout',$logoutUrl);
  }
  public function loginformAction()
  {
    $request = $this->getRequest();
	$this->view->assign('action', $request->getBaseURL()."/user/auth");
    $this->view->assign('title', 'Login Form');
    $this->view->assign('username', 'Nome Utente');
    $this->view->assign('password', 'Password');	
  }
  public function authAction(){
    $request 	= $this->getRequest();
    $registry 	= Zend_Registry::getInstance();
	$auth		= Zend_Auth::getInstance(); 
	$DB = $registry['DB'];
	$authAdapter = new Zend_Auth_Adapter_DbTable($DB);
    $authAdapter->setTableName('users')
    ->setIdentityColumn('username')
    ->setCredentialColumn('password');    
	// Impostare i valori di input delle credenziali
	$uname = $request->getParam('username');
	$paswd = $request->getParam('password');
    $authAdapter->setIdentity($uname);
    $authAdapter->setCredential(md5($paswd));
    // Eseguire la query di autenticazione
    // salvando il risultato
    $result = $auth->authenticate($authAdapter);
    if($result->isValid()){
//print_r($result);
	  $data = $authAdapter->getResultRowObject(null,'password');
	  $auth->getStorage()->write($data);
	  $this->_redirect('/user');
	}else{
	  $this->_redirect('/user/loginform');
	}
  }
  public function logoutAction()
  {
    $auth = Zend_Auth::getInstance(); 
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}
	$auth->clearIdentity();
	$this->_redirect('/user');
  }
  public function nameAction()
  {
    $auth		= Zend_Auth::getInstance(); 
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}
    $request = $this->getRequest();
    $this->view->assign('name', $request->getParam('username'));
    $this->view->assign('gender', $request->getParam('gender'));	  
    $this->view->assign('title', 'Nome Utente');
  }  
  public function registerAction()
  {
    $auth		= Zend_Auth::getInstance(); 
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}
    $request = $this->getRequest();
	$this->view->assign('action',"process");
    $this->view->assign('title','Registrazione Membri');
	$this->view->assign('label_fname','Nome');
	$this->view->assign('label_lname','Cognome');
	$this->view->assign('label_uname','Nome Utente');
	$this->view->assign('label_pass','Password');
	$this->view->assign('label_submit','Registra');
	$this->view->assign('description','Compilare questo modulo completamente:');
  }
  public function editAction()
  {
    $auth = Zend_Auth::getInstance(); 
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}  
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
    $request = $this->getRequest();
	$id 	 = $request->getParam("id");
	$sql = "SELECT * FROM `user` WHERE id='".$id."'";
	$result = $DB->fetchRow($sql);
	$this->view->assign('data',$result);
	$this->view->assign('action', $request->getBaseURL()."/user/processedit");
    $this->view->assign('title','Modifica Membri');
	$this->view->assign('label_fname','Nome');
	$this->view->assign('label_lname','Cognome');
	$this->view->assign('label_uname','Nome Utente');
	$this->view->assign('label_pass','Password');
	$this->view->assign('label_submit','Edita');
	$this->view->assign('description','Compilare questo modulo completamente:');
  }  
  public function processAction()
  {
    $auth		= Zend_Auth::getInstance(); 
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
    $request = $this->getRequest();
	$data = array('first_name' => $request->getParam('first_name'),
	  'last_name' => $request->getParam('last_name'),
				  'user_name' => $request->getParam('user_name'),
				  'password' => md5($request->getParam('password'))
	  );
    $DB->insert('user', $data);
    $this->view->assign('title','Processo di registrazione');
	$this->view->assign('description','Registrazione avventa');
  }
  public function listAction()
  {
    $auth		= Zend_Auth::getInstance(); 
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
	$sql = "SELECT * FROM `user` ORDER BY user_name ASC";
	$result = $DB->fetchAssoc($sql);
    $this->view->assign('title','Lista membri');
	$this->view->assign('description','Sotto, nostri membri:');
	$this->view->assign('datas',$result);		
  }
  public function processeditAction()
  {
    $auth		= Zend_Auth::getInstance(); 
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
	$request = $this->getRequest();
	$data = array('first_name' => $request->getParam('first_name'),
	  'last_name' => $request->getParam('last_name'),
				  'user_name' => $request->getParam('user_name'),
				  'password' => md5($request->getParam('password'))
	  );
    $DB->update('user', $data,'id = '.$request->getParam('id'));	
    $this->view->assign('title','Processo di modifica');
	$this->view->assign('description','Modifica eseguita');
  }
  public function delAction()
  {
    $auth		= Zend_Auth::getInstance(); 
	if(!$auth->hasIdentity()){
	  $this->_redirect('/user/loginform');
	}
    $registry = Zend_Registry::getInstance();
	$DB = $registry['DB'];
	$request = $this->getRequest();
    $DB->delete('user', 'id = '.$request->getParam('id'));	
    $this->view->assign('title','Eliminazione Dati');
	$this->view->assign('description','Eliminazione avvenuta');
    $this->view->assign('list',$request->getBaseURL()."/user/list");  
  }
}
?>

[nextpage title=”Zend Framework Session”]
Introduzione
⤽
Session è una parola familiare nella programmazione PHP. Quando si costruisce un’applicazione complessa, di solito, coinvolgiamo una sessione. In PHP, conosciamo $ _SESSION. Rappresenta uno stato persistente e logico del dato e l’agente client utente (ad esempio, browser web).
A Zend Framework, possiamo usare Zend_Session. Zend_Session gestisce, lato server, i dati memorizzati in $ _SESSION. E una importante classe che dobbiamo conoscere è Zend_Session_Namespace. LA sessione del Namespace fornisce l’accesso ai dati di sessione tramite i namespace classico implementato logicamente come nome di gruppi in array associativi, con chiave di stringhe (simile al normale array in PHP). Qui di seguito, cito dal manuale Zend Framework:
Le istanze di Zend_Session_Namespace sono oggetti che hanno metodi per accedere alle sezioni dello spazio dei nomi della variabile di sessione $_SESSION. Il componente Zend_Session avvolge l’esistente funzionalità di PHP per ext/session con un interfaccia di amministrazione e gestione, inoltre fornisce un’API per le Zend_Session_Namespace per farlo persistente nello spazio dei nomi della sessione. Zend_Session_Namespace fornisce una interfaccia standardizzata, object-oriented, per lavorare con lo spazio dei nomi in modo persistente all’interno meccanismo sessione standard di PHP. Esiste il supporto per entrambi (anonimi e autenticati – ad esempio, “login”) spazi dei nomi della sessione. Zend_Auth, il componente di autenticazione di Zend Framework, utilizza Zend_Session_Namespace per memorizzare alcune informazioni associate a utenti autenticati. Dal Zend_Session si utilizza le normali funzioni di PHP ext/session internamente, tutte le opzioni di configurazione familiare e impostazioni vengono applicate (vedi http://www.php.net/session), con i bonus come ad esempio la comodità di avere un’interfaccia object-oriented e un comportamento di default che fornisce le best practices e l’integrazione con lo Zend Framework. Quindi, uno standard identificativo di sessione in PHP, trasmessa dal cookie o all’interno degli URL, mantiene l’associazione tra un client e i suoi dati dello stato sessione.
Ancora confUSIONE? Non preoccupatevi, Nel prossimo post cercheremo di fare un po’ di pratica con la sessione con Zend Framework. Inizieremo con Zend_Session_Namespace.
Usando Namespace
⤽
In questo post, impareremo a usare lo spazio dei nomi in una sessione in Zend Framework. Se non si ha familiarità con lo spazio dei nomi, non ti preoccupare. È semplice. Facciamolo.
Semplicemente, è come il nome dei gruppi di array associativi, con chiavi rappresentate da stringhe. Per fare pratica, usiamo il nostro esercizio precedente.
Ok, vogliamo contare il numero vi volte che si fa’ una richiesta di pagina particolare di form di un visitatore. Vedere l’immagine:
count number of page request
Per fare questo, aprire il file UserController.php sotto la cartella application/controller. Includere Zend/Session/Namespace.php in prima linea dopo il delimitatore.
Copia codice 

require_once 'Zend/Session/Namespace.php';
Modificare loginformAction() per farlo diventare come segue:
Copia codice 

  public function loginFormAction()
  {
    $request = $this->getRequest();  
    $ns = new Zend_Session_Namespace('ciaoMondo');
	if(!isset($ns->yourLoginRequest)){
	  $ns->yourLoginRequest = 1;
	}else{
	  $ns->yourLoginRequest++;
	}
	$this->view->assign('request', $ns->yourLoginRequest);
	$this->view->assign('action', $request->getBaseURL()."/user/auth");
    $this->view->assign('title', 'Login Form');
    $this->view->assign('username', 'Nome Utente');
    $this->view->assign('password', 'Password');	
  }
Alla linea 5, si definisce oggetto namespace. Lo spazio dei nomi, che abbiamo chiamato “ciaoMondo”. È come $_SESSION['ciaoMondo']. Si può mettere il nome come MioNamespace, MiApplicazione, ecc
Poi, alla riga 7, si verifica il valore di $ns->yourLoginRequest. È come $_SESSION['ciaoMondo']['yourLoginRequest']. Successivamente, modificare loginform.phtml sotto la cartella application/views/scripts/user. Aggiornandolo diventa come segue:
Copia codice 

<? include "header.phtml"; ?>
  <h1><?=$this->escape($this->title);?></h1>
  Sei entrato in questa pagina: <?=$this->escape($this->request);?> volte.
  <form method='post' action='<?=$this->escape($this->action);?>'>
  <table>
    <tr>
	  <td><?=$this->escape($this->username);?></td>
	  <td><input type='text' name='username'></td>
	</tr>
    <tr>
	  <td><?=$this->escape($this->password);?></td>
	  <td><input type='password' name='password'></td>
	</tr>
  </table>
  <input type='submit' name='login' value='Login'>
  </form>
<? include "footer.phtml"; ?>
Ora, puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/user/loginform. Si può ottenere le schermate come l’immagine di sopra.Ok, prova di nuovo con userPageAction() nelcontroller. L’aggiornamento apparirebbe come segue:
Copia codice 

  public function loginformAction()
  {
    $request = $this->getRequest();  
    $ns = new Zend_Session_Namespace('CiaoWorld');
	if(!isset($ns->yourLoginRequest)){
	  $ns->yourLoginRequest = 1;
	}else{
	  $ns->yourLoginRequest++;
	}
	$this->view->assign('request', $ns->yourLoginRequest);
	$this->view->assign('action', $request->getBaseURL()."/user/auth");
    $this->view->assign('title', 'Login Form');
    $this->view->assign('username', 'Nome Utente');
    $this->view->assign('password', 'Password');
  }
Poi, aggiornare la sua view a application/views/scripts/user/userpage.phtml:
Copia codice 

<? include "header.phtml"; ?>
<h1>Ciao, <?=$this->escape($this->real_name);?></h1>
Sei entrato in questa pagina: <?=$this->escape($this->request);?> volte.
<a href='<?=$this->escape($this->urllogout);?>'>Logout</a>
<? include "footer.phtml"; ?>
Accedendo ai dati di Session
⤽
In questo post, impareremo ad accedere ai dati di sessione. Ora, si spiega come accedere alla sessione.
Si prega di prestare attenzione al codice del precedente capitolo:
Copia codice 

$ns = new Zend_Session_Namespace('ciaoMondo');
if(!isset($ns->yourLoginRequest)){
  $ns->yourLoginRequest = 1;
}else{
  $ns->yourLoginRequest++;
}
Da sopra, sappiamo come impostare la sessione in Zend Framework. Basta dare le proprietà come:
Copia codice 

$ns->yourLoginRequest = 1;
$ns->thisIsSession = "Oke";
$ns->nameOfSession = "MiaSession";
$ns->foo = 10;
Ora, come accedere ai valori? Semplice:
Copia codice 

echo $ns->yourLoginRequest;
echo $ns->thisIsSession;
echo $ns->nameOfSession;
echo $ns->foo;
Vedere tutti i valori del Namespace
⤽
Questo è un piccolo suggerimento per mostrare tutti i valori di uno spazio dei nomi. Come sappiamo, la sessione può avere un comportamento come un array. Quindi, possiamo mostrare valori come se fosse un array. Guardate questo esempio:
Copia codice 

$ns = new Zend_Session_Namespace('ciaoMondo');
foreach ($ns as $index => $value) {
  echo "ns->$index = '$value';";
}
Ok, prova a testarlo. Abbiamo messo la sessione nella pagina loginform e nella pagina utente. Ora, vogliamo mostrare le statistiche di richiesta per quella pagina. Aprite il file “UserController.php” sotto la cartella application/controller. Aggiungere il seguente metodo:
Copia codice 

  public function statsAction()
  {
    $ns = new Zend_Session_Namespace('ciaoMondo');
    foreach ($ns as $index => $value) {
echo "ns->$index = '$value';";
	  echo "<br />";
    }
  }
Quindi, creare una view per quest’azione sul controller. Creare un file denominato “stats.phtml” sotto la cartella application/views/scripts/user. Lasciare la pagina vuota.
Ok, prova ora a puntare il browser su http://localhost/test/zend/ciaoMondo/web_root/user/stats. Si può ottenere come ad esempio:
Copia codice 

ns->yourLoginRequest = '2';
ns->yourUserPageRequest = '7';
I valori dipendono dal numero di visite.
Blocco e sblocco del Namespace
⤽
Le sessioni del Namespace possono essere chiuse a chiave. Che cosa significa? Quando un namespace di una sessione è bloccata, non si può aggiornare o eliminare il valore della sessione. Sarà di sola lettura.
Possiamo usare lock() per bloccare lo spazio dei nomi. Poi, se volete controllare se è bloccato o no, possiamo usare il booleano isLocked(). Guardate questo esempio:
Copia codice 

  public function loginFormAction()
  {
    $ns = new Zend_Session_Namespace('ciaoMondo');
	$ns->lock();
    if (!$ns->isLocked()) {
	  if(!isset($ns->yourLoginRequest)){
	    $ns->yourLoginRequest = 1;
	  }else{
	    $ns->yourLoginRequest++;
	  }
    }
    $request = $this->getRequest();
	$this->view->assign('request', $ns->yourLoginRequest);
	$this->view->assign('action', $request->getBaseURL()."/user/auth");
    $this->view->assign('title', 'Login Form');
    $this->view->assign('username', 'Nome Utente');
    $this->view->assign('password', 'Password');	
  }
Per aprirlo, possiamo usare il metodo unLock().
Copia codice 

$ns= new Zend_Session_Namespace('CiaoWorld');
// blocca la sessione e diventa di sola lettura
$ns->lock();
// sblocca la sessione di sola lettura
if ($ns->isLocked()) {
    $ns->unLock();
}
Scadenza automatica
⤽
Possiamo impostare un tempo limitato di validità per uno spazio dei nomi. Per questa caratteristica, realizzaremo unaa scadenza dello spazio dei nomi. Esempio, vogliamo contare il numero di richiesta di pagina da una persona in un minuto. Dopo 1 minuto, sarà contato come persona nuova. Quindi, il codice sarà come questo:
Proviamo ad modificare il metodo loginform del file UserController.php sotto la cartella application/controller. Aggiorniamo loginformAction():
Copia codice 

  public function loginformAction()
  {
    $ns = new Zend_Session_Namespace('ciaoMondo');
	if(!isset($ns->yourLoginRequest)){
	    $ns->yourLoginRequest = 1;
	}else{
	    $ns->yourLoginRequest++;
	}
	$ns->setExpirationSeconds(60);
    $request = $this->getRequest();
	$this->view->assign('request', $ns->yourLoginRequest);
	$this->view->assign('action', $request->getBaseURL()."/user/auth");
    $this->view->assign('title', 'Login Form');
    $this->view->assign('username', 'Nome Utente');
    $this->view->assign('password', 'Password');
  }
È possibile impostare solo in una chiave particolare (ad esempio, yourLoginRequest):
Copia codice 

$ns->setExpirationSeconds(60,'yourLoginRequest');