www/plugins/saisies/inc/saisies.php

   1 <?php
   2
   3 /**
   4  * Gestion de l'affichage des saisies
   5  *
   6  * @return SPIP\Saisies\Saisies
   7 **/
   8
   9 // Sécurité
  10 if (!defined('_ECRIRE_INC_VERSION')) return;
  11
  12 /*
  13  * Une librairie pour manipuler ou obtenir des infos sur un tableau de saisies
  14  *
  15  * saisies_lister_par_nom()
  16  * saisies_lister_champs()
  17  * saisies_lister_valeurs_defaut()
  18  * saisies_charger_champs()
  19  * saisies_chercher()
  20  * saisies_supprimer()
  21  * saisies_inserer()
  22  * saisies_deplacer()
  23  * saisies_modifier()
  24  * saisies_verifier()
  25  * saisies_comparer()
  26  * saisies_generer_html()
  27  * saisies_generer_vue()
  28  * saisies_generer_nom()
  29  * saisies_inserer_html()
  30  * saisies_lister_disponibles()
  31  * saisies_autonomes()
  32  */
  33
  34 // Différentes méthodes pour trouver les saisies
  35 include_spip('inc/saisies_lister');
  36
  37 // Différentes méthodes pour manipuler une liste de saisies
  38 include_spip('inc/saisies_manipuler');
  39
  40 // Les outils pour afficher les saisies et leur vue
  41 include_spip('inc/saisies_afficher');
  42
  43 /*
  44  * Cherche la description des saisies d'un formulaire CVT dont on donne le nom
  45  *
  46  * @param string $form Nom du formulaire dont on cherche les saisies
  47  * @return array Retourne les saisies du formulaire sinon false
  48  */
  49 function saisies_chercher_formulaire($form, $args){
  50         if ($fonction_saisies = charger_fonction('saisies', 'formulaires/'.$form, true)
  51                 and $saisies = call_user_func_array($fonction_saisies, $args)
  52                 and is_array($saisies)
  53                 // On passe les saisies dans un pipeline normé comme pour CVT
  54                 and $saisies = pipeline(
  55                         'formulaire_saisies',
  56                         array(
  57                                 'args' => array('form' => $form, 'args' => $args),
  58                                 'data' => $saisies
  59                         )
  60                 )
  61                 // Si c'est toujours un tableau après le pipeline
  62                 and is_array($saisies)
  63         ){
  64                 return $saisies;
  65         }
  66         else{
  67                 return false;
  68         }
  69 }
  70
  71 /*
  72  * Cherche une saisie par son id, son nom ou son chemin et renvoie soit la saisie, soit son chemin
  73  *
  74  * @param array $saisies Un tableau décrivant les saisies
  75  * @param unknown_type $id_ou_nom_ou_chemin L'identifiant ou le nom de la saisie à chercher ou le chemin sous forme d'une liste de clés
  76  * @param bool $retourner_chemin Indique si on retourne non pas la saisie mais son chemin
  77  * @return array Retourne soit la saisie, soit son chemin, soit null
  78  */
  79 function saisies_chercher($saisies, $id_ou_nom_ou_chemin, $retourner_chemin=false){
  80
  81         if (is_array($saisies) and $id_ou_nom_ou_chemin){
  82                 if (is_string($id_ou_nom_ou_chemin)){
  83                         $nom = $id_ou_nom_ou_chemin;
  84                         // identifiant ? premier caractere @
  85                         $id = ($nom[0] == '@');
  86
  87                         foreach($saisies as $cle => $saisie){
  88                                 $chemin = array($cle);
  89                                 // notre saisie est la bonne ?
  90                                 if ($nom == ($id ? $saisie['identifiant'] : $saisie['options']['nom'])) {
  91                                         return $retourner_chemin ? $chemin : $saisie;
  92                                 // sinon a telle des enfants ? et si c'est le cas, cherchons dedans
  93                                 } elseif (isset($saisie['saisies']) and is_array($saisie['saisies']) and $saisie['saisies']
  94                                         and ($retour = saisies_chercher($saisie['saisies'], $nom, $retourner_chemin))) {
  95                                                 return $retourner_chemin ? array_merge($chemin, array('saisies'), $retour) : $retour;
  96                                 }
  97
  98                         }
  99                 }
 100                 elseif (is_array($id_ou_nom_ou_chemin)){
 101                         $chemin = $id_ou_nom_ou_chemin;
 102                         $saisie = $saisies;
 103                         // On vérifie l'existence quand même
 104                         foreach ($chemin as $cle){
 105                                 if (isset($saisie[$cle])) $saisie = $saisie[$cle];
 106                                 else return null;
 107                         }
 108                         // Si c'est une vraie saisie
 109                         if ($saisie['saisie'] and $saisie['options']['nom'])
 110                                 return $retourner_chemin ? $chemin : $saisie;
 111                 }
 112         }
 113
 114         return null;
 115 }
 116
 117 /**
 118  * Génère un nom unique pour un champ d'un formulaire donné
 119  *
 120  * @param array $formulaire
 121  *     Le formulaire à analyser
 122  * @param string $type_saisie
 123  *     Le type de champ dont on veut un identifiant
 124  * @return string
 125  *     Un nom unique par rapport aux autres champs du formulaire
 126  */
 127 function saisies_generer_nom($formulaire, $type_saisie){
 128         $champs = saisies_lister_champs($formulaire);
 129
 130         // Tant que type_numero existe, on incrémente le compteur
 131         $compteur = 1;
 132         while (array_search($type_saisie.'_'.$compteur, $champs) !== false)
 133                 $compteur++;
 134
 135         // On a alors un compteur unique pour ce formulaire
 136         return $type_saisie.'_'.$compteur;
 137 }
 138
 139 /*
 140  * Crée un identifiant Unique
 141  * pour toutes les saisies donnees qui n'en ont pas
 142  *
 143  * @param Array $saisies Tableau de saisies
 144  * @param Bool $regenerer_id Régénère un nouvel identifiant pour toutes les saisies ?
 145  * @return Array Tableau de saisies complété des identifiants
 146  */
 147 function saisies_identifier($saisies, $regenerer = false) {
 148         if (!is_array($saisies)) {
 149                 return array();
 150         }
 151         foreach ($saisies as $k => $saisie) {
 152                 $saisies[$k] = saisie_identifier($saisie, $regenerer);
 153         }
 154         return $saisies;
 155 }
 156
 157 /**
 158  * Crée un identifiant Unique
 159  * pour la saisie donnee si elle n'en a pas
 160  * (et pour ses sous saisies éventuels)
 161  *
 162  * @param Array $saisie Tableau d'une saisie
 163  * @param Bool $regenerer_id Régénère un nouvel identifiant pour la saisie ?
 164  * @return Array Tableau de la saisie complété de l'identifiant
 165 **/
 166 function saisie_identifier($saisie, $regenerer = false) {
 167         if (!isset($saisie['identifiant']) OR !$saisie['identifiant']) {
 168                 $saisie['identifiant'] = uniqid('@');
 169         } elseif ($regenerer) {
 170                 $saisie['identifiant'] = uniqid('@');
 171         }
 172         if (isset($saisie['saisies']) AND is_array($saisie['saisies'])) {
 173                 $saisie['saisies'] = saisies_identifier($saisie['saisies'], $regenerer);
 174         }
 175         return $saisie;
 176 }
 177
 178 /*
 179  * Vérifier tout un formulaire tel que décrit avec les Saisies
 180  *
 181  * @param array $formulaire Le contenu d'un formulaire décrit dans un tableau de Saisies
 182  * @param bool $saisies_masquees_nulles Si TRUE, les saisies masquées selon afficher_si ne seront pas verifiées, leur valeur étant forcée a NULL. Cette valeur NULL est transmise à traiter (via set_request).
 183  * @return array Retourne un tableau d'erreurs
 184  */
 185 function saisies_verifier($formulaire, $saisies_masquees_nulles=true){
 186         include_spip('inc/verifier');
 187         $erreurs = array();
 188         $verif_fonction = charger_fonction('verifier','inc',true);
 189
 190         if ($saisies_masquees_nulles)
 191                 $formulaire = saisies_verifier_afficher_si($formulaire);
 192
 193         $saisies = saisies_lister_par_nom($formulaire);
 194         foreach ($saisies as $saisie){
 195                 $obligatoire = isset($saisie['options']['obligatoire']) ? $saisie['options']['obligatoire'] : '';
 196                 $champ = $saisie['options']['nom'];
 197                 $file = ($saisie['saisie'] == 'input' and isset($saisie['options']['type']) and $saisie['options']['type'] == 'file');
 198                 $verifier = isset($saisie['verifier']) ? $saisie['verifier'] : false;
 199
 200                 // Si le nom du champ est un tableau indexé, il faut parser !
 201                 if (preg_match('/([\w]+)((\[[\w]+\])+)/', $champ, $separe)){
 202                         $valeur = _request($separe[1]);
 203                         preg_match_all('/\[([\w]+)\]/', $separe[2], $index);
 204                         // On va chercher au fond du tableau
 205                         foreach($index[1] as $cle){
 206                                 $valeur = isset($valeur[$cle]) ? $valeur[$cle] : null;
 207                         }
 208                 }
 209                 // Sinon la valeur est juste celle du nom
 210                 else
 211                         $valeur = _request($champ);
 212
 213                 // Pour la saisie "destinataires" il faut filtrer si jamais on a mis un premier choix vide
 214                 if ($saisie['saisie'] == 'destinataires') {
 215                         $valeur = array_filter($valeur);
 216                 }
 217
 218                 // On regarde d'abord si le champ est obligatoire
 219                 if ($obligatoire
 220                         and $obligatoire != 'non'
 221                         and (
 222                                 ($file and !$_FILES[$champ]['name'])
 223                                 or (!$file and (
 224                                         is_null($valeur)
 225                                         or (is_string($valeur) and trim($valeur) == '')
 226                                         or (is_array($valeur) and count($valeur) == 0)
 227                                 ))
 228                         )
 229                 ) {
 230                         $erreurs[$champ] =
 231                                 (isset($saisie['options']['erreur_obligatoire']) and $saisie['options']['erreur_obligatoire'])
 232                                 ? $saisie['options']['erreur_obligatoire']
 233                                 : _T('info_obligatoire');
 234                 }
 235
 236                 // On continue seulement si ya pas d'erreur d'obligation et qu'il y a une demande de verif
 237                 if ((!isset($erreurs[$champ]) or !$erreurs[$champ]) and is_array($verifier) and $verif_fonction){
 238                         $normaliser = null;
 239                         // Si le champ n'est pas valide par rapport au test demandé, on ajoute l'erreur
 240                         $options = isset($verifier['options']) ? $verifier['options'] : array();
 241                         if ($erreur_eventuelle = $verif_fonction($valeur, $verifier['type'], $options, $normaliser)) {
 242                                 $erreurs[$champ] = $erreur_eventuelle;
 243                         // S'il n'y a pas d'erreur et que la variable de normalisation a été remplie, on l'injecte dans le POST
 244                         } elseif (!is_null($normaliser)) {
 245                                 set_request($champ, $normaliser);
 246                         }
 247                 }
 248         }
 249
 250         return $erreurs;
 251 }
 252
 253 /**
 254  * Applatie une description tabulaire
 255  * @param string $tab, le tableau à aplatir
 256  * @return $nouveau_tab
 257  */
 258 function saisies_aplatir_tableau($tab){
 259         $nouveau_tab = array();
 260         foreach($tab as $entree=>$contenu){
 261                 if (is_array($contenu)) {
 262                         foreach ($contenu as $cle => $valeur) {
 263                                 $nouveau_tab[$cle] = $valeur;
 264                         }
 265                 } else {
 266                         $nouveau_tab[$entree] = $contenu;
 267                 }
 268         }
 269         return $nouveau_tab;
 270 }
 271
 272 /**
 273  * Applatie une description chaînée, en supprimant les sous-groupes.
 274  * @param string $chaine, la chaîne à aplatir
 275  * @return $chaine
 276  */
 277 function saisies_aplatir_chaine($chaine){
 278         return trim(preg_replace("#(?:^|\n)(\*(?:.*)|/\*)\n#i","\n",$chaine));
 279 }
 280
 281 /**
 282  * Transforme une chaine en tableau avec comme principe :
 283  *
 284  * - une ligne devient une case
 285  * - si la ligne est de la forme truc|bidule alors truc est la clé et bidule la valeur
 286  * - si la ligne commence par * alors on commence un sous-tableau
 287  * - si la ligne est égale à /*, alors on fini le sous-tableau
 288  *
 289  * @param string $chaine Une chaine à transformer
 290  * @return array Retourne un tableau PHP
 291  */
 292 function saisies_chaine2tableau($chaine, $separateur="\n"){
 293         if ($chaine and is_string($chaine)){
 294                 $tableau = array();
 295                 $soustab = False;
 296                 // On découpe d'abord en lignes
 297                 $lignes = explode($separateur, $chaine);
 298                 foreach ($lignes as $i=>$ligne){
 299                         $ligne = trim(trim($ligne), '|');
 300                         // Si ce n'est pas une ligne sans rien
 301                         if ($ligne !== ''){
 302                                 // si ca commence par * c'est qu'on va faire un sous tableau
 303                                 if (strpos($ligne,"*")===0) {
 304                                         $soustab=True;
 305                                         $soustab_cle    = _T_ou_typo(substr($ligne,1), 'multi');
 306                                         if (!isset($tableau[$soustab_cle])){
 307                                                 $tableau[$soustab_cle] = array();
 308                                         }
 309                                 }
 310                                 elseif ($ligne=="/*") {//si on finit sous tableau
 311                                         $soustab=False;
 312                                 }
 313                                 else{//sinon c'est une entrée normale
 314                                 // Si on trouve un découpage dans la ligne on fait cle|valeur
 315                                         if (strpos($ligne, '|') !== false) {
 316                                                 list($cle,$valeur) = explode('|', $ligne, 2);
 317                                                 // permettre les traductions de valeurs au passage
 318                                                 if ($soustab == True){
 319                                                         $tableau[$soustab_cle][$cle] = _T_ou_typo($valeur, 'multi');
 320                                                 } else {
 321                                                         $tableau[$cle] = _T_ou_typo($valeur, 'multi');
 322                                                 }
 323                                         }
 324                                 // Sinon on génère la clé
 325                                         else{
 326                                                 if ($soustab == True) {
 327                                                         $tableau[$soustab_cle][$i] = _T_ou_typo($ligne,'multi');
 328                                                 } else {
 329                                                         $tableau[$i] = _T_ou_typo($ligne,'multi');
 330                                                 }
 331                                         }
 332                                 }
 333                         }
 334                 }
 335                 return $tableau;
 336         }
 337         // Si c'est déjà un tableau on lui applique _T_ou_typo (qui fonctionne de manière récursive avant de le renvoyer
 338         elseif (is_array($chaine)){
 339                 return _T_ou_typo($chaine, 'multi');
 340         } else {
 341                 return array();
 342         }
 343 }
 344
 345 /**
 346  * Transforme un tableau en chaine de caractères avec comme principe :
 347  *
 348  * - une case de vient une ligne de la chaine
 349  * - chaque ligne est générée avec la forme cle|valeur
 350  * - si une entrée du tableau est elle même un tableau, on met une ligne de la forme *clef
 351  * - pour marquer que l'on quitte un sous-tableau, on met une ligne commencant par /*, sauf si on bascule dans un autre sous-tableau.
 352  */
 353 function saisies_tableau2chaine($tableau){
 354         if ($tableau and is_array($tableau)){
 355                 $chaine = '';
 356                 $avant_est_tableau = False;
 357                 foreach($tableau as $cle=>$valeur){
 358                         if (is_array($valeur)){
 359                                 $avant_est_tableau = True;
 360                                 $ligne=trim("*$cle");
 361                                 $chaine .= "$ligne\n";
 362                                 $chaine .= saisies_tableau2chaine($valeur)."\n";
 363                                 }
 364                         else{
 365                                 if ($avant_est_tableau == True){
 366                                                 $avant_est_tableau = False;
 367                                                 $chaine.="/*\n";
 368                                         }
 369                                 $ligne = trim("$cle|$valeur");
 370                                 $chaine .= "$ligne\n";
 371                         }
 372                 }
 373                 $chaine = trim($chaine);
 374
 375                 return $chaine;
 376         }
 377         // Si c'est déjà une chaine on la renvoie telle quelle
 378         elseif (is_string($tableau)){
 379                 return $tableau;
 380         }
 381         else{
 382                 return '';
 383         }
 384 }
 385
 386
 387
 388
 389 /**
 390  * Passe une valeur en tableau d'élements si ce n'en est pas une
 391  *
 392  * entrée :
 393  * cle|valeur
 394  * cle|valeur
 395  *
 396  * Sinon :
 397  * valeur,valeur
 398  *
 399  * @param mixed $valeur
 400  * @return array Tableau de valeurs
 401 **/
 402 function saisies_valeur2tableau($valeur, $sinon_separateur="") {
 403         if (is_array($valeur)) {
 404                 return $valeur;
 405         }
 406
 407         if (!strlen($valeur)) {
 408                 return array();
 409         }
 410
 411         $t = saisies_chaine2tableau($valeur);
 412         if (count($t) > 1) {
 413                 return $t;
 414         }
 415
 416         // qu'une seule valeur, c'est qu'elle a peut etre un separateur a virgule
 417         // et a donc une cle est 0 dans ce cas la d'ailleurs
 418         if (isset($t[0])) {
 419                 $t = saisies_chaine2tableau($t[0], ',');
 420         }
 421
 422         return $t;
 423 }
 424
 425
 426
 427
 428 /*
 429  * Génère une page d'aide listant toutes les saisies et leurs options
 430  */
 431 function saisies_generer_aide(){
 432         // On a déjà la liste par saisie
 433         $saisies = saisies_lister_disponibles();
 434
 435         // On construit une liste par options
 436         $options = array();
 437         foreach ($saisies as $type_saisie=>$saisie){
 438                 $options_saisie = saisies_lister_par_nom($saisie['options'], false);
 439                 foreach ($options_saisie as $nom=>$option){
 440                         // Si l'option n'existe pas encore
 441                         if (!isset($options[$nom])){
 442                                 $options[$nom] = _T_ou_typo($option['options']);
 443                         }
 444                         // On ajoute toujours par qui c'est utilisé
 445                         $options[$nom]['utilisee_par'][] = $type_saisie;
 446                 }
 447                 ksort($options_saisie);
 448                 $saisies[$type_saisie]['options'] = $options_saisie;
 449         }
 450         ksort($options);
 451
 452         return recuperer_fond(
 453                 'inclure/saisies_aide',
 454                 array(
 455                         'saisies' => $saisies,
 456                         'options' => $options
 457                 )
 458         );
 459 }
 460
 461 /*
 462  * Le tableau de saisies a-t-il une option afficher_si ?
 463  *
 464  * @param array $saisies Un tableau de saisies
 465  * @return boolean
 466  */
 467
 468 function saisies_afficher_si($saisies) {
 469         $saisies = saisies_lister_par_nom($saisies,true);
 470         // Dès qu'il y a au moins une option afficher_si, on l'active
 471         foreach ($saisies as $saisie) {
 472                 if (isset($saisie['options']['afficher_si']))
 473                         return true;
 474         }
 475         return false;
 476 }
 477
 478
 479 /*
 480  * Le tableau de saisies a-t-il une option afficher_si_remplissage ?
 481  *
 482  * @param array $saisies Un tableau de saisies
 483  * @return boolean
 484  */
 485 function saisies_afficher_si_remplissage($saisies) {
 486         $saisies = saisies_lister_par_nom($saisies,true);
 487         // Dès qu'il y a au moins une option afficher_si_remplissage, on l'active
 488         foreach ($saisies as $saisie) {
 489                 if (isset($saisie['options']['afficher_si_remplissage']))
 490                         return true;
 491         }
 492         return false;
 493 }
 494 ?>