Retour sur le plugin Commentaires, partie administration

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 :

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 :

generator:
  config:
    list:
      table_method: retrieveBackendCommentList

La méthode en question :
plugins/sfLexikDoctrineActAsCommentablePlugin/lib/model/doctrine/PluginCommentTable.class.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 :

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 :

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 :

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

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

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

apps/backend/modules/message/template/_handle_comments.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

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

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

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 :

  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 :

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

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

Partagez cet article