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