Logiciel: Evolution #838: Base de connaissance

src/Muzich/CoreBundle/Command/MineTagsDataCommand.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Muzich\CoreBundle\Command;
+
+use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Muzich\CoreBundle\Mining\Tag\TagMiner;
+
+class MineTagsDataCommand extends ContainerAwareCommand
+{
+  
+  protected $sitemap_content;
+  protected $sitemap_urls;
+  protected $router;
+  protected $locales;
+  protected $siteurl_prefix;
+  protected $em;
+  
+  protected function configure()
+  {
+    $this
+      ->setName('mining:tags')
+      ->setDescription('Mine tags data')
+    ;
+  }
+  
+  /** @return TagMiner */
+  protected function getTagMiner()
+  {
+    return $this->getContainer()->get('muzich.mining.tag.miner');
+  }
+  
+  /** @return \Doctrine\ORM\EntityManager */
+  protected function getEntityManager()
+  {
+    return $this->em;
+  }
+
+  protected function init()
+  {
+    $this->em = $this->getContainer()->get('doctrine')->getEntityManager();
+  }
+  
+  protected function execute(InputInterface $input, OutputInterface $output)
+  {
+    $this->init();
+    
+    $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());
+    
+    $output->writeln('<info>Terminé !</info>');
+  }
+  
+}

src/Muzich/CoreBundle/Document/EntityTags.php

@@ -0,0 +1,147 @@
+<?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_top_1;
+
+  /**
+   * @MongoDB\Collection
+   */
+  protected $tags_top_2;
+
+  /**
+   * @MongoDB\Collection
+   */
+  protected $tags_top_3;
+
+  /**
+   * @MongoDB\Collection
+   */
+  protected $tags_top_5;
+
+  /**
+   * @MongoDB\Collection
+   */
+  protected $tags_top_10;
+
+  /**
+   * @MongoDB\Collection
+   */
+  protected $tags_top_25;
+
+  /**
+   * @MongoDB\Collection
+   */
+  protected $tags_all;
+
+  public function getId()
+  {
+    return $this->id;
+  }
+
+  public function getRef()
+  {
+    return $this->ref;
+  }
+
+  public function setRef($ref)
+  {
+    $this->ref = (int)$ref;
+  }
+
+  public function getTagsAll()
+  {
+    return $this->tags_all;
+  }
+  
+  public function setTagsAll($tags)
+  {
+    $this->tags_all = $tags;
+  }
+  
+  public function setTagsTop1($tags)
+  {
+    $this->tags_top_1 = $tags;
+  }
+  
+  public function getTagsTop1()
+  {
+    return $this->tags_top_1;
+  }
+  
+  public function setTagsTop2($tags)
+  {
+    $this->tags_top_2 = $tags;
+  }
+  
+  public function getTagsTop2()
+  {
+    return $this->tags_top_2;
+  }
+  
+  public function setTagsTop3($tags)
+  {
+    $this->tags_top_3 = $tags;
+  }
+  
+  public function getTagsTop3()
+  {
+    return $this->tags_top_3;
+  }
+  
+  public function setTagsTop5($tags)
+  {
+    $this->tags_top_5 = $tags;
+  }
+  
+  public function getTagsTop5()
+  {
+    return $this->tags_top_5;
+  }
+  
+  public function setTagsTop10($tags)
+  {
+    $this->tags_top_10 = $tags;
+  }
+  
+  public function getTagsTop10()
+  {
+    return $this->tags_top_10;
+  }
+  
+  public function setTagsTop25($tags)
+  {
+    $this->tags_top_25 = $tags;
+  }
+  
+  public function getTagsTop25()
+  {
+    return $this->tags_top_25;
+  }
+  
+}

src/Muzich/CoreBundle/Document/GroupTags.php

@@ -0,0 +1,13 @@
+<?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

@@ -0,0 +1,13 @@
+<?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

@@ -0,0 +1,58 @@
+<?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\Hash
+   */
+  protected $element_diffusion_tags;
+
+  /**
+   * @MongoDB\Hash
+   */
+  protected $element_favorite_tags;
+
+  /**
+   * @MongoDB\Hash
+   */
+  protected $element_playlist_tags;
+  
+  public function getElementDiffusionTags()
+  {
+    return $this->element_diffusion_tags;
+  }
+  
+  public function setElementDiffusionTags($tags)
+  {
+    $this->element_diffusion_tags = $tags;
+  }
+  
+  public function getElementFavoriteTags()
+  {
+    return $this->element_favorite_tags;
+  }
+  
+  public function setElementFavoriteTags($tags)
+  {
+    $this->element_favorite_tags = $tags;
+  }
+  
+  public function getElementPlaylistTags()
+  {
+    return $this->element_playlist_tags;
+  }
+  
+  public function setElementPlaylistTags($tags)
+  {
+    $this->element_playlist_tags = $tags;
+  }
+  
+}

src/Muzich/CoreBundle/Entity/User.php

@@ -375,6 +375,20 @@ class User extends BaseUser
   {
     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
@@ -904,6 +918,19 @@ class User extends BaseUser
     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)

src/Muzich/CoreBundle/Managers/PlaylistManager.php

@@ -255,6 +255,25 @@ class PlaylistManager
       ->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/TagMiner.php

@@ -0,0 +1,219 @@
+<?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;
+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;
+
+class TagMiner
+{
+  
+  protected $doctrine_entity_manager;
+  protected $mongo_manager_registry;
+  protected $tag_scorer;
+  protected $tag_orderer;
+  
+  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;
+    $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_scorer;
+  }
+  
+  /** @return TagOrderer */
+  protected function getTagOrderer()
+  {
+    return $this->tag_orderer;
+  }
+  
+  /** 
+   * @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 mineTagsForUsers($users)
+  {
+    foreach ($users as $user)
+    {
+      $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);
+      
+      $this->getMongoManager()->persist($user_tags);
+    }
+    
+    $this->getMongoManager()->flush();
+  }
+  
+  /** @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 scoreUserDiffusionsTags(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);
+  }
+  
+  protected function scoreUserFavoritesTags(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);
+  }
+  
+  protected function scoreUserPlaylistsTags(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);
+  }
+  
+  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 scoreUserTags(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->setTagsAll($all_tags_ordered);
+  }
+  
+  protected function determineTagsTops(EntityTags $user_tags)
+  {
+    $user_tags->setTagsTop1($this->getTopTagsRange($user_tags->getTagsAll(), 1));
+    $user_tags->setTagsTop2($this->getTopTagsRange($user_tags->getTagsAll(), 2));
+    $user_tags->setTagsTop3($this->getTopTagsRange($user_tags->getTagsAll(), 3));
+    $user_tags->setTagsTop5($this->getTopTagsRange($user_tags->getTagsAll(), 5));
+    $user_tags->setTagsTop10($this->getTopTagsRange($user_tags->getTagsAll(), 10));
+    $user_tags->setTagsTop25($this->getTopTagsRange($user_tags->getTagsAll(), 25));
+  }
+  
+  protected function getTopTagsRange($tags, $range_end)
+  {
+    $tags_top = array();
+    if ($range_end <= count($tags))
+    {
+      $max = $range_end;
+    }
+    else
+    {
+      $max = count($tags);
+    }
+      
+    for ($index = 0; $index <= $max-1; $index++)
+    {
+      $tags_top[] = $tags[$index];
+    }
+    
+    
+    return $tags_top;
+  }
+  
+}

src/Muzich/CoreBundle/lib/TagScorer.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Muzich\CoreBundle\lib;
+
+class TagScorer
+{
+  
+  public 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)
+    {
+      foreach ($ordereds_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;
+  }
+  
+}