www/ecrire/public/quete.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2014                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 if (!defined('_ECRIRE_INC_VERSION')) return;
  14
  15 //
  16 // Fonctions d'appel aux serveurs SQL presentes dans le code compile
  17 //
  18
  19 # NB : a l'exception des fonctions pour les balises dynamiques
  20
  21 include_spip('base/abstract_sql');
  22
  23 /**
  24  * retourne l'url de redirection d'un article virtuel, seulement si il est publié
  25  * http://doc.spip.org/@quete_chapo
  26  *
  27  * @param $id_article
  28  * @param $connect
  29  * @return array|bool|null
  30  */
  31 function quete_virtuel($id_article, $connect) {
  32         return sql_getfetsel('virtuel', 'spip_articles', array("id_article=".intval($id_article), "statut='publie'"), '','','','',$connect);
  33 }
  34
  35 /**
  36  * Retourne le couple parent,lang pour toute table
  37  * en pratique id_rubrique si present (ou id_parent pour table rubriques)
  38  * et champ lang si present
  39  *
  40  * @param string $table
  41  * @param int $id
  42  * @param string $connect
  43  * @return array
  44  */
  45 function quete_parent_lang($table,$id,$connect=''){
  46         static $cache_quete = array();
  47
  48         if (!isset($cache_quete[$connect][$table][$id])) {
  49                 if (!isset($cache_quete[$connect][$table]['_select'])){
  50                         $trouver_table = charger_fonction('trouver_table','base');
  51                         if (!$desc=$trouver_table($table,$connect) OR !isset($desc['field']['id_rubrique']))
  52                                 // pas de parent rubrique, on passe
  53                                 $cache_quete[$connect][$table]['_select'] = false;
  54                         else {
  55                                 $select = ($table=='spip_rubriques'?'id_parent':'id_rubrique');
  56                                 $select .= isset($desc['field']['lang'])?", lang":"";
  57                                 $cache_quete[$connect][$table]['_select'] = $select;
  58                                 $cache_quete[$connect][$table]['_id'] = id_table_objet(objet_type($table));
  59                         }
  60                 }
  61                 if ($cache_quete[$connect][$table]['_select'])
  62                         $cache_quete[$connect][$table][$id] = sql_fetsel($cache_quete[$connect][$table]['_select'], $table,$cache_quete[$connect][$table]['_id']."=".intval($id),'','','','',$connect);
  63         }
  64         return isset($cache_quete[$connect][$table][$id]) ? $cache_quete[$connect][$table][$id] : null;
  65 }
  66
  67
  68 /**
  69  * retourne le parent d'une rubrique
  70  * repose sur la fonction quete_parent_lang pour la mutualisation
  71  * +mise en cache sql des requetes
  72  *
  73  * http://doc.spip.org/@quete_parent
  74  *
  75  * @param int $id_rubrique
  76  * @param string $connect
  77  * @return int
  78  */
  79 function quete_parent($id_rubrique, $connect='') {
  80         if (!$id_rubrique = intval($id_rubrique))
  81                 return 0;
  82         $id_parent = quete_parent_lang('spip_rubriques',$id_rubrique,$connect);
  83         return $id_parent['id_parent'];
  84 }
  85
  86 /**
  87  * retourne la rubrique d'un article
  88  * repose sur la fonction quete_parent_lang pour la mutualisation
  89  * +mise en cache sql des requetes
  90  *
  91  * http://doc.spip.org/@quete_rubrique
  92  *
  93  * @param int $id_article
  94  * @param $serveur
  95  * @return
  96  */
  97 function quete_rubrique($id_article, $serveur) {
  98         $id_parent = quete_parent_lang('spip_articles',$id_article,$serveur);
  99         return $id_parent['id_rubrique'];
 100 }
 101
 102
 103 /**
 104  * retourne la profondeur d'une rubrique
 105  *
 106  * http://doc.spip.org/@quete_profondeur
 107  *
 108  * @param int $id
 109  * @param string $connect
 110  * @return int
 111  */
 112 function quete_profondeur($id, $connect='') {
 113         $n = 0;
 114         while ($id) {
 115                 $n++;
 116                 $id = quete_parent($id, $connect);
 117         }
 118         return $n;
 119 }
 120
 121
 122 /**
 123  * retourne la condition sur la date lorsqu'il y a des post-dates
 124  * @param string $champ_date
 125  * @param string $serveur
 126  * @return string
 127  */
 128 function quete_condition_postdates($champ_date, $serveur='', $ignore_previsu=false) {
 129         if (defined('_VAR_PREVIEW') AND _VAR_PREVIEW AND !$ignore_previsu)
 130                 return "1=1";
 131         return
 132           (isset($GLOBALS['meta']['date_prochain_postdate'])
 133              AND $GLOBALS['meta']['date_prochain_postdate'] > time())
 134                         ? "$champ_date<".sql_quote(date('Y-m-d H:i:s',$GLOBALS['meta']['date_prochain_postdate']),$serveur)
 135             : "1=1" ;
 136 }
 137
 138
 139 /**
 140  * Calculer la condition pour filtrer les status,
 141  *
 142  * @param string $mstatut
 143  *  le champ de la table sur lequel porte la condition
 144  * @param string $previsu
 145  *  mode previsu : statut ou liste des statuts separes par une virgule
 146  * @param string $publie
 147  *  mode publie : statut ou liste des statuts separes par une virgule
 148  * @param string $serveur
 149  *  serveur de BDD
 150  * @return array
 151  */
 152 function quete_condition_statut($mstatut,$previsu,$publie, $serveur='', $ignore_previsu=false){
 153         $liste = $publie;
 154         if (defined('_VAR_PREVIEW') AND _VAR_PREVIEW AND !$ignore_previsu)
 155                 $liste = $previsu;
 156         $not = false;
 157         if (strncmp($liste,'!',1)==0){
 158                 $not = true;
 159           $liste = substr($liste,1);
 160         }
 161         // '' => ne rien afficher, '!'=> ne rien filtrer
 162         if (!strlen($liste))
 163                 return ($not?"1=1":"'0=1'");
 164
 165         $liste = explode(',',$liste);
 166         foreach($liste as $k=>$v) {
 167                 // securite
 168                 $liste[$k] = preg_replace(",\W,","",$v);
 169         }
 170   if (count($liste)==1){
 171                 return array(($not?'<>':'='), $mstatut, sql_quote(reset($liste),$serveur));
 172   }
 173   else {
 174           return sql_in($mstatut,$liste,$not,$serveur);
 175   }
 176 }
 177
 178 /**
 179  * retourne le fichier d'un document
 180  *
 181  * http://doc.spip.org/@quete_fichier
 182  *
 183  * @param int $id_document
 184  * @param string $serveur
 185  * @return array|bool|null
 186  */
 187 function quete_fichier($id_document, $serveur='') {
 188         return sql_getfetsel('fichier', 'spip_documents', ("id_document=" . intval($id_document)),      '',array(), '', '', $serveur);
 189 }
 190
 191 /**
 192  * Toute les infos sur un document
 193  *
 194  * @param int $id_document
 195  * @param string $serveur
 196  * @return array|bool
 197  */
 198 function quete_document($id_document, $serveur='') {
 199         return sql_fetsel('*', 'spip_documents', ("id_document=" . intval($id_document)),       '',array(), '', '', $serveur);
 200 }
 201
 202 /**
 203  * recuperer une meta sur un site distant (en local il y a plus simple)
 204  *
 205  * http://doc.spip.org/@quete_meta
 206  *
 207  * @param $nom
 208  * @param $serveur
 209  * @return array|bool|null
 210  */
 211 function quete_meta($nom, $serveur) {
 212         return sql_getfetsel("valeur", "spip_meta", "nom=" . sql_quote($nom),
 213                              '','','','',$serveur);
 214 }
 215
 216 /**
 217  * Retourne le logo d'un objet, eventuellement par heritage
 218  * Si flag <> false, retourne le chemin du fichier
 219  * sinon retourne un tableau de 3 elements:
 220  * le chemin du fichier, celui du logo de survol, l'attribut style=w/h
 221  *
 222  * @param string $type
 223  * @param string $onoff
 224  * @param int $id
 225  * @param int $id_rubrique
 226  * @param bool $flag
 227  * @return array|string
 228  */
 229 function quete_logo($type, $onoff, $id, $id_rubrique, $flag) {
 230         static $chercher_logo;
 231         if (is_null($chercher_logo))
 232                 $chercher_logo = charger_fonction('chercher_logo', 'inc');
 233         $nom = strtolower($onoff);
 234
 235         while (1) {
 236                 $on = $chercher_logo($id, $type, $nom);
 237                 if ($on) {
 238                         if ($flag)
 239                                 return "$on[2].$on[3]";
 240                         else {
 241                                 $taille = @getimagesize($on[0]);
 242                                 $off = ($onoff != 'ON') ? '' :
 243                                         $chercher_logo($id, $type, 'off');
 244                                 // on retourne une url du type IMG/artonXX?timestamp
 245                                 // qui permet de distinguer le changement de logo
 246                                 // et placer un expire sur le dossier IMG/
 247                                 return array ($on[0].($on[4]?"?$on[4]":""),
 248                                         ($off ? $off[0] . ($off[4]?"?$off[4]":"") : ''),
 249                                         (!$taille ? '' : (" ".$taille[3])));
 250                         }
 251                 }
 252                 else if ($id_rubrique) {
 253                         $type = 'id_rubrique';
 254                         $id = $id_rubrique;
 255                         $id_rubrique = 0;
 256                 } else if ($id AND $type == 'id_rubrique')
 257                         $id = quete_parent($id);
 258                 else return '';
 259         }
 260 }
 261
 262 /**
 263  * fonction appelee par la balise #LOGO_DOCUMENT
 264  *
 265  * http://doc.spip.org/@calcule_logo_document
 266  *
 267  * @param array $row
 268  * @param string $connect
 269  * @return bool|string
 270  */
 271 function quete_logo_file($row, $connect=NULL) {
 272         include_spip('inc/documents');
 273         $logo = vignette_logo_document($row, $connect);
 274         if (!$logo) $logo = image_du_document($row);
 275         if (!$logo){
 276                 $f = charger_fonction('vignette','inc');
 277                 $logo = $f($row['extension'], false);
 278         }
 279         // si c'est une vignette type doc, la renvoyer direct
 280         if (strcmp($logo,_DIR_PLUGINS)==0
 281                 OR strcmp($logo,_DIR_PLUGINS_DIST)==0
 282                 OR strcmp($logo,_DIR_RACINE.'prive/')==0)
 283                 return $logo;
 284         return get_spip_doc($logo);
 285 }
 286
 287 /**
 288  * Trouver l'image logo d'un document
 289  *
 290  * @param  $row
 291  *   description du document, issue de la base
 292  * @param  $lien
 293  *   url de lien
 294  * @param  $align
 295  *   alignement left/right
 296  * @param  $mode_logo
 297  *   mode du logo :
 298  *     '' => automatique (vignette sinon apercu sinon icone)
 299  *     icone => icone du type du fichier
 300  *     apercu => apercu de l'image exclusivement, meme si une vignette existe
 301  *     vignette => vignette exclusivement, ou rien si elle n'existe pas
 302  * @param  $x
 303  *   largeur maxi
 304  * @param  $y
 305  *   hauteur maxi
 306  * @param string $connect
 307  *   serveur
 308  * @return string
 309  */
 310 function quete_logo_document($row, $lien, $align, $mode_logo, $x, $y, $connect=NULL) {
 311         include_spip('inc/documents');
 312         $logo = '';
 313         if (!in_array($mode_logo,array('icone','apercu')))
 314                 $logo = vignette_logo_document($row, $connect);
 315         // si on veut explicitement la vignette, ne rien renvoyer si il n'y en a pas
 316         if ($mode_logo == 'vignette' AND !$logo)
 317                 return '';
 318         if ($mode_logo == 'icone')
 319                 $row['fichier'] = '';
 320         return vignette_automatique($logo, $row, $lien, $x, $y, $align);
 321 }
 322
 323 /**
 324  * Retourne la vignette explicitement attachee a un document
 325  * le resutat est un fichier local existant, ou une URL
 326  * ou vide si pas de vignette
 327  *
 328  * @param array $row
 329  * @param string $connect
 330  * @return string
 331  */
 332 function vignette_logo_document($row, $connect='')
 333 {
 334         if (!$row['id_vignette']) return '';
 335         $fichier = quete_fichier($row['id_vignette'], $connect);
 336         if ($connect) {
 337                 $site = quete_meta('adresse_site', $connect);
 338                 $dir = quete_meta('dir_img', $connect);
 339                 return "$site/$dir$fichier";
 340         }
 341         $f = get_spip_doc($fichier);
 342         if ($f AND @file_exists($f)) return $f;
 343         if ($row['mode'] !== 'vignette') return '';
 344         return generer_url_entite($row['id_document'], 'document','','', $connect);
 345 }
 346
 347 /**
 348  * Calcul pour savoir si un objet est expose dans le contexte
 349  * fournit par $reference
 350  *
 351  * http://doc.spip.org/@calcul_exposer
 352  *
 353  * @param int $id
 354  * @param string $prim
 355  * @param array $reference
 356  * @param int $parent
 357  * @param string $type
 358  * @param string $connect
 359  * @return bool|string
 360  */
 361 function calcul_exposer ($id, $prim, $reference, $parent, $type, $connect='') {
 362         static $exposer = array();
 363
 364         // Que faut-il exposer ? Tous les elements de $reference
 365         // ainsi que leur hierarchie ; on ne fait donc ce calcul
 366         // qu'une fois (par squelette) et on conserve le resultat
 367         // en static.
 368         if (!isset($exposer[$m=md5(serialize($reference))][$prim])) {
 369                 $principal = isset($reference[$type])?$reference[$type]:
 370                         // cas de la pagination indecte @xx qui positionne la page avec l'id xx
 371                         // et donne la reference dynamique @type=xx dans le contexte
 372                         (isset($reference["@$type"])?$reference["@$type"]:'');
 373                 // le parent fournit en argument est le parent de $id, pas celui de $principal
 374                 // il n'est donc pas utile
 375                 $parent = 0;
 376                 if (!$principal) { // regarder si un enfant est dans le contexte, auquel cas il expose peut etre le parent courant
 377                         $enfants = array('id_rubrique'=>array('id_article'),'id_groupe'=>array('id_mot'));
 378                         if (isset($enfants[$type]))
 379                                 foreach($enfants[$type] as $t)
 380                                         if (isset($reference[$t])
 381                                                 // cas de la reference donnee dynamiquement par la pagination
 382                                                 OR isset($reference["@$t"])) {
 383                                                 $type = $t;
 384                                                 $principal = isset($reference[$type])?$reference[$type]:$reference["@$type"];
 385                                                 continue;
 386                                         }
 387                 }
 388                 $exposer[$m][$type] = array();
 389                 if ($principal) {
 390                         $principaux = is_array($principal)?$principal:array($principal);
 391                         foreach($principaux as $principal){
 392                                 $exposer[$m][$type][$principal] = true;
 393                                 if ($type == 'id_mot'){
 394                                         if (!$parent) {
 395                                                 $parent = sql_getfetsel('id_groupe','spip_mots',"id_mot=" . $principal, '','','','',$connect);
 396                                         }
 397                                         if ($parent)
 398                                                 $exposer[$m]['id_groupe'][$parent] = true;
 399                                 }
 400                                 else if ($type != 'id_groupe') {
 401                                   if (!$parent) {
 402                                         if ($type == 'id_rubrique')
 403                                                 $parent = $principal;
 404                                         if ($type == 'id_article') {
 405                                                 $parent = quete_rubrique($principal,$connect);
 406                                         }
 407                                   }
 408                                   do { $exposer[$m]['id_rubrique'][$parent] = true; }
 409                                   while ($parent = quete_parent($parent, $connect));
 410                                 }
 411                         }
 412                 }
 413         }
 414         // And the winner is...
 415         return isset($exposer[$m][$prim]) ? isset($exposer[$m][$prim][$id]) : '';
 416 }
 417
 418 /**
 419  * Trouver le numero de page d'une pagination indirecte
 420  * lorsque debut_xxx=@123
 421  * on cherche la page qui contient l'item dont la cle primaire vaut 123
 422  *
 423  * @param string $primary
 424  * @param int|string $valeur
 425  * @param int $pas
 426  * @param objetc $iter
 427  * @return int
 428  */
 429 function quete_debut_pagination($primary,$valeur,$pas,$iter){
 430         // on ne devrait pas arriver ici si la cle primaire est inexistante
 431         // ou composee, mais verifions
 432         if (!$primary OR preg_match('/[,\s]/',$primary))
 433                 return 0;
 434
 435         $pos = 0;
 436         while ($row = $iter->fetch() AND $row[$primary]!=$valeur){
 437                 $pos++;
 438         }
 439         // si on a pas trouve
 440         if ($row[$primary]!=$valeur)
 441                 return 0;
 442
 443         // sinon, calculer le bon numero de page
 444         return floor($pos/$pas)*$pas;
 445 }
 446 ?>