Evolution #176: Modération commentaire

app/Resources/translations/adminui.fr.yml

     title:          Elements
     action:
       delete:       Supprimer
-      clean:         Tout est ok
+      clean:         Tout est ok
+  comments:
+    title:          Commentaires
+    to_moderate:    %count% éléments concernés

src/Muzich/AdminBundle/Controller/ModerateController.php

 use Muzich\CoreBundle\Entity\GroupsTagsFavorites;
 use Muzich\CoreBundle\Managers\TagManager;
 use Muzich\CoreBundle\Propagator\EventElement;
+use Muzich\CoreBundle\Managers\CommentsManager;
 
 class ModerateController extends Controller
 {
       ->countToModerate();
     $count_elements = $this->getDoctrine()->getRepository('MuzichCoreBundle:Element')
       ->countToModerate();
+    $count_comments = $this->getDoctrine()->getRepository('MuzichCoreBundle:Element')
+      ->countForCommentToModerate();
     
     return array(
       'count_tags' => $count_tags,
-      'count_elements' => $count_elements
+      'count_elements' => $count_elements,
+      'count_comments' => $count_comments
     );
   }
     
     ));
   }
   
+  /**
+   *
+   * @Template()
+   */
+  public function commentsAction()
+  {
+    // Récupération des elements
+    $elements = $this->getDoctrine()->getRepository('MuzichCoreBundle:Element')
+      ->getForCommentToModerate();
+    
+    $comments = array();
+    foreach ($elements as $element)
+    {
+      $cm = new CommentsManager($element->getComments());
+      foreach ($cm->getAlertedComments() as $comment)
+      {
+        $comments[] = array(
+          'element_id' => $element->getId(),
+          'comment'    => $comment
+        );
+      }
+      
+    }
+    
+    return array(
+      'comments' => $comments
+    );
+  }
+  
+  /**
+   * Considérer le commentaire signalé comme étant tout a fait acceptable
+   * 
+   * Ceci induit:
+   * * Que le commentaire en question ne soit plus signalé 
+   * * Que le ou les ids d'utilisateurs qui l'ont signalé comme soit "pénalisé
+   * 
+   * @param int $element_id
+   * @param date $date 
+   * 
+   * @return Response
+   */
+  public function commentCleanAction($element_id, $date)
+  {
+    if (($response = $this->mustBeConnected(true)))
+    {
+      return $response;
+    }
+    
+    if (!($element = $this->getDoctrine()->getRepository('MuzichCoreBundle:Element')
+      ->findOneById($element_id))
+    )
+    {
+      return $this->jsonResponse(array(
+        'status' => 'error',
+        'errors' => array('NotFound')
+      ));
+    }
+    
+    $cm = new CommentsManager($element->getComments());
+    // On nettoie le commentaire et on récupère les ids des "signaleurs"
+    $ids = $cm->cleanAlertsOnComment($date);
+    $element->setComments($cm->get());
+    $element->setCountCommentReport($cm->countCommentAlert());
+    
+    $this->getDoctrine()->getEntityManager()->persist($element);
+    
+    // On récupère les user qui ont signalés ce commentaire
+    $users = $this->getDoctrine()->getEntityManager()
+      ->createQuery('
+        SELECT u FROM MuzichCoreBundle:User u
+        WHERE u.id IN (:uids)'
+      )
+      ->setParameter('uids', $ids)
+      ->getResult()
+    ;
+    
+    // Pour chacun on augmente le compteur de signalements inutiles
+    foreach ($users as $user)
+    {
+      $user->addBadReport();
+      $this->getDoctrine()->getEntityManager()->persist($user);
+    }
+    
+    $this->getDoctrine()->getEntityManager()->flush();
+    
+    return $this->jsonResponse(array(
+      'status' => 'success'
+    ));
+  }
+  
+  /**
+   * Considérer le commentaire signalé comme étant tout a fait acceptable
+   * 
+   * Ceci induit:
+   * * Que le commentaire en question ne soit plus signalé 
+   * * Que le ou les ids d'utilisateurs qui l'ont signalé comme soit "pénalisé
+   * 
+   * @param int $element_id
+   * @param date $date 
+   * 
+   * @return Response
+   */
+  public function commentRefuseAction($element_id, $date)
+  {
+    if (($response = $this->mustBeConnected(true)))
+    {
+      return $response;
+    }
+    
+    if (!($element = $this->getDoctrine()->getRepository('MuzichCoreBundle:Element')
+      ->findOneById($element_id))
+    )
+    {
+      return $this->jsonResponse(array(
+        'status' => 'error',
+        'errors' => array('NotFound')
+      ));
+    }
+    
+    $cm = new CommentsManager($element->getComments());
+    // On supprime le commentaire
+    $cm->deleteWithDate($date);
+    $element->setComments($cm->get());
+    $element->setCountCommentReport($cm->countCommentAlert());
+    
+    $this->getDoctrine()->getEntityManager()->persist($element);
+    $this->getDoctrine()->getEntityManager()->flush();
+    
+    return $this->jsonResponse(array(
+      'status' => 'success'
+    ));
+  }
 }

src/Muzich/AdminBundle/Resources/config/routing.yml

   
 moderate_element_clean:
   pattern:  /admin/moderate/element/clean/{element_id}
-  defaults: { _controller: MuzichAdminBundle:Moderate:cleanElement }
+  defaults: { _controller: MuzichAdminBundle:Moderate:cleanElement }
+  
+##
+
+moderate_comments_index:
+  pattern:  /admin/moderate/comments
+  defaults: { _controller: MuzichAdminBundle:Moderate:comments }
+
+moderate_comment_clean:
+  pattern:  /admin/moderate/comment/{element_id}/{date}/clean
+  defaults: { _controller: MuzichAdminBundle:Moderate:commentClean }
+
+moderate_comment_refuse:
+  pattern:  /admin/moderate/comment/{element_id}/{date}/refuse
+  defaults: { _controller: MuzichAdminBundle:Moderate:commentRefuse }

src/Muzich/AdminBundle/Resources/views/Moderate/comments.html.twig

+{% extends "MuzichAdminBundle:Moderate:layout.html.twig" %}
+
+{% block title %}{% endblock %}
+
+{% block content %}
+
+  <h2>{{ 'moderate.comments.title'|trans({}, 'adminui') }}</h2>
+    
+  <ul id="moderate_comments">
+    {% for comment in comments %}
+      <li class="comment" id="mod_comment_{{ comment.element_id }}_{{ comment.comment.d|date_epurate }}">
+        
+        <a href="{{ path('moderate_comment_clean', {
+          'element_id' : comment.element_id,
+          'date'       : comment.comment.d
+        }) }}" class="accept">
+         [V]
+        </a>
+        <a href="{{ path('moderate_comment_refuse', {
+          'element_id' : comment.element_id,
+          'date'       : comment.comment.d
+        }) }}" class="refuse">
+         [X]
+        </a>
+        
+        <strong>{{ comment.comment.u.s }}</strong>: 
+        
+        {{ comment.comment.c }}
+        
+      </li>
+    {% endfor %}
+  </ul>
+
+{% endblock %}

src/Muzich/AdminBundle/Resources/views/Moderate/index.html.twig

     </li>
   </ul>
   
+  <h3>{{ 'moderate.comments.title'|trans({}, 'adminui') }}</h3>
+  
+  <ul>
+    <li>
+      <a href="{{ path('moderate_comments_index') }}">
+        {{ 'moderate.comments.to_moderate'|trans({'%count%' : count_comments}, 'adminui') }}
+      </a>
+    </li>
+  </ul>
+  
 {% endblock %}

src/Muzich/CommentBundle/Controller/CommentController.php

     $cm = new CommentsManager($element->getComments());
     $cm->alertComment($this->getUserId(), $date);
     $element->setComments($cm->get());
-    $element->setHasCommentReport($cm->hasCommentAlert());
+    $element->setCountCommentReport($cm->countCommentAlert());
     
     $this->getDoctrine()->getEntityManager()->persist($element);
     $this->getDoctrine()->getEntityManager()->flush();
     $cm = new CommentsManager($element->getComments());
     $cm->unAlertComment($this->getUserId(), $date);
     $element->setComments($cm->get());
-    $element->setHasCommentReport($cm->hasCommentAlert());
+    $element->setCountCommentReport($cm->countCommentAlert());
     
     $this->getDoctrine()->getEntityManager()->persist($element);
     $this->getDoctrine()->getEntityManager()->flush();

src/Muzich/CoreBundle/Entity/Element.php

    * Booléen permettant de savoir si un des commentaires de cet élément
    * a été signalé a la modération.
    * 
-   * @ORM\Column(type="boolean", nullable = "true")
-   * @var type string
+   * @ORM\Column(type="integer", nullable=true)
+   * @var int
    */
-  protected $has_comment_report = false;
+  protected $count_comment_report = false;
 
   /**
    * Get id
     $this->tags_propositions = $propositions;
   }
   
-  public function getHasCommentReport()
+  public function getCountCommentReport()
   {
-    if (is_null($this->has_comment_report))
+    if (is_null($this->count_comment_report))
     {
       return false;
     }
     return $this->has_comment_report;
   }
   
-  public function setHasCommentReport($has)
+  public function setCountCommentReport($count)
   {
-    $this->has_comment_report = $has;
+    $this->count_comment_report = $count;
   }
   
   /**

src/Muzich/CoreBundle/Managers/CommentsManager.php

     return $found;
   }
   
+  public function deleteWithDate($date)
+  {
+    foreach ($this->comments as $i => $comment)
+    {
+      if ($comment['d'] == $date)
+      {
+        unset($this->comments[$i]);
+        return true;
+      }
+    }
+    return false;
+  }
+  
   /**
    * Permet de récupérer l'index d'un commentaire dans le tableau de commentaires.
    * Si le commentaire n'est pas trouvé on retourne null.
   }
   
   /**
-   * Permet de savoir si un ou plusieurs des commentaires ont été signalé.
+   * Retourne le nombre de commentaires signalés.
    * 
    * @return boolean
    */
-  public function hasCommentAlert()
+  public function countCommentAlert()
   {
+    $count = 0;
     foreach ($this->comments as $i => $comment)
     {
       if (count($comment['a']))
       {
-        return true;
+        $count = $count+1;
       }
     }
-    return false;
+    return $count;
+  }
+  
+  public function getAlertedComments()
+  {
+    $comments = array();
+    foreach ($this->comments as $i => $comment)
+    {
+      if (count($comment['a']))
+      {
+        $comments[] = $comment;
+      }
+    }
+    return $comments;
+  }
+  
+  public function cleanAlertsOnComment($date)
+  {
+    foreach ($this->comments as $i => $comment)
+    {
+      if ($comment['d'] == $date)
+      {
+        $ids = $comment['a'];
+        $this->comments[$i]['a'] = array();
+        return $ids;
+      }
+    }
+    return array();
   }
   
 }

src/Muzich/CoreBundle/Repository/ElementRepository.php

     ;
   }  
   
+  public function countForCommentToModerate()
+  {
+    return $this->getEntityManager()
+      ->createQuery("SELECT COUNT(e.id) FROM MuzichCoreBundle:Element e
+        WHERE e.count_comment_report IS NOT NULL AND e.count_comment_report != 0"
+      )->getSingleScalarResult()
+    ;
+  }
+  
+  public function getForCommentToModerate()
+  {
+    return $this->getEntityManager()
+      ->createQuery("SELECT e FROM MuzichCoreBundle:Element e
+        WHERE e.count_comment_report IS NOT NULL AND e.count_comment_report != 0"
+      )->getResult()
+    ;
+  }
+  
 }

web/bundles/muzichmoderate/js/moderate.js

 $(document).ready(function(){
    
   $('ul#moderate_tags li.tag a.accept, ul#moderate_tags li.tag a.refuse').click(function(){
-    link = $(this);
+    var link = $(this);
     $.getJSON($(this).attr('href'), function(response) {
      
       if (response.status == 'mustbeconnected')
   
    
   $('ul#moderate_tags li.tag a.replace').click(function(){
-    link = $(this);
+    var link = $(this);
     
-    newtag = link.parent('li').find('input.tagBox_tags_ids').val();
+    var newtag = link.parent('li').find('input.tagBox_tags_ids').val();
     
     $.getJSON($(this).attr('href')+'/'+newtag, function(response) {
      
   });
   
   $('ul#moderate_elements li.element div.controls a.delete').live('click', function(){
-     li = $(this).parent('div.controls').parent('li.element');
+     var li = $(this).parent('div.controls').parent('li.element');
      $.getJSON($(this).attr('href'), function(response) {
        if (response.status == 'success')
        {
   });
   
   $('ul#moderate_elements li.element div.controls a.clean').live('click', function(){
-    li = $(this).parent('div.controls').parent('li.element');
+    var li = $(this).parent('div.controls').parent('li.element');
     $.getJSON($(this).attr('href'), function(response) {
        if (response.status == 'success')
        {
      });
      return false;
   });
+  
+  $('ul#moderate_comments li.comment a.accept, ul#moderate_comments li.comment a.refuse').click(function(){
+    var link = $(this);
+    $.getJSON($(this).attr('href'), function(response) {
+     
+      if (response.status == 'mustbeconnected')
+      {
+        $(location).attr('href', url_index);
+      }
+      
+      if (response.status == 'success')
+      {
+        link.parent('li').remove();
+      }
+      
+      if (response.status == 'error')
+      {
+        alert(response.message);
+      }
+      
+    });
+      
+    return false;
+  });
    
 });