massimiliano wosz - zend framework 1.5

ZEND FRAMEWORK BLOG:

UN'APPLICAZIONE REALE

| 31 mar 2008Zend Framework dalla A alla Zend

L'applicazione

Divide et Impera

• E' sempre conveniente separare il livello che incapsula la business logic da quello di presentazione

• Per questo è importante dividere il codice HTML da quello PHP.

Ottenere la separazione

• Ci sono molti modi per dividere la logica dai template.

• Sicuramente la maniera più veloce (ma non la più conveniente) è quella di includere le pagine HTML all'interno dei nostri script PHP.

Esempio di separazione

index.php

$content = array();

$content['title']='Titolo';

$content['text']='Testo';

include_once('index.tpl');

index.tpl

<html>

<body>

<?php echo $content['title'] ?>

</div>

<?php echo $content['text'] ?>

</div>

</body>

</html>

Design Pattern?

• Non è facile trovare il modo perfetto per scrivere un'applicazione.

• I design pattern sicuramente ci vengono in aiuto per identificare i nostri bisogni e costruire applicazioni solide e manutenibili.

Il Pattern MVC

• Il design pattern MVC implementa la concezione di Divide et Impera dividendo l'applicazione addirittura in tre blocchi distinti:• Model• View• Controller

Controller

• I controller si occupano di analizzare le richieste dell'utente per inviarlo alla pagina desiderata.

• Mappano i cambiamenti della User Interface (normalmente attraverso una vista) verso i modelli.

• Mantengono lo stato dell'applicazione e utilizzano realmente le risorse (database,file e altro)

• Rispondono alle richieste di dati

• Incapsulano la Business Logic

• Visualizzano la User Interface

• Richiedono dati ai Modelli (attraverso i controller)

• Inviano eventi e richieste ai controller

Flusso della nostra applicazione

Controller: Post

Action: List

index.php

PostControllerextends Zend_Controller_Action

listAction()

list.pthml

class Post

Lista dei postl'utente richiede la visualizzazione dei post

Front Controller

BOOTSTRAPTutte le richieste vengono inviate aun file di bootstrap che istanzia un oggetto front controller per elaborare le richieste.

Il Front Controller istanzia il controller che si occupa della gestione dei post e chiama l'azione di visualizzazione

Model: Post

Viene istanziato un oggetto del modello che si occupa di estrarre i post dal db. I risultati vengono restituiti dal modello al controller

I dati elaborati dal modello vengono inviati alla vista per la creazione dell'html finale

View: ListL'html viene creato e visualizzatoall'utente

Il formato della richiesta

• Nell'esempio precedente l'utente richiedeva la lista dei post.

• La richiesta per essere interpretata dal front controller di Zend Framework deve essere composta in questo modo:

http:// server / controller / action

http:// localhost / post / list

Creiamo la struttura dell'applicazione

• Creare la struttura per un progetto con Zend Framework è più facile di quanto immaginiamo utilizzando Zend Studio for Eclipse.

Capire la struttura MVC

• application• default

• controllers• models• views

• scripts• html

• index.php• .htaccess• images / scripts / styles

Il file .htaccess

● Per fare in modo che il Front Controller all'interno del bootstrap (index.php) riceva tutte le richieste degli utenti dobbiamo utilizzare il modulo mod_rewrite di Apache.

● Normalmente la nostra richiesta di esempio:● http://localhost/post/list

● Genererebbe un errore 404 di pagina non trovata perchè post e list non sono cartelle presenti fisicamente nella DocumentRoot del nostro server web.

Analizziamo il file .htaccess

RewriteEngine onRewriteRule !\.(js|ico|gif|jpg|png|css)$ index.php

● Con questa semplice espressione regolare indirizziamo tutte le richieste verso index.php escludendo le risorse statiche.

● Le risorse statiche (immagini, fogli di stile, file javascript...) non devono essere elaborate dal Front Controller e per questo vengono escluse identificandole attraverso l'estensione.

Il Bootstrap

● Zend Studio for Eclipse ha creato per noi anche il file index.php che prima abbiamo chiamato bootstrap.

require_once 'Zend/Controller/Front.php';

set_include_path(....)

$controller = Zend_Controller_Front::getInstance();

$controller> setControllerDirectory('../application/default/controllers');

$controller>throwExceptions(false); // should be turned on in development time

// run!

$controller>dispatch();

I controller

● Come già detto in precedenza tutti i controller sono classi derivate da Zend_Controller_Action.

● Tutti i controller devo essere chiamati [Nome]Controller con la prima lettera del nome maiuscola poi tutto CamelCase.

● Devono essere salvati nel file [Nome]Controller.php all'interno della cartella dei controller che abbiamo specificato nel bootstrap.

Perchè IndexController e indexAction

● Se nella richiesta l'utente non specifica nè un controller nè un'azione il front controller chiamerà automaticamente IndexController>indexAction.

● Se viene specificato un controller ma non un'azione verrà chiamata l'azione indexAction del controller specificato.

IndexController

class IndexController extends Zend_Controller_Action

* The default action show the home page

public function indexAction()

// TODO Autogenerated IndexController::indexAction()

//action

● Tutte le azioni sono metodi della classe chiamate come [nome]Action() con la prima lettera minuscola e poi tutto CamelCase.

Il ViewRender

● Il ViewRenderer è un helper che automaticamente visualizzerà la vista corrispondente all'azione chiamata.

● Ad esempio, se l'azione chiamata è la indexAction() di IndexController, il ViewRenderer visualizza automaticamente la vista index.pthml che si trova in application/views/scripts/index

● Generalizzando:● [nomeAzione].phtml● ../application/views/scripts/[NomeController]

index.pthml

<!DOCTYPE html PUBLIC "//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1transitional.dtd">

<head>

<title>New Zend Framework Project</title>

</head>

<body>

Hello, world!

</body>

</html>

TWO STEP VIEW CON ZEND_LAYOUT

Zend_Layout

● Zend_Layout è il modulo di Zend Framework che ci permette di realizzare il classico two step view.

● Il layout dell'applicazione viene seperato dalle view permettendoci di inserire il contenuto delle nostre viste all'interno di un'altra vista che normalmente rappresenta il template del sito.

Configuriamo Zend_Layout

● Prima di iniziare ad utilizzarlo dobbiamo configurare l'istanza di Zend_Layout nel bootstrap.

* Setup Layout

$options = array(

'layout' => 'main',

'layoutPath' => '../application/default/views/layouts',

'contentKey' => 'content'

Zend_Layout::startMvc($options);

Creiamo il layout

<!DOCTYPE html PUBLIC "//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1strict.dtd">

<head>

<title>Zend Framework Blog</title>

</head>

<body>

<?php echo $this>layout()>content; ?>

</div>

</body>

</html>

Il Placeholder “content”

<php echo $this>layout()>content ?>

● Content è il placeholder che abbiamo specificato nella configurazione come contentKey.

● All'interno di questo placeholder verrà automaticamente inserito il contenuto della vista associata all'azione chiamata.

CONFIGURIAMO L'ACCESSO AL DATABASE: ZEND_DB e ZEND_CONFIG

Zend_Db

● Zend_Db è un layer di accesso al database leggero e potente che fornisce un'interfaccia a PDO e ad altre estensioni per i db. Adapter estendibili per ogni driver di database. Un profiler delle query Un API per la costruzione delle istruzioni di SELECT. Un supporto robusto per prepared statements e quoting

Configuriamo Zend_Db

● Prima di poter utilizzare Zend_Db dobbiamo configurarlo nel bootstrap.

● Le impostazioni di configurazione verranno recuperate da un file .ini utilizando Zend_Config.

● Il file di configurazione da utilizzare è come questo: [development]

adapter = PDO_MYSQL

host = localhost

username = root

password =

dbname = blog

Leggiamo la configurazione

● $config = new Zend_Config_Ini('../application/conf/db.ini','development');

● Con la riga precedente parsiamo il file di configurazione e creiamo un oggetto di Zend_Config_Ini.

● Le informazioni adesso saranno disponibili direttamente come proprietà dell'oggetto $config o utilizzando il metodo toArray() che crea un array a partire dalla configurazione.

● Ad esempio $config>adapter

Creiamo un oggetto Zend_Db

● $db = Zend_Db::factory($config>adapter,$config>toArray());

● Per creare un istanza di Zend_Db utilizziamo il suo metodo factory passando come primo parametro l'adapter che abbiamo letto dalla configurazione e come secondo un array con i parametri di connessione.

● L'array deve essere associativo e contenere le chiavi:● host● username● password● dbname

ACCEDIAMO AI DATI CON ZEND_DB_TABLE

Zend_Db_Table

● Zend_Db_Table è una soluzione potente ed efficace per la programmazione ad oggetti con i database.• Implementa i pattern Table Data Gateway e Row Data

Gateway.• Legge i metadati dal database senza la necessità di complessi

file di configurazione.• Fornisce un meccanismo per interrogare tabelle collegate

Configuriamo Zend_Db_Table

● L'unica configurazione da fare a Zend_Db_Table è quella di settare l'oggetto Zend_Db che abbiamo appena creato come default adapter.

Zend_Db_Table::setDefaultAdapter($db);

Creiamo i modelli necessari

● Tutte le classi che implementano Zend_Db_Table devono essere figlie di Zend_Db_Table_Abstract per ereditare le funzionalità necessarie al corretto funzionamento della classe.

● Le classi di cui abbiamo bisogno per la gestione del nostro blog sono tre:● User● Post● Comment

user.php

class user extends Zend_Db_Table_Abstract {

post.php

class post extends Zend_Db_Table_Abstract {

protected $_name = 'post';protected $_primary = 'id';protected $_dependentTables = array('comment');

comment.php

class comment extends Zend_Db_Table_Abstract {

protected $_name = 'comment';protected $_primary = 'id';

protected $_referenceMap = array('Post' => array( 'columns' => 'post', 'refTableClass' => 'post', 'refColumns' => 'id' ));

Collegamenti tra tabelle

● Utilizzando $_dependantTables e $_referenceMap abbiamo creato un collegamento tra la tabella dei post e quella dei commenti.

● In questo modo possiamo facilmente estrarre tutti i commenti collegati a ciascun post utilizzando il metodo findDependentRowset che estrae automaticamente tutte le rige della tabella collegata secondo quanto specificato in $_referenceMap

Estraiamo i dati

● Creiamo un nuovo controller che si chiama PostController

● Creiamo l'azione listAction() che si occuperà di estrarre i post e mostrarli all'utente.

public function listAction()

$post = new post();

$results = $post>fetchAll(null,'date DESC');

$this>view>posts = $results;

list.phtml

<?php foreach ($this>posts as $post): ?>

<?php echo $post>title ?>

</div>

Post inviato il <?php echo $this>FormatDate($post>date) ?>

da <?php echo $this>UserInfo($post>user)>name ?> <?php echo $this>UserInfo($post>user)>surname ?>

</div>

<?php echo $post>abstract ?>

</div>

list.phtml

<div class="post_infoTitle">AZIONI SUL POST</div>

Contatta l'autore:<a href='mailto:<?php echo $this>UserInfo($post>user)>email ?>'>

<?php echo $this>UserInfo($post>user)>email ?></a><br /><br/>

<?php echo $this>PostMenu($post>id) ?>

</div>

</div>

<?php endforeach; ?>

View Helper

• Nelle viste sarà spesso necessario eseguire operazioni complesse come ad esempio formattare una data o generare elementi di un form. Zend Framework ci permette di creare delle classi che ci aiutino ad eseguire queste operazioni.

• C'è un ampio set di view helper builtin in Zend Framework come ad esempio quelli riguardanti la creazione di un form.

Custom View Helper

• FormatDate, UserInfo e PostMenu sono View Helper Custom creati ad hoc per il nostro progetto.

• L'helper che creiamo sarà una classe chiamata Zend_View_Helper_customhelper definita nel file customhelper.php all'interno della cartella degli helper (dove customhelper è il nome che vogliamo utilizzare).

UserInfo.php

class Zend_View_Helper_UserInfo{

function UserInfo($userid){

$user = new user();$info = $user>find($userid);

return $info>current();}

FormatDate.php

class Zend_View_Helper_FormatDate{

public function FormatDate($date){

$date = new Zend_Date($date,Zend_Date::TIMESTAMP);

return $date>toString("dd MMMM yyyy 'alle' HH:mm");}

L'AUTENTICAZIONE DELL'UTENTE

Implementiamo l'autenticazione

• Creiamo un nuovo controller LoginController per gestire l'autenticazione.

• Avremo bisogno di un'azione che visualizzi un form per l'inserimento delle credenziali.

• E di un'altra azione che effettivamente controlli i dati sull'adapter specificato.

Creiamo il form

• Per la creazione del form utilizziamo Zend_Form.

• Creiamo un nuovo metodo protetto all'interno di LoginController che chiameremo _getForm().

• Questo metodo ci sarà utile per recuperare l'oggetto del form in qualsiasi azione del nostro controller anche per effettuare la validazione dei dati inviati.

Il metodo _getForm()

protected function _getForm()

$form = new Zend_Form();

$form>setAction('/login/login');

$form>setMethod('post');

$form>addElement('text','email',

array('Required'=>true,'Label'=>'Email'));

$form>addElement('password','password',

array('Required'=>true,'Label'=>'Password'));

$form>addElement('submit','login',array('label'=>'Entra'));

return $form;

Visualizziano il form

function indexAction()

$form = $this>_getForm();

echo $form>render();

Effettuiamo il login

function loginAction()

$form = $this>_getForm();

if($form>isValid($_POST))

$db = Zend_Registry::get('db');

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

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

$auth = Zend_Auth::getInstance();

$authAdapter = new Zend_Auth_Adapter_DbTable

($db,'user','email','password','MD5(?)');

$authAdapter>setIdentity($email)

>setCredential($password);

$authResult = $auth>authenticate($authAdapter);

$auth>getStorage()>write(

$authAdapter>getResultRowObject(array('id','email')));

if($authResult>isValid())

$this>_redirect('/post/list');

$auth>clearIdentity();

$this>view>error = 'Username o Password errati.';

Creiamo la nostra ACL

• Per creare la nostra Access Control List scriviamo una classe AccessControl derivata da Zend_Acl.

• In questa classe andremo a definire Risorse, Ruoli e Permessi.

AccessControl.php

class AccessControl extends Zend_Acl

public function __construct()

$guest = new Zend_Acl_Role('guest');

$member = new Zend_Acl_Role('member');

$this>addRole($guest);

$this>addRole($member);

$this>add(new Zend_Acl_Resource('index'));

$this>add(new Zend_Acl_Resource('login'));

$this>add(new Zend_Acl_Resource('post'));

$this>add(new Zend_Acl_Resource('comment'));

AccessControl.php

$this>allow('guest','login');

$this>allow('guest','index');

$this>allow('guest','post',array('list','view'));

$this>allow('member','index');

$this>allow('member','login');

$this>allow('member','post',

array('list','new','save','view','delete'));

$this>allow('member','comment',array('list','new','save'));

Meccanismo di autenticazione

• L'autenticazione dell'utente e la verifica dei permessi associati al ruolo dovranno ovviamente essere fatti per ogni richiesta dell'utente.

• L'architettura del controller include un sistema di plugin che permette all'utente di eseguire codice all'occorrenza di alcuni eventi durante il processo dei dispatch dell'applicazione.

• Utilizzeremo un plugin per eseguire ad ogni richiesta il controllo dei permessi dell'utente sulla risorsa richiesta.

Creiamo AuthPlugin

class AuthPlugin extends Zend_Controller_Plugin_Abstract

protected $_acl;

public function __construct(Zend_Acl $acl)

$this>_acl = $acl;

public function preDispatch($request)

Il metodo preDispatch

$auth = Zend_Auth::getInstance();

$acl = $this>_acl;

$controller = $request>getControllerName();

$action = $request>getActionName();

if(!$auth>hasIdentity()) {

$role = 'guest';

else {

$role = 'member';

if(!$acl>isAllowed($role,$controller,$action))

$request>setControllerName('login');

$request>setActionName('index');

FINIAMO IL LAVORO

Inserimento di un nuovo post

• Creiamo una nuova azione in PostController che chiameremo newAction()

• Come per il login abbiamo bisogno di un form che raccolga i dati da utilizzare. Creiamo quindi il metodo _getForm all'interno di PostController.

• Creiamo poi una nuova azione che salvi i dati nel database che chiameremo saveAction()

• saveAction controlla i dati inviati tramite il form e li inserisce utilizzando il metodo insert di Zend_Db_Table

Visualizzazione post

• Creiamo una nuova azione in PostController che chiameremo viewAction()

• Dobbiamo passare un parametro all'azione che rappresenta l'id del post da visulizzare.

• Estraiamo i dati utilizzando il metodo find di Zend_Db_Table e ed estraiamo tutti i commenti utilizzando findDependentRowset

Inserimento di un commento

• Creiamo un nuovo controller CommentController ed una nuova azione all'interno che chiameremo newAction()

• Come per il login abbiamo bisogno di un form che raccolga i dati da utilizzare. Creiamo quindi il metodo _getForm all'interno di CommentController.

• Creiamo poi una nuova azione che salvi i dati nel database che chiameremo saveAction()

• saveAction controlla i dati inviati tramite il form e li inserisce utilizzando il metodo insert di Zend_Db_Table

Creazione dei menu

• Abbiamo bisogno di due menu per permettere la navigazione dell'utente.

• Un menu principale per spostarsi attraverso le pagine del blog• Entra/Esci• Blog• Nuovo post

• Un menu per il post per effettuare azioni sul post.• Aggiungi un commento• Elimina il post

Creazione dei menu

• All'interno dei menu dovremo utilizzare le tecniche apprese in precedenza per controllare i permessi associati al ruolo dell'utente in modo da visualizzare solo i link per le pagine che l'utente può visualizzare.

• Per fare questo utilizziamo Zend_Auth e Zend_Acl:• Il primo per prendere l'identità dell'utente e quindi anche il ruolo.• Il secondo per verificare con il metodo idAllowed se quel ruolo può visulizzare una determinata risorsa.

Zend FrameworkSimplicity, Meet Power

massimiliano@zend.com“THANK YOU

massimiliano wosz - zend framework 1.5

Business

plnog 13: jacek wosz: user defined network

zend tutorial

zend gramework

massimiliano pitocco presenta massimiliano caporale

zend framework 2

zend performance

manual zend

zend framework 3

zend framework introduccion

i complementi latini canana’ massimiliano prof. canana'...

zend framework totalflex

zend framework 1.11

la segmentazione massimiliano pancini. la segmentazione...

zend framework 2

zend framework presentation

pro zend techniques

certificação zend framework

zend framework felipe ferreri tonello. Índice php zend...

zend framework - lumen agência de...

taller zend framework