Logiciel: Evolution #838: Base de connaissance

src/Muzich/CoreBundle/Command/MineTagsDataCommand.php

 
 use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
 use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Muzich\CoreBundle\Mining\Tag\TagMiner;
+use Doctrine\ORM\QueryBuilder;
+use Muzich\CoreBundle\Entity\User;
 
 class MineTagsDataCommand extends ContainerAwareCommand
 {
   
-  protected $sitemap_content;
-  protected $sitemap_urls;
-  protected $router;
-  protected $locales;
-  protected $siteurl_prefix;
+  const MINE_DIFFUSION = 'diffusion';
+  const MINE_FAVORITE = 'favorite';
+  const MINE_PLAYLIST = 'playlist';
+  const MINE_TAGS = 'tags';
+  const MINE_TOPS = 'tops';
+  
+  static $mine_types = array(
+    self::MINE_DIFFUSION,
+    self::MINE_FAVORITE,
+    self::MINE_PLAYLIST,
+    self::MINE_TAGS,
+    self::MINE_TOPS
+  );
+  
   protected $em;
+  protected $tag_miner;
+  protected $input;
+  protected $output;
+  protected $progress;
+  protected $users_mineds = array();
   
   protected function configure()
   {
     $this
       ->setName('mining:tags')
       ->setDescription('Mine tags data')
+      ->addOption('all', null, InputOption::VALUE_NONE, 'Selectionne tous les utilisateurs')
+      ->addOption(self::MINE_DIFFUSION, null, InputOption::VALUE_NONE, 'Ne traite que les diffusions')
+      ->addOption(self::MINE_FAVORITE, null, InputOption::VALUE_NONE, 'Ne traite que les favoris')
+      ->addOption(self::MINE_PLAYLIST, null, InputOption::VALUE_NONE, 'Ne traite que les playlists')
+      ->addOption(self::MINE_TAGS, null, InputOption::VALUE_NONE, 'Ne traite que les tags')
+      ->addOption(self::MINE_TOPS, null, InputOption::VALUE_NONE, 'Ne traite que les top tags')
     ;
   }
   
   /** @return TagMiner */
   protected function getTagMiner()
   {
-    return $this->getContainer()->get('muzich.mining.tag.miner');
+    return $this->tag_miner;
   }
   
   /** @return \Doctrine\ORM\EntityManager */
     return $this->em;
   }
 
-  protected function init()
+  protected function init(InputInterface $input, OutputInterface $output)
   {
     $this->em = $this->getContainer()->get('doctrine')->getEntityManager();
+    $this->tag_miner = $this->getContainer()->get('muzich.mining.tag.miner');
+    
+    // Experimental
+    $this->tag_miner->setLogger($this);
+    
+    $this->progress = $this->getHelperSet()->get('progress');
+    $this->input = $input;
+    $this->output = $output;
   }
   
   protected function execute(InputInterface $input, OutputInterface $output)
   {
-    $this->init();
+    $this->init($input, $output);
+    
+    if ($this->canIMineThat(self::MINE_DIFFUSION))
+      $this->mineDiffusions();
+    
+    if ($this->canIMineThat(self::MINE_FAVORITE))
+      $this->mineFavorites();
+    
+    if ($this->canIMineThat(self::MINE_PLAYLIST))
+      $this->minePlaylists();
+    
+    if ($this->canIMineThat(self::MINE_TAGS))
+      $this->mineTags();
+    
+    if ($this->canIMineThat(self::MINE_TOPS))
+      $this->mineTopTags();
+    
+    $this->output->writeln('<info>Terminé !</info>');
+  }
+  
+  /** @return QueryBuilder */
+  protected function getUserQueryBuilder()
+  {
+    $user_query_builder = $this->getEntityManager()->createQueryBuilder()
+      ->from('MuzichCoreBundle:User', 'user');
+    $this->tag_miner->adaptQueryBuilderSelectorsForUser($user_query_builder, 'user');
+    
+    return $user_query_builder;
+  }
+  
+  protected function mineDiffusions()
+  {
+    $users = $this->getUsersToProceed(User::DATA_DIFF_UPDATED);
+    $this->output->writeln('<info>Diffusions: '.count($users).' utilisateurs</info>');
+    $this->progress->start($this->output, count($users));
+    $this->getTagMiner()->mineDiffusionTagsForUsers($users);
+    $this->addUsersToUsersMineds($users);
+  }
+  
+  protected function mineFavorites()
+  {
+    $users = $this->getUsersToProceed(User::DATA_FAV_UPDATED);
+    $this->output->writeln('<info>Favoris: '.count($users).' utilisateurs</info>');
+    $this->progress->start($this->output, count($users));
+    $this->getTagMiner()->mineFavoriteTagsForUsers($users);
+    $this->addUsersToUsersMineds($users);
+  }
+  
+  protected function minePlaylists()
+  {
+    $users = $this->getUsersToProceed(User::DATA_PLAY_UPDATED);
+    $this->output->writeln('<info>Playlists: '.count($users).' utilisateurs</info>');
+    $this->progress->start($this->output, count($users));
+    $this->getTagMiner()->minePlaylistTagsForUsers($users);
+    $this->addUsersToUsersMineds($users);
+  }
+  
+  protected function mineTags()
+  {
+    $this->output->writeln('<info>Tags: '.count($this->users_mineds).' utilisateurs</info>');
+    $this->progress->start($this->output, count($this->users_mineds));
+    $this->getTagMiner()->mineTagsForUsers($this->users_mineds);
+  }
+  
+  protected function mineTopTags()
+  {
+    $this->output->writeln('<info>TopTags: '.count($this->users_mineds).' utilisateurs</info>');
+    $this->progress->start($this->output, count($this->users_mineds));
+    $this->getTagMiner()->mineTopTagsForUsers($this->users_mineds);
+  }
+  
+  protected function getUsersToProceed($condition)
+  {
+    $users_query_builder = $this->getUserQueryBuilder();
+    if (!$this->input->getOption('all'))
+    {
+      $users_query_builder->andWhere('user.datas NOT LIKE :condition OR user.datas IS NULL');
+      $users_query_builder->setParameter('condition', '%"'.$condition.'":false%');
+    }
     
-    $tag_miner = $this->getTagMiner();
-    $user_query_builder = $this->getEntityManager()->createQueryBuilder()->from('MuzichCoreBundle:User', 'user');
-    $tag_miner->adaptQueryBuilderSelectorsForUser($user_query_builder, 'user');
-    // $user_query_builder->where en fonction des inputes etc
-    $this->getTagMiner()->mineTagsForUsers($user_query_builder->getQuery()->getResult());
+    return $users_query_builder->getQuery()->getResult();
+  }
+  
+  protected function canIMineThat($mine_type_asked)
+  {
+    $mine_type_specified = false;
+    foreach (self::$mine_types as $mine_type)
+    {
+      if ($this->input->getOption($mine_type))
+        $mine_type_specified = true;
+    }
     
-    $output->writeln('<info>Terminé !</info>');
+    if (!$mine_type_specified)
+      return true;
+    
+    if ($this->input->getOption($mine_type_asked))
+      return true;
+    
+    return false;
+  }
+  
+  public function logUserProceed()
+  {
+    $this->progress->advance();
+  }
+  
+  public function logSavingInDatabase()
+  {
+    $this->output->writeln('');
+    $this->output->writeln('<info>Saving in database ...</info>');
+  }
+  
+  protected function addUsersToUsersMineds($users_to_add)
+  {
+    foreach ($users_to_add as $user_to_add)
+    {
+      $found = false;
+      foreach ($this->users_mineds as $user_mined)
+      {
+        if ($user_mined->getId() == $user_to_add->getId())
+          $found = true;
+      }
+      
+      if (!$found)
+        $this->users_mineds[] = $user_to_add;
+    }
   }
   
 }

src/Muzich/CoreBundle/Command/TagOrderCommand.php

-<?php
-
-namespace Muzich\CoreBundle\Command;
-
-use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
-use Symfony\Component\Console\Input\InputArgument;
-use Symfony\Component\Console\Input\InputInterface;
-use Symfony\Component\Console\Input\InputOption;
-use Symfony\Component\Console\Output\OutputInterface;
-
-use Muzich\CoreBundle\Entity\User;
-use Muzich\CoreBundle\Searcher\ElementSearcher;
-use Muzich\CoreBundle\lib\Tag as TagLib;
-
-class TagOrderCommand extends ContainerAwareCommand
-{
-  protected function configure()
-  {
-    $this
-      ->setName('tagengine:order')
-      ->setDescription('Ordonne la liste des tags sur les pages utilisateurs')
-      ->addOption('force', null, InputOption::VALUE_NONE, 'Forcer les opérations sur tous les utilisateurs')
-    ;
-  }
-  
-  protected function execute(InputInterface $input, OutputInterface $output)
-  {
-    $doctrine = $this->getContainer()->get('doctrine');
-    $em = $doctrine->getEntityManager();
-    $tag_lib = new TagLib();
-
-    $output->writeln('#');
-    $output->writeln('## Script d\'ordonance des listes de tags sur les pages'
-      .' utilisateurs ##');
-    $output->writeln('#');
-
-    // Premier point on récupère les utilisateurs qui ont mis a jour leurs 
-    // favoris
-    $output->writeln('<info>Gestion de l\'ordre des tags sur les pages de '
-      .'partages favoris</info>');
- 
-    if ($input->getOption('force'))
-    {
-      $users = $em->createQuery("SELECT u FROM MuzichCoreBundle:User u")
-        ->getResult()
-      ;
-    }
-    else
-    {
-      $users = $em->createQuery(
-          "SELECT u FROM MuzichCoreBundle:User u"
-          . " WHERE u.datas LIKE :favupd"
-        )->setParameter('favupd', '%"'.User::DATA_FAV_UPDATED.'":true%')
-        ->getResult()
-      ;
-    }
-    
-    if (count($users))
-    {
-      $output->writeln('<info>Traitement de '.count($users).' utilisateurs</info>');
-      foreach ($users as $user)
-      {
-        // On récupère ses éléments favoris
-        $search_object = new ElementSearcher();
-        $search_object->init(array(
-          'user_id'  => $user->getId(),
-          'favorite' => true
-        ));
-        $elements_favorite = $search_object->getElements($doctrine, $user->getId());
-        
-        // On récupère la nouvelle liste de tags ordonnés
-        $tags_ordered = $tag_lib->getOrderedTagsWithElements($elements_favorite);
-        // On enregistre ça en base
-        $user->setData(User::DATA_TAGS_ORDER_PAGE_FAV, $tags_ordered);
-        $user->setData(User::DATA_FAV_UPDATED, false);
-        $em->persist($user);
-        $em->flush();
-      }
-    
-    }
-    else
-    {
-      $output->writeln('<info>Aucun utilisateur a traiter</info>');
-    }
-    
-    // Deuxième point on récupère les utilisateurs qui ont mis a jour leurs 
-    // diffusion
-    $output->writeln('<info>Gestion de l\'ordre des tags sur les diffusions</info>');
- 
-    if ($input->getOption('force'))
-    {
-      $users = $em->createQuery("SELECT u FROM MuzichCoreBundle:User u")
-        ->getResult()
-      ;
-    }
-    else
-    {
-      $users = $em->createQuery(
-          "SELECT u FROM MuzichCoreBundle:User u"
-          . " WHERE u.datas LIKE :favupd"
-        )->setParameter('favupd', '%"'.User::DATA_DIFF_UPDATED.'":true%')
-        ->getResult()
-      ;
-    }
-    
-    if (count($users))
-    {
-      $output->writeln('<info>Traitement de '.count($users).' utilisateurs</info>');
-      foreach ($users as $user)
-      {
-        // On récupère ses éléments diffusés
-        $search_object = new ElementSearcher();
-        $search_object->init(array(
-          'user_id'  => $user->getId()
-        ));
-        $elements_diffused = $search_object->getElements($doctrine, $user->getId());
-        
-        // On récupère la nouvelle liste de tags ordonnés
-        $tags_ordered = $tag_lib->getOrderedTagsWithElements($elements_diffused);
-        // On enregistre ça en base
-        $user->setData(User::DATA_TAGS_ORDER_DIFF, $tags_ordered);
-        $user->setData(User::DATA_DIFF_UPDATED, false);
-        $em->persist($user);
-        $em->flush();
-      }
-    
-    }
-    else
-    {
-      $output->writeln('<info>Aucun utilisateur a traiter</info>');
-    }
-    
-    $output->writeln('<info>Terminé !</info>');
-  }
-}

src/Muzich/CoreBundle/Controller/ElementController.php

       $em->persist($element->getOwner());
       $em->remove($element);
       
-      /**
-      * Bug lors des tests: L'user n'est pas 'lié' a celui en base par doctrine.
-      * Docrine le voit si on faire une requete directe.
-      */
       $user = $this->getUser();
       
       // On signale que cet user a modifié ses diffusions

src/Muzich/CoreBundle/Document/UserTags.php

 {
 
   /**
-   * @MongoDB\Hash
+   * @MongoDB\Collection
    */
   protected $element_diffusion_tags;
 
   /**
-   * @MongoDB\Hash
+   * @MongoDB\Collection
    */
   protected $element_favorite_tags;
 
   /**
-   * @MongoDB\Hash
+   * @MongoDB\Collection
    */
   protected $element_playlist_tags;
   
   public function getElementDiffusionTags()
   {
+    if (!$this->element_diffusion_tags)
+      return array();
+      
     return $this->element_diffusion_tags;
   }
   
   
   public function getElementFavoriteTags()
   {
+    if (!$this->element_favorite_tags)
+      return array();
+      
     return $this->element_favorite_tags;
   }
   
   
   public function getElementPlaylistTags()
   {
+    if (!$this->element_playlist_tags)
+      return array();
+      
     return $this->element_playlist_tags;
   }
   

src/Muzich/CoreBundle/Entity/User.php

 class User extends BaseUser
 {
   
-  /**
-   * Data ordre des tags de sa page favoris
-   * @var string 
-   */
-  const DATA_TAGS_ORDER_PAGE_FAV = "data_tags_order_page_fav";
-  
-  /**
-   * Data ordre des tags de ses diffusions
-   * @var string 
-   */
-  const DATA_TAGS_ORDER_DIFF     = "data_tags_order_diff";
-  
-  /**
-   * Data, les favoris ont ils été modifiés
-   * @var string 
-   */
-  const DATA_FAV_UPDATED         = "data_fav_updated";
-  
-  /**
-   * Data, les favoris ont ils été modifiés
-   * @var string 
-   */
-  const DATA_DIFF_UPDATED        = "data_diff_updated";
+  const DATA_FAV_UPDATED = "data_fav_updated";
+  const DATA_DIFF_UPDATED = "data_diff_updated";
+  const DATA_PLAY_UPDATED = "data_play_updated";
   
   const HELP_TOUR_HOME = "home";
   
     return $privacy_manager->set(PrivacyManager::CONF_FAVORITES_PUBLIC, $public);
   }
   
+  public function setDataFavoriteNoMoreUpdated()
+  {
+    $this->setData(self::DATA_FAV_UPDATED, false);
+  }
+  
+  public function setDataDiffusionsNoMoreUpdated()
+  {
+    $this->setData(self::DATA_DIFF_UPDATED, false);
+  }
+  
+  public function setDataPlaylistNoMoreUpdated()
+  {
+    $this->setData(self::DATA_PLAY_UPDATED, false);
+  }
+  
 }

src/Muzich/CoreBundle/Mining/Tag/Tag.php

+<?php
+namespace Muzich\CoreBundle\Mining\Tag;
+
+use Doctrine\ORM\EntityManager;
+use Doctrine\Bundle\MongoDBBundle\ManagerRegistry as MongoManagerRegistry;
+use Doctrine\ODM\MongoDB\DocumentRepository;
+use Doctrine\ODM\MongoDB\DocumentManager;
+
+class Tag
+{
+  
+  protected $doctrine_entity_manager;
+  protected $mongo_manager_registry;
+  
+  public function __construct(EntityManager $doctrine_entity_manager, MongoManagerRegistry $mongo_manager_registry)
+  {
+    $this->doctrine_entity_manager = $doctrine_entity_manager;
+    $this->mongo_manager_registry = $mongo_manager_registry;
+  }
+  
+  /** @return EntityManager */
+  protected function getDoctrineEntityManager()
+  {
+    return $this->doctrine_entity_manager;
+  }
+  
+  /** @return DocumentRepository */
+  protected function getMongoRepository($repository)
+  {
+    return $this->mongo_manager_registry->getRepository($repository);
+  }
+  
+  /** @return DocumentManager */
+  protected function getMongoManager()
+  {
+    return $this->mongo_manager_registry->getManager();
+  }
+  
+}

src/Muzich/CoreBundle/Mining/Tag/TagData.php

+<?php
+namespace Muzich\CoreBundle\Mining\Tag;
+
+use Muzich\CoreBundle\Mining\Tag\Tag as Base;
+use Muzich\CoreBundle\Entity\User;
+
+class TagData extends Base
+{
+  
+  public function getTagOrderForFavorites(User $user)
+  {
+    $user_tags = $this->getUserTagsTags($user, 'element_favorite_tags');
+    
+   if (count($tags_ordereds = $user_tags->getElementFavoriteTags()))
+     return $tags_ordereds;
+   
+   return array();
+  }
+  
+  public function getTagOrderForDiffusions(User $user)
+  {
+    $user_tags = $this->getUserTagsTags($user, 'element_diffusion_tags');
+    
+   if (count($tags_ordereds = $user_tags->getElementDiffusionTags()))
+     return $tags_ordereds;
+   
+   return array();
+  }
+  
+  protected function getUserTagsTags(User $user, $field)
+  {
+    return $this->getMongoManager()->createQueryBuilder('MuzichCoreBundle:UserTags')
+      ->select($field)
+      ->field('ref')->equals((int)$user->getId())
+      ->getQuery()->getSingleResult()
+    ;
+  }
+  
+}

src/Muzich/CoreBundle/Mining/Tag/TagMiner.php

 
 use Doctrine\ORM\EntityManager;
 use Doctrine\Bundle\MongoDBBundle\ManagerRegistry as MongoManagerRegistry;
-use Doctrine\ODM\MongoDB\DocumentRepository;
-use Doctrine\ODM\MongoDB\DocumentManager;
 use Muzich\CoreBundle\Document\EntityTags;
 use Muzich\CoreBundle\Document\UserTags;
 use Muzich\CoreBundle\Document\GroupTags;
 use Muzich\CoreBundle\Entity\User;
 use Muzich\CoreBundle\Managers\PlaylistManager;
 
-class TagMiner
+use Muzich\CoreBundle\Mining\Tag\Tag as Base;
+
+class TagMiner extends Base
 {
   
-  protected $doctrine_entity_manager;
-  protected $mongo_manager_registry;
   protected $tag_scorer;
   protected $tag_orderer;
+  protected $logger_parent;
   
   public function __construct(EntityManager $doctrine_entity_manager, MongoManagerRegistry $mongo_manager_registry)
   {
-    $this->doctrine_entity_manager = $doctrine_entity_manager;
-    $this->mongo_manager_registry = $mongo_manager_registry;
+    parent::__construct($doctrine_entity_manager, $mongo_manager_registry);
     $this->tag_scorer = new TagScorer();
     $this->tag_orderer = new TagOrderer();
   }
   
-  /** @return EntityManager */
-  protected function getDoctrineEntityManager()
-  {
-    return $this->doctrine_entity_manager;
-  }
-  
-  /** @return DocumentRepository */
-  protected function getMongoRepository($repository)
-  {
-    return $this->mongo_manager_registry->getRepository($repository);
-  }
-  
-  /** @return DocumentManager */
-  protected function getMongoManager()
-  {
-    return $this->mongo_manager_registry->getManager();
-  }
-  
   /** @return TagScorer */
   protected function getTagsScorer()
   {
     return $this->tag_orderer;
   }
   
+  // Experimental
+  public function setLogger($parent)
+  {
+    $this->logger_parent = $parent;
+  }
+  
+  // Experimental
+  protected function log($action_name)
+  {
+    $action_name_complete = 'log'.ucfirst($action_name);
+    
+    if ($this->logger_parent)
+      $this->logger_parent->$action_name_complete();
+  }
+  
   /** 
    * @param QueryBuilder $query_builder
    * @param string $user_alias
   /**
    * @param array $users
    */
-  public function mineTagsForUsers($users)
+  public function mineForUsers($users, $mining_action, $user_action = null)
   {
-    foreach ($users as $user)
+    if (count($users))
     {
-      $user_tags = $this->getEntityTagsDocument($user->getId(), EntityTags::TYPE_USER);
-      
-      $this->scoreUserDiffusionsTags($user_tags, $user);
-      $this->scoreUserFavoritesTags($user_tags, $user);
-      $this->scoreUserPlaylistsTags($user_tags, $user);
-      $this->scoreUserTags($user_tags, $user);
-      $this->determineTagsTops($user_tags);
+      foreach ($users as $user)
+      {
+        $user_tags = $this->getEntityTagsDocument($user->getId(), EntityTags::TYPE_USER);
+
+        $this->log('userProceed');
+        $this->$mining_action($user_tags, $user);
+        if ($user_action)
+          $user->$user_action();
+
+        $this->getMongoManager()->persist($user_tags);
+        $this->getDoctrineEntityManager()->persist($user);
+      }
       
-      $this->getMongoManager()->persist($user_tags);
+      $this->log('savingInDatabase');
+      $this->getMongoManager()->flush();
+      $this->getDoctrineEntityManager()->flush();
     }
-    
-    $this->getMongoManager()->flush();
+  }
+  
+  public function mineDiffusionTagsForUsers($users)
+  {
+    $this->mineForUsers($users, 'orderUserDiffusionsTags', 'setDataDiffusionsNoMoreUpdated');
+  }
+  
+  public function mineFavoriteTagsForUsers($users)
+  {
+    $this->mineForUsers($users, 'orderUserFavoritesTags', 'setDataFavoriteNoMoreUpdated');
+  }
+  
+  public function minePlaylistTagsForUsers($users)
+  {
+    $this->mineForUsers($users, 'orderUserPlaylistsTags', 'setDataPlaylistNoMoreUpdated');
+  }
+  
+  public function mineTagsForUsers($users)
+  {
+    $this->mineForUsers($users, 'orderUserTags');
+  }
+  
+  public function mineTopTagsForUsers($users)
+  {
+    $this->mineForUsers($users, 'determineTagsTops');
   }
   
   /** @return EntityTags */
     }
   }
   
-  protected function scoreUserDiffusionsTags(EntityTags $user_tags, User $user)
+  protected function orderUserDiffusionsTags(EntityTags $user_tags, User $user)
   {
     $tags_ids_ordereds = $this->getTagOrderer()->getOrderedTagsWithElements($user->getElements());
-    $scoreds_tags_ids = $this->getTagsScorer()->scoreOrderedsTagsIds($tags_ids_ordereds);
-    $user_tags->setElementDiffusionTags($scoreds_tags_ids);
+    $user_tags->setElementDiffusionTags($tags_ids_ordereds);
   }
   
-  protected function scoreUserFavoritesTags(EntityTags $user_tags, User $user)
+  protected function orderUserFavoritesTags(EntityTags $user_tags, User $user)
   {
     $tags_ids_ordereds = $this->getTagOrderer()->getOrderedTagsWithElements($user->getElementsFavoritesElements());
-    $scoreds_tags_ids = $this->getTagsScorer()->scoreOrderedsTagsIds($tags_ids_ordereds);
-    $user_tags->setElementFavoriteTags($scoreds_tags_ids);
+    $user_tags->setElementFavoriteTags($tags_ids_ordereds);
   }
   
-  protected function scoreUserPlaylistsTags(EntityTags $user_tags, User $user)
+  protected function orderUserPlaylistsTags(EntityTags $user_tags, User $user)
   {
     $playlist_manager = new PlaylistManager($this->getDoctrineEntityManager());
     $tags_ids_ordereds = $this->getTagOrderer()->getOrderedTagsWithElements($playlist_manager->getElementsOfPlaylists($this->getUserPlaylists($user)));
-    $scoreds_tags_ids = $this->getTagsScorer()->scoreOrderedsTagsIds($tags_ids_ordereds);
-    $user_tags->setElementPlaylistTags($scoreds_tags_ids);
+    $user_tags->setElementPlaylistTags($tags_ids_ordereds);
   }
   
   protected function getUserPlaylists(User $user)
     return $playlists;
   }
   
-  protected function scoreUserTags(EntityTags $user_tags, User $user)
+  protected function orderUserTags(EntityTags $user_tags, User $user)
   {
     $all_tags_ordered = $this->getTagsScorer()->scoreEntireOrderedTagsIds(array(
       $user_tags->getElementDiffusionTags(),
     $user_tags->setTagsAll($all_tags_ordered);
   }
   
-  protected function determineTagsTops(EntityTags $user_tags)
+  protected function determineTagsTops(EntityTags $user_tags, User $user)
   {
     $user_tags->setTagsTop1($this->getTopTagsRange($user_tags->getTagsAll(), 1));
     $user_tags->setTagsTop2($this->getTopTagsRange($user_tags->getTagsAll(), 2));

src/Muzich/CoreBundle/lib/Controller.php

     return $this->getDoctrine()->getManager();
   }
   
+  /** @return Doctrine\ODM\MongoDB\DocumentManager */
+  public function getMongoManager()
+  {
+    return $this->get('doctrine_mongodb')->getManager();
+  }
+  
+  /** @return Doctrine\ODM\MongoDB\DocumentRepository */
+  public function getMongoRepository($repository)
+  {
+    return $this->get('doctrine_mongodb')->getRepository($repository);
+  }
+  
   /**
    *
    * @param object $entity 
     return $this->container->get('muzich_user_manager');
   }
   
+  /** @return \Muzich\CoreBundle\Mining\Tag\TagMiner */
+  protected function getMineTagMiner()
+  {
+    return $this->container->get('muzich.mining.tag.miner');
+  }
+  
+  /** @return \Muzich\CoreBundle\Mining\Tag\TagData */
+  protected function getMineTagData()
+  {
+    return $this->container->get('muzich.mining.tag.data');
+  }
+  
 }

src/Muzich/CoreBundle/lib/TagScorer.php

 class TagScorer
 {
   
-  public function scoreOrderedsTagsIds($ordered_tags)
+  protected function scoreOrderedsTagsIds($ordered_tags)
   {
     $tags_ordered_by_score = array();
     $score_max = count($ordered_tags);
     
     foreach ($ordereds_elements_tags_ids as $ordereds_tags_ids)
     {
-      foreach ($ordereds_tags_ids as $score_tag => $tag_id)
+      $scored_tags_ids = $this->scoreOrderedsTagsIds($ordereds_tags_ids);
+      foreach ($scored_tags_ids as $score_tag => $tag_id)
       {
         if (!array_key_exists($tag_id, $tags_score))
           $tags_score[$tag_id] = 0;

src/Muzich/FavoriteBundle/Controller/FavoriteController.php

     
     // Organisation des tags en fonction de leurs utilisation
     $tag_lib = new TagLib();
-    $tags = $tag_lib->sortTagWithOrderedReference($tags, 
-      $user->getData(User::DATA_TAGS_ORDER_PAGE_FAV, array()));
+    $tags = $tag_lib->sortTagWithOrderedReference($tags, $this->getMineTagData()->getTagOrderForFavorites($user));
     
     $tags_id = array();
     foreach ($tags as $tag)
         ->getTags($viewed_user->getId(), $this->getUserId(true))      
       ;
 
+      $tag_lib = new TagLib();
+      $tags = $tag_lib->sortTagWithOrderedReference($tags, $this->getMineTagData()->getTagOrderForFavorites($viewed_user));
+      
       $tags_id = array();
       foreach ($tags as $tag)
       {

src/Muzich/HomeBundle/Controller/ShowController.php

     
     // Organisation des tags en fonction de leurs utilisation
     $tag_lib = new TagLib();
-    $tags = $tag_lib->sortTagWithOrderedReference($tags, 
-    $viewed_user->getData(User::DATA_TAGS_ORDER_DIFF, array()));
+    $tags = $tag_lib->sortTagWithOrderedReference($tags, $this->getMineTagData()->getTagOrderForDiffusions($viewed_user));
     
     $tags_id = array();
     foreach ($tags as $tag)

src/Muzich/PlaylistBundle/Controller/EditController.php

 use Muzich\CoreBundle\Propagator\EventElement;
 use Muzich\CoreBundle\Form\Playlist\PrivateLinksForm;
 use Muzich\CoreBundle\Entity\Playlist;
+use Muzich\CoreBundle\Entity\User;
 
 class EditController extends Controller
 {
       return $this->jsonNotFoundResponse();
     
     $playlist_manager->removePlaylistElementWithIndex($playlist, $index);
+    $this->getUser()->setData(User::DATA_PLAY_UPDATED, true);
     
     $event = new EventElement($this->container);
     $event->removedFromPlaylist($element, $this->getUser(), $playlist);
       return $this->jsonNotFoundResponse();
     
     $playlist_manager->addElementToPlaylist($element, $playlist);
+    $this->getUser()->setData(User::DATA_PLAY_UPDATED, true);
     
     $event = new EventElement($this->container);
     $event->addedToPlaylist($element, $this->getUser(), $playlist);
       
       $event = new EventElement($this->container);
       $event->addedToPlaylist($element, $this->getUser(), $form->getData());
+      $this->getUser()->setData(User::DATA_PLAY_UPDATED, true);
 
       $this->persist($element);
       $this->flush();
     
     $event = new EventElement($this->container);
     $event->addedToPlaylist($element, $this->getUser(), $new_playlist);
+    $this->getUser()->setData(User::DATA_PLAY_UPDATED, true);
     
     $this->persist($element);
     $this->flush();
       throw $this->createNotFoundException();
     
     $this->getPlaylistManager()->deletePlaylist($playlist);
+    $this->getUser()->setData(User::DATA_PLAY_UPDATED, true);
     $this->flush();
     $this->setFlash('success', 'playlist.delete.success');
     
       throw $this->createNotFoundException();
     
     $playlist_manager->removePickedPlaylistToUser($this->getUser(), $playlist);
+    $this->getUser()->setData(User::DATA_PLAY_UPDATED, true);
     $this->flush();
     $this->setFlash('success', 'playlist.delete.success');
     
       throw $this->createNotFoundException();
     }
     $this->getPlaylistManager()->addPickedPlaylistToUser($this->getUser(), $playlist);
+    $this->getUser()->setData(User::DATA_PLAY_UPDATED, true);
     $this->flush();
     
     if ($this->getRequest()->isXmlHttpRequest())
       if ($playlist_form->isValid())
       {
         $this->persist($playlist_form->getData());
+        $this->getUser()->setData(User::DATA_PLAY_UPDATED, true);
         $this->flush();
         
         $this->setFlash('success', $this->trans('playlist.create.success', array(), 'flash'));