www/plugins-dist/svp/svp_fonctions.php

   1 <?php
   2
   3 /**
   4  * Déclarations de fonctions
   5  *
   6  * @plugin SVP pour SPIP
   7  * @license GPL
   8  * @package SPIP\SVP\Fonctions
   9 **/
  10
  11 /**
  12  * Retourne un texte expliquant l'intervalle de compatibilité avec un plugin ou SPIP
  13  *
  14  * Retourne par exemple "2.0 <= SPIP < 3.1"
  15  *
  16  * @param string $intervalle
  17  *     L'intervalle tel que déclaré dans paquet.xml. Par exemple "[2.1;3.0.*]"
  18  * @param string $logiciel
  19  *     Nom du plugin pour qui est cette intervalle
  20  * @return string
  21  *     Texte expliquant l'intervalle
  22 **/
  23 function svp_afficher_intervalle($intervalle, $logiciel){
  24         if (!strlen($intervalle)) return '';
  25         if (!preg_match(',^[\[\(\]]([0-9.a-zRC\s\-]*)[;]([0-9.a-zRC\s\-\*]*)[\]\)\[]$,Uis',$intervalle,$regs)) return false;
  26         $mineure = $regs[1];
  27         $majeure = preg_replace(',\.99$,', '.*', $regs[2]);
  28         $mineure_inc = $intervalle{0}=="[";
  29         $majeure_inc = substr($intervalle,-1)=="]";
  30         if (strlen($mineure)){
  31                 if (!strlen($majeure))
  32                         $version = $logiciel . ($mineure_inc ? ' &ge; ' : ' &gt; ') . $mineure;
  33                 else
  34                         $version = $mineure . ($mineure_inc ? ' &le; ' : ' &lt; ') .  $logiciel . ($majeure_inc ? ' &le; ' : ' &lt; ') . $majeure;
  35         }
  36         else {
  37                 if (!strlen($majeure))
  38                         $version = $logiciel;
  39                 else
  40                         $version =  $logiciel . ($majeure_inc ? ' &le; ' : ' &lt; ') . $majeure;
  41         }
  42
  43         return $version;
  44 }
  45
  46 /**
  47  * Traduit un type d'état de plugin
  48  *
  49  * Si l'état n'existe pas, prendra par défaut 'developpement'
  50  *
  51  * @see plugin_etat_en_clair()
  52  * @param string $etat
  53  *     Le type d'état (stable, test, ...)
  54  * @return string
  55  *     Traduction de l'état dans la langue en cours
  56 **/
  57 function svp_afficher_etat($etat) {
  58         include_spip('plugins/afficher_plugin');
  59         return plugin_etat_en_clair($etat);
  60 }
  61
  62 /**
  63  * Retourne un texte HTML présentant la liste des dépendances d'un plugin
  64  *
  65  * Des liens vers les plugins dépendants sont présents lorsque les plugins
  66  * en dépendance sont connus dans notre base.
  67  *
  68  * @param string $balise_serialisee
  69  *     Informations des dépendances (tableau sérialisé) tel que stocké
  70  *     en base dans la table spip_paquets
  71  * @param string $dependance
  72  *     Type de dépendances à afficher (necessite ou utilise).
  73  *     Une autre valeur indique qu'on demande la liste des librairies dépendantes.
  74  * @param string $sep
  75  *     Séparateur entre les noms de dépendances
  76  * @param string $lien
  77  *         Type de lien affecté au plugin référencé dans la base locale. Prend les valeurs :
  78  *
  79  *              - local : le lien pointe vers la page publique du plugin sur le site lui-même. Il faut
  80  * donc que le site propose des pages publiques pour les plugins sinon une 404 sera affichée;
  81  *              - pluginspip : le lien pointe vers la page du plugin sur le site de référence Plugins SPIP;
  82  *              - non : aucun lien n'est affiché.
  83  * @return string
  84  *     Texte informant des dépendances
  85 **/
  86 function svp_afficher_dependances($balise_serialisee, $dependance='necessite', $sep='<br />', $lien='local') {
  87         $texte = '';
  88
  89         $t = unserialize($balise_serialisee);
  90         $dependances = $t[$dependance];
  91         if (is_array($dependances)) {
  92                 ksort($dependances);
  93
  94                 foreach($dependances as $_compatibilite => $_dependance) {
  95                         $compatibilite = ($_compatibilite !== 0)
  96                                         ? _T('svp:info_compatibilite_dependance', array('compatibilite' => svp_afficher_intervalle($_compatibilite, 'SPIP')))
  97                                         : '';
  98                         if ($compatibilite)
  99                                 $texte .= ($texte ? str_repeat($sep, 2) : '') . $compatibilite;
 100                         foreach ($_dependance as $_plugin) {
 101                                 if ($texte)
 102                                         $texte .= $sep;
 103                                 if (($dependance == 'necessite' ) OR ($dependance == 'utilise')) {
 104                                         if ($plugin = sql_fetsel('id_plugin, nom', 'spip_plugins', 'prefixe=' . sql_quote($_plugin['nom']))) {
 105                                                 $nom = extraire_multi($plugin['nom']);
 106                                                 if ($lien == 'non')
 107                                                         $logiciel = $nom;
 108                                                 else {
 109                                                         $url = ($lien == 'local')
 110                                                                  ? generer_url_entite($plugin['id_plugin'], 'plugin')
 111                                                                  : "http://plugins.spip.net/{$_plugin['nom']}.html";
 112                                                         $bulle = _T('svp:bulle_aller_plugin');
 113                                                         $logiciel = '<a href="' . $url . '" title="' . $bulle . '">' . $nom . '</a>';
 114                                                 }
 115                                         } else {
 116                                                 // Cas ou le plugin n'est pas encore dans la base SVP.
 117                                                 // On affiche son préfixe, cependant ce n'est pas un affichage devant perdurer
 118                                                 $logiciel = $_plugin['nom'];
 119                                         }
 120                                         $intervalle = '';
 121                                         if (isset($_plugin['compatibilite'])) {
 122                                                 $intervalle = svp_afficher_intervalle($_plugin['compatibilite'], $logiciel);
 123                                         }
 124                                         $texte .= ($intervalle) ? $intervalle : $logiciel;
 125                                 }
 126                                 else
 127                                         // On demande l'affichage des librairies
 128                                         $texte .= '<a href="' . $_plugin['lien'] . '" title="' . _T('svp:bulle_telecharger_librairie') . '">' . $_plugin['nom'] . '</a>';
 129                         }
 130                 }
 131         }
 132
 133         return $texte;
 134 }
 135
 136 /**
 137  * Teste si un plugin possède des dépendances
 138  *
 139  * @param string $balise_serialisee
 140  *     Informations des dépendances (tableau sérialisé) tel que stocké
 141  *     en base dans la table spip_paquets
 142  * @return bool
 143  *     Le plugin possède t'il des dépendances ?
 144 **/
 145 function svp_dependances_existe($balise_serialisee) {
 146         $dependances = unserialize($balise_serialisee);
 147         foreach($dependances as $_dependance) {
 148                 if ($_dependance)
 149                         return true;
 150         }
 151
 152         return false;
 153 }
 154
 155
 156 /**
 157  * Retourne un texte HTML présentant les crédits d'un plugin
 158  *
 159  * Des liens vers les crédits sont présents lorsqu'ils sont déclarés
 160  * dans le paquet.xml.
 161  *
 162  * @param string $balise_serialisee
 163  *     Informations des crédits (tableau sérialisé) tel que stocké
 164  *     en base dans la table spip_paquets
 165  * @param string $sep
 166  *     Séparateur entre les différents crédits
 167  * @return string
 168  *     Texte informant des crédits
 169 **/
 170 function svp_afficher_credits($balise_serialisee, $sep=', ') {
 171         $texte = '';
 172
 173         $credits = unserialize($balise_serialisee);
 174         if (is_array($credits)) {
 175                 foreach ($credits as $_credit) {
 176                         if ($texte)
 177                                 $texte .= $sep;
 178                         // Si le credit en cours n'est pas un array c'est donc un copyright
 179                         $texte .=
 180                                 (!is_array($_credit))
 181                                 ? PtoBR(propre($_credit)) // propre pour les [lien->url] des auteurs de plugin.xml ...
 182                                 : ($_credit['url'] ? '<a href="' . $_credit['url'] . '">' : '') .
 183                                   $_credit['nom'] .
 184                                   ($_credit['url'] ? '</a>' : '');
 185                 }
 186         }
 187
 188         return $texte;
 189 }
 190
 191
 192 /**
 193  * Retourne un texte HTML présentant la liste des langues et traducteurs d'un plugin
 194  *
 195  * Des liens vers les traducteurs sont présents lorsqu'ils sont connus.
 196  *
 197  * @param array $langues
 198  *     Tableau code de langue => traducteurs
 199  * @param string $sep
 200  *     Séparateur entre les différentes langues
 201  * @return string
 202  *     Texte informant des langues et traducteurs
 203 **/
 204 function svp_afficher_langues($langues, $sep=', '){
 205         $texte = '';
 206
 207         if ($langues) {
 208                 foreach ($langues as $_code => $_traducteurs) {
 209                         if ($texte)
 210                                 $texte .= $sep;
 211                         $traducteurs_langue = array();
 212                         foreach ($_traducteurs as $_traducteur) {
 213                                 if (is_array($_traducteur))
 214                                         $traducteurs_langue[] =
 215                                                 ($_traducteur['lien'] ? '<a href="' . $_traducteur['lien'] . '">' : '') .
 216                                                 $_traducteur['nom'] .
 217                                                 ($_traducteur['lien'] ? '</a>' : '');
 218                         }
 219                         $texte .= $_code . (count($traducteurs_langue) > 0 ? ' (' . implode(', ', $traducteurs_langue) . ')' : '');
 220                 }
 221         }
 222
 223         return $texte;
 224 }
 225
 226
 227 /**
 228  * Retourne un texte HTML présentant des statistiques d'un dépot
 229  *
 230  * Liste le nombre de plugins et de paquets d'un dépot
 231  * Indique aussi le nombre de dépots si l'on ne demande pas de dépot particulier.
 232  *
 233  * @param int $id_depot
 234  *     Identifiant du dépot
 235  * @return string
 236  *     Code HTML présentant les statistiques du dépot
 237 **/
 238 function svp_afficher_statistiques_globales($id_depot=0){
 239         $info = '';
 240
 241         $total = svp_compter('depot', $id_depot);
 242         if (!$id_depot) {
 243                 // Si on filtre pas sur un depot alors on affiche le nombre de depots
 244                 $info = '<li id="stats-depot" class="item">
 245                                         <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_depots_disponibles', array('total_depots'=>'')))) . '</div>
 246                                         <div class="unit size1of5 lastUnit">' . $total['depot'] . '</div>
 247                                 </li>';
 248         }
 249         // Compteur des plugins filtre ou pas par depot
 250         $info .= '<li id="stats-plugin" class="item">
 251                                 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_plugins_heberges',  array('total_plugins'=>'')))) . '</div>
 252                                 <div class="unit size1of5 lastUnit">' . $total['plugin'] . '</div>
 253                         </li>';
 254         // Compteur des paquets filtre ou pas par depot
 255         $info .= '<li id="stats-paquet" class="item">
 256                                 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_paquets_disponibles', array('total_paquets'=>'')))) . '</div>
 257                                 <div class="unit size1of5 lastUnit">' . $total['paquet'] . '</div>
 258                         </li>';
 259
 260         return $info;
 261 }
 262
 263
 264 /**
 265  * Retourne un texte indiquant un nombre total de paquets
 266  *
 267  * Calcule le nombre de paquets correspondant à certaines contraintes,
 268  * tel que l'appartenance à un certain dépot, une certaine catégorie
 269  * ou une certaine branche de SPIP et retourne une phrase traduite
 270  * tel que «78 paquets disponibles»
 271  *
 272  * @param int $id_depot
 273  *     Identifiant du dépot
 274  *     Zéro (par défaut) signifie ici : «dans tous les dépots distants»
 275  *     (id_dépot>0) et non «dans le dépot local»
 276  * @param string $categorie
 277  *     Type de catégorie (auteur, communication, date...)
 278  * @param string $compatible_spip
 279  *     Numéro de branche de SPIP. (3.0, 2.1, ...)
 280  * @return string
 281  *     Texte indiquant un nombre total de paquets
 282 **/
 283 function svp_compter_telechargements($id_depot=0, $categorie='', $compatible_spip=''){
 284         $total = svp_compter('paquet', $id_depot, $categorie, $compatible_spip);
 285         $info = _T('svp:info_paquets_disponibles', array('total_paquets'=>$total['paquet']));
 286         return $info;
 287 }
 288
 289 /**
 290  * Retourne un texte indiquant un nombre total de contributions pour un dépot
 291  *
 292  * Calcule différents totaux pour un dépot donné et retourne un texte
 293  * de ces différents totaux. Les totaux correspondent par défaut aux
 294  * plugins et paquets, mais l'on peut demander le total des autres contributions
 295  * avec le second paramètre.
 296  *
 297  * @param int $id_depot
 298  *     Identifiant du dépot
 299  *     Zéro (par défaut) signifie ici : «dans tous les dépots distants»
 300  *     (id_dépot>0) et non «dans le dépot local»
 301  * @param string $contrib
 302  *     Type de total demandé ('plugin' ou autre)
 303  *     Si 'plugin' : indique le nombre de plugins et de paquets du dépot
 304  *     Si autre chose : indique le nombre des autres contributions, c'est
 305  *     à dire des zips qui ne sont pas des plugins, comme certaines libraires ou
 306  *     certains jeux de squelettes.
 307  * @return string
 308  *     Texte indiquant certains totaux tel que nombre de plugins, nombre de paquets...
 309 **/
 310 function svp_compter_depots($id_depot, $contrib='plugin'){
 311         $info = '';
 312
 313         $total = svp_compter('depot', $id_depot);
 314         if (!$id_depot) {
 315                 $info = _T('svp:info_depots_disponibles', array('total_depots'=>$total['depot'])) . ', ' .
 316                                 _T('svp:info_plugins_heberges', array('total_plugins'=>$total['plugin'])) . ', ' .
 317                                 _T('svp:info_paquets_disponibles', array('total_paquets'=>$total['paquet']));
 318         }
 319         else {
 320                 if ($contrib == 'plugin') {
 321                         $info = _T('svp:info_plugins_heberges', array('total_plugins'=>$total['plugin'])) . ', ' .
 322                                         _T('svp:info_paquets_disponibles', array('total_paquets'=>$total['paquet']-$total['autre']));
 323                 }
 324                 else {
 325                         $info = _T('svp:info_contributions_hebergees', array('total_autres'=>$total['autre']));
 326                 }
 327         }
 328         return $info;
 329 }
 330
 331
 332 /**
 333  * Retourne un texte indiquant un nombre total de plugins
 334  *
 335  * Calcule le nombre de plugins correspondant à certaines contraintes,
 336  * tel que l'appartenance à un certain dépot, une certaine catégorie
 337  * ou une certaine branche de SPIP et retourne une phrase traduite
 338  * tel que «64 plugins disponibles»
 339  *
 340  * @param int $id_depot
 341  *     Identifiant du dépot
 342  *     Zéro (par défaut) signifie ici : «dans tous les dépots distants»
 343  *     (id_dépot>0) et non «dans le dépot local»
 344  * @param string $categorie
 345  *     Type de catégorie (auteur, communication, date...)
 346  * @param string $compatible_spip
 347  *     Numéro de branche de SPIP. (3.0, 2.1, ...)
 348  * @return string
 349  *     Texte indiquant un nombre total de paquets
 350 **/
 351 function svp_compter_plugins($id_depot=0, $categorie='', $compatible_spip='') {
 352         $total = svp_compter('plugin', $id_depot, $categorie, $compatible_spip);
 353         $info = _T('svp:info_plugins_disponibles', array('total_plugins'=>$total['plugin']));
 354         return $info;
 355 }
 356
 357
 358 /**
 359  * Compte le nombre de plugins, paquets ou autres contributions
 360  * en fonction de l'entité demandée et de contraintes
 361  *
 362  * Calcule, pour un type d'entité demandé (depot, plugin, paquet, catégorie)
 363  * leur nombre en fonction de certaines contraintes, tel que l'appartenance
 364  * à un certain dépot, une certaine catégorie ou une certaine branche de SPIP.
 365  *
 366  * Lorsque l'entité demandée est un dépot, le tableau des totaux possède,
 367  * en plus du nombre de dépots, le nombre de plugins et paquets.
 368  *
 369  * @note
 370  *     Attention le critère de compatibilite SPIP pris en compte est uniquement
 371  *     celui d'une branche SPIP
 372  *
 373  * @param string $entite
 374  *     De quoi veut-on obtenir des comptes. Peut être 'depot', 'plugin',
 375  *    'paquet' ou 'categorie'
 376  * @param int $id_depot
 377  *     Identifiant du dépot
 378  *     Zéro (par défaut) signifie ici : «dans tous les dépots distants»
 379  *     (id_dépot>0) et non «dans le dépot local»
 380  * @param string $categorie
 381  *     Type de catégorie (auteur, communication, date...)
 382  * @param string $compatible_spip
 383  *     Numéro de branche de SPIP. (3.0, 2.1, ...)
 384  * @return array
 385  *     Couples (entite => nombre).
 386 **/
 387 function svp_compter($entite, $id_depot=0, $categorie='', $compatible_spip=''){
 388         $compteurs = array();
 389
 390         $group_by = array();
 391         $where = array();
 392         if ($id_depot)
 393                 $where[] = "t1.id_depot=" . sql_quote($id_depot);
 394         else
 395                 $where[] = "t1.id_depot>0";
 396
 397         if ($entite == 'plugin') {
 398                 $from = 'spip_plugins AS t2, spip_depots_plugins AS t1';
 399                 $where[] = "t1.id_plugin=t2.id_plugin";
 400                 if ($categorie)
 401                         $where[] = "t2.categorie=" . sql_quote($categorie);
 402                 if ($compatible_spip) {
 403                         $creer_where = charger_fonction('where_compatible_spip', 'inc');
 404                         $where[] =  $creer_where($compatible_spip, 't2', '>');
 405                 }
 406                 $compteurs['plugin'] = sql_count(sql_select('t2.id_plugin', $from, $where));
 407         }
 408         elseif ($entite == 'paquet') {
 409                 if ($categorie) {
 410                         $ids = sql_allfetsel('id_plugin', 'spip_plugins', 'categorie='.sql_quote($categorie));
 411                         $ids = array_map('reset', $ids);
 412                         $where[] = sql_in('t1.id_plugin', $ids);
 413                 }
 414                 if ($compatible_spip) {
 415                         $creer_where = charger_fonction('where_compatible_spip', 'inc');
 416                         $where[] =  $creer_where($compatible_spip, 't1', '>');
 417                 }
 418                 $compteurs['paquet'] = sql_countsel('spip_paquets AS t1', $where);
 419         }
 420         elseif ($entite == 'depot') {
 421                 $champs = array('COUNT(t1.id_depot) AS depot',
 422                                                 'SUM(t1.nbr_plugins) AS plugin',
 423                                                 'SUM(t1.nbr_paquets) AS paquet',
 424                                                 'SUM(t1.nbr_autres) AS autre');
 425                 $compteurs = sql_fetsel($champs, 'spip_depots AS t1', $where);
 426         }
 427         elseif ($entite == 'categorie') {
 428                 $from = array('spip_plugins AS t2');
 429                 $where_depot = $where[0];
 430                 $where = array();
 431                 if ($id_depot) {
 432                         $ids = sql_allfetsel('id_plugin', 'spip_depots_plugins AS t1', $where_depot);
 433                         $ids = array_map('reset', $ids);
 434                         $where[] = sql_in('t2.id_plugin', $ids);
 435                 }
 436                 if ($compatible_spip) {
 437                         $creer_where = charger_fonction('where_compatible_spip', 'inc');
 438                         $where[] =  $creer_where($compatible_spip, 't2', '>');
 439                 }
 440                 if ($categorie)
 441                         $where[] = "t2.categorie=" . sql_quote($categorie);
 442                 else
 443                         $group_by = array('t2.categorie');
 444                 $compteurs['categorie'] = sql_countsel($from, $where, $group_by);
 445         }
 446
 447         return $compteurs;
 448 }
 449
 450
 451 /**
 452  * Compile la balise #SVP_CATEGORIES
 453  *
 454  * Cette balise retourne un tableau listant chaque type de catégorie
 455  * en index, associé à sa traduction en valeur.
 456  *
 457  * Accepte 2 paramètres :
 458  * 1) le type du tri (ordre_cle ou ordre_alpha)
 459  * 2) une catégorie (dans ce cas, limite le tableau à cette seule catégorie si elle existe)
 460  *
 461  * @example
 462  *     #SVP_CATEGORIES
 463  *     #SVP_CATEGORIES{ordre_alpha}
 464  *     #SVP_CATEGORIES{ordre_cle,auteur}
 465  *
 466  * @balise svp_categories
 467  * @see calcul_svp_categories()
 468  * @param Champ $p
 469  *     Pile au niveau de la balise
 470  * @return Champ
 471  *     Pile complétée par le code à générer
 472 **/
 473 function balise_SVP_CATEGORIES($p) {
 474         // tri, peut être 'ordre_cle' ou 'ordre_alpha'
 475         if (!$tri = interprete_argument_balise(1,$p)) {
 476                 $tri = "'ordre_cle'";
 477         }
 478         // catégorie (pour n'en prendre qu'une au lieu de toutes)
 479         if (!$categorie = interprete_argument_balise(2,$p)) {
 480                 $categorie = "''";
 481         }
 482         $p->code = 'calcul_svp_categories(' . $tri .  ',' . $categorie . ')';
 483         return $p;
 484 }
 485
 486 /**
 487  * Retourne un tableau listant chaque type de catégorie
 488  * en index, associé à sa traduction en valeur.
 489  *
 490  * @param string $tri
 491  *     Type de tri (ordre_cle ou ordre_alpha)
 492  * @param string $categorie
 493  *     Restreindre le tableau de retour à cette catégorie si elle existe
 494  * @return array
 495  *     Couples (type de catégorie => Texte de la catégorie)
 496 **/
 497 function calcul_svp_categories($tri='ordre_cle', $categorie='') {
 498
 499         $retour = array();
 500         include_spip('inc/svp_phraser'); // pour $GLOBALS['categories_plugin']
 501         $svp_categories = $GLOBALS['categories_plugin'];
 502
 503         if (is_array($svp_categories)) {
 504                 if (($categorie) AND in_array($categorie, $svp_categories))
 505                         $retour[$categorie] = _T('svp:categorie_' . strtolower($categorie));
 506                 else {
 507                         if ($tri == 'ordre_alpha') {
 508                                 sort($svp_categories);
 509                                 // On positionne l'absence de categorie en fin du tableau
 510                                 $svp_categories[] = array_shift($svp_categories);
 511                         }
 512                         foreach ($svp_categories as $_alias)
 513                                 $retour[$_alias] = svp_traduire_categorie($_alias);
 514                 }
 515         }
 516
 517         return $retour;
 518 }
 519
 520
 521 /**
 522  * Compile la balise #SVP_BRANCHES_SPIP
 523  *
 524  * Cette balise retourne une liste des branches de SPIP
 525  *
 526  * Avec un paramètre indiquant une branche, la balise retourne
 527  * une liste des bornes mini et maxi de cette branche.
 528  *
 529  * @example
 530  *     #SVP_BRANCHES_SPIP       : array('1.9', '2.0', '2.1', ....)
 531  *     #SVP_BRANCHES_SPIP{3.0}  : array('3.0.0', '3.0.99')
 532  *
 533  * @balise svp_branches_spip
 534  * @see calcul_svp_branches_spip()
 535  *
 536  * @param Champ $p
 537  *     Pile au niveau de la balise
 538  * @return Champ
 539  *     Pile complétée par le code à générer
 540 **/
 541 function balise_SVP_BRANCHES_SPIP($p) {
 542         // nom d'une branche en premier argument
 543         if (!$branche = interprete_argument_balise(1,$p)) {
 544                 $branche = "''";
 545         }
 546         $p->code = 'calcul_svp_branches_spip('.$branche.')';
 547         return $p;
 548 }
 549
 550 /**
 551  * Retourne une liste des branches de SPIP, ou les bornes mini et maxi
 552  * d'une branche donnée
 553  *
 554  * @param string $branche
 555  *     Branche dont on veut récupérer les bornes mini et maxi
 556  * @return array
 557  *     Liste des branches array('1.9', '2.0', '2.1', ....)
 558  *     ou liste mini et maxi d'une branche array('3.0.0', '3.0.99')
 559 **/
 560 function calcul_svp_branches_spip($branche) {
 561
 562         $retour = array();
 563         include_spip('inc/svp_outiller'); // pour $GLOBALS['infos_branches_spip']
 564         $svp_branches = $GLOBALS['infos_branches_spip'];
 565
 566         if (is_array($svp_branches)) {
 567                 if (($branche) AND in_array($branche, $svp_branches))
 568                         // On renvoie les bornes inf et sup de la branche specifiee
 569                         $retour = $svp_branches[$branche];
 570                 else {
 571                         // On renvoie uniquement les numeros de branches
 572                         $retour = array_keys($svp_branches);
 573                 }
 574         }
 575
 576         return $retour;
 577 }
 578
 579 /**
 580  * Traduit un type de catégorie de plugin
 581  *
 582  * @param string $alias
 583  *     Type de catégorie (auteur, communication, date...)
 584  * @return string
 585  *     Titre complet et traduit de la catégorie
 586 **/
 587 function svp_traduire_categorie($alias) {
 588         $traduction = '';
 589         if ($alias) {
 590                 $traduction = _T('svp:categorie_' . strtolower($alias));
 591         }
 592         return $traduction;
 593 }
 594
 595 /**
 596  * Traduit un type de dépot de plugin
 597  *
 598  * @param string $type
 599  *     Type de dépot (svn, git, manuel)
 600  * @return string
 601  *     Titre complet et traduit du type de dépot
 602 **/
 603 function svp_traduire_type_depot($type) {
 604
 605         $traduction = '';
 606         if ($type) {
 607                 $traduction = _T('svp:info_type_depot_' . $type);
 608         }
 609         return $traduction;
 610 }
 611
 612 /**
 613  * Critère de compatibilité avec une version précise ou une branche de SPIP.
 614  *
 615  * Fonctionne sur les tables spip_paquets et spip_plugins
 616  *
 617  * Si aucune valeur n'est explicité dans le critère, tous les enregistrements
 618  * sont retournés.
 619  *
 620  * Le ! (NOT) fonctionne sur le critère BRANCHE
 621  *
 622  * @critere compatible_spip
 623  * @example
 624  *   {compatible_spip}
 625  *   {compatible_spip 2.0.8} ou {compatible_spip 1.9}
 626  *   {compatible_spip #ENV{vers}} ou {compatible_spip #ENV{vers, 1.9.2}}
 627  *   {compatible_spip #GET{vers}} ou {compatible_spip #GET{vers, 2.1}}
 628  *
 629  * @param string $idb     Identifiant de la boucle
 630  * @param array $boucles  AST du squelette
 631  * @param Critere $crit   Paramètres du critère dans cette boucle
 632  * @return void
 633  */
 634 function critere_compatible_spip_dist($idb, &$boucles, $crit) {
 635
 636         $boucle = &$boucles[$idb];
 637         $table = $boucle->id_table;
 638
 639         // Si on utilise ! la fonction LOCATE doit retourner 0.
 640         // -> utilise uniquement avec le critere BRANCHE
 641         $op = ($crit->not == '!') ? '=' : '>';
 642
 643         $boucle->hash .= '
 644         // COMPATIBILITE SPIP
 645         $creer_where = charger_fonction(\'where_compatible_spip\', \'inc\');';
 646
 647         // version/branche explicite dans l'appel du critere
 648         if (isset($crit->param[0][0])) {
 649                 $version = calculer_liste(array($crit->param[0][0]), array(), $boucles, $boucle->id_parent);
 650                 $boucle->hash .= '
 651                 $where = $creer_where('.$version.', \''.$table.'\', \''.$op.'\');
 652                 ';
 653         }
 654         // pas de version/branche explicite dans l'appel du critere
 655         // on regarde si elle est dans le contexte
 656         else {
 657                 $boucle->hash .= '
 658                 $version = isset($Pile[0][\'compatible_spip\']) ? $Pile[0][\'compatible_spip\'] : \'\';
 659                 $where = $creer_where($version, \''.$table.'\', \''.$op.'\');
 660                 ';
 661         }
 662
 663         $boucle->where[] = '$where';
 664 }
 665
 666 /**
 667  * Retourne la liste des plugins trouvés par une recherche
 668  *
 669  * @filtre construire_recherche_plugins
 670  * @param string $phrase
 671  *     Texte de la recherche
 672  * @param string $categorie
 673  *     Type de catégorie de plugin (auteur, date...)
 674  * @param string $etat
 675  *     État de plugin (stable, test...)
 676  * @param string|int $depot
 677  *     Identifiant de dépot
 678  * @param bool|string $afficher_exclusions
 679  *     Afficher aussi les paquets déjà installés (true ou 'oui')
 680  *     ou ceux qui ne le sont pas (false) ?
 681  * @param bool|string $afficher_doublons
 682  *     Afficher toutes les versions de paquet (true ou 'oui')
 683  *     ou seulement la plus récente (false) ?
 684  * @return array
 685  *     Tableau classé par pertinence de résultat
 686  *     - 'prefixe' => tableau de description du paquet (si pas de doublons demandé)
 687  *     - n => tableau de descriptions du paquet (si doublons autorisés)
 688 **/
 689 function filtre_construire_recherche_plugins($phrase='', $categorie='', $etat='', $depot='', $afficher_exclusions=true, $afficher_doublons=false) {
 690
 691         // On traite les paramètres d'affichage
 692         $afficher_exclusions = ($afficher_exclusions == 'oui') ? true : false;
 693         $afficher_doublons = ($afficher_doublons == 'oui') ? true : false;
 694
 695         $tri = ($phrase) ? 'score' : 'nom';
 696         $version_spip = $GLOBALS['spip_version_branche'].".".$GLOBALS['spip_version_code'];
 697
 698         // On recupere la liste des paquets:
 699         // - sans doublons, ie on ne garde que la version la plus recente
 700         // - correspondant a ces criteres
 701         // - compatible avec la version SPIP installee sur le site
 702         // - et n'etant pas deja installes (ces paquets peuvent toutefois etre affiches)
 703         // tries par nom ou score
 704         include_spip('inc/svp_rechercher');
 705         $plugins = svp_rechercher_plugins_spip(
 706                 $phrase, $categorie, $etat, $depot, $version_spip,
 707                 svp_lister_plugins_installes(), $afficher_exclusions, $afficher_doublons, $tri);
 708
 709         return $plugins;
 710
 711 }
 712
 713 /**
 714  * Retourne le nombre d'heures entre chaque actualisation
 715  * si le cron est activé.
 716  *
 717  * @return int
 718  *     Nombre d'heures (sinon 0)
 719 **/
 720 function filtre_svp_periode_actualisation_depots() {
 721         include_spip('genie/svp_taches_generales_cron');
 722         return _SVP_CRON_ACTUALISATION_DEPOTS ? _SVP_PERIODE_ACTUALISATION_DEPOTS : 0;
 723 }
 724
 725
 726 /**
 727  * Retourne 'x.y.z' à partir de '00x.00y.00z'
 728  *
 729  * Retourne la chaine de la version x.y.z sous sa forme initiale,
 730  * sans remplissage à gauche avec des 0.
 731  *
 732  * @see normaliser_version()
 733  * @param string $version_normalisee
 734  *     Numéro de version normalisée
 735  * @return string
 736  *     Numéro de version dénormalisée
 737 **/
 738 function denormaliser_version($version_normalisee='') {
 739
 740         $version = '';
 741         if ($version_normalisee) {
 742                 $v = explode('.', $version_normalisee);
 743                 foreach($v as $_nombre) {
 744                         $n = ltrim($_nombre, '0');
 745                         // On traite les cas du type 001.002.000-dev qui doivent etre transformes en 1.2.0-dev.
 746                         // Etant donne que la denormalisation est toujours effectuee sur une version normalisee on sait
 747                         // que le suffixe commence toujours pas '-'
 748                         $vn[] = ((strlen($n)>0) AND substr($n, 0, 1)!='-' ) ? $n : "0$n";
 749                 }
 750                 $version = implode('.', $vn);
 751         }
 752         return $version;
 753 }
 754
 755 /**
 756  * Teste l'utilisation du répertoire auto des plugins.
 757  *
 758  * Ce répertoire permet de télécharger dedans des plugins
 759  * lorsqu'il est présent.
 760  *
 761  * @return bool
 762  *     Le répertoire de chargement des plugins auto est-il présent
 763  *     et utilisable ?
 764  */
 765 function test_plugins_auto() {
 766         static $test = null;
 767         if (is_null($test)) {
 768                 include_spip('inc/plugin'); // pour _DIR_PLUGINS_AUTO
 769                 $test = (defined('_DIR_PLUGINS_AUTO') and _DIR_PLUGINS_AUTO and is_writable(_DIR_PLUGINS_AUTO));
 770         }
 771         return $test;
 772 }
 773 ?>