Evolution #584: Propositions de stags: cacher

src/Muzich/CoreBundle/Controller/ElementController.php

 use Muzich\CoreBundle\Entity\ElementTagsProposition;
 use Symfony\Component\HttpFoundation\Request;
 use Muzich\CoreBundle\Entity\Element;
+use Muzich\CoreBundle\Entity\Event;
 use Muzich\CoreBundle\Util\TagLike;
 use Muzich\CoreBundle\Entity\User;
 use Muzich\CoreBundle\lib\AutoplayManager;
 use Muzich\CoreBundle\Searcher\ElementSearcher;
+use Symfony\Component\HttpFoundation\File\Exception\AccessDeniedException;
 
 class ElementController extends Controller
 {
       $this->getDoctrine()->getEntityManager()->remove($proposition);
     }
     
+    // Traitement de l'Event si il y a
+    $this->removeElementFromEvent($element->getId(), Event::TYPE_TAGS_PROPOSED);
+    
     $this->getDoctrine()->getEntityManager()->flush();
     $element = $this->getDoctrine()->getRepository('MuzichCoreBundle:Element')
       ->findOneById($element->getId())
     {
       $this->getDoctrine()->getEntityManager()->remove($proposition);
     }
+    
+    // Traitement de l'Event si il y a
+    $this->removeElementFromEvent($element->getId(), Event::TYPE_TAGS_PROPOSED);
+    
     // On spécifie qu'il n'y as plus de proposition
     $element->setHasTagProposition(false);
     $this->getDoctrine()->getEntityManager()->persist($element);
     ));
   }
   
+  
+  protected function removeElementFromEvent($element_id, $event_type)
+  {
+    if (($event = $this->getEntityManager()->getRepository('MuzichCoreBundle:Event')
+          ->findUserEventWithElementId($this->getUserId(), $element_id, $event_type)))
+    {
+      $event->removeId($element_id);
+      if (!$event->getCount())
+      {
+        $this->remove($event);
+        $this->flush();
+        return;
+      }
+      
+      $this->persist($event);
+      $this->flush();
+    }
+  }
+  
   public function reshareAction(Request $request, $element_id, $token)
   {
     if (($response = $this->mustBeConnected(true)))

src/Muzich/CoreBundle/Entity/Event.php

     }
     $this->setIds($ids);
   }
-    
+  
+  public function removeId($id)
+  {
+    if ($this->hasId($id))
+    {
+      $new_ids = array();
+      $ids = $this->getIds();
+      foreach ($ids as $i => $idc)
+      {
+        if ($id != $idc)
+        {
+          $new_ids[] = $idc;
+        }
+      }
+      $this->setIds($new_ids);
+      $this->setCount(count($new_ids));
+    }
+  }
   /**
    * Répond vrai si l'id transmis fait partis des ids
    * 

src/Muzich/CoreBundle/Repository/EventRepository.php

     return $events;
   }
   
+  public function findUserEventWithElementId($user_id, $element_id, $event_type)
+  {
+    $query =  $this->getEntityManager()
+      ->createQuery('SELECT e FROM MuzichCoreBundle:Event e
+        WHERE e.user = :uid AND
+        e.ids LIKE :eid AND
+        e.type = :etype'
+      )
+      ->setParameters(array(
+        'uid' => $user_id,
+        'eid' => '%"'.$element_id.'"%',
+        'etype' => $event_type
+      ))
+    ;
+    try {
+        return $query->getSingleResult();
+    } catch (\Doctrine\ORM\NoResultException $e) {
+        return null;
+    }
+  }
+  
 }

src/Muzich/CoreBundle/Tests/Controller/EventTest.php

     $this->assertEquals(count($result), 0);
   }
   
+  public function testElementTagsPropositions()
+  {
+    $this->client = self::createClient();
+    $this->connectUser('bux', 'toor');
+    
+    $paul = $this->getUser('paul');
+    $bux = $this->getUser('bux');
+    
+    $element_1 = $this->findOneBy('Element', 'Infected Mushroom - Psycho');
+    $element_2 = $this->findOneBy('Element', 'CardioT3K - Juggernaut Trap ');
+    $tag_1     = $this->findOneBy('Tag', 'Metal');
+    
+    // Bux propose un tag de remplacement sur son element 1
+    $this->eventCount($paul, Event::TYPE_TAGS_PROPOSED, 0);
+    $this->proposeElementTags($element_1, $bux, array($tag_1->getId()));
+    $this->eventCount($paul, Event::TYPE_TAGS_PROPOSED, 1);
+    $this->eventHasElementId($paul, Event::TYPE_TAGS_PROPOSED, $element_1->getId());
+    // Deuxieme proposition
+    $this->proposeElementTags($element_2, $bux, array($tag_1->getId()));
+    $this->eventCount($paul, Event::TYPE_TAGS_PROPOSED, 1);
+    $this->eventHasElementId($paul, Event::TYPE_TAGS_PROPOSED, $element_1->getId());
+    $event = $this->eventHasElementId($paul, Event::TYPE_TAGS_PROPOSED, $element_2->getId());
+    // On connecte paul
+    $this->disconnectUser();
+    $this->connectUser('paul', 'toor');
+    $this->acceptTagProposition($paul, $this->getElementTagProposition($element_1->getId(), $bux->getId())->getId());
+    $this->eventCount($paul, Event::TYPE_TAGS_PROPOSED, 1);
+    $this->eventHasNotElementId($paul, Event::TYPE_TAGS_PROPOSED, $element_1->getId());
+    $this->eventHasElementId($paul, Event::TYPE_TAGS_PROPOSED, $element_2->getId());
+    $this->refuseTagProposition($paul, $element_2->getId());
+    $this->eventCount($paul, Event::TYPE_TAGS_PROPOSED, 0);
+  }
+  
+  protected function eventCount($user, $type, $count)
+  {
+    $events = $this->getDoctrine()->getEntityManager()
+      ->createQuery('SELECT e FROM MuzichCoreBundle:Event e
+        WHERE e.user = :uid AND e.type = :type'
+      )
+      ->setParameters(array(
+        'uid' => $user->getId(),
+        'type' => $type
+      ))
+      ->getArrayResult()
+    ;
+    $this->assertEquals(count($events), $count);
+  }
+  
+  protected function proposeElementTags($element, $user, $tags_ids)
+  {
+    $crawler = $this->client->request(
+      'POST', 
+      $this->generateUrl('ajax_element_propose_tags_proceed', 
+        array('element_id' => $element->getId(), 'token' => $user->getPersonalHash())
+      ), 
+      array(
+        'element_tag_proposition_'.$element->getId() => array(
+          'tags' => json_encode($tags_ids)
+        )
+      ), 
+      array(), 
+      array('HTTP_X-Requested-With' => 'XMLHttpRequest')
+    );
+    
+    $this->isResponseSuccess();
+    
+    $response = json_decode($this->client->getResponse()->getContent(), true);
+    $this->assertEquals($response['status'], 'success');
+  }
+  
+  protected function eventHasElementId($user, $type, $element_id)
+  {
+    $events = $this->getDoctrine()->getEntityManager()
+      ->createQuery('SELECT e FROM MuzichCoreBundle:Event e
+        WHERE e.user = :uid AND e.type = :type AND e.ids LIKE :eid'
+      )
+      ->setParameters(array(
+        'uid' => $user->getId(),
+        'type' => $type,
+        'eid' => '%"'.$element_id.'"%'
+      ))
+      ->getArrayResult()
+    ;
+    $this->assertEquals(count($events), 1);
+    return $events[0];
+  }
+  
+  protected function eventHasNotElementId($user, $type, $element_id)
+  {
+    $events = $this->getDoctrine()->getEntityManager()
+      ->createQuery('SELECT e FROM MuzichCoreBundle:Event e
+        WHERE e.user = :uid AND e.type = :type AND e.ids LIKE :eid'
+      )
+      ->setParameters(array(
+        'uid' => $user->getId(),
+        'type' => $type,
+        'eid' => '%"'.$element_id.'"%'
+      ))
+      ->getArrayResult()
+    ;
+    $this->assertEquals(count($events), 0);
+  }
+  
+  protected function acceptTagProposition($user, $proposition_id)
+  {
+    $crawler = $this->client->request(
+      'POST', 
+      $this->generateUrl('ajax_element_proposed_tags_accept', 
+        array(
+          'proposition_id' => $proposition_id,
+          'token' => $user->getPersonalHash()
+        )
+      ), 
+      array(), 
+      array(), 
+      array('HTTP_X-Requested-With' => 'XMLHttpRequest')
+    );
+    
+    $this->isResponseSuccess();
+    
+    $response = json_decode($this->client->getResponse()->getContent(), true);
+    $this->assertEquals($response['status'], 'success');
+  }        
+  
+  protected function refuseTagProposition($user, $element_id)
+  {
+    $crawler = $this->client->request(
+      'POST', 
+      $this->generateUrl('ajax_element_proposed_tags_refuse', 
+        array(
+          'element_id' => $element_id,
+          'token' => $user->getPersonalHash()
+        )
+      ), 
+      array(), 
+      array(), 
+      array('HTTP_X-Requested-With' => 'XMLHttpRequest')
+    );
+    
+    $this->isResponseSuccess();
+    
+    $response = json_decode($this->client->getResponse()->getContent(), true);
+    $this->assertEquals($response['status'], 'success');
+  }
+  
+  protected function getElementTagProposition($element_id, $user_id)
+  {
+    $propositions = $this->getDoctrine()->getEntityManager()
+      ->createQuery('SELECT p, t FROM MuzichCoreBundle:ElementTagsProposition p'
+        .' JOIN p.tags t WHERE p.element = :eid AND p.user = :uid')
+      ->setParameters(array(
+        'eid' => $element_id,
+        'uid' => $user_id
+      ))
+      ->getResult();
+    if (count($propositions))
+    {
+      return $propositions[0];
+    }
+  }
+  
 }

src/Muzich/CoreBundle/lib/Controller.php

   }
   
   /**
+   *
+   * @param object $entity 
+   */
+  public function remove($entity)
+  {
+    $this->getEntityManager()->remove($entity);
+  }
+  
+  /**
    * 
    */
   public function flush()

src/Muzich/UserBundle/Controller/EventController.php

           'errors' => array('NotFound')
         ));
       }
-      throw $this->createNotFoundException('Ressource ajax uniquement.');
+      return $this->redirect($this->generateUrl('index'));
     }
     
     if ($event->getUser()->getId() != $this->getUserId())

src/Muzich/UserBundle/Resources/views/Event/elements.html.twig

     
     <div class="show_options">
      
-      <a class="button darkbutton" href="{{ path('event_delete', {
-        'event_id' : event.id,
-        'token'    : app.user.getPersonalHash(event.id)
-      }) }}" >
-        {{ 'events.view.link_delete'|trans({}, 'userui') }}
-      </a>
+      {% if event.type != event_const('TYPE_TAGS_PROPOSED') %}
+        <a class="button darkbutton" href="{{ path('event_delete', {
+          'event_id' : event.id,
+          'token'    : app.user.getPersonalHash(event.id)
+        }) }}" >
+          {{ 'events.view.link_delete'|trans({}, 'userui') }}
+        </a>
+      {% endif %}
     
     </div>