4 * Traitement des dépots distants
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.
12 * @plugin SVP pour SPIP
14 * @package SPIP\SVP\Depots
17 if (!defined("_ECRIRE_INC_VERSION")) {
20 include_spip('inc/plugin');
21 include_spip('inc/svp_phraser');
25 * Ajout d'un dépot et de son contenu (paquets, plugins) dans la base de données
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
30 * @uses svp_phraser_depot()
31 * @uses svp_actualiser_paquets()
32 * @uses svp_base_supprimer_paquets_locaux()
34 * URL du fichier XML de description du dépot
35 * @param string $erreur
36 * Texte d'un éventuel message d'erreur
38 * true si le dépot est ajouté correctement, false sinon
40 function svp_ajouter_depot($url, &$erreur = '') {
41 include_spip('inc/distant');
43 // On considere que l'url a deja ete validee (correcte et nouveau depot)
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
49 $fichier_xml = copie_locale($url, 'modif');
51 $erreur = _T('svp:message_nok_xml_non_recupere', array('fichier' => $url));
56 $fichier_xml = _DIR_RACINE
. $fichier_xml;
58 // Lire les donnees d'un depot de paquets
59 $infos = svp_phraser_depot($fichier_xml);
61 $erreur = _T('svp:message_nok_xml_non_conforme', array('fichier' => $url));
66 $titre = filtrer_entites($infos['depot']['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),
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));
88 } elseif (!$id_depot = sql_insertq('spip_depots', $champs)) {
89 $erreur = _T('svp:message_nok_sql_insert_depot', array('objet' => "$titre ($url)"));
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));
100 $erreur = _T('svp:message_nok_xml_non_conforme', array('fichier' => $url));
102 $erreur = _T('svp:message_nok_aucun_paquet_ajoute', array('url' => $url));
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));
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);
122 * Suppression d'un dépot et de son contenu (paquets, plugins) dans la base de données
124 * Cette suppression entraîne des recalcul comme les versions maximales
125 * des plugins téléchargeables qui peuvent changer.
127 * @uses svp_actualiser_url_plugins()
128 * @uses svp_nettoyer_apres_suppression()
129 * @uses svp_base_supprimer_paquets_locaux()
132 * Identifiant du dépot
134 * false si le dépot n'est pas trouvé, true sinon
136 function svp_supprimer_depot($id) {
139 // Pas de depot a cet id ?
140 if (!$id_depot = sql_getfetsel('id_depot', 'spip_depots', 'id_depot=' . sql_quote($id))) {
144 // on calcule les versions max des plugins heberges par le depot
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'], '<'))
153 $vmax[$id_plugin] = $paquet['version'];
158 // On supprime les paquets heberges par le depot
159 sql_delete('spip_paquets', 'id_depot=' . sql_quote($id_depot));
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);
169 // Nettoyer les autres relations à ce dépot
170 svp_nettoyer_apres_suppression($id_depot, $vmax);
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);
180 // On supprime le depot lui-meme
181 sql_delete('spip_depots', 'id_depot=' . sql_quote($id_depot));
183 // on supprime les paquets locaux pour reactualisation
184 include_spip('inc/svp_depoter_local');
185 svp_base_supprimer_paquets_locaux();
192 * Nettoyer la base de données après la suppression d'un dépot
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
199 * @param int $id_depot
200 * Identifiant du dépot
202 * Tableau de la version maximale des plugins du dépot supprimé
203 * Tableau (id_plugin => version maximale)
207 function svp_nettoyer_apres_suppression($id_depot, $vmax) {
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);
214 // On peut donc supprimer tous ces liens *plugins-depots* du depot
215 sql_delete('spip_depots_plugins', 'id_depot=' . sql_quote($id_depot));
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 !!!
224 // On insere, en encapsulant pour sqlite...
225 if (sql_preferer_transaction()) {
226 sql_demarrer_transaction();
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']));
237 if (sql_preferer_transaction()) {
238 sql_terminer_transaction();
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);
248 // - L'intersection des deux tableaux renvoie les plugins a supprimer
249 $plugins_a_supprimer = array_diff($plugins_depot, $plugins_restants);
251 // On supprimer les plugins identifies
252 sql_delete('spip_plugins', sql_in('id_plugin', $plugins_a_supprimer));
259 * Actualisation des plugins d'un dépot déjà crée
261 * Actualise les informations uniquement si la signature du fichier
262 * XML de description du dépot a changé
264 * @uses svp_actualiser_maj_version()
265 * @uses svp_actualiser_paquets()
266 * @uses svp_phraser_depot()
268 * Identifiant du dépot
270 * false si erreur, true sinon
272 function svp_actualiser_depot($id) {
273 include_spip('inc/distant');
277 // pas de depot a cet id ?
278 if (!$depot = sql_fetsel('*', 'spip_depots', 'id_depot=' . sql_quote($id))) {
282 $fichier_xml = _DIR_RACINE
. copie_locale($depot['xml_paquets'], 'modif');
284 $sha = sha1_file($fichier_xml);
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' => '')));
294 // Le fichier a bien change il faut actualiser tout le depot
295 $infos = svp_phraser_depot($fichier_xml);
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);
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();
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
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
327 sql_updateq('spip_depots', $champs, 'id_depot=' . sql_quote($depot['id_depot']));
336 * Actualisation de la table des paquets pour le dépot choisi
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.
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()
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
364 * false si aucun dépot ou paquets, true sinon
366 function svp_actualiser_paquets($id_depot, $paquets, &$nb_paquets, &$nb_plugins, &$nb_autres) {
368 // Initialisation des compteurs
373 // Si aucun depot ou aucun paquet on renvoie une erreur
374 if ((!$id_depot) or (!is_array($paquets))) {
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));
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'];
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);
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);
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é
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'),
414 sql_in('pl.id_plugin', $anciens_plugins),
415 'pl.id_plugin=pa.id_plugin',
416 'pa.id_depot=' . sql_quote($id_depot)
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);
425 // supprimer les plugins orphelins
426 include_spip('inc/svp_depoter_local');
427 svp_supprimer_plugins_orphelins($anciens_plugins);
429 // corriger les vmax des plugins
430 svp_corriger_vmax_plugins($anciens_plugins);
432 // corriger les compats, branches aussi
433 svp_completer_plugins($anciens_plugins);
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]);
445 // tableaux d'actions
446 $insert_paquets = array();
447 $insert_plugins = array();
448 $insert_contribs = array();
449 $prefixes = array(); // prefixe => id_plugin
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) {
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'];
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);
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 // Le logo est normalement fourni dans les infos de zip
483 if (!empty($_infos['logo'])) {
484 $insert_paquet['logo'] = $depot['url_archives'] . '/' . $_infos['logo'];
486 elseif ($insert_paquet['logo']) {
487 // Sinon on construit l'url complete du logo
488 // Le logo est maintenant disponible a la meme adresse que le zip et porte le nom du zip.
489 // Son extension originale est conservee
490 $insert_paquet['logo'] = $depot['url_archives'] . '/'
491 . preg_replace(",\.zip$,i", "", $insert_paquet['nom_archive']) . '.'
492 . pathinfo($insert_paquet['logo'], PATHINFO_EXTENSION
);
495 // On loge l'absence de categorie ou une categorie erronee et on positionne la categorie
496 // par defaut "aucune"
497 // Provisoire tant que la DTD n'est pas en fonction
498 if (!$insert_plugin['categorie']) {
499 spip_log("Categorie absente dans le paquet issu de <" . $insert_paquet['src_archive'] .
500 "> du depot <" . $insert_paquet['id_depot'] . ">\n", 'svp_paquets.' . _LOG_INFO_IMPORTANTE
);
501 $insert_plugin['categorie'] = 'aucune';
503 $svp_categories = $GLOBALS['categories_plugin'];
504 if (!in_array($insert_plugin['categorie'], $svp_categories)) {
505 spip_log("Categorie k" . $insert_plugin['categorie'] . "l incorrecte dans le paquet issu de <" . $insert_paquet['src_archive'] .
506 "> du depot <" . $insert_paquet['id_depot'] . ">\n", 'svp_paquets.' . _LOG_INFO_IMPORTANTE
);
507 $insert_plugin['categorie'] = 'aucune';
511 $paquet_plugin = false;
513 // On teste l'existence du paquet dans la base avec les champs
514 // id_depot, nom_archive et src_archive pour être sur de l'unicité.
515 // - si le paquet n'existe pas, on le crée,
516 // - sinon (et ça ne devrait pas arriver), on ne fait qu'un update
517 if (!$paquet = sql_fetsel('*', 'spip_paquets', array(
518 'id_depot=' . sql_quote($insert_paquet['id_depot']),
519 'nom_archive=' . sql_quote($insert_paquet['nom_archive']),
520 'src_archive=' . sql_quote($insert_paquet['src_archive'])
523 // Le paquet n'existe pas encore en base de donnees
524 // ------------------------------------------------
526 // On positionne la date de creation a celle du dernier commit ce qui est bien le cas
527 $insert_paquet['date_crea'] = $insert_paquet['date_modif'];
529 // Les collisions ne sont possibles que si on ajoute un nouveau paquet
532 if ($paquet_plugin) {
533 // On est en presence d'un PLUGIN
534 // ------------------------------
535 // On evite les doublons de paquet
536 // Pour determiner un doublon on verifie actuellement :
538 // - la version du paquet et de la base
541 't1.id_plugin=t2.id_plugin',
542 't1.version=' . sql_quote($insert_paquet['version']),
543 't1.version_base=' . sql_quote($insert_paquet['version_base']),
544 't1.etatnum=' . sql_quote($insert_paquet['etatnum']),
545 't1.id_depot>' . intval(0),
546 't2.prefixe=' . sql_quote($insert_plugin['prefixe'])
548 if (!$id_paquet = sql_getfetsel('t1.id_paquet', 'spip_paquets AS t1, spip_plugins AS t2', $where)) {
549 // On traite d'abord le plugin du paquet pour recuperer l'id_plugin
550 // On rajoute le plugin dans la table spip_plugins si celui-ci n'y est pas encore ou on recupere
551 // l'id si il existe deja et on le met a jour si la version du paquet est plus elevee
553 $plugin = sql_fetsel('id_plugin, vmax', 'spip_plugins',
554 array('prefixe=' . sql_quote($insert_plugin['prefixe'])));
555 if (!$plugin and !array_key_exists($insert_plugin['prefixe'], $insert_plugins)) {
556 $insert_plugins[$insert_plugin['prefixe']] = array_merge($insert_plugin,
557 array('vmax' => $insert_paquet['version']));
560 $id_plugin = $plugin['id_plugin'];
561 $prefixes[$insert_plugin['prefixe']] = $id_plugin;
563 if (array_key_exists($insert_plugin['prefixe'], $insert_plugins)
564 and (spip_version_compare($insert_plugins[$insert_plugin['prefixe']]['vmax'], $insert_paquet['version'],
567 // attribuer au plugin le nom et le slogan du paquet le plus à jour
568 $insert_plugins[$insert_plugin['prefixe']]['nom'] = $insert_plugin['nom'];
569 $insert_plugins[$insert_plugin['prefixe']]['slogan'] = $insert_plugin['slogan'];
570 $insert_plugins[$insert_plugin['prefixe']]['vmax'] = $insert_paquet['version'];
574 // On traite maintenant le paquet connaissant l'id du plugin
575 // temporaire qui sera supprime lors de la connaissance de l'id_paquet
576 $insert_paquet['prefixe'] = $insert_plugin['prefixe'];
577 $insert_paquets[] = $insert_paquet;
582 // On est en presence d'une CONTRIBUTION NON PLUGIN
583 // ------------------------------------------------
585 'id_depot=' . sql_quote($insert_paquet['id_depot']),
586 'nom_archive=' . sql_quote($insert_paquet['nom_archive'])
588 if (!$id_paquet = sql_getfetsel('id_paquet', 'spip_paquets', $where)) {
589 // Ce n'est pas un plugin, donc id_plugin=0 et toutes les infos plugin sont nulles
590 $insert_paquet['id_plugin'] = 0;
591 $insert_contribs[] = $insert_paquet;
596 // On loge le paquet ayant ete refuse dans un fichier a part afin de les verifier
599 spip_log("Collision avec le paquet <" . $insert_paquet['nom_archive'] .
600 " / " . $insert_paquet['src_archive'] . "> du depot <" . $insert_paquet['id_depot'] . ">\n",
601 'svp_paquets.' . _LOG_INFO_IMPORTANTE
);
604 // Le paquet existe deja en base de donnees
605 // ----------------------------------------
607 // On ne devrait plus arriver ICI...
609 spip_log('!!!!!! Passage dans code obsolete (svp/svp_depoter_distant)', 'depoter');
611 // on effectue les traitements en attente
612 // pour que les updates soient corrects
613 svp_inserer_multi($insert_plugins, $insert_paquets, $insert_contribs, $prefixes);
616 // On met a jour le paquet en premier lieu qu'il soit un plugin ou une contribution
617 sql_updateq('spip_paquets', $insert_paquet,
618 'id_paquet=' . sql_quote($paquet['id_paquet']));
623 // on effectue les traitements en attente
624 // pour que les updates soient corrects
625 svp_inserer_multi($insert_plugins, $insert_paquets, $insert_contribs, $prefixes);
627 // On rajoute le plugin comme heberge par le depot si celui-ci n'est pas encore enregistre comme tel
628 $ids = sql_allfetsel('p.id_plugin',
629 array('spip_plugins AS p', 'spip_depots_plugins AS dp'),
630 array('p.id_plugin=dp.id_plugin', 'dp.id_depot=' . sql_quote($id_depot)));
631 $ids = array_map('array_shift', $ids);
633 // inserer les liens avec le depots
634 $insert_dp = array();
635 $news_id = array_diff(array_values($prefixes), $ids);
636 foreach ($news_id as $id) {
637 $insert_dp[] = array('id_depot' => $id_depot, 'id_plugin' => $id);
640 sql_insertq_multi('spip_depots_plugins', $insert_dp);
643 // on recalcul les vmax des plugins de ce depot.
644 svp_corriger_vmax_plugins(array_values($prefixes));
646 // On compile maintenant certaines informations des paquets mis a jour dans les plugins
647 // (date de creation, date de modif, version spip...)
648 svp_completer_plugins_depot($id_depot);
650 // Si on est pas en mode runtime, on utilise surement l'espace public pour afficher les plugins.
651 // Il faut donc s'assurer que les urls suivent bien la mise à jour
652 // - on supprime toutes les urls plugin
653 // - on les regenere pour la liste des plugins mise a jour
654 if (!_SVP_MODE_RUNTIME
) {
655 svp_actualiser_url_plugins();
658 // Calcul des compteurs de paquets, plugins et contributions
659 $nb_paquets = sql_countsel('spip_paquets', 'id_depot=' . sql_quote($id_depot));
660 $nb_plugins = sql_countsel('spip_depots_plugins', 'id_depot=' . sql_quote($id_depot));
661 $nb_autres = sql_countsel('spip_paquets', array('id_depot=' . sql_quote($id_depot), 'id_plugin=0'));
668 * Insertion en masse de plugins ou de paquets.
670 * Les paquets peuvent de pas avoir d'info "prefixe" (à transformer en id_plugin)
671 * lorsqu'ils ne proviennent pas de plugin (squelettes...)
673 * @param array $insert_plugins
674 * Tableau de description de plugins.
675 * Une description est un tableau de couples (colonne sql => valeur)
676 * pour l'insertion en base de données.
677 * @param array $insert_paquets
678 * Tableau de description de paquets.
679 * Une description est un tableau de couples (colonne sql => valeur)
680 * pour l'insertion en base de données.
681 * @param array $insert_contribs
682 * Tableau de description de paquets (contributions non plugins).
683 * Une description est un tableau de couples (colonne sql => valeur)
684 * pour l'insertion en base de données.
685 * @param array $prefixes
686 * Couples de relation (préfixe de plugin => identifiant de plugin) connues,
687 * pour limiter les accès SQL.
690 function svp_inserer_multi(&$insert_plugins, &$insert_paquets, &$insert_contribs, &$prefixes) {
692 if (count($insert_plugins)) {
693 sql_insertq_multi('spip_plugins', $insert_plugins);
694 $insert_plugins = array();
697 if (count($insert_paquets)) {
699 // on cherche tous les id_plugin/prefixe que l'on a à récuperer
700 // en une seule requete
701 $prefixes_manquants = array();
702 foreach ($insert_paquets as $p) {
703 // on ne connait que le prefixe
704 if (isset($p['prefixe']) and !isset($prefixes[$p['prefixe']])) {
705 $prefixes_manquants[] = $p['prefixe'];
709 // recuperer les nouveaux prefixes :
710 $new = sql_allfetsel(array('prefixe', 'id_plugin'), 'spip_plugins', sql_in('prefixe', $prefixes_manquants));
711 foreach ($new as $p) {
712 $prefixes[$p['prefixe']] = $p['id_plugin'];
715 // inserer les id_plugin dans les paquets a inserer
716 // inserer le prefixe dans le paquet (pour raccourcis de jointures)
717 foreach ($insert_paquets as $c => $p) {
718 if (isset($p['prefixe'])) {
719 $insert_paquets[$c]['id_plugin'] = $prefixes[$insert_paquets[$c]['prefixe']];
721 $insert_paquets[$c]['prefixe'] = array_search($p['id_plugin'], $prefixes);
726 sql_insertq_multi('spip_paquets', $insert_paquets);
727 $insert_paquets = array();
730 // les contribs n'ont pas le même nombre de champs dans les insertions
731 // et n'ont pas de plugin rattachés.
732 if (count($insert_contribs)) {
733 sql_insertq_multi('spip_paquets', $insert_contribs);
734 $insert_contribs = array();
739 * Complète les informations des plugins contenus dans un depot
740 * en compilant certaines informations (compatibilités, dates, branches)
742 * @uses svp_completer_plugins()
743 * @param int $id_depot
744 * Identifiant du depot à actualiser
746 function svp_completer_plugins_depot($id_depot) {
747 // On limite la revue des paquets a ceux des plugins heberges par le depot en cours d'actualisation
748 $ids_plugins = sql_allfetsel('id_plugin', 'spip_depots_plugins', array('id_depot=' . sql_quote($id_depot)));
749 $ids_plugins = array_map('reset', $ids_plugins);
751 svp_completer_plugins($ids_plugins);
756 * Complète les informations des plugins, d'une liste de plugins donnés,
757 * en compilant certaines informations (compatibilités, dates, branches)
759 * @uses compiler_branches_spip()
760 * @param array $ids_plugin
761 * Liste d'identifiants de plugins
763 * false si rien à faire, true sinon
765 function svp_completer_plugins($ids_plugin) {
771 include_spip('inc/svp_outiller');
773 // -- on recupere tous les paquets associes aux plugins indiques et on compile les infos
774 if ($resultats = sql_allfetsel('id_plugin, compatibilite_spip, date_crea, date_modif', 'spip_paquets',
775 array(sql_in('id_plugin', $ids_plugin), 'id_depot>' . intval(0)), '', 'id_plugin')
778 $plugin_en_cours = 0;
780 $complements = array('compatibilite_spip' => '', 'branches_spip' => '', 'date_crea' => 0, 'date_modif' => 0);
782 foreach ($resultats as $paquet) {
783 // On finalise le plugin en cours et on passe au suivant
784 if ($plugin_en_cours != $paquet['id_plugin']) {
785 // On met a jour le plugin en cours
786 if ($plugin_en_cours) {
787 // On deduit maintenant les branches de la compatibilite globale
788 $complements['branches_spip'] = compiler_branches_spip($complements['compatibilite_spip']);
789 $inserts[$plugin_en_cours] = $complements;
791 // On passe au plugin suivant
792 $plugin_en_cours = $paquet['id_plugin'];
793 $complements = array('compatibilite_spip' => '', 'branches_spip' => '', 'date_crea' => 0, 'date_modif' => 0);
796 // On compile les compléments du plugin avec le paquet courant sauf les branches
797 // qui sont deduites en fin de compilation de la compatibilite
798 if ($paquet['date_modif'] > $complements['date_modif']) {
799 $complements['date_modif'] = $paquet['date_modif'];
801 if (($complements['date_crea'] === 0)
802 or ($paquet['date_crea'] < $complements['date_crea'])
804 $complements['date_crea'] = $paquet['date_crea'];
806 if ($paquet['compatibilite_spip']) {
807 if (!$complements['compatibilite_spip']) {
808 $complements['compatibilite_spip'] = $paquet['compatibilite_spip'];
810 $complements['compatibilite_spip'] = fusionner_intervalles($paquet['compatibilite_spip'],
811 $complements['compatibilite_spip']);
815 // On finalise le dernier plugin en cours
816 $complements['branches_spip'] = compiler_branches_spip($complements['compatibilite_spip']);
817 $inserts[$plugin_en_cours] = $complements;
819 // On insere, en encapsulant pour sqlite...
820 if (sql_preferer_transaction()) {
821 sql_demarrer_transaction();
824 foreach ($inserts as $id_plugin => $complements) {
825 sql_updateq('spip_plugins', $complements, 'id_plugin=' . intval($id_plugin));
828 if (sql_preferer_transaction()) {
829 sql_terminer_transaction();
839 * Recrée toutes les URLs propres de plugin
841 * Supprime toutes les urls de plugin de la table spip_urls puis les régénère.
844 * Nombre d'URLs de plugin régénérées
846 function svp_actualiser_url_plugins() {
849 // On supprime toutes les urls de plugin
850 sql_delete('spip_urls', array('type=\'plugin\''));
852 // On recupere les ids des plugins et on regenere les urls
853 if ($ids_plugin = sql_allfetsel('id_plugin', 'spip_plugins')) {
854 $ids_plugin = array_map('reset', $ids_plugin);
855 $nb_plugins = count($ids_plugin);
857 foreach ($ids_plugin as $_id) {
858 generer_url_entite($_id, 'plugin', '', '', true);
866 * Éclate une description de paquet issu du XML du dépot en deux parties,
867 * une pour le plugin, l'autre pour le paquet
869 * Sépare en deux une description de champs désignant un paquet, en extrayant :
870 * - la partie plugin, soit ce qui peut être propre à plusieurs paquets.
871 * On trouve dedans le prefixe, nom, slogan, catégorie, tags
872 * - la partie paquet, soit ce qui est propre à ce conteneur là. On trouve
873 * dedans entre autres la description, la version, la compatibilité
874 * à SPIP, les dépendances, etc...
876 * @param array $champs_aplat
877 * Couples (clé => valeur) d'un paquet issu de l'analyse XML du dépot
879 * Tableau de 2 index :
880 * - Index 'plugin' : couples (clé=>valeur) relatives au plugin
881 * - Index 'paquet' : couples (clé=>valeur) spécifiques au paquet
883 function eclater_plugin_paquet($champs_aplat) {
886 'prefixe' => $champs_aplat['prefixe'],
887 'nom' => $champs_aplat['nom'],
888 'slogan' => $champs_aplat['slogan'],
889 'categorie' => $champs_aplat['categorie'],
890 'tags' => $champs_aplat['tags'],
893 'logo' => $champs_aplat['logo'],
894 'description' => $champs_aplat['description'],
895 'auteur' => $champs_aplat['auteur'],
896 'credit' => $champs_aplat['credit'],
897 'version' => $champs_aplat['version'],
898 'version_base' => $champs_aplat['version_base'],
899 'compatibilite_spip' => $champs_aplat['compatibilite_spip'],
900 'branches_spip' => $champs_aplat['branches_spip'],
901 'etat' => $champs_aplat['etat'],
902 'etatnum' => $champs_aplat['etatnum'],
903 'licence' => $champs_aplat['licence'],
904 'copyright' => $champs_aplat['copyright'],
905 'lien_doc' => $champs_aplat['lien_doc'],
906 'lien_demo' => $champs_aplat['lien_demo'],
907 'lien_dev' => $champs_aplat['lien_dev'],
908 'dependances' => $champs_aplat['dependances'],
909 'procure' => $champs_aplat['procure'],
916 * Détermine la version max de chaque plugin, c'est à dire
917 * la version maxi d'un des paquets qui lui est lié.
919 * @param array $plugins Liste d'identifiant de plugins
921 function svp_corriger_vmax_plugins($plugins) {
922 // tous les plugins encore lies a des depots (hors local)...
923 // la vmax est a retablir...
925 $p = sql_allfetsel('DISTINCT(p.id_plugin)',
926 array('spip_plugins AS p', 'spip_paquets AS pa'),
927 array(sql_in('p.id_plugin', $plugins), 'p.id_plugin=pa.id_plugin', 'pa.id_depot>' . intval(0)));
928 $p = array_map('array_shift', $p);
930 // pour les autres, on la fixe correctement
932 // On insere, en encapsulant pour sqlite...
933 if (sql_preferer_transaction()) {
934 sql_demarrer_transaction();
937 foreach ($p as $id_plugin) {
939 if ($pa = sql_allfetsel('version', 'spip_paquets', array('id_plugin=' . $id_plugin, 'id_depot>' . intval(0)))) {
940 foreach ($pa as $v) {
941 if (spip_version_compare($v['version'], $vmax, '>')) {
942 $vmax = $v['version'];
946 sql_updateq('spip_plugins', array('vmax' => $vmax), 'id_plugin=' . intval($id_plugin));
949 if (sql_preferer_transaction()) {
950 sql_terminer_transaction();