failed stage: score for playlist

src/Muzich/CoreBundle/Command/RecalculateReputationCommand.php

 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Muzich\CoreBundle\Entity\EventArchive;
+use Muzich\CoreBundle\Entity\Element;
 
 class RecalculateReputationCommand extends ContainerAwareCommand
 {
   protected function configure()
   {
     $this
-      ->setName('users:reputation:recalculate')
-      ->setDescription('Recalcul des scores de reputation')
+      ->setName('score:recalculate')
+      ->setDescription('Recalcul des scores')
       ->addOption('user', null, InputOption::VALUE_REQUIRED, 'username du compte a traiter')
 //      ->addArgument('sites', InputArgument::OPTIONAL, 'Liste exhaustive des site a traiter')
 //      ->addOption('yell', null, InputOption::VALUE_NONE, 'If set, the task will yell in uppercase letters')
   {
     $doctrine = $this->getContainer()->get('doctrine');
     $em = $doctrine->getEntityManager();
-
+    
     $output->writeln('#');
-    $output->writeln('## Script de recalcul des scores de reputation ##');
+    $output->writeln('## Script de recalcul des scores ##');
     $output->writeln('#');
 
     $output->writeln('<info>Début du traitement ...</info>');
+    $this->recalculateUserScores($input, $output);
+    $this->recalculateElementScores($input, $output);
+    
+    $output->writeln('<info>Saving in database ...</info>');
+    $em->flush();
+    $output->writeln('<info>Terminé !</info>');
+  }
+  
+  protected function recalculateUserScores(InputInterface $input, OutputInterface $output)
+  {
+    $doctrine = $this->getContainer()->get('doctrine');
+    $em = $doctrine->getEntityManager();
     
     if (($username = $input->getOption('user')))
     {
       foreach ($elements as $element)
       {
         $element_points += $element->getPoints();
+        // Point déjà ajoutés a l'user
+        $element_points -= ($element->getCountFavorited()*$this->getContainer()->getParameter('reputation_element_favorite_value'));
       }
       
       /*
       
       $user->setReputation($points);
       $em->persist($user);
-      $em->flush();
+      $output->writeln('<info>User "'.$user->getUsername().'": '.$points.' score</info>');
     }
     
-    $output->writeln('<info>Terminé !</info>');
   }
+    
+  protected function recalculateElementScores(InputInterface $input, OutputInterface $output)
+  {
+    $doctrine = $this->getContainer()->get('doctrine');
+    $em = $doctrine->getEntityManager();
+    
+    $elements = $em->createQuery(
+      "SELECT element FROM MuzichCoreBundle:Element element"
+    )->getResult();
+    
+    foreach ($elements as $element)
+    {
+      $element->setPoints($this->getElementScore($element));
+      $em->persist($element);
+    }
+    
+  }
+  
+  protected function getElementScore(Element $element)
+  {
+    $element_score = 0;
+    
+    $element_score += (count($element->getVoteGoodIds())*$this->getContainer()->getParameter('reputation_element_point_value'));
+    
+    $element_score += ($element->getCountFavorited()*$this->getContainer()->getParameter('reputation_element_favorite_value'));
+    
+    $element_score += ($element->getCountPlaylisted()*$this->getContainer()->getParameter('reputation_element_added_to_playlist'));
+    
+    return $element_score;
+  }
+  
 }

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

 use Muzich\CoreBundle\Entity\UsersElementsFavorites;
 use Muzich\CoreBundle\Entity\User;
 use Muzich\CoreBundle\Managers\PlaylistManager;
+use Muzich\CoreBundle\Propagator\EventElement;
 
 class LoadUsersElementsFavoritesData  extends AbstractFixture implements OrderedFixtureInterface, ContainerAwareInterface
 {
     
     $playlist_manager->addElementsToPlaylist($elements, $playlist);
     $this->entity_manager->persist($playlist);
+    $this->entity_manager->flush();
+    
+    foreach ($elements as $element)
+    {
+      $event = new EventElement($this->container);
+      $event->addedToPlaylist($element, $user, $playlist);
+      $this->entity_manager->persist($element);
+    }
+    
     return $playlist;
   }
   

src/Muzich/CoreBundle/Entity/Element.php

   protected $count_report;
   
   /**
+<<<<<<< Updated upstream
+=======
+   * @ORM\Column(type="integer", nullable=true)
+   * @var int 
+   */
+  protected $count_favorited;
+  
+  /**
+   * @ORM\Column(type="integer", nullable=true)
+   * @var int 
+   */
+  protected $count_playlisted;
+  
+  /**
+>>>>>>> Stashed changes
    * @ORM\Column(type="boolean", nullable=false)
    * @var int 
    */
     $this->slug = $slug;
   }
   
+  public function getCountFavorited()
+  {
+    if (!$this->count_favorited)
+      return 0;
+    
+    return $this->count_favorited;
+  }
+  
+  public function setCountFavorited($count_favorited)
+  {
+    $this->count_favorited = $count_favorited;
+  }
+  
+  public function increaseCountFavorited()
+  {
+    $this->setCountFavorited($this->getCountFavorited()+1);
+  }
+  
+  public function uncreaseCountFavorited()
+  {
+    $this->setCountFavorited($this->getCountFavorited()-1);
+  }
+  
+  public function getCountPlaylisted()
+  {
+    if (!$this->count_playlisted)
+      return 0;
+    
+    return $this->count_playlisted;
+  }
+  
+  public function setCountPlaylisted($count_playlisted)
+  {
+    $this->count_playlisted = $count_playlisted;
+  }
+  
+  public function increaseCountPlaylisted()
+  {
+    $this->setCountPlaylisted($this->getCountPlaylisted()+1);
+  }
+  
+  public function uncreaseCountPlaylisted()
+  {
+    $this->setCountPlaylisted($this->getCountPlaylisted()-1);
+  }
+  
 }

src/Muzich/CoreBundle/Entity/Playlist.php

     return $elements_manager->have($element);
   }
   
+  public function getCountElement(Element $element)
+  {
+    $elements_manager = new ElementCollectionManager(json_decode($this->elements, true));
+    return $elements_manager->count($element);
+  }
+  
   public function haveElementId($element_id)
   {
     $elements_manager = new ElementCollectionManager(json_decode($this->elements, true));
     return $elements_manager->haveRefId($element_id);
   }
   
+  public function getElementDataWithIndex($index)
+  {
+    $elements_manager = new ElementCollectionManager(json_decode($this->elements, true));
+    return $elements_manager->getLineWithIndex($index);
+  }
+  
   public function haveTagId($tag_id)
   {
     $tags_manager = new TagCollectionManager(json_decode($this->tags, true));

src/Muzich/CoreBundle/Managers/PlaylistManager.php

     $this->entity_manager->persist($playlist);
   }
   
+  /** @return Element */
+  public function getElementWithIndex(Playlist $playlist, $index)
+  {
+    $element_data = $playlist->getElementDataWithIndex($index);
+    return $this->entity_manager->getRepository('MuzichCoreBundle:Element')
+      ->findOneById($element_data['id']);
+  }
+  
 }

src/Muzich/CoreBundle/Propagator/EventElement.php

 use Muzich\CoreBundle\Managers\EventArchiveManager;
 use Muzich\CoreBundle\Entity\EventArchive;
 use Muzich\CoreBundle\Security\Context as SecurityContext;
+use Muzich\CoreBundle\Entity\Playlist;
 
 /**
  * Propagateur d'événement concernant les éléments
     }
   }
   
+  public function addedToPlaylist(Element $element, User $added_by_user, Playlist $playlist)
+  {
+    // On persiste les modifs pour compter correctement
+    $this->getEntityManager()->persist($playlist);
+    $this->getEntityManager()->flush();
+    
+    $ur = new UserReputation($element->getOwner());
+    $security_context = new SecurityContext($added_by_user);
+    if (
+        !$security_context->actionIsAffectedBy(SecurityContext::AFFECT_NO_SCORING, SecurityContext::ACTION_PLAYLIST_ADD_ELEMENT) 
+        // Qu'une seule fois dans la playlist
+        && $playlist->getCountElement($element) == 1
+        // Element dans une seule playlist (par la suite ca ne rapporte plus de points)
+        && $this->countUserPlaylistWithElement($added_by_user, $element) == 1
+        && $element->getOwner()->getId() != $added_by_user->getId()
+    )
+    {
+      $score_action = $this->container->getParameter('reputation_element_added_to_playlist');
+      $ur->addPoints($score_action);
+      $element->addPoints($score_action);
+      $element->increaseCountPlaylisted();
+    }
+  }
+  
+  protected function countUserPlaylistWithElement(User $user, Element $element)
+  {
+    return $this->getEntityManager()->createQueryBuilder()
+      ->select('COUNT(p)')
+      ->from('MuzichCoreBundle:Playlist', 'p')
+      ->where('p.elements LIKE :element_id AND p.owner = :owner_id')
+      ->setParameter('owner_id', $user->getId())
+      ->setParameter('element_id', '%"id":"'.$element->getId().'"%')
+      ->getQuery()
+      ->getSingleScalarResult()
+    ;
+  }
+  
+  public function removedFromPlaylist(Element $element, User $removed_by_user, Playlist $playlist)
+  {
+    // On persiste les modifs pour compter correctement
+    $this->getEntityManager()->persist($playlist);
+    $this->getEntityManager()->flush();
+    
+    $ur = new UserReputation($element->getOwner());
+    $security_context = new SecurityContext($removed_by_user);
+    if (
+        !$security_context->actionIsAffectedBy(SecurityContext::AFFECT_NO_SCORING, SecurityContext::ACTION_PLAYLIST_REMOVE_ELEMENT) 
+        // L'element n'est plus dans la playlist
+        && $playlist->getCountElement($element) == 0
+        // On ne trouve plus l'element dans ses playlists
+        && $this->countUserPlaylistWithElement($removed_by_user, $element) == 0
+        && $element->getOwner()->getId() != $removed_by_user->getId()
+    )
+    {
+      $score_action = $this->container->getParameter('reputation_element_added_to_playlist');
+      $ur->removePoints($score_action);
+      $element->removePoints($score_action);
+      $element->uncreaseCountPlaylisted();
+    }
+  }
+  
   /**
    * Des tags viennent d'être proposé a un élément
    *

src/Muzich/CoreBundle/Propagator/EventPropagator.php

 namespace Muzich\CoreBundle\Propagator;
 
 use Symfony\Component\DependencyInjection\Container;
+use Doctrine\ORM\EntityManager;
 
 /**
  * Description of EventPropagator
   {
     $this->container = $container;
   }
+  
+  /** @return EntityManager */
+  protected function getEntityManager()
+  {
+    return $this->container->get('doctrine')->getEntityManager();
+  }
+  
 }

src/Muzich/CoreBundle/Twig/Extensions/MyTwigExtension.php

     return $this->container->get('form.csrf_provider')->generateCsrfToken($intention);
   }
   
-  public function path_token($route, $parameters = array(), $intention = '', $absolute = false)
+  public function path_token($route, $parameters = array(), $intention = 'unknown', $absolute = false)
   {
     $parameters = array_merge($parameters, array('token' => $this->token($intention)));
     return $this->container->get('router')->generate($route, $parameters, $absolute);

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

     }
   }
   
+  public function count($object)
+  {
+    $count = 0;
+    $method_name = 'get' . $this->object_reference_attribute;
+    foreach ($this->content as $content_line)
+    {
+      if ($object->$method_name() == $content_line[lcfirst($this->object_reference_attribute)])
+      {
+        $count++;
+      }
+    }
+    
+    return $count;
+  }
+  
   public function have($object)
   {
     $method_name = 'get' . $this->object_reference_attribute;
     }
   }
   
+  public function getLineWithIndex($index)
+  {
+    if (array_key_exists($index, $this->content))
+    {
+      return $this->content[$index];
+    }
+  }
+  
   public function index($object)
   {
     $method_name = 'get' . $this->object_reference_attribute;

src/Muzich/PlaylistBundle/Controller/EditController.php

 use Muzich\CoreBundle\lib\Controller;
 use Symfony\Component\HttpFoundation\Request;
 use Muzich\CoreBundle\Security\Context as SecurityContext;
+use Muzich\CoreBundle\Propagator\EventElement;
 
 class EditController extends Controller
 {
     if (!$this->tokenIsCorrect() || !($playlist = $playlist_manager->findOwnedPlaylistWithId($playlist_id, $this->getUser())))
       return $this->jsonNotFoundResponse();
     
+    $element = $playlist_manager->getElementWithIndex($index);
     $playlist_manager->removePlaylistElementWithIndex($playlist, $index);
+    
+    $event = new EventElement($this->container);
+    $event->removedFromPlaylist($element, $this->getUser(), $playlist);
+    
+    $this->persist($element);
     $this->flush();
     return $this->jsonSuccessResponse();
   }
       return $this->jsonNotFoundResponse();
     
     $playlist_manager->addElementToPlaylist($element, $playlist);
+    
+    $event = new EventElement($this->container);
+    $event->addedFromPlaylist($element, $this->getUser(), $playlist);
+    
+    $this->persist($element);
     $this->flush();
     return $this->jsonSuccessResponse();
   }
     if ($form->isValid())
     {
       $this->getPlaylistManager()->addElementToPlaylist($element, $form->getData());
+      
+      $event = new EventElement($this->container);
+      $event->addedFromPlaylist($element, $this->getUser(), $form->getData());
+
+      $this->persist($element);
       $this->flush();
       return $this->jsonSuccessResponse();
     }
     $new_playlist = $this->getPlaylistManager()->copyPlaylist($this->getUser(), $playlist);
     $this->getPlaylistManager()->addElementToPlaylist($element, $new_playlist);
     $this->getPlaylistManager()->removePickedPlaylistToUser($this->getUser(), $playlist);
+    
+    $event = new EventElement($this->container);
+    $event->addedFromPlaylist($element, $this->getUser(), $new_playlist);
+    
+    $this->persist($element);
     $this->flush();
     
     return $this->jsonSuccessResponse();