Merge branch 'feature/v0.9.8.2/mining' into stable/v0.9.8.2

app/AppKernel.php

             new WhiteOctober\PagerfantaBundle\WhiteOctoberPagerfantaBundle(),
             new Shtumi\UsefulBundle\ShtumiUsefulBundle(),
             new FOS\FacebookBundle\FOSFacebookBundle(),
+            new Doctrine\Bundle\MongoDBBundle\DoctrineMongoDBBundle(),
             
             new Muzich\CoreBundle\MuzichCoreBundle(),
             new Muzich\UserBundle\MuzichUserBundle(),

app/autoload.php

 <?php
 
 use Doctrine\Common\Annotations\AnnotationRegistry;
+use Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver;
 
 $loader = include __DIR__.'/../vendor/autoload.php';
 
 }
 
 AnnotationRegistry::registerLoader(array($loader, 'loadClass'));
+AnnotationDriver::registerAnnotationClasses();
 
 return $loader;

app/bootstrap.php.cache

 protected $startTime;
 protected $classes;
 protected $errorReportingLevel;
-const VERSION ='2.2.3';
-const VERSION_ID ='20203';
+const VERSION ='2.2.4';
+const VERSION_ID ='20204';
 const MAJOR_VERSION ='2';
 const MINOR_VERSION ='2';
-const RELEASE_VERSION ='3';
+const RELEASE_VERSION ='4';
 const EXTRA_VERSION ='';
 public function __construct($environment, $debug)
 {

composer.json

     },
     "require": {
         "php": ">=5.3.3",
-        "symfony/symfony": "v2.2.3",
+        "symfony/symfony": "v2.2.4",
         "doctrine/orm": "2.3.4",
         "doctrine/doctrine-bundle": "v1.2.0",
         "twig/extensions": "1.0.*@dev",
         "sonata-project/admin-bundle": "2.2.2",
         "sonata-project/jquery-bundle": "1.8.*@dev",
         "sonata-project/block-bundle": "2.2.3",
-        "friendsofsymfony/facebook-bundle": "dev-master"
+        "friendsofsymfony/facebook-bundle": "dev-master",
+        
+        "doctrine/mongodb-odm-bundle": "v3.0.0-BETA4",
+        "doctrine/mongodb-odm": "1.0.0-BETA9",
+        "symfony/options-resolver": "v2.2.4",
+        "symfony/doctrine-bridge": "v2.2.4",
+        "doctrine/mongodb": "1.0.0-BETA1"
+        
+        
     },
     "scripts": {
         "post-install-cmd": [

composer.lock

         "This file locks the dependencies of your project to a known state",
         "Read more about it at http://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file"
     ],
-    "hash": "0a6ed902bb57e0f8c4f106273cf613f0",
+    "hash": "66af7e69e293a353ab3fb2c45f07a831",
     "packages": [
         {
             "name": "cedriclombardot/admingenerator-generator-bundle",
             "source": {
                 "type": "git",
                 "url": "https://github.com/doctrine/data-fixtures.git",
-                "reference": "6924952026b77ff492da559b04ad166d25c611cb"
+                "reference": "b4a135c7db56ecc4602b54a2184368f440cac33e"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/doctrine/data-fixtures/zipball/6924952026b77ff492da559b04ad166d25c611cb",
-                "reference": "6924952026b77ff492da559b04ad166d25c611cb",
+                "url": "https://api.github.com/repos/doctrine/data-fixtures/zipball/b4a135c7db56ecc4602b54a2184368f440cac33e",
+                "reference": "b4a135c7db56ecc4602b54a2184368f440cac33e",
                 "shasum": ""
             },
             "require": {
             "keywords": [
                 "database"
             ],
-            "time": "2013-04-11 23:14:04"
+            "time": "2013-07-10 17:04:07"
         },
         {
             "name": "doctrine/dbal",
             "source": {
                 "type": "git",
                 "url": "https://github.com/doctrine/DoctrineFixturesBundle.git",
-                "reference": "512fc0fa1d0ce7bdcc6a0a91812eb531f20e0828"
+                "reference": "8070624b47f7f171db4c9e4134436db7de51244c"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/doctrine/DoctrineFixturesBundle/zipball/512fc0fa1d0ce7bdcc6a0a91812eb531f20e0828",
-                "reference": "512fc0fa1d0ce7bdcc6a0a91812eb531f20e0828",
+                "url": "https://api.github.com/repos/doctrine/DoctrineFixturesBundle/zipball/8070624b47f7f171db4c9e4134436db7de51244c",
+                "reference": "8070624b47f7f171db4c9e4134436db7de51244c",
                 "shasum": ""
             },
             "require": {
                 "Fixture",
                 "persistence"
             ],
-            "time": "2013-06-21 10:31:45"
+            "time": "2013-07-18 09:26:47"
+        },
+        {
+            "name": "doctrine/mongodb",
+            "version": "1.0.0-BETA1",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/doctrine/mongodb.git",
+                "reference": "1.0.0-BETA1"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/doctrine/mongodb/zipball/1.0.0-BETA1",
+                "reference": "1.0.0-BETA1",
+                "shasum": ""
+            },
+            "require": {
+                "doctrine/common": ">=2.1.0",
+                "ext-mongo": "*",
+                "php": ">=5.3.2",
+                "symfony/console": ">=2.0",
+                "symfony/yaml": ">=2.0"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-0": {
+                    "Doctrine\\MongoDB": "lib/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Bulat Shakirzyanov",
+                    "email": "mallluhuct@gmail.com",
+                    "homepage": "http://avalanche123.com"
+                },
+                {
+                    "name": "Jonathan H. Wage",
+                    "email": "jonwage@gmail.com",
+                    "homepage": "http://www.jwage.com/"
+                },
+                {
+                    "name": "Kris Wallsmith",
+                    "email": "kris.wallsmith@gmail.com",
+                    "homepage": "http://kriswallsmith.net/"
+                }
+            ],
+            "description": "Doctrine MongoDB Abstraction Layer",
+            "homepage": "http://www.doctrine-project.org",
+            "keywords": [
+                "mongodb",
+                "persistence"
+            ],
+            "time": "2012-08-02 18:00:59"
+        },
+        {
+            "name": "doctrine/mongodb-odm",
+            "version": "1.0.0-BETA9",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/doctrine/mongodb-odm.git",
+                "reference": "1.0.0-BETA9"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/doctrine/mongodb-odm/zipball/1.0.0-BETA9",
+                "reference": "1.0.0-BETA9",
+                "shasum": ""
+            },
+            "require": {
+                "doctrine/common": ">=2.2.0,<2.5-dev",
+                "doctrine/mongodb": "1.0.*",
+                "php": ">=5.3.2",
+                "symfony/console": ">=2.0,<3.0"
+            },
+            "require-dev": {
+                "symfony/yaml": ">=2.0,<3.0"
+            },
+            "suggest": {
+                "symfony/yaml": "Enables the YAML metadata mapping driver"
+            },
+            "type": "library",
+            "extra": {
+                "branch-alias": {
+                    "dev-master": "1.0.x-dev"
+                }
+            },
+            "autoload": {
+                "psr-0": {
+                    "Doctrine\\ODM\\MongoDB": "lib/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Bulat Shakirzyanov",
+                    "email": "mallluhuct@gmail.com",
+                    "homepage": "http://avalanche123.com"
+                },
+                {
+                    "name": "Jonathan H. Wage",
+                    "email": "jonwage@gmail.com",
+                    "homepage": "http://www.jwage.com/"
+                },
+                {
+                    "name": "Kris Wallsmith",
+                    "email": "kris.wallsmith@gmail.com",
+                    "homepage": "http://kriswallsmith.net/"
+                },
+                {
+                    "name": "Jeremy Mikola",
+                    "email": "jmikola@gmail.com",
+                    "homepage": "http://jmikola.net"
+                }
+            ],
+            "description": "Doctrine MongoDB Object Document Mapper",
+            "homepage": "http://www.doctrine-project.org",
+            "keywords": [
+                "database",
+                "mongodb",
+                "odm",
+                "persistence"
+            ],
+            "time": "2013-06-06 19:15:45"
+        },
+        {
+            "name": "doctrine/mongodb-odm-bundle",
+            "version": "v3.0.0-BETA4",
+            "target-dir": "Doctrine/Bundle/MongoDBBundle",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/doctrine/DoctrineMongoDBBundle.git",
+                "reference": "v3.0.0-BETA4"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/doctrine/DoctrineMongoDBBundle/zipball/v3.0.0-BETA4",
+                "reference": "v3.0.0-BETA4",
+                "shasum": ""
+            },
+            "require": {
+                "doctrine/mongodb-odm": ">=1.0-beta5,<1.1",
+                "php": ">=5.3.2",
+                "symfony/doctrine-bridge": ">=2.1,<2.3-dev",
+                "symfony/framework-bundle": ">=2.1,<2.3-dev",
+                "symfony/options-resolver": ">=2.1,<2.3-dev"
+            },
+            "require-dev": {
+                "doctrine/data-fixtures": "@dev",
+                "symfony/form": ">=2.1,<2.3-dev",
+                "symfony/yaml": ">=2.1,<2.3-dev"
+            },
+            "suggest": {
+                "doctrine/data-fixtures": "Load data fixtures"
+            },
+            "type": "symfony-bundle",
+            "extra": {
+                "branch-alias": {
+                    "dev-master": "3.0-dev"
+                }
+            },
+            "autoload": {
+                "psr-0": {
+                    "Doctrine\\Bundle\\MongoDBBundle": ""
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Bulat Shakirzyanov",
+                    "email": "mallluhuct@gmail.com",
+                    "homepage": "http://avalanche123.com"
+                },
+                {
+                    "name": "Jonathan H. Wage",
+                    "email": "jonwage@gmail.com",
+                    "homepage": "http://www.jwage.com/"
+                },
+                {
+                    "name": "Kris Wallsmith",
+                    "email": "kris@symfony.com"
+                }
+            ],
+            "description": "Symfony2 Doctrine MongoDB Bundle",
+            "homepage": "http://www.doctrine-project.org",
+            "keywords": [
+                "mongodb",
+                "persistence",
+                "symfony"
+            ],
+            "time": "2013-03-18 18:12:08"
         },
         {
             "name": "doctrine/orm",
             "source": {
                 "type": "git",
                 "url": "https://github.com/Gregwar/ImageBundle.git",
-                "reference": "ae746b296768cc63c7f3478446dc5bf5d36812d4"
+                "reference": "c0f86ad2095e084bb899d22304581d14c02d3da6"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/Gregwar/ImageBundle/zipball/ae746b296768cc63c7f3478446dc5bf5d36812d4",
-                "reference": "ae746b296768cc63c7f3478446dc5bf5d36812d4",
+                "url": "https://api.github.com/repos/Gregwar/ImageBundle/zipball/c0f86ad2095e084bb899d22304581d14c02d3da6",
+                "reference": "c0f86ad2095e084bb899d22304581d14c02d3da6",
                 "shasum": ""
             },
             "require": {
                 "Symfony2",
                 "image"
             ],
-            "time": "2013-06-02 20:38:56"
+            "time": "2013-07-23 15:16:28"
         },
         {
             "name": "jdorn/sql-formatter",
                 {
                     "name": "Johannes M. Schmitt",
                     "email": "schmittjoh@gmail.com",
-                    "homepage": "https://github.com/schmittjoh",
+                    "homepage": "http://jmsyst.com",
                     "role": "Developer of wrapped JMSSerializerBundle"
                 }
             ],
                 {
                     "name": "Johannes M. Schmitt",
                     "email": "schmittjoh@gmail.com",
-                    "homepage": "https://github.com/schmittjoh",
+                    "homepage": "http://jmsyst.com",
                     "role": "Developer of wrapped JMSSerializerBundle"
                 }
             ],
                 {
                     "name": "Johannes M. Schmitt",
                     "email": "schmittjoh@gmail.com",
-                    "homepage": "https://github.com/schmittjoh",
+                    "homepage": "http://jmsyst.com",
                     "role": "Developer of wrapped JMSSerializerBundle"
                 }
             ],
         },
         {
             "name": "monolog/monolog",
-            "version": "1.5.0",
+            "version": "1.6.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/Seldaek/monolog.git",
-                "reference": "1.5.0"
+                "reference": "1.6.0"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/Seldaek/monolog/zipball/1.5.0",
-                "reference": "1.5.0",
+                "url": "https://api.github.com/repos/Seldaek/monolog/zipball/1.6.0",
+                "reference": "1.6.0",
                 "shasum": ""
             },
             "require": {
                 "php": ">=5.3.0",
-                "psr/log": ">=1.0,<2.0"
+                "psr/log": "~1.0"
             },
             "require-dev": {
                 "doctrine/couchdb": "dev-master",
                 "mlehner/gelf-php": "1.0.*",
-                "raven/raven": "0.3.*"
+                "raven/raven": "0.5.*"
             },
             "suggest": {
                 "doctrine/couchdb": "Allow sending log messages to a CouchDB server",
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "1.4.x-dev"
+                    "dev-master": "1.6.x-dev"
                 }
             },
             "autoload": {
                 "logging",
                 "psr-3"
             ],
-            "time": "2013-04-23 10:09:48"
+            "time": "2013-07-28 22:38:30"
         },
         {
             "name": "pagerfanta/pagerfanta",
                 "doctrine/mongodb-odm": "*",
                 "doctrine/orm": "2.*",
                 "mandango/mandango": "*",
-                "propel/propel1": ">=1.6,<2.0",
+                "propel/propel1": "~1.6",
                 "solarium/solarium": "dev-develop"
             },
             "suggest": {
             "source": {
                 "type": "git",
                 "url": "https://github.com/shtumi/ShtumiUsefulBundle.git",
-                "reference": "fc6cef6a071d903749dfcff38884f9c240f9e6cf"
+                "reference": "c48ef1a7c1ff8c2b9db73f9c1a69f63e1f6bcbef"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/shtumi/ShtumiUsefulBundle/zipball/fc6cef6a071d903749dfcff38884f9c240f9e6cf",
-                "reference": "fc6cef6a071d903749dfcff38884f9c240f9e6cf",
+                "url": "https://api.github.com/repos/shtumi/ShtumiUsefulBundle/zipball/c48ef1a7c1ff8c2b9db73f9c1a69f63e1f6bcbef",
+                "reference": "c48ef1a7c1ff8c2b9db73f9c1a69f63e1f6bcbef",
                 "shasum": ""
             },
             "require": {
                 "daterange",
                 "shtumi"
             ],
-            "time": "2013-04-08 08:10:20"
+            "time": "2013-07-20 18:33:09"
         },
         {
             "name": "sonata-project/admin-bundle",
         },
         {
             "name": "symfony/symfony",
-            "version": "v2.2.3",
+            "version": "v2.2.4",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/symfony.git",
-                "reference": "v2.2.3"
+                "reference": "v2.2.4"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/symfony/zipball/v2.2.3",
-                "reference": "v2.2.3",
+                "url": "https://api.github.com/repos/symfony/symfony/zipball/v2.2.4",
+                "reference": "v2.2.4",
                 "shasum": ""
             },
             "require": {
-                "doctrine/common": ">=2.2,<3.0",
+                "doctrine/common": "~2.2",
                 "php": ">=5.3.3",
-                "psr/log": ">=1.0,<2.0",
-                "twig/twig": ">=1.11.0,<2.0"
+                "psr/log": "~1.0",
+                "twig/twig": "~1.11"
             },
             "replace": {
                 "symfony/browser-kit": "self.version",
             },
             "require-dev": {
                 "doctrine/data-fixtures": "1.0.*",
-                "doctrine/dbal": ">=2.2,<3.0",
-                "doctrine/orm": ">=2.2,<3.0,>=2.2.3",
-                "monolog/monolog": ">=1.3,<2.0",
+                "doctrine/dbal": "~2.2",
+                "doctrine/orm": "~2.2,>=2.2.3",
+                "monolog/monolog": "~1.3",
                 "propel/propel1": "1.6.*"
             },
             "type": "library",
             "keywords": [
                 "framework"
             ],
-            "time": "2013-06-19 12:09:49"
+            "time": "2013-07-15 12:28:01"
         },
         {
             "name": "twig/extensions",
             },
             "require": {
                 "pagerfanta/pagerfanta": "1.0.*",
-                "symfony/framework-bundle": ">=2.1,<3.0"
+                "symfony/framework-bundle": "~2.1"
             },
             "type": "symfony-bundle",
             "extra": {
         "pagerfanta/pagerfanta": 20,
         "shtumi/useful-bundle": 20,
         "sonata-project/jquery-bundle": 20,
-        "friendsofsymfony/facebook-bundle": 20
+        "friendsofsymfony/facebook-bundle": 20,
+        "doctrine/mongodb-odm-bundle": 10,
+        "doctrine/mongodb-odm": 10,
+        "doctrine/mongodb": 10
     },
     "platform": {
         "php": ">=5.3.3"

src/Muzich/CoreBundle/Command/MineTagsDataCommand.php

+<?php
+
+namespace Muzich\CoreBundle\Command;
+
+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
+{
+  
+  const MINE_DIFFUSION = 'diffusion';
+  const MINE_FAVORITE = 'favorite';
+  const MINE_PLAYLIST = 'playlist';
+  const MINE_TAGS = 'tags';
+  
+  static $mine_types = array(
+    self::MINE_DIFFUSION,
+    self::MINE_FAVORITE,
+    self::MINE_PLAYLIST,
+    self::MINE_TAGS
+  );
+  
+  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')
+    ;
+  }
+  
+  /** @return TagMiner */
+  protected function getTagMiner()
+  {
+    return $this->tag_miner;
+  }
+  
+  /** @return \Doctrine\ORM\EntityManager */
+  protected function getEntityManager()
+  {
+    return $this->em;
+  }
+
+  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($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();
+    
+    $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 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%');
+    }
+    
+    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;
+    }
+    
+    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/EntityTags.php

+<?php
+namespace Muzich\CoreBundle\Document;
+
+use Doctrine\ODM\MongoDB\Mapping\Annotations as MongoDB;
+
+/**
+ * @MongoDB\MappedSuperclass
+ */
+class EntityTags
+{
+  
+  const TYPE_USER = 'User';
+  const TYPE_GROUP = 'Group';
+  const TYPE_PLAYLIST = 'Playlist';
+  
+  /**
+   * @MongoDB\Id
+   */
+  protected $id;
+
+  /**
+   * @MongoDB\Int
+   * @MongoDB\Index(unique=true) 
+   */
+  protected $ref;
+
+  /**
+   * @MongoDB\Collection
+   */
+  protected $tags;
+
+  public function getId()
+  {
+    return $this->id;
+  }
+
+  public function getRef()
+  {
+    return $this->ref;
+  }
+
+  public function setRef($ref)
+  {
+    $this->ref = (int)$ref;
+  }
+
+  public function getTags()
+  {
+    return $this->tags;
+  }
+  
+  public function setTags($tags)
+  {
+    $this->tags = $tags;
+  }
+  
+}

src/Muzich/CoreBundle/Document/GroupTags.php

+<?php
+namespace Muzich\CoreBundle\Document;
+
+use Doctrine\ODM\MongoDB\Mapping\Annotations as MongoDB;
+use Muzich\CoreBundle\Document\EntityTags;
+
+/**
+ * @MongoDB\Document
+ */
+class GroupTags extends EntityTags
+{
+
+}

src/Muzich/CoreBundle/Document/PlaylistTags.php

+<?php
+namespace Muzich\CoreBundle\Document;
+
+use Doctrine\ODM\MongoDB\Mapping\Annotations as MongoDB;
+use Muzich\CoreBundle\Document\EntityTags;
+
+/**
+ * @MongoDB\Document
+ */
+class PlaylistTags extends EntityTags
+{
+
+}

src/Muzich/CoreBundle/Document/UserTags.php

+<?php
+namespace Muzich\CoreBundle\Document;
+
+use Doctrine\ODM\MongoDB\Mapping\Annotations as MongoDB;
+use Muzich\CoreBundle\Document\EntityTags;
+
+/**
+ * @MongoDB\Document
+ */
+class UserTags extends EntityTags
+{
+
+  /**
+   * @MongoDB\Collection
+   */
+  protected $element_diffusion_tags;
+
+  /**
+   * @MongoDB\Collection
+   */
+  protected $element_favorite_tags;
+
+  /**
+   * @MongoDB\Collection
+   */
+  protected $element_playlist_tags;
+  
+  public function getElementDiffusionTags()
+  {
+    if (!$this->element_diffusion_tags)
+      return array();
+      
+    return $this->element_diffusion_tags;
+  }
+  
+  public function setElementDiffusionTags($tags)
+  {
+    $this->element_diffusion_tags = $tags;
+  }
+  
+  public function getElementFavoriteTags()
+  {
+    if (!$this->element_favorite_tags)
+      return array();
+      
+    return $this->element_favorite_tags;
+  }
+  
+  public function setElementFavoriteTags($tags)
+  {
+    $this->element_favorite_tags = $tags;
+  }
+  
+  public function getElementPlaylistTags()
+  {
+    if (!$this->element_playlist_tags)
+      return array();
+      
+    return $this->element_playlist_tags;
+  }
+  
+  public function setElementPlaylistTags($tags)
+  {
+    $this->element_playlist_tags = $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 $this->elements_favorites;
   }
+  
+  public function getElementsFavoritesElements()
+  {
+    if (!$this->elements_favorites)
+      return new ArrayCollection();
+    
+    $elements = array();
+    foreach ($this->elements_favorites as $element_favorite)
+    {
+      $elements[] = $element_favorite->getElement();
+    }
+    
+    return $elements;
+  }
 
   /**
    * Add elements
     return json_decode($this->tags_favorites_quick, true);
   }
   
+  public function getTagsFavoritesQuickIds()
+  {
+    $tags_favorites_ids = array();
+    $tags_favorites_data = $this->getTagsFavoritesQuick();
+    
+    foreach ($tags_favorites_data as $tag_id => $tag_name)
+    {
+      $tags_favorites_ids[] = $tag_id;
+    }
+    
+    return $tags_favorites_ids;
+  }
+  
   /**
    * 
    * @param array $tags_favorites_quick (id => name)
     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/Managers/PlaylistManager.php

       ->findById($playlist->getElementsIds());
   }
   
+  public function getElementsOfPlaylists($playlists)
+  {
+    $elements_ids = array();
+    
+    foreach ($playlists as $playlist)
+    {
+      foreach ($playlist->getElementsIds() as $element_id)
+      {
+        $elements_ids[] = $element_id;
+      }
+    }
+    $elements_ids = array_unique($elements_ids);
+    if ($elements_ids)
+      return $this->entity_manager->getRepository('MuzichCoreBundle:Element')
+      ->findById($elements_ids);
+    
+    return array();
+  }
+  
   public function addPrivateLinks(Playlist $playlist, User $user, $links, Container $container)
   {
     // Pour le moment on le fait ici car le ElementManager est mal pensé.

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

+<?php
+namespace Muzich\CoreBundle\Mining\Tag;
+
+use Doctrine\ORM\EntityManager;
+use Doctrine\Bundle\MongoDBBundle\ManagerRegistry as MongoManagerRegistry;
+use Muzich\CoreBundle\Document\EntityTags;
+use Muzich\CoreBundle\Document\UserTags;
+use Muzich\CoreBundle\Document\GroupTags;
+use Muzich\CoreBundle\Document\PlaylistTags;
+use Doctrine\ORM\QueryBuilder;
+use Muzich\CoreBundle\lib\Tag as TagOrderer;
+use Muzich\CoreBundle\lib\TagScorer;
+use Muzich\CoreBundle\Entity\User;
+use Muzich\CoreBundle\Managers\PlaylistManager;
+
+use Muzich\CoreBundle\Mining\Tag\Tag as Base;
+
+class TagMiner extends Base
+{
+  
+  protected $tag_scorer;
+  protected $tag_orderer;
+  protected $logger_parent;
+  
+  public function __construct(EntityManager $doctrine_entity_manager, MongoManagerRegistry $mongo_manager_registry)
+  {
+    parent::__construct($doctrine_entity_manager, $mongo_manager_registry);
+    $this->tag_scorer = new TagScorer();
+    $this->tag_orderer = new TagOrderer();
+  }
+  
+  /** @return TagScorer */
+  protected function getTagsScorer()
+  {
+    return $this->tag_scorer;
+  }
+  
+  /** @return TagOrderer */
+  protected function getTagOrderer()
+  {
+    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
+   */
+  public function adaptQueryBuilderSelectorsForUser(QueryBuilder $query_builder, $user_alias = 'user')
+  {
+    // Adapt query builder to necessary data in mining
+    $query_builder->leftJoin($user_alias.'.elements', 'element_owned');
+    $query_builder->leftJoin('element_owned.tags', 'element_owned_tags');
+    
+    $query_builder->leftJoin($user_alias.'.elements_favorites', 'element_favorite');
+    $query_builder->leftJoin('element_favorite.element', 'element_favorite_element');
+    
+    $query_builder->select($user_alias.', element_owned, element_owned_tags, element_favorite');
+    
+  }
+  
+  /**
+   * @param array $users
+   */
+  public function mineForUsers($users, $mining_action, $user_action = null)
+  {
+    if (count($users))
+    {
+      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->log('savingInDatabase');
+      $this->getMongoManager()->flush();
+      $this->getDoctrineEntityManager()->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');
+  }
+  
+  /** @return EntityTags */
+  protected function getEntityTagsDocument($ref, $type)
+  {
+    if (!($user_tags = $this->getMongoManager()->createQueryBuilder('MuzichCoreBundle:'.$type.'Tags')
+      ->field('ref')->equals((int)$ref)
+      ->getQuery()->getSingleResult()
+    ))
+    {
+      $user_tags = $this->getObjectTypeTags($type);
+      $user_tags->setRef($ref);
+    }
+    
+    return $user_tags;
+  }
+  
+  /** @return EntityTags */
+  protected function getObjectTypeTags($type)
+  {
+    switch ($type)
+    {
+      case EntityTags::TYPE_USER:
+        return new UserTags();
+      break;
+      case EntityTags::TYPE_GROUP:
+        return new GroupTags();
+      break;
+      case EntityTags::TYPE_PLAYLIST:
+        return new PlaylistTags();
+      break;
+    }
+  }
+  
+  protected function orderUserDiffusionsTags(EntityTags $user_tags, User $user)
+  {
+    $tags_ids_ordereds = $this->getTagOrderer()->getOrderedTagsWithElements($user->getElements());
+    $user_tags->setElementDiffusionTags($tags_ids_ordereds);
+  }
+  
+  protected function orderUserFavoritesTags(EntityTags $user_tags, User $user)
+  {
+    $tags_ids_ordereds = $this->getTagOrderer()->getOrderedTagsWithElements($user->getElementsFavoritesElements());
+    $user_tags->setElementFavoriteTags($tags_ids_ordereds);
+  }
+  
+  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)));
+    $user_tags->setElementPlaylistTags($tags_ids_ordereds);
+  }
+  
+  protected function getUserPlaylists(User $user)
+  {
+    $playlists = $user->getPlaylistsOwneds();
+    foreach ($user->getPickedsPlaylists() as $picked_playlist)
+    {
+      $found = false;
+      foreach ($playlists as $playlist)
+      {
+        if ($playlist->getId() == $picked_playlist->getId())
+        {
+          $found = true;
+        }
+      }
+      
+      if (!$found)
+        $playlists[] = $picked_playlist;
+    }
+    
+    return $playlists;
+  }
+  
+  protected function orderUserTags(EntityTags $user_tags, User $user)
+  {
+    $all_tags_ordered = $this->getTagsScorer()->scoreEntireOrderedTagsIds(array(
+      $user_tags->getElementDiffusionTags(),
+      $user_tags->getElementFavoriteTags(),
+      $user_tags->getElementPlaylistTags()
+    ), $user->getTagsFavoritesQuickIds());
+    
+    $user_tags->setTags($all_tags_ordered);
+  }
+  
+}

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

+<?php
+
+namespace Muzich\CoreBundle\lib;
+
+class TagScorer
+{
+  
+  protected function scoreOrderedsTagsIds($ordered_tags)
+  {
+    $tags_ordered_by_score = array();
+    $score_max = count($ordered_tags);
+    
+    foreach ($ordered_tags as $tag_id)
+    {
+      $tags_ordered_by_score[(int)$score_max] = $tag_id;
+      $score_max -= 1;
+    }
+    
+    return $tags_ordered_by_score;
+  }
+  
+  public function scoreEntireOrderedTagsIds($ordereds_elements_tags_ids, $favoriteds_tags)
+  {
+    $tags_score = array();
+    
+    foreach ($ordereds_elements_tags_ids as $ordereds_tags_ids)
+    {
+      $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;
+        
+        $tags_score[$tag_id] += $score_tag;
+      }
+    }
+    
+    foreach ($favoriteds_tags as $favorite_tag_id)
+    {
+      if (!array_key_exists($favorite_tag_id, $tags_score))
+        $tags_score[$favorite_tag_id] = 0;
+        
+      $tags_score[$favorite_tag_id] += 5;
+    }
+        
+    arsort($tags_score);
+    
+    $oredered_tags_ids_without_score = array();
+    foreach ($tags_score as $tag_id => $tag_score)
+    {
+      $oredered_tags_ids_without_score[] = $tag_id;
+    }
+    
+    return $oredered_tags_ids_without_score;
+  }
+  
+}

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'));