www/plugins/auto/cfg/inc/cfg_formulaire.php

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