Symfony: progettazione un blog

Per realizzare la nostra prima applicazione basata su Symfony ci appoggeremo alla sandbox. Ne abbiamo già parlato 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.

Schema dell'applicazione e sintassi YALM

Per una prima applicazione basata su Symfony realizzeremo un semplice blog destinato a contenere articoli e relativi commenti; come passo iniziale dovremo creare un file denominato schema.yml da salvare nella directory sf_sandbox/config/, questo file dovrà contenere il codice seguente:

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

Utilizzo dello scaffolding

Uno dei problemi che spesso si devono affrontare quando si decide di realizzare un content manager come può essere per esempio un blog, è quello di scegliere tra la creazione da zero dell'applicazione (approccio from scratch) oppure ricorrere ad un CMS (magari Open Source) preesistente.

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):

$ symfony propel-generate-crud frontend post Post
$ symfony propel-generate-crud frontend comment Comment

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

Modifica del layout delle pagine

A questo punto, una volta realizzato il nostro scaffolding, sarà possibile dare un aspetto alle pagine del blog; come sottolineato in precedenza, uno dei grandi vantaggi nell'utilizzo di Symfony sta nel fatto che questo framework permette di separare nettamente la parte relativa all'applicazione da quella che attiene la sua presentazione grafica.

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>
  </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:

<?php echo "<p>Lorem ipsum..</p>"; ?>

in favore di:

<p><?php echo "Lorem ipsum.." ?></p>

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

Relazioni tra post e commenti

In un blog i commenti svolgono un ruolo fondamentale e permettono agli utenti di partecipare alla vita del nostro sito Web con contributi, critiche, riferimenti ed eventuali spunti per la discussione; perché questo sia possibile è necessario che esista una relazione tra articoli pubblicati e relativi commenti.

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:

public function executeShow ()
{
  $this->post = PostPeer::retrieveByPk($this->getRequestParameter('id'));
 
  $c = new Criteria();
  $c->add(CommentPeer::POST_ID, $this->getRequestParameter('id'));
  $c->addAscendingOrderByColumn(CommentPeer::CREATED_AT);
  $this->comments = CommentPeer::doSelect($c);
 
  $this->forward404Unless($this->post instanceof Post);
}

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:

<?php use_helper('Text') ?>
<?php use_helper('Date') ?>
 
<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.

Inserimento dei commenti

Cercheremo ora di rendere la nostra applicazione più semplice da utilizzare mettendo a disposizione degli utenti un link per l'aggiunta dei commenti che porti al relativo modulo di inserimento, per far questo dovremo innanzitutto modificare il file modules/post/templates/showSuccess.php digitando la seguente riga di istruzioni:

<?php echo link_to('Aggiungi un commento','comment/create?post_id='.$post->getId()) ?>

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():

public function executeUpdate ()
{
  if (!$this->getRequestParameter('id', 0))
  {
    $comment = new Comment();
  }
  else
  {
    $comment = CommentPeer::retrieveByPk($this->getRequestParameter('id'));
    $this->forward404Unless($comment);
  }    
 
  $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.

Validare gli input provenienti dai form

Mettere dei form a disposizione degli utenti senza effettuare alcun controllo sui dati inviati come parametri è una procedura inutile e rischiosa. Il nostro database potrebbe riempirsi velocemente di record inutili pregiudicando la qualità del nostro blog; la nostra applicazione deve essere invece in grado di gestire l'invio di form vuoti e di input non corretti.

Fortunatamente Symfony mette a disposizione una semplice procedura per la validazione dei dati di input; basterà infatti creare un file 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

Analizziamo ora il codice proposto:

• 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).

Parte II: conclusioni

In questa seconda parte della nostra trattazione dedicata alla creazione di una prima applicazione con Symfony abbiamo affrontato gli argomenti relativi alla gestione dei commenti: creazione del form per l'inserimento, memorizzazione degli stessi nel database e validazione dei dati di input. Nella prossima ed ultima parte affronteremo altri due argomenti fondamentali: la modifica delle URL e la creazione di un back end per la gestione del blog.

Nell'attesa attesa consigliamo per eventuali approfondimenti la lettura del Wiki Il mio primo progetto con Symfony 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.

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.

Modificare gli URL del blog

Di default Symfony non produce URL particolarmente ottimizzati e questa mancanza potrebbe andare a discapito di una buona indicizzazione delle pagine del nostro blog, è infatti necessario osservare alcuni accorgimenti perché gli indirizzi vengano modificati in modo da essere più graditi ai motori di ricerca. Si tratta di un lavoro basilare per qualsiasi attività SEO, l'eliminazione di variabili passate per stringa e la creazione di URL contestuali al contenuto trattato permetterà di risalire più facilmente le SERP dei motori.

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/

public function getStrippedTitle()
{
// tutte le lettere vengono espresse in minuscolo
 $result = strtolower($this->getTitle());
 
 // elimina tutti i caratteri speciali 
  $result = preg_replace('/W/', ' ', $result);
 
 // sostituisce gli spazi con il trattino
  $result = preg_replace('/ +/', '-', $result);
 
 // elimina gli spazi vicini ai trattini
  $result = preg_replace('/-$/', '', $result);
  $result = preg_replace('/^-/', '', $result);
 
  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:

public function executePermalink()
{
  $posts = PostPeer::doSelect(new Criteria());
  $title = $this->getRequestParameter('titolo');
  foreach ($posts as $post)
  {
    if ($post->getStrippedTitle() == $title)
    {
      break;
    }
  }
  $this->forward404Unless($post);
 
  $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.

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

<?php echo $post->getTitle() ?>

con una nuova riga espressa nel formato seguente:

<?php echo link_to($post->getTitle(), '/'.$sf_last_module.'/permalink?title='.$post->getStrippedTitle()) ?>

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.

Una semplice area di amministrazione

Prima di affrontare il discorso relativo all'area di amministrazione che ci consentirà di arricchire di articoli il nostro blog, dovremo agire sul template in modo da eliminare tutti i link che fino ad ora permettono a chiunque di postare, le funzioni di inserimento e di editing dei post sono infatti ancora in bella mostra sul nostro frontend.

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:

<?php echo link_to('edit', 'post/edit?id='.$post->getId()) ?>

Sempre in showSuccess.php abbiamo un link che permette di creare i post:

<?php echo link_to('create', 'post/create') ?>

naturalmente anche questa porzione di codice dovrà essere eliminato dal template.

Salviamo l'ultimo file modificato e spostiamoci su modules/post/actions/actions.class.php, apriamolo e rimuoviamo i metodi:

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:

$ symfony init-app backend
$ symfony propel-init-admin backend post Post
$ symfony propel-init-admin backend comment Comment

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>
    <li><?php echo link_to('Gestisci i commenti', 'comment/list') ?></li>
  </ul>
</div>      
<div>
  <?php echo $sf_content ?>
</div>

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.

A questo punto l'area di amministrazione sarà accessibile dall'indirizzo:

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.

Proteggere l'area di amministrazione

Nessun sito è sicuro se l'area di amministrazione non è protetta da un sistema di autenticazione efficace, per il momento l'accesso al backend del nostro blog è pubblico ma rimedieremo presto anche a questa mancanza imponendo le dovute restrizioni.

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.

$ symfony init-module backend security

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:

<h1>Admin del Blog</h1>
 
<?php if ($sf_request->hasErrors()): ?>
  Autenticazione fallita
<?php endif ?>
 
<?php echo form_tag('security/login') ?>
  <label for="login">login:</label>
  <?php echo input_tag('login', $sf_params->get('login')) ?>
 
  <label for="password">password:</label>
  <?php echo input_password_tag('password') ?>
 
  <?php echo submit_tag('submit', 'class=default') ?>
</form>

Di seguito dovremo modificare il file apps/backend/modules/security/actions/actions.class.php in modo da aggiungere al modulo security l'azione per il login e l'elaborazione dei parametri inviati tramite form:

public function executeLogin()
{
// controllo sui parametri inviati 
 if ($this->getRequestParameter('login') == 'admin' && $this->getRequestParameter('password') == 'password')
  {
// azione conseguente ad una verifica con esito positivo
    $this->getUser()->setAuthenticated(true);
    return $this->redirect('default/index');
  }
  else
  {
// azione conseguente ad una verifica con esito negativo
    $this->getRequest()->setError('login', 'incorrect entry');
    return $this->forward('security', 'index');
  }
}

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/ o 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.