www/plugins/champs_extras3/cextras_fonctions.php

   1 <?php
   2
   3 /**
   4  * Déclarations de balises pour les squelettes
   5  *
   6  * @package SPIP\Cextras\Fonctions
   7 **/
   8
   9 // sécurité
  10 if (!defined("_ECRIRE_INC_VERSION")) return;
  11
  12 /**
  13  * Retourne la description de la saisie du champ demandé
  14  * permettant ainsi d'exploiter ses données.
  15  *
  16  * @example
  17  *     ```
  18  *     <BOUCLE_x(TABLE)>
  19  *     - #CHAMP_EXTRA{nom_du_champ}
  20  *     - #CHAMP_EXTRA{nom_du_champ,label}
  21  *     </BOUCLE_x>
  22  *     ```
  23  *
  24  * @balise
  25  * @note
  26  *     Lève une erreur de squelette si le nom de champs extras
  27  *     n'est pas indiqué en premier paramètre de la balise
  28  *
  29  * @param Champ $p
  30  *     AST au niveau de la balise
  31  * @return Champ
  32  *     AST complété par le code PHP de la balise
  33 **/
  34 function balise_CHAMP_EXTRA_dist($p) {
  35         // prendre nom de la cle primaire de l'objet pour calculer sa valeur
  36         $id_boucle = $p->nom_boucle ? $p->nom_boucle : $p->id_boucle;
  37         $objet = $p->boucles[$id_boucle]->id_table;
  38
  39         // recuperer les parametres : colonne sql (champ)
  40         if (!$colonne = interprete_argument_balise(1, $p)) {
  41                 $msg = array('zbug_balise_sans_argument', array('balise' => ' CHAMP_EXTRA'));
  42                 erreur_squelette($msg, $p);
  43         }
  44
  45         $demande = sinon(interprete_argument_balise(2, $p), "''");
  46         $p->code = "calculer_balise_CHAMP_EXTRA('$objet', $colonne, $demande)";
  47         return $p;
  48 }
  49
  50 /**
  51  * Retourne la description d'un champ extra indiqué
  52  *
  53  * Retourne le tableau de description des options de saisies
  54  * ou un des attributs de ce tableau
  55  *
  56  * @param string $objet
  57  *     Type d'objet
  58  * @param string $colonne
  59  *     Nom de la colonne SQL
  60  * @param string $demande
  61  *     Nom du paramètre demandé.
  62  *     Non renseigné, tout le tableau de description est retourné
  63  * @return mixed
  64  *     - Tableau si toute la description est demandée
  65  *     - Indéfini si un élément spécifique de la description est demandé.
  66  *     - Chaine vide si le champs extra n'est pas trouvé
  67  */
  68 function calculer_balise_CHAMP_EXTRA($objet, $colonne, $demande='') {
  69         // Si la balise n'est pas dans une boucle, on cherche un objet explicite dans le premier argument
  70         // de la forme "trucs/colonne" ou "spip_trucs/colonne"
  71         if (!$objet and $decoupe = explode('/', $colonne) and count($decoupe) == 2){
  72                 $objet = $decoupe[0];
  73                 $colonne = $decoupe[1];
  74         }
  75
  76         // recuperer la liste des champs extras existants
  77         include_spip('cextras_pipelines');
  78         if (!$saisies = champs_extras_objet( $table = table_objet_sql($objet) )) {
  79                 return '';
  80         }
  81
  82         include_spip('inc/saisies');
  83         if (!$saisie = saisies_chercher($saisies, $colonne)) {
  84                 return '';
  85         }
  86
  87         if (!$demande) {
  88                 return $saisie['options']; // retourne la description de la saisie...
  89         }
  90
  91         if (array_key_exists($demande, $saisie['options'])) {
  92                 return $saisie['options'][$demande];
  93         }
  94
  95         return '';
  96 }
  97
  98
  99 /**
 100  * Retourne les choix possibles d'un champ extra donné
 101  *
 102  * @example
 103  *     ```
 104  *     #LISTER_CHOIX{champ}
 105  *     #LISTER_CHOIX{champ, " > "}
 106  *     // ** pour retourner un tableau (cle => valeur),
 107  *     // ou tableau groupe => tableau (cle => valeur) si déclaration de groupements.
 108  *     #LISTER_CHOIX**{champ}
 109  *     ```
 110  *
 111  * @balise
 112  * @param Champ $p
 113  *     AST au niveau de la balise
 114  * @return Champ
 115  *     AST complété par le code PHP de la balise
 116 **/
 117 function balise_LISTER_CHOIX_dist($p) {
 118         // prendre nom de la cle primaire de l'objet pour calculer sa valeur
 119         $id_boucle = $p->nom_boucle ? $p->nom_boucle : $p->id_boucle;
 120
 121         // s'il n'y a pas de nom de boucle, on ne peut pas fonctionner
 122         if (!isset($p->boucles[$id_boucle])) {
 123                 $msg = array('zbug_champ_hors_boucle', array('champ' => ' LISTER_CHOIX'));
 124                 erreur_squelette($msg, $p);
 125                 $p->code = "''";
 126                 return $p;
 127         }
 128
 129         $objet = $p->boucles[$id_boucle]->id_table;
 130
 131         // recuperer les parametres : colonne sql (champ)
 132         if (!$colonne = interprete_argument_balise(1, $p)) {
 133                 $msg = array('zbug_balise_sans_argument',       array('balise' => ' LISTER_CHOIX'));
 134                 erreur_squelette($msg, $p);
 135                 $p->code = "''";
 136                 return $p;
 137         }
 138
 139         $separateur = interprete_argument_balise(2, $p);
 140         if (!$separateur) $separateur = "', '";
 141
 142         // generer le code d'execution
 143         $applatir = ($p->etoile == "**") ? 'false' : 'true';
 144         $p->code = "calculer_balise_LISTER_CHOIX('$objet', $colonne, $applatir)";
 145
 146         // retourne un array si #LISTER_CHOIX**
 147         // sinon fabrique une chaine avec le separateur designe.
 148         if ($p->etoile != "**") {
 149                 $p->code = "(is_array(\$a = $p->code) ? join($separateur, \$a) : " . $p->code . ")";
 150         }
 151
 152         return $p;
 153 }
 154
 155
 156 /**
 157  * Retourne les choix possibles d'un champ extra indiqué
 158  *
 159  * @note
 160  *     Le plugin saisies tolère maintenant des sélections avec
 161  *     un affichage par groupe (optgroup / options) avec une syntaxe
 162  *     spécifique. Ici nous devons pouvoir applatir
 163  *     toutes les cle => valeur.
 164  *
 165  * @param string $objet
 166  *     Type d'objet
 167  * @param string $colonne
 168  *     Nom de la colonne SQL
 169  * @param bool $applatir
 170  *     true pour applatir les choix possibles au premier niveau
 171  *     même si on a affaire à une liste de choix triée par groupe
 172  * @return string|array
 173  *     - Tableau des couples (clé => valeur) des choix
 174  *     - Chaîne vide si le champs extra n'est pas trouvé
 175  */
 176 function calculer_balise_LISTER_CHOIX($objet, $colonne, $applatir = true) {
 177         if ($options = calculer_balise_CHAMP_EXTRA($objet, $colonne)) {
 178                 if (isset($options['datas']) and $options['datas']) {
 179                         include_spip('inc/saisies');
 180                         $choix = saisies_chaine2tableau($options['datas']);
 181                         // applatir les sous-groupes si présents
 182                         if ($applatir) {
 183                                 $choix = saisies_aplatir_tableau($choix);
 184                         }
 185                         return $choix;
 186                 }
 187         }
 188         return '';
 189 }
 190
 191
 192
 193 /**
 194  * Liste les valeurs des champs de type liste (enum, radio, case)
 195  *
 196  * Ces champs enregistrent en base la valeur de la clé
 197  * Il faut donc transcrire clé -> valeur
 198  *
 199  * @example
 200  *     ```
 201  *     #LISTER_VALEURS{champ}
 202  *     #LISTER_VALEURS{champ, " > "}
 203  *     #LISTER_VALEURS**{champ} // retourne un tableau cle/valeur
 204  *     ```
 205  *
 206  * @note
 207  *     Pour des raisons d'efficacité des requetes SQL
 208  *     le paramètre "champ" ne peut être calculé
 209  *     ``#LISTER_VALEURS{#GET{champ}}`` ne peut pas fonctionner.
 210  *
 211  *     Si cette restriction est trop limitative, on verra par la suite
 212  *     pour l'instant, on laisse comme ca...
 213  *
 214  * @balise
 215  * @param Champ $p
 216  *     AST au niveau de la balise
 217  * @return Champ
 218  *     AST complété par le code PHP de la balise
 219  */
 220 function balise_LISTER_VALEURS_dist($p) {
 221         // prendre nom de la cle primaire de l'objet pour calculer sa valeur
 222         $id_boucle = $p->nom_boucle ? $p->nom_boucle : $p->id_boucle;
 223
 224         // s'il n'y a pas de nom de boucle, on ne peut pas fonctionner
 225         if (!isset($p->boucles[$id_boucle])) {
 226                 $msg = array('zbug_champ_hors_boucle', array('champ' => ' LISTER_VALEURS'));
 227                 erreur_squelette($msg, $p);
 228                 $p->code = "''";
 229                 return $p;
 230         }
 231
 232         $objet = $p->boucles[$id_boucle]->id_table;
 233         $_id_objet = $p->boucles[$id_boucle]->primary;
 234         $id_objet = champ_sql($_id_objet, $p);
 235
 236         // recuperer les parametres : colonne sql (champ)
 237         if (!$colonne = interprete_argument_balise(1, $p)) {
 238                 $msg = array('zbug_balise_sans_argument', array('balise' => ' LISTER_VALEURS'));
 239                 erreur_squelette($msg, $p);
 240                 $p->code = "''";
 241                 return $p;
 242         }
 243
 244         $separateur = interprete_argument_balise(2, $p);
 245         if (!$separateur) $separateur = "', '";
 246
 247         // demander la colonne dans la requete SQL
 248         // $colonne doit etre un texte 'nom_du_champ'
 249         if ($p->param[0][1][0]->type != 'texte') {
 250                 $msg = array('cextras:zbug_balise_argument_non_texte', array('nb'=>1, 'balise' => ' LISTER_VALEURS'));
 251                 erreur_squelette($msg, $p);
 252                 $p->code = "''";
 253                 return $p;
 254         }
 255
 256         $texte_colonne = $p->param[0][1][0]->texte;
 257
 258         $valeur = champ_sql($texte_colonne, $p);
 259
 260         // generer le code d'execution
 261         $p->code = "calculer_balise_LISTER_VALEURS('$objet', $colonne, $valeur)";
 262
 263         // retourne un array si #LISTER_VALEURS**
 264         // sinon fabrique une chaine avec le separateur designe.
 265         if ($p->etoile != "**") {
 266                 $p->code = "(is_array(\$a = $p->code) ? join($separateur, \$a) : " . $p->code . ")";
 267         }
 268
 269         return $p;
 270 }
 271
 272
 273 /**
 274  * Retourne liste des valeurs choisies pour un champ extra indiqué
 275  *
 276  * @param string $objet
 277  *     Type d'objet
 278  * @param string $colonne
 279  *     Nom de la colonne SQL
 280  * @param string $cles
 281  *     Valeurs enregistrées pour ce champ dans la bdd pour l'objet en cours
 282  *
 283  * @return string|array
 284  *     - Tableau des couples (clé => valeur) des choix
 285  *     - Chaîne vide si le champs extra n'est pas trouvé
 286 **/
 287 function calculer_balise_LISTER_VALEURS($objet, $colonne, $cles) {
 288
 289         // exploser les cles !
 290         $cles = explode(',', $cles);
 291
 292         // si pas de cles, on part aussi gentiment
 293         if (!$cles) return array();
 294
 295         // recuperer les choix possibles
 296         $choix = calculer_balise_LISTER_CHOIX($objet, $colonne);
 297
 298         // sortir gentiment si pas de champs declares
 299         // on ne peut pas traduire les cles
 300         if (!$choix) return $cles;
 301
 302         // correspondances...
 303         $vals = array_intersect_key($choix, array_flip($cles));
 304
 305         // et voici les valeurs !
 306         return $vals ? $vals : $cles;
 307 }
 308
 309
 310
 311 ?>