1 | <?php |
---|
2 | |
---|
3 | if (!defined("_ECRIRE_INC_VERSION")) return; |
---|
4 | include_spip('inc/plugin'); |
---|
5 | |
---|
6 | // ----------------------- Traitements des depots --------------------------------- |
---|
7 | |
---|
8 | /** |
---|
9 | * Teste la validite d'une url d'un depot de paquets |
---|
10 | * |
---|
11 | * @param string $url |
---|
12 | * @return boolean |
---|
13 | */ |
---|
14 | |
---|
15 | // $url => url du fichier xml de description du depot |
---|
16 | function svp_verifier_adresse_depot($url){ |
---|
17 | include_spip('inc/distant'); |
---|
18 | return (!$xml = recuperer_page($url)) ? false : true; |
---|
19 | } |
---|
20 | |
---|
21 | |
---|
22 | /** |
---|
23 | * Ajout du depot et de ses extensions dans la base de donnees |
---|
24 | * |
---|
25 | * @param string $url |
---|
26 | * @return boolean |
---|
27 | */ |
---|
28 | |
---|
29 | // $url => url du fichier xml de description du depot |
---|
30 | // $erreur => message d'erreur a afficher |
---|
31 | function svp_ajouter_depot($url, &$erreur=''){ |
---|
32 | // On considere que l'url a deja ete validee (correcte et nouveau depot) |
---|
33 | $url = trim($url); |
---|
34 | |
---|
35 | // Lire les donnees d'un depot de paquets |
---|
36 | $infos = svp_xml_parse_depot($url); |
---|
37 | if (!$infos) { |
---|
38 | $erreur = _T('svp:message_nok_xml_non_conforme', array('fichier' => $url)); |
---|
39 | return false; |
---|
40 | } |
---|
41 | |
---|
42 | // Ajout du depot dans la table spip_depots. Les compteurs de paquets et de plugins |
---|
43 | // sont mis a jour apres le traitement des paquets |
---|
44 | $champs = array('titre' => filtrer_entites($infos['depot']['titre']), |
---|
45 | 'descriptif' => filtrer_entites($infos['depot']['descriptif']), |
---|
46 | 'type' => $infos['depot']['type'], |
---|
47 | 'url_serveur' => $infos['depot']['url_serveur'], |
---|
48 | 'url_archives' => $infos['depot']['url_archives'], |
---|
49 | 'xml_paquets'=> $url, |
---|
50 | 'sha_paquets'=> sha1_file($url)); |
---|
51 | $id_depot = sql_insertq('spip_depots', $champs); |
---|
52 | |
---|
53 | // Ajout des paquets dans spip_paquets et actualisation des plugins dans spip_plugins |
---|
54 | $ok = svp_actualiser_paquets($id_depot, $infos['paquets'], $nb_paquets, $nb_plugins, $nb_autres); |
---|
55 | if (!$ok OR ($nb_paquets == 0)) { |
---|
56 | // Si une erreur s'est produite, on supprime le depot deja insere |
---|
57 | sql_delete('spip_depots','id_depot='.sql_quote($id_depot)); |
---|
58 | if (!ok) |
---|
59 | $erreur = _T('svp:message_nok_xml_non_conforme', array('fichier' => $url)); |
---|
60 | else |
---|
61 | $erreur = _T('svp:message_nok_aucun_paquet_ajoute', array('url' => $url)); |
---|
62 | return false; |
---|
63 | } |
---|
64 | |
---|
65 | // On met à jour le nombre de paquets et de plugins du depot maintenant ! |
---|
66 | sql_updateq('spip_depots', |
---|
67 | array('nbr_paquets'=> $nb_paquets, 'nbr_plugins'=> $nb_plugins, 'nbr_autres'=> $nb_autres), |
---|
68 | 'id_depot=' . sql_quote($id_depot)); |
---|
69 | |
---|
70 | return true; |
---|
71 | } |
---|
72 | |
---|
73 | /** |
---|
74 | * Suppression du depot et de ses extensions dans la base de donnees |
---|
75 | * |
---|
76 | * @param int $id |
---|
77 | * @return boolean |
---|
78 | */ |
---|
79 | |
---|
80 | // $id => id_depot de l'objet depot dans la table spip_depots |
---|
81 | function svp_supprimer_depot($id){ |
---|
82 | $id = intval($id); |
---|
83 | |
---|
84 | // Pas de depot a cet id ? |
---|
85 | if (!$id_depot = sql_getfetsel('id_depot', 'spip_depots', 'id_depot='. sql_quote($id)) ){ |
---|
86 | return false; |
---|
87 | } |
---|
88 | |
---|
89 | // on calcule les versions max des plugins heberges par le depot |
---|
90 | $vmax =array(); |
---|
91 | if ($resultats = sql_select('id_plugin, version', 'spip_paquets', 'id_depot='. sql_quote($id))) { |
---|
92 | while ($paquet = sql_fetch($resultats)) { |
---|
93 | $id_plugin = $paquet['id_plugin']; |
---|
94 | if (!isset($vmax[$id_plugin]) |
---|
95 | OR (spip_version_compare($vmax[$id_plugin], $paquet['version'], '<'))) |
---|
96 | $vmax[$id_plugin] = $paquet['version']; |
---|
97 | } |
---|
98 | } |
---|
99 | |
---|
100 | // On supprime les paquets heberges par le depot |
---|
101 | sql_delete('spip_paquets','id_depot='.sql_quote($id_depot)); |
---|
102 | |
---|
103 | // On supprime ensuite : |
---|
104 | // - les liens des plugins avec le depot (table spip_depots_plugins) |
---|
105 | // - les plugins dont aucun paquet n'est encore heberge par un depot restant (table spip_plugins) |
---|
106 | // - et on met a zero la vmax des plugins ayant vu leur paquet vmax supprime |
---|
107 | svp_nettoyer_apres_suppression($id_depot, $vmax); |
---|
108 | |
---|
109 | // On supprime le depot lui-meme |
---|
110 | sql_delete('spip_depots','id_depot='.sql_quote($id_depot)); |
---|
111 | return true; |
---|
112 | } |
---|
113 | |
---|
114 | |
---|
115 | function svp_nettoyer_apres_suppression($id_depot, $vmax) { |
---|
116 | |
---|
117 | // On rapatrie la liste des plugins du depot qui servira apres qu'on ait supprime les liens |
---|
118 | // de la table spip_depots_plugins |
---|
119 | $liens = sql_allfetsel('id_plugin', 'spip_depots_plugins', 'id_depot='.sql_quote($id_depot)); |
---|
120 | $plugins_depot = array_map('reset', $liens); |
---|
121 | |
---|
122 | // On peut donc supprimer tous ces liens *plugins-depots* du depot |
---|
123 | sql_delete('spip_depots_plugins', 'id_depot='.sql_quote($id_depot)); |
---|
124 | |
---|
125 | // On verifie pour chaque plugin concerne par la disparition de paquets si c'est la version |
---|
126 | // la plus elevee qui a ete supprimee. |
---|
127 | // Si oui, on positionne le vmax a 0, ce qui permettra de remettre a jour le plugin systematiquement |
---|
128 | // a la prochaine actualisation. |
---|
129 | // Cette operation est necessaire car on n'impose pas que les informations du plugin soient identiques |
---|
130 | // pour chaque paquet !!! |
---|
131 | if ($resultats = sql_select('id_plugin, vmax', 'spip_plugins', sql_in('id_plugin', $plugins_depot))) { |
---|
132 | while ($plugin = sql_fetch($resultats)) { |
---|
133 | if (spip_version_compare($plugin['vmax'], $vmax[$plugin['id_plugin']], '=')) |
---|
134 | sql_updateq('spip_plugins', array('vmax' => '0.0'), 'id_plugin=' . sql_quote($plugin['id_plugin'])); |
---|
135 | } |
---|
136 | } |
---|
137 | |
---|
138 | // Maintenant on calcule la liste des plugins du depot qui ne sont pas heberges |
---|
139 | // par un autre depot => donc a supprimer |
---|
140 | // - Liste de tous les plugins encore lies a un autre depot |
---|
141 | $liens = sql_allfetsel('id_plugin', 'spip_depots_plugins'); |
---|
142 | $autres_plugins = array_map('reset', $liens); |
---|
143 | // - L'intersection des deux tableaux renvoie les plugins a supprimer |
---|
144 | $plugins_a_supprimer = array_diff($plugins_depot, $autres_plugins); |
---|
145 | |
---|
146 | // On supprimer les plugins identifies |
---|
147 | sql_delete('spip_plugins', sql_in('id_plugin', $plugins_a_supprimer)); |
---|
148 | |
---|
149 | return true; |
---|
150 | } |
---|
151 | |
---|
152 | |
---|
153 | /** |
---|
154 | * Actualisation des plugins d'un depot deja cree. |
---|
155 | * @param int $id |
---|
156 | * @return boolean |
---|
157 | */ |
---|
158 | |
---|
159 | // $id => id_depot de l'objet depot dans la table spip_depots |
---|
160 | function svp_actualiser_depot($id){ |
---|
161 | $id = intval($id); |
---|
162 | |
---|
163 | // pas de depot a cet id ? |
---|
164 | if (!$depot = sql_fetsel('*', 'spip_depots', 'id_depot='. sql_quote($id)) ){ |
---|
165 | return false; |
---|
166 | } |
---|
167 | |
---|
168 | $sha = sha1_file($depot['xml_paquets']); |
---|
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('>> AVERTISSEMENT : aucune modification du fichier XML, actualisation non declenchee - id_depot = ' . $depot['id_depot'], 'svp'); |
---|
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_xml_parse_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 |
---|
219 | function 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 | // A REVOIR COMPLETEMENT !!!! |
---|
232 | $depot = sql_fetsel('url_archives, type', '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 | |
---|
257 | // On verifie si le paquet est celui d'un plugin ou pas |
---|
258 | if ($champs = svp_remplir_champs_sql($_infos['plugin'])) { |
---|
259 | $paquet_plugin = true; |
---|
260 | // On complete les informations du paquet et du plugin |
---|
261 | $insert_paquet = array_merge($insert_paquet, $champs['paquet']); |
---|
262 | $insert_plugin = $champs['plugin']; |
---|
263 | // On construit l'url complete du logo |
---|
264 | // Le logo est maintenant disponible a la meme adresse que le zip et porte le nom du zip. |
---|
265 | // Son extension originale est conservee |
---|
266 | if ($insert_paquet['logo']) |
---|
267 | $insert_paquet['logo'] = $depot['url_archives'] . '/' |
---|
268 | . basename($insert_paquet['nom_archive'], '.zip') . '.' |
---|
269 | . pathinfo($insert_paquet['logo'], PATHINFO_EXTENSION); |
---|
270 | |
---|
271 | // On loge l'absence de categorie ou une categorie erronee et on positionne la categorie |
---|
272 | // par defaut "aucune" |
---|
273 | // Provisoire tant que la DTD n'est pas en fonction |
---|
274 | if (!$insert_plugin['categorie']) { |
---|
275 | spip_log("Categorie absente dans le paquet issu de <". $insert_paquet['src_archive'] . |
---|
276 | "> du depot <" . $insert_paquet['id_depot'] . ">\n", 'svp_paquets'); |
---|
277 | $insert_plugin['categorie'] = 'aucune'; |
---|
278 | } |
---|
279 | else { |
---|
280 | $svp_categories = unserialize($GLOBALS['meta']['svp_categories']); |
---|
281 | if (!in_array($insert_plugin['categorie'], $svp_categories)) { |
---|
282 | spip_log("Categorie k" . $insert_plugin['categorie'] . "l incorrecte dans le paquet issu de <". $insert_paquet['src_archive'] . |
---|
283 | "> du depot <" . $insert_paquet['id_depot'] . ">\n", 'svp_paquets'); |
---|
284 | $insert_plugin['categorie'] = 'aucune'; |
---|
285 | } |
---|
286 | } |
---|
287 | } |
---|
288 | else { |
---|
289 | $paquet_plugin = false; |
---|
290 | } |
---|
291 | // On teste l'existence du paquet dans la base avec les champs id_depot, nom_archive et src_archive |
---|
292 | // pour etre sur de l'unicite. |
---|
293 | // - si le paquet existe on ne fait qu'un update |
---|
294 | // - sinon on insere le paquet |
---|
295 | if (!$paquet = sql_fetsel('*', 'spip_paquets', array('id_depot='. sql_quote($insert_paquet['id_depot']), |
---|
296 | 'nom_archive='. sql_quote($insert_paquet['nom_archive']), |
---|
297 | 'src_archive='. sql_quote($insert_paquet['src_archive'])))) { |
---|
298 | // Le paquet n'existe pas encore en base de donnees |
---|
299 | // ------------------------------------------------ |
---|
300 | |
---|
301 | // On positionne la date de creation a celle du dernier commit ce qui est bien le cas |
---|
302 | $insert_paquet['date_crea'] = $insert_paquet['date_modif']; |
---|
303 | |
---|
304 | // Les collisions ne sont possibles que si on ajoute un nouveau paquet |
---|
305 | $collision = false; |
---|
306 | |
---|
307 | if ($paquet_plugin) { |
---|
308 | // On est en presence d'un PLUGIN |
---|
309 | // ------------------------------ |
---|
310 | // On evite les doublons de paquet |
---|
311 | // Pour determiner un doublon on verifie actuellement : |
---|
312 | // - le prefixe |
---|
313 | // - la version du paquet et de la base |
---|
314 | // - l'etat |
---|
315 | // - et on exclu les themes car leur prefixe est toujours = a "theme" |
---|
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 (($insert_plugin['prefixe'] == _SVP_PREFIXE_PLUGIN_THEME) |
---|
322 | OR (!$id_paquet = sql_getfetsel('t1.id_paquet', 'spip_paquets AS t1, spip_plugins AS t2', $where))) { |
---|
323 | // On traite d'abord le plugin du paquet pour recuperer l'id_plugin |
---|
324 | // On rajoute le plugin dans la table spip_plugins si celui-ci n'y est pas encore ou on recupere |
---|
325 | // l'id si il existe deja et on le met a jour si la version du paquet est plus elevee |
---|
326 | if (!$plugin = sql_fetsel('id_plugin, vmax', 'spip_plugins', |
---|
327 | array('prefixe=' . sql_quote($insert_plugin['prefixe'])))) { |
---|
328 | $id_plugin = sql_insertq('spip_plugins', |
---|
329 | array_merge($insert_plugin, array('vmax' => $insert_paquet['version']))); |
---|
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 | $insert_paquet['id_plugin'] = $id_plugin; |
---|
341 | sql_insertq('spip_paquets', $insert_paquet); |
---|
342 | |
---|
343 | // On rajoute le plugin comme heberge par le depot si celui-ci n'est pas encore |
---|
344 | // enregistre comme tel |
---|
345 | if (!sql_countsel('spip_depots_plugins', |
---|
346 | array('id_plugin=' . sql_quote($id_plugin), |
---|
347 | 'id_depot=' . sql_quote($id_depot)))) { |
---|
348 | sql_insertq('spip_depots_plugins', array('id_depot' => $id_depot, 'id_plugin' => $id_plugin)); |
---|
349 | } |
---|
350 | } |
---|
351 | else |
---|
352 | $collision = true; |
---|
353 | } |
---|
354 | else { |
---|
355 | // On est en presence d'une CONTRIBUTION NON PLUGIN |
---|
356 | // ------------------------------------------------ |
---|
357 | $where = array( |
---|
358 | 't1.id_depot=' . sql_quote($insert_paquet['id_depot']), |
---|
359 | 't1.nom_archive=' . sql_quote($insert_paquet['nom_archive'])); |
---|
360 | if (!$id_paquet = sql_getfetsel('t1.id_paquet', 'spip_paquets AS t1', $where)) { |
---|
361 | // Ce n'est pas un plugin, donc id_plugin=0 et toutes les infos plugin sont nulles |
---|
362 | $insert_paquet['id_plugin'] = 0; |
---|
363 | sql_insertq('spip_paquets', $insert_paquet); |
---|
364 | } |
---|
365 | else |
---|
366 | $collision = true; |
---|
367 | } |
---|
368 | // On loge le paquet ayant ete refuse dans un fichier a part afin de les verifier |
---|
369 | // apres coup |
---|
370 | if ($collision AND _SVP_LOG_PAQUETS) { |
---|
371 | spip_log("Collision avec le paquet <". $insert_paquet['nom_archive'] . |
---|
372 | " / " . $insert_paquet['src_archive'] . "> du depot <" . $insert_paquet['id_depot'] . ">\n", 'svp_paquets'); |
---|
373 | } |
---|
374 | } |
---|
375 | else { |
---|
376 | // Le paquet existe deja en base de donnees |
---|
377 | // ---------------------------------------- |
---|
378 | |
---|
379 | // On met a jour le paquet en premier lieu qu'il soit un plugin ou une contribution |
---|
380 | sql_updateq('spip_paquets', $insert_paquet, |
---|
381 | 'id_paquet=' . sql_quote($paquet['id_paquet'])); |
---|
382 | |
---|
383 | // Ensuite, si on est en presence d'un plugin, on le met a jour si le paquet est de version |
---|
384 | // plus elevee ou egale (on gere ainsi les oublis d'incrementation) |
---|
385 | if ($paquet_plugin) { |
---|
386 | if ($vmax = sql_getfetsel('vmax', 'spip_plugins', array('id_plugin=' . sql_quote($paquet['id_plugin'])))) |
---|
387 | if (spip_version_compare($vmax, $insert_paquet['version'], '<=')) |
---|
388 | sql_updateq('spip_plugins', |
---|
389 | array_merge($insert_plugin, array('vmax' => $insert_paquet['version'])), |
---|
390 | 'id_plugin=' . sql_quote($paquet['id_plugin'])); |
---|
391 | } |
---|
392 | |
---|
393 | // On ne change rien sur la table spip_depots_plugins, c'est inutile |
---|
394 | |
---|
395 | // On retire le paquet mis a jour de la liste des paquets a supprimer a la fin de l'actualisation |
---|
396 | if (isset($ids_a_supprimer[$paquet['id_paquet']])) { |
---|
397 | unset($ids_a_supprimer[$paquet['id_paquet']]); |
---|
398 | unset($versions_a_supprimer[$paquet['id_paquet']]); |
---|
399 | } |
---|
400 | } |
---|
401 | } |
---|
402 | |
---|
403 | // Il faut maintenant nettoyer la liste des paquets et plugins qui ont disparus du depot |
---|
404 | if (count($ids_a_supprimer) > 0) |
---|
405 | svp_nettoyer_apres_actualisation($id_depot, $ids_a_supprimer, $versions_a_supprimer); |
---|
406 | |
---|
407 | // Calcul des compteurs de paquets, plugins et contributions |
---|
408 | $nb_paquets = sql_countsel('spip_paquets', 'id_depot=' . sql_quote($id_depot)); |
---|
409 | $nb_plugins = sql_countsel('spip_depots_plugins', 'id_depot=' . sql_quote($id_depot)); |
---|
410 | $nb_autres = sql_countsel('spip_paquets', array('id_depot=' . sql_quote($id_depot), 'id_plugin=0')); |
---|
411 | |
---|
412 | return true; |
---|
413 | } |
---|
414 | |
---|
415 | |
---|
416 | function svp_nettoyer_apres_actualisation($id_depot, $ids_a_supprimer, $versions_a_supprimer) { |
---|
417 | |
---|
418 | // Si on rentre dans cette fonction c'est que le tableau des paquets a supprimer est non vide |
---|
419 | // On prepare : |
---|
420 | // - la liste des paquets a supprimer |
---|
421 | // - la liste des plugins a verifier |
---|
422 | // - la liste des versions max pour les plugins a verifier |
---|
423 | $paquets_a_supprimer = array(); |
---|
424 | $ids_plugin = array(); |
---|
425 | $vmax = array(); |
---|
426 | foreach ($ids_a_supprimer as $_id_paquet => $_id_plugin) { |
---|
427 | $paquets_a_supprimer[] = $_id_paquet; |
---|
428 | if (!in_array($_id_plugin, $ids_plugin) AND ($_id_plugin != 0)) { |
---|
429 | $ids_plugin[] = $_id_plugin; |
---|
430 | if (!isset($vmax[$id_plugin]) |
---|
431 | OR (spip_version_compare($vmax[$id_plugin], $versions_a_supprimer[$_id_paquet], '<'))) |
---|
432 | $vmax[$_id_plugin] = $versions_a_supprimer[$_id_paquet]; |
---|
433 | } |
---|
434 | } |
---|
435 | |
---|
436 | // On supprime les paquets inutiles |
---|
437 | sql_delete('spip_paquets', sql_in('id_paquet', $paquets_a_supprimer)); |
---|
438 | |
---|
439 | // On verifie pour chaque plugin concerne par la disparition de paquets si c'est la version |
---|
440 | // la plus elevee qui a ete supprimee. |
---|
441 | // Si oui, on positionne le vmax a 0, ce qui permettra de remettre a jour le plugin systematiquement |
---|
442 | // a la prochaine actualisation. |
---|
443 | // Cette operation est necessaire car on n'impose pas que les informations du plugin soient identiques |
---|
444 | // pour chaque paquet !!! |
---|
445 | if ($resultats = sql_select('id_plugin, vmax', 'spip_plugins', sql_in('id_plugin', $ids_plugin))) { |
---|
446 | while ($plugin = sql_fetch($resultats)) { |
---|
447 | if (spip_version_compare($plugin['vmax'], $vmax[$plugin['id_plugin']], '=')) |
---|
448 | sql_updateq('spip_plugins', array('vmax' => '0.0'), 'id_plugin=' . sql_quote($plugin['id_plugin'])); |
---|
449 | } |
---|
450 | } |
---|
451 | |
---|
452 | if ($ids_plugin) { |
---|
453 | // On cherche pour chaque plugin de la liste si un paquet existe encore dans le meme depot |
---|
454 | // Si aucun autre paquet n'existe on peut supprimer le plugin de la table spip_depots_plugins |
---|
455 | if ($resultats = sql_select('id_plugin', 'spip_paquets', |
---|
456 | array('id_depot=' . sql_quote($id_depot), sql_in('id_plugin', $ids_plugin)))) { |
---|
457 | while ($paquet = sql_fetch($resultats)) { |
---|
458 | $cle = array_search($paquet['id_plugin'], $ids_plugin); |
---|
459 | if ($cle !== false) |
---|
460 | unset($ids_plugin[$cle]); |
---|
461 | } |
---|
462 | } |
---|
463 | if (count($ids_plugin) > 0) { |
---|
464 | // On supprime les liens des plugins n'etant plus heberges par le depot |
---|
465 | sql_delete('spip_depots_plugins', array('id_depot=' . sql_quote($id_depot), sql_in('id_plugin', $ids_plugin))); |
---|
466 | |
---|
467 | // Maintenant on verifie si les plugins supprimes sont encore heberges par d'autre depot |
---|
468 | // Si non, on peut supprimer le plugin lui-meme de la table spip_plugins |
---|
469 | $plugins_a_supprimer = $ids_plugin; |
---|
470 | if ($liens = sql_allfetsel('id_plugin', 'spip_depots_plugins', sql_in('id_plugin', $ids_plugin))) { |
---|
471 | $plugins_a_conserver = array_map('reset', $liens); |
---|
472 | // L'intersection des deux tableaux renvoie les plugins a supprimer |
---|
473 | $plugins_a_supprimer = array_diff($ids_plugin, $plugins_a_conserver); |
---|
474 | } |
---|
475 | |
---|
476 | // On supprime les plugins identifies |
---|
477 | if ($plugins_a_supprimer) |
---|
478 | sql_delete('spip_plugins', sql_in('id_plugin', $plugins_a_supprimer)); |
---|
479 | } |
---|
480 | } |
---|
481 | |
---|
482 | return true; |
---|
483 | } |
---|
484 | |
---|
485 | |
---|
486 | // Les archives xml sont deja applaties, pas la peine de se compliquer. |
---|
487 | function svp_remplir_champs_sql($p) { |
---|
488 | |
---|
489 | if (!$p) |
---|
490 | return array(); |
---|
491 | |
---|
492 | // On passe le prefixe en lettres majuscules comme ce qui est fait dans SPIP |
---|
493 | // Ainsi les valeurs dans la table spip_plugins coincideront avec celles de la meta plugin |
---|
494 | $p['prefix'] = strtoupper($p['prefix']); |
---|
495 | |
---|
496 | // calcul du tableau de dependances |
---|
497 | $dependances = array(); |
---|
498 | $v_spip = ''; |
---|
499 | if (is_array($p['necessite'])) { |
---|
500 | foreach ($p['necessite'] as $c=>$n) { |
---|
501 | $p['necessite'][$c]['id'] = strtoupper($n['id']); |
---|
502 | if ($n['id'] == 'SPIP') { |
---|
503 | $v_spip = $n['version']; |
---|
504 | } |
---|
505 | } |
---|
506 | $dependances['necessite'] = $p['necessite']; |
---|
507 | } |
---|
508 | |
---|
509 | if (is_array($p['utilise'])) { |
---|
510 | foreach ($p['utilise'] as $c=>$n) { |
---|
511 | $p['utilise'][$c]['id'] = strtoupper($n['id']); |
---|
512 | } |
---|
513 | $dependances['utilise'] = $p['utilise']; |
---|
514 | } |
---|
515 | |
---|
516 | // Etat numerique (pour simplifier la recherche de maj) |
---|
517 | $num = array('stable'=>4, 'test'=>3, 'dev'=>2, 'experimental'=>1); |
---|
518 | $etatnum = isset($num[$p['etat']]) ? $num[$p['etat']] : 0; |
---|
519 | |
---|
520 | // On passe en utf-8 avec le bon charset les champs pouvant contenir des entites html |
---|
521 | $p['description'] = unicode2charset(html2unicode($p['description'])); |
---|
522 | $p['slogan'] = unicode2charset(html2unicode($p['slogan'])); |
---|
523 | $p['nom'] = unicode2charset(html2unicode($p['nom'])); |
---|
524 | $p['auteur'] = unicode2charset(html2unicode($p['auteur'])); |
---|
525 | $p['licence'] = unicode2charset(html2unicode($p['licence'])); |
---|
526 | |
---|
527 | // Nom, slogan et branche |
---|
528 | if ($p['prefix'] == _SVP_PREFIXE_PLUGIN_THEME) { |
---|
529 | // Traitement specifique des themes qui aujourd'hui sont consideres comme des paquets |
---|
530 | // d'un plugin unique de prefixe "theme" |
---|
531 | $nom = _SVP_NOM_PLUGIN_THEME; |
---|
532 | $slogan = _SVP_SLOGAN_PLUGIN_THEME; |
---|
533 | } |
---|
534 | else { |
---|
535 | // Calcul *temporaire* de la nouvelles balise slogan si celle-ci n'est |
---|
536 | // pas renseignee et de la balise nom. Ceci devrait etre temporaire jusqu'a la nouvelle ere |
---|
537 | // glaciaire des plugins |
---|
538 | // - Slogan : si vide alors on prend la premiere phrase de la description limitee a 255 |
---|
539 | $slogan = (!$p['slogan']) ? svp_remplir_slogan($p['description']) : $p['slogan']; |
---|
540 | // - Nom : on repere dans le nom du plugin un chiffre en fin de nom |
---|
541 | // et on l'ampute de ce numero pour le normaliser |
---|
542 | // et on passe tout en unicode avec le charset du site |
---|
543 | $nom = svp_normaliser_nom($p['nom']); |
---|
544 | } |
---|
545 | |
---|
546 | return array( |
---|
547 | 'plugin' => array( |
---|
548 | 'prefixe' => $p['prefix'], |
---|
549 | 'nom' => $nom, |
---|
550 | 'slogan' => $slogan, |
---|
551 | 'categorie' => $p['categorie'], |
---|
552 | 'tags' => $p['tags']), |
---|
553 | 'paquet' => array( |
---|
554 | 'logo' => $p['icon'], |
---|
555 | 'description' => $p['description'], |
---|
556 | 'auteur' => $p['auteur'], |
---|
557 | 'version' => $p['version'], |
---|
558 | 'version_base' => $p['version_base'], |
---|
559 | 'version_spip' => $v_spip, |
---|
560 | 'etat' => $p['etat'], |
---|
561 | 'etatnum' => $etatnum, |
---|
562 | 'licence' => $p['licence'], |
---|
563 | 'lien' => $p['lien'], |
---|
564 | 'dependances' => serialize($dependances)) |
---|
565 | ); |
---|
566 | } |
---|
567 | |
---|
568 | function svp_remplir_slogan($description) { |
---|
569 | include_spip('inc/texte'); |
---|
570 | |
---|
571 | // On extrait les traductions de l'eventuel multi |
---|
572 | // Si le nom n'est pas un multi alors le tableau renvoye est de la forme '' => 'nom' |
---|
573 | $descriptions = extraire_trads(str_replace(array('<multi>', '</multi>'), array(), $description, $nbr_replace)); |
---|
574 | $multi = ($nbr_replace > 0) ? true : false; |
---|
575 | |
---|
576 | // On boucle sur chaque multi ou sur la chaine elle-meme en extrayant le slogan |
---|
577 | // dans les differentes langues |
---|
578 | $slogan = ''; |
---|
579 | foreach ($descriptions as $_lang => $_descr) { |
---|
580 | $_descr = trim($_descr); |
---|
581 | if (!$_lang) |
---|
582 | $_lang = 'fr'; |
---|
583 | $nbr_matches = preg_match(',^(.+)[.!?\r\n\f],Um', $_descr, $matches); |
---|
584 | $slogan .= (($multi) ? '[' . $_lang . ']' : '') . |
---|
585 | (($nbr_matches > 0) ? trim($matches[1]) : couper($_descr, 150, '')); |
---|
586 | } |
---|
587 | |
---|
588 | if ($slogan) |
---|
589 | // On renvoie un nouveau slogan multi ou pas |
---|
590 | $slogan = (($multi) ? '<multi>' : '') . $slogan . (($multi) ? '</multi>' : ''); |
---|
591 | |
---|
592 | return $slogan; |
---|
593 | } |
---|
594 | |
---|
595 | function svp_normaliser_nom($nom) { |
---|
596 | include_spip('inc/texte'); |
---|
597 | |
---|
598 | // On extrait les traductions de l'eventuel multi |
---|
599 | // Si le nom n'est pas un multi alors le tableau renvoye est de la forme '' => 'nom' |
---|
600 | $noms = extraire_trads(str_replace(array('<multi>', '</multi>'), array(), $nom, $nbr_replace)); |
---|
601 | $multi = ($nbr_replace > 0) ? true : false; |
---|
602 | |
---|
603 | $nouveau_nom = ''; |
---|
604 | foreach ($noms as $_lang => $_nom) { |
---|
605 | $_nom = trim($_nom); |
---|
606 | if (!$_lang) |
---|
607 | $_lang = 'fr'; |
---|
608 | $nbr_matches = preg_match(',(.+)(\s+[\d._]*)$,Um', $_nom, $matches); |
---|
609 | $nouveau_nom .= (($multi) ? '[' . $_lang . ']' : '') . |
---|
610 | (($nbr_matches > 0) ? trim($matches[1]) : $_nom); |
---|
611 | } |
---|
612 | |
---|
613 | if ($nouveau_nom) |
---|
614 | // On renvoie un nouveau nom multi ou pas sans la valeur de la branche |
---|
615 | $nouveau_nom = (($multi) ? '<multi>' : '') . $nouveau_nom . (($multi) ? '</multi>' : ''); |
---|
616 | |
---|
617 | return $nouveau_nom; |
---|
618 | } |
---|
619 | |
---|
620 | |
---|
621 | // ----------------------- Analyses XML --------------------------------- |
---|
622 | |
---|
623 | // parse un fichier de source dont l'url est donnee |
---|
624 | // ce fichier est un fichier XML contenant <depot>...</depot> |
---|
625 | // et <archives>...</archives> |
---|
626 | function svp_xml_parse_depot($url){ |
---|
627 | include_spip('inc/xml'); |
---|
628 | include_spip('inc/distant'); |
---|
629 | |
---|
630 | // On lit le fichier xml |
---|
631 | if (!$xml = recuperer_page($url)) { |
---|
632 | return false; |
---|
633 | } |
---|
634 | |
---|
635 | // On enleve la balise doctype qui provoque une erreur "balise non fermee" lors du parsage |
---|
636 | $xml = preg_replace('#<!DOCTYPE[^>]*>#','',$xml); |
---|
637 | |
---|
638 | // Deux cas d'erreur de fichier non conforme |
---|
639 | // - la syntaxe xml est incorrecte |
---|
640 | // - aucun plugin dans le depot |
---|
641 | // Si le bloc <depot> n'est pas renseigne on ne considere pas cela comme une erreur |
---|
642 | $arbre = array(); |
---|
643 | if (!is_array($arbre = spip_xml_parse($xml)) OR !is_array($archives = $arbre['archives'][0])){ |
---|
644 | return false; |
---|
645 | } |
---|
646 | |
---|
647 | // On extrait les informations du depot si elles existent (balise <depot>) |
---|
648 | $infos = array('depot' => array(), 'paquets' => array()); |
---|
649 | if (is_array($depot = $arbre['depot'][0])) |
---|
650 | $infos['depot'] = svp_xml_aplatit_multiple(array('titre', 'descriptif', 'type', 'url_serveur', 'url_archives'), $depot); |
---|
651 | if (!$infos['depot']['titre']) |
---|
652 | $infos['depot']['titre'] = _T('svp:titre_nouveau_depot'); |
---|
653 | if (!$infos['depot']['type']) |
---|
654 | $infos['depot']['type'] = 'svn'; |
---|
655 | |
---|
656 | // On extrait les informations de chaque plugin du depot (balise <archives>) |
---|
657 | foreach ($archives as $z=>$c){ |
---|
658 | $c = $c[0]; |
---|
659 | // si fichier zip, on ajoute le paquet dans la liste |
---|
660 | // - cas 1 : c'est un plugin donc on integre les infos du plugin |
---|
661 | // - cas 2 : c'est une archive non plugin, pas d'infos autres que celles de l'archive |
---|
662 | if ($url = $c['file'][0]) { |
---|
663 | if (is_array($c['plugin'])) |
---|
664 | $plugin = svp_xml_parse_plugin($c['plugin'][0]); |
---|
665 | else |
---|
666 | $plugin = array(); |
---|
667 | // On remplit les infos dans les deux cas |
---|
668 | $infos['paquets'][$url] = array( |
---|
669 | 'plugin' => $plugin, |
---|
670 | 'file' => $url, |
---|
671 | 'size' => $c['size'][0], |
---|
672 | 'date' => $c['date'][0], // c'est la date de generation du zip |
---|
673 | 'source' => $c['source'][0], |
---|
674 | 'last_commit' => $c['last_commit'][0] |
---|
675 | ); |
---|
676 | } |
---|
677 | } |
---|
678 | |
---|
679 | return $infos; |
---|
680 | } |
---|
681 | |
---|
682 | |
---|
683 | // aplatit plusieurs cles d'un arbre xml dans un tableau |
---|
684 | // effectue un trim() au passage |
---|
685 | function svp_xml_aplatit_multiple($array, $arbre){ |
---|
686 | $a = array(); |
---|
687 | // array('uri','archive'=>'zip',...) |
---|
688 | foreach ($array as $i=>$n){ |
---|
689 | if (is_string($i)) $cle = $i; |
---|
690 | else $cle = $n; |
---|
691 | $a[$n] = trim(spip_xml_aplatit($arbre[$cle])); |
---|
692 | } |
---|
693 | return $a; |
---|
694 | } |
---|
695 | |
---|
696 | |
---|
697 | // parse un plugin.xml genere par spip_xml_parse() |
---|
698 | // en un tableau plus facilement utilisable |
---|
699 | // cette fonction doit permettre de mapper des changements |
---|
700 | // de syntaxe entre plugin.xml et step |
---|
701 | function svp_xml_parse_plugin($arbre){ |
---|
702 | |
---|
703 | if (!is_array($arbre)) |
---|
704 | return false; |
---|
705 | |
---|
706 | // on commence par les simples ! |
---|
707 | $plug_arbre = svp_xml_aplatit_multiple( |
---|
708 | array('nom','icon','auteur','licence','version','version_base','etat','slogan','categorie','tags', |
---|
709 | 'description','lien','options','fonctions','prefix','install'), |
---|
710 | $arbre); |
---|
711 | $plug_arbre['prefix'] = strtolower($plug_arbre['prefix']); |
---|
712 | |
---|
713 | // on continue avec les plus complexes... |
---|
714 | // 1) balises avec attributs |
---|
715 | foreach (array( |
---|
716 | 'necessite'=>array('necessite', null), |
---|
717 | 'utilise'=>array('utilise', null), |
---|
718 | 'chemin'=>array('path', array('dir'=>''))) |
---|
719 | as $balise=>$p){ |
---|
720 | $params = $res = array(); |
---|
721 | // recherche de la balise et extraction des attributs |
---|
722 | if (spip_xml_match_nodes(",^$balise,",$arbre, $res)){ |
---|
723 | foreach(array_keys($res) as $tag){ |
---|
724 | list($tag,$att) = spip_xml_decompose_tag($tag); |
---|
725 | $params[] = $att; |
---|
726 | } |
---|
727 | } |
---|
728 | // valeur par defaut |
---|
729 | else { |
---|
730 | if ($p[1]!==null) |
---|
731 | $params[] = $p[1]; |
---|
732 | } |
---|
733 | $plug_arbre[$p[0]] = $params; |
---|
734 | } |
---|
735 | |
---|
736 | return $plug_arbre; |
---|
737 | } |
---|
738 | |
---|
739 | |
---|
740 | // ----------------------- Recherches de plugins --------------------------------- |
---|
741 | |
---|
742 | function svp_rechercher_plugins_spip($phrase, $categorie, $etat, $depot, $version_spip='', |
---|
743 | $exclusions=array(), $afficher_exclusions=false, $doublon=false, $tri='nom') { |
---|
744 | |
---|
745 | include_spip('inc/rechercher'); |
---|
746 | |
---|
747 | $plugins = array(); |
---|
748 | $scores = array(); |
---|
749 | $ids_paquets = array(); |
---|
750 | |
---|
751 | // On prepare l'utilisation de la recherche en base SPIP en la limitant aux tables spip_plugins |
---|
752 | // et spip_paquets si elle n'est pas vide |
---|
753 | if ($phrase) { |
---|
754 | $liste = liste_des_champs(); |
---|
755 | $tables = array('plugin' => $liste['plugin'], 'paquet' => $liste['paquet']); |
---|
756 | $options = array('jointures' => true, 'score' => true); |
---|
757 | |
---|
758 | // On cherche dans tous les enregistrements de ces tables des correspondances les plugins qui |
---|
759 | // correspondent a la phrase recherchee |
---|
760 | // -- On obtient une liste d'id de plugins et d'id de paquets |
---|
761 | $resultats = array('plugin' => array(), 'paquet' => array()); |
---|
762 | $resultats = recherche_en_base($phrase, $tables, $options); |
---|
763 | // -- On prepare le tableau des scores avec les paquets trouves par la recherche |
---|
764 | if ($resultats) { |
---|
765 | // -- On convertit les id de plugins en id de paquets |
---|
766 | $ids = array(); |
---|
767 | if ($resultats['plugin']) { |
---|
768 | $ids_plugin = array_keys($resultats['plugin']); |
---|
769 | $where[] = sql_in('id_plugin', $ids_plugin); |
---|
770 | $ids = sql_allfetsel('id_paquet, id_plugin', 'spip_paquets', $where); |
---|
771 | } |
---|
772 | // -- On prepare les listes des id de paquet et des scores de ces memes paquets |
---|
773 | if ($resultats['paquet']) { |
---|
774 | $ids_paquets = array_keys($resultats['paquet']); |
---|
775 | foreach ($resultats['paquet'] as $_id => $_score) { |
---|
776 | $scores[$_id] = intval($resultats['paquet'][$_id]['score']); |
---|
777 | } |
---|
778 | } |
---|
779 | // -- On merge les deux tableaux de paquets sans doublon en mettant a jour un tableau des scores |
---|
780 | foreach ($ids as $_ids) { |
---|
781 | $id_paquet = intval($_ids['id_paquet']); |
---|
782 | $id_plugin = intval($_ids['id_plugin']); |
---|
783 | if (array_search($id_paquet, $ids_paquets) === false) { |
---|
784 | $ids_paquets[] = $id_paquet; |
---|
785 | $scores[$id_paquet] = intval($resultats['plugin'][$id_plugin]['score']); |
---|
786 | } |
---|
787 | else { |
---|
788 | $scores[$id_paquet] = intval($resultats['paquet'][$id_paquet]['score']) |
---|
789 | + intval($resultats['plugin'][$id_plugin]['score']); |
---|
790 | } |
---|
791 | } |
---|
792 | } |
---|
793 | } |
---|
794 | |
---|
795 | // Maintenant, on continue la recherche en appliquant, sur la liste des id de paquets, |
---|
796 | // les filtres complementaires : categorie, etat, exclusions et compatibilite spip |
---|
797 | // si on a bien trouve des resultats precedemment ou si aucune phrase n'a ete saisie |
---|
798 | // -- Preparation de la requete |
---|
799 | if (!$phrase OR $resultats) { |
---|
800 | $from = array('spip_plugins AS t1', 'spip_paquets AS t2', 'spip_depots AS t3'); |
---|
801 | $select = array('t1.nom AS nom', 't1.slogan AS slogan', 't1.prefixe AS prefixe', 't1.id_plugin AS id_plugin', |
---|
802 | 't2.id_paquet AS id_paquet', 't2.description AS description', 't2.version_spip AS version_spip', |
---|
803 | 't2.auteur AS auteur', 't2.licence AS licence', 't2.etat AS etat', |
---|
804 | 't2.logo AS logo', 't2.version AS version', 't2.nom_archive AS nom_archive', |
---|
805 | 't3.url_archives AS url_archives', ); |
---|
806 | $where = array('t1.id_plugin=t2.id_plugin', 't2.id_depot=t3.id_depot'); |
---|
807 | if ($ids_paquets) |
---|
808 | $where[] = sql_in('t2.id_paquet', $ids_paquets); |
---|
809 | if (($categorie) AND ($categorie != 'toute_categorie')) |
---|
810 | $where[] = 't1.categorie=' . sql_quote($categorie); |
---|
811 | if (($etat) AND ($etat != 'tout_etat')) |
---|
812 | $where[] = 't2.etat=' . sql_quote($etat); |
---|
813 | if (($depot) AND ($depot != 'tout_depot')) |
---|
814 | $where[] = 't2.id_depot=' . sql_quote($depot); |
---|
815 | if ($exclusions AND !$afficher_exclusions) |
---|
816 | $where[] = sql_in('t2.id_plugin', $exclusions, 'NOT'); |
---|
817 | |
---|
818 | if ($resultats = sql_select($select, $from, $where)) { |
---|
819 | while ($paquets = sql_fetch($resultats)) { |
---|
820 | $prefixe = $paquets['prefixe']; |
---|
821 | $version = $paquets['version']; |
---|
822 | $nom = extraire_multi($paquets['nom']); |
---|
823 | $slogan = extraire_multi($paquets['slogan']); |
---|
824 | $description = extraire_multi($paquets['description']); |
---|
825 | if (svp_verifier_compatibilite_spip($paquets['version_spip'], $version_spip)) { |
---|
826 | // Le paquet remplit tous les criteres, on peut le selectionner |
---|
827 | // -- on utilise uniquement la langue du site |
---|
828 | $paquets['nom'] = $nom; |
---|
829 | $paquets['slogan'] = $slogan; |
---|
830 | $paquets['description'] = $description; |
---|
831 | // -- on ajoute le score si on a bien saisi une phrase |
---|
832 | if ($phrase) |
---|
833 | $paquets['score'] = $scores[intval($paquets['id_paquet'])]; |
---|
834 | else |
---|
835 | $paquets['score'] = 0; |
---|
836 | // -- on construit l'url de l'archive |
---|
837 | $paquets['url_archive'] = $paquets['url_archives'] . '/' . $paquets['nom_archive']; |
---|
838 | // -- on gere les exclusions si elle doivent etre affichees |
---|
839 | if ($afficher_exclusions AND in_array($paquets['id_plugin'], $exclusions)) |
---|
840 | $paquets['installe'] = true; |
---|
841 | else |
---|
842 | $paquets['installe'] = false; |
---|
843 | // -- On traite les doublons (meme plugin, versions differentes) |
---|
844 | if ($doublon) |
---|
845 | // ajout systematique du paquet |
---|
846 | $plugins[] = $paquets; |
---|
847 | else { |
---|
848 | // ajout |
---|
849 | // - si pas encore trouve |
---|
850 | // - ou si sa version est inferieure (on garde que la derniere version) |
---|
851 | if (!$plugins[$prefixe] |
---|
852 | OR ($plugins[$prefixe] AND spip_version_compare($plugins[$prefixe]['version'], $version, '<'))) { |
---|
853 | $plugins[$prefixe] = $paquets; |
---|
854 | } |
---|
855 | } |
---|
856 | } |
---|
857 | } |
---|
858 | } |
---|
859 | |
---|
860 | // On trie le tableau par score décroissant ou nom croissant |
---|
861 | $fonction = 'svp_trier_par_' . $tri; |
---|
862 | if ($doublon) |
---|
863 | usort($plugins, $fonction); |
---|
864 | else |
---|
865 | uasort($plugins, $fonction); |
---|
866 | } |
---|
867 | |
---|
868 | return $plugins; |
---|
869 | } |
---|
870 | |
---|
871 | |
---|
872 | /** |
---|
873 | * Recuperation des id des plugins a exclure car deja installes |
---|
874 | * |
---|
875 | * @return array |
---|
876 | */ |
---|
877 | function svp_lister_plugins_installes(){ |
---|
878 | |
---|
879 | $ids = array(); |
---|
880 | |
---|
881 | // On recupere la liste des plugins installes physiquement sur le site |
---|
882 | // Pour l'instant ce n'est pas possible avec les fonctions natives de SPIP |
---|
883 | // donc on se contente des plugins actifs |
---|
884 | // - liste des prefixes en lettres majuscules des plugins actifs |
---|
885 | include_spip('inc/plugin'); |
---|
886 | $plugins = liste_plugin_actifs(); |
---|
887 | |
---|
888 | // - liste des id de plugin correspondants |
---|
889 | // Il se peut que certains plugins ne soient pas trouves dans la bdd car aucun zip n'est disponible |
---|
890 | // (donc pas inclus dans archives.xml). C'est le cas des extensions du core |
---|
891 | $ids = sql_allfetsel('id_plugin', 'spip_plugins', sql_in('prefixe', array_keys($plugins))); |
---|
892 | $ids = array_map('reset', $ids); |
---|
893 | $ids = array_map('intval', $ids); |
---|
894 | |
---|
895 | return $ids; |
---|
896 | } |
---|
897 | |
---|
898 | |
---|
899 | /** |
---|
900 | * Test de la compatibilite du plugin avec une version donnee de SPIP |
---|
901 | * |
---|
902 | * @return boolean |
---|
903 | */ |
---|
904 | function svp_verifier_compatibilite_spip($version, $version_spip) { |
---|
905 | include_spip('inc/plugin'); |
---|
906 | if (!$version_spip) |
---|
907 | $version_spip = $GLOBALS['spip_version_branche'].".".$GLOBALS['spip_version_code']; |
---|
908 | return plugin_version_compatible($version, $version_spip); |
---|
909 | } |
---|
910 | |
---|
911 | |
---|
912 | /** |
---|
913 | * Tri decroissant des resultats par score. |
---|
914 | * Cette fonction est appelee par un usort ou uasort |
---|
915 | * |
---|
916 | * @return int |
---|
917 | */ |
---|
918 | function svp_trier_par_score($p1, $p2){ |
---|
919 | if ($p1['score'] == $p2['score']) |
---|
920 | $retour = 0; |
---|
921 | else |
---|
922 | $retour = ($p1['score'] < $p2['score']) ? 1 : -1; |
---|
923 | return $retour; |
---|
924 | } |
---|
925 | |
---|
926 | |
---|
927 | /** |
---|
928 | * Tri croissant des resultats par nom. |
---|
929 | * Si le nom est identique on classe par version decroissante |
---|
930 | * Cette fonction est appelee par un usort ou uasort |
---|
931 | * |
---|
932 | * @return int |
---|
933 | */ |
---|
934 | function svp_trier_par_nom($p1, $p2){ |
---|
935 | $c1 = strcasecmp($p1['nom'], $p2['nom']); |
---|
936 | if ($c1 == 0) { |
---|
937 | $c2 = spip_version_compare($p1['version'], $p1['version'], '<'); |
---|
938 | $retour = ($c2) ? 1 : -1; |
---|
939 | } |
---|
940 | else |
---|
941 | $retour = ($c1 < 0) ? -1 : 1; |
---|
942 | return $retour; |
---|
943 | } |
---|
944 | |
---|
945 | ?> |
---|