Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Per realizzare la nostra prima applicazione basata su Symfony ci appoggeremo alla sandbox. Ne abbiamo già parlato (http://php.html.it
/articoli/leggi/2608/symfony-per-php-5-presentazione-e-installazione/3/) in precedenza: si tratta di una semplice raccolta di documenti
che raccoglie tutte le librerie necessarie per il funzionamento del framework.
L'utilizzo della sandbox non è consigliabile in fase di produzione, ma risulterà molto comodo in sede di sviluppo perché richiede una
procedura di istallazione e di configurazione minimale.
propel:
weblog_post:
_attributes: { phpName: Post }
id:
titolo: varchar(255)
testo: longvarchar
body: longvarchar
created_at:
weblog_comment:
_attributes: { phpName: Comment }
id:
post_id:
autore: varchar(255)
email: varchar(255)
body: longvarchar
created_at:
È fondamentale tenere conto che lo schema di dati proposto viene espresso attraverso una particolare sintassi detta YALM e utilizzata
nell'omonimo linguaggio destinato alla creazione di strutture ad albero; nella sintassi YALM l'indentazione ha un significato ben preciso in
cui gli spazi non vengono utilizzati a caso ma rappresentano la gerarchia interna dei dati, inoltre, non è possibile introdurre tabulazioni.
Grazie allo schema creato viene descritta la struttura delle tabelle (chiamate Post e Comment) che verranno utilizzate per la
memorizzazione dei contenuti inseriti tra le pagine del blog; i nomi delle due tabelle utilizzate saranno anche quelli delle classi che
verranno generate al momento dell'inizializzazione del model.
Una volta salvato il file schema.yml nell'apposita directory dovremo passare ad una breve fase dedicata alla linea di comando; apriremo
quindi la nostra interfaccia testuale e raggiungeremo la directory (sf_sandbox/) contenente la sandbox per poi digitare:
$ symfony propel-build-model
A meno di imprevisti questa istruzione si dovrebbe risolvere con la creazione di alcune classi situate all'interno della directory
sf_sandbox/lib/model/, queste ultime consentono di accedere ad un database relazionale interrogabile tramite linguaggio orientato agli
oggetti senza dover ricorrere a query in SQL; a questo scopo il framework utilizza una particolare libreria chiamata Propel, nella directory
sf_sanbox/config è infatti possibile reperire il file propel.inidestinato alla configurazione di questa libreria.
Lasciamo aperta la schermata della shell perché dovremo riutilizzarla immediatamente, il prossimo comando da digitare sarà infatti:
$ symfony propel-build-sql
A questo punto verrà generato il documento denominato schema.sql salvato all'interno della directory sf_sandbox/data/sql/, attraverso di
esso sarà possibile inizializzare un database avente la medesima struttura rispetto a quella definita all'interno dello schema; per rendere
più semplice il nostro lavoro ci appoggeremo però ad un file di SQLite, in questo modo non dovremo inizializzare alcun database, cosa che
1 di 10 03/11/2009 01:11
Symfony: progettazione un blog (versione per la s... http://php.html.it/articoli/stampa/2647/symfony-pro...
succederebbe invece se dovessimo interfacciare la nostra applicazione con un DBMS più complesso come MySQL o PostgrSQL.
sf_sandbox integra un database di default denominato sandbox.db e reperibile all'interno della directory sf_sandbox_data, in esso
dovremo costruire la struttura delle nostre tabelle attraverso la digitazione del seguente comando.
$ symfony propel-insert-sql
Questa istruzione potrebbe generare delle notifiche di errore, fortunatamente esse non sono riferite a problematiche che potrebbero
pregiudicare la buona riuscita della nostra applicazione; molto più semplicemente il comando utilizzato ha anche il compito di cancellare
eventuali tabelle già presenti all'interno di shema.sql, la loro assenza è dunque all'origine delle segnalazioni di errore.
Nel primo caso la fase relativa alla programmazione risulterà molto più lunga, nel secondo si potrebbe dover fare i conti con difficoltà
relative alla personalizzazione del prodotto finito; l'utilizzo di un framework rappresenta una via di mezzo ottimale a questo proposito
perché da una parte non richiede che lo sviluppatore scriva riga per riga la sua applicazione e dall'altra fornisce un supporto flessibile
attorno a cui realizzarla.
Stiamo introducendo il concetto dello scaffolding (letteralmente: impalcatura), Symfony mette infatti a disposizione dell'utilizzatore la
possibilità di operare su una base personalizzabile costituita da metodi preesistenti su cui appoggiare il proprio progetto.
La creazione di uno scaffolding per la creazione di applicazioni come i blog richiedono la semplice digitazione di due comandi
(impersonando l'utente di root):
Le istruzioni appena esposte porteranno alla creazione di due moduli con cui sarà possibile agire sugli oggetti appartenenti alle classi
denominate Post e Comment, l'acronimo CRUD non è altro che i risultato delle iniziali dei nomi relativi alle funzioni più utilizzate in fase di
gestione dei contenuti (Create, Retrieve, Update e Delete); nel caso specifico un modulo non è altro che la rappresentazione di una pagina
o di un gruppo di pagine aventi elementi comuni; i moduli creati tramite le due istruzioni appena digitate verranno salvati all'interno della
directory sandbox/apps/frontend/modules/ e potranno essere raggiunti digitando gli indirizzi locali http://localhost/sf_sandbox
/web/frontend_dev.php/post (http://localhost/sf_sandbox/web/frontend_dev.php/post) e http://localhost/sf_sandbox
/web/frontend_dev.php/comment
Negli indirizzi frontend è naturalmente il nome dello script principale o front controller, come è facile notare la pagina di accesso ad esso
non è la classica index.php ma frontend_dev.php; questo particolare non è di importanza secondaria, infatti mentre frontend_dev.php
consente l'accesso all'ambiente di sviluppo, index.php è invece il front controller dell'ambiente di produzione. Per questo motivo
l'esecuzione della prima risulta più lenta rispetto a quella della seconda.
Quindi per passare da un ambiente all'altro sarà sufficiente sostituire nell'URL frontend_dev.php con index.php ricordandosi però di
ripulire la cache del framework in modo da rendere visibili la modifiche effettuate con il seguente comando:
$ symfony clear-cache
Le modifiche al template del blog potranno essere effettuate direttamente nel file che contiene il template globale, reperibile sul percorso
sf_sandbox/apps/frontend/templates/layout.php dove potremo inserire modifiche anche sostanziali al contenuto dei tag <body>:
<div id="container">
<div id="navigation">
<ul>
<li><?php echo link_to('Articoli del Blog', 'post/list') ?></li>
<li><?php echo link_to('I commenti dei visitatori', 'comment/list') ?></li>
</ul>
2 di 10 03/11/2009 01:11
Symfony: progettazione un blog (versione per la s... http://php.html.it/articoli/stampa/2647/symfony-pro...
</div>
<div id="title">
<h1><?php echo link_to('Nome del Blog', 'default/index') ?></h1>
</div>
<div id="content">
<?php echo $sf_content ?>
</div>
</div>
Naturalmente il codice HTML proposto potrà essere arricchito sulla base delle diverse esigenze utilizzando CSS inline oppure fogli di stile
esterni, ciò che conta nel nostro caso è mostrare come il markup e il codice dinamico rimangano due entità ben distinte nella creazione
delle pagine; ricordiamo tra l'altro che la corretta sintassi per Symfony richiede che l'HTML non venga prodotto come output del PHP
digitato. Quindi sarà bene evitare listati sul modello del seguente:
in favore di:
Ora sarà possibile applicare qualche modifica anche ai dati relativi al nostro blog, come ad esempio il titolo che dovrà essere associato alle
pagine oppure il contenuto dei meta tags; per far questo dovremo agire su un altro file YML denominato view.yml situato nella directory
sf_sandbox/apps/frontend/config/. Naturalmente le modifiche dovranno rispettare la già citata sintassi YALM e la relativa indentazione:
default:
http_metas:
content-type: text/html; charset=utf-8
metas:
title: Il mio Blog
robots: index, follow
description: blog dedicato a Symfony
keywords: framework, programmazione, php
language: it
L'ultimo passo necessario per la modifica del nostro template sarà ora quello di creare una directory destinata al template della nostra
applicazione in modo da non utilizzare quella messa a disposizione dal modulo predefinito:
$ cd apps/frontend/modules
$ mkdir default
$ cd default
$ mkdir templates
$ cd templates
L'esito delle istruzioni porterà alla creazione del file indexSuccess.php e alla produzione del relativo messaggio di benvenuto.
Conclusioni
In questa breve trattazione abbiamo descritto i passaggi necessari per la creazione di un piccolo blog utilizzando il framework Symfony. Il
nostro lavoro non è ancora finito, per completare l'applicazione dovremo affrontare altri argomenti importanti che riguardano per esempio
l'utilizzo dei form e la creazione di un'area di amministrazione per la gestione dei contenuti.
In attesa della prossima parte consigliamo la lettura del Wiki Il mio primo progetto con Symfony (http://trac.symfony-project.com
/wiki/MyFirstSymfonyProjectItalian) preziosa fonte di ispirazione per questa trattazione.
Nella prima parte di questa trattazione abbiamo descritto le procedure necessarie per la definizione di uno schema di dati, per l'utilizzo di
uno scaffolding (impalcatura dell'applicazione) e per la modifica del layout delle pagine di un piccolo blog creato sfruttando le potenzialità e
i metodi messi a disposizione dal framework Symfony.
I nostri prossimi obiettivi saranno rivolti all'estensione delle funzionalità relative all'applicazione, in particolare analizzeremo i passaggi
necessari per integrare nel nostro blog elementi che consentano l'interazione con gli utenti come i commenti e relativi form per
l'inserimento.
3 di 10 03/11/2009 01:11
Symfony: progettazione un blog (versione per la s... http://php.html.it/articoli/stampa/2647/symfony-pro...
Questa relazione viene espressa visivamente tramite il template della pagina che propone una rappresentazione di quella che è la relazione
tra i moduli comment e post derivanti dallo schema di dati della nostra applicazione. I commenti sono legati ai relativi articoli sulla base di
un identificatore unico di riferimento (id) che ci permette di mostrare entrambe le informazioni (e se lo desideriamo, solo quelle) sulla
stessa pagina.
In Symfony la relazione tra dati e template è possibile grazie alle actions, quindi se per esempio nella nostra applicazione volessimo
mostrate i commenti sotto gli articoli dovremmo modificare il file in cui sono contenute le actions del blog.
Questo file si trova sul percorso sf_sandbox/apps/frontend/modules/post/actions/actions.class.php, nel nostro caso dovremo modificare
il metodo executeShow() inserendo alcune righe di codice:
$c = new Criteria();
$c->add(CommentPeer::POST_ID, $this->getRequestParameter('id'));
$c->addAscendingOrderByColumn(CommentPeer::CREATED_AT);
$this->comments = CommentPeer::doSelect($c);
Le righe aggiunte presentano due elementi denominati Criteria e -Peer entrambi appartenenti al mapping basato su relazioni tra oggetti
della libreria Propel che, come abbiamo sottolineato in precedenza, consente di interrogare il database senza dover digitare alcuna query;
gli oggetti introdotti avranno quindi il compito di formulare un'interrogazione sulla tabella relativa ai commenti e permetteranno di
estrarre soltanto quelli riferiti all'articolo corrente, ciò è possibile grazie al campo id dei post che permette di salvare nella tabella dei
commenti un valore post_id ogni volta che un utente inserisce un contributo per un determinato articolo.
Grazie alla linea $this->comments presente nell'azione sarà possibile avere accesso alla variabile $comments del template, quindi il nostro
prossimo passaggio sarà quello di modificare il file relativo al template destinato a mostrare gli articoli che si trova sul percorso
sf_sandbox/apps/frontend/modules/post/templates/showSuccess.php, esso dovrà presentare alla fine le seguenti righe di codice:
<hr />
<?php if($comments) : ?>
<p>Sono presenti <?php echo count($comments) ?> commenti per questo articolo.</p>
<?php foreach ($comments as $comment): ?>
<p>Inserito da <em><?php echo $comment->getAuthor() ?></em> il <?php echo format_date($comment->getCreatedAt()) ?><br />
<?php echo simple_format_text($comment->getBody()) ?></p>
<?php endforeach ?>
<?php endif ?>
format_date() e simple_format_text() sono due funzioni messe a disposizione dal framework, entrambe rientrano nella categoria degli
helpers (letteralmente aiutanti) in quanto consentono di dar luogo a comportamenti tramite una semplice chiamata (sintassi:
use_helper('nome_funzione')) evitando la digitazione di lunghe righe di codice.
4 di 10 03/11/2009 01:11
Symfony: progettazione un blog (versione per la s... http://php.html.it/articoli/stampa/2647/symfony-pro...
link_to() è una funzione messa a disposizione da Symfony che permette di puntare ad una determinata azione tramite un collegamento
ipertestuale, nel nostro caso abbiamo appunto un link che rimanda all'azione relativa al modulo per l'inserimento dei commenti.
Ora apriamo la pagina editSuccess.php che si trova nella directory modules/comment/templates/ e modifichiamo le righe:
<tr>
<th>Post*:</th>
<td><?php echo object_select_tag($comment, 'getPostId', array (
'related_class' => 'Post',
)) ?></td>
</tr>
Sostituendole con il codice seguente:
<?php if ($sf_request->hasParameter('post_id')): ?>
<?php echo input_hidden_tag('post_id',$sf_request->getParameter('post_id')) ?>
<?php else: ?>
<tr>
<th>Articolo*:</th>
<td><?php echo object_select_tag($comment, 'getPostId', array (
'related_class' => 'Post',
)) ?></td>
</tr>
<?php endif ?>
Abbiamo ora un form presente in comment/create che punta verso l'azione comment/update con il compito di effettuare un
rindirizzamento verso comment/show. Semplificando quanto esposto, possiamo dire che l'invio di dati tramite form determina la
visualizzazione dei commenti al di sotto dell'articolo. Perché ciò sia possibile è però necessario effettuare delle modifiche all'interno del file
modules/comment/actions/actions.class.php in cui è presente il metodo executeUpdate():
$comment->setId($this->getRequestParameter('id'));
$comment->setPostId($this->getRequestParameter('post_id'));
$comment->setAutore($this->getRequestParameter('autore'));
$comment->setEmail($this->getRequestParameter('email'));
$comment->setBody($this->getRequestParameter('body'));
$comment->save();
return $this->redirect('post/show?id='.$comment->getPostId());
}
Con questa semplice modifica gli utenti potranno inviare commenti ai singoli articoli e l'applicazione sarà in grado di raccoglierli, processarli
e archiviarli mettendoli in relazione con gli articoli a cui sono riferiti.
Fortunatamente Symfony mette a disposizione una semplice procedura per la validazione dei dati di input; basterà infatti creare un file
5 di 10 03/11/2009 01:11
Symfony: progettazione un blog (versione per la s... http://php.html.it/articoli/stampa/2647/symfony-pro...
denominato update.yml da salvare all'interno di una directory presente nel seguente percorso: sf_sandbox/apps/frontend/modules
/comment/validate/ (da creare nel caso non sia disponibile).
Utilizzando la sintassi YALM, quindi rispettando attentamente l'indentazione, sarà poi necessario digitare nel file le seguenti istruzioni:
methods:
post: [autore, email, body]
get: [autore, email, body]
fillin:
enabled: on
names:
autore:
required: Yes
required_msg: Campo autore obbligatorio
email:
required: Yes
required_msg: Campo email obbligatorio
validators: emailValidator
body:
required: Yes
required_msg: Hai dimenticato di scrivere il commento
emailValidator:
class: sfEmailValidator
param:
email_error: Indirizzo email non valido
gli invii tramite form potranno essere effettuati tramite metodo POST o metodo GET, per entrambi i campi che dovranno essere
sottoposti a validazione sono gli stessi;
la direttiva fillin consente di ricompilare i form con informazioni precedentemente inviate dagli utenti, mentre names è la voce che
introduce il nome dei parametri che dovranno essere validati o meno;
required accetta due argomenti: Yes oppure No; nel nostro caso tutti i campi sono obbligatori e quindi required è impostata
sempre su Yes;
required_msq è la notifica di errore che verrà mostrata per segnalare all'utente che un determinato parametro obbligatorio non è
stato inviato, ogni notifica potrà essere personalizzata sulla base del campo che dovrà essere controllato;
per l'email viene introdotto un doppio controllo: questo campo non solo non deve essere vuoto (required) ma deve anche essere
espresso in forma valida; per la sua validazione viene introdotta la classe sfEmailValidator che ne verificherà la correttezza pronta
ad inviare eventuali notifiche di errore.
Le notifiche degli errori vengono effettuate attraverso un apposito template su cui verrà rindirizzato il browser dell'utente (pagina
updateError.php).
Nell'attesa attesa consigliamo per eventuali approfondimenti la lettura del Wiki Il mio primo progetto con Symfony (http://trac.symfony-
project.com/wiki/MyFirstSymfonyProjectItalian) fondamentale fonte di informazioni per la stesura di questa serie di articoli.
Siamo arrivati all'ultima parte della nostra trattazione dedicata alla creazione di una prima applicazione con il framework open souce per
PHP Symfony. Nelle prossime pagine concluderemo l'esposizione dei passaggi necessari alla realizzazione di un semplice blog.
6 di 10 03/11/2009 01:11
Symfony: progettazione un blog (versione per la s... http://php.html.it/articoli/stampa/2647/symfony-pro...
Modificheremo in primo luogo gli URL, che dovranno essere resi più semplici da digitare per gli utenti e più facilmente indicizzabili per i
motori di ricerca, in secondo luogo vedremo come dotare il blog di un semplice sistema di gestione dei contenuti da area di
amministrazione (backend) protetta tramite password.
Generalmente un buon URL viene creato utilizzando il titolo del post contenuto nella pagina di destinazione; i titoli sono brevi ma anche
riassuntivi dei contenuti affrontati, caratteristiche che li rendono una risorsa ottimale per le operazioni di riscrittura degli URL. Un titolo
però può contenere dei caratteri speciali, degli spazi o delle lettere accentate, elementi che vanno corretti, "tradotti" o eliminati per
migliorare l'aspetto degli indirizzi.
Symfony mette a disposizione una semplice procedura per ovviare a questi problemi che consiste nell'estensione del model attraverso cui
verrà introdotto un metodo appositamente dedicato all'oggetto Post.
Per procedere bisognerà prima di tutto modificare il file Post.php presente sul percorso sf_sandbox/lib/model/
return $result;
}
Con il passaggio successivo sarà invece possibile introdurre un'azione permalink all'interno del modulo post, per far questo sarà
necessario modificare il file actions.class.php, presente nel percorso modules/post/actions/, aggiungendo le seguenti righe di codice:
$this->getRequest()->setParameter('id', $post->getId());
$this->forward('post', 'show');
}
In questo modo l'azione post list sarà in grado di richiamare permalink invece dell'azione post per ciascun post.
7 di 10 03/11/2009 01:11
Symfony: progettazione un blog (versione per la s... http://php.html.it/articoli/stampa/2647/symfony-pro...
Ora dovremo agire sul file listSuccess.php presente sul percorso modules/post/templates/; in esso non viene effettuata alcuna correzione
al titolo per la creazione degli URL, quindi dovremo sostituire la riga di codice relativa all'output
Infine dovremo agire sul file routing.yml situato nella directory sf_sandbox/apps/frontend/config/, per inserire alcune regole che
dovranno essere espresse nella sintassi YALM rispettando attentamente l'indentazione utilizzata per il seguente esempio:
list_of_posts:
url: /latest_posts
param: { module: post, action: list }
post:
url: /weblog/:title
param: { module: post, action: permalink }
È bene ricordare che il file .yml rappresentano in Symfony lo schema dell'applicazione e sono altrettanto importanti quanto i file PHP e il
contenuto del database.
Per far questo dovremo innanzitutto rimuovere dal file modules/post/templates/showSuccess.php il collegamento ipertestuale che
consente di accedere all'editing dei contenuti. Si tratta di un piccolo link edit prodotto come output dalla seguente riga di codice che
dovrà essere rimossa:
naturalmente anche questa porzione di codice dovrà essere eliminato dal template.
executeCreate
executeEdit
executeUpdate
executeDelete
Una volta fatto questo potremo passare alla fase relativa alla creazione dell'area di amministrazione.
Portiamoci quindi da shell sulla directory che contiene il progetto sf_sandbox e digitiamo i seguenti comandi:
Grazie ad essi potremo richiamare l'admin generator di Symfony con cui realizzare il backend del blog sfruttando una procedura
praticamente automatica.
Il prossimo passaggio richiederà la modifica del file apps/backend/template/layout.php che dovremo modificare in modo da ottenere un
semplice menu di navigazione:
<div>
<ul>
<li><?php echo link_to('Gestisci i post', 'post/list') ?></li>
8 di 10 03/11/2009 01:11
Symfony: progettazione un blog (versione per la s... http://php.html.it/articoli/stampa/2647/symfony-pro...
Naturalmente il menu potrà essere migliorato esteticamente utilizzando i CSS magari da un foglio di stile esterno, per far questo sarà
però necessario copiare la cartella denominata sf_sandbox/web/sf/images/sf_admin/ nella directory sf/images/sf_admin/ che dovrà
essere salvata all'interno della root dell'applicazione.
http://localhost/sf_sandbox/web/backend_dev.php/post
Per modificare l'aspetto dell'area di amministrazione non sarà necessario agire sui file PHP, Symfony mette infatti a disposizione un file di
configurazione denominato generator.yml in backend/modules/post/config/ nel quale sono presenti tutte le regole relative al back end.
Anche in questo caso Symfony si rivela uno strumento estremamente ricco di opzioni, le regole relative alla sicurezza dell'applicazione
possono infatti essere definite facilmente salvando all'interno della directory apps/backend/modules/post/config/ un file denominato
security.yml contenente la direttiva esposta di seguito:
all:
is_secure: on
Ora il modulo dei post è sicuro, dovremo quindi creare un file perfettamente identico per la protezione dei commenti. Esauriti questi due
passaggi nessuno potrà accedere ai moduli protetti senza essersi prima autenticato. Dato che per ora non abbiamo a disposizione alcuna
interfaccia per l'autenticazione l'accesso è interdetto anche a noi che stiamo sviluppando l'applicazione.
Rechiamoci sulla shell e digitiamo il comando che ci consentirà di creare un modulo (security) appositamente dedicato all'autenticazione.
Il modulo creato permetterà di gestire il form per il login e le relative richieste di accesso, ora dovremo agire sul file apps/backend
/modules/security/templates/indexSuccess.php con cui costruiremo il form:
<label for="password">password:</label>
<?php echo input_password_tag('password') ?>
9 di 10 03/11/2009 01:11
Symfony: progettazione un blog (versione per la s... http://php.html.it/articoli/stampa/2647/symfony-pro...
Per ora security non è ancora il modulo predefinito per il controllo delle operazioni di autenticazione, questa regola dovrà quindi essere
comunicata all'applicazione con una semplice modifica da operare sul file apps/backend/config/settings.yml:
all:
.actions:
login_module: security
login_action: index
Il nostro blog (almeno per quanto riguarda le sue funzioni essenziali) può quindi ritenersi terminato e le due diverse parti da cui è
composto, front end e area di amministrazione, potranno essere raggiunte semplicemente digitando le due URL seguenti, che scriviamo
con il loro collegamento nel caso aveste provveduto a seguire i nostri passi: http://localhost/sf_sandbox/web/index.php/ (http://localhost
/sf_sandbox/web/index.php/) o http://localhost/sf_sandbox/web/backend.php/ (http://localhost/sf_sandbox/web/backend.php/).
Conclusioni
Con quest'ultima parte si conclude il nostro discorso riguardante la creazione di una prima applicazione utilizzando il framework Open
Source PHP Symfony. Symfony mette però a disposizione molte altre funzioni oltre a quelle elencate, quindi torneremo presto a parlarne
per scoprire insieme nuovi strumenti con cui semplificare il nostro lavoro di sviluppo.
© 1997-2006 HTML.it
La vendita, il noleggio, il prestito e la diffusione del contenuto di questa pagina sono vietate, tranne nei casi specificati nella pagina http://www.html.it
/info/note-legali.php
10 di 10 03/11/2009 01:11