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

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

Pour tonton qui ne peut pas commiter depuis son palace : suppression du traitement particulier sur les thèmes maintenant que le préfixe est unique + ajout des statistiques d'utilisation des plugins (stats.spip.org) avec mise à jour automatique possible

  • Property svn:eol-style set to native
File size: 22.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        // 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                                $where = array('t1.id_plugin=t2.id_plugin',
317                                                't1.version=' . sql_quote($insert_paquet['version']),
318                                                't1.version_base=' . sql_quote($insert_paquet['version_base']),
319                                                't1.etatnum=' . sql_quote($insert_paquet['etatnum']),
320                                                't2.prefixe=' . sql_quote($insert_plugin['prefixe']));
321                                if (!$id_paquet = sql_getfetsel('t1.id_paquet', 'spip_paquets AS t1, spip_plugins AS t2', $where)) {
322                                        // On traite d'abord le plugin du paquet pour recuperer l'id_plugin
323                                        // On rajoute le plugin dans la table spip_plugins si celui-ci n'y est pas encore ou on recupere
324                                        // l'id si il existe deja et on le met a jour si la version du paquet est plus elevee
325                                        if (!$plugin = sql_fetsel('id_plugin, vmax', 'spip_plugins',
326                                                array('prefixe=' . sql_quote($insert_plugin['prefixe'])))) {
327                                                if (!$id_plugin = sql_insertq('spip_plugins', 
328                                                                                        array_merge($insert_plugin, array('vmax' => $insert_paquet['version']))))
329                                                        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);
330                                        }
331                                        else {
332                                                $id_plugin = $plugin['id_plugin'];
333                                                if (spip_version_compare($plugin['vmax'], $insert_paquet['version'], '<='))
334                                                        sql_updateq('spip_plugins',
335                                                                                array_merge($insert_plugin, array('vmax' => $insert_paquet['version'])),
336                                                                                'id_plugin=' . sql_quote($id_plugin));
337                                        }
338       
339                                        // On traite maintenant le paquet connaissant l'id du plugin
340                                        if ($id_plugin) {
341                                                $insert_paquet['id_plugin'] = $id_plugin;
342                                                if (!$id_paquet = sql_insertq('spip_paquets', $insert_paquet))
343                                                        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);
344                                                else {
345                                                        // On rajoute le plugin comme heberge par le depot si celui-ci n'est pas encore
346                                                        // enregistre comme tel
347                                                        if (!sql_countsel('spip_depots_plugins',
348                                                                array('id_plugin=' . sql_quote($id_plugin),
349                                                                        'id_depot=' . sql_quote($id_depot)))) {
350                                                                sql_insertq('spip_depots_plugins', array('id_depot' => $id_depot, 'id_plugin' => $id_plugin));
351                                                        }
352                                                }
353                                        }
354                                }
355                                else
356                                        $collision = true;
357                        }
358                        else {
359                                // On est en presence d'une CONTRIBUTION NON PLUGIN
360                                // ------------------------------------------------
361                                $where = array(
362                                                't1.id_depot=' . sql_quote($insert_paquet['id_depot']),
363                                                't1.nom_archive=' . sql_quote($insert_paquet['nom_archive']));
364                                if (!$id_paquet = sql_getfetsel('t1.id_paquet', 'spip_paquets AS t1', $where)) {
365                                        // Ce n'est pas un plugin, donc id_plugin=0 et toutes les infos plugin sont nulles
366                                        $insert_paquet['id_plugin'] = 0;
367                                        if (!$id_paquet = sql_insertq('spip_paquets', $insert_paquet))
368                                                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);
369                                }
370                                else
371                                        $collision = true;
372                        }
373                        // On loge le paquet ayant ete refuse dans un fichier a part afin de les verifier
374                        // apres coup
375                        if ($collision) {
376                                spip_log("Collision avec le paquet <". $insert_paquet['nom_archive'] . 
377                                                " / " . $insert_paquet['src_archive'] . "> du depot <" . $insert_paquet['id_depot'] . ">\n", 'svp_paquets.' . _LOG_INFO_IMPORTANTE);
378                        }
379                }
380                else {
381                        // Le paquet existe deja en base de donnees
382                        // ----------------------------------------
383                       
384                        // On met a jour le paquet en premier lieu qu'il soit un plugin ou une contribution
385                        sql_updateq('spip_paquets', $insert_paquet,
386                                                'id_paquet=' . sql_quote($paquet['id_paquet']));
387
388                        // Ensuite, si on est en presence d'un plugin, on le met a jour si le paquet est de version
389                        // plus elevee ou egale (on gere ainsi les oublis d'incrementation)
390                        if ($paquet_plugin) {
391                                if ($vmax = sql_getfetsel('vmax', 'spip_plugins', array('id_plugin=' . sql_quote($paquet['id_plugin']))))
392                                        if (spip_version_compare($vmax, $insert_paquet['version'], '<='))
393                                                sql_updateq('spip_plugins',
394                                                                        array_merge($insert_plugin, array('vmax' => $insert_paquet['version'])),
395                                                                        'id_plugin=' . sql_quote($paquet['id_plugin']));
396                        }
397                               
398                        // On ne change rien sur la table spip_depots_plugins, c'est inutile
399
400                        // On retire le paquet mis a jour de la liste des paquets a supprimer a la fin de l'actualisation
401                        if (isset($ids_a_supprimer[$paquet['id_paquet']])) {
402                                unset($ids_a_supprimer[$paquet['id_paquet']]);
403                                unset($versions_a_supprimer[$paquet['id_paquet']]);
404                        }
405                }
406        }
407       
408        // Il faut maintenant nettoyer la liste des paquets et plugins qui ont disparus du depot
409        if (count($ids_a_supprimer) > 0)
410                svp_nettoyer_apres_actualisation($id_depot, $ids_a_supprimer, $versions_a_supprimer);
411       
412        // Calcul des compteurs de paquets, plugins et contributions
413        $nb_paquets = sql_countsel('spip_paquets', 'id_depot=' . sql_quote($id_depot));
414        $nb_plugins = sql_countsel('spip_depots_plugins', 'id_depot=' . sql_quote($id_depot));
415        $nb_autres = sql_countsel('spip_paquets', array('id_depot=' . sql_quote($id_depot), 'id_plugin=0'));
416       
417        return true;
418}
419
420
421function svp_nettoyer_apres_actualisation($id_depot, $ids_a_supprimer, $versions_a_supprimer) {
422
423        // Si on rentre dans cette fonction c'est que le tableau des paquets a supprimer est non vide
424        // On prepare :
425        // - la liste des paquets a supprimer
426        // - la liste des plugins a verifier
427        // - la liste des versions max pour les plugins a verifier
428        $paquets_a_supprimer = array();
429        $ids_plugin = array();
430        $vmax = array();
431        foreach ($ids_a_supprimer as $_id_paquet => $_id_plugin) {
432                $paquets_a_supprimer[] = $_id_paquet;
433                if (!in_array($_id_plugin, $ids_plugin) AND ($_id_plugin != 0)) {
434                        $ids_plugin[] = $_id_plugin;
435                        if (!isset($vmax[$id_plugin])
436                        OR (spip_version_compare($vmax[$id_plugin], $versions_a_supprimer[$_id_paquet], '<'))) 
437                                $vmax[$_id_plugin] = $versions_a_supprimer[$_id_paquet];
438                }
439        }
440
441        // On supprime les paquets inutiles
442        sql_delete('spip_paquets', sql_in('id_paquet', $paquets_a_supprimer));
443
444        // On verifie pour chaque plugin concerne par la disparition de paquets si c'est la version
445        // la plus elevee qui a ete supprimee.
446        // Si oui, on positionne le vmax a 0, ce qui permettra de remettre a jour le plugin systematiquement
447        // a la prochaine actualisation.
448        // Cette operation est necessaire car on n'impose pas que les informations du plugin soient identiques
449        // pour chaque paquet !!!
450        if ($resultats = sql_select('id_plugin, vmax', 'spip_plugins', sql_in('id_plugin', $ids_plugin))) {
451                while ($plugin = sql_fetch($resultats)) {
452                        if (spip_version_compare($plugin['vmax'], $vmax[$plugin['id_plugin']], '='))
453                                sql_updateq('spip_plugins',     array('vmax' => '0.0'), 'id_plugin=' . sql_quote($plugin['id_plugin']));
454                }
455        }
456
457        if ($ids_plugin) {
458                // On cherche pour chaque plugin de la liste si un paquet existe encore dans le meme depot
459                // Si aucun autre paquet n'existe on peut supprimer le plugin de la table spip_depots_plugins
460                if ($resultats = sql_select('id_plugin', 'spip_paquets', 
461                                                                        array('id_depot=' . sql_quote($id_depot), sql_in('id_plugin', $ids_plugin)))) {
462                        while ($paquet = sql_fetch($resultats)) {
463                                $cle = array_search($paquet['id_plugin'], $ids_plugin);
464                                if ($cle !== false)
465                                        unset($ids_plugin[$cle]);
466                        }
467                }
468                if (count($ids_plugin) > 0) {
469                        // On supprime les liens des plugins n'etant plus heberges par le depot
470                        sql_delete('spip_depots_plugins', array('id_depot=' . sql_quote($id_depot), sql_in('id_plugin', $ids_plugin)));
471                               
472                        // Maintenant on verifie si les plugins supprimes sont encore heberges par d'autre depot
473                        // Si non, on peut supprimer le plugin lui-meme de la table spip_plugins
474                        $plugins_a_supprimer = $ids_plugin;
475                        if ($liens = sql_allfetsel('id_plugin', 'spip_depots_plugins', sql_in('id_plugin', $ids_plugin))) {
476                                $plugins_a_conserver = array_map('reset', $liens);
477                                // L'intersection des deux tableaux renvoie les plugins a supprimer     
478                                $plugins_a_supprimer = array_diff($ids_plugin, $plugins_a_conserver);
479                        }
480                       
481                        // On supprime les plugins identifies
482                        if ($plugins_a_supprimer)
483                                sql_delete('spip_plugins', sql_in('id_plugin', $plugins_a_supprimer));
484                }
485        }
486       
487        return true;
488}
489
490function eclater_plugin_paquet($champs_aplat) {
491        return array(
492                'plugin' => array(
493                        'prefixe' => $champs_aplat['prefixe'],
494                        'nom' => $champs_aplat['nom'],
495                        'slogan' => $champs_aplat['slogan'],
496                        'categorie' => $champs_aplat['categorie'],
497                        'tags' => $champs_aplat['tags']),
498                'paquet' => array(
499                        'logo' => $champs_aplat['logo'],
500                        'description' => $champs_aplat['description'],
501                        'auteur' => $champs_aplat['auteur'],
502                        'version' => $champs_aplat['version'],
503                        'version_base' => $champs_aplat['version_base'],
504                        'version_spip' => $champs_aplat['version_spip'],
505                        'etat' => $champs_aplat['etat'],
506                        'etatnum' => $champs_aplat['etatnum'],
507                        'licence' => $champs_aplat['licence'],
508                        'lien' => $champs_aplat['lien'],
509                        'dependances' => $champs_aplat['dependances'])
510        );
511}
512
513
514
515// ----------------------- Traitements des stats ---------------------------------
516
517/**
518 * Actualisation des statistiques des plugins presents dans la base.
519 * @return boolean
520 */
521
522function svp_actualiser_stats() {
523        include_spip('inc/distant');
524
525        $page = recuperer_page(_SVP_SOURCE_STATS);
526        $infos = json_decode($page);
527        if (!$stats = $infos->plugins) {
528                // On ne fait que loger l'erreur car celle-ci n'a pas d'incidence sur le comportement
529                // de SVP
530                spip_log('Réponse du serveur incorrecte ou mal formée. Les statistiques ne seront pas mises à jour', 'svp.' . _LOG_ERREUR);
531                return false;
532        }
533
534        foreach ($stats as $_stat) {
535                $prefixe = strtoupper($_stat->nom);
536                if ($id_plugin = sql_fetsel('id_plugin', 'spip_plugins', array('prefixe='. sql_quote($prefixe)))) {
537                        // Si le plugin est bien dans la base on peut lui mettre a jour ses statistiques
538                        sql_updateq('spip_plugins', 
539                                                array('nbr_sites'=> $_stat->sites, 'popularite'=> floatval(trim($_stat->pourcentage, '%'))),
540                                                'id_plugin=' . sql_quote($id_plugin));
541                }
542        }
543       
544        return true;
545}
546
547?>
Note: See TracBrowser for help on using the repository browser.