Evolution #125: Actualisation des éléments ajax

app/Resources/translations/userui.fr.yml

     inputs:
       cancel:       Annuler
       submit:       Faire la demande
+  new:
+    has_news:       %count% éléments viennent d'être ajoutés, %link%
+    has_news_one:   %count% élément vient d'être ajouté, %link%
+    has_news_link:  cliquez ici pour les afficher
+    has_news_link_one:  cliquez ici pour l'afficher
+    has_news_link_more_x:  cliquez ici pour en afficher %x%
            
 filter:
   network: "Résultats de "

src/Muzich/CoreBundle/Controller/ElementController.php

     }
   }
   
+  protected function getcountNewMessage($count)
+  {
+    if ($count == 1)
+    {
+      $transid = 'tags.new.has_news_one';
+      $transidlink = 'tags.new.has_news_link_one';
+    }
+    else if ($count == 0)
+    {
+      return '';
+    }
+    else 
+    {
+      $transid = 'tags.new.has_news';
+      $transidlink = 'tags.new.has_news_link';
+    }
+    
+    
+    if ($count > ($limit = $this->container->getParameter('search_default_count')))
+    {
+      $link = $this->trans(
+        'tags.new.has_news_link_more_x', 
+        array(
+          '%x%' => $limit
+        ), 
+        'userui'
+      );
+    }
+    else
+    {
+      $link = $this->trans(
+        $transidlink, 
+        array(), 
+        'userui'
+      );
+    }
+    
+    $link = '<a href="#" class="show_new_elements" >'.$link.'</a>';
+    
+    return $this->trans(
+      $transid, 
+      array(
+        '%count%' => $count,
+        '%link%'  => $link
+      ), 
+      'userui'
+    );
+  }
+  
+  /**
+   * Retourne le nombre de nouveaux éléments possible
+   *
+   * @param int $refid 
+   */
+  public function countNewsAction($refid)
+  {
+    if (!$this->getRequest()->isXmlHttpRequest())
+    { 
+      return $this->redirect($this->generateUrl('index'));
+    }
+    
+    if ($this->getUser() == 'anon.')
+    {
+      if ($this->getRequest()->isXmlHttpRequest())
+      {
+        return $this->jsonResponse(array(
+          'status' => 'mustbeconnected'
+        ));
+      }
+      else
+      {
+        return $this->redirect($this->generateUrl('index'));
+      }
+    }
+    
+    $es = $this->getElementSearcher();
+    $es->update(array(
+      // On veux de nouveaux éléments
+      'searchnew' => true,
+      // Notre id de référence
+      'id_limit'  => $refid
+    ));
+    
+    $count = $es->getElements($this->getDoctrine(), $this->getUserId(), 'count');
+    
+    return $this->jsonResponse(array(
+      'status'   => 'success',
+      'count'    => $count,
+      'message'  => $this->getcountNewMessage($count)
+    ));
+  }
+  
+  /**
+   * Cette action, utilisé en ajax seulement, retourne les x nouveaux éléments
+   * depuis le refid transmis. Tout en respectant le filtre en cours.
+   * 
+   * @param int $refid identifiant de l'élément de référence
+   * 
+   * @return jsonResponse
+   */
+  public function getNewsAction($refid)
+  {
+    if (!$this->getRequest()->isXmlHttpRequest())
+    { 
+      return $this->redirect($this->generateUrl('index'));
+    }
+    
+    if ($this->getUser() == 'anon.')
+    {
+      if ($this->getRequest()->isXmlHttpRequest())
+      {
+        return $this->jsonResponse(array(
+          'status' => 'mustbeconnected'
+        ));
+      }
+      else
+      {
+        return $this->redirect($this->generateUrl('index'));
+      }
+    }
+    
+    $es = $this->getElementSearcher();
+    $es->update(array(
+      // On veux de nouveaux éléments
+      'searchnew' => true,
+      // Notre id de référence
+      'id_limit'  => $refid,
+      // On en veut qu'un certain nombres
+      'count'     => $this->container->getParameter('search_default_count')
+    ));
+    
+    // Récupération de ces nouveaux élméents
+    $elements = $es->getElements($this->getDoctrine(), $this->getUserId());
+    
+    // On en fait un rendu graphique
+    $html_elements = $this->render('MuzichCoreBundle:SearchElement:default.html.twig', array(
+      'user'        => $this->getUser(),
+      'elements'    => $elements,
+      'invertcolor' => false
+    ))->getContent();
+    
+    // On calcule le nouveau compte de nouveaux
+    $count = 0;
+    if (count($elements))
+    {      
+      $es->update(array(
+        // On veux de nouveaux éléments
+        'searchnew' => true,
+        // Notre id de référence
+        'id_limit'  => $elements[0]->getId(),
+        // On n'en récupère que x
+        'count'     => $this->container->getParameter('search_default_count')
+      ));
+      $count = $es->getElements($this->getDoctrine(), $this->getUserId(), 'count');
+    }
+    
+    return $this->jsonResponse(array(
+      'status'  => 'success',
+      'html'    => $html_elements,
+      'count'   => $count,
+      'message' => $this->getcountNewMessage($count)
+    ));
+  }
+  
 }

src/Muzich/CoreBundle/Repository/ElementRepository.php

    * @param ElementSearcher $searcher
    * @return Doctrine\ORM\Query
    */
-  public function findBySearch(ElementSearcher $searcher, $user_id)
-  {    
+  public function findBySearch(ElementSearcher $searcher, $user_id, $exec_type = 'execute')
+  {
     // Tableaux des paramétres
     $params_ids = array();
     $params_select = array();
     $params_select['uid'] = $user_id;
+    $order_by = "ORDER BY e_.created DESC, e_.id DESC";
     
     // Booléen nous permettant de savoir si un where a déjà été écrit
     $is_where = false;
       }
     }
     
-    // Si id_limit est précisé c'est que l'on demande "la suite"
+    // Si id_limit est précisé c'est que l'on demande "la suite" ou "les nouveaux"
     $where_id_limit = '';
-    if (($id_limit = $searcher->getIdLimit()))
+    if (($id_limit = $searcher->getIdLimit()) && !$searcher->isSearchingNew())
     {
       $where_id_limit = ($is_where) ? ' AND' : ' WHERE';
       $is_where = true;
       $where_id_limit .= " e_.id < :id_limit";
       $params_ids['id_limit'] = $id_limit;
     }
+    elseif ($id_limit && $searcher->isSearchingNew())
+    {
+      $where_id_limit = ($is_where) ? ' AND' : ' WHERE';
+      $is_where = true;
+      $where_id_limit .= " e_.id > :id_limit";
+      $params_ids['id_limit'] = $id_limit;
+      // Pour pouvoir charger les x nouveaux on doit organiser la liste 
+      // de manière croissante
+      $order_by = "ORDER BY e_.created ASC, e_.id ASC";
+    }
     
     // Requête qui selectionnera les ids en fonction des critéres
-    $r_ids = $this->getEntityManager()
+    $id_query = $this->getEntityManager()
       ->createQuery(
         "SELECT e_.id
         FROM MuzichCoreBundle:Element e_
         $where_favorite
         $where_id_limit
         GROUP BY e_.id
-        ORDER BY e_.created DESC, e_.id DESC")
+        $order_by")
      ->setParameters($params_ids)
-     ->setMaxResults($searcher->getCount())
-     ->getArrayResult()
     ;
     
+    // Si on a précisé que l'on voulait un count, pas de limite
+    if ($exec_type != 'count')
+    {
+      $id_query->setMaxResults($searcher->getCount());
+    }
+    
+    // si l'on a demandé un count
+    if ($exec_type == 'count')
+    {
+      // On retourne cette query
+      return $id_query;
+    }
+    
+    $r_ids = $id_query->getArrayResult();
+    
     $ids = array();
     
     if (count($r_ids))

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

   pattern: /element/{element_id}/remove
   defaults: { _controller: MuzichCoreBundle:Element:remove }
   
+element_new_count:
+  pattern: /ajax/element/new/count/{refid}
+  defaults: { _controller: MuzichCoreBundle:Element:countNews, refid: null }
+  
+element_new_get:
+  pattern: /ajax/element/new/get/{refid}
+  defaults: { _controller: MuzichCoreBundle:Element:getNews, refid: null }
   

src/Muzich/CoreBundle/Resources/views/layout.html.twig

     url_search_tag = "{{ path('search_tag') }}";
     url_get_favorites_tags = "{{ path('ajax_get_favorites_tags') }}";
     url_add_tag = "{{ path('ajax_add_tag') }}";
+    url_element_new_count = "{{ path('element_new_count') }}";
+    url_element_new_get = "{{ path('element_new_get') }}";
   </script>
   {% block js %}{% endblock %}
   

src/Muzich/CoreBundle/Searcher/ElementSearcher.php

   /**
    * Si id_limit est renseigné c'est que l'on veut trouver les elements
    * plus vieux (ont utilise l'id comme référence) que l'id_limi passé.
+   * EDIT: Ou les éléments plus récents si $searchnew est a vrai
    * 
    * @var type int
    */
   protected $id_limit = null;
   
   /**
+   * Si searchnew est a vrai, c'est que l'on recherche les nouveau éléments 
+   * depuis id_limit.
+   * 
+   * @var type boolean
+   */
+  protected $searchnew = false;
+  
+  /**
    * @see SearcherInterface
    * @param array $params 
    */
     
     // Mise a jour des attributs
     $this->setAttributes(array(
-      'network', 'tags', 'count', 'user_id', 'group_id', 'favorite', 'id_limit'
+      'network', 'tags', 'count', 'user_id', 'group_id', 'favorite', 'id_limit', 'searchnew'
     ), $params);
     
   }
   {
     // Mise a jour des attributs
     $this->setAttributes(array(
-      'network', 'tags', 'count', 'user_id', 'group_id', 'favorite', 'id_limit'
+      'network', 'tags', 'count', 'user_id', 'group_id', 'favorite', 'id_limit', 'searchnew'
     ), $params);
   }
   
    * Construction de l'objet Query
    *
    * @param Registry $doctrine
+   * @param int $user_id
+   * @param string $exec_type
+   * 
    * @return collection
    */
-  protected function constructQueryObject(Registry $doctrine, $user_id)
+  protected function constructQueryObject(Registry $doctrine, $user_id, $exec_type = 'execute')
   {
     $this->setQuery($doctrine
       ->getRepository('MuzichCoreBundle:Element')
-      ->findBySearch($this, $user_id))
+      ->findBySearch($this, $user_id, $exec_type))
     ;
   }
   
    * Retourne l'objet Query
    * 
    * @param Registry $doctrine
+   * @param int $user_id
+   * @param string $exec_type
+   * 
    * @return collection
    */
-  public function getQuery(Registry $doctrine, $user_id)
+  public function getQuery(Registry $doctrine, $user_id, $exec_type = 'execute')
   {
-    if (!$this->query)
-    {
-      $this->constructQueryObject($doctrine, $user_id);
-    }
+    $this->constructQueryObject($doctrine, $user_id, $exec_type);
     return $this->query;
   }
 
    * 
    * @param Registry $doctrine
    * @param int $user_id
+   * @param string $exec_type Type d'execution
+   * 
    * @return collection
    */
   public function getElements(Registry $doctrine, $user_id, $exec_type = 'execute')
   {
-    $query = $this->getQuery($doctrine, $user_id);
+    $query = $this->getQuery($doctrine, $user_id, $exec_type);
     
     switch ($exec_type)
     {
         return $query->execute();
       break;
     
+      case 'count':
+        return count($query->getArrayResult());
+      break;
+    
       default :
         throw new \Exception('Mode de récupération des Elements non supporté.');
       break;
     }
   }
   
+  public function isSearchingNew()
+  {
+    return $this->searchnew;
+  }
+  
 }

src/Muzich/CoreBundle/Searcher/Searcher.php

     $this->query = $query;
   }
 
-  public function getQuery(Registry $doctrine, $user_id)
+  public function getQuery(Registry $doctrine, $user_id, $exec_type)
   {
     return $this->query;
   }

src/Muzich/CoreBundle/lib/Controller.php

   }
   
   /**
-   * Retourn l'objet ElementSearcher en cours.
+   * @desc Retourn l'objet ElementSearcher en cours.
+   * 
+   * @param int $count Si renseigné impact le nombre d'éléments qui seront 
+   * récupérés
+   * @param boolean $force_new Si a vrai la méthode procéède comme si on 
+   * demandé un nouveau objet de recherche (basé sur les tags favoris donc).
    * 
    * @return  ElementSearcher
    */

src/Muzich/HomeBundle/Resources/views/Home/index.html.twig

     <input class="main button" type="submit" value="{{ 'filter.submit'|trans({}, 'userui') }}"/>
   </form>
 
+  <div class="display_more_elements" style="display: none;">
+    <span></span>
+  </div>
+
+  <div class="elements_loader_div">
+    <img class="elements_new_loader" style="display: none;" src="{{ asset('/bundles/muzichcore/img/ajax-loader.gif') }}" alt="loading" />
+  </div>
+
   {% include "MuzichCoreBundle:SearchElement:default.html.twig" with {'noelements_filter' : true }%}
     
   <div class="elements_loader_div">

web/bundles/muzichcore/css/main.css

 #container a.element_edit_link
 {
   text-decoration: none;
+}
+
+div.display_more_elements
+{
+  background-color: #D9F7FF;
+  text-align: center;
 }

web/bundles/muzichcore/js/muzich.js

         $('form[name="search"]').slideDown();
       }
       remove_tags('add');
+      recolorize_element_list();
     }
     else if (response.status == 'error')
     {
     
     return null;
   }
+  
+  ////////////////////////////////////////
+  /// Gestion de nouveaux éléments
+  
+  function check_new_elements()
+  {
+    var url = url_element_new_count
+      +'/'
+      +str_replace('element_', '', $('ul.elements li:first').attr('id'))
+    ;
+    $.getJSON(url, function(response){
+      
+      if (response.status == 'mustbeconnected')
+      {
+        $(location).attr('href', url_index);
+      }
+      
+      if (response.status == 'success' && response.count)
+      {
+        $('div.display_more_elements').show();
+        $('div.display_more_elements span').html(response.message);
+      }
+      
+      setTimeout(check_new_elements, 300000);
+    });
+  }
+  
+  if ($('div.display_more_elements').length)
+  {
+    setTimeout(check_new_elements, 300000);
+  }
+  
+  $('a.show_new_elements').live('click', function(){
+    var url = url_element_new_get
+      +'/'
+      +str_replace('element_', '', $('ul.elements li:first').attr('id'))
+    ;
+    $('img.elements_new_loader').show();
+    $.getJSON(url, function(response){
+      
+      if (response.status == 'mustbeconnected')
+      {
+        $(location).attr('href', url_index);
+      }
+      
+      if (response.status == 'success')
+      {
+        if (response.count)
+        {
+          $('div.display_more_elements').show();
+          $('div.display_more_elements span').html(response.message);
+        }
+        else
+        {
+          $('div.display_more_elements').hide();
+        }
+        
+        $('ul.elements').prepend(response.html);
+        recolorize_element_list();
+      }
+      
+      $('img.elements_new_loader').hide();
+    });
+  });
+
+  function recolorize_element_list()
+  {
+    $('ul.elements li.element').each(function(index){
+      if ((index & 1) == 1)
+      {
+        $(this).removeClass('even');
+        $(this).removeClass('odd');
+        $(this).addClass('odd');
+      }
+      else
+      {
+        $(this).removeClass('odd');
+        $(this).removeClass('even');
+        $(this).addClass('even');
+      }
+    });
+  }
    
  });