Blog Symfony - Lexik Montpellier » plugin

Blog Symfony - Lexik Montpellier » plugin http://www.lexik.fr/blog/symfony Blog sur le développement Web PHP Tue, 20 Jul 2010 08:35:36 +0000 en hourly 1 http://wordpress.org/?v=3.0 Retour sur le plugin Commentaires, partie administration http://www.lexik.fr/blog/symfony/non-classe/retour-sur-le-plugin-commentaires-partie-administration-1087 http://www.lexik.fr/blog/symfony/non-classe/retour-sur-le-plugin-commentaires-partie-administration-1087#comments Wed, 31 Mar 2010 08:39:13 +0000 Nikaw http://www.lexik.fr/blog/symfony/?p=1087 J’espère que vous vous souvenez du post concernant le plugin / behavior sfLexikDoctrineActAsCommentablePlugin.
Je vous avais promis une deuxième partie sur l’administration des commentaires, et bien après quelques mois d’absence me revoilà pour tenir ma promesse.

Tout d’abord un peu de configuration, puis nous verront quelles sont l’utilité et la problématique principales de cette partie.
Nous verrons l’administration des commentaires dans leur ensemble, puis la gestion des commentaires depuis l’objet porteur.

Configuration
Tout d’abord il ne faut pas oublier de charger le module dans les settings.
apps/backend/config/settings.yml :

^?View Code YAML

all:
  .settings:
    enabled_modules: [..., comment]

Problématique

On veut ici pouvoir gérer facilement et rapidement les commentaires déposés par les utilisateurs.
Une des problématiques sera donc la façon de lister les commentaires sur l’index.
J’ai choisi par défaut de regrouper les commentaires par type d’objet, puis par objet, puis par date de modification.

Exemple : je liste tous les commentaires déposé sur les objets Message, je les regroupe par message, et je les classe par date de modification (la plupart du temps, un commentaire ne pouvant être modifié, on aura une concordance entre la date d’ajout et la date de modification).

Pour ceci, je spécifie dans le fichier de génération la méthode utilisée pour récupérer les commentaires :
plugins/sfLexikDoctrineActAsCommentablePlugin/module/comment/config/generator.yml :

^?View Code YAML

generator:
  config:
    list:
      table_method: retrieveBackendCommentList

La méthode en question :
plugins/sfLexikDoctrineActAsCommentablePlugin/lib/model/doctrine/PluginCommentTable.class.php :

^?View Code PHP

  public function retrieveBackendCommentList()
  {
    $query = $this->createQuery('c')
            ->orderBy('c.parent_class_name ASC')
            ->addOrderBy('c.parent_id ASC')
            ->addOrderBy('c.updated_at DESC');
 
    return $query;
  }

Nous allons maintenant nous pencher sur les différents traitements que je propose.
Il s’agit ici de publier / censurer, marquer comme spam / non spam, nettoyer les spams, et bien sûr supprimer des commentaires.

Tout d’abord je vous donne la configuration que j’ai choisie pour l’index, évidemment vous pouvez choisir de la changer, elle représente mes préférences rapportées au projet pour lequel j’ai créé ce plugin.
plugins/sfLexikDoctrineActAsCommentablePlugin/module/comment/config/generator.yml :

^?View Code YAML

generator:
  class: sfDoctrineGenerator
  param:
    model_class:           Comment
    theme:                 admin
    non_verbose_templates: true
    with_show:             false
    singular:              ~
    plural:                ~
    route_prefix:          comment
    with_doctrine_route:     1
 
    config:
      actions: ~
      fields:
      list:
        table_method: retrieveBackendCommentList
        display: [author_name, author_mail, text, is_published, is_spam]
        fields:
          author_name: {label: 'Nom auteur'}
        actions:
          _delete: ~
          CleanSpam: {label: 'Nettoyer les spams'}
        object_actions:
          Publish: {label: 'Publier'}
          UnPublish: {label: 'Censurer'}
          MakeSpam: {label: 'Spam !'}
          UnmakeSpam: {label: 'Pas spam'}
          _delete: ~
        batch_actions:
          _delete: ~
          Publish: {label: 'Publier'}
          UnPublish: {label: 'Censurer'}
          MakeSpam: {label: 'Marquer comme spams'}
          UnmakeSpam: {label: 'Retirer des spams'}
      filter: ~
      form: ~
      edit: ~
      new:     ~

Laissez moi maintenant vous décrire rapidement chaque méthode :
Publish: {label: ‘Publier’}
permet d’afficher un commentaire

UnPublish: {label: ‘Censurer’}
permet de censurer un commentaire, c’est à dire de bloquer sa publication

MakeSpam: {label: ‘Spam !’}
permet de marquer un commentaire en tant que spam

UnmakeSpam: {label: ‘Pas spam’}
permet de marquer un commentaire en tant que non spam

Ces méthodes dans la « list » s’appliquent sur un seul commentaire, et dans le « batch » sur un groupe de commentaires sélectionnés.

La méthode CleanSpam: {label: ‘Nettoyer les spams’} quant à elle permet de supprimer d’un coup tous les commentaires notifiés comme étant des spams.

Voici le code des méthodes ci-dessus :
plugins/sfLexikDoctrineActAsCommentablePlugin/modules/comment/actions/actions.class.php :

^?View Code PHP

public function executeListCleanSpam(sfWebRequest $request)
  {
    $nb = Doctrine::getTable('Comment')->cleanSpam();
 
    if ($nb)
    {
      $this->getUser()->setFlash('notice', sprintf('%d spam'.($nb > 1 ? 's' : '').' supprimé'.($nb > 1 ? 's' : ''), $nb));
    }
    else
    {
      $this->getUser()->setFlash('notice', 'Pas de spams.');
    }
 
    $this->redirect('@comment');
  }
 
  public function executeListPublish(sfWebRequest $request)
  {
    $page = $request->getParameter('page', 1);
 
    $this->comment = $this->getRoute()->getObject();
    $this->comment->setIsPublished(true);
    $this->comment->save();
 
    $this->redirect('@comment?page='.$page);
  }
 
  public function executeListUnPublish(sfWebRequest $request)
  {
    $page = $request->getParameter('page', 1);
 
    $this->comment = $this->getRoute()->getObject();
    $this->comment->setIsPublished(false);
    $this->comment->save();
 
    $this->redirect('@comment?page='.$page);
  }
 
  public function executeListMakeSpam(sfWebRequest $request)
  {
    $page = $request->getParameter('page', 1);
 
    $this->comment = $this->getRoute()->getObject();
    $this->comment->setIsSpam(true);
    $this->comment->save();
 
    $this->redirect('@comment?page='.$page);
  }
 
  public function executeListUnmakeSpam(sfWebRequest $request)
  {
    $page = $request->getParameter('page', 1);
 
    $this->comment = $this->getRoute()->getObject();
    $this->comment->setIsSpam(false);
    $this->comment->save();
 
    $this->redirect('@comment?page='.$page);
  }
 
  public function executeBatchPublish(sfWebRequest $request)
  {
    $page = $request->getParameter('page', 1);
 
    $ids = $request->getParameter('ids');
    foreach($ids as $id)
    {
      $this->comment = Doctrine::getTable('Comment')->find($id);
      $this->comment->setIsPublished(true);
      $this->comment->save();
    }
 
    $this->redirect('@comment?page='.$page);
  }
 
  public function executeBatchUnPublish(sfWebRequest $request)
  {
    $page = $request->getParameter('page', 1);
 
    $ids = $request->getParameter('ids');
    foreach($ids as $id)
    {
      $this->comment = Doctrine::getTable('Comment')->find($id);
      $this->comment->setIsPublished(false);
      $this->comment->save();
    }
 
    $this->redirect('@comment?page='.$page);
  }
 
  public function executeBatchMakeSpam(sfWebRequest $request)
  {
    $page = $request->getParameter('page', 1);
 
    $ids = $request->getParameter('ids');
    foreach($ids as $id)
    {
      $this->comment = Doctrine::getTable('Comment')->find($id);
      $this->comment->setIsSpam(true);
      $this->comment->save();
    }
 
    $this->redirect('@comment?page='.$page);
  }
 
  public function executeBatchUnmakeSpam(sfWebRequest $request)
  {
    $page = $request->getParameter('page', 1);
 
    $ids = $request->getParameter('ids');
    foreach($ids as $id)
    {
      $this->comment = Doctrine::getTable('Comment')->find($id);
      $this->comment->setIsSpam(false);
      $this->comment->save();
    }
 
    $this->redirect('@comment?page='.$page);
  }

et la méthode cleanSpam() dans le modèle :
plugins/sfLexikDoctrineActAsCommentablePlugin/lib/model/doctrine/PluginCommentTable.class.php :

^?View Code PHP

  /**
   * supprime tous les commentaires classifiés comme spam et retourne le nombre d'enregistrements supprimés
   *
   * @return int
   */
  public function cleanSpam()
  {
    $q = $this->createQuery('c')->delete()->where('c.is_spam = ?', true);
 
    return $q->execute();
  }

Je n’ai pas touché au filtre, mais chacun peut décider que tel ou tel champ sera utile ou pas, ça dépendra très souvent du projet.

Donc voilà pour la première étape. Jusque là on peut afficher et traiter les commentaires un par un ou par lots, directement depuis leur index.

Voyons maintenant comment ajouter la gestion des commentaires depuis les objets porteurs.
Attention, cette partie est une nouveauté par rapport au premier post, voici les nouvelles sources : plugin.

Tout d’abord il faut ajouter dans l’édition de l’objet porteur le partial qui permettra de gérer les commentaires.
Pour éviter de devoir dupliquer le même template pour chaque type d’objet, on va créer un partial dans le module comment du plugin puis l’appeler dans le partial de l’objet porteur :
/home/lexik/sfprojects/kelsms/plugins/sfLexikDoctrineActAsCommentablePlugin/modules/comment/templates/_backend_comments_list.php :

^?View Code PHP

<div class="container_16">
  Commentaires :
<ul class="order">
    $comment): ?>
	<li id="<?php echo $comment->getId() ?>" class="row_<?php echo $key%2 ?>">
<div id="show_<?php echo $comment->getId() ?>" class="grid_10">
          $comment)) ?></div>
<div class="grid_4">
          $comment)) ?></div></li>
</ul>
</div>
<script type="text/javascript"><!--mce:0--></script>

Il sera appelé de la manière suivant dans le partial de notre objet, par exemple ici un Message, grâce à la configuration du generator.yml :

^?View Code YAML

generator:
  config:
      edit:
        display: [..., _handle_comments]

apps/backend/modules/message/template/_handle_comments.php :

^?View Code PHP

$form->getObject()->findComments())) ?>

Bref.
Dans le partial _backend_comments_list.php on remarque 3 choses :
1) l’appel du partial backend_show
2) l’appel du partial backend_comment_actions
3) les fonctions javascript

1) le partial backend_show affiche tout simplement le contenu du commentaire :
_backend_show.php

^?View Code PHP

<div class="show_comment_class">
<div class="infos_class">
    <span class="author_name_class">
      getAuthorName() ?>
    </span>
 
    <span class="time_and_date_class">
      - le <span class="date_class">getCreatedAt(), 'd/MM/yyyy', 'fr') ?></span>
      à <span class="time_class">getCreatedAt(), 'hh:mm', 'fr') ?></span>
    </span></div>
<hr />
<div class="text_class">
    getText() ?></div>
</div>

2) le partial _backend_comment_actions.php contient les actions pouvant être effectuées sur un commentaire :

^?View Code PHP

<a onclick="publishComment(<?php echo $comment->getId()?>)" href="#">publier</a> |
<a onclick="unPublishComment(<?php echo $comment->getId()?>)" href="#">censurer</a> |
<a onclick="makeSpamComment(<?php echo $comment->getId()?>)" href="#">spam</a> |
<a onclick="unMakeSpamComment(<?php echo $comment->getId()?>)" href="#">pas spam</a> |
<a onclick="deleteComment(<?php echo $comment->getId()?>)" href="#">supprimer</a> |
<a href="<?php echo url_for('@comment_edit?id='.$comment->getId()) ?>">editer</a>

3) les fonctions javascript : elles permettent d’appeler respectivement les méthodes permettant d’effectuer les actions correspondante, tout ça en AJAX.

Ces différentes actions vont effectuer le même travail que les ListAction, à la différence près qu’elle sont appelée en Ajax, et n’ont donc pas le même template de retour.

Voilà d’abord le routing, puis les actions :

^?View Code YAML

comment_ajax_publish:
  url:   /comment_ajax_publish
  params: {module: comment, action: ajaxPublish}
comment_ajax_unpublish:
  url:   /comment_ajax_unpublish
  params: {module: comment, action: ajaxUnPublish}
comment_ajax_makespam:
  url:   /comment_ajax_markspam
  params: {module: comment, action: ajaxMakeSpam}
comment_ajax_unmakespam:
  url:   /comment_ajax_unmarkspam
  params: {module: comment, action: ajaxUnMakeSpam}
comment_ajax_delete:
  url:   /comment_ajax_delete
  params: {module: comment, action: ajaxDelete}

actions :

^?View Code PHP

  public function executeAjaxPublish(sfWebRequest $request)
  {
    $this->comment = Doctrine::getTable('Comment')->find($request->getParameter('id'));
    $this->forward404Unless($this->comment);
    $this->publish($this->comment);
 
    $this->setTemplate('ajaxAction');
  }
 
  public function executeAjaxUnPublish(sfWebRequest $request)
  {
    $this->comment = Doctrine::getTable('Comment')->find($request->getParameter('id'));
    $this->forward404Unless($this->comment);
    $this->unpublish($this->comment);
 
    $this->setTemplate('ajaxAction');
  }
 
  public function executeAjaxMakeSpam(sfWebRequest $request)
  {
    $this->comment = Doctrine::getTable('Comment')->find($request->getParameter('id'));
    $this->forward404Unless($this->comment);
    $this->makespam($this->comment);
 
    $this->setTemplate('ajaxAction');
  }
 
  public function executeAjaxUnMakeSpam(sfWebRequest $request)
  {
    $this->comment = Doctrine::getTable('Comment')->find($request->getParameter('id'));
    $this->forward404Unless($this->comment);
    $this->unmakespam($this->comment);
 
    $this->setTemplate('ajaxAction');
  }
 
  public function executeAjaxDelete(sfWebRequest $request)
  {
    $this->comment = Doctrine::getTable('Comment')->find($request->getParameter('id'));
    $this->forward404Unless($this->comment);
 
    $this->comment->delete();
  }
 
  protected function publish($comment)
  {
    $comment->setIsPublished(true);
    $comment->save();
  }
  protected function unpublish($comment)
  {
    $comment->setIsPublished(false);
    $comment->save();
  }
  protected function makespam($comment)
  {
    $comment->setIsSpam(true);
    $comment->save();
  }
  protected function unmakespam($comment)
  {
    $comment->setIsSpam(false);
    $comment->save();
  }

On remarque une certaine redondance de code dans le actions.class.php,c’est pour ça que j’ai factorisé. Pensez à corriger les autres actions (elles sont ok si vous récupérez les sources).

Et pour finir, dans les templates correspondant à ces actions, on reload la ligne du commentaire en cours, ce qui permettra de mette à jour ses état de publication et spam dans la liste des commentaires.

ajaxActionSuccess.php :

^?View Code PHP

include_partial('comment/backend_show', array('comment'=>$comment))

Voilà, si vous avez des questions ou des incompréhensions, n’hésitez pas !

]]> http://www.lexik.fr/blog/symfony/non-classe/retour-sur-le-plugin-commentaires-partie-administration-1087/feed 3 sfLexikDoctrineActAsCommentablePlugin ou comment rendre des objets commentables via un behavior / plugin http://www.lexik.fr/blog/symfony/symfony/sflexikdoctrineactascommentableplugin-ou-comment-rendre-des-objets-commentables-via-un-behavior-plugin-1002 http://www.lexik.fr/blog/symfony/symfony/sflexikdoctrineactascommentableplugin-ou-comment-rendre-des-objets-commentables-via-un-behavior-plugin-1002#comments Mon, 09 Nov 2009 10:39:52 +0000 Nikaw http://www.lexik.fr/blog/symfony/?p=1002 Aujourd’hui je vais vous montrer comment rendre des objets commentables grâce à un behavior Doctrine que j’ai créé, et le plugin qui permet de l’exploiter.

Le behavior donne les fonctionnalités, le plugin donne le modèle et l’affichage ainsi que les actions (listing des commentaires, formulaire d’ajout de commentaire, …)

Je me suis basé sur le behavior Doctrine Taggable fourni à l’origine pour réaliser ceci.

Le behavior et le plugin ne sont pas utilisable l’un sans l’autre.

télécharger les sources

Fourni par le behavior :

Le listener :

void postDelete(event) //supprime tous les commentaires liés lors de la suppression de l’objet les portant

Le template et ses méthodes :

void addComment(Comment) //ajoute le commentaire à l’objet

void deleteComments() //supprime tous les commentaires reliés à l’objet

Doctrine_Collection findComments(array $params, array $orders) //retourne tous les commentaires liés à l’objet, respectant les paramètres du tableau params, et classés successivement dans les ordres donnés par le tableau orders

int getNbComments() //retourne le nombre de commentaires liés à l’objet

CommentForm getCommentForm()

Fourni par le plugin :

La classe Comment :

getParent() pour récupérer l’objet porteur du commentaire

La classe CommentTable :

getCommentsFilteredQuery($params, $orders) pour récupérer une requête permettant de retrouver une collection de commentaires selon certains paramètres, et en respectant une suite d’ordres

getUnmoderatedCommentsQuery() pour récupérer une requête permettant de retrouver la collection des commentaires non modérés

getSpamCommentsQuery() pour récupérer la collection des commentaires classés spam
Le modèle de données :

^?View Code YAML

Comment:
  tableName: sf_comment
 
  actAs: [Timestampable]
 
  columns:
    user_id:
      type: integer(4)
 
    #nom de l'auteur
    author_name:
      type: string(255)
      default: Anonyme
    #email de l'auter
    author_mail:
      type: string(255)
    #site web de l'auteur
    author_website:
      type: string(255)
 
    #texte du commentaire
    text:
      type: clob
 
    #id de l'objet porteur du commentaire
    parent_id:
      type: integer
    #classe de l'objet porteur du commentaire
    parent_class_name:
      type: string(255)
 
    #publié ?
    is_published:
      type: boolean
      notnull: true
      default: true
    #modéré ?
    is_moderated:
      type: boolean
      notnull: true
      default: false
    #est un spam ?
    is_spam:
      type: boolean
      notnull: true
      default: false
 
  relations:
    sfGuardUser:
      type: one
      foreignType: many
      local: user_id
      foreign: id
      foreignAlias: Comments

La technique pour relier un objet à cette table Comment est d’utiliser 2 champs spéciaux : parent_class_name et parent_id qui contiennent le nom de la classe ainsi que l’identifiant en base de l’objet porteur du commentaire.

De cette manière, on perd en partie l’aspect relationnel de la base, mais on allège énormément les requêtes de listing (derniers commentaires toutes catégories confondues, commentaires reliés à un objet, reliés à un type d’objet, …).
Comment ça marche :

télécharger les sources
Avant de commencer, il faut évidemment copié les sources du plugin dans le répertoire plugin/ de votre projet, puis :

php symfony plugin:publish-assets

Tout d’abord, il faut activer le module dans les settings, en l’ajoutant comme ceci :

^?View Code YAML

all:
  .settings:
    enabled_modules: [default, sfGuardAuth, sfGuardUser, comment]

Ensuite dans le schema.yml du projet, il faut spécifier le behavior sur l’objet :

^?View Code YAML

Message:
  actAs:
    Timestampable: ~
    Commentable: ~
  columns:
    …

A partir de là, on utilisera les fonctions et méthodes vues plus haut (fournies par le template).

Le plugin fournit des partials pour l’affichage par défaut, personnalisable via les noms de classes et id passables en paramètres (toutes les classes et id sont définies par défaut si pas d’options) :

Partial show_comment, paramètres :
$comment : le message à afficher
$options : les options spécifiques pour css personnalisé
show_comment_class → conteneur global
infos_class → entete (auteur, date et heure)
author_name_class → auteur
time_and_date_class → date et heure
date_class → date
time_class → heure
text_class → corps du commentaire

Partial comments_list, paramètres : (boucle sur le partial show_comment, donc passer en parametre les options pour le show_comment)
$comments : la liste des messages à afficher
$options : les options spécifiques pour css personnalisé
list_comment_class : classe de la div conteneur
list_comment_id : id de la div conteneur

Partial form_comment, paramètres :
$form : le formulaire
$action : l’action du formulaire, définie par défaut
$options : les options spécifiques pour css personnalisé
id → id du formulaire
class → classe du formulaire

Partial ajax_script, paramètres : script jquery permettant de valider le formulaire en ajax
$form : le formulaire

Partial ajax_form_comment, paramètres : le formulaire et le script ajax

Exemple d’utilisation :

^?View Code PHP

  <!-- // liste des commentaires du message -->
  <?php include_partial('comment/comments_list', array('comments'=>$message->findComments(array(), array('created_at DESC')), 'options'=>array())) ?>
 
  <!-- // formulaire d'ajout de commentaire -->
  <div id="form<?php echo $message->getId() ?>">
    <h2>Postez votre commentaire :</h2>
    <?php include_partial('comment/ajax_form_comment', array('form'=>$message->getCommentForm())) ?>
  </div>

Vous aurez noté qu’on ne parle pas encore de l’administration dans ce post, dans les publications à venir je vous parlerai d’abord du backend pour les commentaires, puis de la réalisation d’un behavior étape par étape.

]]> http://www.lexik.fr/blog/symfony/symfony/sflexikdoctrineactascommentableplugin-ou-comment-rendre-des-objets-commentables-via-un-behavior-plugin-1002/feed 4 Utilisation de sfDoctrineGuardPlugin pour la gestion des utilisateurs http://www.lexik.fr/blog/symfony/symfony/utilisation-de-sfdoctrineguardplugin-pour-la-gestion-des-utilisateurs-634 http://www.lexik.fr/blog/symfony/symfony/utilisation-de-sfdoctrineguardplugin-pour-la-gestion-des-utilisateurs-634#comments Wed, 27 May 2009 12:01:50 +0000 olivier http://www.lexik.fr/sfblog/?p=634 sfDoctrineGuardPlugin comme son nom l’indique est la version Doctrine de sfGuardPlugin qui est THE plugin de gestion des utilisateurs de Symfony.

Il comporte des formulaires d’identification et d’inscription très basique, mais son principal point fort est la gestion des droits associés aux utilisateurs, la possibilité de gérer des groupes le tout générant automatiquement les crédentials qui va permettre de sécuriser l’application de manière très simple.

Je ne reviendrai pas sur la gestion des crédentials qui est très bien expliquée dans le Jobeet #13.

De même pour l’installation. Le readme est très bien fait et explique très clairement comment faire.

Le modèle de données

Le modèle de données du plugin comporte la table des Utilisateurs, des Groupes et des Permissions ainsi que les tables d’associations entre Utilisateurs/Permissions, Groupes/Permissions et Utilsateurs/Groupes.

Ce sont les permissions attribuées à un utilisateur (directement ou par ses groupes) qui déterminent les crédentials qu’il aura une fois logué (C’est le nom de la permission qui sera le nom du crédential).

Pour illustrer tout ca, on va voir un petit exemple.

On prends une structure simple, avec 2 groupes et 3 permissions.
Les permissions de Lecture, Ecriture et Téléchargement (même si la loi Hadopie a été votée ^^).
Les groupes Admin qui a tous les droits et Membre qui n’a que le droit de lecture.

^?View Code YML

 
sfGuardPermission:
  pLecture:
    name: lecture
  pEcriture:
    name: ecriture
  pTelegargement:
    name: telechargement
 
sfGuardGroup:
  gAdmin:
    name: admin
  gMembre:
    name: membre
 
sfGuardGroupPermission:
  gp1:
    sfGuardGroup:      gAdmin
    sfGuardPermission: pLecture
  gp2:
    sfGuardGroup:      gAdmin
    sfGuardPermission: pEcriture
  gp3:
    sfGuardGroup:      gAdmin
    sfGuardPermission: pTelegargement
  gp4:
    sfGuardGroup:      gMembre
    sfGuardPermission: pLecture

Et 3 utilisateurs : Toto, Titi et Tata à qui on va définir des droits différents.

- Toto sera dans le groupe admin, il aura ainsi tout les droits.
- Titi et Tata seront dans le groupe Membre et auront ainsi seulement le droit de Lecture.
- Titi a en plus le droit de téléchargement.

Ce qui se traduit en fixture comme ceci :

^?View Code YML

 
sfGuardUser:
  Toto:
    username: toto
    password: t0t0
  Titi:
    username: titi
    password: t1t1
  Tata:
    username: tata
    password: t4t4
 
sfGuardUserGroup:
  ug1:
    sfGuardUser:  Toto
    sfGuardGroup: gAdmin
  ug2:
    sfGuardUser:  Titi
    sfGuardGroup: gMembre
  ug3:
    sfGuardUser:  Tata
    sfGuardGroup: gMembre
 
sfGuardUserPermission:
  up1:
    sfGuardUser:       Titi
    sfGuardPermission: pTelegargement

Dans un module lambda, on peut donc très facilement sécuriser nos pages comme suit.

/module/config/security.yml

^?View Code YML

secure:
  is_secure:   on
 
telechargement:
  is_secure:   on
  credentials: [lecture, telechargement]
 
default:
  is_secure:   off

La page secure nécessite que l’utilisateur soit connecté mais il n’y a aucune restriction de crédential. Les 3 utilisateur, une fois logés, pourront y accéder.

La page téléchargement nécessite 2 permissions lecture et téléchargement. Seuls Toto et Titi y auront accès. Tata sera redirigé automatiquement vers la page d’erreur de permissions.

La redirection après l’authentification.

L’authentification est gérée par le plugin, il suffit d’envoyer l’utilisateur vers la route @sf_guard_signin.

Une fois l’authentification effectuée, le script redirige l’utilisateur. Par défaut l’utilisateur est redirigé vers le HTTP_REFERER.

Heureusement on peut aussi déterminer une route vers laquelle on veut être redirigé après l’authentification de plusieurs manières.

Premièrement via des variable du app.yml

^?View Code YML

all:
  sf_guard_plugin:
    success_signin_url:      @my_route?param=value
    success_signout_url:     module/action

Autre méthode qui consiste à utiliser le comportement par défaut de redirection vers le referer, mais en utilisant la méthode setReferer() de la classe sfGuardSecurityUser.

^?View Code PHP

<?php
class moduleActions extends sfActions
{
  ...
  public function executeAction(sfWebRequest $request)
  {
    ...
    $this->getUser()->setReferer('@my_route');
    $this->redirect('@sf_guard_signin');
  }
}

L’ordre de priorité est :
- la variable du fichier app.yml
- le getReferer() du GuardUser
- le HTTP_REFERER

Connecter automatiquement un utilisateur

Il est possible de connecter automatiquement un utilisateur grâce à la méthode signin() à la quelle on doit passer une instance de sfGuardUser.

Par exemple dans une action quelconque :

^?View Code PHP

<?php
class moduleActions extends sfActions
{
  ...
  public function executeAction(sfWebRequest $request)
  {
    ...
    $utilisateur = Doctrine::getTable('sfGuardUser')->findOneByUsername('toto');
    $this->getUser()->signin($utilisateur);
    ...
  }
}

Associer un ou plusieurs groupes à un utilisateur

On a vu au début de l’article comment associer des groupes aux utilisateurs par le fixture.

On va voir ici comment le faire en php.

Par exemple si on avait à le faire dans le script d’inscription et qu’on veulait associer automatiquement le groupe membre aux utilisateurs qui s’inscrivent.

^?View Code PHP

 
public function executeInscription(sfWebRequest $request)
{
  $this->form = new sfGuardUserFormRegister();
  // la classe de formulaire sfGuardUserFormRegister n'existe pas dans le plugin par defaut
  // je la mets en annexe à la fin de l'article
 
  if($request->isMethod('post'))
  {
    $this->form->bind($request->getParameter($this->form->getName()));
 
    if($this->form->isValid())
    {
      $permission = Doctrine::getTable('sfGuardGroup')->findOneByName('membre');
 
      $utilisateur = $this->form->getObject();
      $utilisateur['permissions'][] = $permission;
      $utilisateur->save();
 
      $this->getUser()->signIn($utilisateur);
      $this->redirect('@homepage');
    }
  }
}

Annexe

^?View Code PHP

 
/**
 * formulaire d'inscription
 *
 * @package    form
 * @subpackage sfGuardUser
 * @author     Lexik
 * @version    SVN: $Id: sfDoctrineFormTemplate.php 6174 2007-11-27 06:22:40Z fabien $
 */
class sfGuardUserFormRegister extends PluginsfGuardUserForm
{
 
  public function configure()
  {
    unset(
      $this['groups_list'],
      $this['permissions_list'],
      $this['algorithm'],
      $this['salt'],
      $this['is_active'],
      $this['is_super_admin'],
      $this['last_login'],
      $this['created_at'],
      $this['updated_at']
    );
 
    $this->widgetSchema['password']     = new sfWidgetFormInputPassword();
    $this->widgetSchema['password_bis'] = new sfWidgetFormInputPassword();
 
    $this->widgetSchema->setLabels(array(
      'username'     => 'Email* :',
      'password'     => 'Mot de passe* :',
      'password_bis' => 'Confirmation* :'
    ));
 
    $this->validatorSchema['username']     = new sfValidatorEmail(array('required' => true), array('invalid' => 'Cet email n\'est pas valide.', 'required' => 'Champ obligatoire.'));
    $this->validatorSchema['password']     = new sfValidatorString(array('required' => true, 'min_length' => 6), array('min_length' => '"%value%" est trop court (%min_length% lettres minimum).', 'required' => 'Champ obligatoire.'));
    $this->validatorSchema['password_bis'] = new sfValidatorString(array('required' => true, 'min_length' => 6), array('min_length' => '"%value%" est trop court (%min_length% lettres minimum).', 'required' => 'Champ obligatoire.'));
 
    $this->mergePostValidator(new sfValidatorSchemaCompare(
      'password',
      sfValidatorSchemaCompare::EQUAL,
      'password_bis',
      array(),
      array('invalid' => 'Les champs doivent être identiques.')
    ));
  }
 
}

]]> http://www.lexik.fr/blog/symfony/symfony/utilisation-de-sfdoctrineguardplugin-pour-la-gestion-des-utilisateurs-634/feed 4 TinyMCE dans l’admin generator (Symfony 1.2, Doctrine) http://www.lexik.fr/blog/symfony/symfony/sfformextraplugin-tinymce-197 http://www.lexik.fr/blog/symfony/symfony/sfformextraplugin-tinymce-197#comments Wed, 04 Mar 2009 22:58:26 +0000 Samuel Breton http://www.lexik.fr/sfblog/?p=197 Comment mettre en place un « Rich Text Editor » dans un backend Symfony 1.2 doctrine ?
J’ai trouvé la solution dans un post du forum symfony, je vous donne la version originale :

http://forum.symfony-project.org/index.php/m/66906/?srch=tinymce+3+steps#msg_66906

En français et expliqué plus en détails, ça donne :

Intégrer Tiny MCE

Télécharger et copier :
http://tinymce.moxiecode.com/download.php
dans :

/web/js/tinyMCE
Modifier ce fichier :

/apps/backend/config/settings.yml

^?View Code YML
all: .settings: sf_rich_text_js_dir: js/tinyMCE

Installer le plugin sfFormExtraPlugin:

symfony plugin:install sfFormExtraPlugin

Modifier le widget sfWidgetFormTextareaTinyMCE.class.php

Il faut modifier le plugin !

/plugins/sfFormExtraPlugin/lib/widget/sfWidgetFormTextareaTinyMCE.class.php

Fichier :

^?View Code PHP

<?php
class sfWidgetFormTextareaTinyMCE extends sfWidgetFormTextarea
{
  protected function configure($options = array(), $attributes = array())
  {
    $this->addOption('theme', 'advanced');
    $this->addOption('width');
    $this->addOption('height');
    $this->addOption('config', '');
  }
  public function render($name, $value = null, $attributes = array(), $errors = array())
  {
    $attributes = array_merge($this->attributes, $attributes); 
    ...

Utilisation

Modifier ce fichier :

/lib/form/doctrine/ContenuForm.class.php

^?View Code PHP

<?php
class ContenuForm extends BaseContenuForm
{
  public function configure()
  {
      $this->widgetSchema['texte'] =  new sfWidgetFormTextareaTinyMCE(
      array(
        'width'=>550,
        'height'=>350,
        'config'=>'theme_advanced_disable: "anchor,image,cleanup,help"',
        'theme'   =>  sfConfig::get('app_tinymce_theme','advanced'),
      ),
      array(
        'class'   =>  'tiny_mce'
      )
    );
    $js_path = sfConfig::get('sf_rich_text_js_dir') ? '/'.sfConfig::get('sf_rich_text_js_dir').'/tiny_mce.js' : '/sf/tinymce/js/tiny_mce.js';
    sfContext::getInstance()->getResponse()->addJavascript($js_path);
  }
}

Sources:

http://forum.symfony-project.org/index.php/m/66906/?srch=tinymce+3+steps#msg_66906

http://tinymce.moxiecode.com/download.php

]]> http://www.lexik.fr/blog/symfony/symfony/sfformextraplugin-tinymce-197/feed 10