4 * Déclarations de fonctions
6 * @plugin SVP pour SPIP
8 * @package SPIP\SVP\Fonctions
11 function svp_importer_charset($texte) {
12 if ($GLOBALS['meta']['charset'] == 'utf-8') {
16 return importer_charset($texte, 'utf-8');
20 * Retourne un texte expliquant l'intervalle de compatibilité avec un plugin ou SPIP
22 * Retourne par exemple "2.0 <= SPIP < 3.1"
24 * @param string $intervalle
25 * L'intervalle tel que déclaré dans paquet.xml. Par exemple "[2.1;3.0.*]"
26 * @param string $logiciel
27 * Nom du plugin pour qui est cette intervalle
29 * Texte expliquant l'intervalle
31 function svp_afficher_intervalle($intervalle, $logiciel) {
32 if (!strlen($intervalle)) {
35 if (!defined('_EXTRAIRE_INTERVALLE')) {
36 include_spip('inc/plugin');
38 if (!preg_match(_EXTRAIRE_INTERVALLE
. 'Uis', $intervalle, $regs)) {
44 $majeure = preg_replace(',\.99$,', '.*', $regs[2]);
45 $mineure_inc = $intervalle[0] == "[";
46 $majeure_inc = substr($intervalle, -1) == "]";
47 if (strlen($mineure)) {
48 if (!strlen($majeure)) {
49 $version = _T('svp:info_logiciel_version', array(
50 'logiciel' => $logiciel,
51 'signe' => ($mineure_inc ?
'≥' : '>'),
52 'version' => $mineure,
55 $version = _T('svp:info_logiciel_version_intervalle', array(
56 'logiciel' => $logiciel,
57 'signe_min' => ($mineure_inc ?
'≥' : '>'),
58 'version_min' => $mineure,
59 'signe_max' => ($majeure_inc ?
'≤' : '<'),
60 'version_max' => $majeure,
64 if (!strlen($majeure)) {
67 $version = _T('svp:info_logiciel_version', array(
68 'logiciel' => $logiciel,
69 'signe' => ($majeure_inc ?
'≤' : '<'),
70 'version' => $majeure,
79 * Traduit un type d'état de plugin
81 * Si l'état n'existe pas, prendra par défaut 'developpement'
83 * @see plugin_etat_en_clair()
85 * Le type d'état (stable, test, ...)
87 * Traduction de l'état dans la langue en cours
89 function svp_afficher_etat($etat) {
90 include_spip('plugins/afficher_plugin');
92 return plugin_etat_en_clair($etat);
96 * Retourne un texte HTML présentant la liste des dépendances d'un plugin
98 * Des liens vers les plugins dépendants sont présents lorsque les plugins
99 * en dépendance sont connus dans notre base.
101 * @uses svp_afficher_intervalle()
102 * @param string $balise_serialisee
103 * Informations des dépendances (tableau sérialisé) tel que stocké
104 * en base dans la table spip_paquets
105 * @param string $dependance
106 * Type de dépendances à afficher (necessite ou utilise).
107 * Une autre valeur indique qu'on demande la liste des librairies dépendantes.
109 * Séparateur entre les noms de dépendances
110 * @param string $lien
111 * Type de lien affecté au plugin référencé dans la base locale. Prend les valeurs :
113 * - local : le lien pointe vers la page publique du plugin sur le site lui-même. Il faut
114 * donc que le site propose des pages publiques pour les plugins sinon une 404 sera affichée;
115 * - pluginspip : le lien pointe vers la page du plugin sur le site de référence Plugins SPIP;
116 * - non : aucun lien n'est affiché.
118 * Texte informant des dépendances
120 function svp_afficher_dependances($balise_serialisee, $dependance = 'necessite', $sep = '<br />', $lien = 'local') {
123 $t = unserialize($balise_serialisee);
124 $dependances = $t[$dependance];
125 if (is_array($dependances)) {
128 foreach ($dependances as $_compatibilite => $_dependance) {
129 $compatibilite = ($_compatibilite !== 0)
130 ?
_T('svp:info_compatibilite_dependance',
131 array('compatibilite' => svp_afficher_intervalle($_compatibilite, 'SPIP')))
133 if ($compatibilite) {
134 $texte .= ($texte ?
str_repeat($sep, 2) : '') . $compatibilite;
136 foreach ($_dependance as $_plugin) {
140 if (($dependance == 'necessite') or ($dependance == 'utilise')) {
141 if ($plugin = sql_fetsel('id_plugin, nom', 'spip_plugins', 'prefixe=' . sql_quote($_plugin['nom']))) {
142 $nom = extraire_multi($plugin['nom']);
143 if ($lien == 'non') {
146 $url = ($lien == 'local')
147 ?
generer_url_entite($plugin['id_plugin'], 'plugin')
148 : "https://plugins.spip.net/{$_plugin['nom']}.html";
149 $bulle = _T('svp:bulle_aller_plugin');
150 $logiciel = '<a href="' . $url . '" title="' . $bulle . '">' . $nom . '</a>';
153 // Cas ou le plugin n'est pas encore dans la base SVP.
154 // On affiche son préfixe, cependant ce n'est pas un affichage devant perdurer
155 $logiciel = $_plugin['nom'];
158 if (isset($_plugin['compatibilite'])) {
159 $intervalle = svp_afficher_intervalle($_plugin['compatibilite'], $logiciel);
161 $texte .= ($intervalle) ?
$intervalle : $logiciel;
162 } else // On demande l'affichage des librairies
164 $texte .= '<a href="' . $_plugin['lien'] . '" title="' . _T('svp:bulle_telecharger_librairie') . '">' . $_plugin['nom'] . '</a>';
174 * Teste si un plugin possède des dépendances
176 * @param string $balise_serialisee
177 * Informations des dépendances (tableau sérialisé) tel que stocké
178 * en base dans la table spip_paquets
180 * Le plugin possède t'il des dépendances ?
182 function svp_dependances_existe($balise_serialisee) {
183 $dependances = unserialize($balise_serialisee);
184 foreach ($dependances as $_dependance) {
195 * Retourne un texte HTML présentant les crédits d'un plugin
197 * Des liens vers les crédits sont présents lorsqu'ils sont déclarés
198 * dans le paquet.xml.
200 * @param string $balise_serialisee
201 * Informations des crédits (tableau sérialisé) tel que stocké
202 * en base dans la table spip_paquets
204 * Séparateur entre les différents crédits
206 * Texte informant des crédits
208 function svp_afficher_credits($balise_serialisee, $sep = ', ') {
211 $credits = unserialize($balise_serialisee);
212 if (is_array($credits)) {
213 foreach ($credits as $_credit) {
217 // Si le credit en cours n'est pas un array c'est donc un copyright
219 (!is_array($_credit))
220 ?
PtoBR(propre($_credit)) // propre pour les [lien->url] des auteurs de plugin.xml ...
221 : ($_credit['url'] ?
'<a href="' . $_credit['url'] . '">' : '') .
223 ($_credit['url'] ?
'</a>' : '');
232 * Retourne un texte HTML présentant la liste des langues et traducteurs d'un plugin
234 * Des liens vers les traducteurs sont présents lorsqu'ils sont connus.
236 * @param array $langues
237 * Tableau code de langue => traducteurs
239 * Séparateur entre les différentes langues
241 * Texte informant des langues et traducteurs
243 function svp_afficher_langues($langues, $sep = ', ') {
247 foreach ($langues as $_code => $_traducteurs) {
251 $traducteurs_langue = array();
252 foreach ($_traducteurs as $_traducteur) {
253 if (is_array($_traducteur)) {
254 $traducteurs_langue[] =
255 ($_traducteur['lien'] ?
'<a href="' . $_traducteur['lien'] . '">' : '') .
256 $_traducteur['nom'] .
257 ($_traducteur['lien'] ?
'</a>' : '');
260 $texte .= $_code . (count($traducteurs_langue) > 0 ?
' (' . implode(', ', $traducteurs_langue) . ')' : '');
269 * Retourne un texte HTML présentant des statistiques d'un dépot
271 * Liste le nombre de plugins et de paquets d'un dépot
272 * Indique aussi le nombre de dépots si l'on ne demande pas de dépot particulier.
274 * @uses svp_compter()
275 * @param int $id_depot
276 * Identifiant du dépot
278 * Code HTML présentant les statistiques du dépot
280 function svp_afficher_statistiques_globales($id_depot = 0) {
283 $total = svp_compter('depot', $id_depot);
285 // Si on filtre pas sur un depot alors on affiche le nombre de depots
286 $info = '<li id="stats-depot" class="item">
287 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_depots_disponibles', array('total_depots' => '')))) . '</div>
288 <div class="unit size1of5 lastUnit">' . $total['depot'] . '</div>
291 // Compteur des plugins filtre ou pas par depot
292 $info .= '<li id="stats-plugin" class="item">
293 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_plugins_heberges', array('total_plugins' => '')))) . '</div>
294 <div class="unit size1of5 lastUnit">' . $total['plugin'] . '</div>
296 // Compteur des paquets filtre ou pas par depot
297 $info .= '<li id="stats-paquet" class="item">
298 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_paquets_disponibles', array('total_paquets' => '')))) . '</div>
299 <div class="unit size1of5 lastUnit">' . $total['paquet'] . '</div>
307 * Retourne un texte indiquant un nombre total de paquets
309 * Calcule le nombre de paquets correspondant à certaines contraintes,
310 * tel que l'appartenance à un certain dépot, une certaine catégorie
311 * ou une certaine branche de SPIP et retourne une phrase traduite
312 * tel que «78 paquets disponibles»
314 * @uses svp_compter()
315 * @param int $id_depot
316 * Identifiant du dépot
317 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
318 * (id_dépot>0) et non «dans le dépot local»
319 * @param string $categorie
320 * Type de catégorie (auteur, communication, date...)
321 * @param string $compatible_spip
322 * Numéro de branche de SPIP. (3.0, 2.1, ...)
324 * Texte indiquant un nombre total de paquets
326 function svp_compter_telechargements($id_depot = 0, $categorie = '', $compatible_spip = '') {
327 $total = svp_compter('paquet', $id_depot, $categorie, $compatible_spip);
328 $info = _T('svp:info_paquets_disponibles', array('total_paquets' => $total['paquet']));
334 * Retourne un texte indiquant un nombre total de contributions pour un dépot
336 * Calcule différents totaux pour un dépot donné et retourne un texte
337 * de ces différents totaux. Les totaux correspondent par défaut aux
338 * plugins et paquets, mais l'on peut demander le total des autres contributions
339 * avec le second paramètre.
341 * @uses svp_compter()
342 * @param int $id_depot
343 * Identifiant du dépot
344 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
345 * (id_dépot>0) et non «dans le dépot local»
346 * @param string $contrib
347 * Type de total demandé ('plugin' ou autre)
348 * Si 'plugin' : indique le nombre de plugins et de paquets du dépot
349 * Si autre chose : indique le nombre des autres contributions, c'est
350 * à dire des zips qui ne sont pas des plugins, comme certaines libraires ou
351 * certains jeux de squelettes.
353 * Texte indiquant certains totaux tel que nombre de plugins, nombre de paquets...
355 function svp_compter_depots($id_depot, $contrib = 'plugin') {
358 $total = svp_compter('depot', $id_depot);
360 $info = _T('svp:info_depots_disponibles', array('total_depots' => $total['depot'])) . ', ' .
361 _T('svp:info_plugins_heberges', array('total_plugins' => $total['plugin'])) . ', ' .
362 _T('svp:info_paquets_disponibles', array('total_paquets' => $total['paquet']));
364 if ($contrib == 'plugin') {
365 $info = _T('svp:info_plugins_heberges', array('total_plugins' => $total['plugin'])) . ', ' .
366 _T('svp:info_paquets_disponibles', array('total_paquets' => $total['paquet'] - $total['autre']));
368 $info = _T('svp:info_contributions_hebergees', array('total_autres' => $total['autre']));
377 * Retourne un texte indiquant un nombre total de plugins
379 * Calcule le nombre de plugins correspondant à certaines contraintes,
380 * tel que l'appartenance à un certain dépot, une certaine catégorie
381 * ou une certaine branche de SPIP et retourne une phrase traduite
382 * tel que «64 plugins disponibles»
384 * @uses svp_compter()
385 * @param int $id_depot
386 * Identifiant du dépot
387 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
388 * (id_dépot>0) et non «dans le dépot local»
389 * @param string $categorie
390 * Type de catégorie (auteur, communication, date...)
391 * @param string $compatible_spip
392 * Numéro de branche de SPIP. (3.0, 2.1, ...)
394 * Texte indiquant un nombre total de paquets
396 function svp_compter_plugins($id_depot = 0, $categorie = '', $compatible_spip = '') {
397 $total = svp_compter('plugin', $id_depot, $categorie, $compatible_spip);
398 $info = _T('svp:info_plugins_disponibles', array('total_plugins' => $total['plugin']));
405 * Compte le nombre de plugins, paquets ou autres contributions
406 * en fonction de l'entité demandée et de contraintes
408 * Calcule, pour un type d'entité demandé (depot, plugin, paquet, catégorie)
409 * leur nombre en fonction de certaines contraintes, tel que l'appartenance
410 * à un certain dépot, une certaine catégorie ou une certaine branche de SPIP.
412 * Lorsque l'entité demandée est un dépot, le tableau des totaux possède,
413 * en plus du nombre de dépots, le nombre de plugins et paquets.
416 * Attention le critère de compatibilite SPIP pris en compte est uniquement
417 * celui d'une branche SPIP
419 * @param string $entite
420 * De quoi veut-on obtenir des comptes. Peut être 'depot', 'plugin',
421 * 'paquet' ou 'categorie'
422 * @param int $id_depot
423 * Identifiant du dépot
424 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
425 * (id_dépot>0) et non «dans le dépot local»
426 * @param string $categorie
427 * Type de catégorie (auteur, communication, date...)
428 * @param string $compatible_spip
429 * Numéro de branche de SPIP. (3.0, 2.1, ...)
431 * Couples (entite => nombre).
433 function svp_compter($entite, $id_depot = 0, $categorie = '', $compatible_spip = '') {
434 $compteurs = array();
438 $where[] = "t1.id_depot=" . sql_quote($id_depot);
440 $where[] = "t1.id_depot>0";
443 if ($entite == 'plugin') {
444 $from = array('spip_plugins AS t2', 'spip_depots_plugins AS t1');
445 $where[] = "t1.id_plugin=t2.id_plugin";
447 $where[] = "t2.categorie=" . sql_quote($categorie);
449 if ($compatible_spip) {
450 $creer_where = charger_fonction('where_compatible_spip', 'inc');
451 $where[] = $creer_where($compatible_spip, 't2', '>');
453 $compteurs['plugin'] = sql_count(sql_select('DISTINCT t1.id_plugin', $from, $where));
454 } elseif ($entite == 'paquet') {
455 $from = array('spip_paquets AS t1');
457 $ids = sql_allfetsel('id_plugin', 'spip_plugins', 'categorie=' . sql_quote($categorie));
458 $ids = array_column($ids, 'id_plugin');
459 $where[] = sql_in('t1.id_plugin', $ids);
461 if ($compatible_spip) {
462 $creer_where = charger_fonction('where_compatible_spip', 'inc');
463 $where[] = $creer_where($compatible_spip, 't1', '>');
465 $compteurs['paquet'] = sql_countsel($from, $where);
466 } elseif ($entite == 'depot') {
467 $from = array('spip_depots AS t1');
469 'COUNT(t1.id_depot) AS depot',
470 'SUM(t1.nbr_plugins) AS plugin',
471 'SUM(t1.nbr_paquets) AS paquet',
472 'SUM(t1.nbr_autres) AS autre'
474 $compteurs = sql_fetsel($select, $from, $where);
475 } elseif ($entite == 'categorie') {
476 $from = array('spip_plugins AS t2', 'spip_depots_plugins AS t1');
477 $where[] = "t1.id_plugin=t2.id_plugin";
479 $ids = sql_allfetsel('id_plugin', 'spip_depots_plugins AS t1', $where);
480 $ids = array_column($ids, 'id_plugin');
481 $where[] = sql_in('t2.id_plugin', $ids);
483 if ($compatible_spip) {
484 $creer_where = charger_fonction('where_compatible_spip', 'inc');
485 $where[] = $creer_where($compatible_spip, 't2', '>');
488 $where[] = "t2.categorie=" . sql_quote($categorie);
489 $compteurs['categorie'] = sql_count(sql_select('DISTINCT t1.id_plugin', $from, $where));
491 $select = array('t2.categorie', 'count(DISTINCT t1.id_plugin) as nb');
492 $group_by = array('t2.categorie');
493 $plugins = sql_allfetsel($select, $from, $where, $group_by);
494 $compteurs['categorie'] = array_column($plugins, 'nb', 'categorie');
503 * Compile la balise `#SVP_CATEGORIES`
505 * Cette balise retourne un tableau listant chaque type de catégorie
506 * en index, associé à sa traduction en valeur.
508 * Accepte 2 paramètres :
509 * 1) le type du tri (ordre_cle ou ordre_alpha)
510 * 2) une catégorie (dans ce cas, limite le tableau à cette seule catégorie si elle existe)
514 * #SVP_CATEGORIES{ordre_alpha}
515 * #SVP_CATEGORIES{ordre_cle,auteur}
518 * @see calcul_svp_categories()
520 * Pile au niveau de la balise
522 * Pile complétée par le code à générer
524 function balise_SVP_CATEGORIES($p) {
525 // tri, peut être 'ordre_cle' ou 'ordre_alpha'
526 if (!$tri = interprete_argument_balise(1, $p)) {
527 $tri = "'ordre_cle'";
529 // catégorie (pour n'en prendre qu'une au lieu de toutes)
530 if (!$categorie = interprete_argument_balise(2, $p)) {
533 $p->code
= 'calcul_svp_categories(' . $tri . ',' . $categorie . ')';
539 * Retourne un tableau listant chaque type de catégorie
540 * en index, associé à sa traduction en valeur.
542 * @uses svp_traduire_categorie()
545 * Type de tri (ordre_cle ou ordre_alpha)
546 * @param string $categorie
547 * Restreindre le tableau de retour à cette catégorie si elle existe
549 * Couples (type de catégorie => Texte de la catégorie)
551 function calcul_svp_categories($tri = 'ordre_cle', $categorie = '') {
554 include_spip('inc/svp_phraser'); // pour $GLOBALS['categories_plugin']
555 $svp_categories = $GLOBALS['categories_plugin'];
557 if (is_array($svp_categories)) {
558 if (($categorie) and in_array($categorie, $svp_categories)) {
559 $retour[$categorie] = _T('svp:categorie_' . strtolower($categorie));
561 if ($tri == 'ordre_alpha') {
562 sort($svp_categories);
563 // On positionne l'absence de categorie en fin du tableau
564 $svp_categories[] = array_shift($svp_categories);
566 foreach ($svp_categories as $_alias) {
567 $retour[$_alias] = svp_traduire_categorie($_alias);
577 * Compile la balise `#SVP_BRANCHES_SPIP`
579 * Cette balise retourne une liste des branches de SPIP
581 * Avec un paramètre indiquant une branche, la balise retourne
582 * une liste des bornes mini et maxi de cette branche.
585 * #SVP_BRANCHES_SPIP : array('1.9', '2.0', '2.1', ....)
586 * #SVP_BRANCHES_SPIP{3.0} : array('3.0.0', '3.0.99')
589 * @see calcul_svp_branches_spip()
592 * Pile au niveau de la balise
594 * Pile complétée par le code à générer
596 function balise_SVP_BRANCHES_SPIP($p) {
597 // nom d'une branche en premier argument
598 if (!$branche = interprete_argument_balise(1, $p)) {
601 $p->code
= 'calcul_svp_branches_spip(' . $branche . ')';
607 * Retourne une liste des branches de SPIP, ou les bornes mini et maxi
608 * d'une branche donnée
610 * @param string $branche
611 * Branche dont on veut récupérer les bornes mini et maxi
613 * Liste des branches array('1.9', '2.0', '2.1', ....)
614 * ou liste mini et maxi d'une branche array('3.0.0', '3.0.99')
616 function calcul_svp_branches_spip($branche) {
619 include_spip('inc/svp_outiller'); // pour $GLOBALS['infos_branches_spip']
620 $svp_branches = $GLOBALS['infos_branches_spip'];
622 if (is_array($svp_branches)) {
623 if (($branche) and in_array($branche, $svp_branches)) // On renvoie les bornes inf et sup de la branche specifiee
625 $retour = $svp_branches[$branche];
627 // On renvoie uniquement les numeros de branches
628 $retour = array_keys($svp_branches);
636 * Traduit un type de catégorie de plugin
638 * @param string $alias
639 * Type de catégorie (auteur, communication, date...)
641 * Titre complet et traduit de la catégorie
643 function svp_traduire_categorie($alias) {
646 $traduction = _T('svp:categorie_' . strtolower($alias));
653 * Traduit un type de dépot de plugin
655 * @param string $type
656 * Type de dépot (svn, git, manuel)
658 * Titre complet et traduit du type de dépot
660 function svp_traduire_type_depot($type) {
664 $traduction = _T('svp:info_type_depot_' . $type);
671 * Calcule l'url exacte d'un lien de démo en fonction de son écriture
673 * @param string $url_demo
674 * URL de démonstration telle que saisie dans le paquet.xml
675 * @param boolean $url_absolue
676 * Indique que seules les url absolues doivent être retournées par la fonction.
677 * Tous les autres types d'url renvoient une chaine vide
679 * URL calculée en fonction de l'URL d'entrée
681 function svp_calculer_url_demo($url_demo, $url_absolue = false) {
684 $url_demo = trim($url_demo);
685 if (strlen($url_demo) > 0) {
686 $url_elements = @parse_url
($url_demo);
687 if (isset($url_elements['scheme']) and $url_elements['scheme']) {
688 // Cas 1 : http://xxxx. C'est donc une url absolue que l'on conserve telle qu'elle.
689 $url_calculee = $url_demo;
692 if (isset($url_elements['query']) and $url_elements['query']) {
693 // Cas 2 : ?exec=xxx ou ?page=yyy. C'est donc une url relative que l'on transforme
694 // en url absolue privée ou publique en fonction de la query.
695 $egal = strpos($url_elements['query'], '=');
696 $page = substr($url_elements['query'], $egal +
1, strlen($url_elements['query']) - $egal - 1);
697 if (strpos($url_elements['query'], 'exec=') !== false) {
698 $url_calculee = generer_url_ecrire($page);
700 $url_calculee = generer_url_public($page);
702 } elseif (isset($url_elements['path']) and $url_elements['path']) {
703 // Cas 3 : xxx/yyy. C'est donc une url relative que l'on transforme
704 $url_calculee = generer_url_public($url_demo);
710 return $url_calculee;
714 * Critère de compatibilité avec une version précise ou une branche de SPIP ou une liste de branches séparées par
717 * Fonctionne sur les tables spip_paquets et spip_plugins.
718 * Si aucune valeur n'est explicité dans le critère on interroge le contexte pour trouver une variable
719 * compatible_spip et sinon tous les objets sont retournés.
721 * Le ! (NOT) ne fonctionne que sur une branche ou une liste de branches SPIP.
726 * {compatible_spip 2.0.8} ou {compatible_spip 1.9}
727 * {compatible_spip #ENV{vers}} ou {compatible_spip #ENV{vers, 1.9.2}}
728 * {compatible_spip #GET{vers}} ou {compatible_spip #GET{vers, 2.1}}
729 * {compatible_spip '2.0,2.1'}
730 * {!compatible_spip 2.0}
731 * {!compatible_spip '2.0,2.1'}
732 * {!compatible_spip #ENV{vers}} ou {!compatible_spip #GET{vers}}
734 * @param string $idb Identifiant de la boucle
735 * @param array $boucles AST du squelette
736 * @param Critere $crit Paramètres du critère dans cette boucle
740 function critere_compatible_spip_dist($idb, &$boucles, $crit) {
742 // Initialisation de la table (spip_plugins ou spip_paquets)
743 $boucle = &$boucles[$idb];
744 $table = $boucle->id_table
;
746 // Initialisation du numéro de critère pour utiliser plusieurs fois le critère dans la même boucle
749 // La fonction LOCATE retourne soit 0 (pas trouvée) soit une valeur strictement supérieure à 0 (trouvée).
750 // Donc avec le modificateur not l'opérateur est un "=", sinon un ">".
751 // Le NOT s'utilise uniquement avec une branche SPIP (ex 2.0).
752 $op = ($crit->not
== '!') ?
'=' : '>';
754 // On calcule le code des critères.
755 // -- Initialisation avec le chargement de la fonction de calcul du critère.
757 // COMPATIBILITE SPIP
758 $creer_where = charger_fonction(\'where_compatible_spip\', \'inc\');';
760 // On traite le critère suivant que la version ou la branche est explicitement fournie ou pas.
761 if (!empty($crit->param
)) {
762 // La ou les versions/branches sont explicites dans l'appel du critere.
763 // - on boucle sur les paramètres sachant qu'il est possible de fournir une liste séparée par une virgule
765 foreach ($crit->param
as $_param) {
766 if (isset($_param[0])) {
767 $version = calculer_liste(array($_param[0]), array(), $boucles, $boucle->id_parent
);
769 $where' . $i . ' = $creer_where(' . $version . ', \'' . $table . '\', \'' . $op . '\');
771 $boucle->where
[] = '$where' . $i;
776 // Pas de version ou de branche explicite dans l'appel du critere.
777 // - on regarde si elle est dans le contexte
779 $version = isset($Pile[0][\'compatible_spip\']) ? $Pile[0][\'compatible_spip\'] : \'\';
780 $where' . $i . ' = $creer_where($version, \'' . $table . '\', \'' . $op . '\');
782 $boucle->where
[] = '$where' . $i;
788 * Retourne la liste des plugins trouvés par une recherche
791 * @param string $phrase
792 * Texte de la recherche
793 * @param string $categorie
794 * Type de catégorie de plugin (auteur, date...)
795 * @param string $etat
796 * État de plugin (stable, test...)
797 * @param string|int $depot
798 * Identifiant de dépot
799 * @param bool|string $afficher_exclusions
800 * Afficher aussi les paquets déjà installés (true ou 'oui')
801 * ou ceux qui ne le sont pas (false) ?
802 * @param bool|string $afficher_doublons
803 * Afficher toutes les versions de paquet (true ou 'oui')
804 * ou seulement la plus récente (false) ?
806 * Tableau classé par pertinence de résultat
807 * - 'prefixe' => tableau de description du paquet (si pas de doublons demandé)
808 * - n => tableau de descriptions du paquet (si doublons autorisés)
810 function filtre_construire_recherche_plugins(
815 $afficher_exclusions = true,
816 $afficher_doublons = false
819 // On traite les paramètres d'affichage
820 $afficher_exclusions = ($afficher_exclusions == 'oui') ?
true : false;
821 $afficher_doublons = ($afficher_doublons == 'oui') ?
true : false;
823 $tri = ($phrase) ?
'score' : 'nom';
824 $version_spip = $GLOBALS['spip_version_branche'] . "." . $GLOBALS['spip_version_code'];
826 // On recupere la liste des paquets:
827 // - sans doublons, ie on ne garde que la version la plus recente
828 // - correspondant a ces criteres
829 // - compatible avec la version SPIP installee sur le site
830 // - et n'etant pas deja installes (ces paquets peuvent toutefois etre affiches)
831 // tries par nom ou score
832 include_spip('inc/svp_rechercher');
833 $plugins = svp_rechercher_plugins_spip(
834 $phrase, $categorie, $etat, $depot, $version_spip,
835 svp_lister_plugins_installes(), $afficher_exclusions, $afficher_doublons, $tri);
842 * Retourne le nombre d'heures entre chaque actualisation
843 * si le cron est activé.
846 * Nombre d'heures (sinon 0)
848 function filtre_svp_periode_actualisation_depots() {
849 include_spip('genie/svp_taches_generales_cron');
851 return _SVP_CRON_ACTUALISATION_DEPOTS ? _SVP_PERIODE_ACTUALISATION_DEPOTS
: 0;
856 * Retourne 'x.y.z' à partir de '00x.00y.00z'
858 * Retourne la chaine de la version x.y.z sous sa forme initiale,
859 * sans remplissage à gauche avec des 0.
861 * @see normaliser_version()
862 * @param string $version_normalisee
863 * Numéro de version normalisée
865 * Numéro de version dénormalisée
867 function denormaliser_version($version_normalisee = '') {
870 if ($version_normalisee) {
871 $v = explode('.', $version_normalisee);
872 foreach ($v as $_nombre) {
873 $n = ltrim($_nombre, '0');
874 // On traite les cas du type 001.002.000-dev qui doivent etre transformes en 1.2.0-dev.
875 // Etant donne que la denormalisation est toujours effectuee sur une version normalisee on sait
876 // que le suffixe commence toujours pas '-'
877 $vn[] = ((strlen($n) > 0) and substr($n, 0, 1) != '-') ?
$n : "0$n";
879 $version = implode('.', $vn);
886 * Teste l'utilisation du répertoire auto des plugins.
888 * Ce répertoire permet de télécharger dedans des plugins
889 * lorsqu'il est présent.
892 * Le répertoire de chargement des plugins auto est-il présent
895 function test_plugins_auto() {
897 if (is_null($test)) {
898 include_spip('inc/plugin'); // pour _DIR_PLUGINS_AUTO
899 $test = (defined('_DIR_PLUGINS_AUTO') and _DIR_PLUGINS_AUTO
and is_writable(_DIR_PLUGINS_AUTO
));