Evolution #183: Suivis des mauvais comportements

src/Muzich/AdminBundle/Controller/ModerateController.php

   
   public function tagAcceptAction($tag_id)
   {
-    if (($response = $this->mustBeConnected()))
+    if (($response = $this->mustBeConnected(true)))
     {
       return $response;
     }
     
+    if (!($tag = $doctrine->getRepository('MuzichCoreBundle:Tag')->findOneBy(array(
+      'id'         => $tag_id,
+      'tomoderate' => true
+    ))))
+    {
+      return $this->jsonResponse(array(
+        'status'  => 'error',
+        'message' => 'NotFound'
+      ));
+    }
+    
     $tagManager = new TagManager();
-    if (!$tagManager->moderateTag($this->getDoctrine(), $tag_id, true))
+    if (!$tagManager->moderateTag($this->getDoctrine(), $tag, true))
     {
       return $this->jsonResponse(array(
         'status'  => 'error',
   
   public function tagRefuseAction($tag_id)
   {
-    if (($response = $this->mustBeConnected()))
+    if (($response = $this->mustBeConnected(true)))
     {
       return $response;
     }
     
+    if (!($tag = $this->getDoctrine()->getRepository('MuzichCoreBundle:Tag')->findOneBy(array(
+      'id'         => $tag_id,
+      'tomoderate' => true
+    ))))
+    {
+      return $this->jsonResponse(array(
+        'status'  => 'error',
+        'message' => 'NotFound'
+      ));
+    }
+    
     $tagManager = new TagManager();
-    if (!$tagManager->moderateTag($this->getDoctrine(), $tag_id, false))
+    if (!$tagManager->moderateTag($this->getDoctrine(), $tag, false))
     {
       return $this->jsonResponse(array(
         'status'  => 'error',
       ));
     }
     
+    // Tout c'est bien passé, on incremente ceci dit le compteur
+    // de tag refusés par la modération pour le ou les utilisateurs
+    // ayant fait la demande d'ajout
+    $uids = json_decode($tag->getPrivateids(), true);
+    
+    $users = $this->getDoctrine()->getEntityManager()
+      ->createQuery('
+        SELECT u FROM MuzichCoreBundle:User u
+        WHERE u.id IN (:uids)'
+      )
+      ->setParameter('uids', $uids)
+      ->getResult()
+    ;
+    
+    // Pour chacun on augmente le compteur
+    foreach ($users as $user)
+    {
+      $user->addModeratedTagCount();
+      $this->getDoctrine()->getEntityManager()->persist($user);
+    }
+    
+    $this->getDoctrine()->getEntityManager()->flush();
+    
     return $this->jsonResponse(array(
       'status' => 'success'
     ));
    */
   public function tagReplaceAction($tag_id, $tag_new_id)
   {
-    if (($response = $this->mustBeConnected()))
+    if (($response = $this->mustBeConnected(true)))
     {
       return $response;
     }
     
+    if (!($tag = $doctrine->getRepository('MuzichCoreBundle:Tag')->findOneBy(array(
+      'id'         => $tag_id,
+      'tomoderate' => true
+    ))))
+    {
+      return $this->jsonResponse(array(
+        'status'  => 'error',
+        'message' => 'NotFound'
+      ));
+    }
+    
     $tag_array = json_decode($tag_new_id);
     if (!array_key_exists(0, $tag_array))
     {
     $tag_new_id = $tag_array[0];
     
     $tagManager = new TagManager();
-    if (!$tagManager->moderateTag($this->getDoctrine(), $tag_id, false, $tag_new_id))
+    if (!$tagManager->moderateTag($this->getDoctrine(), $tag, false, $tag_new_id))
     {
       return $this->jsonResponse(array(
         'status'  => 'error',
     
     $event = new EventElement($this->container);
     $event->elementRemoved($element);
+    $element->getOwner()->addModeratedElementCount();
 
     $this->getDoctrine()->getEntityManager()->persist($element->getOwner());
     $this->getDoctrine()->getEntityManager()->remove($element);
     }
     
     $cm = new CommentsManager($element->getComments());
+    $comment = $cm->get($cm->getIndexWithDate($date));
     // On supprime le commentaire
     $cm->deleteWithDate($date);
     $element->setComments($cm->get());
     $element->setCountCommentReport($cm->countCommentAlert());
     
+    // On récupère l'auteur du commentaire pour lui incrémenté son compteur
+    // de contenu modéré
+    $user = $this->getDoctrine()->getEntityManager()->getRepository('MuzichCoreBundle:User')
+      ->findOneBy(array(
+        'id' => $comment['u']['i']
+      ));
+    
+    $user->addModeratedCommentCount();
+    
+    $this->getDoctrine()->getEntityManager()->persist($user);
     $this->getDoctrine()->getEntityManager()->persist($element);
     $this->getDoctrine()->getEntityManager()->flush();
     

src/Muzich/CoreBundle/Entity/User.php

    * @var int 
    */
   protected $bad_report_count;
+  
+  /**
+   * Compteur de contenus refusés par la modération
+   * 
+   * @ORM\Column(type="integer", nullable=true)
+   * @var int 
+   */
+  protected $moderated_element_count;
+  
+  /**
+   * Compteur de contenus refusés par la modération
+   * 
+   * @ORM\Column(type="integer", nullable=true)
+   * @var int 
+   */
+  protected $moderated_tag_count;
+  
+  /**
+   * Compteur de contenus refusés par la modération
+   * 
+   * @ORM\Column(type="integer", nullable=true)
+   * @var int 
+   */
+  protected $moderated_comment_count;
 
   /**
    * @ORM\Column(type="text", nullable=true)
     $this->events = $events;
   }
   
+  public function getModeratedElementCount()
+  {
+    if ($this->moderated_element_count === null)
+    {
+      return 0;
+    }
+    return $this->moderated_element_count;
+  }
+  
+  public function setModeratedElementCount($count)
+  {
+    $this->moderated_element_count = $count;
+  }
+  
+  public function addModeratedElementCount()
+  {
+    $this->setModeratedElementCount($this->getModeratedElementCount()+1);
+  }
+  
+  public function getModeratedTagCount()
+  {
+    if ($this->moderated_tag_count === null)
+    {
+      return 0;
+    }
+    return $this->moderated_tag_count;
+  }
+  
+  public function setModeratedTagCount($count)
+  {
+    $this->moderated_tag_count = $count;
+  }
+  
+  public function addModeratedTagCount()
+  {
+    $this->setModeratedTagCount($this->getModeratedTagCount()+1);
+  }
+  
+  public function getModeratedCommentCount()
+  {
+    if ($this->moderated_comment_count === null)
+    {
+      return 0;
+    }
+    return $this->moderated_comment_count;
+  }
+  
+  public function setModeratedCommentCount($count)
+  {
+    $this->moderated_comment_count = $count;
+  }
+  
+  public function addModeratedCommentCount()
+  {
+    $this->setModeratedCommentCount($this->getModeratedCommentCount()+1);
+  }
+  
   /*
    * 
    * 

src/Muzich/CoreBundle/Managers/CommentsManager.php

   }
   
   /**
+   * 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.
+   * 
+   * @param  string $date (Y-m-d H:i:s u)
+   * @return int 
+   */
+  public function getIndexWithDate($date)
+  {
+    foreach ($this->comments as $i => $comment)
+    {
+      if ($comment['d'] == $date)
+      {
+        return $i;
+      }
+    }
+    return null;
+  }
+  
+  /**
    * Retourne un commentaire en fonction de son index dans le tableau.
    * 
    * @return array

src/Muzich/CoreBundle/Managers/TagManager.php

     $em->flush();
   }
   
-  public function moderateTag(Registry $doctrine, $tag_id, $accept, $replacing_id = null)
+  public function moderateTag(Registry $doctrine, Tag $tag, $accept, $replacing_id = null)
   {
-    if (($tag = $doctrine->getRepository('MuzichCoreBundle:Tag')->findOneBy(array(
-      'id'         => $tag_id,
-      'tomoderate' => true
-    ))))
+    if ($tag)
     {
       if ($accept)
       {