Changeset 26929 in spip-zone


Ignore:
Timestamp:
Feb 25, 2009, 11:20:16 PM (10 years ago)
Author:
marcimat@…
Message:

Allons un peu plus vers la séparation :

  • déplacement des dépots php, table et tablepack
  • suppression du parametre 'inline'
  • les extensions par les classes css ou par les paramètres sont supprimées (mis dans compat)
Location:
_plugins_/_stable_/cfg2
Files:
5 added
5 edited
5 moved

Legend:

Unmodified
Added
Removed
  • _plugins_/_stable_/cfg2/core/cfg_fonctions.php

    r21298 r26929  
    7979        $sortie = '';
    8080        $hash = substr(md5(rand()*rand()),0,6);
    81        
    82         // integration du css
    83         // Suppression de cette inclusion des css arbo au profit d'une inclusion d'un fichier cfg.css dans le header prive
    84 //      $sortie .= "<style type='text/css'>\n"
    85 //                      .  ".cfg_arbo{}\n"
    86 //                      .  ".cfg_arbo h5{padding:0.2em 0.2em; margin:0.2em 0; cursor:pointer;}\n"
    87 //                      .  ".cfg_arbo ul{border:1px solid #ccc; margin:0; padding:0.2em 0.5em; list-style-type:none;}\n"
    88 //                      .  "</style>\n";
    8981
    9082        // integration du js   
  • _plugins_/_stable_/cfg2/core/changelog.txt

    r26913 r26929  
    22v2.0.0
    33  * Suppression de la compatibilite 1.9.2 (cf. extension compat)
    4   * Suppression du parametre <!-- head=... --> (cf. extension compat)
     4  * Suppression du parametre 'head' (cf. extension compat)
     5  * Suppression des depots "php, table, tablepack" (cf. extension depots)
     6  * Suppression du parametre 'inline' (cf. extension compat)
     7 
     8  * Suppresison du parametre 'afficher_messages' (aucune occurence)
     9 
    510
    611
  • _plugins_/_stable_/cfg2/core/inc/cfg_config.php

    r26913 r26929  
    6969        //                      'type' => 'checkbox|hidden|text...', // type d'un input
    7070        //                      'tableau' => bool, // est-ce un champ tableau name="champ[]" ?
    71         //                      'cfg' => 'xx',   // classe css commencant par css_xx
    7271        //                      'id' => y, // cle du tableau 'champs_id' (emplacement qui possede ce champ)
    7372        //              ),
  • _plugins_/_stable_/cfg2/core/inc/cfg_formulaire.php

    r22620 r26929  
    11<?php
    2 
    32
    43/*
    54 * Plugin CFG pour SPIP
    6  * (c) toggg 2007, distribue sous licence GNU/GPL
    7  * Documentation et contact: http://www.spip-contrib.net/
     5 * (c) toggg, marcimat 2009, distribue sous licence GNU/GPL
    86 *
    97 */
     
    1210
    1311
     12// charger la classe CFG d'origine pour l'etendre
     13include_spip('inc/cfg_formulaire_dist');
    1414
    15 // la classe cfg represente une page de configuration
    16 class 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 }
     15// etendre la classe CFG sans rien changer...
     16class cfg_formulaire extends cfg_formulaire_dist {}
    69217
    69318?>
  • _plugins_/_stable_/cfg2/extensions/compat/plugin.xml

    r26913 r26929  
    11<plugin>
    22    <nom>Comptabilite : fonctionnalites de CFG 1.10</nom>
    3     <auteur>bertrand Gugger [->http://toggg.com/], Matthieu Marcillaud
    4 _ &#169; 2008 - <multi>[fr]Distribu&#233; sous licence[en]License[de]Vertrieb unter Lizenz</multi> GNU/LGPL
    5     </auteur>
     3    <auteur>bertrand Gugger [->http://toggg.com/], Matthieu Marcillaud</auteur>
     4        <licence>GNU/GPL</licence>
    65    <version>1.0.0</version>
    76    <etat>stable</etat>
     
    2625    </pipeline>
    2726       
    28         <necessite id="SPIP" version="[1.9.0;]" />
     27        <necessite id="SPIP" version="[1.9.2;]" />
     28        <necessite id="cfg" version="[1.99.0;]" />
    2929</plugin>
  • _plugins_/_stable_/cfg2/extensions/depots/depots/php.php

    r26913 r26929  
    33/*
    44 * Plugin CFG pour SPIP
    5  * (c) toggg 2007, distribue sous licence GNU/GPL
    6  * Documentation et contact: http://www.spip-contrib.net/
     5 * (c) toggg, marcimat 2009, distribue sous licence GNU/GPL
    76 *
    87 * classe cfg_php: storage dans un fichier php
     
    109
    1110if (!defined("_ECRIRE_INC_VERSION")) return;
     11
     12/*
     13 * Ce depot accepte un parametre supplementaire dans les formulaires CFG :
     14 * - fichier : c'est l'adresse du fichier (depuis la racine de spip), sinon ca prend /local/cfg/nom.php
     15 */
    1216
    1317// cfg_php retrouve et met a jour les donnees d'un fichier php
  • _plugins_/_stable_/cfg2/extensions/depots/depots/table.php

    r26913 r26929  
    33/*
    44 * Plugin CFG pour SPIP
    5  * (c) toggg 2007, distribue sous licence GNU/GPL
    6  * Documentation et contact: http://www.spip-contrib.net/
     5 * (c) toggg, marcimat 2009, distribue sous licence GNU/GPL
    76 *
    87 * classe cfg_table: storage naturel dans une table
     
    1110if (!defined("_ECRIRE_INC_VERSION")) return;
    1211
    13 
     12/*
     13 *
     14 * Ce depot accepte des parametres supplementaires dans les formulaires CFG :
     15 * - autoriser_absence_id : si 'oui', on autorisee l'insertion de nouveau
     16 *   contenu dans une table sans donner d'identifiant
     17 * - table : nom de la table sql
     18 *
     19 */
    1420
    1521// cfg_table retrouve et met a jour les colonnes d'une table
  • _plugins_/_stable_/cfg2/extensions/depots/depots/tablepack.php

    r26913 r26929  
    1111if (!defined("_ECRIRE_INC_VERSION")) return;
    1212
    13 
     13/*
     14 * Ce depot accepte des parametres supplementaires dans les formulaires CFG :
     15 * - table : nom de la table sql
     16 *
     17 */
    1418
    1519// cfg_tablepack retrouve et met a jour les donnees serialisees dans une colonne d'une table
Note: See TracChangeset for help on using the changeset viewer.