source: spip-zone/_core_/plugins/svp/inc/svp_decider.php @ 61726

Last change on this file since 61726 was 61726, checked in by denisb@…, 7 years ago

svp/inc/svp_decider.php : en lien avec http://core.spip.org/projects/spip/repository/revisions/19474 ajout d'un troisième argument à la fonction plugin_version_compatible()

  • Property svn:eol-style set to native
File size: 23.2 KB
Line 
1<?php
2
3if (!defined("_ECRIRE_INC_VERSION")) return;
4
5include_spip('plugins/installer'); // pour spip_version_compare()
6include_spip('inc/svp_rechercher'); // svp_verifier_compatibilite_spip()
7# include_spip('inc/plugin'); // plugin_version_compatible() [inclu dans svp_rechercher]
8
9class Decideur {
10
11        // plugins actifs en cours avant toute modification
12        var $start = array(
13                'i' => array(),
14                'p' => array(),
15        );
16
17        // plugins actifs a la fin des modifications effectuees
18        var $end = array(
19                'i' => array(),
20                'p' => array(),
21        );
22
23        // plugins procure par SPIP
24        var $procure = array();
25
26        var $ask = array();     // toutes les actions a faire demandees
27        var $todo = array();    // toutes les actions a faire
28        var $changes = array(); // juste les actions a faire en plus de celles demandees
29        var $off = array();     // juste les plugins a arreter
30        var $invalides = array(); // juste les plugins invalides (suite a des dependances introuvables)
31        var $mefiance = false;  // lorsqu'une action entraine des desactivations, mettre ce flag a true !
32
33        var $err = array(); // erreurs rencontrees
34        var $ok = true;     // le resultat permet d'effectuer toutes les actions
35        var $log = false;   // loguer les differents elements
36
37        var $erreur_sur_maj_introuvable = true; // generer une erreur si on demande une mise a jour d'un plugin alors que l'on n'en connait pas.
38
39
40        function Decideur () {
41                include_spip('inc/config');
42                $this->log = (lire_config('svp/mode_log_verbeux') == 'oui');
43        }
44
45
46        /* Liste des plugins deja actifs */
47        function liste_plugins_actifs() {
48                return $this->infos_courtes(array('pa.actif='.sql_quote('oui'),  'pa.attente=' . sql_quote('non')));
49        }
50       
51        /* Liste des plugins en attente */
52        function est_attente_id($id) {
53                static $attente = null;
54                if (is_null($attente)) {
55                        $attente = $this->infos_courtes('pa.attente=' . sql_quote('oui'));
56                }
57                return isset($attente['i'][$id]) ? $attente['i'][$id] : false;
58        }
59
60        /* Liste des plugins procure par SPIP */
61        function liste_plugins_procure() {
62                $procure = array();
63                $get_infos = charger_fonction('get_infos','plugins');
64                $infos['_DIR_RESTREINT'][''] = $get_infos('./',false,_DIR_RESTREINT);
65
66                foreach($infos['_DIR_RESTREINT']['']['procure'] as $_procure) {
67                        $prefixe = strtoupper($_procure['nom']);
68                        $procure[$prefixe] = $_procure['version'];
69                }
70
71                return $procure;
72        }
73
74        function log($quoi) {
75                if ($this->log) {
76                        spip_log($quoi,'decideur');
77                }
78        }
79
80        function infos_courtes_id($id) {
81                // on cache ceux la
82                static $plug = array();
83                if (!isset($plug[$id])) {
84                        $plug[$id] = $this->infos_courtes('pa.id_paquet=' . sql_quote($id));
85                }
86                return $plug[$id];
87        }
88
89        /**
90         * recuperer les infos utiles des plugins
91         * on passe un where et on cree deux tableaux
92         * id (infos)
93         * prefixe (infos)
94         * OU prefixe[] (infos) si multiple=true, classes par etats decroissants.
95         *
96         */
97        function infos_courtes($condition, $multiple=false) {
98                $plugs = array(
99                        'i'=>array(),
100                        'p'=>array()
101                );
102
103                $from = array('spip_paquets AS pa', 'spip_plugins AS pl');
104                $orderby = $multiple ? 'pa.etatnum DESC' : '';
105                $where = array('pa.id_plugin = pl.id_plugin');
106                if (is_array($condition))
107                        $where = array_merge($where, $condition);
108                else
109                        $where[] = $condition;
110
111                include_spip('inc/filtres'); // extraire_multi()
112                $res = sql_allfetsel(array(
113                        'pa.id_paquet AS i',
114                        'pl.nom AS n',
115                        'pl.prefixe AS p',
116                        'pa.version AS v',
117                        'pa.etatnum AS e',
118                        'pa.compatibilite_spip',
119                        'pa.dependances',
120                        'pa.id_depot',
121                        'pa.maj_version AS maj',
122                        'pa.actif AS a'), $from, $where, '', $orderby);
123                foreach ($res as $r) {
124                        $r['p'] = strtoupper( $r['p'] ); // on s'assure du prefixe en majuscule.
125                       
126                        // savoir si un paquet est en local ou non...
127                        $r['local'] = ($r['id_depot']) == 0 ? true : false;
128                        unset($r['id_depot']);
129                       
130                        $d = unserialize($r['dependances']);
131                        // voir pour enregistrer en bdd simplement 'n' et 'u' (pas la peine d'encombrer)...
132                        $deps = array('necessite'=>array(array()), 'utilise'=>array(array()), 'librairie'=>array(array()));
133                        if (!$d) $d = $deps;
134                       
135                        unset($r['dependances']);
136
137                        /*
138                         * On extrait les multi sur le nom du plugin
139                         */
140                        $r['n'] = extraire_multi($r['n']);
141
142                        $plugs['i'][$r['i']] = $r;
143
144                       
145                        // pour chaque type de dependences... (necessite, utilise, librairie)
146                        // on cree un tableau unique [$dependence] = array()
147                        // au lieu de plusieurs tableaux par version de spip
148                        // en ne mettant dans 0 que ce qui concerne notre spip local
149                        foreach($deps as $cle => $defaut) {
150                                if (!isset($d[$cle])) {
151                                        $d[$cle] = $defaut;
152                                }
153                               
154                                // gerer les dependences autres que dans 0 (communs ou local) !!!!
155                                // il peut exister des cles info[dn]["[version_spip_min;version_spip_max]"] de dependences
156                                if (!isset($d[$cle][0]) OR count($d[$cle]) > 1) {
157                                        $dep = array();
158                                        $dep[0] = isset($d[$cle][0]) ? $d[$cle][0] : array();
159                                        unset($d[$cle][0]);
160                                        foreach ($d[$cle] as $version => $dependences) {
161                                                if (svp_verifier_compatibilite_spip($version)) {
162                                                        $dep = array_merge($dep[0], $dependences);
163                                                }
164                                        }
165                                        $d[$cle] = $dep;
166                                }
167                        }
168                        // passer les prefixes en majuscule
169                        foreach($d['necessite'][0] as $i=>$n) {
170                                $d['necessite'][0][$i]['nom'] = strtoupper($n['nom']);
171                        }
172                        $plugs['i'][$r['i']]['dn'] = $d['necessite'][0];
173                        $plugs['i'][$r['i']]['du'] = $d['utilise'][0];
174                        $plugs['i'][$r['i']]['dl'] = $d['librairie'][0];
175
176
177                        if ($multiple) {
178                                $plugs['p'][$r['p']][] = &$plugs['i'][$r['i']]; // alias
179                        } else {
180                                $plugs['p'][$r['p']] = &$plugs['i'][$r['i']]; // alias
181                        }
182                       
183                }
184                return $plugs;
185        }
186
187
188        /* liste des erreurs */
189        function erreur($id, $texte = '') {
190                $this->log("erreur: $id -> $texte");
191                if (!is_array($this->err[$id])) $this->err[$id] = array();
192                $this->err[$id][] = $texte;
193                $this->ok = false;
194        }
195
196        function en_erreur($id) {
197                return isset($this->err[$id]) ? $this->err[$id] : false;
198        }
199
200
201        /* verifier qu'on plugin plus recent existe pour un prefixe et une version donnee */
202        function chercher_plugin_recent($prefixe, $version) {
203                $news = $this->infos_courtes(array('pl.prefixe=' . sql_quote($prefixe), 'pa.obsolete=' . sql_quote('non'), 'pa.id_depot > '.sql_quote(0)), true);
204                $res = false;
205                if ($news and count($news['p'][$prefixe]) > 0) {
206                        foreach ($news['p'][$prefixe] as $new) {
207                                if (spip_version_compare($new['v'],$version,'>')) {
208                                        if (!$res or version_compare($new['v'],$res['v'],'>')) {
209                                                $res = $new;
210                                        }
211                                }
212                        }
213                }
214                return $res;
215        }
216
217        /* verifier qu'un plugin exsite avec prefixe (cfg) pour une version [1.0;] donnee */
218        function chercher_plugin_compatible($prefixe, $version) {
219               
220                // on choisit en priorite dans les paquets locaux !
221                $locaux = $this->infos_courtes(array(
222                        'pl.prefixe=' . sql_quote($prefixe),
223                        'pa.obsolete=' . sql_quote('non'),
224                        'pa.id_depot='.sql_quote(0)), true);
225                if ($locaux and count($locaux['p'][$prefixe]) > 0) {
226                        foreach ($locaux['p'][$prefixe] as $new) {
227                                if (plugin_version_compatible($version, $new['v'],'plug')
228                                and svp_verifier_compatibilite_spip($new['compatibilite_spip']) ){
229                                        return $new;
230                                }
231                        }
232                }
233               
234                // sinon dans les paquets distants
235                $distants = $this->infos_courtes(array(
236                        'pl.prefixe=' . sql_quote($prefixe),
237                        'pa.obsolete=' . sql_quote('non'),
238                        'pa.id_depot>'.sql_quote(0)), true);
239                if ($distants and count($distants['p'][$prefixe]) > 0) {
240                        foreach ($distants['p'][$prefixe] as $new) {
241                                if (plugin_version_compatible($version, $new['v'],'plug')
242                                and svp_verifier_compatibilite_spip($new['compatibilite_spip']) ){
243                                        return $new;
244                                }
245                        }
246                }
247               
248                return false;
249        }
250
251
252        // ajouter a la liste des plugins actifs
253        function add($info) {
254                $this->end['i'][$info['i']] = $info;
255                $this->end['p'][$info['p']] = &$this->end['i'][$info['i']];
256        }
257
258        function off($info, $recur = false) {
259                $this->log('- stopper ' . $info['p']);
260                $this->remove($info);
261                $this->off[$info['p']] = $info;
262
263                // si recursif, on stoppe aussi les plugins dependants
264                if ($recur) {
265                        foreach ($this->end['i'] as $id => $plug) {
266                                if (is_array($plug['dn']) and $plug['dn']) {
267                                        foreach ($plug['dn'] as $n) {
268                                                if ($info['p'] == $n['nom']) {
269                                                        $this->change($plug, 'off');
270                                                        $this->off($plug, true);
271                                                        $this->mefiance = true;
272                                                }
273                                        }
274                                }
275                        }
276                }
277        }
278
279
280        function sera_off($prefixe) {
281                return isset($this->off[$prefixe]) ? $this->off[$prefixe] : false;
282        }
283
284        function sera_off_id($id) {
285                foreach ($this->off as $info) {
286                        if ($info['i'] == $id) {
287                                return $info;
288                        }
289                }
290                return false;
291        }
292
293        function sera_actif($prefixe) {
294                return isset($this->end['p'][$prefixe]) ? $this->end['p'][$prefixe] : false;
295        }
296
297        function sera_actif_id($id) {
298                return isset($this->end['i'][$id]) ? $this->end['i'][$id] : false;
299        }
300
301        // ajouter a la liste des demandes
302        function ask($info, $quoi) {
303                $this->ask[$info['i']] = $info;
304                $this->ask[$info['i']]['todo'] = $quoi;
305                $this->todo($info, $quoi);
306        }
307
308        // ajouter a la liste des changements en plus
309        function change($info, $quoi) {
310                $this->changes[$info['i']] = $info;
311                $this->changes[$info['i']]['todo'] = $quoi;
312                $this->todo($info, $quoi);
313        }
314
315        // pour annuler une action (automatique) qui finalement etait
316        // reellement officielement demandee (cas de mise a 'off' de plugins).
317        function annule_change($info) {
318                unset($this->changes[$info['i']]);
319        }
320
321        // ajouter a la liste des actions
322        function todo($info, $quoi) {
323                $this->todo[$info['i']] = $info;
324                $this->todo[$info['i']]['todo'] = $quoi;
325        }
326
327        // retirer un plugin des actifs
328        function remove($info) {
329                $i = $this->end['p'][$info['p']]; // aucazou ce ne soit pas les memes ids
330                unset($this->end['i'][$info['i']], $this->end['p'][$info['p']], $this->end['i'][$i['i']]);
331        }
332
333        // invalider un plugin...
334        function invalider($info) {
335                $this->log("-> invalider $info[p]");
336                $this->remove($info); // suffisant ?
337                $this->invalides[$info['p']] = $info;
338                $this->annule_change($info);
339                unset($this->todo[$info['i']]);
340        }
341
342        function sera_invalide($p) {
343                return isset($this->invalides[$p]) ? $this->invalides[$p] : false;
344        }
345
346
347        function est_presente_lib($lib) {
348                static $libs = false;
349                if ($libs === false) {
350                        include_spip('inc/svp_outiller');
351                        $libs = svp_lister_librairies();
352                }
353                return isset($libs[$lib]) ? $libs[$lib] : false;
354        }
355
356
357        /* Ajouter les actions demandees */
358        function actionner($todo = null) {
359                if (is_array($todo)) {
360                        foreach ($todo as $id => $t) {
361                                // plusieurs choses nous interessent... Sauf... le simple telechargement
362                                // et la suppression des fichiers (qui ne peuvent etre fait
363                                // que si le plugin n'est pas actif)
364                                $this->log("-- todo: $id/$t");
365
366                                switch ($t) {
367                                        case 'getlib':
368                                                break;
369                                        case 'on':
370                                        case 'geton':
371                                                // ajouter ce plugin dans la liste
372                                                if (!$this->sera_actif_id($id)) {
373                                                        $i = $this->infos_courtes_id($id);
374                                                        if ($i = $i['i'][$id]) {
375                                                                $this->log("--> $t : " . $i['p'] . ' en version : ' . $i['v'] );
376
377                                                                // se mefier : on peut tenter d'activer
378                                                                // un plugin de meme prefixe qu'un autre deja actif
379                                                                // mais qui n'est pas de meme version ou de meme etat
380                                                                // par exemple un plugin obsolete ou un plugin au contraire plus a jour.
381                                                                // dans ce cas, on desactive l'ancien (sans desactiver les dependences)
382                                                                // et on active le nouveau.
383                                                                // Si une dependance ne suit pas, une erreur se produira du coup.
384                                                                if (isset($this->end['p'][ $i['p'] ])) {
385                                                                        $old = $this->end['p'][ $i['p'] ];
386                                                                        $this->log("-->> off : " . $old['p'] . ' en version : ' . $old['v'] );
387                                                                        $this->ask($old, 'off');
388                                                                        $this->todo($old, 'off');
389                                                                        $this->off($old, false); // a priori, les dependences devraient suivre...
390
391                                                                }
392                                                               
393                                                                // pas de prefixe equivalent actif...
394                                                                $this->add($i);
395                                                                $this->ask($i, $i['local'] ? 'on' : 'geton' );
396                                                               
397                                                        } else {
398                                                                // la c'est vraiment pas normal... Erreur plugin inexistant...
399                                                                // concurrence entre administrateurs ?
400                                                                $this->erreur($id, _T('svp:message_nok_plugin_inexistant',array('plugin' => $id)));
401                                                        }
402                                                }
403                                                break;
404                                        case 'up':
405                                        case 'upon':
406                                                // le plugin peut etre actif !
407                                                // ajouter ce plugin dans la liste et retirer l'ancien
408                                                $i = $this->infos_courtes_id($id);
409                                                if ($i = $i['i'][$id]) {
410                                                        $this->log("--> $t : " . $i['p'] . ' en version : ' . $i['v'] );
411
412                                                        // new : plugin a installer
413                                                        if ($new = $this->chercher_plugin_recent($i['p'], $i['v'])) {
414                                                                $this->log("--> maj : " . $new['p'] . ' en version : ' . $new['v'] );
415                                                                // ajouter seulement si on l'active !
416                                                                // ou si le plugin est actuellement actif
417                                                                if ($t == 'upon' or $this->sera_actif_id($id)) {
418                                                                        $this->remove($i);
419                                                                        $this->add($new);
420                                                                }
421                                                                $this->ask($i, $t);
422                                                        } else {
423                                                                if ($this->erreur_sur_maj_introuvable) {
424                                                                        // on n'a pas trouve la nouveaute !!!
425                                                                        $this->erreur($id, _T('svp:message_nok_maj_introuvable',array('plugin' => $i['n'],'id'=>$id)));
426                                                                }
427                                                        }
428                                                } else {
429                                                        // mauvais identifiant ?
430                                                        // on n'a pas trouve le plugin !!!
431                                                        $this->erreur($id, _T('svp:message_erreur_maj_inconnu',array('id'=>$id)));
432                                                }
433                                                break;
434                                        case 'off':
435                                        case 'stop':
436                                                // retirer ce plugin
437                                                // (il l'est peut etre deja)
438                                                if ($info = $this->sera_actif_id($id)
439                                                or  $info_off = $this->sera_off_id($id)
440                                                // un plugin en attente (desactive parce sa dependance a disparu certainement par ftp)
441                                                // peut etre desactive
442                                                or $info = $this->est_attente_id($id)) {
443                                                        // annuler le signalement en "proposition" (due a une mise a 'off' recursive)
444                                                        // de cet arret de plugin, vu qu'on le demande reellement
445                                                        if (!$info) {
446                                                                $info = $info_off;
447                                                                $this->annule_change($info);
448                                                        }
449                                                        $this->log("--> $t : " . $info['p'] . ' en version : ' . denormaliser_version($info['v']) );
450                                                        $this->ask($info, $t);
451                                                        $this->todo($info, $t);
452                                                        $this->off($info, true);
453
454                                                } else {
455                                                        // pas normal... plugin deja inactif...
456                                                        // concurrence entre administrateurs ?
457                                                        $this->erreur($id, _T('svp:message_erreur_plugin_non_actif'));
458                                                }
459                                                break;
460                                        case 'null':
461                                        case 'get':
462                                        case 'kill':
463                                                if ($info = $this->infos_courtes_id($id)) {
464                                                        $this->log("--> $t : " . $info['i'][$id]['p'] . ' en version : ' . $info['i'][$id]['v'] );
465                                                        $this->ask($info['i'][$id], $t);
466                                                } else {
467                                                        // pas normal... plugin inconnu... concurrence entre administrateurs ?
468                                                        $this->erreur($id, _T('svp:message_erreur_plugin_introuvable',array('plugin'=>$id,'action'=>$t)));
469                                                }
470                                                break;
471                                }
472                        }
473                }
474                return $this->ok;
475        }
476
477
478        // ecrire les plugins actifs
479        function start() {
480                $this->start = $this->end = $this->liste_plugins_actifs();
481        $this->procure = $this->liste_plugins_procure();
482        }
483
484        /* Calcul de dependances */
485        function verifier_dependances($todo = null) {
486
487                $this->start();
488
489                // ajouter les actions
490                if (!$this->actionner($todo)) {
491                        $this->log("! Todo en echec !");
492                        $this->log($decideur->err);
493                        return false;
494                }
495
496                // doit on reverifier les dependances ?
497                // oui des qu'on modifie quelque chose...
498                // attention a ne pas boucler infiniment !
499
500                $supersticieux = 0;
501                do {
502                        $try_again = 0;
503                        $supersticieux++;
504
505                        // verifier chaque dependance de chaque plugin a activer
506                        foreach ($this->end['i'] as $info) {
507                                if (!$this->verifier_dependances_plugin($info)) {
508                                        $try_again = true;
509                                }
510                        }
511                        unset($id, $info);
512                        $this->log("--------> try_again: $try_again, supersticieux: $supersticieux");
513                } while ($try_again > 0 and $supersticieux < 100); # and !count($this->err)
514
515                $this->log("Fin !");
516                $this->log("Ok: " . $this->ok);
517                # $this->log($this->todo);
518
519                return $this->ok;
520        }
521
522
523
524        function verifier_dependances_plugin($info, $prof=0) {
525                $this->log("- [$prof] verifier dependances " . $info['p']);
526                $id = $info['i'];
527
528                $cache = array(); // cache des actions realisees dans ce tour
529
530                // 1
531                // tester la version de SPIP de notre paquet
532                // si on ne valide pas, on retourne une erreur !
533                // mais normalement, on ne devrait vraiment pas pouvoir tomber sur ce cas
534                if (!svp_verifier_compatibilite_spip($info['compatibilite_spip'])) {
535                        $this->invalider($info);
536                        $this->erreur($id, _T('svp:message_incompatibilite_spip',array('plugin'=>$info['n'])));
537                        return false;
538                }
539
540                // 2
541                // ajouter les librairies necessaires a notre paquet
542                if (is_array($info['dl']) and count($info['dl'])) {
543                        $err = false;
544                        foreach ($info['dl'] as $l) {
545                                // $l = array('nom' => 'x', 'lien' => 'url')
546                                $lib = $l['nom'];
547                                $this->log("## Necessite la librairie : " . $lib );
548
549                                // on verifie sa presence OU le fait qu'on pourra la telecharger
550                                if ($lib and !$this->est_presente_lib($lib)) {
551                                        // peut on ecrire ?
552                                        if (!is_writable(_DIR_LIB)) {
553                                                $this->invalider($info);
554                                                $this->erreur($id, _T('svp:message_erreur_ecriture_lib', array('plugin'=>$info['n'], 'lib_url'=>$l['lien'], 'lib'=>$lib)));
555                                                $err = true;
556                                        }
557                                        // ajout, pour info
558                                        // de la librairie dans la todo list
559                                        else {
560                                                $this->change(array(
561                                                        'i' => md5(serialize($l)),
562                                                        'p' => $lib,
563                                                        'n' => $lib,
564                                                        'v' => $l['lien'],
565                                                ), 'getlib');
566                                                $this->log("- La librairie $lib sera a télécharger");
567                                        }
568                                }
569                        }
570                        if ($err) {
571                                return false;
572                        }
573                }
574
575                // 3
576                // Trouver les dependences aux necessites
577                // et les activer au besoin
578                if (is_array($info['dn']) and count($info['dn'])) {
579                        foreach ($info['dn'] as $n) {
580
581                                $p = $n['nom'];
582                                $v = $n['compatibilite'];
583
584                                if ($p == 'SPIP') {
585                                        // c'est pas la que ça se fait !
586                                        // ca ne devrait plus apparaitre comme dependence a un plugin.
587                                }
588
589                                // le core procure le paquet que l'on demande !
590                                elseif ((array_key_exists($p, $this->procure))
591                                  and (plugin_version_compatible($v, $this->procure[$p]))) {
592                                        // rien a faire...
593                                        $this->log("-- est procure par le core ($p)");
594
595                                }
596
597                                // pas d'autre alternative qu'un vrai paquet a activer
598                                else {
599                                        $this->log("-- verifier : $p");
600                                        // nous sommes face a une dependance de plugin
601                                        // on regarde s'il est present et a la bonne version
602                                        // sinon on le cherche et on l'ajoute
603                                        if ($ninfo = $this->sera_actif($p)
604                                        and !$err = $this->en_erreur($ninfo['i'])
605                                        and plugin_version_compatible($v, $ninfo['v'],'plug')) {
606                                                // il est deja actif ou a activer, et tout est ok
607                                                $this->log('-- dep OK pour '.$info['p'].' : '.$p);
608                                        }
609                                        // il faut le trouver et demander a l'activer
610                                        else {
611                                       
612                                                // absent ou erreur ou pas compatible
613                                                $etat = $err ? 'erreur' : ($ninfo ? 'conflit' : 'absent');
614                                                // conflit signifie qu'il existe le prefixe actif, mais pas a la version demandee
615                                                $this->log("Dedendance " . $p . " a resoudre ! ($etat)");
616
617                                                switch ($etat) {
618                                                        // commencons par le plus simple :
619                                                        // en cas d'absence, on cherche ou est ce plugin !
620                                                        case 'absent':
621                                                                // on choisit par defaut le meilleur etat de plugin.
622                                                                // de preference dans les plugins locaux, sinon en distant.
623                                                                if (!$this->sera_off($p)
624                                                                and $new = $this->chercher_plugin_compatible($p, $v)
625                                                                and $this->verifier_dependances_plugin($new, ++$prof)) {
626                                                                        // si le plugin existe localement et possede maj_version,
627                                                                        // c'est que c'est peut etre une mise a jour + activation a faire
628                                                                        // si le plugin
629                                                                        // nouveau est local   => non
630                                                                        // nouveau est distant => oui peut etre
631                                                                        $cache[] = $new;
632                                                                        $i = array();
633                                                                        if (!$new['local']) {
634                                                                                $i = $this->infos_courtes(array(
635                                                                                                'pl.prefixe=' . sql_quote($new['p']),
636                                                                                                'pa.maj_version=' . sql_quote($new['v'])
637                                                                                        ), true);
638                                                                        }
639                                                                        if ($i and isset($i['p'][$new['p']]) and count($i['p'][$new['p']])) {
640                                                                                // c'est une mise a jour
641                                                                                $vieux = $i['p'][$new['p']][0];
642                                                                                $this->change($vieux, 'upon');
643                                                                                $this->log("-- update+active : $p");
644                                                                        } else {
645                                                                                // tout nouveau tout beau
646                                                                                $this->change($new, $new['local'] ? 'on' : 'geton');
647                                                                                if ($new['local']) {
648                                                                                        $this->log("-- nouveau present : $p");
649                                                                                } else {
650                                                                                        $this->log("-- nouveau distant : $p");
651                                                                                }
652                                                                        }
653                                                                        $this->add($new);
654                                                                } else {
655                                                                        $this->log("-- !erreur : $p");
656                                                                        // on ne trouve pas la dependance !
657                                                                        $this->invalider($info);
658                                                                        $this->erreur($id, $v ? _T('svp:message_dependance_plugin_version',array('plugin'=>$info['n'],'dependance'=>$p,'version'=>denormaliser_version($v))) : _T('svp:message_dependance_plugin',array('plugin'=>$info['n'],'dependance'=>$p)));
659                                                                }
660                                                                unset($new, $vieux);
661                                                                break;
662
663                                                        case 'erreur':
664                                                                break;
665
666                                                        // present, mais conflit de version
667                                                        // de deux choses l'une :
668                                                        // soit on trouve un paquet meilleur...
669                                                        // soit pas :)
670                                                        case 'conflit':
671                                                                $this->log("  conflit -> demande $v, present : " . $ninfo['v']);
672                                                                if (!$this->sera_off($p)
673                                                                and $new = $this->chercher_plugin_compatible($p, $v)
674                                                                and $this->verifier_dependances_plugin($new, ++$prof)) {
675                                                                        // on connait le nouveau...
676                                                                        $cache[] = $new;
677                                                                        $this->remove($ninfo);
678                                                                        $this->add($new);
679                                                                        $this->change($ninfo,'up');
680                                                                        $this->log("-- update : $p");
681                                                                } else {
682                                                                        $this->log("-- !erreur : $p");
683                                                                        // on ne trouve pas la dependance !
684                                                                        $this->invalider($info);
685                                                                        $this->erreur($id, $v ? _T('svp:message_dependance_plugin_version',array('plugin'=>$info['n'],'dependance'=>$p,'version'=>denormaliser_version($v))) : _T('svp:message_dependance_plugin',array('plugin'=>$info['n'],'dependance'=>$p)));
686                                                                }
687                                                                break;
688                                                }
689
690                                        } 
691                                }
692
693                                if ($this->sera_invalide($info['p'])) {
694                                        break;
695                                }
696                        }
697                        unset($n, $v, $p, $ninfo, $present, $conflit, $erreur, $err);
698
699                        // si le plugin est devenu invalide...
700                        // on invalide toutes les actions qu'on vient de faire !
701                        if ($this->sera_invalide($info['p'])) {
702                                $this->log("> Purge du cache");
703                                foreach ($cache as $i) {
704                                        $this->invalider($i);
705                                }
706                                return false;
707                        }
708                }
709                return true;
710        }
711
712        function presenter_actions($quoi) {
713                $res = array();
714                foreach ($this->$quoi as $id=>$info) {
715                        $res[] = _T('svp:message_action_'.$info['todo'], array(
716                                'plugin'=>$info['n'],
717                                'version'=>denormaliser_version($info['v']),
718                                'version_maj'=>denormaliser_version($info['maj'])));
719                }
720                return $res;
721        }
722}
723
724
725/**
726 * Simplification pour la partie verifier
727 * des formulaires utilisant le decideur
728 *
729 * @param array $a_actionner Tableau des actions par paquet (id_paquet => action)
730 * @param array $erreurs Tableau d'erreurs de verifier (CVT)
731 * @return bool Operation ok.
732**/
733function svp_decider_verifier_actions_demandees($a_actionner, &$erreurs) {
734        $decideur = new Decideur;
735        $decideur->erreur_sur_maj_introuvable = false;
736        $decideur->verifier_dependances($a_actionner);
737
738        if (!$decideur->ok) {
739                $erreurs['decideur_erreurs'] = array();
740                foreach ($decideur->err as $id=>$errs) {
741                        foreach($errs as $err) {
742                                $erreurs['decideur_erreurs'][] = $err;
743                        }
744                }
745                return false;
746        }
747
748        $erreurs['decideur_propositions']       = $decideur->presenter_actions('changes');
749        $erreurs['decideur_demandes']           = $decideur->presenter_actions('ask');
750        $erreurs['decideur_actions']            = $decideur->presenter_actions('todo');
751
752        // On construit la liste des actions pour la passer au formulaire en hidden
753        $todo = array();
754        foreach ($decideur->todo as $_todo) {
755                $todo[$_todo['i']] = $_todo['todo'];
756        }
757        set_request('_todo', serialize($todo));
758        return true;
759}
760?>
Note: See TracBrowser for help on using the repository browser.