Ajout de commentaires, nettoyage code, petites refactorisations.

src/Muzich/CoreBundle/Controller/CoreController.php

 
 class CoreController extends Controller
 {
-  
-  public function changeLanguageAction($language, $redirect)
+
+  /**
+   * Action permettant de changer le language
+   *
+   * @param string $language
+   * @return RedirectResponse
+   */
+  public function changeLanguageAction($language)
   {
     if($language != null)
     {
     
     $url_referer = $this->container->get('request')->headers->get('referer');
     
-    // On effectue un contrôl un peu sépcial:
+    // On effectue un contrôle un peu spécial:
     // Si la page de demande était la page de connexion (hello)
     if (
       $this->generateUrl('index', array('_locale' => $old), true) == $url_referer
   }
   
   /**
+   * Cette action permet a un utilisateur de suivre ou de ne plus suivre
+   * un utilisateur ou un groupe.
    * 
    * @param string $type
    * @param int $id
     {
       throw $this->createNotFoundException();
     }
-    
+
+    // On tente de récupérer l'enregistrement FollowUser / FollowGroup
     $em = $this->getDoctrine()->getEntityManager();
     $Follow = $em
       ->getRepository('MuzichCoreBundle:Follow' . ucfirst($type))
         )
       )
     ;
-    
+
+    // Si il existe déjà c'est qu'il ne veut plus suivre
     if ($Follow)
     {
       // L'utilisateur suis déjà, on doit détruire l'entité
       $em->remove($Follow);
       $em->flush();
     }
+    // Sinon, c'est qu'il veut le suivre
     else
     {
+      // On récupére l'entité a suivre
       $followed = $em->getRepository('MuzichCoreBundle:'.ucfirst($type))->find($id);
 
       if (!$followed) {
           throw $this->createNotFoundException('No '.$type.' found for id '.$id);
       }
       
-      
+      // On instancie te renseigne l'objet Follow****
       if ($type == 'user') { $Follow = new FollowUser(); }
       else { $Follow = new FollowGroup(); }
       $Follow->setFollower($user);
       return $this->redirect($this->container->get('request')->headers->get('referer'));
     }
   }
-  
+
+  /**
+   *  Procédure d'ajout d'un element
+   */
   public function elementAddAction()
   {
     $user = $this->getUser();
       {
         $data = $form->getData();
         $element = new Element();
-        
+
+        // On utilise le gestionnaire d'élément
         $factory = new ElementManager($element, $em, $this->container);
         $factory->proceedFill($data, $user);
         
     
   }
   
-//  protected function proceedElement(Element $element)
-//  {
-//    $factory = new ElementFactory();
-//    $factory->proceed($element, $form->getData());
-//  }
-  
 }

src/Muzich/CoreBundle/Controller/SearchController.php

 
 use Muzich\CoreBundle\Searcher\ElementSearcher;
 use Muzich\CoreBundle\Form\Search\ElementSearchForm;
-use Doctrine\ORM\Query;
 
 class SearchController extends Controller
 {
   public function searchElementsAction()
   {
     $request = $this->getRequest();
-    $search_object = $this->getElementSearcher($this->getUser()->getId());
+    $search_object = $this->getElementSearcher();
     
     $search_form = $this->createForm(
       new ElementSearchForm(), 
     if ($request->getMethod() == 'POST')
     {
       $search_form->bindRequest($request);
+      // Si le formulaire est valide
       if ($search_form->isValid())
       {
+        // On met a jour l'objet avec les nouveaux paramétres saisie dans le form
         $search_object->update($search_form->getData());
-        $this->setElementSearcher($search_object);
+        // Et on met a jour la "mémoire" de la recherche
+        $this->setElementSearcherParams($search_object->getParams());
       }
     }
     

src/Muzich/CoreBundle/ElementFactory/ElementManager.php

       'tags' => array()
     );
   }
-  
+
+  /**
+   * 
+   * @param Element $element
+   * @param EntityManager $em
+   * @param Container $container
+   */
   public function __construct(Element $element, EntityManager $em, Container $container)
   {
     $this->element = $element;

src/Muzich/CoreBundle/Managers/GroupManager.php

    * Procédure chargé de construire le contenu tags.
    * 
    * @param array $tags_ids
-   * @param User $owner
    */
   public function proceedTags($tags_ids)
   {

src/Muzich/CoreBundle/Repository/GroupRepository.php

 {
   
   /**
-   * Retourne un tableau d'user correspondant a un chaine de caractère
-   * La recherche est effectué sur le username.
+   * Retourne un tableau de groupe correspondant a un chaine de caractère
+   * La recherche est effectué sur le name.
    * 
    * @param type $string
    * @return Doctrine\ORM\Query

src/Muzich/CoreBundle/Repository/TagRepository.php

 {
   
   /**
-   * Retourne les tags
+   * Retourne tous les tags connus sous forme d'un tableau
    * 
    * @return array id => name
    */

src/Muzich/CoreBundle/Repository/UserRepository.php

       $join   .= ' LEFT JOIN u.groups_owned og';
     }
     
-//    if (array_key_exists('followed_user_id', $join_list))
-//    {
-//      $select .= ', fu, fu_u';
-//      $join   .= ' LEFT JOIN u.followeds_users fu WITH fu.followed = :fuid LEFT JOIN fu.followed fu_u';
-//      $parameters = array_merge($parameters, array(
-//        'fuid' => $join_list['followed_user_id']
-//      ));
-//    }
-    
     return $this->getEntityManager()
       ->createQuery("
         SELECT $select FROM MuzichCoreBundle:User u
       ))
     ;
   }
-  
+
+  /**
+   * Retourne vrai si follower suis followed
+   *
+   * @param int $follower_id
+   * @param int $followed_id
+   * @return boolean
+   */
   public function isFollowingUser($follower_id, $followed_id)
   {
     $result = $this->getEntityManager()
     
     return $result[1];
   }
-  
+
+  /**
+   * Retourne vrai si follower suis le groupe
+   *
+   * @param int $follower_id
+   * @param int $group_id
+   * @return boolean
+   */
   public function isFollowingGroup($follower_id, $group_id)
   {
     $result = $this->getEntityManager()

src/Muzich/CoreBundle/Searcher/ElementSearcher.php

   {
     return $this->favorite;
   }
-  
+
   /**
-   * Retourne les elements correspondant a la recherche
-   * 
+   * Construction de l'objet Query
+   *
    * @param Registry $doctrine
    * @return collection
    */
-  public function doSearch(Registry $doctrine, $user_id)
+  protected function constructQueryObject(Registry $doctrine, $user_id)
   {
-    return $doctrine
+    $this->setQuery($doctrine
       ->getRepository('MuzichCoreBundle:Element')
-      ->findBySearch($this, $user_id)
-      ->execute()
+      ->findBySearch($this, $user_id))
     ;
   }
   
+  /**
+   * Retourne l'objet Query
+   * 
+   * @param Registry $doctrine
+   * @return collection
+   */
+  public function getQuery(Registry $doctrine, $user_id)
+  {
+    if (!$this->query)
+    {
+      $this->constructQueryObject($doctrine, $user_id);
+    }
+    return $this->query;
+  }
+
+  /**
+   * Retourne les elements correspondant a la recherche
+   *
+   * @param Registry $doctrine
+   * @return collection
+   */
+  public function getElements(Registry $doctrine, $user_id)
+  {
+    return $this->getQuery($doctrine, $user_id)->execute();
+  }
+  
 }

src/Muzich/CoreBundle/Searcher/Searcher.php

 
 namespace Muzich\CoreBundle\Searcher;
 
+use Doctrine\ORM\Query;
+use Symfony\Bundle\DoctrineBundle\Registry;
+
 /**
  * Objet utiliser pour cadrer la recherche.
  * 
  */
-class Searcher
+abstract class Searcher
 {
+  /**
+   * Query est l'objet requete correspondant a la recherche
+   *
+   * @var Query
+   */
+  protected $query = null;
+
   protected function checkParams($params, $neededs)
   {
     foreach ($neededs as $config_id => $message)
       }
     }
   }
+
+  protected function setQuery(Query $query)
+  {
+    $this->query = $query;
+  }
+
+  public function getQuery(Registry $doctrine, $user_id)
+  {
+    return $this->query;
+  }
+
 }

src/Muzich/CoreBundle/Searcher/SearcherInterface.php

    */
   public function getParams();
   
-//  /**
-//   * Procédure qui construit la requete.
-//   */
-//  public function constructQueryObject();
-//  
-//  /**
-//   * Récupération de l'objet requete, pour ajouter des JOIN 
-//   * par exemple.
-//   */
-//  public function getQueryObject();
-//  
-//  /**
-//   * Récupération des résultats.
-//   */
-//  public function getResults();
-  
 }

src/Muzich/CoreBundle/lib/Controller.php

   }
     
   /**
-   * Met a jour l'objet ElementSearcher (en réallité on met a jour les
-   * paramètres en sessions).
+   * Met a jour les parametres de ElementSearcher pour la "mémoire" de la
+   * recherche
    * 
-   * @param ElementSearcher $es 
+   * @param array $params
    */
-  protected function setElementSearcher(ElementSearcher $es)
+  protected function setElementSearcherParams($params)
   {
-    $this->get("session")->set('user.element_search.params', $es->getParams());
+    $this->get("session")->set('user.element_search.params', $params);
   }
   
   /**
    * Retourn l'objet ElementSearcher en cours.
    * 
-   * @param int $user_id
    * @return  ElementSearcher
    */
-  protected function getElementSearcher($user_id)
+  protected function getElementSearcher()
   {
     $session = $this->get("session");
     // Si l'objet n'existe pas encore, a t-on déjà des paramètres de recherche
       $this->ElementSearcher->init(array(
         'tags' => $this->getDoctrine()->getRepository('MuzichCoreBundle:User')
         // TODO: 3: CONFIG !!
-        ->getTagIdsFavorites($user_id, 3)
+        ->getTagIdsFavorites($this->getUserId(), 3)
       ));
 
       // Et on met en session les paramètres
     {
       // Des paramètres existes, on fabrique l'objet recherche
       $this->ElementSearcher = new ElementSearcher();
+      // et on l'initatialise avec ces paramétres connus
       $this->ElementSearcher->init($session->get('user.element_search.params'));
     }
     

src/Muzich/FavoriteBundle/Controller/FavoriteController.php

     {
       throw $this->createNotFoundException();
     }
-    
+
+    // Si l'élément n'est pas déjà en favoris
     if (!$em->getRepository('MuzichCoreBundle:UsersElementsFavorites')
       ->findOneBy(array(
         'user'    => $user->getId(),
         'element' => $id
       )))
     {
+      // On créer un objet 
       $favorite = new UsersElementsFavorites();
       $favorite->setUser($user);
       $favorite->setElement($element);
     
     return array(
       'user'     => $this->getUser(),
-      'elements' => $search_object->doSearch($this->getDoctrine(), $this->getUserId())
+      'elements' => $search_object->getElements($this->getDoctrine(), $this->getUserId())
     );
   }
   
     return array(
       'user'        => $this->getUser(),
       'viewed_user' => $viewed_user,
-      'elements'    => $search_object->doSearch($this->getDoctrine(), $this->getUserId())
+      'elements'    => $search_object->getElements($this->getDoctrine(), $this->getUserId())
     );
   }
   

src/Muzich/GroupBundle/Controller/DefaultController.php

 {
   
   /**
-   * 
+   * Page listant les groupes possédés par l'utilisateur. Comporte egallement
+   * un formulaire pour ajouter un groupe.
+   *
    * @Template()
    */
   public function myListAction()
   
   /**
    * Procédure d'ajout d'un groupe
+   *
+   * @param Request $request
+   * @return redirect|template
    */
   public function addAction(Request $request)
   {
   }
   
   /**
-   * 
+   * Modification d'un groupe
+   *
    * @Template()
+   * @param Request $request
+   * @param string $slug
+   * @return array
    */
   public function editAction(Request $request, $slug)
   {
   
   public function updateAction(Request $request, $slug)
   {
-    $user = $this->getUser();
     $em = $this->getDoctrine()->getEntityManager();
+    $group = $this->findGroupWithSlug($slug);
     
-    try {
-      
-      $group = $this->getDoctrine()
-        ->getRepository('MuzichCoreBundle:Group')
-        ->findOneBySlug($slug)
-        ->getSingleResult()
-      ;
-      
-    } catch (\Doctrine\ORM\NoResultException $e) {
-        throw $this->createNotFoundException('Groupe introuvable.');
-    }
-    
-    if ($group->getOwner()->getId() != $user->getId())
+    if ($group->getOwner()->getId() != $this->getUserId())
     {
       throw $this->createNotFoundException('Vous n\'ête pas le créateur de ce groupe.');
     }
-    
+
+    // Pour être compatible avec le formulaire, la collection de tags dois être
+    // une collection d'id
     $group->setTagsToIds();
     
     $form = $this->createForm(

src/Muzich/HomeBundle/Controller/HomeController.php

    */
   public function indexAction()
   {
-    $search_object = $this->getElementSearcher($this->getUserId());
+    $search_object = $this->getElementSearcher();
     
     $search_form = $this->createForm(
       new ElementSearchForm(), 
       'user'        => $this->getUser(),
       'add_form'    => $add_form->createView(),
       'search_form' => $search_form->createView(),
-      'elements'    => $search_object->doSearch($this->getDoctrine(), $this->getUserId())
+      'elements'    => $search_object->getElements($this->getDoctrine(), $this->getUserId())
     );
   }
 }

src/Muzich/HomeBundle/Controller/ShowController.php

    * Page public de l'utilisateur demandé.
    * 
    * @Template()
+   * @param string $slug
    */
   public function showUserAction($slug)
   {
     
     return array(
       'viewed_user' => $viewed_user,
-      'elements'    => $search_object->doSearch($this->getDoctrine(), $this->getUserId()),
+      'elements'    => $search_object->getElements($this->getDoctrine(), $this->getUserId()),
       'following'   => $this->getUser()->isFollowingUserByQuery($this->getDoctrine(), $viewed_user->getId()),
       'user'        => $this->getUser()
     );
    * Page publique du groupe demandé.
    * 
    * @Template()
+   * @param string $slug
    */
   public function showGroupAction($slug)
   {
     return array(
       'group'     => $group,
       'his_group' => ($group->getOwner()->getId() == $this->getUserId()) ? true : false,
-      'elements'  => $search_object->doSearch($this->getDoctrine(), $this->getUserId()),
+      'elements'  => $search_object->getElements($this->getDoctrine(), $this->getUserId()),
       'following' => $this->getUser()->isFollowingGroupByQuery($this->getDoctrine(), $group->getId()),
       'user'      => $this->getUser()
     );

src/Muzich/MynetworkBundle/Controller/MynetworkController.php

 {
   
   /**
-   * 
+   * Page listant les personnes et groupes que l'on suit, ainsi que les 
+   * personnes qui nous duivent.
+   *
    * @Template()
    */
   public function indexAction()

src/Muzich/UserBundle/Controller/UserController.php

 class UserController extends Controller
 {
   /**
+   * Page de configuration de son compte
+   *
    * @Template()
    */
   public function accountAction()
   }
   
   /**
+   * Page ouverte après l'inscription sur laquelle on propose de saisir ses
+   * tags favoris.
    * 
    * @Template()
    */