source: spip-zone/_plugins_/_stable_/cfg/inc/cfg_formulaire.php @ 22620

Last change on this file since 22620 was 22620, checked in by fil@…, 11 years ago

recuperer_fond('../plugins/xxx/fonds/cfg_truc') provoque une erreur de chemin lorsqu'on le cherche a partir de ecrire/ (et donc ../ dans le chemin)

File size: 22.7 KB
Line 
1<?php
2
3
4/*
5 * Plugin CFG pour SPIP
6 * (c) toggg 2007, distribue sous licence GNU/GPL
7 * Documentation et contact: http://www.spip-contrib.net/
8 *
9 */
10
11if (!defined("_ECRIRE_INC_VERSION")) return;
12
13
14
15// la classe cfg represente une page de configuration
16class cfg_formulaire{
17
18// les parametres des formulaires cfg sont stockes dans cet objet
19        var $param;
20// l'objet de classe cfg_depot qui assure lecture/ecriture/effacement des config
21        var $depot = null;
22// le fond html utilise , en general pour config simple idem $nom
23        var $vue = '';
24// l'adresse du fond html (sans l'extension .html)
25        var $path_vue = '';
26// provient-on d'un formulaire de type CVT (charger/verifier/traiter) dans formulaires/ ?
27        var $depuis_cvt = false;
28// compte-rendu des mises a jour
29        var $messages = array('message_ok'=>array(), 'message_erreur'=>array(), 'erreurs'=>array());
30// les champs trouve dans le fond
31        var $champs = array();
32// les champs index
33        var $champs_id = array();
34// leurs valeurs
35        var $val = array();
36// pour tracer les valeurs modifiees
37        var $log_modif = '';
38// contenu du fichier de formulaire
39        var $controldata ='';
40// stockage du fond compile par recuperer_fond()
41        var $fond_compile = '';
42// y a t-il des extensions (classes css 'type_{nom}' ou 'cfg_{nom}' sur champs) a traiter ?
43        var $extensions = array();
44
45// Alias pour passer facilement les parametres aux classes appelees
46        var $params = array();
47
48        //
49        // Constructeur de la classe
50        //
51        function cfg_formulaire($nom, $cfg_id = '', $opt = array())
52        {
53                $this->param = array(
54                        'afficher_messages' => true, // afficher ce compte rendu ?
55                        'autoriser' => 'configurer',    // le "faire" de autoriser($faire), par defaut, autoriser_configurer_dist()     
56                        'autoriser_absence_id' => 'non', // autoriser l'insertion de nouveau contenu dans une table sans donner d'identifiant ?
57                        'casier' => '', // sous tableau optionel du meta ou va etre stocke le fragment de config
58                        'cfg_id' => '', // pour une config multiple , l'id courant
59                        'descriptif' => '', // descriptif
60                        'depot' => 'metapack', // (ancien 'storage') le depot utilise pour stocker les donnees, par defaut metapack: spip_meta serialise
61                        'fichier' => '', // pour storage php, c'est l'adresse du fichier (depuis la racine de spip), sinon ca prend /local/cfg/nom.php
62                        'head' => '', // partie du fond cfg a inserer dans le head par le pipeline header_prive (todo insert_head?)
63                        'icone' => '', // lien pour une icone
64                        'inline' => '', // code qui sera insere apres le contenu du fond (peut servir pour inserer du js)
65                        'interpreter' => 'oui', // si interpreter vaut 'non', le fond ne sera pas traite comme un fond cfg, mais comme une inclusion simple (pas de recherche des champs de formulaires). Cela permet d'utiliser des #FORMULAIRES_XX dans un fonds/ tout en utilisant la simplicite des parametres <!-- liens=.. --> par exemple.
66                        'liens' => array(), // liens optionnels sur des sous-config <!-- liens*=xxx -->
67                        'liens_multi' => array(), // liens optionnels sur des sous-config pour des fonds utilisant un champ multiple  <!-- liens_multi*=xxx -->
68                        'nom' => '', // le nom du meta (ou autre) ou va etre stocke la config concernee
69                        'onglet' => 'oui', // cfg doit-il afficher un lien vers le fond sous forme d'onglet dans la page ?exec=cfg
70                        'presentation' => 'auto', // cfg doit-il encadrer le formulaire tout seul ?
71                        'refus' => '', // en cas de refus d'autorisation, un message informatif [(#REM) refus=...]
72                        'table' => '', // nom de la table sql pour storage extra ou table
73                );
74                $this->param['nom'] = $this->vue = $nom;
75                $this->param['cfg_id'] = $cfg_id;
76               
77                // definition de l'alias params
78                $this->params = array(
79                        'champs' => &$this->champs, 
80                        'champs_id' => &$this->champs_id,
81                        'messages' => &$this->messages,
82                        'val' => &$this->val,
83                        'param' => &$this->param
84                );     
85               
86                foreach ($opt as $o=>$v) {
87                        $this->$o = $v;
88                }   
89                // charger les donnees du fond demande
90                $this->charger();
91        }
92
93               
94        // retourne true en cas d'erreur...
95        function erreurs(){
96                return $this->messages['erreurs'] || $this->messages['message_erreur'];
97        }
98       
99        // ajoute une erreur sur un champ donne
100        function ajouter_erreur($champ, $message) {
101                $this->messages['erreurs'][$champs] = isset($this->messages['erreurs'][$champs]) 
102                        ? $this->messages['erreurs'][$champs] .= '<br />' . $message
103                        : $message;
104        }
105       
106        // ajoute des erreurs sur les champs indiques dans le tableau
107        // (comme verifier de cvt)
108        function ajouter_erreurs($err) {
109                if (!is_array($err)) return false;
110                if (isset($err['message_erreur']) && $err['message_erreur']) 
111                        $this->messages['message_erreur'][] = $err['message_erreur'];
112                if (isset($err['message_ok']) && $err['message_ok'])   
113                        $this->messages['message_ok'][] = $err['message_ok'];
114                unset($err['message_erreur'], $err['message_ok']);
115                if ($err) $this->messages['erreurs'] = $err;            // ou un merge ?? //
116                return true;
117        }
118       
119       
120        // pre-analyser le formulaire
121        // c'est a dire recuperer les parametres CFG
122        // et les noms des champs du formulaire
123        function charger(){
124                $ok = true;
125               
126                // si pas de fichier, rien a charger
127                if (!$this->vue) return false;
128
129                // lecture de la vue (fond cfg)
130                // il s'agit de recuperer le contenu du fichier
131                if (!$fichier = find_in_path($nom = 'fonds/cfg_' . $this->vue .'.html')){
132                        if ($fichier = find_in_path($nom = 'formulaires/' . $this->vue .'.html'))
133                                $this->depuis_cvt = true;
134                }
135               
136                // si pas de fichier, rien a charger
137                if (!$fichier) return false;
138               
139                if (!lire_fichier($fichier, $this->controldata)) {
140                        $ok = false;
141                        $this->messages['message_erreur'][] =  _T('cfg:erreur_lecture', array('nom' => $nom));
142                } else {
143                        $this->path_vue = substr($fichier,0,-5);
144                }               
145
146                // recherche et stockage des parametres de cfg
147                $this->recuperer_parametres();
148
149                // si le fond ne doit pas etre calcule comme un fond CFG,
150                // on s'arrete ici. De cette maniere, CFG ne prendra pas
151                // comme des champs a recuperer les champs issus d'un autre formulaire
152                // CFG inclu depuis un formulaire CVT via #FORMULAIRE_XX
153                if ($this->param['interpreter'] == 'non')
154                        return true;
155                       
156                // recherche et stockage des noms de champs de formulaire
157                if ($err = $this->recuperer_noms_champs()){
158                        $ok = false;
159                        $this->messages['message_erreur'][] = $err;
160                }
161           
162                // charger les champs particuliers si existants
163                $this->actionner_extensions('pre_charger');       
164                 
165                // creer le storage et lire les valeurs
166                $this->param['depot'] = strtolower(trim($this->param['depot']));
167                include_spip('inc/cfg_config');
168                $this->depot = new cfg_depot($this->param['depot'], $this->params);
169                $ok &= $this->lire();
170
171                // charger les champs particuliers si existants
172                $this->actionner_extensions('charger');
173               
174                return $ok;
175        }
176
177
178        //
179        // Doit controler la validite des valeurs transmises
180        //
181        // Verifie les valeurs postees.
182        // - stocke les valeurs qui ont changees dans $this->val[$nom_champ] = 'nouvelle_valeur'
183        // - verifie que les types de valeurs attendus sont corrects ($this->verifier_champs_types)
184        //
185        // retourne les messages d'erreur
186        //
187        function verifier() {
188
189                if ($this->erreurs() || !$this->autoriser()) 
190                                return false;
191
192                // si on a pas poste de formulaire, pas la peine de controler
193                // ce qui mettrait de fausses valeurs dans l'environnement
194                if  (!_request('_cfg_ok') && !_request('_cfg_delete')) return true;
195
196                // les formulaires CVT ont deja leurs securites
197                if (!$this->depuis_cvt) {
198                        $securiser_action = charger_fonction('securiser_action', 'inc');
199                        $securiser_action();
200                }
201
202                // actions par champs speciaux, avant les tests des nouvelles valeurs
203                $this->actionner_extensions('pre_verifier');
204               
205                // stockage des nouvelles valeurs
206                foreach ($this->champs as $name => $def) {
207                        // enregistrement des valeurs postees
208                        $oldval = $this->val[$name];
209                    $this->val[$name] = _request($name);
210                   
211                    // tracer les modifications
212                    if ($oldval != $this->val[$name]) {
213                        $this->log_modif .= $name . ':' . var_export($oldval, true) . '/' . var_export($this->val[$name], true) .', ';
214                    }
215                }
216           
217                // si pas de changement, pas la peine de continuer
218                if (!$this->log_modif && !_request('_cfg_delete')) {
219                        $this->messages['message_erreur'][] = _T('cfg:pas_de_changement', array('nom' => $this->nom_config()));
220                        return false;
221                }
222               
223                // verifier la validite des champs speciaux (cfg_xx, type_xx)
224                $this->actionner_extensions('verifier');
225               
226                // stocker le fait que l'on a controle les valeurs
227                $this->verifier = true;
228            return !$this->erreurs();
229        }
230       
231
232       
233        //
234        // Gere le traitement du formulaire.
235        //
236        // Si le chargement ou le controle n'ont pas ete fait,
237        // la fonction s'en occupe.
238        //
239        //
240        function traiter()
241        {
242                if (!$this->verifier) $this->verifier();
243               
244                if ($this->erreurs() || !$this->autoriser()) return false;
245       
246                if (!_request('_cfg_ok') && !_request('_cfg_delete')) return false;
247               
248                // les formulaires CVT ont deja leurs securites
249                if (!$this->depuis_cvt) {
250                        $securiser_action = charger_fonction('securiser_action', 'inc');
251                        $securiser_action();
252                }
253               
254                $this->actionner_extensions('pre_traiter');     
255               
256                if ($this->erreurs()) return false;             
257                       
258                // suppression
259                if (_request('_cfg_delete')) {
260                        $this->effacer();
261               
262                // sinon modification
263                } else {
264                        $this->ecrire();
265                }
266
267                // pipeline 'cfg_post_edition' ? (quelqu'un utilise ??)
268                $this->messages = pipeline('cfg_post_edition',array('args'=>array('nom_config'=>$this->nom_config()),'data'=>$this->messages));
269
270                $this->actionner_extensions('post_traiter');
271        }
272
273
274
275
276        //
277        // Determine l'arborescence ou CFG doit chercher les valeurs deja enregistrees
278        // si nom=toto, casier=chose/truc, cfg_id=2,
279        // cfg cherchera dans #CONFIG{toto/chose/truc/2}
280        //
281        function nom_config()
282        {
283            return $this->param['nom'] . 
284                        ($this->param['casier'] ? '/' . $this->param['casier'] : '') .
285                        ($this->param['cfg_id'] ? '/' . $this->param['cfg_id'] : '');
286        }
287
288
289
290        //
291        // Recherche et stockage
292        // des parametres #REM passes a CFG
293        // (DEPRECIE)
294        //
295        function recuperer_parametres_rem(){
296                // cas de #REM (deprecie)
297                preg_replace_callback('/(\[\(#REM\) ([a-z0-9_]\w+)(\*)?=)(.*?)\]/sim',
298                                        array(&$this, 'post_params'), $this->controldata);
299        }
300       
301       
302        // cette fonction recherche et stocke les parametres passes a cfg par <!-- param=valeur -->
303        // ces lignes sont alors effacees du code html. Ces proprietes sont lues apres recuperer_fond(),
304        // et interpretent donc les balises spip et les chaines de langues
305        //
306        // si la fonction est appelee 2 fois, les parametres identiques ne seront pas copies
307        // sauf si le parametre est un tableau (<!-- param*=valeur -->), les valeurs seront dupliquees
308        function recuperer_parametres(){
309
310                // pour compatibilite, recuperer l'ancien code #REM
311                $this->recuperer_parametres_rem();     
312               
313                $this->recuperer_fond();
314                $this->fond_compile = preg_replace_callback('/(<!-- ([a-z0-9_]\w+)(\*)?=)(.*?)-->/sim',
315                                                        array(&$this, 'post_params'), $this->fond_compile);
316
317                // s'il en reste : il y a un probleme !
318                // est-ce utile de tester ça ?
319                if (preg_match('/<!-- [a-z0-9_]\w+\*?=/', $this->fond_compile)) {
320                        die('Un parametre CFG n\'a pas pu etre importe depuis '.$this->vue);
321                }
322
323                // pour compatibilite avec les anciennes versions (<1.4.1)
324                if (isset($this->param['storage'])) 
325                        $this->param['depot'] = $this->param['storage'];
326               
327                if ($this->param['depot'] == 'classic')
328                        $this->param['depot'] = 'meta';
329                       
330                if ($this->param['depot'] == 'extrapack'){
331                        $this->param['depot'] = 'tablepack';
332                        $this->param['colonne'] = 'extra';
333                        $this->param['table'] = 'spip_auteurs';
334                }
335               
336                // definir les parametres qui sont a traiter comme des extensions
337                // il faut que le parametre ne soit pas vide et qu'un fichier
338                // /cfg/params/{param}.php existe
339                $this->extensions_parametres = array();
340                foreach ($this->param as $nom=>$val){
341                        if ($val) $this->ajouter_extension_parametre($nom);             
342                }
343        }
344       
345       
346        // une fonction pour effacer les parametres du code html
347        // ce qui evite de dupliquer les tableaux
348        // (si on utilisait recuperer_parametres() a la place)
349        function effacer_parametres(){
350                $this->fond_compile = preg_replace('/(<!-- ([a-z0-9_]\w+)(\*)?=)(.*?)-->/sim', '', $this->fond_compile);               
351        }
352       
353       
354       
355        //
356        // Recherche  des noms des champs (y) du formulaire
357        // <input type="x" name="y"... />
358        // stockes dans le tableau $this->champs
359        // a l'exception des noms par _cfg_, reserves a ce plugin
360        //
361        function recuperer_noms_champs(){       
362                if (!$this->vue) return;
363
364                // recherche d'au moins un champ de formulaire pour savoir si la vue est valide
365                $this->recuperer_fond();
366                if (!preg_match_all(
367                /*  '#<(?:(select|textarea)|input type="(text|password|checkbox|radio|hidden|file)") name="(\w+)(\[\])?"(?: class="[^"]*?(?:type_(\w+))?[^"]*?(?:cfg_(\w+))?[^"]*?")?( multiple=)?[^>]*?>#ims', */
368                  '#<(?:(select|textarea)|input type="(text|password|checkbox|radio|hidden|file)") name="(\w+)(\[\])?"(?: class="([^"]*)")?( multiple=)?[^>]*?>#ims',
369                                                $this->fond_compile, $matches, PREG_SET_ORDER)) {
370                        return _T('cfg:pas_de_champs_dans', array('nom' => $this->vue));
371                }
372               
373                foreach ($matches as $regs) {
374                        $name = $regs[3];
375                        if (substr($name, 0, 5) == '_cfg_') continue;
376
377                        $this->champs[$name] = array('balise' => $regs[1]); 
378                        // input type
379                    if ($regs[2]) $this->champs[$name]['type'] = $regs[2];
380                    // champs tableau[]
381                        if ($regs[4]) $this->champs[$name]['tableau'] = true;
382
383                        //
384                        // Extensions et validations des champs
385                        // via les classes css
386                        //
387                        // attention : ordre important : <balise (type="xx")? name="xx" class="xx" multiple="xx" />
388                        //
389                        if ($regs[5]) {
390                                $tcss = explode(' ',trim($regs[5]));
391                                foreach($tcss as $css){
392                                        // classes css type_xx
393                                        if (substr($css,0,5)=='type_') {
394                                                $this->ajouter_extension($css, $name);
395                                        // classes css cfg_xx
396                                        } elseif (substr($css,0,4)=='cfg_') {
397                                                $this->champs[$name]['cfg'] = substr($css,4); // juste 'id' si classe = cfg_id
398                                                $this->ajouter_extension($css, $name);
399                                        }
400                                }
401                        }
402                       
403                        // cas particulier automatiques :
404                        // * input type file => type de verification : fichier
405                        if (($regs[2] == 'file') AND (!$this->champs[$name]['cfg'])){
406                                $this->champs[$name]['cfg'] = 'fichier';
407                                $this->ajouter_extension('cfg_fichier', $name); 
408                        }
409                       
410            }
411
412            return '';
413        }       
414       
415        // ajoute une extension (classe cfg_xx ou type_xx)
416        // ce qui dit a cfg d'executer des fonctions particulieres
417        // si elles existent : ex: cfg_traiter_cfg_xx()
418        // lors de l'appel de 'actionner_extensions($faire)'
419        function ajouter_extension($ext, $nom){
420                if (!is_array($this->extensions[$ext])) $this->extensions[$ext] = array();
421                $this->extensions[$ext][] = $nom;       
422        }
423       
424        // ajoute une extension sur un parametre
425        // seulement si un fichier sur ce parametre existe
426        function ajouter_extension_parametre($param){
427                if (in_array($param, $this->extensions_parametres))
428                        return true;
429               
430                if (find_in_path('cfg/params/'.$param.'.php')){
431                        $this->extensions_parametres[] = $param;
432                        return true;
433                }
434                return false;
435        }
436       
437       
438        //
439        // Compiler le fond CFG si ce n'est pas fait
440        //
441        function recuperer_fond($contexte = array(), $forcer = false){
442
443                if (!$this->fond_compile OR $forcer){
444                        include_spip('inc/presentation'); // offrir les fonctions d'espace prive
445                        include_spip('public/assembler');
446                       
447                        // rendre editable systematiquement
448                        // sinon, ceux qui utilisent les fonds CFG avec l'API des formulaires dynamiques
449                        // et mettent des [(#ENV**{editable}|oui) ... ] ne verraient pas leurs variables
450                        // dans l'environnement vu que CFG ne pourrait pas lire les champs du formulaire
451                        if ($this->depuis_cvt)
452                                if (!isset($contexte['editable'])) $contexte['editable'] = true; // plante 1.9.2 !!
453                       
454                        // passer cfg_id...
455                        if (!isset($contexte['cfg_id']) && $this->param['cfg_id']) {
456                                $contexte['cfg_id'] = $this->param['cfg_id'];
457                        }
458                        // passer id aussi
459                        if (!isset($contexte['id']) && $this->param['cfg_id']) {
460                                $contexte['id'] = $this->param['cfg_id'];
461                        }
462                        // passer 'message_ok', 'message_erreur', 'erreurs'     
463                        if (!isset($contexte['message_ok']) && $this->messages['message_ok']) {
464                                $contexte['message_ok'] = join('<br />',$this->messages['message_ok']);
465                        }
466                        if (!isset($contexte['message_erreur']) && $this->messages['message_erreur']) {
467                                $contexte['message_erreur'] = join('<br />',$this->messages['message_erreur']);
468                        }
469                        if (!isset($contexte['erreurs']) && $this->messages['erreurs']) {
470                                $contexte['erreurs'] = $this->messages['erreurs'];
471                        }
472                       
473                        $val = $this->val ? array_merge($contexte, $this->val) : $contexte;
474
475                        // si on est dans l'espace prive, $this->path_vue est
476                        // de la forme ../plugins/mon_plugin/fonds/toto, d'ou le replace
477                        $this->fond_compile = recuperer_fond(
478                                substr($this->path_vue, strlen(_DIR_RACINE)), $val);
479                }
480                return $this->fond_compile;
481        }
482       
483       
484        //
485        // Verifie les autorisations
486        // d'affichage du formulaire
487        // (parametre autoriser=faire)
488        //
489        function autoriser()
490        {
491                static $autoriser=-1;
492                if ($autoriser !== -1) return $autoriser;
493
494                // on peut passer 'oui' ou 'non' directement au parametre autoriser
495                if ($this->param['autoriser'] == 'oui')
496                        return $autoriser = 1;
497                if ($this->param['autoriser'] == 'non') {
498                        $this->messages['message_refus'] = $this->param['refus'];
499                        return $autoriser = 0;
500                }
501                // sinon, test de l'autorisation
502                // <!-- autoriser=webmestre -->
503                // <!-- autoriser=configurer -->
504                include_spip('inc/autoriser');
505                if (!$autoriser = autoriser($this->param['autoriser'])){
506                        $this->messages['message_refus'] = $this->param['refus'];
507                }
508                return $autoriser;
509        }
510
511
512        //
513        // Log le message passe en parametre
514        // $this->log('message');
515        //
516        function log($message)
517        {
518                ($GLOBALS['auteur_session'] && ($qui = $GLOBALS['auteur_session']['login']))
519                || ($qui = $GLOBALS['ip']);
520                spip_log('cfg (' . $this->nom_config() . ') par ' . $qui . ': ' . $message);
521        }
522       
523       
524        // lit les donnees depuis le depot
525        function lire(){
526                list ($ok, $val, $messages) = $this->depot->lire($this->params);
527                if ($messages) $this->messages = $messages;
528                if ($ok) {
529                        $this->val = $val;     
530                } else {
531                        $this->messages['message_erreur'][] = _T('cfg:erreur_lecture', array('nom' => $this->nom_config()));
532                }
533                return $ok;
534        }
535       
536       
537        // Ecrit les donnees dans le depot
538        function ecrire() {
539                list ($ok, $val, $messages) = $this->depot->ecrire($this->params);
540                if ($messages) $this->messages = $messages;
541                if ($ok){
542                        $this->val = $val;
543                        $this->messages['message_ok'][] = $msg = _T('cfg:config_enregistree', array('nom' => $this->nom_config()));
544                } else {
545                        $this->messages['message_erreur'][] = $msg =  _T('cfg:erreur_enregistrement', array('nom' => $this->nom_config()));
546                }
547                $this->log($msg . ' ' . $this->log_modif);
548                return $msg;
549        }
550
551
552        // Efface les donnees dans le depot
553        //
554        // dans le cas d'une suppression, il faut vider $this->val qui
555        // contient encore les valeurs du formulaire, sinon elles sont
556        // passees dans le fond et le formulaire garde les informations
557        // d'avant la suppression       
558        function effacer(){
559                list ($ok, $val, $messages) = $this->depot->effacer($this->params);
560                if ($messages) $this->messages = $messages;
561                if ($ok) {
562                        $this->val = $val;
563                        $this->messages['message_ok'][] = $msg = _T('cfg:config_supprimee', array('nom' => $this->nom_config()));
564                } else {
565                        $this->messages['message_erreur'][] = $msg = _T('cfg:erreur_suppression', array('nom' => $this->nom_config()));
566                }
567                $this->log($msg);       
568                return $msg;   
569        }
570       
571
572        //
573        // Fabriquer les balises des champs d'apres un modele fonds/cfg_<driver>.html
574        // $contexte est un tableau (nom=>valeur)
575        // qui sera enrichi puis passe a recuperer_fond
576        //
577        function formulaire($contexte = array())
578        {
579                if (!$this->path_vue)
580                        return '';
581
582                if (!$this->depuis_cvt)
583                        $contexte['_cfg_'] = $this->creer_hash_cfg();
584       
585                // recuperer le fond avec le contexte
586                // forcer le calcul.
587                $this->recuperer_fond($contexte, true);
588                $this->recuperer_parametres();
589                //$this->effacer_parametres(); // pour enlever les <!-- param=valeur --> ... sans dedoubler le contenu lorsque ce sont des tableau (param*=valeur)
590                return $this->fond_compile;
591        }
592       
593       
594        //
595        function creer_hash_cfg($action=''){
596                include_spip('inc/securiser_action');
597            $arg = 'cfg0.0.0-' . $this->param['nom'] . '-' . $this->vue;
598                return 
599                        '?cfg=' . $this->vue .
600                        '&cfg_id=' . $this->param['cfg_id'] .
601                    '&arg=' . $arg .
602                    '&hash=' .  calculer_action_auteur($action . '-' . $arg);           
603        }
604       
605       
606        //
607        // teste et charge les points d'entrees de CFG a travers certaines actions
608        // 1 : fonctions generales cfg_{nom}_{action}
609        // 2 : actions sur les types de champs particuliers
610        //     notifies par 'type_XX' ou 'cfg_YY' sur les classes css
611        //     s'ils existent dans /cfg/classes/ par des fonctions
612        //     cfg_{action}_{classe}
613        // 3 : actions en fonctions des parametres du formulaire
614        //     s'ils existent dans /cfg/params/ par des fonctions
615        //     cfg_{action}_{parametre}
616        //
617        // les actions possibles sont :
618        // - pre_charger, charger,
619        // - pre_verifier, verifier,
620        // - pre_traiter, post_traiter
621        //
622        function actionner_extensions($action){
623                // 1 - general : on transmet l'instance de cfg_formulaire
624                if (function_exists($f = 'cfg_' . $this->vue . '_' . $action)) {
625                        $res = $f($this);
626                        // compat ascendante (1.7 a 1.10.2) : verifier retournait un array comme cvt
627                        // il faut envoyer le resultat dans la fonction d'ajout des erreurs
628                        if ($action == 'verifier' AND is_array($res))
629                                $this->ajouter_erreurs($res);
630                } 
631                // 2 - type de champ : on transmet le nom du champ et l'instance de cfg_formulaire
632                if ($this->extensions) {
633                        foreach ($this->extensions as $type => $champs){
634                                // si un fichier de ce type existe, on lance la fonction
635                                // demandee pour chaque champs possedant la classe css en question
636                                if (include_spip('cfg/classes/'.$type)) {
637                                        foreach ($champs as $champ){
638                                                if (function_exists($f = 'cfg_' . $action . '_' . $type)){ // absence possible normale
639                                                        $f($champ, $this);
640                                                }
641                                        }
642                                }       
643                        }
644                }
645                // 3 - parametre : on transmet la valeur du parametre et l'instance de cfg_formulaire
646                if ($this->extensions_parametres){
647                        foreach ($this->extensions_parametres as $param){
648                                if (include_spip('cfg/params/'.$param)) {
649                                        if (function_exists($f = 'cfg_' . $action . '_param_' . $param)){ // absence possible normale
650                                                // artillerie lourde on passe
651                                                // la valeur et la classe
652                                                $f($this->param[$param], $this);                                               
653                                        }
654                                }
655                        }
656                }
657        }
658       
659
660       
661        //
662        //callback pour interpreter les parametres objets du formulaire
663        // commun avec celui de set_vue()
664        //
665        // Parametres :
666        // - $regs[2] = 'parametre'
667        // - $regs[3] = '*' ou ''
668        // - $regs[4] = 'valeur'
669        //
670        // Lorsque des parametres sont passes dans le formulaire
671        // par <!-- param=valeur -->
672        // stocker $this->param['parametre']=valeur
673        //
674        // Si <!-- param*=valeur -->
675        // Stocker $this->param['parametre'][]=valeur
676        //
677        //
678        function post_params($regs) {
679
680                // $regs[3] peut valoir '*' pour signaler un tableau
681                $regs[4] = trim($regs[4]);
682               
683                if (empty($regs[3])) {
684                    $this->param[$regs[2]] = $regs[4];
685                } elseif (is_array($this->param[$regs[2]])) {
686                    $this->param[$regs[2]][] = $regs[4];
687                }
688                // plus besoin de garder ca
689                return '';
690        }
691}
692
693?>
Note: See TracBrowser for help on using the repository browser.