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

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

Grosse évolution : SVP abandonne SPIP 2.1 pour se projeter dans l'avernir avec SPIP 3. Au menu du commit :

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