Development

MyFirstSymfonyProjectItalian

You must first sign up to be able to contribute.

Version 12 (modified by giosan, 10 years ago)
--

Original Text: http://www.symfony-project.com/tutorial/my_first_project.html

Il mio primo progetto con Symfony

Quindi hai intenzione di provarci? Ok, allora costruiamo insieme un'applicazione web completamente funzionante in un'ora. Scegli tu. Un'applicazione per un negozio di libri? Ok, un'altra idea. Un blog! Questa è una buona idea. Iniziamo.

Daremo per scontato che tu abbia già installato apache con php5 e che abbia avviato il servizio sul tuo localhost. Avrai anche bisogno dell'estensione SQLite, che è compilata di default con PHP5. In ogni caso, dalla versione 5.1.0 di PHP avrai bisogno di attivare manualmente questa estensione nel file php.ini (guarda come farlo qui).

Installazione di Symfony e inizializzazione del progetto

Per velocizzare il tutto utilizzeremo il sandbox di symfony. Non è nient'altro che un progetto di symfony vuoto con tutte le librerie richieste per un progetto già incluse, e con la configurazione di base già pronta. Il vantaggio del sandbox rispetto ad altri tipi di installazione è che in questo modo potete iniziare a sperimentare con symfony immediatamente.

Scaricalo da qui: sf_sandbox.tgz, e decomprimilo nella direcory root del tuo server web. Per avere maggiori informazioni puoi sempre dare uno sguardo al file readme incluso. La struttura delle directory risultante, dopo aver decompresso l'archivio, dovrebbe essere questa:

www/
  sf_sandbox/
    apps/
      frontend/
    batch/
    cache/
    config/
    data/
      sql/
    doc/
      api/
    lib/
      model/
    log/
    test/
    web/
      css/
      images/
      js/
      uploads/

Questo è un progetto sf_sandbox che contiente un'applicazione frontend. Puoi testare il sandbox richiedendo l'URL seguente:

http://localhost/sf_sandbox/web/index.php/

A questo punto, se tutto è andato bene, dovresti vedere una pagina di congratulazioni. http://www.symfony-project.com/images/tutorials/first_congrats.gif

Nota: Se non dovessi vedere questa pagina controlla che nel tuo file di configurazione php.ini ci sia magic_quotes_gpc posto a off. Per avere ulteriore aiuto puoi dare uno sguardo al forum di installazione, dove molti casi particolari sono già stati risolti.

Puoi anche installare symfony in una directory a tua scelta e configurare in tuo web server con un Virtual Host o un Alias. Il libro di symfony contiene dei capitoli dettagliati riguardo l'installazione di symfony e creazione di un progetto, la Le basi per la creazione di pagine e come Configurare symfony all'interno del progetto.

Inizializzazione del model

Il blog conterrà dei post, e tu dovrai abilitare dei commenti su questi ultimi. Crea un file chiamato schema.yml nella directory sf_sandbox/config/ e incollaci dentro il seguente modello per i dati:

propel:
  weblog_post:
    _attributes: { phpName: Post }
    id:
    title:       varchar(255)
    excerpt:     longvarchar
    body:        longvarchar
    created_at:
  weblog_comment:
    _attributes: { phpName: Comment }
    id:
    post_id:
    author:      varchar(255)
    email:       varchar(255)
    body:        longvarchar
    created_at:

Questo file di configurazione usa la sintassi YAML. YAML è un linguaggio molto semplice che consente di creare una struttura ad albero descritta dall'indentazione simile a quella di XML. Inoltre, è più semplice da leggere e scrivere rispetto all' XML. L'unica cosa da tenere a mente è che l'indentazione ha un significato (molto importante) e che la tabulazione è proibita, perciò ricorda di usare gli spazi per l'indentazione. Puoi trovare più informazioni riguardo YAML e la configurazione di symfony nel capitolo relativo alla configurazione.

Questo schema descrive la struttura di due tabelle necessarie per il blog. Post e Comment sono i nomi delle classi collegate alle tabelle che saranno generate. Salva il file, apri un prompt dei comandi, spostati nella directory sf_sandbox/ e digita:

$ symfony propel-build-model

Nota: Sulle piattaforme *nix, dovresti chiamare ./symfony.sh o forse solo symfony.

A questo punto verranno create alcune classi nella directory sf_sandbox/lib/model/. Queste sono le classi per il mappaggio object-relational, che ci consentono di avere accesso ad un database relazionale dal codice object-oriented senza scrivere nemmeno una query in SQL. Symfony usa la libreria Propel per questo scopo. D'ora in poi ci riferiremo a questi oggetti come al modello (puoi trovare di più su questo argomento nel capitolo relativo al model).

Ora dalla riga di comando digita:

$ symfony propel-build-sql

Verrà creato un file schema.sql nella directory sf_sandbox/data/sql/. Questo file sql può essere utilizzato per inizializzare un database con la stessa struttura delle tabelle. Puoi creare un database in MySQL con la linea di comando o con l'interfaccia web (come descritto nel capitolo sul model). Fortunatamente la sandbox di symfony è configurata per funzionare con un semplice file SQLite, perciò non è richiesta nessuna inizializzazione del database. Di default, il progetto sf_sandbox userà il database chiamato sandbox.db situato nella directory sf_sandbox/data/. Per costruire la struttura delle tabelle basata sul file SQL digita:

$ symfony propel-insert-sql

Nota: Non ti preoccupare se vedi dei warning a questo punto, è assolutamente normale. Il comando insert-sql cerca di rimuovere le vecchie tabelle prima di aggiungere le nuove dal tuo file schema.sql, e non ci sono tabelle da rimuovere a questo punto.

Creazione dello scaffolding per l'applicazione

L'applicazione di base per un blog è di Creare, Richiedere, Aggiornare e Cancellare (CRUD dall'inglese Create, Retrieve, Update e Delete) dei post e commenti. Dato che è la prima volta che usi symfony, ora non creerai del codice da zero, ma creeremo uno scaffolding che poi potrai usare e modificare secondo le tue necessità. Symfony può interpretare il model per generare l'interfaccia per il CRUD automaticamente:

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

Nota: Assicurati di essere l'utente root del tuo progetto (sf_sandbox/) quando chiami i comandi symfony.

A questo punto avrai due moduli (post e comment) che ti consentiranno di manipolare oggetti delle classi Post e Comment. Un modulo rappresenta una pagina o un gruppo di pagine con un qualcosa in comune. I tuoi nuovi moduli sono situati nella directory sf_sandbox/apps/frontend/modules/ e sono accessibili attraverso gli URL:

http://localhost/sf_sandbox/web/frontend_dev.php/post http://localhost/sf_sandbox/web/frontend_dev.php/comment

A questo punto puoi creare dei nuovi post per fare in modo che il blog risulti meno vuoto.

http://www.symfony-project.com/images/tutorials/first_crud.gif

Ti consiglio di documentarti a fondo sullo scaffolding e sulla struttura del progetto symfony (progetto, applicazione, modulo).

Nota: Negli URL appena visti, il nome dello script principale - chiamato front controller in symfony - è stato cambiato da index.php in frontend_dev.php. I due script accedono alla stessa applicazione (frontend), ma in diversi ambienti. Con frontend_dev.php accedi all'applicazione nell' ambiente di sviluppo, che fornisce degli strumenti per lo sviluppo, come una barra di debug nell'angolo in alto a destra dello schermo e il motore di configurazione dal vivo. Per questo motivo ogni pagina viene processata molto più lentamente nell'ambiente di sviluppo piuttosto che che quando si usa index.php, che è il front controller nell' ambiente di produzione, ottimizzato per la velocità. Se vuoi usare l'ambiente di produzione, semplicemente sostituisci frontend_dev.php con index.php negli URL, ma non dimenticarti di pulire la cache prima di guardare i cambiamenti:

$ symfony clear-cache

http://localhost/sf_sandbox/web/index.php/

In questa pagina puoi trovare più documentazione sugli ambienti di symfony.

Modifica del layout della pagina

Per poter navigare avanti e indietro fra i due moduli, il blog ha bisogno di qualcosa che fornisca una navigazione. Modifica il template globale sf_sandbox/apps/frontend/templates/layout.php e cambia il contenuto del tag <body> come segue:

<div id="container" style="width:600px;margin:0 auto;border:1px solid grey;padding:10px">
  <div id="navigation" style="display:inline;float:right">
    <ul>
      <li><?php echo link_to('List of posts', 'post/list') ?></li>
      <li><?php echo link_to('List of comments', 'comment/list') ?></li>
    </ul>
  </div>
  <div id="title">
    <h1><?php echo link_to('My first symfony project', 'default/index') ?></h1>
  </div>
 
  <div id="content" style="clear:right">
    <?php echo $sf_content ?>
  </div>
</div>

Siate pazienti per l'uso di un design davvero scarno e l'uso dei tag css in-line, ma un'ora è davvero molto poco.

http://www.symfony-project.com/images/tutorials/first_crud_layout.gif

Visto che ci siamo, cambiamo il titolo delle pagine. Modifica il file della configurazione della vista per l'applicazione (sf_sandbox/apps/frontend/config/view.yml), trova la linea con la chiave relativa al titolo dell'applicazione e cambiala come segue:

default:
  http_metas:
    content-type: text/html; charset=utf-8

  metas:
    title:        The best weblog ever
    robots:       index, follow
    description:  symfony project
    keywords:     symfony, project
    language:     en

La stessa home page va cambiata. Attualmente usare il template di default del modulo di default, che è contenuto nel framework ma non nella directory della tua applicazione. Per fare un override di questo, devi creare un tuo modulo di default:

$ cd apps/frontend/modules
$ mkdir default
$ cd default
$ mkdir templates
$ cd templates

Qui dentro crea un file indexSuccess.php che mostra un simpatico messaggio di benvenuto:

<h1>Welcome to my swell weblog</h1>
<p>You are the <?php echo rand(1000,5000) ?>th visitor today.</p>

Puoi ora controllare il risultato richiedendo nuovamente la home page: http://localhost/sf_sandbox/web/frontend_dev.php/ http://www.symfony-project.com/images/tutorials/first_welcome.gif

Ora puoi iniziare ad usare la tua nuova applicazione web: crea un nuovo post di prova e aggiungi dei commenti per questo post.

Documentati a fondo sui template e sulla configurazione delle view.

Passare dei dati dall'azione al template

Fin'ora è stato semplice no? Ora è il momento di mischiare parti di codice del modulo comment col modulo post per fare in modo che i commenti siano mostrati sotto i post.

Per prima cosa, hai bisogno di fare in modo che i commenti dei post siano disponibili per il template dei post. In symfony questo tipo di logica è tenuta nelle actions. Modifica il file delle actions sf_sandbox/apps/frontend/modules/post/actions/actions.class.php e cambia il metodo executeShow() con l'aggiunta delle 4 linee di mezzo:

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);
}

Gli oggetti Criteria e -Peer sono parte del mapping object-relational di Propel. Principalmente, queste quattro linee gestiranno una query SQL alla tabella Comment per ottenere i commenti collegati al post attuale (quello definito dal parametro id dell'URL). La linea $this->comments nell'azione darà accesso alla variabile $comments nel template corrispondente. A questo punto modifica il template che mostra i post sf_sandbox/apps/frontend/modules/post/templates/showSuccess.php semplicemente aggiungendo alla fine:

...
<?php use_helper('Text') ?>
<?php use_helper('Date') ?>
 
<hr />
<?php if($comments) : ?>
  <p><?php echo count($comments) ?> comment<?php if(count($comments)>1) : ?>s<?php endif ?> to this post.</p>
  <?php foreach ($comments as $comment): ?>
    <p><em>posted by <?php echo $comment->getAuthor() ?> on <?php echo format_date($comment->getCreatedAt()) ?></em></p>
    <div class="comment" style="margin-bottom:10px;">
      <?php echo simple_format_text($comment->getBody()) ?>
    </div>    
  <?php endforeach ?>
<?php endif ?>

Questa pagina usa delle funzioni PHP (format_date() e simple_format_text()) fornite da symfony, queste sono chiamate 'helpers' perchè svolgono per te alcune funzioni che normalmente richiederebbero molto tempo e diverse righe di codice. Crea un nuovo commento per il tuo primo post, quindi controlla di nuovo il tuo primo post, sia cliccando sul suo numero nella lista che digitando direttamente:

http://localhost/sf_sandbox/web/frontend_dev.php/post/show?id=1 http://www.symfony-project.com/images/tutorials/first_comments_under_post.gif

Sembra già meglio, che ne dici?

Aggiungere un record relativo ad un'altra tabella

Quando aggiungi un commento, puoi scegliere l'id del post collegato. Questo non è molto user-friendly. Vediamo di cambiare questo, e facciamo in modo che l'utente torni indietro al post che stava guardando dopo aver aggiunto un commento.

Per prima cosa nel template modules/post/templates/showSuccess.php, aggiungi questa riga alla fine:

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

L'helper link_to() crea un hyperlink che punta all'azione create del modulo comment, in questo modo potrete aggiungere un commento direttamente dalla pagina sui dettagli del post. Ora, apri il file modules/comment/templates/editSuccess.php e sostituisci le righe seguenti:

<tr>
  <th>Post*:</th>
  <td><?php echo object_select_tag($comment, 'getPostId', array (
  'related_class' => 'Post',
)) ?></td>
</tr>

con:

<?php if ($sf_request->hasParameter('post_id')): ?>
  <?php echo input_hidden_tag('post_id',$sf_request->getParameter('post_id')) ?> 
<?php else: ?>
  <tr>
    <th>Post*:</th>
    <td><?php echo object_select_tag($comment, 'getPostId', array (
    'related_class' => 'Post',
    )) ?></td>
  </tr>
<?php endif ?>

Il form nella pagina comment/create punta all'azione comment/update, che redirige a comment/show quando inviato(questo è il comportamento di default nei moduli CRUD generati da symfony). Per il nostro blog, questo significa che dopo l'aggiunta di un commento ad un post, vengono mostrati i dettagli del commento. A questo punto è sicuramente meglio mostrare il post coi suoi commenti. Perciò apri il file modules/comment/actions/actions.class.php e cerca il metodo executeUpdate(). Nota che il campo created_at non è definito dall'azione: in quanto symfony sa che un campo chiamato created_at deve essere impostato all'ora attuale del sistema quando viene creato il record. Il redirect finale dell'azione deve essere modificato perchè punti all'azione corretta. Quindi cambialo in:

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->setAuthor($this->getRequestParameter('author'));
  $comment->setEmail($this->getRequestParameter('email'));
  $comment->setBody($this->getRequestParameter('body'));
 
  $comment->save();
 
  return $this->redirect('post/show?id='.$comment->getPostId());
}

Adesso gli utenti possono postare commenti ad un post e ritornare indietro al post. Volevi un vero blog? Ora hai un vero blog.

Ulteriore documentazione sulle azioni.

Validazione dei form

I visitatori possono inserire dei commenti, ma cosa succede se inviano un form senza alcun dato? A questo punto avresti un database "sporco". Per evitare questo crea un file chiamato update.yml nella directory {{{ sf_sandbox/apps/frontend/modules/comment/validate/}}} (probabilmente dovrai creare anche la directory) e scrivici dentro:

methods:
  post:           [author, email, body]
  get:            [author, email, body]


fillin:
  enabled:        on

names:
  author:
    required:     Yes
    required_msg: The name field cannot be left blank

  email:  
    required:     No
    validators:   emailValidator

  body:
    required:     Yes
    required_msg: The text field cannot be left blank

emailValidator:
  class:          sfEmailValidator
  param:
    email_error:  The email address is not valid.

L'attivazione di fillin abilita la ricompilazione del form coi dati precedentemente inseriti dall'utente nel caso in cui la validazione dello stesso fallisca. La dichiarazione names imposta le regole di validazione per ogni campo del form.

Il controller redirige l'utente al template updateError.php se viene riscontrato un errore. Sarebbe meglio mostrare di nuovo il form con un messaggio di errore. Per fare questo, è sufficiente aggiungere un metodo handleError alla classe modules/comment/actions/actions.class.php:

public function handleError()
{
  $this->forward('comment', 'create');
}

Infine, apri di nuvo il file modules/comment/templates/editSuccess.php e inserisci all'inizio:

<?php if ($sf_request->hasErrors()): ?>  
  <div id="errors" style="padding:10px;">
    Please correct the following errors and resubmit:
    <ul>
    <?php foreach($sf_request->getErrors() as $error): ?>
      <li><?php echo $error ?></li>
    <?php endforeach ?>
    </ul>
  </div>
<?php endif ?>

Ora hai un form robusto. http://www.symfony-project.com/images/tutorials/first_form_validation.gif

Trova ulteriore documentazione sulla validazione dei form

Cambia l'aspetto degli URL

Hai notato come sono mostrati gli URL? Li puoi rendere molto più user-friendly e engine-friendly. Vediamo di usare il titolo del post come URL per il post stesso.

Il problema è che i titoli dei post possono contenere caratteri speciali, come gli spazi. Se usi soltanto delle sequenze di escape l'URL mostrerà dei bruttissimi %20, per questo estendiamo il model per aggiungtere un nuovo metodo all'oggetto Post, in modo da ottenere un bel titolo. Per fare questo modifica il file Post.php situato nella directory sf_sandbox/lib/model/, e aggiungi il metodo seguente:

public function getStrippedTitle()
{
  $result = strtolower($this->getTitle());
 
  // strip all non word chars
  $result = preg_replace('/\W/', ' ', $result);
 
  // replace all white space sections with a dash
  $result = preg_replace('/\ +/', '-', $result);
 
  // trim dashes
  $result = preg_replace('/\-$/', '', $result);
  $result = preg_replace('/^\-/', '', $result);
 
  return $result;
}

Ora puoi creare un'azione permalink nel modulo post. Aggiungi il medoto seguente al file modules/post/actions/actions.class.php:

public function executePermalink()
{
  $posts = PostPeer::doSelect(new Criteria());
  $title = $this->getRequestParameter('title');
  foreach ($posts as $post)
  {
    if ($post->getStrippedTitle() == $title)
    {
      break;
    }
  }
  $this->forward404Unless($post);
 
  $this->getRequest()->setParameter('id', $post->getId());
 
  $this->forward('post', 'show');
}

L'azione post list può chiamare questa azione permalink invece dell'azione post per ogni post. Nel file modules/post/templates/listSuccess.php, rimuovi l'intestazione id della tabella e la cella, e cambia la cella Title da:

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

in:

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

Un ultimo passo: modifica il file routing.yml situato nella directory sf_sandbox/apps/frontend/config/ e aggiungi queste regole all'inizio:

list_of_posts:
  url:   /latest_posts
  param: { module: post, action: list }

post:
  url:   /weblog/:title
  param: { module: post, action: permalink }

Ora naviga di nuovo nell'applicazione e osserva gli URL. http://www.symfony-project.com/images/tutorials/first_routing.gif

Documentati ulteriormente sugli URL intelligenti.

Pulizia del frontend

Bene, se questo è un blog, ognuno ha il diritto di aggiungere un post. Questo è quello che stavi pensando, giusto? Ok, puliamo un pochino i nostri template.

Nel file modules/post/templates/showSuccess.php, rimuovi il link 'edit' rimuovendo la linea:

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

Fai lo stesso per il template modules/post/templates/listSuccess.php e rimuovi:

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

Devi inoltre rimuovere i seguenti metodi dal file modules/post/actions/actions.class.php:

* executeCreate
* executeEdit
* executeUpdate
* executeDelete

Fatto, a questo punto i lettori non possono più postare.

Generazione del backend

Per consentirti di creare dei post ora creiamo un'applicazione backend, per fare questo è sufficiente digitare dalla riga di comando (sempre dalla directory del progetto sf_sandbox):

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

Questa volta useremo l'admin generator. Offre molte più potenzialità e possibilità di configurazione rispetto al CRUD generator.

Esattamente come hai fatto per l'applicazione frontend, modifica il layout (apps/backend/template/layout.php) per aggiungere una navigazione globale:

<div id="navigation">
  <ul style="list-style:none;">
    <li><?php echo link_to('Manage posts', 'post/list') ?></li>
    <li><?php echo link_to('Manage comments', 'comment/list') ?></li>
  </ul>
</div>      
<div id="content">
  <?php echo $sf_content ?>
</div>

Nota: Dato che stai usando una sandbox, devi anche copiare la directory sf_sandbox/web/sf/images/sf_admin/ in una directory chiamata sf/images/sf_admin/ nella tua root dell'applicazione (questo per i path nel foglio di stile CSS).

Puoi accedere la tua nuova applicazione back-office nell'ambiente di sviluppo chiamando:

http://localhost/sf_sandbox/web/backend_dev.php/post

http://www.symfony-project.com/images/tutorials/first_basic_admin.gif

Il maggior vantaggio del modulo admin è che puoi facilmente modificarlo semplicemente modificando un file di configurazione.

Modifica il file backend/modules/post/config/generator.yml come segue:

generator: 
  class:              sfPropelAdminGenerator
  param:
    model_class:      Post
    theme:            default
    fields:
      title:          { name: Title }
      excerpt:        { name: Exerpt }
      body:           { name: Body }
      nb_comments:    { name: Comments }
      created_at:     { name: Creation date }
    list:
      title:          Post list
      layout:         tabular
      display:        [=title, excerpt, nb_comments, created_at]
      object_actions:
        _edit:        -
        _delete:      -
      max_per_page:   5
      filters:        [title, created_at]
    edit:  
      title:          Post detail        
      fields:
        title:        { type: input_tag, params: size=53 }
        excerpt:      { type: textarea_tag, params: size=50x2 }
        body:         { type: textarea_tag, params: size=50x10 }
        created_at:   { type: input_date_tag, params: rich=on }

Nota che fra le altre colonne della tabella Post, il modulo admin cercherà di accedere a nb_comments. Non c'è ancora un getter, ma è semplice aggiungerlo al file sf_sandbox/lib/model/Post.php:

public function getNbComments()
{
  return count($this->getComments()); 
}

A questo punto fai un refresh della pagina per vedere i cambiamenti:

http://www.symfony-project.com/images/tutorials/first_custom_admin.gif

Inibire l'accesso al backend

Chiunque può accedere al backend in questo momento. Devi fare in modo di aggiungere delle restrizioni di accesso.

Nella directory apps/backend/modules/post/config/, aggiungi un file chiamato security.yml col seguente contenuto:

all:
  is_secure: on

Ripeti l'operazione per il modulo comment. A questo punto non potrai più accedere a questi moduli, a meno che tu non sia loggato nel sistema.

Ma l'azione di login ancora non esiste! Ok, vediamo come fare in modo di aggiungerla semplicemente. Per prima cosa creiamo lo scheletro del modulo security:

$ symfony init-module backend security

Questo nuovo modulo sarà usato per gestire il form di login e la richiesta. Modifica il file apps/backend/modules/security/templates/indexSuccess.php per creare il form di login:

<h2>Authentication</h2>
 
<?php if ($sf_request->hasErrors()): ?>
  Identification failed - please try again
<?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>

Aggiungi al modulo security l'azione di login che è chiamata dal form (nel file apps/backend/modules/security/actions/actions.class.php):

public function executeLogin()
{
  if ($this->getRequestParameter('login') == 'admin' && $this->getRequestParameter('password') == 'password')
  {
    $this->getUser()->setAuthenticated(true);
    return $this->redirect('default/index');
  }
  else
  {
    $this->getRequest()->setError('login', 'incorrect entry');
    return $this->forward('security', 'index');
  }
}

L'ultima cosa che rimane da fare è fare in modo che il modulo security sia il modulo di default per la gestione delle azioni di login. Per fare questo apri il file di configurazione apps/backend/config/settings.yml e aggiungi:

all:
  .actions:
    login_module:           security
    login_action:           index

A questo punto se cerchi di accedere alla pagina di gestione dei post dovrai inserire nome utente e password:

http://www.symfony-project.com/images/tutorials/first_login.gif

Leggi ulteriore documentazione sulla sicurezza

Conclusioni

Ok, l'ora è finita. Ce l'hai fatta. Ora puoi usare entrambe le applicazioni nell'ambiente di produzione e giocare con loro:

frontend:   http://localhost/sf_sandbox/web/index.php/
backend:    http://localhost/sf_sandbox/web/backend.php/

A questo punto, se ricevi qualche errore, potrebbe essere perchè hai cambiato il modello dopo che alcune azioni sono state messe in cache (la cache non è attiva nell'ambiente di sviluppo). Per pulire la cache digita semplicemente:

$ symfony cc

Visto? ora l'applicazione è veloce e risponde rapidamente. Abbastanza figo no? Ora sentiti libero di esplorare il codice, e i nuovi moduli e cambiare il design delle pagine.

E non dimenticare di menzionare le tue applicazioni basate su symfony funzionanti nel Wiki di symfony!