www/plugins-dist/svp/inc/svp_depoter_distant.php

   1 <?php
   2
   3 /**
   4  * Traitement des dépots distants
   5  *
   6  * Un dépot distant est une liste de paquets que l'on peut télécharger.
   7  * Cette liste est donnée par un fichier XML que l'on peut relire
   8  * régulièrement pour actualiser nos informations. Effectivement, chaque
   9  * paquet (et plugin) décrit est inséré en base de données pour nous
  10  * faciliter les recherches.
  11  *
  12  * @plugin SVP pour SPIP
  13  * @license GPL
  14  * @package SPIP\SVP\Depots
  15  */
  16
  17 if (!defined("_ECRIRE_INC_VERSION")) {
  18         return;
  19 }
  20 include_spip('inc/plugin');
  21 include_spip('inc/svp_phraser');
  22
  23
  24 /**
  25  * Ajout d'un dépot et de son contenu (paquets, plugins) dans la base de données
  26  *
  27  * Si une erreur survient (syntaxe XML incorrecte, pas de plugin dans le dépot),
  28  * son texte est placé dans le paramètre $erreur
  29  *
  30  * @uses  svp_phraser_depot()
  31  * @uses  svp_actualiser_paquets()
  32  * @uses  svp_base_supprimer_paquets_locaux()
  33  * @param string $url
  34  *     URL du fichier XML de description du dépot
  35  * @param string $erreur
  36  *     Texte d'un éventuel message d'erreur
  37  * @return bool
  38  *     true si le dépot est ajouté correctement, false sinon
  39  */
  40 function svp_ajouter_depot($url, &$erreur = '') {
  41         include_spip('inc/distant');
  42
  43         // On considere que l'url a deja ete validee (correcte et nouveau depot)
  44         $url = trim($url);
  45         // Ajout du depot dans la table spip_depots. Les compteurs de paquets et de plugins
  46         // sont mis a jour apres le traitement des paquets
  47
  48         // on recupère le XML
  49         $fichier_xml = copie_locale($url, 'modif');
  50         if (!$fichier_xml) {
  51                 $erreur = _T('svp:message_nok_xml_non_recupere', array('fichier' => $url));
  52
  53                 return false;
  54         }
  55
  56         $fichier_xml = _DIR_RACINE . $fichier_xml;
  57
  58         // Lire les donnees d'un depot de paquets
  59         $infos = svp_phraser_depot($fichier_xml);
  60         if (!$infos) {
  61                 $erreur = _T('svp:message_nok_xml_non_conforme', array('fichier' => $url));
  62
  63                 return false;
  64         }
  65
  66         $titre = filtrer_entites($infos['depot']['titre']);
  67         $champs = array(
  68                 'titre' => $titre,
  69                 'descriptif' => filtrer_entites($infos['depot']['descriptif']),
  70                 'type' => $infos['depot']['type'],
  71                 'url_serveur' => $infos['depot']['url_serveur'],
  72                 'url_brouteur' => $infos['depot']['url_brouteur'],
  73                 'url_archives' => $infos['depot']['url_archives'],
  74                 'url_commits' => $infos['depot']['url_commits'],
  75                 'xml_paquets' => $url,
  76                 'sha_paquets' => sha1_file($fichier_xml),
  77                 'nbr_paquets' => 0,
  78                 'nbr_plugins' => 0,
  79                 'nbr_autres' => 0
  80         );
  81
  82         // verifier avant l'insertion que le depot n'existe pas deja
  83         // car la recuperation pouvant etre longue on risque le probleme en cas de concurrence
  84         if (sql_countsel('spip_depots', 'xml_paquets=' . sql_quote($url))) {
  85                 $erreur = _T('svp:message_nok_depot_deja_ajoute', array('url' => $url));
  86
  87                 return false;
  88         } elseif (!$id_depot = sql_insertq('spip_depots', $champs)) {
  89                 $erreur = _T('svp:message_nok_sql_insert_depot', array('objet' => "$titre ($url)"));
  90
  91                 return false;
  92         }
  93
  94         // Ajout des paquets dans spip_paquets et actualisation des plugins dans spip_plugins
  95         $ok = svp_actualiser_paquets($id_depot, $infos['paquets'], $nb_paquets, $nb_plugins, $nb_autres);
  96         if (!$ok or ($nb_paquets == 0)) {
  97                 // Si une erreur s'est produite, on supprime le depot deja insere
  98                 sql_delete('spip_depots', 'id_depot=' . sql_quote($id_depot));
  99                 if (!$ok) {
 100                         $erreur = _T('svp:message_nok_xml_non_conforme', array('fichier' => $url));
 101                 } else {
 102                         $erreur = _T('svp:message_nok_aucun_paquet_ajoute', array('url' => $url));
 103                 }
 104
 105                 return false;
 106         }
 107
 108         // On met à jour le nombre de paquets et de plugins du depot maintenant !
 109         sql_updateq('spip_depots',
 110                 array('nbr_paquets' => $nb_paquets, 'nbr_plugins' => $nb_plugins, 'nbr_autres' => $nb_autres),
 111                 'id_depot=' . sql_quote($id_depot));
 112
 113         // On vide les paquets locaux pour mettre a jour leurs donnees relatives au depot
 114         // comme les mises a jour disponibles
 115         include_spip('inc/svp_depoter_local');
 116         svp_actualiser_paquets_locaux(true);
 117
 118         return true;
 119 }
 120
 121 /**
 122  * Suppression d'un dépot et de son contenu (paquets, plugins) dans la base de données
 123  *
 124  * Cette suppression entraîne des recalcul comme les versions maximales
 125  * des plugins téléchargeables qui peuvent changer.
 126  *
 127  * @uses  svp_actualiser_url_plugins()
 128  * @uses  svp_nettoyer_apres_suppression()
 129  * @uses  svp_base_supprimer_paquets_locaux()
 130  *
 131  * @param int $id
 132  *     Identifiant du dépot
 133  * @return bool
 134  *     false si le dépot n'est pas trouvé, true sinon
 135  */
 136 function svp_supprimer_depot($id) {
 137         $id = intval($id);
 138
 139         // Pas de depot a cet id ?
 140         if (!$id_depot = sql_getfetsel('id_depot', 'spip_depots', 'id_depot=' . sql_quote($id))) {
 141                 return false;
 142         }
 143
 144         // on calcule les versions max des plugins heberges par le depot
 145         $vmax = array();
 146
 147         if ($resultats = sql_allfetsel('id_plugin, version', 'spip_paquets', 'id_depot=' . sql_quote($id))) {
 148                 foreach ($resultats as $paquet) {
 149                         $id_plugin = $paquet['id_plugin'];
 150                         if (!isset($vmax[$id_plugin])
 151                                 or (spip_version_compare($vmax[$id_plugin], $paquet['version'], '<'))
 152                         ) {
 153                                 $vmax[$id_plugin] = $paquet['version'];
 154                         }
 155                 }
 156         }
 157
 158         // On supprime les paquets heberges par le depot
 159         sql_delete('spip_paquets', 'id_depot=' . sql_quote($id_depot));
 160
 161         // Si on est pas en mode runtime, on utilise surement l'espace public pour afficher les plugins.
 162         // Il faut donc verifier que les urls suivent bien la mise à jour
 163         // Donc avant de nettoyer la base des plugins du depot ayant disparus on supprime toutes les urls
 164         // associees a ce depot : on les recreera apres le nettoyage
 165         if (!_SVP_MODE_RUNTIME) {
 166                 svp_actualiser_url_plugins($id_depot);
 167         }
 168
 169         // Nettoyer les autres relations à ce dépot
 170         svp_nettoyer_apres_suppression($id_depot, $vmax);
 171
 172         // Si on est pas en mode runtime, on utilise surement l'espace public pour afficher les plugins.
 173         // Il faut donc s'assurer que les urls suivent bien la mise à jour
 174         // - on supprime toutes les urls plugin
 175         // - on les regenere pour la liste des plugins mise a jour
 176         if (!_SVP_MODE_RUNTIME) {
 177                 svp_actualiser_url_plugins($id_depot);
 178         }
 179
 180         // On supprime le depot lui-meme
 181         sql_delete('spip_depots', 'id_depot=' . sql_quote($id_depot));
 182
 183         // on supprime les paquets locaux pour reactualisation
 184         include_spip('inc/svp_depoter_local');
 185         svp_base_supprimer_paquets_locaux();
 186
 187         return true;
 188 }
 189
 190
 191 /**
 192  * Nettoyer la base de données après la suppression d'un dépot
 193  *
 194  * Supprime
 195  * - les liens des plugins avec le dépot (table spip_depots_plugins)
 196  * - les plugins dont aucun paquet n'est encore hébergé par un dépot restant (table spip_plugins)
 197  * Remet à zéro la version maximale des plugins ayant vu leur paquet en version maximale supprimée
 198  *
 199  * @param int $id_depot
 200  *     Identifiant du dépot
 201  * @param array $vmax
 202  *     Tableau de la version maximale des plugins du dépot supprimé
 203  *     Tableau (id_plugin => version maximale)
 204  * @return bool
 205  *     true toujours.
 206  **/
 207 function svp_nettoyer_apres_suppression($id_depot, $vmax) {
 208
 209         // On rapatrie la liste des plugins du depot qui servira apres qu'on ait supprime les liens
 210         // de la table spip_depots_plugins
 211         $liens = sql_allfetsel('id_plugin', 'spip_depots_plugins', 'id_depot=' . sql_quote($id_depot));
 212         $plugins_depot = array_map('reset', $liens);
 213
 214         // On peut donc supprimer tous ces liens *plugins-depots* du depot
 215         sql_delete('spip_depots_plugins', 'id_depot=' . sql_quote($id_depot));
 216
 217         // On verifie pour chaque plugin concerne par la disparition de paquets si c'est la version
 218         // la plus elevee qui a ete supprimee.
 219         // Si oui, on positionne le vmax a 0, ce qui permettra de remettre a jour le plugin systematiquement
 220         // a la prochaine actualisation.
 221         // Cette operation est necessaire car on n'impose pas que les informations du plugin soient identiques
 222         // pour chaque paquet !!!
 223
 224         // On insere, en encapsulant pour sqlite...
 225         if (sql_preferer_transaction()) {
 226                 sql_demarrer_transaction();
 227         }
 228
 229         if ($resultats = sql_allfetsel('id_plugin, vmax', 'spip_plugins', sql_in('id_plugin', $plugins_depot))) {
 230                 foreach ($resultats as $plugin) {
 231                         if (spip_version_compare($plugin['vmax'], $vmax[$plugin['id_plugin']], '=')) {
 232                                 sql_updateq('spip_plugins', array('vmax' => ''), 'id_plugin=' . sql_quote($plugin['id_plugin']));
 233                         }
 234                 }
 235         }
 236
 237         if (sql_preferer_transaction()) {
 238                 sql_terminer_transaction();
 239         }
 240
 241         // Maintenant on calcule la liste des plugins du depot qui ne sont pas heberges
 242         // par un autre depot => donc a supprimer
 243         // - Liste de tous les plugins encore lies a un autre depot
 244         // tous les plugins correspondants aux anciens paquets
 245         $plugins_restants = sql_allfetsel('DISTINCT(id_plugin)', 'spip_paquets', sql_in('id_plugin', $plugins_depot));
 246         $plugins_restants = array_map('array_shift', $plugins_restants);
 247
 248         // - L'intersection des deux tableaux renvoie les plugins a supprimer
 249         $plugins_a_supprimer = array_diff($plugins_depot, $plugins_restants);
 250
 251         // On supprimer les plugins identifies
 252         sql_delete('spip_plugins', sql_in('id_plugin', $plugins_a_supprimer));
 253
 254         return true;
 255 }
 256
 257
 258 /**
 259  * Actualisation des plugins d'un dépot déjà crée
 260  *
 261  * Actualise les informations uniquement si la signature du fichier
 262  * XML de description du dépot a changé
 263  *
 264  * @uses  svp_actualiser_maj_version()
 265  * @uses  svp_actualiser_paquets()
 266  * @uses  svp_phraser_depot()
 267  * @param int $id
 268  *     Identifiant du dépot
 269  * @return bool
 270  *     false si erreur, true sinon
 271  */
 272 function svp_actualiser_depot($id) {
 273         include_spip('inc/distant');
 274
 275         $id = intval($id);
 276
 277         // pas de depot a cet id ?
 278         if (!$depot = sql_fetsel('*', 'spip_depots', 'id_depot=' . sql_quote($id))) {
 279                 return false;
 280         }
 281
 282         $fichier_xml = _DIR_RACINE . copie_locale($depot['xml_paquets'], 'modif');
 283
 284         $sha = sha1_file($fichier_xml);
 285
 286         if ($depot['sha_paquets'] == $sha) {
 287                 // Le fichier n'a pas change (meme sha1) alors on ne fait qu'actualiser la date
 288                 // de mise a jour du depot en mettant a jour *inutilement* le sha1
 289                 spip_log('Aucune modification du fichier XML, actualisation non declenchee - id_depot = ' . $depot['id_depot'],
 290                         'svp_actions.' . _LOG_INFO);
 291                 sql_replace('spip_depots', array_diff_key($depot, array('maj' => '')));
 292         } else {
 293
 294                 // Le fichier a bien change il faut actualiser tout le depot
 295                 $infos = svp_phraser_depot($fichier_xml);
 296
 297                 if (!$infos) {
 298                         return false;
 299                 }
 300
 301                 // On actualise les paquets dans spip_paquets en premier lieu.
 302                 // Lors de la mise a jour des paquets, les plugins aussi sont actualises
 303                 $ok = svp_actualiser_paquets($depot['id_depot'], $infos['paquets'],
 304                         $nb_paquets, $nb_plugins, $nb_autres);
 305
 306                 // apres la mise a jour des paquets d'un depot, on actualise les informations des paquets locaux
 307                 // principalement l'info "maj_version" indiquant s'il existe un paquet plus recent
 308                 include_spip('inc/svp_depoter_local');
 309                 svp_actualiser_maj_version();
 310
 311                 if ($ok) {
 312                         // On met à jour :
 313                         // -- les infos ne pouvant pas etre editees par le formulaire d'edition
 314                         //    d'un depot et extraites du xml
 315                         // -- le nombre de paquets et de plugins du depot ainsi que le nouveau sha1
 316                         // ce qui aura pour effet d'actualiser la date de mise a jour
 317                         $champs = array(
 318                                 'url_serveur' => $infos['depot']['url_serveur'],
 319                                 'url_brouteur' => $infos['depot']['url_brouteur'],
 320                                 'url_archives' => $infos['depot']['url_archives'],
 321                                 'url_commits' => $infos['depot']['url_commits'],
 322                                 'nbr_paquets' => $nb_paquets,
 323                                 'nbr_plugins' => $nb_plugins,
 324                                 'nbr_autres' => $nb_autres,
 325                                 'sha_paquets' => $sha
 326                         );
 327                         sql_updateq('spip_depots', $champs, 'id_depot=' . sql_quote($depot['id_depot']));
 328                 }
 329         }
 330
 331         return true;
 332 }
 333
 334
 335 /**
 336  * Actualisation de la table des paquets pour le dépot choisi
 337  *
 338  * Enlève de la base les paquets du dépots qui ne sont plus présents
 339  * dans la description du XML. Ajoute ou met à jour les autres.
 340  *
 341  * @uses  svp_supprimer_plugins_orphelins()
 342  * @uses  svp_corriger_vmax_plugins()
 343  * @uses  svp_completer_plugins()
 344  * @uses  eclater_plugin_paquet()
 345  * @uses  svp_inserer_multi()
 346  * @uses  svp_completer_plugins_depot()
 347  * @uses  svp_actualiser_url_plugins()
 348  *
 349  * @param int $id_depot
 350  *     Identifiant du dépot
 351  * @param array $paquets
 352  *     Tableau des paquets extraits du fichier XML
 353  *     L'index est le nom de l'archive (xxxx.zip) et le contenu est
 354  *     un tableau à deux entrées :
 355  *     - Index 'plugin' : le tableau des infos du plugin
 356  *     - Index 'file' : le nom de l'archive .zip
 357  * @param int $nb_paquets
 358  *     Nombre de paquets réellement inserés dans la base
 359  * @param int $nb_plugins
 360  *     Nombre de plugins parmi les paquets inserés
 361  * @param int $nb_autres
 362  *     Nombre de contributions non issues de plugin parmi les paquets inserés
 363  * @return bool
 364  *     false si aucun dépot ou paquets, true sinon
 365  */
 366 function svp_actualiser_paquets($id_depot, $paquets, &$nb_paquets, &$nb_plugins, &$nb_autres) {
 367
 368         // Initialisation des compteurs
 369         $nb_paquets = 0;
 370         $nb_plugins = 0;
 371         $nb_autres = 0;
 372
 373         // Si aucun depot ou aucun paquet on renvoie une erreur
 374         if ((!$id_depot) or (!is_array($paquets))) {
 375                 return false;
 376         }
 377
 378         // On initialise l'url de base des logos du depot et son type afin de
 379         // calculer l'url complete de chaque logo
 380         $select = array('url_archives', 'type');
 381         $depot = sql_fetsel($select, 'spip_depots', 'id_depot=' . sql_quote($id_depot));
 382
 383
 384         // On supprime tous les paquets du depot
 385         // qui ont ete evacues, c'est a dire ceux dont les signatures
 386         // ne correspondent pas aux nouveaux...
 387         // et on retablit les vmax des plugins restants...
 388         $signatures = array();
 389         foreach ($paquets as $_paquet) {
 390                 $signatures[] = $_paquet['md5'];
 391         }
 392
 393         // tous les paquets du depot qui ne font pas parti des signatures
 394         $anciens_paquets = sql_allfetsel('id_paquet', 'spip_paquets',
 395                 array('id_depot=' . sql_quote($id_depot), sql_in('signature', $signatures, 'NOT')));
 396         $anciens_paquets = array_map('array_shift', $anciens_paquets);
 397
 398         // pour ces vieux paquets, on les nettoie de la base
 399         if ($anciens_paquets) {
 400                 // tous les plugins correspondants aux anciens paquets
 401                 $anciens_plugins = sql_allfetsel('pl.id_plugin', array('spip_plugins AS pl', 'spip_paquets AS pa'),
 402                         array('pl.id_plugin=pa.id_plugin', sql_in('pa.id_paquet', $anciens_paquets)));
 403                 $anciens_plugins = array_map('array_shift', $anciens_plugins);
 404
 405                 // suppression des anciens paquets
 406                 sql_delete('spip_paquets', sql_in('id_paquet', $anciens_paquets));
 407                 // suppressions des liaisons depots / anciens plugins
 408                 // on enlève la liaison lorsqu'il n'y a plus aucun paquet lie a un des plugins qui ont vu un paquet enlevé
 409
 410                 // liste des plugins qui ont encore des paquets dans ce depot
 411                 $plugins_restants = sql_allfetsel('pl.id_plugin',
 412                         array('spip_plugins AS pl', 'spip_paquets AS pa'),
 413                         array(
 414                                 sql_in('pl.id_plugin', $anciens_plugins),
 415                                 'pl.id_plugin=pa.id_plugin',
 416                                 'pa.id_depot=' . sql_quote($id_depot)
 417                         ));
 418                 $plugins_restants = array_map('array_shift', $plugins_restants);
 419                 // par opposition, on retrouve ceux qui n'en ont plus...
 420                 $plugins_supprimes = array_diff($anciens_plugins, $plugins_restants);
 421                 sql_delete('spip_depots_plugins',
 422                         array('id_depot=' . sql_quote($id_depot), sql_in('id_plugin', $plugins_supprimes)));
 423                 unset($plugins_restants, $plugins_supprimes);
 424
 425                 // supprimer les plugins orphelins
 426                 include_spip('inc/svp_depoter_local');
 427                 svp_supprimer_plugins_orphelins($anciens_plugins);
 428
 429                 // corriger les vmax des plugins
 430                 svp_corriger_vmax_plugins($anciens_plugins);
 431
 432                 // corriger les compats, branches aussi
 433                 svp_completer_plugins($anciens_plugins);
 434         }
 435
 436         // on ne garde que les paquets qui ne sont pas presents dans la base
 437         $signatures = sql_allfetsel('signature', 'spip_paquets', 'id_depot=' . sql_quote($id_depot));
 438         $signatures = array_map('array_shift', $signatures);
 439         foreach ($paquets as $cle => $_infos) {
 440                 if (in_array($_infos['md5'], $signatures)) {
 441                         unset($paquets[$cle]);
 442                 }
 443         }
 444
 445         // tableaux d'actions
 446         $insert_paquets = array();
 447         $insert_plugins = array();
 448         $insert_contribs = array();
 449         $prefixes = array(); // prefixe => id_plugin
 450
 451         // On met a jour ou on cree chaque paquet a partir du contenu du fichier xml
 452         // On ne fait pas cas de la compatibilite avec la version de SPIP installee
 453         // car l'operation doit permettre de collecter tous les paquets
 454         foreach ($paquets as $_archive => $_infos) {
 455
 456                 $insert_paquet = array();
 457                 // On initialise les informations specifiques au paquet :
 458                 // l'id du depot et les infos de l'archive
 459                 $insert_paquet['id_depot'] = $id_depot;
 460                 $insert_paquet['nom_archive'] = $_archive;
 461                 $insert_paquet['nbo_archive'] = $_infos['size'];
 462                 $insert_paquet['maj_archive'] = date('Y-m-d H:i:s', $_infos['date']);
 463                 $insert_paquet['src_archive'] = $_infos['source'];
 464                 $insert_paquet['date_modif'] = $_infos['last_commit'];
 465                 // On serialise le tableau des traductions par module
 466                 $insert_paquet['traductions'] = serialize($_infos['traductions']);
 467                 // On ajoute la signature
 468                 $insert_paquet['signature'] = $_infos['md5'];
 469
 470                 // On verifie si le paquet est celui d'un plugin ou pas
 471                 // -- Les traitements du XML dependent de la DTD utilisee
 472                 // Formatage des informations extraites du plugin pour insertion dans la base SVP
 473                 $formater = charger_fonction('preparer_sql_' . $_infos['dtd'], 'plugins');
 474                 if ($champs_aplat = $formater($_infos['plugin'])) {
 475                         // Eclater les champs recuperes en deux sous tableaux, un par table (plugin, paquet)
 476                         $champs = eclater_plugin_paquet($champs_aplat);
 477
 478                         $paquet_plugin = true;
 479                         // On complete les informations du paquet et du plugin
 480                         $insert_paquet = array_merge($insert_paquet, $champs['paquet']);
 481                         $insert_plugin = $champs['plugin'];
 482                         // On construit l'url complete du logo
 483                         // Le logo est maintenant disponible a la meme adresse que le zip et porte le nom du zip.
 484                         // Son extension originale est conservee
 485                         if ($insert_paquet['logo']) {
 486                                 $insert_paquet['logo'] = $depot['url_archives'] . '/'
 487                                         . basename($insert_paquet['nom_archive'], '.zip') . '.'
 488                                         . pathinfo($insert_paquet['logo'], PATHINFO_EXTENSION);
 489                         }
 490
 491                         // On loge l'absence de categorie ou une categorie erronee et on positionne la categorie
 492                         // par defaut "aucune"
 493                         // Provisoire tant que la DTD n'est pas en fonction
 494                         if (!$insert_plugin['categorie']) {
 495                                 spip_log("Categorie absente dans le paquet issu de <" . $insert_paquet['src_archive'] .
 496                                         "> du depot <" . $insert_paquet['id_depot'] . ">\n", 'svp_paquets.' . _LOG_INFO_IMPORTANTE);
 497                                 $insert_plugin['categorie'] = 'aucune';
 498                         } else {
 499                                 $svp_categories = $GLOBALS['categories_plugin'];
 500                                 if (!in_array($insert_plugin['categorie'], $svp_categories)) {
 501                                         spip_log("Categorie &#107;" . $insert_plugin['categorie'] . "&#108; incorrecte dans le paquet issu de <" . $insert_paquet['src_archive'] .
 502                                                 "> du depot <" . $insert_paquet['id_depot'] . ">\n", 'svp_paquets.' . _LOG_INFO_IMPORTANTE);
 503                                         $insert_plugin['categorie'] = 'aucune';
 504                                 }
 505                         }
 506                 } else {
 507                         $paquet_plugin = false;
 508                 }
 509                 // On teste l'existence du paquet dans la base avec les champs
 510                 // id_depot, nom_archive et src_archive pour être sur de l'unicité.
 511                 // - si le paquet n'existe pas, on le crée,
 512                 // - sinon (et ça ne devrait pas arriver), on ne fait qu'un update
 513                 if (!$paquet = sql_fetsel('*', 'spip_paquets', array(
 514                         'id_depot=' . sql_quote($insert_paquet['id_depot']),
 515                         'nom_archive=' . sql_quote($insert_paquet['nom_archive']),
 516                         'src_archive=' . sql_quote($insert_paquet['src_archive'])
 517                 ))
 518                 ) {
 519                         // Le paquet n'existe pas encore en base de donnees
 520                         // ------------------------------------------------
 521
 522                         // On positionne la date de creation a celle du dernier commit ce qui est bien le cas
 523                         $insert_paquet['date_crea'] = $insert_paquet['date_modif'];
 524
 525                         // Les collisions ne sont possibles que si on ajoute un nouveau paquet
 526                         $collision = false;
 527
 528                         if ($paquet_plugin) {
 529                                 // On est en presence d'un PLUGIN
 530                                 // ------------------------------
 531                                 // On evite les doublons de paquet
 532                                 // Pour determiner un doublon on verifie actuellement :
 533                                 // - le prefixe
 534                                 // - la version du paquet et de la base
 535                                 // - l'etat
 536                                 $where = array(
 537                                         't1.id_plugin=t2.id_plugin',
 538                                         't1.version=' . sql_quote($insert_paquet['version']),
 539                                         't1.version_base=' . sql_quote($insert_paquet['version_base']),
 540                                         't1.etatnum=' . sql_quote($insert_paquet['etatnum']),
 541                                         't1.id_depot>' . intval(0),
 542                                         't2.prefixe=' . sql_quote($insert_plugin['prefixe'])
 543                                 );
 544                                 if (!$id_paquet = sql_getfetsel('t1.id_paquet', 'spip_paquets AS t1, spip_plugins AS t2', $where)) {
 545                                         // On traite d'abord le plugin du paquet pour recuperer l'id_plugin
 546                                         // On rajoute le plugin dans la table spip_plugins si celui-ci n'y est pas encore ou on recupere
 547                                         // l'id si il existe deja et on le met a jour si la version du paquet est plus elevee
 548
 549                                         $plugin = sql_fetsel('id_plugin, vmax', 'spip_plugins',
 550                                                 array('prefixe=' . sql_quote($insert_plugin['prefixe'])));
 551                                         if (!$plugin and !array_key_exists($insert_plugin['prefixe'], $insert_plugins)) {
 552                                                 $insert_plugins[$insert_plugin['prefixe']] = array_merge($insert_plugin,
 553                                                         array('vmax' => $insert_paquet['version']));
 554                                         } else {
 555                                                 if ($plugin) {
 556                                                         $id_plugin = $plugin['id_plugin'];
 557                                                         $prefixes[$insert_plugin['prefixe']] = $id_plugin;
 558                                                 }
 559                                                 if (array_key_exists($insert_plugin['prefixe'], $insert_plugins)
 560                                                         and (spip_version_compare($insert_plugins[$insert_plugin['prefixe']]['vmax'], $insert_paquet['version'],
 561                                                                 '<='))
 562                                                 ) {
 563                                                         // attribuer au plugin le nom et le slogan du paquet le plus à jour
 564                                                         $insert_plugins[$insert_plugin['prefixe']]['nom'] = $insert_plugin['nom'];
 565                                                         $insert_plugins[$insert_plugin['prefixe']]['slogan'] = $insert_plugin['slogan'];
 566                                                         $insert_plugins[$insert_plugin['prefixe']]['vmax'] = $insert_paquet['version'];
 567                                                 }
 568                                         }
 569
 570                                         // On traite maintenant le paquet connaissant l'id du plugin
 571                                         // temporaire qui sera supprime lors de la connaissance de l'id_paquet
 572                                         $insert_paquet['prefixe'] = $insert_plugin['prefixe'];
 573                                         $insert_paquets[] = $insert_paquet;
 574                                 } else {
 575                                         $collision = true;
 576                                 }
 577                         } else {
 578                                 // On est en presence d'une CONTRIBUTION NON PLUGIN
 579                                 // ------------------------------------------------
 580                                 $where = array(
 581                                         'id_depot=' . sql_quote($insert_paquet['id_depot']),
 582                                         'nom_archive=' . sql_quote($insert_paquet['nom_archive'])
 583                                 );
 584                                 if (!$id_paquet = sql_getfetsel('id_paquet', 'spip_paquets', $where)) {
 585                                         // Ce n'est pas un plugin, donc id_plugin=0 et toutes les infos plugin sont nulles
 586                                         $insert_paquet['id_plugin'] = 0;
 587                                         $insert_contribs[] = $insert_paquet;
 588                                 } else {
 589                                         $collision = true;
 590                                 }
 591                         }
 592                         // On loge le paquet ayant ete refuse dans un fichier a part afin de les verifier
 593                         // apres coup
 594                         if ($collision) {
 595                                 spip_log("Collision avec le paquet <" . $insert_paquet['nom_archive'] .
 596                                         " / " . $insert_paquet['src_archive'] . "> du depot <" . $insert_paquet['id_depot'] . ">\n",
 597                                         'svp_paquets.' . _LOG_INFO_IMPORTANTE);
 598                         }
 599                 } else {
 600                         // Le paquet existe deja en base de donnees
 601                         // ----------------------------------------
 602
 603                         // On ne devrait plus arriver ICI...
 604                         // Code obsolete ?
 605                         spip_log('!!!!!! Passage dans code obsolete (svp/svp_depoter_distant)', 'depoter');
 606
 607                         // on effectue les traitements en attente
 608                         // pour que les updates soient corrects
 609                         svp_inserer_multi($insert_plugins, $insert_paquets, $insert_contribs, $prefixes);
 610
 611
 612                         // On met a jour le paquet en premier lieu qu'il soit un plugin ou une contribution
 613                         sql_updateq('spip_paquets', $insert_paquet,
 614                                 'id_paquet=' . sql_quote($paquet['id_paquet']));
 615
 616                 }
 617         }
 618
 619         // on effectue les traitements en attente
 620         // pour que les updates soient corrects
 621         svp_inserer_multi($insert_plugins, $insert_paquets, $insert_contribs, $prefixes);
 622
 623         // On rajoute le plugin comme heberge par le depot si celui-ci n'est pas encore enregistre comme tel
 624         $ids = sql_allfetsel('p.id_plugin',
 625                 array('spip_plugins AS p', 'spip_depots_plugins AS dp'),
 626                 array('p.id_plugin=dp.id_plugin', 'dp.id_depot=' . sql_quote($id_depot)));
 627         $ids = array_map('array_shift', $ids);
 628
 629         // inserer les liens avec le depots
 630         $insert_dp = array();
 631         $news_id = array_diff(array_values($prefixes), $ids);
 632         foreach ($news_id as $id) {
 633                 $insert_dp[] = array('id_depot' => $id_depot, 'id_plugin' => $id);
 634         }
 635         if ($insert_dp) {
 636                 sql_insertq_multi('spip_depots_plugins', $insert_dp);
 637         }
 638
 639         // on recalcul les vmax des plugins de ce depot.
 640         svp_corriger_vmax_plugins(array_values($prefixes));
 641
 642         // On compile maintenant certaines informations des paquets mis a jour dans les plugins
 643         // (date de creation, date de modif, version spip...)
 644         svp_completer_plugins_depot($id_depot);
 645
 646         // Si on est pas en mode runtime, on utilise surement l'espace public pour afficher les plugins.
 647         // Il faut donc s'assurer que les urls suivent bien la mise à jour
 648         // - on supprime toutes les urls plugin
 649         // - on les regenere pour la liste des plugins mise a jour
 650         if (!_SVP_MODE_RUNTIME) {
 651                 svp_actualiser_url_plugins($id_depot);
 652         }
 653
 654         // Calcul des compteurs de paquets, plugins et contributions
 655         $nb_paquets = sql_countsel('spip_paquets', 'id_depot=' . sql_quote($id_depot));
 656         $nb_plugins = sql_countsel('spip_depots_plugins', 'id_depot=' . sql_quote($id_depot));
 657         $nb_autres = sql_countsel('spip_paquets', array('id_depot=' . sql_quote($id_depot), 'id_plugin=0'));
 658
 659         return true;
 660 }
 661
 662
 663 /**
 664  * Insertion en masse de plugins ou de paquets.
 665  *
 666  * Les paquets peuvent de pas avoir d'info "prefixe" (à transformer en id_plugin)
 667  * lorsqu'ils ne proviennent pas de plugin (squelettes...)
 668  *
 669  * @param array $insert_plugins
 670  *     Tableau de description de plugins.
 671  *     Une description est un tableau de couples (colonne sql => valeur)
 672  *     pour l'insertion en base de données.
 673  * @param array $insert_paquets
 674  *     Tableau de description de paquets.
 675  *     Une description est un tableau de couples (colonne sql => valeur)
 676  *     pour l'insertion en base de données.
 677  * @param array $insert_contribs
 678  *     Tableau de description de paquets (contributions non plugins).
 679  *     Une description est un tableau de couples (colonne sql => valeur)
 680  *     pour l'insertion en base de données.
 681  * @param array $prefixes
 682  *     Couples de relation (préfixe de plugin => identifiant de plugin) connues,
 683  *     pour limiter les accès SQL.
 684  * @return void
 685  **/
 686 function svp_inserer_multi(&$insert_plugins, &$insert_paquets, &$insert_contribs, &$prefixes) {
 687
 688         if (count($insert_plugins)) {
 689                 sql_insertq_multi('spip_plugins', $insert_plugins);
 690                 $insert_plugins = array();
 691         }
 692
 693         if (count($insert_paquets)) {
 694
 695                 // on cherche tous les id_plugin/prefixe que l'on a à récuperer
 696                 // en une seule requete
 697                 $prefixes_manquants = array();
 698                 foreach ($insert_paquets as $p) {
 699                         // on ne connait que le prefixe
 700                         if (isset($p['prefixe']) and !isset($prefixes[$p['prefixe']])) {
 701                                 $prefixes_manquants[] = $p['prefixe'];
 702                         }
 703                 }
 704
 705                 // recuperer les nouveaux prefixes :
 706                 $new = sql_allfetsel(array('prefixe', 'id_plugin'), 'spip_plugins', sql_in('prefixe', $prefixes_manquants));
 707                 foreach ($new as $p) {
 708                         $prefixes[$p['prefixe']] = $p['id_plugin'];
 709                 }
 710
 711                 // inserer les id_plugin dans les paquets a inserer
 712                 // inserer le prefixe dans le paquet (pour raccourcis de jointures)
 713                 foreach ($insert_paquets as $c => $p) {
 714                         if (isset($p['prefixe'])) {
 715                                 $insert_paquets[$c]['id_plugin'] = $prefixes[$insert_paquets[$c]['prefixe']];
 716                         } else {
 717                                 $insert_paquets[$c]['prefixe'] = array_search($p['id_plugin'], $prefixes);
 718                         }
 719                 }
 720
 721                 // on insere tout !
 722                 sql_insertq_multi('spip_paquets', $insert_paquets);
 723                 $insert_paquets = array();
 724         }
 725
 726         // les contribs n'ont pas le même nombre de champs dans les insertions
 727         // et n'ont pas de plugin rattachés.
 728         if (count($insert_contribs)) {
 729                 sql_insertq_multi('spip_paquets', $insert_contribs);
 730                 $insert_contribs = array();
 731         }
 732 }
 733
 734 /**
 735  * Complète les informations des plugins contenus dans un depot
 736  * en compilant certaines informations (compatibilités, dates,  branches)
 737  *
 738  * @uses  svp_completer_plugins()
 739  * @param int $id_depot
 740  *     Identifiant du depot à actualiser
 741  **/
 742 function svp_completer_plugins_depot($id_depot) {
 743         // On limite la revue des paquets a ceux des plugins heberges par le depot en cours d'actualisation
 744         $ids_plugins = sql_allfetsel('id_plugin', 'spip_depots_plugins', array('id_depot=' . sql_quote($id_depot)));
 745         $ids_plugins = array_map('reset', $ids_plugins);
 746         if ($ids_plugins) {
 747                 svp_completer_plugins($ids_plugins);
 748         }
 749 }
 750
 751 /**
 752  * Complète les informations des plugins, d'une liste de plugins donnés,
 753  * en compilant certaines informations (compatibilités, dates,  branches)
 754  *
 755  * @uses  compiler_branches_spip()
 756  * @param array $ids_plugin
 757  *     Liste d'identifiants de plugins
 758  * @return bool
 759  *     false si rien à faire, true sinon
 760  **/
 761 function svp_completer_plugins($ids_plugin) {
 762
 763         if (!$ids_plugin) {
 764                 return false;
 765         }
 766
 767         include_spip('inc/svp_outiller');
 768
 769         // -- on recupere tous les paquets associes aux plugins indiques et on compile les infos
 770         if ($resultats = sql_allfetsel('id_plugin, compatibilite_spip, date_crea, date_modif', 'spip_paquets',
 771                 array(sql_in('id_plugin', $ids_plugin), 'id_depot>' . intval(0)), '', 'id_plugin')
 772         ) {
 773
 774                 $plugin_en_cours = 0;
 775                 $inserts = array();
 776
 777                 foreach ($resultats as $paquet) {
 778                         // On finalise le plugin en cours et on passe au suivant
 779                         if ($plugin_en_cours != $paquet['id_plugin']) {
 780                                 // On met a jour le plugin en cours
 781                                 if ($plugin_en_cours) {
 782                                         // On deduit maintenant les branches de la compatibilite globale
 783                                         $complements['branches_spip'] = compiler_branches_spip($complements['compatibilite_spip']);
 784                                         $inserts[$plugin_en_cours] = $complements;
 785                                 }
 786                                 // On passe au plugin suivant
 787                                 $plugin_en_cours = $paquet['id_plugin'];
 788                                 $complements = array('compatibilite_spip' => '', 'branches_spip' => '', 'date_crea' => 0, 'date_modif' => 0);
 789                         }
 790
 791                         // On compile les compléments du plugin avec le paquet courant sauf les branches
 792                         // qui sont deduites en fin de compilation de la compatibilite
 793                         if ($paquet['date_modif'] > $complements['date_modif']) {
 794                                 $complements['date_modif'] = $paquet['date_modif'];
 795                         }
 796                         if (($complements['date_crea'] === 0)
 797                                 or ($paquet['date_crea'] < $complements['date_crea'])
 798                         ) {
 799                                 $complements['date_crea'] = $paquet['date_crea'];
 800                         }
 801                         if ($paquet['compatibilite_spip']) {
 802                                 if (!$complements['compatibilite_spip']) {
 803                                         $complements['compatibilite_spip'] = $paquet['compatibilite_spip'];
 804                                 } else {
 805                                         $complements['compatibilite_spip'] = fusionner_intervalles($paquet['compatibilite_spip'],
 806                                                 $complements['compatibilite_spip']);
 807                                 }
 808                         }
 809                 }
 810                 // On finalise le dernier plugin en cours
 811                 $complements['branches_spip'] = compiler_branches_spip($complements['compatibilite_spip']);
 812                 $inserts[$plugin_en_cours] = $complements;
 813
 814                 // On insere, en encapsulant pour sqlite...
 815                 if (sql_preferer_transaction()) {
 816                         sql_demarrer_transaction();
 817                 }
 818
 819                 foreach ($inserts as $id_plugin => $complements) {
 820                         sql_updateq('spip_plugins', $complements, 'id_plugin=' . intval($id_plugin));
 821                 }
 822
 823                 if (sql_preferer_transaction()) {
 824                         sql_terminer_transaction();
 825                 }
 826
 827         }
 828
 829         return true;
 830 }
 831
 832
 833 /**
 834  * Recrée toutes les URLs propres de plugin
 835  *
 836  * Supprime toutes les urls de plugin de la table spip_urls puis les régénère.
 837  *
 838  * @return int
 839  *     Nombre d'URLs de plugin régénérées
 840  **/
 841 function svp_actualiser_url_plugins() {
 842         $nb_plugins = 0;
 843
 844         // On supprime toutes les urls de plugin
 845         sql_delete('spip_urls', array('type=\'plugin\''));
 846
 847         // On recupere les ids des plugins et on regenere les urls
 848         if ($ids_plugin = sql_allfetsel('id_plugin', 'spip_plugins')) {
 849                 $ids_plugin = array_map('reset', $ids_plugin);
 850                 $nb_plugins = count($ids_plugin);
 851
 852                 foreach ($ids_plugin as $_id) {
 853                         generer_url_entite($_id, 'plugin', '', '', true);
 854                 }
 855         }
 856
 857         return $nb_plugins;
 858 }
 859
 860 /**
 861  * Éclate une description de paquet issu du XML du dépot en deux parties,
 862  * une pour le plugin, l'autre pour le paquet
 863  *
 864  * Sépare en deux une description de champs désignant un paquet, en extrayant :
 865  * - la partie plugin, soit ce qui peut être propre à plusieurs paquets.
 866  *   On trouve dedans le prefixe, nom, slogan, catégorie, tags
 867  * - la partie paquet, soit ce qui est propre à ce conteneur là. On trouve
 868  *   dedans entre autres la description, la version, la compatibilité
 869  *   à SPIP, les dépendances, etc...
 870  *
 871  * @param array $champs_aplat
 872  *     Couples (clé => valeur) d'un paquet issu de l'analyse XML du dépot
 873  * @return array
 874  *     Tableau de 2 index :
 875  *     - Index 'plugin' : couples (clé=>valeur) relatives au plugin
 876  *     - Index 'paquet' : couples (clé=>valeur) spécifiques au paquet
 877  **/
 878 function eclater_plugin_paquet($champs_aplat) {
 879         return array(
 880                 'plugin' => array(
 881                         'prefixe' => $champs_aplat['prefixe'],
 882                         'nom' => $champs_aplat['nom'],
 883                         'slogan' => $champs_aplat['slogan'],
 884                         'categorie' => $champs_aplat['categorie'],
 885                         'tags' => $champs_aplat['tags'],
 886                 ),
 887                 'paquet' => array(
 888                         'logo' => $champs_aplat['logo'],
 889                         'description' => $champs_aplat['description'],
 890                         'auteur' => $champs_aplat['auteur'],
 891                         'credit' => $champs_aplat['credit'],
 892                         'version' => $champs_aplat['version'],
 893                         'version_base' => $champs_aplat['version_base'],
 894                         'compatibilite_spip' => $champs_aplat['compatibilite_spip'],
 895                         'branches_spip' => $champs_aplat['branches_spip'],
 896                         'etat' => $champs_aplat['etat'],
 897                         'etatnum' => $champs_aplat['etatnum'],
 898                         'licence' => $champs_aplat['licence'],
 899                         'copyright' => $champs_aplat['copyright'],
 900                         'lien_doc' => $champs_aplat['lien_doc'],
 901                         'lien_demo' => $champs_aplat['lien_demo'],
 902                         'lien_dev' => $champs_aplat['lien_dev'],
 903                         'dependances' => $champs_aplat['dependances'],
 904                         'procure' => $champs_aplat['procure'],
 905                 )
 906         );
 907 }
 908
 909
 910 /**
 911  * Détermine la version max de chaque plugin, c'est à dire
 912  * la version maxi d'un des paquets qui lui est lié.
 913  *
 914  * @param array $plugins Liste d'identifiant de plugins
 915  **/
 916 function svp_corriger_vmax_plugins($plugins) {
 917         // tous les plugins encore lies a des depots (hors local)...
 918         // la vmax est a retablir...
 919         if ($plugins) {
 920                 $p = sql_allfetsel('DISTINCT(p.id_plugin)',
 921                         array('spip_plugins AS p', 'spip_paquets AS pa'),
 922                         array(sql_in('p.id_plugin', $plugins), 'p.id_plugin=pa.id_plugin', 'pa.id_depot>' . intval(0)));
 923                 $p = array_map('array_shift', $p);
 924
 925                 // pour les autres, on la fixe correctement
 926
 927                 // On insere, en encapsulant pour sqlite...
 928                 if (sql_preferer_transaction()) {
 929                         sql_demarrer_transaction();
 930                 }
 931
 932                 foreach ($p as $id_plugin) {
 933                         $vmax = '';
 934                         if ($pa = sql_allfetsel('version', 'spip_paquets', array('id_plugin=' . $id_plugin, 'id_depot>' . intval(0)))) {
 935                                 foreach ($pa as $v) {
 936                                         if (spip_version_compare($v['version'], $vmax, '>')) {
 937                                                 $vmax = $v['version'];
 938                                         }
 939                                 }
 940                         }
 941                         sql_updateq('spip_plugins', array('vmax' => $vmax), 'id_plugin=' . intval($id_plugin));
 942                 }
 943
 944                 if (sql_preferer_transaction()) {
 945                         sql_terminer_transaction();
 946                 }
 947         }
 948 }