Evolution #59: Modifier le script tags en ajax

src/Muzich/CoreBundle/Controller/CoreController.php

     }
     
     $element = new Element();
-    $form = $this->createForm(
-      new ElementAddForm(),
-      $element,
-      array(
-       'tags'   => $this->getTagsArray(),
-        // Ligne non obligatoire (cf. verif du contenu du form -> ticket)
-       //'groups' => $this->getGroupsArray()
-      )
-    );
-    
+    $form = $this->getAddForm($element);
     
     $form->bindRequest($this->getRequest());
     if ($form->isValid())
         $add_form = $this->getAddForm();
 
         return $this->render('MuzichHomeBundle:Home:index.html.twig', array(
-          'tags'             => $this->getTagsArray(),
           'search_tags_id'   => $search_object->getTags(),
           'user'             => $this->getUser(),
           'add_form'         => $add_form->createView(),

src/Muzich/CoreBundle/Controller/SearchController.php

 
 use Muzich\CoreBundle\Searcher\ElementSearcher;
 use Muzich\CoreBundle\Form\Search\ElementSearchForm;
+use Symfony\Component\HttpFoundation\Response;
 
 class SearchController extends Controller
 {
     $request = $this->getRequest();
     $search_object = $this->getElementSearcher();
     
-    $search_form = $this->createForm(
-      new ElementSearchForm(), 
-      $search_object->getParams(),
-      array('tags' => $this->getTagsArray())
-    );
+    $search_form = $this->getSearchForm($search_object);
     
     if ($request->getMethod() == 'POST')
     {
       if ($search_form->isValid())
       {
         // On met a jour l'objet avec les nouveaux paramétres saisie dans le form
-        $search_object->update($search_form->getData());
+        $data = $search_form->getData();
+        
+        // Le formulaire nous permet de récupérer uniquement les ids.
+        // On va donc chercher les name en base pour le passer a l'objet
+        // ElementSearch
+        $data['tags'] = $this->getDoctrine()->getRepository('MuzichCoreBundle:Tag')
+          ->getTagsForElementSearch(json_decode($data['tags'], true));
+        
+        $search_object->update($data);
         // Et on met a jour la "mémoire" de la recherche
         $this->setElementSearcherParams($search_object->getParams());
       }
     }
   }
   
+  /**
+   *
+   * @param string $string_search 
+   */
+  public function searchTagAction($string_search)
+  {
+    if ($this->getRequest()->isXmlHttpRequest())
+    {
+      $tags = $this->getDoctrine()->getEntityManager()->createQuery("
+        SELECT t.name FROM MuzichCoreBundle:Tag t
+        WHERE UPPER(t.name) LIKE :str
+        ORDER BY t.name ASC"
+      )->setParameter('str', '%'.strtoupper($string_search).'%')
+      ->getScalarResult()
+      ;
+      
+      $tags_response = array();
+      foreach ($tags as $tag)
+      {
+        $tags_response[] = $tag['name'];
+      }
+      
+      $response = new Response(json_encode($tags_response));
+      $response->headers->set('Content-Type', 'application/json; charset=utf-8');
+      return $response;
+    }
+    
+    throw $this->createNotFoundException('Cette ressource n\'est pas accessible');
+  }
+  
+  /**
+   *
+   * @param type $string_search
+   * @return Response 
+   */
+  public function searchTagIdAction($string_search)
+  {
+    if ($this->getRequest()->isXmlHttpRequest())
+    {
+      $tag_id = $this->getDoctrine()->getEntityManager()->createQuery("
+        SELECT t.id FROM MuzichCoreBundle:Tag t
+        WHERE t.name = :str
+        ORDER BY t.name ASC"
+      )->setParameter('str', $string_search)
+      ->getSingleScalarResult()
+      ;
+      
+      $response = new Response(json_encode($tag_id));
+      $response->headers->set('Content-Type', 'application/json; charset=utf-8');
+      return $response;
+    }
+    
+    throw $this->createNotFoundException('Cette ressource n\'est pas accessible');
+  }
+  
 }

src/Muzich/CoreBundle/ElementFactory/ElementManager.php

   {
     $this->element->setOwner($owner);
     $this->element->setTagsWithIds($this->em, $this->element->getTags());
-    //$this->setGroup();
     $this->determineType();
     $this->proceedExtraFields();
   }

src/Muzich/CoreBundle/Entity/Element.php

   public function setTagsWithIds(EntityManager $em, $ids)
   {
     $this->tags = null;
+    $ids = json_decode($ids);
     if (count($ids))
     {
       $tags = $em->getRepository('MuzichCoreBundle:Tag')->findByIds($ids)->execute();

src/Muzich/CoreBundle/Entity/User.php

    */
   public function updateTagsFavoritesById(EntityManager $em, $ids)
   {
+    $ids = json_decode($ids);
     $ids_to_add = $ids;
     
     // Pour chacun des tags favoris 

src/Muzich/CoreBundle/Form/Element/ElementAddForm.php

       'required' => true,
     ));
         
-    $builder->add('tags', 'choice', array(
-      'choices'           => $options['tags'],
-      'expanded'          => true,
-      'multiple'          => true
-    ));
-    
-//    $options['groups'][''] = '';
-//    $builder->add('group', 'choice', array(
-//      'choices'           => $options['groups'],
-//      'expanded'          => false,
-//      'multiple'          => false,
-//      'required'          => false
-//    ));
-    
+    $builder->add('tags', 'hidden');    
   }
 
   public function getName()
     return array(
       'name' => '',
       'url' => '',
-      'tags' => array(),
+      'tags' => '',
       //'groups' => array(),
       'data_class' => 'Muzich\CoreBundle\Entity\Element'
     );

src/Muzich/CoreBundle/Form/Group/GroupForm.php

       'required' => false,
     ));
         
-    $builder->add('tags', 'choice', array(
-      'choices'           => $options['tags'],
-      'expanded'          => true,
-      'multiple'          => true
-    ));
+    $builder->add('tags', 'hidden');
   }
 
   public function getName()
     return array(
       'name' => '',
       'open' => true,
-      'tags' => array(),
+      'tags' => '',
       'data_class' => 'Muzich\CoreBundle\Entity\Group'
     );
   }

src/Muzich/CoreBundle/Form/Search/ElementSearchForm.php

       'required' => true,
     ));
         
-    $builder->add('tags', 'choice', array(
-      'choices'           => $options['tags'],
-      'expanded'          => true,
-      'multiple'          => true
-    ));
-        
-//    $builder->add('groups', 'choice', array(
-//      'choices'           => $options['groups'],
-//      'expanded'          => true,
-//      'multiple'          => true
-//    ));
+    $builder->add('tags', 'hidden');
   }
 
   public function getName()
   public function getDefaultOptions(array $options)
   {
     return array(
-      'tags' => array(),
-//      'groups' => array(),
+      'tags' => ''
     );
   }
 }

src/Muzich/CoreBundle/Form/Tag/TagFavoritesForm.php

 {
   public function buildForm(FormBuilder $builder, array $options)
   {    
-    $builder->add('tags', 'choice', array(
-      'choices'           => $options['tags'],
-      'expanded'          => true,
-      'multiple'          => true
-    ));
+    $builder->add('tags', 'hidden');
   }
 
   public function getName()
   public function getDefaultOptions(array $options)
   {
     return array(
-      'tags' => array(),
+      'tags' => '',
     );
   }
 }

src/Muzich/CoreBundle/Repository/ElementRepository.php

     $join_tags  = '';
     if (count(($tags = $searcher->getTags())))
     {
-      foreach ($tags as $tag_id)
+      foreach ($tags as $tag_id => $tag_name)
       {
         // LEFT JOIN car un element n'est pas obligatoirement lié a un/des tags
         $join_tags = " LEFT JOIN e_.tags t_";

src/Muzich/CoreBundle/Repository/TagRepository.php

     ")->setParameter('tids', $ids);
   }
   
+  public function getTagsForElementSearch($ids)
+  {
+    $tags = array();
+    foreach ($this->getEntityManager()
+      ->createQuery('
+        SELECT t.id, t.name FROM MuzichCoreBundle:Tag t
+        WHERE t.id IN (:ids)
+        ORDER BY t.name ASC'
+      )
+      ->setParameter('ids', $ids)
+      ->getArrayResult() as $tag)
+    {
+      $tags[$tag['id']] = $tag['name'];
+    }
+    
+    return $tags;
+  }
+  
 }
   

src/Muzich/CoreBundle/Repository/UserRepository.php

    * @param int $limit
    * @return array 
    */
-  public function getTagIdsFavorites($user_id, $limit = null)
+  public function getTagsFavorites($user_id, $limit = null)
   {
-    $tag_ids = array();
+    $tags = array();
     foreach ($this->getEntityManager()
       ->createQuery('
-        SELECT t.id FROM MuzichCoreBundle:Tag t 
+        SELECT t.id, t.name FROM MuzichCoreBundle:Tag t 
         JOIN t.users_favorites uf
         JOIN uf.user u
         WHERE u.id = :uid
       ->setMaxResults($limit)
       ->getArrayResult() as $tag)
     {
-      $tag_ids[] = $tag['id'];
+      $tags[$tag['id']] = $tag['name'];
     }
-    return $tag_ids;
+    return $tags;
   }
   
   /**

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

 element_add:
   pattern:  /element/add/{group_slug}
   defaults: { _controller: MuzichCoreBundle:Core:elementAdd, group_slug: null }
+
+search_tag:
+  pattern: /search/tag/{string_search}
+  defaults: { _controller: MuzichCoreBundle:Search:searchTag, string_search: null }
+  
+search_tag_ig_by_name:
+  pattern: /search/tagid/{string_search}
+  defaults: { _controller: MuzichCoreBundle:Search:searchTagId, string_search: null }

src/Muzich/CoreBundle/Resources/views/Element/form.add.html.twig

   {{ form_widget(form.url) }}
 </div>
 
-{% if  app.environment != 'test' %}
   {% include "MuzichCoreBundle:Tag:tagsPrompt.html.twig" with { 'form_name': form_name } %}
-{% else %}
+
   {{ form_row(form.tags) }}
-{% endif %}
 
 {{ form_row(form._token) }}

src/Muzich/CoreBundle/Resources/views/SearchElement/form.html.twig

 
   {{ form_row(search_form.network) }}
 
-  {% if  app.environment != 'test' %}
-    {% include "MuzichCoreBundle:Tag:tagsPrompt.html.twig" with { 'form_name': form_name } %}
-  {% else %}
-    {{ form_row(search_form.tags) }}
-  {% endif %}
+  {% include "MuzichCoreBundle:Tag:tagsPrompt.html.twig" with { 'form_name': form_name } %}
   
+  {{ form_row(search_form.tags) }}
   {{ form_row(search_form._token) }}
 
   <input type="submit" />

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

   
   {{ form_errors(form) }}
 
-  {% if  app.environment != 'test' %}
-    {% include "MuzichCoreBundle:Tag:tagsPrompt.html.twig" with { 
-      'form_name'   : form_name,
-      'search_tags' : favorite_tags_id
-    } %}
-  {% else %}
-    {{ form_row(form.tags) }}
-  {% endif %}
+  {% include "MuzichCoreBundle:Tag:tagsPrompt.html.twig" with { 
+    'form_name'   : form_name,
+    'search_tags' : favorite_tags_id
+  } %}
+  
+  {{ form_row(form.tags) }}
 
   {{ form_row(form._token) }}
 

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

 </div>
 
 <script language="javascript" type="text/javascript">
-
-  if (typeof(taglist) == 'undefined')
-  {
-    taglist = new Array({{ tags|length }});
-    {% for i, tag in tags %}taglist[{{ i }}] = "{{ tag }}"; {% endfor %}
-  }
   
   var taginit = new Array();
   {% if search_tags is defined %}
-    {% for tid in search_tags %}
-      taginit[{{ tid }}] = {{ tid }};
+    {% for tid, tname in search_tags %}
+      taginit[{{ loop.index0 }}] = {"id":"{{ tid }}", "name":"{{ tname }}"};
     {% endfor %}
   {% endif %}
   
   var options = new Array();
-  options.tag_values = taglist;
   options.form_name  = "{{ form_name }}";
   options.tag_init   = taginit;
   
   // The autocomplete for the last tagbox
   $("#tags_prompt_{{ form_name }} ul.tagbox li.input input").autocomplete({
       source: function(req, responseFn) {
-          var sstr = $.trim(req.term);
-          var re = $.ui.autocomplete.escapeRegex(sstr);
-          var matcher = new RegExp(re, "i" );
-          var a = $.grep( taglist, function(item,index){
-              return matcher.test(item);
-          });
-          responseFn( a );
+        
+        // ici il faut faire une ajax q pour obtenir la liste
+        // ou a est un tableau de strings
+        
+        $.getJSON('/app_dev.php/fr/search/tag/'+req.term, function(data) {
+          responseFn( data );
+        });
+        
+          //var sstr = $.trim(req.term);
+          //var re = $.ui.autocomplete.escapeRegex(sstr);
+          //var matcher = new RegExp(re, "i" );
+          //var a = $.grep( taglist, function(item,index){
+          //    return matcher.test(item);
+          //});
+          //console.debug(a);
+          
+          //responseFn( a );
       },
       minLength: 2,
       select: function(e, ui) {

src/Muzich/CoreBundle/Searcher/ElementSearcher.php

    * 
    * @return array 
    */
-  public function getParams()
+  public function getParams($tags_string = false)
   {
     return array(
       'network'  => $this->getNetwork(),
-      'tags'     => $this->getTags(),
+      'tags'     => $this->getTags($tags_string),
       'count'    => $this->getCount(),
       'user_id'  => $this->getUserId(),
       'group_id' => $this->getGroupId(),
     return $this->network;
   }
   
-  public function getTags()
+  public function getTags($tags_string = false)
   {
-    return $this->tags;
+    if (!$tags_string)
+    {
+      return $this->tags;
+    }
+    
+    $ids = array();
+    foreach ($this->tags as $id => $name)
+    {
+      $ids[] = $id;
+    }
+    return json_encode($ids);
   }
   
   public function getCount()

src/Muzich/CoreBundle/Validator/TagsValidator.php

   
   public function isValid($value, Constraint $constraint)
   {
+    $value = json_decode($value);
+    
     if (count($value))
     {
       if (array_diff($value, array_unique($value)))

src/Muzich/CoreBundle/lib/Controller.php

       $this->ElementSearcher = new ElementSearcher();
       $this->ElementSearcher->init(array(
         'tags' => $this->getDoctrine()->getRepository('MuzichCoreBundle:User')
-          ->getTagIdsFavorites(
+          ->getTagsFavorites(
             $this->getUserId(),
             $this->container->getParameter('search_default_favorites_tags_count')
           ),
    */
   protected function getTagsArray($force_refresh = false)
   {
+    throw new \Exception("Cette méthode ne doit plus être utilisé.");
+    
     if (!count(self::$tags) || $force_refresh)
     {
       return self::$tags = $this->getDoctrine()->getRepository('MuzichCoreBundle:Tag')->getTagsArray();
   {
     return $this->createForm(
       new ElementSearchForm(), 
-      $search_object->getParams(),
-      array(
-        'tags' => $this->getTagsArray()
-      )
+      $search_object->getParams(true),
+      array()
     );
   }
   
-  protected function getAddForm()
+  protected function getAddForm($element = array())
   {
     return $this->createForm(
       new ElementAddForm(),
-      array(),
-      array(
-        'tags' => $this->getTagsArray()
-      )
+      $element,
+      array()
     );
   }
   

src/Muzich/GroupBundle/Controller/DefaultController.php

 class DefaultController extends Controller
 {
   
+  protected function getGroupForm($group)
+  {
+    return $this->createForm(
+      new GroupForm(), 
+      $group
+    );
+  }
+  
   /**
    * Page listant les groupes possédés par l'utilisateur. Comporte egallement
    * un formulaire pour ajouter un groupe.
     )));
     
     $new_group = new Group();
-    $form_new = $this->createForm(
-      new GroupForm(), 
-      $new_group,
-      array('tags' => $this->getTagsArray())
-    );
+    $form_new = $this->getGroupForm($new_group);
     
     return array(
-      'groups'   => $user->getGroupsOwned(),
-      'form_new' => $form_new->createView()
+      'groups'        => $user->getGroupsOwned(),
+      'form_new'      => $form_new->createView(),
+      'form_new_name' => $form_new->getName()
     );
   }
   
     
     $new_group = new Group();
     $new_group->setOwner($user);
-    $form_new = $this->createForm(
-      new GroupForm(), 
-      $new_group,
-      array('tags' => $this->getTagsArray())
-    );
+    $form_new = $this->getGroupForm($new_group);
     
     $form_new->bindRequest($request);
     
       return $this->render(
         'MuzichGroupBundle:Default:myList.html.twig', 
          array(
-           'groups'   => $user->getGroupsOwned(),
-           'form_new' => $form_new->createView()
+           'groups'        => $user->getGroupsOwned(),
+           'form_new'      => $form_new->createView(),
+           'form_new_name' => $form_new->getName()
          )
       );
     }
     }
     
     $group->setTagsToIds();
-    
-    $form = $this->createForm(
-      new GroupForm(), 
-      $group,
-      array('tags' => $this->getTagsArray())
-    );
+    $form = $this->getGroupForm($group);
     
     return array(
-      'group' => $group,
-      'form'  => $form->createView()        
+      'group'     => $group,
+      'form'      => $form->createView()  ,
+      'form_name' => $form->getName()      
     );
   }
   
     // Pour être compatible avec le formulaire, la collection de tags dois être
     // une collection d'id
     $group->setTagsToIds();
-    
-    $form = $this->createForm(
-      new GroupForm(), 
-      $group,
-      array('tags' => $this->getTagsArray())
-    );
+    $form = $this->getGroupForm($group);
     
     $form->bindRequest($request);
     
       return $this->render(
         'GroupBundle:Default:edit.html.twig', 
          array(
-           'form_new' => $form->createView()
+           'form_new'      => $form->createView(),
+           'form_new_name' => $form_new->getName()
          )
       );
     }

src/Muzich/GroupBundle/Resources/views/Default/myList.html.twig

 
   <form action="{{ path('group_add') }}" method="post" {{ form_enctype(form_new) }}>
     
-    {% include "MuzichGroupBundle:Form:form.html.twig" with { 'form': form_new } %}
+    {% include "MuzichGroupBundle:Form:form.html.twig" with { 'form': form_new, 'form_name': form_new_name } %}
 
     <input type="submit" />
   </form>

src/Muzich/GroupBundle/Resources/views/Form/form.html.twig

   {{ form_widget(form.open) }}
 </div>
 
-<div class="field">
-  {{ form_errors(form.tags) }}
-  {{ form_label(form.tags, 'tags'|trans({}, 'groupform')) }}
-  {{ form_widget(form.tags) }}
-</div>
+{% include "MuzichCoreBundle:Tag:tagsPrompt.html.twig" with { 'form_name': form_name } %}
+
+{{ form_row(form.tags) }}
 
 {{ form_rest(form) }}

src/Muzich/HomeBundle/Controller/HomeController.php

     $add_form = $this->getAddForm();
     
     return array(
-      'tags'             => $this->getTagsArray(),
       'search_tags_id'   => $search_object->getTags(),
       'user'             => $this->getUser(),
       'add_form'         => $add_form->createView(),

src/Muzich/HomeBundle/Controller/ShowController.php

     ($group->getOwner()->getId() == $this->getUserId()) ? $his = true : $his = false;
     if ($his || $group->getOpen())
     {      
-      $add_form = $this->createForm(
-        new ElementAddForm(),
-        array(),
-        array(
-          'tags' => $this->getTagsArray()
-        )
-      );
+      $add_form = $this->getAddForm();
     }
     
     return array(

src/Muzich/UserBundle/Controller/UserController.php

 class UserController extends Controller
 {
   
-  protected $tags_favorites = array();
+  protected $tags_favorites = null;
   
   protected function getChangeEmailForm()
   {
   
   protected function getTagsFavoritesForm($user)
   {
+    $ids = array();
+    foreach ($this->getTagsFavorites() as $id => $name)
+    {
+      $ids[] = $id;
+    }
+    
     return $this->createForm(
       new TagFavoritesForm(), 
-      array('tags' => $this->tags_favorites = $this->getDoctrine()->getRepository('MuzichCoreBundle:User')
-        ->getTagIdsFavorites($user->getId())
-      ),
-      array('tags' => $this->getTagsArray())
+      array('tags' => json_encode($ids))
     );
   }
   
+  protected function getTagsFavorites($force = false)
+  {
+    if ($this->tags_favorites === null || $force)
+    {
+      $this->tags_favorites = $this->getDoctrine()->getRepository('MuzichCoreBundle:User')
+        ->getTagsFavorites($this->getUser()->getId())
+      ;
+    }
+    
+    return $this->tags_favorites;
+  }
+  
   /**
    * Page de configuration de son compte
    *
     $change_email_form = $this->getChangeEmailForm();
     
     return array(
-      'tags'                     => $this->getTagsArray(),
       'user'                     => $user,
       'form_password'            => $form_password->createView(),
       'form_tags_favorites'      => $form_tags_favorites->createView(),
       'form_tags_favorites_name' => $form_tags_favorites->getName(),
-      'favorite_tags_id'         => $this->tags_favorites,
+      'favorite_tags_id'         => $this->getTagsFavorites(),
       'change_email_form'        => $change_email_form->createView()
     );
   }
       return $this->container->get('templating')->renderResponse(
         'MuzichUserBundle:User:account.html.twig',
         array(
-          'tags'                     => $this->getTagsArray(),
           'form_password'            => $form->createView(),
           'errors_pers'              => $errors,
           'user'                     => $user,
           'form_tags_favorites'      => $form_tags_favorites->createView(),
           'form_tags_favorites_name' => $form_tags_favorites->getName(),
-          'favorite_tags_id'         => $this->tags_favorites,
+          'favorite_tags_id'         => $this->getTagsFavorites(),
           'change_email_form'        => $change_email_form->createView()
         )
       );
     $form_tags_favorites = $this->getTagsFavoritesForm($user);
     
     return array(
-      'tags'                     => $this->getTagsArray(),
-      'favorite_tags_id'         => $this->tags_favorites,
+      'favorite_tags_id'         => $this->getTagsFavorites(),
       'form_tags_favorites'      => $form_tags_favorites->createView(),
       'form_tags_favorites_name' => $form_tags_favorites->getName(),
     );
       )->getSingleResult();
     }
     
-    $form = $this->createForm(
-      new TagFavoritesForm(), 
-      array('tags' => $this->getDoctrine()->getRepository('MuzichCoreBundle:User')
-        ->getTagIdsFavorites($user->getId())
-      ),
-      array('tags' => $this->getTagsArray())
-    );
+    $form = $this->getTagsFavoritesForm($user);
     
     if ($request->getMethod() == 'POST')
     {
     return $this->container->get('templating')->renderResponse(
       'MuzichUserBundle:User:account.html.twig',
       array(
-        'tags'                     => $this->getTagsArray(),
         'user'                     => $user,
         'form_password'            => $form_password->createView(),
         'form_tags_favorites'      => $form_tags_favorites->createView(),
         'form_tags_favorites_name' => $form_tags_favorites->getName(),
-        'favorite_tags_id'         => $this->tags_favorites,
+        'favorite_tags_id'         => $this->getTagsFavorites(),
         'change_email_form'        => $change_email_form->createView()
       )
     );

web/bundles/muzichcore/js/muzich.js

   return "";
 }
 
+function json_to_array(json_string)
+{
+  if (json_string.length)
+  {
+    return eval("(" + json_string + ")");
+  }
+  return new Array();
+}
+
+/**
+ * Converts the given data structure to a JSON string.
+ * Argument: arr - The data structure that must be converted to JSON
+ * Example: var json_string = array2json(['e', {pluribus: 'unum'}]);
+ * 			var json = array2json({"success":"Sweet","failure":false,"empty_array":[],"numbers":[1,2,3],"info":{"name":"Binny","site":"http:\/\/www.openjs.com\/"}});
+ * http://www.openjs.com/scripts/data/json_encode.php
+ */
+function array2json(arr) {
+    var parts = [];
+    var is_list = (Object.prototype.toString.apply(arr) === '[object Array]');
+
+    for(var key in arr) {
+    	var value = arr[key];
+        if(typeof value == "object") { //Custom handling for arrays
+            if(is_list) parts.push(array2json(value)); /* :RECURSION: */
+            else parts[key] = array2json(value); /* :RECURSION: */
+        } else {
+            var str = "";
+            if(!is_list) str = '"' + key + '":';
+
+            //Custom handling for multiple data types
+            if(typeof value == "number") str += value; //Numbers
+            else if(value === false) str += 'false'; //The booleans
+            else if(value === true) str += 'true';
+            else str += '"' + value + '"'; //All other things
+            // :TODO: Is there any more datatype we should be in the lookout for? (Functions?)
+
+            parts.push(str);
+        }
+    }
+    var json = parts.join(",");
+    
+    if(is_list) return '[' + json + ']';//Return numerical JSON
+    return '{' + json + '}';//Return associative JSON
+}
+
+function isInteger(s) {
+  return (s.toString().search(/^-?[0-9]+$/) == 0);
+}
+
+function inArray(array, p_val) {
+    var l = array.length;
+    for(var i = 0; i < l; i++) {
+        if(array[i] == p_val) {
+            return true;
+        }
+    }
+    return false;
+}
+
 if(typeof(String.prototype.trim) === "undefined")
 {
     String.prototype.trim = function() 

web/js/tags/jquery.tagBox.js

             self.delimit_key = 32 
             self.delimit_expr = /\s+/
         }
-
-        var values = options.tag_values;
  
         var val = input.val();
         var tags = []
             }
         });
         
-        self.tagInput.bind("selectTag", function() {
-            if(!$(this).val()) {
-                return;
+        self.tagInput.bind("selectTag", function(event) {
+          if(!$(this).val()) {
+              return;
+          }
+          
+          input = $(this);
+
+          // Ici il faut faire un ajax q pour connaitre l'id, on a que le string
+          $.getJSON('/app_dev.php/fr/search/tagid/'+$(this).val(), function(data) {
+            if (isInteger(data))
+            {
+              self.addTag(input.val(), data, options.form_name, false);
+              input.val("");
             }
-            self.addTag($(this).val(), findKeyWithValue(values, $(this).val()), options.form_name);
-            $(this).val("");
+          });
+
+          
         });
         
         self.tagbox = $('<ul>', {
         self.inputHolder.append(self.tagInput);
         self.tagInput.autoGrowInput();
         
-        for(tag in tags) {
-            self.addTag(tags[tag], findKeyWithValue(values, tags[tag]), options.form_name);
-        }
+        // On désactive l'ajout de tags basé sur le contenu du input
+        // ona notre propre système (taginit)
+        //for(tag in tags) {
+        //    self.addTag(tags[tag], findKeyWithValue(values, tags[tag]), options.form_name, true);
+        //}
         
         if (options.tag_init.length)
         {
-          for(tagid in options.tag_init) {
-              self.addTag(values[tagid], tagid, options.form_name);
+          for(i in options.tag_init) {
+            tag = options.tag_init[i];
+            self.addTag(tag.name, tag.id, options.form_name, true);
           }
         }
         
     
     TagBox.prototype = {
         
-        addTag : function(label, id, form_name) {
-            
-            // Nos conditions pour ajouter le tag:
-            // * N'a pas déjà été ajouté a ce champ
-            // * Est dans la liste des tags existants
-            if (id && !findKeyWithValue(tagsAddeds[form_name], id))
-            {
-              var self = this;
-              var tag = $('<li class="tag">' + $('<div>').text(label).remove().html() + '</li>');
+        addTag : function(label, id, form_name, force) {
+          
+          // On n'ajoute pas deux fois le même tag
+          if (id && !findKeyWithValue(tagsAddeds[form_name], id))
+          {
+            var self = this;
+            var tag = $('<li class="tag">' + $('<div>').text(label).remove().html() + '</li>');
 
-              this.tags.push(label);
+            this.tags.push(label);
+
+            tag.append($('<a>', {
+                "href" : "#",
+                "class": "close",
+                "text": "close",
+                click: function(e) {
+                    e.preventDefault();
+                    var index = self.tagbox.find("li").index($(this).parent());
+                    self.removeTag(index, id, form_name);
+                }
+            }));
 
-              tag.append($('<a>', {
-                  "href" : "#",
-                  "class": "close",
-                  "text": "close",
-                  click: function(e) {
-                      e.preventDefault();
-                      var index = self.tagbox.find("li").index($(this).parent());
-                      self.removeTag(index);
-                  }
-              })).append($('<input>', {
-                'type'   : 'checkbox',
-                'style'  : 'display: none;',
-                'value'  : id,
-                'name'   : form_name+'[tags]['+id+']',
-                'id'     : form_name+'_tags_'+id,
-                'checked': 'checked'
-              }));
-              
-              tagsAddeds[form_name][id] = id;
-              self.inputHolder.before(tag);
-              self.updateInput();
+            // si on force, on ne touche pas l'inpu (il contient déjà ces valeurs)
+            if (!force)
+            {
+              var input_tags = $('input#'+form_name+'_tags');
+              if (input_tags.length)
+              {
+                // array des ids de tags
+                var input_values = json_to_array(input_tags.val());
+                if (!inArray(input_values, id))
+                {
+                  input_values[input_values.length] = parseInt(id);
+                  $('input#'+form_name+'_tags').val(array2json(input_values));
+                }
+              }
             }
-            
+            //
+
+            tagsAddeds[form_name][id] = id;
+            self.inputHolder.before(tag);
+            self.updateInput();
+             
+          }
         },
-        removeTag : function(index) {
+        removeTag : function(index, id, form_name) {
             
             this.tagbox.find("li").eq(index).remove();
             this.tags.splice(index, 1);
             this.updateInput();
+            
+            input_tags = $('input#'+form_name+'_tags');
+            if (input_tags.length)
+            {
+              // array des ids de tags
+              input_values = json_to_array(input_tags.val());
+              for(var i = 0; i < input_values.length; i++)
+              {
+                if (input_values[i] == id)
+                {
+                  delete input_values[i];
+                }
+              }
+              $('input#'+form_name+'_tags').val(array2json(input_values));
+            }
         },
         updateInput : function() {