www/plugins/champs_extras3/cextras_pipelines.php

   1 <?php
   2
   3 /**
   4  * Utilisations de pipelines
   5  *
   6  * @package SPIP\Cextras\Pipelines
   7 **/
   8
   9 // sécurité
  10 if (!defined("_ECRIRE_INC_VERSION")) return;
  11
  12 /**
  13  * Retourne la liste des saisies de champs extras concernant un objet donné
  14  *
  15  * @pipeline_appel declarer_champs_extras
  16  * @param string $table
  17  *     Nom d'une table SQL éditoriale
  18  * @return array
  19  *     Liste des saisies de champs extras de l'objet
  20 **/
  21 function champs_extras_objet($table) {
  22         static $saisies_tables = array();
  23         if (!$saisies_tables) {
  24                 $saisies_tables = pipeline('declarer_champs_extras', array());
  25         }
  26         return isset($saisies_tables[$table]) ? $saisies_tables[$table] : array();
  27 }
  28
  29 /**
  30  * Filtrer par autorisation les saisies transmises
  31  *
  32  * Chacune des saisies est parcourue et si le visiteur n'a pas l'autorisation
  33  * de la voir, elle est enlevée de la liste.
  34  * La fonction ne retourne donc que la liste des saisies que peut voir
  35  * la personne.
  36  *
  37  * @param string $faire
  38  *     Type d'autorisation testée : 'voir', 'modifier'
  39  * @param string $quoi
  40  *     Type d'objet tel que 'article'
  41  * @param array $saisies
  42  *     Liste des saisies à filtrer
  43  * @param array $args
  44  *     Arguments pouvant être utiles à l'autorisation
  45  * @return array
  46  *     Liste des saisies filtrées
  47 **/
  48 function champs_extras_autorisation($faire, $quoi='', $saisies=array(), $args=array()) {
  49         if (!$saisies) return array();
  50         include_spip('inc/autoriser');
  51
  52         foreach ($saisies as $cle=>$saisie) {
  53                 $id = isset($args['id']) ? $args['id'] : $args['id_objet'];
  54                 if (!autoriser($faire . 'extra', $quoi, $id, '', array(
  55                         'type' => $quoi,
  56                         'id_objet' => $id,
  57                         'contexte' => isset($args['contexte']) ? $args['contexte'] : array(),
  58                         'table' => table_objet_sql($quoi),
  59                         'saisie' => $saisie,
  60                         'champ' => $saisie['options']['nom'],
  61                 ))) {
  62                         // on n'est pas autorise
  63                         unset($saisies[$cle]);
  64                 }
  65                 else
  66                 {
  67                         // on est autorise
  68                         // on teste les sous-elements
  69                         if (isset($saisie['saisies']) and $saisie['saisies']) {
  70                                 $saisies['saisies'] = champs_extras_autorisation($faire, $quoi, $saisie['saisies'], $args);
  71                         }
  72                 }
  73         }
  74         return $saisies;
  75 }
  76
  77 /**
  78  * Ajoute pour chaque saisie de type SQL un drapeau (input hidden)
  79  * permettant de retrouver les saisies editées.
  80  *
  81  * Particulièrement utile pour les checkbox qui ne renvoient
  82  * rien si on les décoche.
  83  *
  84  * @param array $saisies
  85  *     Liste de saisies
  86  * @return array $saisies
  87  *     Saisies complétées des drapeaux d'édition
  88 **/
  89 function champs_extras_ajouter_drapeau_edition($saisies) {
  90         $saisies_sql = saisies_lister_avec_sql($saisies);
  91         foreach ($saisies_sql as $saisie) {
  92                 $nom = $saisie['options']['nom'];
  93                 $saisies[] = array(
  94                         'saisie' => 'hidden',
  95                         'options' => array(
  96                                 'nom' => "cextra_$nom",
  97                                 'defaut' => 1
  98                         )
  99                 );
 100         }
 101         return $saisies;
 102 }
 103
 104 // ---------- pipelines -----------
 105
 106
 107 /**
 108  * Ajouter les champs extras sur les formulaires CVT editer_xx
 109  *
 110  * Liste les champs extras de l'objet, et s'il y en a les ajoute
 111  * sur le formulaire d'édition en ayant filtré uniquement les saisies
 112  * que peut voir le visiteur et en ayant ajouté des champs hidden
 113  * servant à champs extras.
 114  *
 115  * @pipeline editer_contenu_objet
 116  * @param array $flux Données du pipeline
 117  * @return array      Données du pipeline
 118 **/
 119 function cextras_editer_contenu_objet($flux){
 120
 121         // recuperer les saisies de l'objet en cours
 122         $objet = $flux['args']['type'];
 123         include_spip('inc/cextras');
 124         if ($saisies = champs_extras_objet( table_objet_sql($objet) )) {
 125                 // filtrer simplement les saisies que la personne en cours peut voir
 126                 $saisies = champs_extras_autorisation('modifier', $objet, $saisies, $flux['args']);
 127                 // pour chaque saisie presente, de type champs extras (hors fieldset et autres)
 128                 // ajouter un flag d'edition
 129                 $saisies = champs_extras_ajouter_drapeau_edition($saisies);
 130                 // ajouter au formulaire
 131                 $ajout = recuperer_fond('inclure/generer_saisies', array_merge($flux['args']['contexte'], array('saisies'=>$saisies)));
 132                 $flux['data'] = preg_replace('%(<!--extra-->)%is', '<ul class="champs_extras">'.$ajout.'</ul>'."\n".'$1', $flux['data']);
 133         }
 134
 135         return $flux;
 136 }
 137
 138
 139 /**
 140  * Ajouter les champs extras soumis par les formulaire CVT editer_xx
 141  *
 142  * Pour chaque champs extras envoyé par le formulaire d'édition,
 143  * ajoute les valeurs dans l'enregistrement à effectuer.
 144  *
 145  * @pipeline pre_edition
 146  * @param array $flux Données du pipeline
 147  * @return array      Données du pipeline
 148 **/
 149 function cextras_pre_edition($flux){
 150
 151         include_spip('inc/cextras');
 152         include_spip('inc/saisies_lister');
 153         $table = $flux['args']['table'];
 154         if ($saisies = champs_extras_objet( $table )) {
 155
 156                 // Restreindre les champs postés en fonction des autorisations de les modifier
 157                 // au cas où un malin voudrait en envoyer plus que le formulaire ne demande
 158                 $saisies = champs_extras_autorisation('modifier', objet_type($table), $saisies, $flux['args']);
 159
 160                 $saisies = saisies_lister_avec_sql($saisies);
 161                 foreach ($saisies as $saisie) {
 162                         $nom = $saisie['options']['nom'];
 163                         if (_request('cextra_' .  $nom)) {
 164                                 $extra = _request($nom);
 165                                 if (is_array($extra)) {
 166                                         $extra = join(',' , $extra);
 167                                 }
 168                                 $flux['data'][$nom] = corriger_caracteres($extra);
 169                         }
 170                 }
 171         }
 172
 173         return $flux;
 174 }
 175
 176
 177 /**
 178  * Ajouter les champs extras sur la visualisation de l'objet
 179  *
 180  * S'il y a des champs extras sur l'objet, la fonction les ajoute
 181  * à la vue de l'objet, en enlevant les saisies que la personne n'a
 182  * pas l'autorisation de voir.
 183  *
 184  * @pipeline afficher_contenu_objet
 185  * @param array $flux Données du pipeline
 186  * @return array      Données du pipeline
 187 **/
 188 function cextras_afficher_contenu_objet($flux){
 189         // recuperer les saisies de l'objet en cours
 190         $objet = $flux['args']['type'];
 191         include_spip('inc/cextras');
 192         if ($saisies = champs_extras_objet( $table = table_objet_sql($objet) )) {
 193                 // ajouter au contexte les noms et valeurs des champs extras
 194                 $saisies_sql = saisies_lister_avec_sql($saisies);
 195                 $valeurs = sql_fetsel(array_keys($saisies_sql), $table, id_table_objet($table) . '=' . sql_quote($flux['args']['id_objet']));
 196                 if (!$valeurs) {
 197                         $valeurs = array();
 198                 } else {
 199                         // on applique les eventuels traitements definis
 200                         // /!\ La saisies-vues/_base applique |propre par defaut si elle ne trouve pas de saisie
 201                         // Dans ce cas, certains traitements peuvent être effectués 2 fois !
 202                         $saisies_traitees = saisies_lister_avec_traitements($saisies_sql);
 203                         unset($saisies_sql);
 204
 205                         // Fournir $connect et $Pile[0] au traitement si besoin (l'evil eval)
 206                         $connect = '';
 207                         $Pile = array(0 => (isset($flux['args']['contexte']) ? $flux['args']['contexte'] : array()));
 208
 209                         foreach ($saisies_traitees as $saisie) {
 210                                 $traitement = $saisie['options']['traitements'];
 211                                 $traitement = defined($traitement) ? constant($traitement) : $traitement;
 212                                 $nom = $saisie['options']['nom'];
 213                                 list($avant, $apres) = explode('%s', $traitement);
 214                                 eval('$val = ' . $avant . ' $valeurs[$nom] ' . $apres . ';');
 215                                 $valeurs[$nom] = $val;
 216                         }
 217                 }
 218
 219                 $contexte = isset($flux['args']['contexte']) ? $flux['args']['contexte'] : array();
 220                 $contexte = array_merge($contexte, $valeurs);
 221
 222                 // restreindre la vue selon les autorisations
 223                 $saisies = champs_extras_autorisation('voir', $objet, $saisies, $flux['args']);
 224
 225                 // ajouter les vues
 226                 $flux['data'] .= recuperer_fond('inclure/voir_saisies', array_merge($contexte, array(
 227                                         'saisies' => $saisies,
 228                                         'valeurs' => $valeurs,
 229                 )));
 230         }
 231
 232         return $flux;
 233 }
 234
 235 /**
 236  * Vérification de la validité des champs extras
 237  *
 238  * Lorsqu'un formulaire 'editer_xx' se présente, la fonction effectue,
 239  * pour chaque champs extra les vérifications prévues dans la
 240  * définition de la saisie, et retourne les éventuelles erreurs rencontrées.
 241  *
 242  * @pipeline formulaire_verifier
 243  * @param array $flux Données du pipeline
 244  * @return array      Données du pipeline
 245 **/
 246 function cextras_formulaire_verifier($flux){
 247         $form = $flux['args']['form'];
 248
 249         if (strncmp($form, 'editer_', 7) !== 0) {
 250                 return $flux;
 251         }
 252
 253         $objet = substr($form, 7);
 254         if ($saisies = champs_extras_objet( $table = table_objet_sql($objet) )) {
 255                 include_spip('inc/autoriser');
 256                 include_spip('inc/saisies');
 257
 258                 // restreindre les saisies selon les autorisations
 259                 $id_objet = $flux['args']['args'][0]; // ? vraiment toujours ?
 260                 $saisies = champs_extras_autorisation('modifier', $objet, $saisies, array_merge($flux['args'], array(
 261                         'id' => $id_objet,
 262                         'contexte' => array()))); // nous ne connaissons pas le contexte dans ce pipeline
 263
 264                 // restreindre les vérifications aux saisies enregistrables
 265                 $saisies = saisies_lister_avec_sql($saisies);
 266
 267                 $verifier = charger_fonction('verifier', 'inc', true);
 268
 269                 foreach ($saisies as $saisie) {
 270                         // verifier obligatoire
 271                         $nom = $saisie['options']['nom'];
 272                         if (isset($saisie['options']['obligatoire']) and $saisie['options']['obligatoire']
 273                         and !_request($nom))
 274                         {
 275                                 $flux['data'][$nom] = _T('info_obligatoire');
 276
 277                         // verifier (api) + normalisation
 278                         } elseif ($verifier
 279                            AND isset($saisie['verifier']['type'])
 280                            AND $verif = $saisie['verifier']['type'])
 281                         {
 282                                 $options = isset($saisie['verifier']['options']) ? $saisie['verifier']['options'] : array();
 283                                 $normaliser = null;
 284                                 $valeur = _request($nom);
 285                                 if ($erreur = $verifier($valeur, $verif, $options, $normaliser)) {
 286                                         $flux['data'][$nom] = $erreur;
 287                                 // si une valeur de normalisation a ete transmis, la prendre.
 288                                 } elseif (!is_null($normaliser)) {
 289                                         set_request($nom, $normaliser);
 290                                 } else {
 291
 292                                         // [FIXME] exceptions connues de vérifications (pour les dates entre autres)
 293                                         // en attendant une meilleure solution !
 294                                         //
 295                                         // Lorsque le champ n'est pas rempli dans le formulaire
 296                                         // alors qu'une normalisation est demandée,
 297                                         // verifier() sort sans indiquer d'erreur (c'est normal).
 298                                         //
 299                                         // Sauf que la donnée alors soumise à SQL sera une chaine vide,
 300                                         // ce qui ne correspond pas toujours à ce qui est attendu.
 301                                         if ((is_string($valeur) and !strlen($valeur) or (is_array($valeur) and $saisie['saisie']=='date'))
 302                                           and isset($options['normaliser'])
 303                                           and $norme = $options['normaliser']) {
 304                                                 // Charger la fonction de normalisation théoriquement dans verifier/date
 305                                                 // et si on en trouve une, obtenir la valeur normalisée
 306                                                 // qui est théoriquement la valeur par défaut, puisque $valeur est vide
 307                                                 include_spip("verifier/$verif");
 308                                                 if ($normaliser = charger_fonction("${verif}_${norme}", "normaliser", true)) {
 309                                                         $erreur = null;
 310                                                         $defaut = $normaliser($valeur, $options, $erreur);
 311                                                         if (is_null($erreur)) {
 312                                                                 set_request($nom, $defaut);
 313                                                         } else {
 314                                                                 // on affecte l'erreur, mais il est probable que
 315                                                                 // l'utilisateur ne comprenne pas grand chose
 316                                                                 $flux['data'][$nom] = $erreur;
 317                                                         }
 318                                                 } else {
 319                                                         include_spip('inc/cextras');
 320                                                         extras_log("Fonction de normalisation pour ${verif}_${norme} introuvable");
 321                                                 }
 322
 323                                         }
 324                                 }
 325                         }
 326                 }
 327         }
 328         return $flux;
 329 }
 330
 331 /**
 332  * Insertion dans le pipeline revisions_chercher_label (Plugin révisions)
 333  * Trouver le bon label à afficher sur les champs dans les listes de révisions
 334  *
 335  * Si un champ est un champ extra, son label correspond au label défini du champs extra
 336  *
 337  * @pipeline revisions_chercher_label
 338  * @param array $flux Données du pipeline
 339  * @return array      Données du pipeline
 340 **/
 341 function cextras_revisions_chercher_label($flux){
 342         $table = table_objet_sql($flux['args']['objet']);
 343         $saisies_tables = champs_extras_objet($table);
 344         foreach($saisies_tables as $champ){
 345                 if($champ['options']['nom'] == $flux['args']['champ']){
 346                         $flux['data'] = $champ['options']['label'];
 347                         break;
 348                 }
 349         }
 350         return $flux;
 351 }
 352
 353 ?>