source: spip-zone/_plugins_/svp/inc/svp_depoter.php @ 51758

Last change on this file since 51758 was 51758, checked in by eric@…, 8 years ago

Passer par une copie locale du fichier xml avant de caculer un sha1 pour éviter de requérir une configuration php spécifique.

  • Property svn:eol-style set to native
File size: 24.5 KB
Line 
1<?php
2
3if (!defined("_ECRIRE_INC_VERSION")) return;
4include_spip('inc/plugin');
5include_spip('inc/svp_phraser');
6
7// ----------------------- Traitements des depots ---------------------------------
8
9/**
10 * Ajout du depot et de ses extensions dans la base de donnees
11 *
12 * @param string $url
13 * @return boolean
14 */
15
16// $url         => url du fichier xml de description du depot
17// $erreur      => message d'erreur a afficher
18function svp_ajouter_depot($url, &$erreur='') {
19        include_spip('inc/distant');
20
21        // On considere que l'url a deja ete validee (correcte et nouveau depot)
22        $url = trim($url);
23
24        // Lire les donnees d'un depot de paquets
25        $infos = svp_phraser_depot($url);
26        if (!$infos) {
27                $erreur = _T('svp:message_nok_xml_non_conforme', array('fichier' => $url));
28                return false;
29        }
30       
31        // Ajout du depot dans la table spip_depots. Les compteurs de paquets et de plugins
32        // sont mis a jour apres le traitement des paquets
33        $fichier_xml = _DIR_RACINE . copie_locale($url, 'force');
34        $champs = array('titre' => filtrer_entites($infos['depot']['titre']), 
35                                        'descriptif' => filtrer_entites($infos['depot']['descriptif']),
36                                        'type' => $infos['depot']['type'],
37                                        'url_serveur' => $infos['depot']['url_serveur'],
38                                        'url_brouteur' => $infos['depot']['url_brouteur'],
39                                        'url_archives' => $infos['depot']['url_archives'],
40                                        'xml_paquets'=> $url,
41                                        'sha_paquets'=> sha1_file($fichier_xml),
42                                        'nbr_paquets' => 0,
43                                        'nbr_plugins' => 0,
44                                        'nbr_autres' => 0);
45        if (!$id_depot = sql_insertq('spip_depots', $champs)) {
46                $erreur = _T('svp:message_nok_sql_insert_depot', array('objet' => $titre));
47                return false;
48        }
49               
50        // Ajout des paquets dans spip_paquets et actualisation des plugins dans spip_plugins
51        $ok = svp_actualiser_paquets($id_depot, $infos['paquets'], $nb_paquets, $nb_plugins, $nb_autres);
52        if (!$ok OR ($nb_paquets == 0)) {
53                // Si une erreur s'est produite, on supprime le depot deja insere
54                sql_delete('spip_depots','id_depot='.sql_quote($id_depot));
55                if (!ok)
56                        $erreur = _T('svp:message_nok_xml_non_conforme', array('fichier' => $url));
57                else
58                        $erreur = _T('svp:message_nok_aucun_paquet_ajoute', array('url' => $url));
59                return false;
60        }
61
62        // On met à jour le nombre de paquets et de plugins du depot maintenant !
63        sql_updateq('spip_depots',
64                                array('nbr_paquets'=> $nb_paquets, 'nbr_plugins'=> $nb_plugins, 'nbr_autres'=> $nb_autres),
65                                'id_depot=' . sql_quote($id_depot));
66       
67        return true;
68}
69
70/**
71 * Suppression du depot et de ses extensions dans la base de donnees
72 *
73 * @param int $id
74 * @return boolean
75 */
76
77// $id  => id_depot de l'objet depot dans la table spip_depots
78function svp_supprimer_depot($id){
79        $id = intval($id);
80       
81        // Pas de depot a cet id ?
82        if (!$id_depot = sql_getfetsel('id_depot', 'spip_depots', 'id_depot='. sql_quote($id)) ){
83                return false;
84        }
85
86        // on calcule les versions max des plugins heberges par le depot
87        $vmax =array();
88        if ($resultats = sql_select('id_plugin, version', 'spip_paquets', 'id_depot='. sql_quote($id))) {
89                while ($paquet = sql_fetch($resultats)) {
90                        $id_plugin = $paquet['id_plugin'];
91                        if (!isset($vmax[$id_plugin])
92                        OR (spip_version_compare($vmax[$id_plugin], $paquet['version'], '<'))) 
93                                $vmax[$id_plugin] = $paquet['version'];
94                }
95        }
96
97        // On supprime les paquets heberges par le depot
98        sql_delete('spip_paquets','id_depot='.sql_quote($id_depot));
99
100        // On supprime ensuite :
101        // - les liens des plugins avec le depot (table spip_depots_plugins)
102        // - les plugins dont aucun paquet n'est encore heberge par un depot restant (table spip_plugins)
103        // - et on met a zero la vmax des plugins ayant vu leur paquet vmax supprime
104        svp_nettoyer_apres_suppression($id_depot, $vmax);
105
106        // On supprime le depot lui-meme
107        sql_delete('spip_depots','id_depot='.sql_quote($id_depot));
108        return true;
109}
110
111
112function svp_nettoyer_apres_suppression($id_depot, $vmax) {
113
114        // On rapatrie la liste des plugins du depot qui servira apres qu'on ait supprime les liens
115        // de la table spip_depots_plugins
116        $liens = sql_allfetsel('id_plugin', 'spip_depots_plugins', 'id_depot='.sql_quote($id_depot));
117        $plugins_depot = array_map('reset', $liens);
118
119        // On peut donc supprimer tous ces liens *plugins-depots* du depot
120        sql_delete('spip_depots_plugins', 'id_depot='.sql_quote($id_depot));
121
122        // On verifie pour chaque plugin concerne par la disparition de paquets si c'est la version
123        // la plus elevee qui a ete supprimee.
124        // Si oui, on positionne le vmax a 0, ce qui permettra de remettre a jour le plugin systematiquement
125        // a la prochaine actualisation.
126        // Cette operation est necessaire car on n'impose pas que les informations du plugin soient identiques
127        // pour chaque paquet !!!
128        if ($resultats = sql_select('id_plugin, vmax', 'spip_plugins', sql_in('id_plugin', $plugins_depot))) {
129                while ($plugin = sql_fetch($resultats)) {
130                        if (spip_version_compare($plugin['vmax'], $vmax[$plugin['id_plugin']], '='))
131                                sql_updateq('spip_plugins',     array('vmax' => '0.0'), 'id_plugin=' . sql_quote($plugin['id_plugin']));
132                }
133        }
134
135        // Maintenant on calcule la liste des plugins du depot qui ne sont pas heberges
136        // par un autre depot => donc a supprimer
137        // - Liste de tous les plugins encore lies a un autre depot
138        $liens = sql_allfetsel('id_plugin', 'spip_depots_plugins');
139        $autres_plugins = array_map('reset', $liens);
140        // - L'intersection des deux tableaux renvoie les plugins a supprimer   
141        $plugins_a_supprimer = array_diff($plugins_depot, $autres_plugins);
142
143        // On supprimer les plugins identifies
144        sql_delete('spip_plugins', sql_in('id_plugin', $plugins_a_supprimer)); 
145       
146        return true;
147}
148
149
150/**
151 * Actualisation des plugins d'un depot deja cree.
152 * @param int $id
153 * @return boolean
154 */
155
156// $id  => id_depot de l'objet depot dans la table spip_depots
157function svp_actualiser_depot($id){
158        include_spip('inc/distant');
159       
160        $id = intval($id);
161       
162        // pas de depot a cet id ?
163        if (!$depot = sql_fetsel('*', 'spip_depots', 'id_depot='. sql_quote($id)) ){
164                return false;
165        }
166
167        $fichier_xml = _DIR_RACINE . copie_locale($depot['xml_paquets'], 'force');
168        $sha = sha1_file($fichier_xml);
169        if ($depot['sha_paquets'] == $sha) {
170                // Le fichier n'a pas change (meme sha1) alors on ne fait qu'actualiser la date
171                // de mise a jour du depot en mettant a jour *inutilement* le sha1
172                spip_log('Aucune modification du fichier XML, actualisation non declenchee - id_depot = ' . $depot['id_depot'], 'svp_actions.' . _LOG_INFO);
173                sql_replace('spip_depots', array_diff_key($depot, array('maj' => '')));
174        }
175        else {
176                // Le fichier a bien change il faut actualiser tout le depot
177                $infos = svp_phraser_depot($depot['xml_paquets']);
178                if (!$infos)
179                        return false;
180       
181                // On actualise les paquets dans spip_paquets uniquement car le depot n'est
182                // mis a jour que par le formulaire d'edition d'un depot.
183                // Lors de la mise a jour des paquets, les plugins aussi sont actualises
184                $ok = svp_actualiser_paquets($depot['id_depot'], $infos['paquets'],
185                                                                        $nb_paquets, $nb_plugins, $nb_autres);
186                if ($ok) {
187                        // On met à jour le nombre de paquets et de plugins du depot ainsi que le nouveau sha1
188                        // ce qui aura pour effet d'actualiser la date de mise a jour
189                        sql_updateq('spip_depots', 
190                                                array('nbr_paquets'=> $nb_paquets, 'nbr_plugins'=> $nb_plugins, 'nbr_autres'=> $nb_autres, 'sha_paquets'=> $sha),
191                                                'id_depot=' . sql_quote($depot['id_depot']));
192                }
193        }
194       
195        return true;
196}
197
198
199/**
200 * Actualisation de la table des paquets pour le depot choisi
201 *
202 * @param int $id_depot
203 * @param array $paquets
204 * @param int &$nb_paquets
205 * @param int &$nb_plugins
206 * @param int &$nb_autres
207 * @return boolean
208 */
209
210// $id_depot    => Id du depot dans la table spip_depots
211// $paquets             => Tableau des paquets extrait du fichier xml
212//                                 L'index est le nom de l'archive (xxxx.zip) et le contenu est
213//                                 un tableau à deux entrées :
214//                                      - ['plugin'] le tableau des infos du plugin
215//                                      - ['file'] le nom de l'archive .zip
216// &$nb_paquets => Nombre de paquets reellement inseres dans la base renvoye a l'appelant
217// &$nb_plugins => Nombre de plugins parmi les paquets inseres
218// &$nb_autres  => Nombre de contributions non issues de plugin parmi les paquets inseres
219function svp_actualiser_paquets($id_depot, $paquets, &$nb_paquets, &$nb_plugins, &$nb_autres) {
220
221        // Initialisation des compteurs
222        $nb_paquets = 0;
223        $nb_plugins = 0;
224        $nb_autres = 0;
225       
226        // Si aucun depot ou aucun paquet on renvoie une erreur
227        if ((!$id_depot) OR (!is_array($paquets)))
228                return false;
229               
230        // On initialise l'url de base des logos du depot et son type afin de calculer l'url complete de chaque logo
231        $select = array('url_brouteur', 'url_archives', 'type');
232        $depot = sql_fetsel($select, 'spip_depots', 'id_depot=' . sql_quote($id_depot));
233       
234        // Initialisation du tableau des id de paquets crees ou mis a jour pour le depot concerne
235        $ids_a_supprimer = array();
236        $versions_a_supprimer = array();
237        $ids = sql_allfetsel('id_paquet, id_plugin, version', 'spip_paquets', array('id_depot='. sql_quote($id_depot)));
238        foreach ($ids as $_ids) {
239                $ids_a_supprimer[$_ids['id_paquet']] = $_ids['id_plugin'];
240                $versions_a_supprimer[$_ids['id_paquet']] = $_ids['version'];
241        }
242
243        // On met a jour ou on cree chaque paquet a partir du contenu du fichier xml
244        // On ne fait pas cas de la compatibilite avec la version de SPIP installee
245        // car l'operation doit permettre de collecter tous les paquets
246        foreach ($paquets as $_archive => $_infos) {
247                $insert_paquet = array();
248                // On initialise les informations specifiques au paquet :
249                // l'id du depot et les infos de l'archive
250                $insert_paquet['id_depot'] = $id_depot;
251                $insert_paquet['nom_archive'] = $_archive;
252                $insert_paquet['nbo_archive'] = $_infos['size'];
253                $insert_paquet['maj_archive'] = date('Y-m-d H:i:s', $_infos['date']);
254                $insert_paquet['src_archive'] = $_infos['source'];
255                $insert_paquet['date_modif'] = $_infos['last_commit'];
256                // On serialise le tableau des traductions par module
257                $insert_paquet['traductions'] = serialize($_infos['traductions']);
258
259                // On verifie si le paquet est celui d'un plugin ou pas
260                // -- Les traitements du XML dependent de la DTD utilisee
261                // Formatage des informations extraites du plugin pour insertion dans la base SVP
262                $formater = charger_fonction('preparer_sql_' . $_infos['dtd'], 'plugins');
263                if ($champs_aplat = $formater($_infos['plugin'])) {
264                        // Eclater les champs recuperes en deux sous tableaux, un par table (plugin, paquet)
265                        $champs = eclater_plugin_paquet($champs_aplat);
266
267                        $paquet_plugin = true;
268                        // On complete les informations du paquet et du plugin
269                        $insert_paquet = array_merge($insert_paquet, $champs['paquet']);
270                        $insert_plugin = $champs['plugin'];
271                        // On construit l'url complete du logo
272                        // Le logo est maintenant disponible a la meme adresse que le zip et porte le nom du zip.
273                        // Son extension originale est conservee
274                        if ($insert_paquet['logo'])
275                                $insert_paquet['logo'] = $depot['url_archives'] . '/'
276                                                                           . basename($insert_paquet['nom_archive'], '.zip') . '.'
277                                                                           . pathinfo($insert_paquet['logo'], PATHINFO_EXTENSION);
278
279                        // On loge l'absence de categorie ou une categorie erronee et on positionne la categorie
280                        // par defaut "aucune"
281                        // Provisoire tant que la DTD n'est pas en fonction
282                        if (!$insert_plugin['categorie']) {
283                                spip_log("Categorie absente dans le paquet issu de <". $insert_paquet['src_archive'] . 
284                                                "> du depot <" . $insert_paquet['id_depot'] . ">\n", 'svp_paquets.' . _LOG_INFO_IMPORTANTE);
285                                $insert_plugin['categorie'] = 'aucune';
286                        }
287                        else {
288                                $svp_categories = $GLOBALS['categories_plugin'];
289                                if (!in_array($insert_plugin['categorie'], $svp_categories)) {
290                                        spip_log("Categorie &#107;" . $insert_plugin['categorie'] . "&#108; incorrecte dans le paquet issu de <". $insert_paquet['src_archive'] . 
291                                                        "> du depot <" . $insert_paquet['id_depot'] . ">\n", 'svp_paquets.' . _LOG_INFO_IMPORTANTE);
292                                        $insert_plugin['categorie'] = 'aucune';
293                                }
294                        }
295                }
296                else {
297                        $paquet_plugin = false;
298                }
299                // On teste l'existence du paquet dans la base avec les champs id_depot, nom_archive et src_archive
300                // pour etre sur de l'unicite.
301                // - si le paquet existe on ne fait qu'un update
302                // - sinon on insere le paquet
303                if (!$paquet = sql_fetsel('*', 'spip_paquets', array('id_depot='. sql_quote($insert_paquet['id_depot']),
304                                                                                                                        'nom_archive='. sql_quote($insert_paquet['nom_archive']),
305                                                                                                                        'src_archive='. sql_quote($insert_paquet['src_archive'])))) {
306                        // Le paquet n'existe pas encore en base de donnees
307                        // ------------------------------------------------
308                       
309                        // On positionne la date de creation a celle du dernier commit ce qui est bien le cas
310                        $insert_paquet['date_crea'] = $insert_paquet['date_modif'];
311
312                        // Les collisions ne sont possibles que si on ajoute un nouveau paquet
313                        $collision = false;
314
315                        if ($paquet_plugin) {
316                                // On est en presence d'un PLUGIN
317                                // ------------------------------
318                                // On evite les doublons de paquet
319                                // Pour determiner un doublon on verifie actuellement :
320                                // - le prefixe
321                                // - la version du paquet et de la base
322                                // - l'etat
323                                $where = array('t1.id_plugin=t2.id_plugin',
324                                                't1.version=' . sql_quote($insert_paquet['version']),
325                                                't1.version_base=' . sql_quote($insert_paquet['version_base']),
326                                                't1.etatnum=' . sql_quote($insert_paquet['etatnum']),
327                                                't2.prefixe=' . sql_quote($insert_plugin['prefixe']));
328                                if (!$id_paquet = sql_getfetsel('t1.id_paquet', 'spip_paquets AS t1, spip_plugins AS t2', $where)) {
329                                        // On traite d'abord le plugin du paquet pour recuperer l'id_plugin
330                                        // On rajoute le plugin dans la table spip_plugins si celui-ci n'y est pas encore ou on recupere
331                                        // l'id si il existe deja et on le met a jour si la version du paquet est plus elevee
332                                        if (!$plugin = sql_fetsel('id_plugin, vmax', 'spip_plugins',
333                                                array('prefixe=' . sql_quote($insert_plugin['prefixe'])))) {
334                                                if (!$id_plugin = sql_insertq('spip_plugins', 
335                                                                                        array_merge($insert_plugin, array('vmax' => $insert_paquet['version']))))
336                                                        spip_log("insertion dans la base du plugin de prefixe " . $insert_plugin['prefixe'] . " archive (". $insert_paquet['nom_archive'] . ") a echoue\n", 'svp_paquets.' . _LOG_ERREUR);
337                                        }
338                                        else {
339                                                $id_plugin = $plugin['id_plugin'];
340                                                if (spip_version_compare($plugin['vmax'], $insert_paquet['version'], '<='))
341                                                        sql_updateq('spip_plugins',
342                                                                                array_merge($insert_plugin, array('vmax' => $insert_paquet['version'])),
343                                                                                'id_plugin=' . sql_quote($id_plugin));
344                                        }
345       
346                                        // On traite maintenant le paquet connaissant l'id du plugin
347                                        if ($id_plugin) {
348                                                $insert_paquet['id_plugin'] = $id_plugin;
349                                                if (!$id_paquet = sql_insertq('spip_paquets', $insert_paquet))
350                                                        spip_log("insertion dans la base du paquet provenant de l'archive " . $insert_paquet['nom_archive'] . " a echoue (prefixe : " . $insert_plugin['prefixe'] . ")\n", 'svp_paquets.' . _LOG_ERREUR);
351                                                else {
352                                                        // On rajoute le plugin comme heberge par le depot si celui-ci n'est pas encore
353                                                        // enregistre comme tel
354                                                        if (!sql_countsel('spip_depots_plugins',
355                                                                array('id_plugin=' . sql_quote($id_plugin),
356                                                                        'id_depot=' . sql_quote($id_depot)))) {
357                                                                sql_insertq('spip_depots_plugins', array('id_depot' => $id_depot, 'id_plugin' => $id_plugin));
358                                                        }
359                                                }
360                                        }
361                                }
362                                else
363                                        $collision = true;
364                        }
365                        else {
366                                // On est en presence d'une CONTRIBUTION NON PLUGIN
367                                // ------------------------------------------------
368                                $where = array(
369                                                't1.id_depot=' . sql_quote($insert_paquet['id_depot']),
370                                                't1.nom_archive=' . sql_quote($insert_paquet['nom_archive']));
371                                if (!$id_paquet = sql_getfetsel('t1.id_paquet', 'spip_paquets AS t1', $where)) {
372                                        // Ce n'est pas un plugin, donc id_plugin=0 et toutes les infos plugin sont nulles
373                                        $insert_paquet['id_plugin'] = 0;
374                                        if (!$id_paquet = sql_insertq('spip_paquets', $insert_paquet))
375                                                spip_log("insertion dans la base du paquet provenant de l'archive " . $insert_paquet['nom_archive'] . " a echoue (contribution non plugin)\n", 'svp_paquets.' . _LOG_ERREUR);
376                                }
377                                else
378                                        $collision = true;
379                        }
380                        // On loge le paquet ayant ete refuse dans un fichier a part afin de les verifier
381                        // apres coup
382                        if ($collision) {
383                                spip_log("Collision avec le paquet <". $insert_paquet['nom_archive'] . 
384                                                " / " . $insert_paquet['src_archive'] . "> du depot <" . $insert_paquet['id_depot'] . ">\n", 'svp_paquets.' . _LOG_INFO_IMPORTANTE);
385                        }
386                }
387                else {
388                        // Le paquet existe deja en base de donnees
389                        // ----------------------------------------
390                       
391                        // On met a jour le paquet en premier lieu qu'il soit un plugin ou une contribution
392                        sql_updateq('spip_paquets', $insert_paquet,
393                                                'id_paquet=' . sql_quote($paquet['id_paquet']));
394
395                        // Ensuite, si on est en presence d'un plugin, on le met a jour si le paquet est de version
396                        // plus elevee ou egale (on gere ainsi les oublis d'incrementation)
397                        if ($paquet_plugin) {
398                                if ($vmax = sql_getfetsel('vmax', 'spip_plugins', array('id_plugin=' . sql_quote($paquet['id_plugin']))))
399                                        if (spip_version_compare($vmax, $insert_paquet['version'], '<='))
400                                                sql_updateq('spip_plugins',
401                                                                        array_merge($insert_plugin, array('vmax' => $insert_paquet['version'])),
402                                                                        'id_plugin=' . sql_quote($paquet['id_plugin']));
403                        }
404                               
405                        // On ne change rien sur la table spip_depots_plugins, c'est inutile
406
407                        // On retire le paquet mis a jour de la liste des paquets a supprimer a la fin de l'actualisation
408                        if (isset($ids_a_supprimer[$paquet['id_paquet']])) {
409                                unset($ids_a_supprimer[$paquet['id_paquet']]);
410                                unset($versions_a_supprimer[$paquet['id_paquet']]);
411                        }
412                }
413        }
414       
415        // Il faut maintenant nettoyer la liste des paquets et plugins qui ont disparus du depot
416        if (count($ids_a_supprimer) > 0)
417                svp_nettoyer_apres_actualisation($id_depot, $ids_a_supprimer, $versions_a_supprimer);
418
419        // On compile maintenant certaines informations des paquets mis a jour dans les plugins
420        // (date de creation, date de modif, version spip...)
421        svp_completer_plugins($id_depot);
422       
423        // Calcul des compteurs de paquets, plugins et contributions
424        $nb_paquets = sql_countsel('spip_paquets', 'id_depot=' . sql_quote($id_depot));
425        $nb_plugins = sql_countsel('spip_depots_plugins', 'id_depot=' . sql_quote($id_depot));
426        $nb_autres = sql_countsel('spip_paquets', array('id_depot=' . sql_quote($id_depot), 'id_plugin=0'));
427       
428        return true;
429}
430
431
432function svp_nettoyer_apres_actualisation($id_depot, $ids_a_supprimer, $versions_a_supprimer) {
433
434        // Si on rentre dans cette fonction c'est que le tableau des paquets a supprimer est non vide
435        // On prepare :
436        // - la liste des paquets a supprimer
437        // - la liste des plugins a verifier
438        // - la liste des versions max pour les plugins a verifier
439        $paquets_a_supprimer = array();
440        $ids_plugin = array();
441        $vmax = array();
442        foreach ($ids_a_supprimer as $_id_paquet => $_id_plugin) {
443                $paquets_a_supprimer[] = $_id_paquet;
444                if (!in_array($_id_plugin, $ids_plugin) AND ($_id_plugin != 0)) {
445                        $ids_plugin[] = $_id_plugin;
446                        if (!isset($vmax[$id_plugin])
447                        OR (spip_version_compare($vmax[$id_plugin], $versions_a_supprimer[$_id_paquet], '<'))) 
448                                $vmax[$_id_plugin] = $versions_a_supprimer[$_id_paquet];
449                }
450        }
451
452        // On supprime les paquets inutiles
453        sql_delete('spip_paquets', sql_in('id_paquet', $paquets_a_supprimer));
454
455        // On verifie pour chaque plugin concerne par la disparition de paquets si c'est la version
456        // la plus elevee qui a ete supprimee.
457        // Si oui, on positionne le vmax a 0, ce qui permettra de remettre a jour le plugin systematiquement
458        // a la prochaine actualisation.
459        // Cette operation est necessaire car on n'impose pas que les informations du plugin soient identiques
460        // pour chaque paquet !!!
461        if ($resultats = sql_select('id_plugin, vmax', 'spip_plugins', sql_in('id_plugin', $ids_plugin))) {
462                while ($plugin = sql_fetch($resultats)) {
463                        if (spip_version_compare($plugin['vmax'], $vmax[$plugin['id_plugin']], '='))
464                                sql_updateq('spip_plugins',     array('vmax' => '0.0'), 'id_plugin=' . sql_quote($plugin['id_plugin']));
465                }
466        }
467
468        if ($ids_plugin) {
469                // On cherche pour chaque plugin de la liste si un paquet existe encore dans le meme depot
470                // Si aucun autre paquet n'existe on peut supprimer le plugin de la table spip_depots_plugins
471                if ($resultats = sql_select('id_plugin', 'spip_paquets', 
472                                                                        array('id_depot=' . sql_quote($id_depot), sql_in('id_plugin', $ids_plugin)))) {
473                        while ($paquet = sql_fetch($resultats)) {
474                                $cle = array_search($paquet['id_plugin'], $ids_plugin);
475                                if ($cle !== false)
476                                        unset($ids_plugin[$cle]);
477                        }
478                }
479                if (count($ids_plugin) > 0) {
480                        // On supprime les liens des plugins n'etant plus heberges par le depot
481                        sql_delete('spip_depots_plugins', array('id_depot=' . sql_quote($id_depot), sql_in('id_plugin', $ids_plugin)));
482                               
483                        // Maintenant on verifie si les plugins supprimes sont encore heberges par d'autre depot
484                        // Si non, on peut supprimer le plugin lui-meme de la table spip_plugins
485                        $plugins_a_supprimer = $ids_plugin;
486                        if ($liens = sql_allfetsel('id_plugin', 'spip_depots_plugins', sql_in('id_plugin', $ids_plugin))) {
487                                $plugins_a_conserver = array_map('reset', $liens);
488                                // L'intersection des deux tableaux renvoie les plugins a supprimer     
489                                $plugins_a_supprimer = array_diff($ids_plugin, $plugins_a_conserver);
490                        }
491                       
492                        // On supprime les plugins identifies
493                        if ($plugins_a_supprimer)
494                                sql_delete('spip_plugins', sql_in('id_plugin', $plugins_a_supprimer));
495                }
496        }
497       
498        return true;
499}
500
501
502function svp_completer_plugins($id_depot) {
503        include_spip('inc/svp_outiller');
504
505        // On limite la revue des paquets a ceux des plugins heberges par le depot en cours d'actualisation
506        if ($ids_plugin = sql_allfetsel('id_plugin', 'spip_depots_plugins', array('id_depot=' . sql_quote($id_depot)))) {
507                // -- on commence donc par recuperer les id des plugins du depot
508                $ids_plugin = array_map('reset', $ids_plugin);
509       
510                // -- on recupere tous les paquets associes aux plugins du depot et on compile les infos
511                $plugin_en_cours = 0;
512                if ($resultats = sql_select('id_plugin, compatibilite_spip, date_crea, date_modif', 
513                                                                        'spip_paquets', 
514                                                                        array(sql_in('id_plugin', $ids_plugin)), array(), 
515                                                                        array('id_plugin'))) {
516                        while ($paquet = sql_fetch($resultats)) {
517                                // On finalise le plugin en cours et on passe au suivant
518                                if ($plugin_en_cours != $paquet['id_plugin']) {
519                                        // On met a jour le plugin en cours
520                                        if ($plugin_en_cours != 0) {
521                                                // On deduit maintenant les branches de la compatibilite globale
522                                                $complements['branches_spip'] = compiler_branches_spip($complements['compatibilite_spip']);
523                                                sql_updateq('spip_plugins',
524                                                                        $complements,
525                                                                        'id_plugin=' . sql_quote($plugin_en_cours));
526                                        }
527                                        // On passe au plugin suivant
528                                        $plugin_en_cours = $paquet['id_plugin'];
529                                        $complements = array('compatibilite_spip' => '', 'branches_spip' => '', 'date_crea' => 0, 'date_modif' => 0);
530                                }
531                               
532                                // On compile les compléments du plugin avec le paquet courant sauf les branches
533                                // qui sont deduites en fin de compilation de la compatibilite
534                                if ($paquet['date_modif'] > $complements['date_modif'])
535                                        $complements['date_modif'] = $paquet['date_modif'];
536                                if (($complements['date_crea'] === 0)
537                                OR ($paquet['date_crea'] < $complements['date_crea']))
538                                        $complements['date_crea'] = $paquet['date_crea'];
539                                if ($paquet['compatibilite_spip'])
540                                        if (!$complements['compatibilite_spip'])
541                                                $complements['compatibilite_spip'] = $paquet['compatibilite_spip'];
542                                        else
543                                                $complements['compatibilite_spip'] = fusionner_intervalles($paquet['compatibilite_spip'], $complements['compatibilite_spip']);
544                        }
545                        // On finalise le dernier plugin en cours
546                        $complements['branches_spip'] = compiler_branches_spip($complements['compatibilite_spip']);
547                        sql_updateq('spip_plugins',
548                                                $complements,
549                                                'id_plugin=' . sql_quote($plugin_en_cours));
550                }
551        }
552
553        return true;
554}
555
556
557function eclater_plugin_paquet($champs_aplat) {
558        return array(
559                'plugin' => array(
560                        'prefixe' => $champs_aplat['prefixe'],
561                        'nom' => $champs_aplat['nom'],
562                        'slogan' => $champs_aplat['slogan'],
563                        'categorie' => $champs_aplat['categorie'],
564                        'tags' => $champs_aplat['tags']),
565                'paquet' => array(
566                        'logo' => $champs_aplat['logo'],
567                        'description' => $champs_aplat['description'],
568                        'auteur' => $champs_aplat['auteur'],
569                        'credit' => $champs_aplat['credit'],
570                        'version' => $champs_aplat['version'],
571                        'version_base' => $champs_aplat['version_base'],
572                        'compatibilite_spip' => $champs_aplat['compatibilite_spip'],
573                        'branches_spip' => $champs_aplat['branches_spip'],
574                        'etat' => $champs_aplat['etat'],
575                        'etatnum' => $champs_aplat['etatnum'],
576                        'licence' => $champs_aplat['licence'],
577                        'copyright' => $champs_aplat['copyright'],
578                        'lien_doc' => $champs_aplat['lien_doc'],
579                        'lien_demo' => $champs_aplat['lien_demo'],
580                        'lien_dev' => $champs_aplat['lien_dev'],
581                        'dependances' => $champs_aplat['dependances'])
582        );
583}
584
585?>
Note: See TracBrowser for help on using the repository browser.