Evolution #738: Playlist

app/AppKernel.php

             new Muzich\FavoriteBundle\MuzichFavoriteBundle(),
             new Muzich\CommentBundle\MuzichCommentBundle(),
             new Muzich\AdminBundle\MuzichAdminBundle(),
+            new Muzich\PlaylistBundle\MuzichPlaylistBundle(),
         );
 
         if (in_array($this->getEnvironment(), array('dev', 'test'))) {

app/config/routing.yml

   requirements:
     _locale: fr|en
   
+MuzichPlaylistBundle:
+  resource: "@MuzichPlaylistBundle/Resources/config/routing.yml"
+  prefix:   /{_locale}/
+  requirements:
+    _locale: fr|en
+  
 AdmingeneratorDashboard_welcome:
     pattern: /admin/dashboard
     defaults: { _controller: MuzichAdminBundle:Dashboard:welcome }

src/Muzich/CoreBundle/Controller/ElementController.php

     ));
   }
   
+  
+  public function getOneAction($element_id)
+  {
+    $es = new ElementSearcher();
+    $es->init(array(
+      'ids' => array($element_id)
+    ));
+    
+    if (!($element = $es->getElements($this->getDoctrine(), $this->getUserId(true), 'single')))
+    {
+      return $this->jsonResponse(array(
+      'status'  => 'error'
+    ));
+    }
+    
+    $html = $this->render('MuzichCoreBundle:SearchElement:element.html.twig', array(
+      'element'               => $element,
+      'display_edit_actions'  => true,
+      'display_player'        => true,
+      'display_comments'      => true
+    ))->getContent();
+    
+    return $this->jsonResponse(array(
+      'status'  => 'success',
+      'data'    => $html
+    ));
+  }
+  
   public function getOneDomAction(Request $request, $element_id, $type)
   {
     if (!in_array($type, array('autoplay')) || !$element_id)

src/Muzich/CoreBundle/DataFixtures/ORM/LoadUsersElementsFavoritesData.php

 use Symfony\Component\DependencyInjection\ContainerAwareInterface;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 use Muzich\CoreBundle\Entity\UsersElementsFavorites;
+use Muzich\CoreBundle\Entity\User;
+use Muzich\CoreBundle\Managers\PlaylistManager;
 
 class LoadUsersElementsFavoritesData  extends AbstractFixture implements OrderedFixtureInterface, ContainerAwareInterface
 {
   /**
    *  
    */
-  protected function createRecord($user, $element)
+  protected function createRecord(User $user, $element)
   {
     $favorite = new UsersElementsFavorites();
     $favorite->setUser($user);
     //$this->addReference('user_tag_'.$user->getId().'_'.$tag->getId(), $userTag);
   }
   
+  protected function createPlaylist($name, User $user, $public, $elements)
+  {
+    $playlist_manager = new PlaylistManager($this->entity_manager);
+    $playlist = $playlist_manager->getNewPlaylist($user);
+    $playlist->setPublic($public);
+    $playlist->setName($name);
+    
+    $playlist_manager->addElementsToPlaylist($elements, $playlist);
+    $this->entity_manager->persist($playlist);
+    return $playlist;
+  }
+  
   public function load(ObjectManager $entity_manager)
   {
     $this->entity_manager = $entity_manager;
     $this->createRecord($paul, $youtube_heretik_1);
     $this->createRecord($paul, $jamendo_caio_1);
     
+    // Playlists
+    $playlist1 = $this->createPlaylist("Un peu de basses ?",
+      $bux, true, array(
+        $this->getReference('element_soulfly_1'),
+        $youtube_heretik_1,
+        $youtube_djfab_1,
+        $jamendo_caio_1,
+        $this->getReference('element_youtube_dtc_passdrop'),
+        $this->getReference('element_youtube_antroppod_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_djantoine_1'),
+        $this->getReference('element_youtube_acroyek_1'),
+        $this->getReference('element_jamendo_caio_1'),
+        $this->getReference('element_jamendo_reverb_1'),
+        $this->getReference('element_jamendo_cardio_1'),
+        $this->getReference('element_dudeldrum'),
+        $this->getReference('element_infected_psycho'),
+        $this->getReference('element_infected_muse'),
+        $this->getReference('element_joelle_1'),
+        $this->getReference('element_joelle_2'),
+        $this->getReference('element_ukf_1'),
+        $this->getReference('element_beatbox_1'),
+        $this->getReference('element_soulfly_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_youtube_koinkoin_1'),
+        $this->getReference('element_soulfly_1')
+      ));
+    
+    $playlist2 = $this->createPlaylist("Ma playlist perso",
+    $bux, false, array($youtube_heretik_1, $youtube_djfab_1));
+    
+    $playlist_manager = new PlaylistManager($this->entity_manager);
+    $playlist_manager->addPickedPlaylistToUser($paul, $playlist1);
+    
     $this->entity_manager->flush();
   }
 }

src/Muzich/CoreBundle/DoctrineExtensions/Query/Mysql/Field.php

+<?php
+
+/**
+ * DoctrineExtensions Mysql Function Pack
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to kontakt@beberlei.de so I can send you a copy immediately.
+ */
+
+/**
+ * Usage: FIELD(str,str1,str2,str3,...)
+ * 
+ * FIELD returns the index (position) of str in the str1, str2, str3, ... list. 
+ * Returns 0 if str is not found. If all arguments to FIELD() are strings, all 
+ * arguments are compared as strings. If all arguments are numbers, they are 
+ * compared as numbers. Otherwise, the arguments are compared as double.
+ * If str is NULL, the return value is 0 because NULL fails equality comparison 
+ * with any value. FIELD() is the complement of ELT(). (Taken from MySQL 
+ * documentation.)
+ * 
+ * @author  Jeremy Hicks <jeremy.hicks@gmail.com>
+ * @version 2011.06.09
+ */
+
+namespace Muzich\CoreBundle\DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Field extends FunctionNode
+{
+    private $field = null;
+    private $values = array();
+    
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+		
+        // Do the field.
+        $this->field = $parser->ArithmeticPrimary();
+		
+        // Add the strings to the values array. FIELD must
+        // be used with at least 1 string not including the field.
+		
+        $lexer = $parser->getLexer();
+		
+        while (count($this->values) < 1 || 
+            $lexer->lookahead['type'] != Lexer::T_CLOSE_PARENTHESIS) {
+            $parser->match(Lexer::T_COMMA);
+            $this->values[] = $parser->ArithmeticPrimary();
+        }
+		
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+	
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        $query = 'FIELD(';
+		
+        $query .= $this->field->dispatch($sqlWalker);
+		
+        $query .= ',';
+		
+        for ($i = 0; $i < count($this->values); $i++) {
+            if ($i > 0) {
+                $query .= ',';
+            }
+			
+            $query .= $this->values[$i]->dispatch($sqlWalker);
+        }
+		
+        $query .= ')';
+		
+        return $query;
+    }
+}

src/Muzich/CoreBundle/Entity/Playlist.php

 
 /**
  * @ORM\Entity
+ * @ORM\Entity(repositoryClass="Muzich\CoreBundle\Repository\PlaylistRepository")
  */
 class Playlist
 {
   {
     $tags_manager = new TagCollectionManager(json_decode($this->tags, true));
     $tags_manager->add($tag);
-    $this->tags = json_encode($tags_manager->getContent(), true);
+    $this->setTags($tags_manager->getContent());
   }
   
   public function removeTag(Tag $tag)
   {
     $tags_manager = new TagCollectionManager(json_decode($this->tags, true));
     $tags_manager->remove($tag);
-    $this->tags = json_encode($tags_manager->getContent(), true);
+    $this->setTags($tags_manager->getContent());
+  }
+  
+  public function cleanTags()
+  {
+    $this->setTags(array());
   }
   
   public function getTagsIds()
   {
     $elements_manager = new ElementCollectionManager(json_decode($this->elements, true));
     $elements_manager->add($element);
-    $this->elements = json_encode($elements_manager->getContent(), true);
+    $this->setElements($elements_manager->getContent());
   }
   
   public function removeElement(Element $element)
   {
     $elements_manager = new ElementCollectionManager(json_decode($this->elements, true));
     $elements_manager->remove($element);
-    $this->elements = json_encode($elements_manager->getContent(), true);
+    $this->setElements($elements_manager->getContent());
   }
   
   public function getElementsIds()

src/Muzich/CoreBundle/Entity/UserPlaylistPicked.php

   protected $user;
   
   /**
-   * @ORM\ManyToOne(targetEntity="Tag", inversedBy="users_favorites")
+   * @ORM\ManyToOne(targetEntity="Playlist", inversedBy="users_favorites")
    * @ORM\JoinColumn(name="tag_id", referencedColumnName="id", onDelete="CASCADE")
    */
   protected $playlist;

src/Muzich/CoreBundle/Managers/PlaylistManager.php

 use Doctrine\ORM\EntityManager;
 use Muzich\CoreBundle\Entity\Playlist;
 use Muzich\CoreBundle\Entity\User;
+use Muzich\CoreBundle\Entity\Element;
 use Muzich\CoreBundle\Entity\UserPlaylistPicked;
 use \Doctrine\Common\Collections\ArrayCollection;
+use Muzich\CoreBundle\lib\Tag as TagLib;
 
 class PlaylistManager
 {
     $this->entity_manager = $entity_manager;
   }
   
-  public function findOnePlaylistWithId($playlist_id, User $user = null)
+  public function getUserPublicsOrOwnedPlaylists(User $user_viewed, User $user = null)
   {
-    $query_builder = $this->entity_manager->createQueryBuilder()
-      ->select('p')
-      ->from('MuzichCoreBundle:Playlist', 'p')
-      ->where('p.id = :playlist_id')
+    return $this->entity_manager->getRepository('MuzichCoreBundle:Playlist')
+      ->getUserPublicPlaylistsOrOwnedQueryBuilder($user_viewed, $user)
+      ->getQuery()->getResult()
+    ;
+  }
+  
+  public function findOneAccessiblePlaylistWithId($playlist_id, User $user = null)
+  {
+    return $this->entity_manager->getRepository('MuzichCoreBundle:Playlist')
+      ->findOnePlaylistOwnedOrPublic($playlist_id, $user)
+      ->getQuery()->getOneOrNullResult()
+    ;
+  }
+  
+  public function getPlaylistElements(Playlist $playlist)
+  {
+    return $this->entity_manager->getRepository('MuzichCoreBundle:Element')
+      ->getElementsWithIdsOrderingQueryBuilder($playlist->getElementsIds())
+      ->getQuery()->getResult()
     ;
-    
-    if ($user)
-    {
-      $query_builder->andWhere('p.public = 1 OR p.owner = :user_id');
-    }
-    else
-    {
-      $query_builder->andWhere('p.public = 1');
-    }
-    
-    return $query_builder->getWuery()->getResult();
   }
   
   public function getNewPlaylist(User $owner)
     $this->entity_manager->persist($user);
   }
   
+  public function addElementToPlaylist(Element $element, Playlist $playlist)
+  {
+    $playlist->addElement($element);
+    $this->actualizePlaylistTags($playlist);
+  }
+  
+  public function addElementsToPlaylist($elements, Playlist $playlist)
+  {
+    foreach ($elements as $element)
+    {
+      $playlist->addElement($element);
+    }
+    $this->actualizePlaylistTags($playlist);
+  }
+  
+  public function removeElementFromPlaylist(Element $element, Playlist $playlist)
+  {
+    $playlist->removeElement($element);
+    $this->actualizePlaylistTags($playlist);
+  }
+  
+  protected function actualizePlaylistTags(Playlist $playlist)
+  {
+    $tag_lib = new TagLib();
+    $playlist->cleanTags();
+    foreach ($tag_lib->getOrderedEntityTagsWithElements($this->getPlaylistElements($playlist)) as $tag)
+    {
+      $playlist->addTag($tag);
+    }
+    $this->entity_manager->persist($playlist);
+  }
+  
 }

src/Muzich/CoreBundle/Repository/ElementRepository.php

     ;
   }
   
+  /**
+   * WARNING: Seulement compatibel avec MySQL !!
+   */
+  public function getElementsWithIdsOrderingQueryBuilder($element_ids)
+  {
+    $doctrineConfig = $this->getEntityManager()->getConfiguration();
+    $doctrineConfig->addCustomStringFunction('FIELD', 'Muzich\CoreBundle\DoctrineExtensions\Query\Mysql\Field');
+    
+    return $this->getEntityManager()->createQueryBuilder()
+      ->select('e, field(e.id, ' . implode(', ', $element_ids) . ') as HIDDEN field')
+      ->from('MuzichCoreBundle:Element', 'e')
+      ->where('e.id IN (:element_ids)')
+      ->setParameter('element_ids', $element_ids)
+      ->orderBy('field')
+    ;
+  }
+  
 }

src/Muzich/CoreBundle/Repository/PlaylistRepository.php

+<?php
+
+namespace Muzich\CoreBundle\Repository;
+
+use Doctrine\ORM\EntityRepository;
+use Doctrine\ORM\Mapping as ORM;
+use Muzich\CoreBundle\Entity\User;
+
+class PlaylistRepository extends EntityRepository
+{
+  
+  protected function getPlaylistsQueryBuilder()
+  {
+    return $this->getEntityManager()->createQueryBuilder()
+      ->select('p')
+      ->from('MuzichCoreBundle:Playlist', 'p')
+    ;
+  }
+  
+  public function getPublicPlaylistsQueryBuilder()
+  {
+    return $this->getPlaylistsQueryBuilder()
+      ->andWhere('p.public = 1')
+    ;
+  }
+  
+  public function getUserPublicPlaylistsQueryBuilder(User $user)
+  {
+    return $this->getPublicPlaylistsQueryBuilder()
+      ->andWhere('p.owner = :owner_id')
+      ->setParameter('owner_id', $user->getId())
+    ;
+  }
+  
+  public function getUserPublicPlaylistsOrOwnedQueryBuilder(User $viewed_user, User $current_user = null)
+  {
+    if (!$current_user)
+    {
+      return $this->getUserPublicPlaylistsQueryBuilder($viewed_user);
+    }
+    
+    if ($viewed_user->getId() != $current_user->getId())
+    {
+      return $this->getUserPublicPlaylistsQueryBuilder($viewed_user);
+    }
+    
+    return $this->getPlaylistsQueryBuilder()
+      ->where('p.owner = :owner_id')
+      ->setParameter('owner_id', $current_user->getId())
+    ;
+  }
+  
+  public function findOnePlaylistOwnedOrPublic($playlist_id, User $user = null)
+  {
+    $query_builder = $this->getPlaylistsQueryBuilder()
+      ->andWhere('p.id = :playlist_id');
+      
+    if ($user)
+    {
+      $query_builder->andWhere('p.public = 1 OR p.owner = :owner_id');
+      $query_builder->setParameters(array(
+        'playlist_id' => $playlist_id,
+        'owner_id'    => $user->getId()
+      ));
+    }
+    else
+    {
+      $query_builder->andWhere('p.public = 1');
+      $query_builder->setParameters(array(
+        'playlist_id' => $playlist_id
+      ));
+    }
+    
+    return $query_builder;
+  }
+  
+  /**
+   * Retourne un tableau de groupe correspondant a un chaine de caractère
+   * La recherche est effectué sur le name.
+   * 
+   * @param type $string
+   * @return Doctrine\ORM\Query
+   */
+  public function findByString($string)
+  {
+    return $this->getEntityManager()
+      ->createQuery("
+        SELECT g FROM MuzichCoreBundle:Group g
+        WHERE UPPER(g.name) LIKE :str
+        ORDER BY g.name ASC"
+      )
+      ->setParameters(array(
+        'str' => '%'.strtoupper(trim($string)).'%'
+      ))
+    ;
+  }
+  
+  /**
+   * Retourne une Query sleectionnant un Group par son slug
+   * 
+   * @param type string 
+   * @return Doctrine\ORM\Query
+   */
+  public function findOneBySlug($slug)
+  {
+    return $this->getEntityManager()
+      ->createQuery("
+        SELECT g FROM MuzichCoreBundle:Group g
+        LEFT JOIN g.tags tr 
+        LEFT JOIN tr.tag t
+        WHERE g.slug = :str
+      ")
+      ->setParameters(array(
+        'str' => $slug
+      ))
+    ;
+  }
+  
+  /**
+   * Retourne un tableau de groupes étant publics, ou possédé par l'user
+   * 
+   * @param int $user_id
+   * @return array id => name
+   */
+  public function getPublicAndOwnedArray($user_id)
+  {
+    $group_array = array();
+    foreach ($this->getEntityManager()
+      ->createQuery('
+        SELECT g.id, g.name FROM MuzichCoreBundle:Group g
+        LEFT JOIN g.owner o 
+        WHERE g.open = \'1\' OR o.id = :uid'
+      )->setParameter('uid', $user_id)
+      ->getArrayResult() as $group)
+    {
+      $group_array[$group['id']] = $group['name'];
+    }
+    return $group_array;
+  }
+  
+  /**
+   * Retourne tous les tags des elements postés
+   * 
+   * @return doctrine_collection
+   */
+  public function getElementsTags($group_id, $current_user_id)
+  {
+    $parameters = array('gid' => $group_id);
+    $current_user_sql = '';
+    if ($current_user_id)
+    {
+      $parameters['uidt'] = '%"'.$current_user_id.'"%';
+      $current_user_sql = 'OR t.privateids LIKE :uidt';
+    }
+    
+    return $this->getEntityManager()
+      ->createQuery('
+        SELECT t FROM MuzichCoreBundle:Tag t
+        LEFT JOIN t.elements e
+        WHERE e.group = :gid
+        AND (t.tomoderate = \'FALSE\' OR t.tomoderate IS NULL
+          '.$current_user_sql.')
+        ORDER BY t.name ASC'
+      )
+      ->setParameters($parameters)
+      ->getResult()
+    ;
+  }
+ 
+  public function getElementIdsOwned($group_id)
+  {
+    $ids = array();
+    foreach ($this->getEntityManager()
+      ->createQuery('SELECT e.id FROM MuzichCoreBundle:Element e
+        WHERE e.group = :gid')
+      ->setParameter('gid', $group_id)
+      ->getScalarResult() as $row)
+    {
+      $ids[] = $row['id'];
+    }
+    return $ids;
+  }
+  
+  public function countFollowers($group_id)
+  {
+    $data = $this->getEntityManager()
+      ->createQuery('SELECT COUNT(f) FROM MuzichCoreBundle:FollowGroup f
+        WHERE f.group = :gid')
+      ->setParameter('gid', $group_id)
+      ->getScalarResult()
+    ;
+    
+    if (count($data))
+    {
+      if (count($data[0]))
+      {
+        return $data[0][1];
+      }
+    }
+    
+    return 0;
+  }
+  
+}
+  

src/Muzich/CoreBundle/Resources/config/routing.yml

   pattern: /ajax/element/dom/get/{type}/{element_id}
   defaults: { _controller: MuzichCoreBundle:Element:getOneDom, element_id: null }
 
+element_get_one:
+  pattern: /ajax/element/get/{element_id}
+  defaults: { _controller: MuzichCoreBundle:Element:getOne }
+
 element_get_stream_data:
   pattern: /ajax/element/data/get/stream/{element_id}
   defaults: { _controller: MuzichCoreBundle:Element:geJamendotStreamDatas, element_id: null }

src/Muzich/CoreBundle/Resources/public/css/main.css

   margin-left: 0px;
 }
   
-.elements ul.element_tags li, ul#autoplay_element ul.element_tags li
+.elements ul.element_tags li, ul#autoplay_element ul.element_tags li, ul.elements ul.element_tags li
 {
   display: inline;
   font-size: 90%;
 
 }
 
-a.button.element_tag, ul.tagbox li.tag, ul.search_tag_list li, ul#favorite_tags li
+a.button.element_tag, ul.tagbox li.tag, ul.search_tag_list li, ul#favorite_tags li, ul.tags_cloud li
 {
   padding: 6px;
   border: none;
   padding-right: 18px;
 }
 
-ul.tagbox li.tag, ul#favorite_tags li
+ul.tagbox li.tag, ul#favorite_tags li, ul.tags_cloud li
 {
   border-radius: 3px 3px 3px 3px;
   display: inline-block;
   padding: 0px;
 }
 
-ul#autoplay_element li
+ul#autoplay_element li, ul.elements li
 {
   list-style-type: none;
 }
 margin:0;
 }
 
-ul#favorite_tags
+ul#favorite_tags, ul.tags_cloud
 {
   padding:0;
   margin-top:10px;
   list-style-type:none;
 }
 
-ul#favorite_tags li a
+ul#favorite_tags li a, ul.tags_cloud li a
 {
   color: white;
 }
 div#login_box
 {
   margin-top: 23px;
+}
+
+ul.playlists ul.tags_cloud
+{
+  margin-top: 5px;
+  margin-bottom: 5px;
+}
+
+ul.playlists ul.tags_cloud li
+{
+  font-size: 11px;
+  font-weight: normal;
+  padding: 4px;
 }

src/Muzich/CoreBundle/Resources/public/js/autoplay.js

     return false;
   });
   
+  $('a.autoplay_playlist').live('click', function(){
+    window.autoplay.start($(this));
+    $('html, body').animate({ scrollTop: 0 }, 'fast');
+    return false;
+  });
+  
   $('a#autoplay_previous').click(function(){window.autoplay.playPrevious()});
   
   $('a#autoplay_next').click(function(){window.autoplay.playNext()});

src/Muzich/CoreBundle/Resources/public/js/muzich.js

    });
    
    
+   /**
+    *PLAYLISTS
+    */
+   
+  $('ul.playlist_elements li a.open_element').live('click', function(){
+    
+    var line = $(this).parents('li.playlist_element');
+    
+    $.getJSON($(this).attr('href'), function(response) {
+      
+      window.ResponseController.execute(
+        response,
+        function(){},
+        function(){}
+      );
+      
+      if (response.status == 'success')
+      {
+        line.append('<ul class="elements"><li class="element">' + response.data + '</li></ul>');
+      }
+      
+    });
+    
+    return false;
+  });
+  
+  $('a.autoplay_playlist').live('click', function(){
+    
+  });
+   
 });
 
 function open_ajax_popin(url, callback)

src/Muzich/CoreBundle/Resources/views/Tag/tag_cloud.html.twig

+<ul class="tags_cloud">
+  {% for key, tag in tags %}
+    <li class="{{ css_list_length_class(key, tags|length) }}" {% if loop.index0 > cloud_tags_limit_to_display %}style="display: none;"{% endif %}>
+      <a data-tagid="{{ tag.id }}" href="#" class="tag">
+        {{ tag.name }}
+      </a>
+    </li>
+  {% endfor %}
+</ul>
+<div class="clearboth" ></div>

src/Muzich/CoreBundle/Tests/Utils/CollectionManagerTest.php

     
     $tag_pop = new TagTest(1, 'Pop');
     $tags_collection_manager->add($tag_pop);
-    $this->assertEquals('[{"Id":"1","Name":"Pop"}]', json_encode($tags_collection_manager->getContent(), true));
+    $this->assertEquals('[{"id":"1","name":"Pop"}]', json_encode($tags_collection_manager->getContent(), true));
     
     $tag_rock = new TagTest(2, 'Rock');
     $tags_collection_manager->add($tag_rock);
-    $this->assertEquals('[{"Id":"1","Name":"Pop"},{"Id":"2","Name":"Rock"}]', json_encode($tags_collection_manager->getContent(), true));
+    $this->assertEquals('[{"id":"1","name":"Pop"},{"id":"2","name":"Rock"}]', json_encode($tags_collection_manager->getContent(), true));
     
     $this->assertTrue($tags_collection_manager->have($tag_rock));
     
     $tags_collection_manager->add($tag_rock);
-    $this->assertEquals('[{"Id":"1","Name":"Pop"},{"Id":"2","Name":"Rock"}]', json_encode($tags_collection_manager->getContent(), true));
+    $this->assertEquals('[{"id":"1","name":"Pop"},{"id":"2","name":"Rock"}]', json_encode($tags_collection_manager->getContent(), true));
     
     $tag_metal = new TagTest(3, 'Metal');
     $tags_collection_manager->add($tag_metal);
-    $this->assertEquals('[{"Id":"1","Name":"Pop"},{"Id":"2","Name":"Rock"},{"Id":"3","Name":"Metal"}]', json_encode($tags_collection_manager->getContent(), true));
+    $this->assertEquals('[{"id":"1","name":"Pop"},{"id":"2","name":"Rock"},{"id":"3","name":"Metal"}]', json_encode($tags_collection_manager->getContent(), true));
     
     $this->assertEquals(array('1', '2', '3'), $tags_collection_manager->getAttributes(TagCollectionManager::ATTRIBUTE_ID));
     $this->assertEquals(array('Pop', 'Rock', 'Metal'), $tags_collection_manager->getAttributes(TagCollectionManager::ATTRIBUTE_NAME));
     
     $tags_collection_manager->remove($tag_pop);
-    $this->assertEquals('[{"Id":"2","Name":"Rock"},{"Id":"3","Name":"Metal"}]', json_encode($tags_collection_manager->getContent(), true));
+    $this->assertEquals('[{"id":"2","name":"Rock"},{"id":"3","name":"Metal"}]', json_encode($tags_collection_manager->getContent(), true));
   }
   
 }

src/Muzich/CoreBundle/lib/Collection/CollectionManager.php

   protected $content;
   protected $schema = array();
   protected $object_reference_attribute;
+  protected $allow_duplicates = false;
   
   public function __construct($content)
   {
   
   public function add($object)
   {
-    if (!$this->have($object))
+    if (!$this->have($object) || $this->allow_duplicates)
     {
       $content_line = array();
       foreach ($this->schema as $attribute)
       {
         $method_name = 'get' . $attribute;
-        $content_line[$attribute] = (string)$object->$method_name();
+        $content_line[lcfirst($attribute)] = (string)$object->$method_name();
       }
       
       $this->content[] = $content_line;
     $method_name = 'get' . $this->object_reference_attribute;
     foreach ($this->content as $content_line)
     {
-      if ($object->$method_name() == $content_line[$this->object_reference_attribute])
+      if ($object->$method_name() == $content_line[lcfirst($this->object_reference_attribute)])
       {
         return true;
       }
     $method_name = 'get' . $this->object_reference_attribute;
     foreach ($this->content as $content_line)
     {
-      if ($object->$method_name() != $content_line[$this->object_reference_attribute])
+      if ($object->$method_name() != $content_line[lcfirst($this->object_reference_attribute)])
       {
         $new_content[] = $content_line;
       }
     $attributes = array();
     foreach ($this->content as $content_line)
     {
-      $attributes[] = $content_line[$attribute];
+      $attributes[] = $content_line[lcfirst($attribute)];
     }
     
     return $attributes;

src/Muzich/CoreBundle/lib/Collection/ElementCollectionManager.php

   const ATTRIBUTE_ID   = 'Id';
   const ATTRIBUTE_NAME = 'Name';
   
+  protected $allow_duplicates = true;
   protected $schema = array(
     self::ATTRIBUTE_ID,
     self::ATTRIBUTE_NAME

src/Muzich/CoreBundle/lib/Controller.php

 use Muzich\CoreBundle\Entity\Presubscription;
 use Muzich\CoreBundle\Entity\User;
 use Muzich\CoreBundle\Security\Context as SecurityContext;
+use Muzich\CoreBundle\Managers\PlaylistManager;
 
 class Controller extends BaseController
 {
     return $this->security_context;
   }
   
+  /** @return PlaylistManager */
+  protected function getPlaylistManager()
+  {
+    return new PlaylistManager($this->getEntityManager());
+  }
+  
+  protected function getLastDisplayedElementId($elements)
+  {
+    if (count($elements))
+      return $elements[count($elements)-1]->getId();
+    
+    return null;
+  }
+  
 }

src/Muzich/CoreBundle/lib/Tag.php

     return $tags_ordered;
   }
   
+  public function getOrderedEntityTagsWithElements($elements)
+  {
+    $tag_ordered_reference = $this->getOrderedTagsWithElements($elements);
+    return $this->populateOrderedReferenceWithElementTags($elements, $tag_ordered_reference);
+  }
+  
+  public function populateOrderedReferenceWithElementTags($elements, $ordered_reference)
+  {
+    $tags = array();
+    $tags_ordered = array();
+    foreach ($elements as $element)
+    {
+      foreach ($element->getTags() as $tag)
+      {
+        $tags[$tag->getId()] = $tag;
+      }
+    }
+    
+    foreach ($ordered_reference as $tag_id)
+    {
+      $tags_ordered[] = $tags[$tag_id];
+    }
+    
+    return $tags_ordered;
+  }
+  
   /**
    * Range une liste de tags [0 => Tag] en fonction d'une
    * réfèrence sous la forme [0 => tag_id, 1 => tag_id]

src/Muzich/PlaylistBundle/Controller/ShowController.php

+<?php
+
+namespace Muzich\PlaylistBundle\Controller;
+
+use Muzich\CoreBundle\lib\Controller;
+use Muzich\CoreBundle\Entity\Playlist;
+use Muzich\CoreBundle\lib\AutoplayManager;
+
+class ShowController extends Controller
+{
+  
+  public function userAction($user_slug)
+  {
+    if (!($viewed_user = $this->findUserWithSlug($user_slug)))
+    {
+      throw $this->createNotFoundException();
+    }
+    
+    return $this->render('MuzichPlaylistBundle:Show:user.html.twig', array(
+      'viewed_user' => $viewed_user,
+      'playlists'   => $this->getPlaylistManager()->getUserPublicsOrOwnedPlaylists($viewed_user, $this->getUser(true))
+    ));
+  }
+  
+  public function showAction($user_slug, $playlist_id)
+  {
+    if (!($playlist = $this->getPlaylistManager()->findOneAccessiblePlaylistWithId($playlist_id, $this->getUser(true))))
+      throw $this->createNotFoundException();
+    
+    return $this->render('MuzichPlaylistBundle:Show:show.html.twig', array(
+      'playlist' => $playlist
+    ));
+  }
+  
+  public function getAutoplayDataAction($playlist_id)
+  {
+    $playlist_manager = $this->getPlaylistManager();
+    
+    if (!($playlist = $playlist_manager->findOneAccessiblePlaylistWithId($playlist_id, $this->getUser(true))))
+      throw $this->createNotFoundException();
+    
+    $autoplaym = new AutoplayManager($playlist_manager->getPlaylistElements($playlist), $this->container);
+    
+    return $this->jsonResponse(array(
+      'status'    => 'success',
+      'data'      => $autoplaym->getList()
+    ));
+  }
+  
+}

src/Muzich/PlaylistBundle/MuzichPlaylistBundle.php

+<?php
+
+namespace Muzich\PlaylistBundle;
+
+use Symfony\Component\HttpKernel\Bundle\Bundle;
+
+class MuzichPlaylistBundle extends Bundle
+{
+  
+}

src/Muzich/PlaylistBundle/Resources/config/routing.yml

+playlists_user:
+  pattern: /user/{user_slug}/playlists
+  defaults: { _controller: MuzichPlaylistBundle:Show:user }
+
+playlist:
+  pattern: /user/{user_slug}/playlist/{playlist_id}
+  defaults: { _controller: MuzichPlaylistBundle:Show:show }
+
+playlist_datas_for_autoplay:
+  pattern: /ajax/autoplay/playlist/datas/{playlist_id}
+  defaults: { _controller: MuzichPlaylistBundle:Show:getAutoplayData }

src/Muzich/PlaylistBundle/Resources/views/Show/show.html.twig

+{% extends "MuzichFavoriteBundle::layout.html.twig" %}
+
+{% block title %}{% endblock %}
+{% block mainbox_classes %}{% endblock %}
+
+{% block content %}
+  
+  <div class="top_tools">
+    
+    <a class="autoplay_playlist" href="{{ path('playlist_datas_for_autoplay', { 'playlist_id' : playlist.id }) }}" >
+      Lire
+    </a>
+    
+    <h2>{{ playlist.name }}</h2>
+    
+    {% include "MuzichCoreBundle:Tag:tag_cloud.html.twig" with {
+      'tags' : playlist.tags
+    } %}
+    
+    {% if playlist.elements|length %}
+      <ul class="playlist_elements">
+        {% for element in playlist.elements %}
+          <li class="playlist_element">
+            <a class="open_element" href="{{ path('element_get_one', { 'element_id' : element.id }) }}" data-id="{{ element.id }}">
+              {{ element.name }}
+            </a>
+          </li>
+        {% endfor %}
+      </ul>
+    {% endif %}
+  
+  </div>
+  
+{% endblock %}

src/Muzich/PlaylistBundle/Resources/views/Show/user.html.twig

+{% extends "MuzichHomeBundle::layout.html.twig" %}
+
+{% block title %}{% endblock %}
+{% block mainbox_classes %}{% endblock %}
+
+{% block content %}
+  
+  {% if playlists|length %}
+  <ul class="playlists">
+    {% for playlist in playlists %}
+      <li>
+        <a href="{{ path('playlist', { 'user_slug' : viewed_user.slug, 'playlist_id' : playlist.id }) }}">
+          {{ playlist.name }}
+        </a>
+        
+        {% include "MuzichCoreBundle:Tag:tag_cloud.html.twig" with {
+          'tags' : playlist.tags
+        } %}
+        
+      </li>
+    {% endfor %}
+  </ul>
+  {% endif %}
+  
+{% endblock %}