Changeset 814 in spip-zone


Ignore:
Timestamp:
Sep 4, 2005, 9:33:13 PM (15 years ago)
Author:
pierre.andrews@…
Message:

tag-machine en objet, une requete pour le suggest de mieux en mieux

Location:
_libs_/tag-machine
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • _libs_/tag-machine/formulaires/ajax.fonctions.php3

    r800 r814  
    11<?php
     2
    23/*
    3 génére une regexp OU pour la liste de mot
     4génére une regexp OU pour la liste de mot
    45*/
    56function enregexp($liste) {
    6   include_ecrire('_libs_/tag-machine/inc_tag-machine.php');
    7   $mots = parser_liste(filtrer_entites($liste));
    8   $str = '^(';
    9   foreach ($mots as $mot) {
    10         $str .= $mot['tag'].'|';
    11   }
    12   $str = substr($str,0,-1);
    13   return $str.')$';
     7    include_ecrire('_libs_/tag-machine/inc_tag-machine.php');
     8        $mots = parser_liste(filtrer_entites($liste));
     9        $str = '';
     10        foreach ($mots as $mot) {
     11          $str .= $mot['tag'].'|';
     12        }
     13        $str = substr($str,0,-1);
     14        if ($str) {
     15          return '('.$str.')';
     16        } else
     17          return '';
    1418}
    1519
    1620/*
    17 combien il y a de mots dans le paramétre
     21combien il y a de mots dans le paramétre
    1822*/
    1923function compte_having($liste) {
    20   include_ecrire('_libs_/tag-machine/inc_tag-machine.php');
    21   $mots = parser_liste(filtrer_entites($liste));
    22   return count($mots)-1;
     24    include_ecrire('_libs_/tag-machine/inc_tag-machine.php');
     25        $liste = dernier_quote($liste);
     26        $tags = new ListeTags(filtrer_entites($liste));
     27        return count($tags->getTags())-1;
    2328}
    2429
    2530/*
    26 un critére pour le HAVING sql
     31un critére pour le HAVING sql
    2732*/
    2833function critere_having($idb, &$boucles, $crit){       
    29   $hav = calculer_liste($crit->param[0], array(), $boucles, $boucles[$idb]->id_parent);
     34        $hav = calculer_liste($crit->param[0], array(), $boucles, $boucles[$idb]->id_parent);
    3035 $boucles[$idb]->having = "'.$hav.'";
    3136}
     
    3338//ajax
    3439
    35 function case_tag($tag) {
     40function seulement_tout($tag) {
    3641 
    37   if(is_array($tag)) {
    38         $ctag = $tag['tag'];
    39         $cgroupe =  $tag['groupe'];
     42  if(is_object($tag)) {
     43        return $tag->echapper();
    4044  } else {
    4145        $cgroupe = '';
     
    4549  $cgroupe = (strpos($cgroupe,' ') || strpos($cgroupe,':'))?'"'.$cgroupe.'"':$cgroupe;
    4650  $ctag = (strpos($ctag,' ') || strpos($ctag,':'))?'"'.$ctag.'"':$ctag;
    47  
     51
    4852  return ($cgroupe.($cgroupe)? ':':'').$ctag;
    4953 
    5054}
    5155
     56function seulement_titre($tag) {
     57 
     58  if(is_object($tag)) {
     59        return $tag->getTitreEchappe();
     60  } else {
     61        $tag = (strpos($tag,' ') || strpos($tag,':') || strpos($tag,','))?'"'.$tag.'"':$tag;
     62        return $tag;
     63  }
     64 
     65}
     66
     67function seulement_type($tag) {
     68 
     69  if(is_object($tag)) {
     70        return $tag->getTypeEchappe();
     71  } else {
     72        $tag = (strpos($tag,' ') || strpos($tag,':') || strpos($tag,','))?'"'.$tag.'"':$tag;
     73        return $tag;
     74  }
     75 
     76}
     77
     78//marche pas ce truc!!
    5279function dernier_quote($lst) {
    5380  if(substr_count($lst,'"')%2 != 0)
     
    5683}
    5784
    58 function m8_debut($liste) {
     85function trouve_debut($liste) {
    5986  include_ecrire('_libs_/tag-machine/inc_tag-machine.php');
    6087  $liste = dernier_quote($liste);
    61   $mots = array_map('case_tag',parser_liste(filtrer_entites($liste)));
    62   return join(' ',array_slice($mots,0,-1));
     88  $tags = new ListeTags(filtrer_entites($liste));
     89  return array_slice($tags->getTags(),0,-1);
    6390}
    6491
    65 function m8_fin($liste) {
    66   include_ecrire('_libs_/tag-machine/inc_tag-machine.php');
     92function tout_debut($liste) {
     93  $mots = array_map('seulement_tout',trouve_debut($liste));
     94  return join(' ',$mots);
     95}
     96
     97function titre_debut($liste) {
     98  $mots = array_map('seulement_titre',trouve_debut($liste));
     99  return join(' ',$mots);
     100}
     101
     102function type_debut($liste) {
     103  $mots = array_map('seulement_type',trouve_debut($liste));
     104  return join(' ',$mots);
     105}
     106
     107function trouve_fin($liste) {
    67108  $liste = dernier_quote($liste);
    68   $mots = array_map('case_tag',parser_liste(filtrer_entites($liste)));
    69   return str_replace('"','',$mots[count($mots)-1]);
     109  $tags = new ListeTags(filtrer_entites($liste));
     110  $tags = $tags->getTags();
     111  return $tags[count($tags)-1];
    70112}
     113
     114function titre_fin($liste) {
     115  $mots = seulement_titre(trouve_fin($liste));
     116  return str_replace('"','',$mots);
     117
     118}
     119
     120function type_fin($liste) {
     121  $mots = seulement_type(trouve_fin($liste));
     122  return str_replace('"','',$mots);
     123
     124}
     125
    71126?>
  • _libs_/tag-machine/formulaires/ajax.html

    r800 r814  
    11//DEBUG
    22//titre: '[(#ENV{titre}|dernier_quote)]'<br>
    3 //debut: '[(#ENV{titre}|m8_debut)]'<br>
    4 //fin: '[(#ENV{titre}|m8_fin)]'<br>
     3//debut: '[(#ENV{titre}|tout_debut)]'<br>
     4//fin: '[(#ENV{titre}|titre_fin)]'<br>
    55//cnt: [(#ENV{titre}|compte_having)]<br>
    66
     
    88//retourne un tableau de mots qui sont associés aux mêmes forums que les mots déjà tappé: suggest
    99<B_forum>
     10//<H1>A</H1>
    1011new Array(
    11 <BOUCLE_forum(FORUMS)  {titre_mot == (#ENV{titre}|m8_debut|enregexp)} {having (#ENV{titre}|m8_debut|compte_having)}>
    12 <BOUCLE_mots2(MOTS) {id_breve} {titre == ^(#ENV{titre}|m8_fin)}>
    13 [new Array('[(#ENV{titre}|m8_debut) ](#TITRE|unique|case_tag)','0 forum'),]
     12<BOUCLE_forum(BREVES)  {titre_mot == ^(#ENV{titre}|titre_debut|enregexp)$} {type_mot == ^(#ENV{titre}|type_debut|enregexp|sinon{.*})$} {having (#ENV{titre}|titre_debut|compte_having)}>
     13<BOUCLE_mots2(MOTS) {id_breve} {titre == ^(#ENV{titre}|titre_fin)} {titre !== ^(#ENV{titre}|titre_debut|enregexp)$} {type == ^(#ENV{titre}|type_debut|enregexp|sinon{.*})$}>
     14[new Array('[(#ENV{titre}|tout_debut) ](#TITRE|unique|seulement_tout)','0 forum'),]
    1415</BOUCLE_mots2>
    1516</BOUCLE_forum>
     
    1718</B_forum>
    1819<B_mots>
     20//<H1>B</H1>
    1921//si yen a pas, donne tous les mots qui match le dernier mot de la liste
    2022// (marche pas avec + de 1 mot dans la liste, mais je sais pourquoi :D)
    2123new Array(
    22 <BOUCLE_mots(MOTS) {","} {titre == ^(#ENV{titre}|m8_fin)}>
    23   new Array('[[(#ENV{titre}|m8_debut) ](#TITRE|case_tag)]',<BOUCLE_forums(FORUMS) {id_mot}> </BOUCLE_forums>'#TOTAL_BOUCLE <:forum:>'</B_forums>'#TOTAL_BOUCLE <:forum:>'<//B_forums>)
     24<BOUCLE_mots(MOTS) {","} {titre == ^(#ENV{titre}|titre_fin)} {titre !== ^(#ENV{titre}|titre_debut|enregexp)$} {type == ^(#ENV{titre}|type_fin)}>
     25  new Array('[[(#ENV{titre}|tout_debut) ](#TITRE|unique|seulement_tout)]',<BOUCLE_forums(BREVES) {id_mot}> </BOUCLE_forums>'#TOTAL_BOUCLE <:forum:>'</B_forums>'#TOTAL_BOUCLE <:forum:>'<//B_forums>)
    2426</BOUCLE_mots>
    2527)
  • _libs_/tag-machine/inc_tag-machine.php

    r672 r814  
    3838include_ecrire ($path_inc_abstract_sql);
    3939
     40function entableau($tag) {
     41  return array('groupe' => $tag->type, 'tag' => $tag->titre);
     42}
     43
    4044/**
    4145   Ajoute les mots clefs dans la liste passée en paramètre au bon objet.
     
    5862                                                        $id_objet='id_document',
    5963                                                        $clear = false) {
    60   if($id) {
    61         if ($clear) {
    62           spip_query("DELETE FROM spip_mots_$nom_objet WHERE $id_objet=$id");
    63         }
    64         for($i=0;$i<sizeof($tags);$i++) {
    65           $tag=$tags[$i]['tag'];
    66           $groupe = $tags[$i]['groupe'];
    67           $groupe = $groupe?$groupe:$groupe_defaut;
    68          
    69           $select_groupe = spip_abstract_select(array('id_groupe','unseul'),
    70                                                                                         array('spip_groupes_mots'),
    71                                                                                         array("titre = '$groupe'"));
    72           $id_groupe = 0;
    73           $add = true;
    74           if($groupe_row = spip_abstract_fetch($select_groupe)) {
    75                 $id_groupe = $groupe_row['id_groupe'];
    76                 $unseul = $groupe_row['unseul'];
    77                 if ($unseul == 'oui') {
    78                   // on verifie qu'il y a pas déjà un mot associé
    79                   $celcount = spip_abstract_select(array('count(id_mot) as tot'),
    80                                                                                    array('spip_mots as mots',
    81                                                                                                  "spip_mots_$nom_objet as objets"),
    82                                                                                    array("mots.id_groupe = $id_groupe",
    83                                                                                                  "mots.id_mot = objets.id_mot"),
    84                                                                                            'mots.id_groupe');
    85                   if($numrow = spip_abstract_fetch($celcount) && $numrow['tot'] > 0) {
    86                         $add = false;
    87                         $warnings[] = array(_T('motspartout:dejamotgroupe',array('groupe' => $titre_groupe, 'chose' => $d)));
    88                   }
    89                   spip_abstract_free($celcount);
    90                 }
    91           } else {
    92                 $id_groupe = spip_abstract_insert("spip_groupes_mots",
    93                                                                                   "(titre, $nom_objet, 0minirezo)",
    94                                                                                   "('$groupe','oui','oui')");
    95                 $warnings[] = array('creer groupe '.$titre_groupe);
    96           }
    97           spip_abstract_free($select_groupe);
    98          
    99           if($add) {
    100                 $select = array('id_mot');
    101                 $from = array('spip_mots');
    102                 $where = array("titre = '$tag'",
    103                                            "type='$groupe'");
    104                 $result = spip_abstract_select($select,$from,$where);
    105                
    106                 if (spip_abstract_count($result) == 0){
    107                   $id_mot = spip_abstract_insert("spip_mots",
    108                                                                                  '(id_groupe, type, titre)',
    109                                                                                  "('$id_groupe','$groupe','$tag')");
    110                   $result2 = spip_abstract_insert("spip_mots_$nom_objet",
    111                                                                                   "(id_mot,$id_objet)",
    112                                                                                    "($id_mot,$id)");
    113                   $warnings[] = array('creer mot '.$tag);
    114                 } else {
    115                   while ($row = spip_fetch_array($result)) {
    116                         $id_mot = $row['id_mot'];
    117                         $result3 = spip_abstract_select(array('id_mot'),
    118                                                                                         array("spip_mots_$nom_objet"),
    119                                                                                         array("id_mot='$id_mot'","$id_objet = $id"));
    120                         if (spip_abstract_count($result3) == 0) {
    121                           spip_abstract_insert("spip_mots_$nom_objet",
    122                                                                    "(id_mot, $id_objet)",
    123                                                                    "('$id_mot','$id')");
    124                         }
    125                         spip_abstract_free($result3);     
    126                   }
    127                 }
    128                 spip_abstract_free($result);     
    129           }
    130         }
    131         return $warnings;
    132   } else
    133         return array();
     64  $tags = new ListeTags($tags,$groupe_defaut);
     65  $tags->ajouter($id, $nom_objet, $id_objet,$clear);
    13466}
    13567
     
    14173                                          $id_objet='id_document',
    14274                                          $clear = false) {
    143                                                 return ajouter_liste_mots(parser_liste($liste_tags), $id, $groupe_defaut, $nom_objet, $id_objet,$clear);
    144   return array();
     75  $tags = new ListeTags($liste_tags,$groupe_defaut);
     76  $tags->ajouter($id, $nom_objet, $id_objet,$clear);
    14577}
    14678
     
    16193                                                        $nom_objet='documents',
    16294                                                        $id_objet='id_document') {
    163   if($id) {
    164         for($i=0;$i<sizeof($tags);$i++) {
    165           $tag=$tags[$i]['tag'];
    166           $groupe = $tags[$i]['groupe'];
    167           $groupe = $groupe?$groupe:$groupe_defaut;
    168          
    169           $select = array('id_mot');
    170           $from = array('spip_mots');
    171           $where = array("titre = '$tag'",
    172                                          "type='$groupe'");
    173          
    174           $result = spip_abstract_select($select,$from,$where);
    175           if ($row = spip_abstract_fetch($result)){
    176                 spip_query("DELETE FROM spip_mots_$nom_objet WHERE id_mot=".$row['id_mot']." AND $id_objet=$id");
    177           }
    178           spip_abstract_free($result);
    179         }
    180   }
     95  $tags = new ListeTags($tags,$groupe_defaut);
     96  $tags->retirer($id, $nom_objet, $id_objet);
    18197}
    18298
     
    186102                                          $nom_objet='documents',
    187103                                          $id_objet='id_document') {
    188   if($liste_tags) retirer_liste_mots(parser_liste($liste_tags), $id, $groupe_defaut, $nom_objet, $id_objet);
    189 }
    190 
    191 /*Retourn un tableau de tags qui sont associé à l'objet, si necessaire entre guillemet*/
    192 function get_tags($id,
    193                                   $groupe_defaut='',
    194                                   $nom_objet='documents',
    195                                   $id_objet='id_document') {
    196   $result = spip_abstract_select(array('titre','type'),
    197                                                                  array("spip_mots_$nom_objet",'spip_mots'),
    198                                                                   array("spip_mots_$nom_objet.id_mot=spip_mots.id_mot","spip_mots_$nom_objet.$id_objet = $id"));
    199  
    200   $to_ret = array();
    201   while ($row = spip_abstract_fetch($result)) {
    202         $groupe = '';
    203         if($groupe == $groupe_defaut) {
    204           $groupe = $groupe_defaut;
    205           if(strpos($groupe,' ') || strpos($groupe,':')) {
    206                 $groupe = "\"groupe\"";
    207           }
    208         }
    209         $mot = $row['titre'];
    210         if(strpos($mot,' ') || strpos($mot,':')) {
    211           $groupe = "\"groupe\"";
    212         }
    213         $to_ret[] = $groupe.($groupe)? ':':''.$mot;
    214   }
    215   spip_abstract_free($result);
    216   return $to_ret;
     104  $tags = new ListeTags($liste_tags,$groupe_defaut);
     105  $tags->retirer($id, $nom_objet, $id_objet);
    217106}
    218107
    219108function parser_liste($liste_tags) {
    220 
     109  $tags = new ListeTags($liste_tags);
     110  return array_map('entableau',$tags->getTags());
     111}
     112
     113?>
     114
     115<?php
     116/*des objets*/
     117
     118class Tag {
     119 var $titre;
     120 var $type;
     121 var $id_mot;
     122 var $id_groupe;
     123
     124  function Tag($titre, $type) {
     125        $this->titre = $titre;
     126        $this->type = $type;
     127  }
     128
     129  /*  function Tag($id_mot,$id_groupe) {
     130        $this->id_mot = $id_mot;
     131        $this->id_groupe = $id_groupe;
     132  }*/
     133
     134 function getID() {
     135        return $this->id_mot;
     136  }
     137
     138  /*public*/ function getIDGroupe() {
     139        return $this->id_groupe;
     140  }
     141
     142  /*public*/ function getTitre() {
     143        return $this->titre;
     144  }
     145
     146  /*public*/ function getType() {
     147        return $this->type;
     148  }
     149
     150  /*public*/ function getTitreEchappe() {
     151      return (strpos($this->titre,' ') || strpos($this->titre,':') || strpos($this->titre,','))?'"'.$this->titre.'"':$this->titre;
     152  }
     153
     154  /*public*/ function getTypeEchappe() {
     155      return (strpos($this->type,' ') || strpos($this->type,':') || strpos($this->type,','))?'"'.$this->type.'"':$this->type;
     156  }
     157
     158
     159 function echapper() {
     160   $cgroupe = $this->type;
     161   $ctag = $this->titre;
     162   
     163   $cgroupe = (strpos($cgroupe,' ') || strpos($cgroupe,':') || strpos($cgroupe,','))?'"'.$cgroupe.'"':$cgroupe;
     164   $ctag = (strpos($ctag,' ') || strpos($ctag,':') || strpos($ctag,','))?'"'.$ctag.'"':$ctag;
     165   
     166   return ($cgroupe.($cgroupe)? ':':'').$ctag;
     167 }
     168 
     169  //----------------------------------------------------------------------
     170
     171  /*private*/ function verifier() {
     172        list($id_groupe,$unseul) = verifier_groupe();
     173        if($id_groupe > 0) {
     174          if ($unseul == 'oui') {
     175                // on verifie qu'il y a pas déjà un mot associé
     176                $celcount = spip_abstract_select(array('count(id_mot) as tot'),
     177                                                                                 array('spip_mots as mots',
     178                                                                                           "spip_mots_$nom_objet as objets"),
     179                                                                                 array("mots.id_groupe = $id_groupe",
     180                                                                                           "mots.id_mot = objets.id_mot"),
     181                                                                                 'mots.id_groupe');
     182                if($numrow = spip_abstract_fetch($celcount) && $numrow['tot'] > 0) {
     183                  return false;
     184                }
     185                spip_abstract_free($celcount);
     186          }
     187        } else {
     188          $id_groupe = spip_abstract_insert("spip_groupes_mots",
     189                                                                                "(titre, $nom_objet, 0minirezo)",
     190                                                                                "('$groupe','oui','oui')");
     191        }       
     192       
     193        return $id_groupe;
     194  }
     195 
     196  /*private*/ function verifier_groupe() {
     197        static $groupes_verifie;
     198        if(!isset($groupes_verifie[$this->type])) {
     199          $select_groupe = spip_abstract_select(array('id_groupe','unseul'),
     200                                                                                        array('spip_groupes_mots'),
     201                                                                                        array("titre = '$groupe'"));
     202           if($groupe_row = spip_abstract_fetch($select_groupe)) {
     203                $id = $groupe_row['id_groupe'];
     204                $unseul = $groupe_row['unseul'];
     205                $groupes_verifie[$this->type] = array($id,$unseul);
     206           }
     207           
     208           spip_abstract_free($select_groupe);
     209        }
     210        return $groupes_verifie[$this->type];
     211  }
     212
     213  //----------------------------------------------------------------------
     214
     215  function creer() {
     216        if(!$this->id_mot && $this->id_groupe = verifier()) {
     217          $select = array('id_mot');
     218          $from = array('spip_mots');
     219          $where = array("titre = '".$this->titre."'",
     220                                         "type='".$this->type."'");
     221          $result = spip_abstract_select($select,$from,$where);
     222          if ($row = spip_fetch_array($result)) {
     223                $this->id_mot = $row['id_mot'];
     224          } else {
     225                $this->id_mot = spip_abstract_insert("spip_mots",
     226                                                                                         '(id_groupe, type, titre)',
     227                                                                                         "('".$this->id_groupe."','".$this->type."','".$this->titre."')");
     228          }
     229          spip_abstract_free($result);   
     230        }
     231        return $this->id_mot;
     232  }
     233
     234  function ajouter($id, $nom_objet, $id_objet) {
     235        if(!$this->id_mot) {
     236          creer();
     237        }
     238        spip_abstract_insert("spip_mots_$nom_objet",
     239                                                 "(id_mot,$id_objet)",
     240                                                 '('.$this->id_mot.",$id)");
     241       
     242  }
     243
     244  function retirer($id, $nom_objet, $id_objet) {
     245        if ($this->id_mot){
     246          spip_query("DELETE FROM spip_mots_$nom_objet WHERE id_mot=".$this->id_mot." AND $id_objet=$id");
     247        }
     248  }
     249
     250}
     251
     252class ListeTags {
     253
     254  //------------------------------- Variables -------------------------------------
     255
     256  /*private*/ var $tags = array();
     257  /*private*/ var $groupe_defaut;
     258
     259  //------------------------------- Constructeurs ---------------------------------
     260
     261  /*public*/ function ListeTags($liste_tags,
     262                                                        $groupe_defaut='') {
     263        $this->groupe_defaut = $groupe_defaut;
     264        if(!is_array($liste_tags)) {
     265          $this->tags = $this->parser_liste($liste_tags);
     266        } else {
     267          $this->tags = $liste_tags;
     268        }
     269  }
     270
     271  /*public*/ /*function ListeTags($id,
     272                                                        $groupe_defaut='',
     273                                                        $nom_objet='documents',
     274                                                        $id_objet='id_document') {
     275        $result = spip_abstract_select(array('titre','type'),
     276                                                                   array("spip_mots_$nom_objet",'spip_mots'),
     277                                                                   array("spip_mots_$nom_objet.id_mot=spip_mots.id_mot",
     278                                                                                 "spip_mots_$nom_objet.$id_objet = $id"));
     279       
     280        while ($row = spip_abstract_fetch($result)) {
     281          $this->tags[] = new Tag($row['titre'],$row['type']);
     282        }
     283        spip_abstract_free($result);
     284        $this->groupe_defaut = $groupe_defaut;
     285  }
     286*/
     287
     288  //------------------------------- Info -----------------------------------------
     289
     290  function getTags() {
     291        return $this->tags;
     292  }
     293 
     294  // prend une liste de tags et retourne les id_mot reconnus (sans en creer)
     295  function getTagsIDs() {
     296        //?? Aller chercher les tags dans la boite
     297        //?? pour faire plus generique : se baser sur id_$objet et/ou url_propre
     298        //?? car " dans l'url arrive ici sous la forme &quot; (#ENV{tags} et non #ENV*{tags})
     299       
     300        $ids_mot = array();
     301        foreach ($this->tags as $mot) {
     302          if (strlen($mot->titre)) {
     303                $where = array(" titre='".addslashes($mot->titre)."'");
     304                if(strlen($mot->type)) {
     305                  $where[] = 'type=\''.addslashes($mot->type).'\'';
     306                }
     307                $results = spip_abstract_select(array('id_mot'),
     308                                                                                array('spip_mots'),
     309                                                                                $where
     310                                                                                ); //+ url_propre ? id_objet ?
     311                list($id) = spip_abstract_fetch_array($results);
     312                if ($id)
     313                  $ids_mot[] = $id;
     314                spip_abstract_free($results);
     315          }
     316        }
     317        return $ids_mot;
     318  }
     319 
     320  function toStringArray() {
     321        $to_ret = array();
     322        foreach($this->tags as $tag) {
     323          $groupe = '';
     324          if($tag->type == $this->groupe_defaut) {
     325                $groupe = $this->groupe_defaut;
     326                if(containsSeparateur($groupe)) {
     327                  $groupe = "\"$groupe\"";
     328                }
     329          }
     330          $mot = $tag->titre;
     331          if(containsSeparateur($mot)) {
     332                $mot = "\"$mot\"";
     333          }
     334          $to_ret[] = ($groupe.($groupe)? ':':'').$mot;
     335        }
     336        return $to_ret;
     337  }
     338
     339  //--------------------------------- Modif DB -----------------------------------
     340 
     341  function ajouter($id,
     342                                   $nom_objet='documents',
     343                                   $id_objet='id_document',
     344                                   $clear=false) {
     345        if($id) {
     346          if ($clear) {
     347                spip_query("DELETE FROM spip_mots_$nom_objet WHERE $id_objet=$id");
     348          }
     349          foreach($this->tags as $mot) {
     350                $mot->ajouter($id,$nom_objet,$id_objet);
     351          }
     352        }
     353  }
     354
     355  function retirer($id,
     356                                   $nom_objet='documents',
     357                                   $id_objet='id_document') {
     358       
     359        if($id) {
     360          foreach($this->tags as $mot) {
     361                $mot->retirer($id,$nom_objet,$id_objet);
     362          }
     363        }
     364  }
     365
     366
     367  //-------------------------------- Statique ------------------------------------
     368 
     369  //-- privé
     370 
     371  /*private*/ /*static*/ function parser_liste($liste_tags) {
     372       
    221373        // supprimer les tab (notre separateur final)
    222374        $liste_tags = strtr($liste_tags, "\t", " ");
    223 
     375       
    224376        // doubler les caracteres qui peuvent faire office de separateur
    225377        $liste_tags = ' '.preg_replace('/[[:space:],]/', '\\0\\0', $liste_tags).' ';
    226 
     378       
    227379        // trouver les tags et les separer par \t
    228380        $liste_tags = preg_replace('/[[:space:],]+("?)(.*?)\\1[[:space:],]/', "\t\\2", $liste_tags);
    229 
     381       
    230382        // remettre les caracteres doubles en simple
    231383        $liste_tags = preg_replace('/([[:space:],])\\1/', '\\1', $liste_tags);
    232 
     384       
    233385        // exploser selon les tab
    234386        $tags = split("\t", substr($liste_tags,1));
    235 
     387       
    236388        // recuperer les groupes sous la forme  <groupe:mot>
    237389        foreach ($tags as $i => $tag) {
    238                 $tag = str_replace('"', '', $tag);
    239                 preg_match('/((.*):)?(.*)/', $tag, $regs);
    240                 $tag =trim($regs[3]);
    241                 $groupe = trim($regs[2]);
    242                 if(strlen($tag) >= 1)
    243                   $tags[$i] = array('groupe' => $groupe, 'tag' => $tag);
    244         }
    245  
    246   return $tags;
    247 }
    248 
    249 //nuage de tags
    250                 //c'est quoi ce truc, qu'est ce que ca fout la???
    251 function nuage_tags($groupe='tags', $link=''){
    252   $query = "SELECT id_mot, titre FROM spip_mots WHERE type='$groupe'";
    253   $result = spip_query($query);
    254   while ($row = spip_fetch_array($result)) {
    255         $id_mot = $row['id_mot'];
    256         $titre_mot = $row['titre'];
    257         $titre[$id_mot]=$titre_mot;
    258         $url[$id_mot]=$link.'?id_mot='.$id_mot;
    259        
    260         $nb = spip_num_rows(spip_query("SELECT id_document FROM spip_mots_documents
    261         WHERE id_mot=$id_mot"));
    262        
    263         $pop[$id_mot]=$nb;
    264   }
    265    
    266   $maxpop = max($pop); // Plus grand nombre de documents pour un mot
    267                                                  
    268   foreach ($titre as $id => $t) {
    269         $score = $pop[$id]/$maxpop; // entre 0 et 1
    270        
    271         $s = ceil(10*$score);
    272         $s = 10 + $s;
    273         $t = str_replace(' ', '&nbsp;', $t);
    274         $l = "<span style='font-size:".$s."px'>$t</span>";
    275         $l = "<a href='".$url[$id]."'>$l</a>";
    276         echo "$l &nbsp; \n";
    277        
    278   }
     390          $tag = str_replace('"', '', $tag);
     391          preg_match('/((.*):)?(.*)/', $tag, $regs);
     392          $groupe = $regs[2];
     393          if(!$groupe)
     394                $groupe = $this->groupe_defaut;
     395          $tags[$i] = new Tag($regs[3], $groupe);
     396        }
     397       
     398        return $tags;
     399  }
     400 
     401  function containsSeparateur($char) {
     402        return (strpos($char,' ') || strpos($char,':') || strpos($char,','));
     403  }
     404 
    279405}
    280406
    281407?>
     408
     409
Note: See TracChangeset for help on using the changeset viewer.