Ajout de commentaires

src/Muzich/CommentBundle/Controller/CommentController.php

 class CommentController extends Controller
 {
   
+  /**
+   * Action d'ajouter un commentaire.
+   * 
+   * @param int $element_id
+   * @param string $token
+   * @return \Symfony\Component\HttpFoundation\Response 
+   */
   public function addAction($element_id, $token)
   {
     if (($response = $this->mustBeConnected(true)))
          
   }
   
+  /**
+   * Suppression d'un commentaire
+   *
+   * @param type $element_id
+   * @param type $date
+   * @param type $token
+   * @return \Symfony\Component\HttpFoundation\Response 
+   */
   public function deleteAction($element_id, $date, $token)
   {
     if (($response = $this->mustBeConnected(true)))
     // On met a jour les commentaires
     $cm = new CommentsManager($element->getComments());
     
-    
+    // On utilise le comment manager pour supprimer le commentaire de la liste
     if (!$cm->delete($this->getUserId(), $date))
     {
+      // Si il n'a pas été trouvé on répond une erreur
       return $this->jsonResponse(array(
         'status' => 'error',
         'errors' => array($this->trans(
       )));
     }
     
+    // Si tout c'est bien passé on met a jour l'attribut de l'élément
     $element->setComments($cm->get());
       
     $this->getDoctrine()->getEntityManager()->persist($element);
     ));
   }
   
+  /**
+   * Modification d'un commentaire, ouverture du formulaire 
+   * 
+   * @param int $element_id
+   * @param string $date (Y-m-d H:i:s u)
+   * @param string $token
+   * @return Response 
+   */
   public function editAction($element_id, $date, $token)
   {
     if (($response = $this->mustBeConnected(true)))
       ));
     }
     
+    // On utilise le gestionnaire de commentaire
     $cm = new CommentsManager($element->getComments());
+    // On récupére le commentaire visé
     $comment = $cm->get($cm->getIndex($this->getUserId(), $date));
-    
+    // On rpépare la réponse html (formulaire)
     $html = $this->render('MuzichCommentBundle:Comment:edit.html.twig', array(
       'comment'     => $comment,
       'element_id'  => $element->getId(),
       'date'        => $date
     ))->getContent();
-    
+    // On retourne le tout
     return $this->jsonResponse(array(
       'status' => 'success',
       'html'   => $html
     ));
   }
   
+  /**
+   * Mise a jour du commentaire. On précise dom_id pour retrouver facilement le 
+   * commentaire dans le dom lorsque js récupére la réponse.
+   * 
+   * @param int $element_id
+   * @param string $date (Y-m-d H:i:s u)
+   * @param string $token
+   * @param string $dom_id
+   * @return type 
+   */
   public function updateAction($element_id, $date, $token, $dom_id)
   {
     if (($response = $this->mustBeConnected(true)))

src/Muzich/CoreBundle/Actions/User/Event.php

 use Muzich\CoreBundle\Entity\Event as EventEntity;
 
 /**
- * Description of Reputation
+ * Refactorisation d'actions lié aux événement de l'utilisateur
  *
  * @author bux
  */
     $this->event = $event;
   }
   
+  /*
+   * Mise a jour de l'objet Eevnt
+   */
   public function updateEvent($element_id)
   {
     $this->event->addId($element_id);
   }
   
+  /**
+   * Création d'un objet Event
+   * 
+   * @param string $type
+   * @param int $element_id 
+   */
   public function createEvent($type, $element_id)
   {
     $this->event->addId($element_id);
     $this->event->setType($type);
     $this->event->setUser($this->user);
   }
+  
 }

src/Muzich/CoreBundle/Actions/User/Reputation.php

 use Muzich\CoreBundle\Entity\User;
 
 /**
- * Description of Reputation
+ * Refactorisation d'actions lié a la réputation de l'utilisateur
  *
  * @author bux
  */
     $this->user = $user;
   }
   
+  /**
+   * Ajoute des points a l'objet User
+   * 
+   * @param int $points 
+   */
   public function addPoints($points)
   {
     $this->user->setReputation($this->user->getReputation()+$points);
   }
   
+  /**
+   * Retirer des points a l'objet User
+   * 
+   * @param int $points 
+   */
   public function removePoints($points)
   {
     $this->user->setReputation($this->user->getReputation()-$points);

src/Muzich/CoreBundle/Controller/CoreController.php

     return $groups;
   }
   
+  /**
+   * Action non ajax nettoyant la liste de tags du chercheur d'éléments
+   * 
+   * @return RedirectResponse 
+   */
   public function filterClearAction()
   {
     $es = $this->getElementSearcher();
     return $this->redirect($this->container->get('request')->headers->get('referer'));
   }
   
+  /**
+   * Action non ajax de selection de ses tags favoris pour le chercheur d'élément
+   * 
+   * @return RedirectResponse 
+   */
   public function filterMytagsAction()
   {
     $this->getElementSearcher(null, true);
     return $this->redirect($this->container->get('request')->headers->get('referer'));
   }
   
+  /**
+   * Action de récupération ajax de l'id des tags favoris de son profil
+   * 
+   * @return Response 
+   */
   public function getFavoriteTagsAction()
   {
     if (($response = $this->mustBeConnected()))
     ));
   }
   
+  /**
+   * Action ajax qui ajoute le tags précisé en paramétre aux tags favoris de
+   * l'utilisateur.
+   * 
+   * @param int $tag_id
+   * @param string $token
+   * @return Response 
+   */
   public function addTagToFavoritesAction($tag_id, $token)
   {
     if (($response = $this->mustBeConnected(true)))
       )->getSingleResult();
     }
     
+    // On contrôle au préalable que le tag ne fait pas déjà partie des favoris de 
+    // l'utilisateur
     if (!$this->getDoctrine()->getRepository('MuzichCoreBundle:UsersTagsFavorites')
       ->findOneBy(array(
         'user' => $this->getUserId(),
         'tag'  => $tag->getId()
       )))
     {
+      // Si il ne l'est pas, on créer ce nouvel objet de relation
       $fav = new UsersTagsFavorites();
       $fav->setTag($tag);
       $fav->setUser($user);
     ));
   }
   
+  /**
+   * Cette action (ajax) configure l'appartenance d'un élément a un groupe.
+   * Le groupe et l'élément doivent appartenir a l'utilisateur en cours.
+   * 
+   * @param int $element_id
+   * @param int $group_id
+   * @param string $token
+   * @return Response 
+   */
   public function setElementGroupAction($element_id, $group_id, $token)
   {
     if (($response = $this->mustBeConnected(true)))
     ));
   }
   
+  /**
+   * Action (ajax) permettant de signaler un élément comme contenu non approprié.
+   * 
+   * @param int $element_id
+   * @param string $token
+   * @return Response 
+   */
   public function reportElementAction($element_id, $token)
   {
     if (($response = $this->mustBeConnected(true)))
       ));
     }
     
+    // On utilise le manager de rapport
     $erm = new ElementReportManager($element);
     $erm->add($this->getUser());
     
     
   }
   
+  /**
+   * Il arrive que l'on configure le chercheur d'élément de façon a ce qu'il
+   * affiche une liste d'élément précis (collection d'id). Cette action
+   * supprime cette configuration de façon a ce que le chercheur fonctionne 
+   * normalement.
+   * 
+   * @return type 
+   */
   public function filterRemoveIdsAction()
   {
     if (($response = $this->mustBeConnected(true)))

src/Muzich/CoreBundle/Controller/ElementController.php

 {
   
   /**
-   *
-   * @param type $element_id
+   * Cette méthode est utilisé pour récupérer un objet Element tout en levant
+   * une erreur si il n'existe pas ou si il n'appartient pas a l'utilisateur en 
+   * cours.
+   * 
+   * @param int $element_id
    * @return Muzich\CoreBundle\Entity\Element 
    */
   protected function checkExistingAndOwned($element_id)
   }
   
   /**
+   * Action d'ouverture du formulaire de modification d'un élément.
    * 
+   * @param int $element_id
+   * @return Response
    */
   public function editAction($element_id)
   {
     
     $element = $this->checkExistingAndOwned($element_id);
     
+    // On doit faire un chmilblik avec les tags pour
+    // utiliser le javascript de tags (tagPrompt)
+    // sur le formulaire
     $element_tags = $element->getTags();
     $element->setTags($element->getTagsIdsJson());
     $form = $this->getAddForm($element);
   }
   
   /**
-   *
+   * Mise a jour des données d'un élément.
+   * 
+   * @param int $element_id
+   * @param string $dom_id
+   * @return Response 
    */
   public function updateAction($element_id, $dom_id)
   {
     {
       $status = 'success';
       $em = $this->getDoctrine()->getEntityManager();
+      // On utilise le manager d'élément
       $factory = new ElementManager($element, $em, $this->container);
       $factory->proceedFill($user);
       // Si il y avais un groupe on le remet
     ));
   }
   
+  /**
+   * Suppression d'un élément. 
+   * 
+   * @param int $element_id
+   * @return Response 
+   */
   public function removeAction($element_id)
   {
     if (($response = $this->mustBeConnected()))
     }
   }
   
+  /**
+   * Cette procédure retourne le lien a afficher sur la page home permettant
+   * d'afficher des élément apparus entre temps.
+   * 
+   * @param int $count
+   * @return type 
+   */
   protected function getcountNewMessage($count)
   {
     if ($count == 1)
     ));
   }
   
+  /**
+   * Action (ajax) ajoutant son vote "good" sur un élément
+   * 
+   * @param int $element_id
+   * @param string $token
+   * @return Response 
+   */
   public function addVoteGoodAction($element_id, $token)
   {
     if (($response = $this->mustBeConnected(true)))
       ));
     }
     
+    // On ajoute un vote a l'élément
     $element->addVoteGood($this->getUser()->getId());
+    // Puis on lance les actions propagés par ce vote
     $event = new EventElementScore($this->container);
     $event->onePointAdded($element);
     
     ));
   }
   
+  /**
+   * Action (ajax) de retrait de son vote good
+   * 
+   * @param int $element_id
+   * @param string $token
+   * @return Response 
+   */
   public function removeVoteGoodAction($element_id, $token)
   {
     if (($response = $this->mustBeConnected(true)))
       ));
     }
     
+    // Retrait du vote good
     $element->removeVoteGood($this->getUser()->getId());
+    // Puis on lance les actions propagés par retrait de vote
     $event = new EventElementScore($this->container);
     $event->onePointRemoved($element);
     

src/Muzich/CoreBundle/Controller/SearchController.php

 class SearchController extends Controller
 {
   
+  /**
+   * Procédure qui construit un réponse json contenant le html
+   * par defalt de la liste d'élément.
+   * 
+   * @param Collection $elements
+   * @param boolean $invertcolors
+   * @param sring $message
+   * @return Response 
+   */
   protected function searchElementsMore($elements, $invertcolors, $message)
   {
     
     }
   }
   
+  /**
+   * Action (ajax) de récupération d'éléments en plus
+   * [a check pour être sur] N'EST PLUS UTILISE
+   *
+   * @param string $type
+   * @param string $object_id
+   * @param int $id_limit
+   * @param boolean $invertcolors
+   * @return Response 
+   */
   public function searchElementsShowAction($type, $object_id, $id_limit, $invertcolors)
   {
     if ($this->getRequest()->isXmlHttpRequest())
   }
     
   /**
-   *
-   * @param string $string_search 
+   * Procédure (ajax) de recherche de tags. Essentielement utilisé dans 
+   * le tagPrompt.
+   * 
+   * @param string $string_search
+   * @param int $timestamp
+   * @return Response 
    */
   public function searchTagAction($string_search, $timestamp)
   {
     {
       if (strlen(trim($string_search)) > 1)
       {
+        // On utilise l'objet TagLike
         $TagLike = new TagLike($this->getDoctrine());
+        // Pour trier nos tags d'une manière plus humaine
         $sort_response = $TagLike->getSimilarTags($string_search, $this->getUserId());
       
         $status = 'success';
   }
   
   /**
-   *
+   * Récupére l'id d'un tag (ajax)
+   * [A check] mais ne doit et n'est plus utilisé.
+   * 
    * @param type $string_search
    * @return Response 
    */

src/Muzich/CoreBundle/Entity/Element.php

     }
   }
   
+  /**
+   * Retourne le nombre de fois que cet élément a été msi en favoris 
+   * 
+   * @return int
+   */
   public function getCountFavorite()
   {
     return count($this->elements_favorites);
 //    $this->tags->removeElement($tag);
 //  }
   
+  /**
+   * Répond vrai si le tag transmis fait partis des tags de l'élément
+   * 
+   * @param Tag $tag_t
+   * @return boolean 
+   */
   public function hasTag(Tag $tag_t)
   {
     foreach ($this->getTags() as $tag)
     $this->vote_good_ids = json_encode($votes_ids);
   }
   
+  /**
+   * ajoute le vote de l'user_id aux votes good
+   * 
+   * @param int $user_id 
+   */
   public function addVoteGood($user_id)
   {
     $votes = $this->getVoteGoodIds();
     $this->setVoteGoodIds($votes);
   }
   
+  /**
+   * Retire le vote_good de l'user_id
+   * 
+   * @param int $user_id 
+   */
   public function removeVoteGood($user_id)
   {
     if (count($votes = $this->getVoteGoodIds()))
     }
   }
   
+  /**
+   * Répond vrai si l'user_id a déjà voté good.
+   * 
+   * @param int $user_id
+   * @return boolean 
+   */
   public function hasVoteGood($user_id)
   {
     if (count($votes = $this->getVoteGoodIds()))

src/Muzich/CoreBundle/Entity/Event.php

    * 
    */
   
+  /**
+   * Ajoute l'identifiant a la liste d'identifiant
+   * 
+   * @param int $id 
+   */
   public function addId($id)
   {
     $ids = $this->getIds();
     $this->setIds($ids);
   }
     
+  /**
+   * Répond vrai si l'id transmis fait partis des ids
+   * 
+   * @param int $id_check
+   * @return boolean 
+   */
   public function hasId($id_check)
   {
     if (count($ids = $this->getIds()))

src/Muzich/CoreBundle/Managers/CommentsManager.php

 namespace Muzich\CoreBundle\Managers;
 
 /**
+ * Gestionnaire de commentaires.
+ * Les commentaires sont stocké en base sous forme de tableau json afin d'économiser
+ * relations entre tables. Ce menager per de gérer le tableau de commentaire
+ * plus facilement.
+ * 
  * @author bux
  */
 class CommentsManager
   }
   
   /**
-   *
+   * Ajouter un commentaire au tableau.
+   * 
    * @param \Muzich\CoreBundle\Entity\User $user
    * @param String $comment
    * @param String $date 
     return $this->get(count($this->comments)-1);
   }
   
+  /**
+   * Mise a jour d'un commentaire parmis le tableau. On l'identifie ici par son
+   * auteur et sa date de publication.
+   * 
+   * @param \Muzich\CoreBundle\Entity\User $user
+   * @param date $date (Y-m-d H:i:s u)
+   * @param string $comment_c 
+   */
   public function update($user, $date, $comment_c)
   {
     $comments = array();
   }
   
   /**
-   *
+   * Suppression d'un commentaire. Si il a été trouvé on retourne vrai.
+   * 
    * @param int $user_id
-   * @param string $date
+   * @param string $date (Y-m-d H:i:s u)
    * @return boolean 
    */
   public function delete($user_id, $date)
     return $found;
   }
   
+  /**
+   * 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 int $user_id
+   * @param  string $date (Y-m-d H:i:s u)
+   * @return int 
+   */
   public function getIndex($user_id, $date)
   {
     foreach ($this->comments as $i => $comment)
   }
   
   /**
-   *
+   * Retourne un commentaire en fonction de son index dans le tableau.
+   * 
    * @return array
    */
   public function get($index = null)

src/Muzich/CoreBundle/Managers/ElementReportManager.php

 use Muzich\CoreBundle\Entity\User;
 
 /**
+ * Manager de rapport sur elements
+ * 
  * @author bux
  */
 class ElementReportManager
   }
   
   /**
-   *
+   * Ajouter un rapport
+   * 
    * @param \Muzich\CoreBundle\Entity\User $user
    * @param String $comment
    * @param String $date 

src/Muzich/CoreBundle/Propagator/EventElementComment.php

 use Muzich\CoreBundle\Entity\Event;
 
 /**
- * Description of EventElementScore
+ * Propagateur d'événement concernant les Commentaires d'éléments
  *
  * @author bux
  */
 class EventElementComment extends EventPropagator
 {  
   
+  /**
+   * Cette procédure doit être appelé après l'ajout d'un commentaire sur un 
+   * événement. Actuellement il:
+   * * Met a jour ou créer un objet événement (nouveau commentaire) pour le
+   *   propriétaire de l'élément.
+   * 
+   * @param Element $element 
+   */
   public function commentAdded(Element $element)
   {    
     $em = $this->container->get('doctrine')->getEntityManager();

src/Muzich/CoreBundle/Propagator/EventElementScore.php

 use Muzich\CoreBundle\Actions\User\Reputation as UserReputation;
 
 /**
- * Description of EventElementScore
+ * Propagateur d'événement liés aux score des éléments
  *
  * @author bux
  */

src/Muzich/CoreBundle/lib/Controller.php

   }
   
   /**
-   * Retourne l'objet User.
+   * Retourne l'objet User. Il est possible de préciser de quel manière récupérer 
+   * l'utilisateur:
    * 
+   * $user = $this->getUser(true, array('join' => array(
+   *   'groups_owned'
+   * )));
+   * 
+   * ou de forcer sa (re)récupération en base (sinon c'est l'objet static qui est renvoyé)
+   * 
+   * @param boolean $personal_query
    * @param array $params
-   * @return User
+   * @param boolean $force_refresh
+   * @return type 
    */
   protected function getUser($personal_query = false, $params = array(), $force_refresh = false)
   {
     }
   }
   
+  /**
+   * Retourne le formulaire de recherche
+   * 
+   * @param \Muzich\CoreBundle\Searcher\Searcher $search_object
+   * @return \Symfony\Component\Form\Form
+   */
   protected function getSearchForm($search_object)
   {
     return $this->createForm(
     );
   }
   
+  /**
+   * Retourne le formulaire d'ajout d'élément
+   * 
+   * @param \Muzich\CoreBundle\Searcher\Searcher $search_object
+   * @return \Symfony\Component\Form\Form
+   */
   protected function getAddForm($element = array())
   {
     return $this->createForm(
   }
   
   /**
-   * Retourne une réponse contenant du json
+   * Retourne une réponse contenant et de type json
    * 
    * @param array $content
    * @return Response 
     return $response;
   }
   
+  /**
+   * Permet d'utiliser la méthode Assert que l'on utilise dans les templates
+   * afin d'avoir une url correcte vers une ressource web (img, js, ...)
+   * 
+   * @param string $path
+   * @param string $packageName
+   * @return string 
+   */
   protected function getAssetUrl($path, $packageName = null)
   {
     return $this->container->get('templating.helper.assets')->getUrl($path, $packageName);
   }
   
   /**
-   *
-   * @param strin $string
+   * Retourne une traduction effectué par le translator
+   * 
+   * @param string $string
    * @param array $params
    * @param string $package
    * @return string 
   }
   
   /**
-   *
+   * Permet de récupérer un objet réponse si l'utilisateur doit être connecté
+   * pour accéder a cette ressource. On peux préciser $and_ajax pour que
+   * la requete de type ajax soit une nécéssité.
+   * 
    * @return Response
    */
   protected function mustBeConnected($and_ajax = false)