Development

Documentation/fr_FR/my_first_project/trunk

You must first sign up to be able to contribute.

Version 12 (modified by Amrac, 10 years ago)
Its not schema.xml but schema.yml

Cette partie de la documentation est en cours de traduction. Cela signifie qu'elle est traduite de manière soit incomplète, soit inexacte. En attendant que cette traduction soit terminée, vous pouvez consulter la version en anglais pour des informations plus fiables.

Mon premier projet avec Symfony

Alors, vous voulez essayer ? Construisons ensemble en une heure une application web pleinement fonctionnelle. Que voulez-vous faire ? Une application de vente de livres ? Une autre idée ? Un blog! Bonne idée, allons-y.

Nous supposons que vous travaillez avec apache/PHP5 installés et lancés sur votre serveur local. Vous aurez aussi besoin de l'extension SQLite qui est fournie et compilée par défaut avec PHP5. Néanmoins, depuis PHP 5.1.0, vous devez activer manuellement l'extension dans php.ini. (infos ici)

Installer Symfony et initialiser le projet

Pour faire vite, nous allons utiliser le bac à sable de Symfony (sandbox) (Vous pouvez aussi télécharger le code source final). Il s'agit d'un projet Symfony vierge dans lequel toutes les bibliothèques sont déjà inclues et toutes les configurations standards déjà réalisées. Le grand avantage du bac à sable par rapport à d'autres types d'installations est que vous pouvez immédiatement commencer à expérimenter.

Téléchargez le ici : sf_sandbox.tgz, décompressez-le à la racine de votre répertoire web. Voir le readme inclus pour plus d'informations. L'arborescence des fichiers devrait ressembler à :

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

Le projet sf_sandbox contient donc une application frontend. Testez le bac à sable en saisissant l'URL suivante :


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

Vous devriez voir la page de configuration suivante :

Page d'accueil

NOTE (NdT) Si vous ne voyez par cette page, vérifiez que magic_quotes_gpc est bien à off dans votre fichier de configuration php.ini. Pour plus d'informations, consultez la partie installation du forum dans laquelle beaucoup de cas particuliers ont déjà été résolus.

Vous pouvez aussi installer Symfony dans un dossier quelconque et configurer votre serveur web avec un Virtual Host ou un Alias. Le livre de Symfony contient des chapitres détaillés sur l'installation et la structure des fichiers.

Initialiser le modèle de données

Le blog contiendra des articles qu'il sera possible de commenter. Créez et éditez le fichier sf_sandbox/config/schema.yml et collez-y la configuration suivante :

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:

Ce fichier de configuration utilise la syntaxe YAML. Il s'agit d'un langage très simple permettant l'emploie d'arborescences style XML décrites par indentation. De plus, c'est plus simple à lire et a écrire que XML. Il faut cependant retenir que l'indentation à un sens et que les tabulations sont strictement interdites. Pensez à n'utiliser que les espaces. Pour plus d'informations que YAML, lisez le chapitre concernant la configuration.

Ce code décrit deux tables Post et Comment. Sauvegardez-le et, en ligne de commande sous le répertoire sf_sandbox/, saisissez :

$ symfony propel-build-model

NOTE Assurez-vous d'être à la racine du projet (sf_sandbox/) avant de lancer la commande symfony

Certaines classes sont crées dans le répertoire sf_sandbox/lib/model/. Ce sont les classes du mappage objet-relationnel (ORM) qui nous permet d'avoir accès à une base de données relationnelle à partir d'un code orienté objet sans avoir à écrire une seule requête SQL. Symfony utilise la bibliothèque Propel pour cela. Nous appellerons ces objets : le modèle (Vous en apprendrez plus sur ce point au chapitre 8 - Inside the Model Layer).

Sur une de commande saisissez :

$ symfony propel-build-sql

Un fichier lib.model.schema.sql est créé dans sf_sandbox/data/sql/. Cette requête SQL peut être utilisée pour initialiser une base de données avec une structure identique. Vous pourriez créer une base de données dans MySQL avec la ligne de commande ou une interface web (tel que décrit dans le chapitre modèle). Heureusement, le bac à sable de Symfony est configuré pour fonctionner de façon autonome avec un simple fichier SQLite. Vous n'avez donc pas à initialiser une base de données. Par défaut, le projet sf_sandbox utilisera une base de données nommée sandbox.db située dans sf_sandbox/data/. Pour créer la structure de table à partir du fichier SQL, saisissez :

$ symfony propel-insert-sql

NOTE Ne vous inquiétez pas, il est normal qu'un avertissement apparaisse à ce moment là. La commande insert-sql efface les tables existantes avant de créer celles de votre fichier lib.model.schema.sql or il n'existe pas encore de tables à effacer.

Créer la structure de l'application

Les fonctionnalités classiques d'un blog sont de créer, récupérer, modifier et supprimer des articles et des commentaires. En anglais "Create, Retrieve, Update, Delete" donne l'acronyme CRUD. Comme vous découvrez Symfony, vous n'écrirez pas de code Symfony dans le vide, mais vous laisserez Symfony fabriquer une structure que vous pourrez ensuite utiliser et modifier comme il vous plaira. Symfony peut interpréter le modèle de données pour générer l'interface CRUD automatiquement.

> $ php symfony propel-generate-crud frontend post Post > $ php symfony propel-generate-crud frontend comment Comment > $ php symfony clear-cache > > Sur les système *nix, vous devrez modifier certains droits : > $ chmod 777 data > $ chmod 777 data/sandbox.db

Vous avez maintenant deux modules (post et comment) qui vont vous permettre de manipuler les enregistrements des tables Post et Comment. Un module représente généralement une page ou un groupe de pages ayant un même but. Les nouveaux modules sont placés dans le répertoire sf_sandbox/apps/frontend/modules/ et accessibles via les URLs :


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


N'hésiter pas à créer un nouvel article pour que le blog soit un peu moins vide.

Le CRUD

Plus d'informations sur le CRUD et la structure des projets Symfony (projet, application, module).

NOTE Dans les URLs ci-dessus, le nom du script principal (le contrôleur principal dans Symfony) a été changé de index.php à frontend_dev.php. Les deux scripts accèdent à la même application mais dans deux environnements différents . Avec frontend_dev.php, vous accédez à l'application dans l'environnement de développement qui possède des outils pratiques comme la barre d'outils de debug dans le coin supérieur droit de l'écran et l'outil de configuration rapide. C'est pourquoi la création de chaque page est plus lente que lors de l'utilisation de index.php qui est le contrôleur principal de l'environnement de production, prévu pour être plus rapide. Si vous préférez utiliser l'environnement de production, remplacez frontend_dev.php/ par index.php/ dans les URLs suivantes et n'oubliez pas de vider le cache après :

$ symfony clear-cache

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

Plus d'informations sur les environnements.

Modifier la mise en page

Afin de naviguer entre les deux modules, le blog a besoin d'une navigation globale.

Modifiez le gabarit principal sf_sandbox/apps/frontend/templates/layout.php et changez le contenu de la balise par:

[php]
<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>

Veuillez excuser la pauvreté du design et l'utilisation des styles à l'intérieur des balises, mais une heure c'est peu de temps.

First Crud Layout

Profitez-en pour changer le titre de vos pages. Editez le fichier de configuration de la vue de l'application (sf_sandbox/apps/frontend/config/view.yml), trouvez la ligne de la clef title et changez-là par ce qui suit :

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 page d'accueil elle-même a besoin d'être modifiée. Elle utilise le modèle par défaut du module default, qui est enregistré dans le framework et non dans un répertoire de votre application. Pour ce faire, vous devez créer un module main :

$ php symfony init-module frontend main

Par défaut, le fichier index affiche un message de félicitation. Pour l'enlever éditez le fichier sf_sandbox/apps/frontend/modules/main/actions/actions.class.php et supprimez-en le contenu comme suit : [php] public function executeIndex() { }

Editez aussi le fichier sf_sandbox/apps/frontend/modules/main/templates/indexSuccess.php pour personnaliser le message d'accueil :

[php]
<h1>Bienvenue sur mon weblog</h1>
<p>Vous êtes le <?php echo rand(1000,5000) ?>ème visiteur aujourd'hui.</p>

Maintenant vous devez indiquer à Symfony quelle action sera exécutée à l'appel de la page d'accueil. Pour ce faire, éditez sf_sandbox/apps/frontend/config/routing.yml et changez les règles de homepage comme suit :

[php]
homepage:
  url:   /
  param: { module: main, action: index }

Testez le résultat en ré-affichant la page d'accueil


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

First Welcom

Dès maintenant vous pouvez commencez à utiliser votre nouvelle application web : Créez un nouveau article de test et un nouveau commentaire de test à cet article.

Plus d'informations sur les vues et la mise en page.

Passer des données depuis l'action au modèle

Rapide n'est-ce pas ? Maintenant il est temps d'associer le module comment avec post afin d'afficher les commentaires sous les articles.

Tout d'abord, il faut que les commentaires associés soient mis à disposition du gabarit des articles. Dans Symfony, ce type de logique est classée dans les actions. Editez le fichier des actions sf_sandbox/apps/frontend/modules/post/actions/actions.class.php et modifiez la méthode executeShow() en y ajoutant les 4 dernières lignes :

[php]
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); 
}

Les objets Criteria et -Peer font partie de la couche ORM Propel. Ces 4 lignes exécuteront une requête SQL sur la table Comment pour récupérer les commentaires liés à l'article courant (celui désigné par le paramètre id dans l'URL). La ligne $this->comments dans l'action donnera accès à la variable $comment dans le modèle correspondant. Maintenant modifiez le gabarit d'affichage de l'article dans sf_sandbox/apps/frontend/modules/post/templates/showSuccess.php en y ajoutant à la fin :

[php]
...
<?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 ?>

Cette page utilise de nouvelles fonction PHP (format_date() et simple_format_text()) fournies par Symfony, appelées 'helpers' (NdT : Volontairement non traduits) parce qu'elles font certaines tâches à votre place qui auraient normalement exigées plus de temps et de code. Créez un nouveau commentaire à votre premier article, puis vérifiez le de nouveau, soit en cliquant sur son numéro dans la liste, soit en saisissant directement :


http://localhost/sf_sandbox/web/frontend_dev.php/post/show?id=1

Under Post

Ca avance.

Apprenez en plus sur les conventions de nommage.

Ajouter un enregistrement relatif à une autre table

En ajoutant un commentaire, vous pouvez choisir l'id de l'article relatif, mais ce n'est pas très intuitif. Par conséquent nous allons changer ça et nous assurer que l'utilisateur reviendra à l'article qu'il lisait avant d'y ajouter un commentaire.

D'abord, dans le modèle modules/post/templates/showSuccess.php, ajouter cette ligne à la fin :

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

Le helper link_to() crée un hyperlien poitant vers l'action create du module comment, vous pouvez ainsi ajouter un commentaire directement depuis la page de détails de l'article. Ensuite, ouvrez modules/comment/templates/editSuccess.php et remplacez-y les lignes suivantes :

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

Par:

[php]
<?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 ?>

Dans la page comment/create le formulaire pointe vers une action comment/update, qui redirige vers comment/show quand il est soumis (ceci est le comportement standard dans les CRUDs générés). Pour un blog, cela veut dire qu'après avoir ajouté un commentaire à un article, le détail de ce commentaire est affiché. Il serait plus logique d'afficher l'article avec ses commentaires. Ouvrez donc modules/comment/actions/actions.class.php et observez la méthode executeUpdate(). Notez que le champ created_at n'est pas défini dans l'action : Symfony sait qu'un champ nommé created_at doit être mis à jour avec la valeur de l'heure système quand un enregistrement est créé. La redirection finale de l'action doit être modifiée pour pointer vers la bonne action. Changez-la en :

[php] 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());
}

Les utilisateurs peuvent maintenant ajouter des commentaires à des articles et revenir sur cet article après coup. Vous vouliez un Blog ? Vous avez un blog

Plus d'informations sur les actions.

Le formulaire de validation

Le visiteur peut valider un commentaire sans rien y saisir et cela risque de polluer la base de données. Afin d'éviter cela, créez un fichier update.yml dans le répertoire sf_sandbox/apps/frontend/modules/comment/validate/ (créez-le si besoin est) et saisissez-y :

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

fillin:
  activate:       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.

NOTE Faites attention à ne pas copier les 4 espaces au début de chaque lignes sinon l'interpreteur YAML échouera. Le premier caractère du fihicer doit être le 'm' de 'methods'.

L'activation de fillin permet de renseigner les champs du formulaire avec les valeurs précédemment saisies au cas où la validation échouerait. L'ensemble des déclarations de la partie names précise les règles associés à chacun de ces champs du formulaire.

Par lui même, le contrôleur redirigera l'utilisateur vers le gabarit updateError.php si une erreur est détectée. Il serait mieux que la page soit réaffichée avec un message d'erreur. Pour ce faire, ajoutez une méthode handleError à la classe d'actions du fichier modules/comment/actions/actions.class.php:

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

Pour finir, editez le modèle modules/comment/templates/editSuccess.php et insérez-y au début :

[php]
<?php if ($sf_request->hasErrors()): ?>  
  <div id="errors" style="padding:10px;">
    Corrigez les erreurs suivantes et validez à nouveau :
    <ul>
    <?php foreach($sf_request->getErrors() as $error): ?>
      <li><?php echo $error ?></li>
    <?php endforeach ?>
    </ul>
  </div>
<?php endif ?>

Vous obtenez une formulaire efficace.

First form validation

Pour en apprendre plus à propos des formulaires de validations

Changer l'aspect des URL

Avez-vous noté que les URL sont interprétées ? Il est possible de les rendre plus compréhensible pour l'utilisateur mais surtout pour les moteurs de recherche. Nous allons utiliser les titres des articles comme URL pour ces articles

Les problème est alors que les titres contiennent des caractères spéciaux comme les espaces et que cela risque de polluer les URL finales avec des '%20' et autres symboles dans le genre. Vous allez donc devoir créer une nouvelle méthode dans l'objet Post afin d'obtenir des titres propres et dépouillés. Pour faire cela, éditez le fichier Post.php situé dans le répertoire sf_sandbox/lib/model/ directory et ajoutez-y la méthode suivante :

[php]
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;
}

Vous pouvez dès à présent créer une action permalink pour le module post. Ajoutez la méthode suivante au fichier modules/post/actions/actions.class.php :

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

La liste des articles peut maintenant utiliser l'action `permalinkà la place de l'actionshowpour chacun des articles. Dans le modulemodules/post/templates/listSuccess.php', supprimer l'entête id et ces cellules et modifier la cellule Title de :

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

en :

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

Une dernière chose à faire : éditez le fichier routing.yml du répertoire sf_sandbox/apps/frontend/config/ et ajoutez-y ces règles au début :

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

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

Maintenant, parcourez de nouveaux votre application et observez les URL.

First routing

Pour en savoir plus sur les Url intelligentes.

Nettoyer le frontend

S'il s'agit d'un weblog, tout le monde a le droit de poste. Ce n'est pas exactement ce à quoi vous pensiez, n'est-ce pas ? Très bien, nettoyons un peut nos gabarits.

Dans le gabarit modules/post/templates/showSuccess.php débarssez-vous du lien 'edit' en supprimant la ligne :

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

Faites de même pour le gabarit modules/post/templates/listSuccess.php et supprimer

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

Vous devez aussi supprimer les méthodes suivantes de modules/post/actions/actions.class.php :

  • executeCreate
  • executeEdit
  • executeUpdate
  • executeDelete

Voilà, les lecteurs ne peuvent plus poster.

Generation du backend

Pour que vous puissiez rédiger des articles, créons une application backend par la ligne de commande (toujours à partir du répertoire sf_sandbox du projet ) :

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

Cette fois-ci nous utiliserons le générateur d'administration qui offre plus d'options et de personnalisations que le très simple générateur CRUD.

Comme vous l'avez fait pour le frontend, éditez le gabarit principal (apps/backend/template/layout.php) et ajoutez-y la navigation globale :

[php]
<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>

Vous pouvez maintenant accéder à votre nouvelle application back-office dans l'environnement de développement en saisissant l'URL :


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

First basic admin

Le grand avantage du générateur d'administration est que vous pouvez aisément les personnaliser en éditant le fichier de configuration :

Modifiez backend/modules/post/config/generator.yml en :

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 }

Notez que parmi les colonnes existantes de la table Post, l'administration recherchera un nb_comments. Il n'y a pas encore de getter associés, mais il est simple dans ajouter dans le fichier sf_sandbox/lib/model/Post.php :

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

Maintenant rafraîchissez la page d'administration et observez les changements :

First Custom  admin

Restreindre l'accès au backend

Pour le moment, le backend est accessible à tous. Vous devez y ajouter une restriction d'accès.

Dans apps/backend/modules/post/config/, ajoutez un security.yml avec le contenu suivant :

all:
  is_secure: on

Répetez cette opération pour le module comment. Maintenant vous ne pouvez plus accéder à ces modules à moins d'être identifié.

Mais l'action d'identification n'existe pas! Très bien, vous pouvez l'ajouter simplement. Tout d'abord, créez le squelette du module de sécurité :

$ symfony init-module backend security

Ce nouveau module sera utilisé pour gérer le login et ces requêtes associées. Editez apps/backend/modules/security/templates/indexSuccess.php pour créer le formulaire de login :

[php]

Authentication

<?php if ($sf_request->hasErrors()): ?>
  L'identification a échoué - Essayez de nouveau.
<?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>

Ajoutez l'action login qui sera employée pour le module sécurité (dans le fichier apps/backend/modules/security/actions/actions.class.php) :

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

De même que pour le module main supprimer le code du fichier index comme suit :

[php]
public function executeIndex()
{
}

La dernière chose à faire est de spécifier que le module security est le module par défaut pour la prise en charge de l'authentification. Pour cela, ouvrez le fichier de configuration apps/backend/config/settings.yml et ajoutez-y :

all:
  .actions:
    login_module:           security
    login_action:           index

A partir de maintenant, si vous essayez d'accéder à l'administration des articles, vous devrez entrer un nom d'utilisateur et un mot de passe :

First Login

En savoir plus sur la sécurité.

Conclusion

C'est terminé, l'heure est écoulée. Vous avez réussi. Vous pouvez maintenant utiliser les deux applications dans l'environnement de production et jouer avec:

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

A ce stade, si vous rencontrez une erreur, il est fort possible que ce soit parce que vous avez changé le modèle après que certaines actions aient été mises en cache (le cache n'est pas activé dans l'environnement de développement). Pour vider le cache, saisissez :

$ symfony cc

Et voilà, l'application fonctionne maintenant rapidement. Génial n'est ce pas ? Sentez-vous libre d'explorer le code, d'ajouter de nouveaux modules et de changer le design des pages.

Et n'oubliez pas de mentionner votre application symfony sur le wiki!