source: spip-zone/_plugins_/saisies/trunk/inc/saisies.php @ 115005

Last change on this file since 115005 was 115005, checked in by maieul@…, 2 years ago

Bugfix. Vérification qu'une saisie obligatoire a bien été remplie : si
la saisie envoie des données tabulaires (type saisie date et heure),
alors il faut vérifier que ces données tabulaires ne soient pas vide.
Merci à Florence Henry pour la remarque.

File size: 21.1 KB
Line 
1<?php
2
3/**
4 * Gestion de l'affichage des saisies
5 *
6 * @package SPIP\Saisies\Saisies
7**/
8
9// Sécurité
10if (!defined('_ECRIRE_INC_VERSION')) {
11        return;
12}
13
14// Différentes méthodes pour trouver les saisies
15include_spip('inc/saisies_lister');
16
17// Différentes méthodes pour manipuler une liste de saisies
18include_spip('inc/saisies_manipuler');
19
20// Les outils pour afficher les saisies et leur vue
21include_spip('inc/saisies_afficher');
22
23// Les outils pour l'affichage conditionnelle des saisies
24include_spip('inc/saisies_afficher_si');
25
26/**
27 * Cherche la description des saisies d'un formulaire CVT dont on donne le nom
28 *
29 * @param string $form Nom du formulaire dont on cherche les saisies
30 * @param array $args Tableau d'arguments du formulaire
31 * @return array Retourne les saisies du formulaire sinon false
32 */
33function saisies_chercher_formulaire($form, $args) {
34        $saisies = array();
35
36        if ($fonction_saisies = charger_fonction('saisies', 'formulaires/'.$form, true)) {
37                $saisies = call_user_func_array($fonction_saisies, $args);
38        }
39
40        // Si on a toujours un tableau, on passe les saisies dans un pipeline normé comme pour CVT
41        if (is_array($saisies)) {
42                $saisies = pipeline(
43                        'formulaire_saisies',
44                        array(
45                                'args' => array('form' => $form, 'args' => $args),
46                                'data' => $saisies
47                        )
48                );
49        }
50
51        if (!is_array($saisies)) {
52                $saisies = false;
53        }
54
55        return $saisies;
56}
57
58/**
59 * Cherche une saisie par son id, son nom ou son chemin et renvoie soit la saisie, soit son chemin
60 *
61 * @param array $saisies Un tableau décrivant les saisies
62 * @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
63 * @param bool $retourner_chemin Indique si on retourne non pas la saisie mais son chemin
64 * @return array Retourne soit la saisie, soit son chemin, soit null
65 */
66function saisies_chercher($saisies, $id_ou_nom_ou_chemin, $retourner_chemin = false) {
67        if (is_array($saisies) and $id_ou_nom_ou_chemin) {
68                if (is_string($id_ou_nom_ou_chemin)) {
69                        $nom = $id_ou_nom_ou_chemin;
70                        // identifiant ? premier caractere @
71                        $id = ($nom[0] == '@');
72
73                        foreach ($saisies as $cle => $saisie) {
74                                $chemin = array($cle);
75                                // notre saisie est la bonne ?
76                                if ($nom == ($id ? $saisie['identifiant'] : $saisie['options']['nom'])) {
77                                        return $retourner_chemin ? $chemin : $saisie;
78                                // sinon a telle des enfants ? et si c'est le cas, cherchons dedans
79                                } elseif (isset($saisie['saisies']) and is_array($saisie['saisies']) and $saisie['saisies']
80                                        and ($retour = saisies_chercher($saisie['saisies'], $nom, $retourner_chemin))) {
81                                                return $retourner_chemin ? array_merge($chemin, array('saisies'), $retour) : $retour;
82                                }
83                        }
84                }
85                elseif (is_array($id_ou_nom_ou_chemin)) {
86                        $chemin = $id_ou_nom_ou_chemin;
87                        $saisie = $saisies;
88
89                        // On vérifie l'existence quand même
90                        foreach ($chemin as $cle) {
91                                if (isset($saisie[$cle])) {
92                                        $saisie = $saisie[$cle];
93                                } else {
94                                        return null;
95                                }
96                        }
97
98                        // Si c'est une vraie saisie
99                        if ($saisie['saisie'] and $saisie['options']['nom']) {
100                                return $retourner_chemin ? $chemin : $saisie;
101                        }
102                }
103        }
104
105        return null;
106}
107
108/**
109 * Génère un nom unique pour un champ d'un formulaire donné
110 *
111 * @param array $formulaire
112 *     Le formulaire à analyser
113 * @param string $type_saisie
114 *     Le type de champ dont on veut un identifiant
115 * @return string
116 *     Un nom unique par rapport aux autres champs du formulaire
117 */
118function saisies_generer_nom($formulaire, $type_saisie) {
119        $champs = saisies_lister_champs($formulaire);
120
121        // Tant que type_numero existe, on incrémente le compteur
122        $compteur = 1;
123        while (array_search($type_saisie.'_'.$compteur, $champs) !== false) {
124                $compteur++;
125        }
126
127        // On a alors un compteur unique pour ce formulaire
128        return $type_saisie.'_'.$compteur;
129}
130
131/**
132 * Crée un identifiant Unique
133 * pour toutes les saisies donnees qui n'en ont pas
134 *
135 * @param Array $saisies Tableau de saisies
136 * @param Bool $regenerer Régénère un nouvel identifiant pour toutes les saisies ?
137 * @return Array Tableau de saisies complété des identifiants
138 */
139function saisies_identifier($saisies, $regenerer = false) {
140        if (!is_array($saisies)) {
141                return array();
142        }
143
144        foreach ($saisies as $k => $saisie) {
145                $saisies[$k] = saisie_identifier($saisie, $regenerer);
146        }
147
148        return $saisies;
149}
150
151/**
152 * Crée un identifiant Unique
153 * pour la saisie donnee si elle n'en a pas
154 * (et pour ses sous saisies éventuels)
155 *
156 * @param Array $saisie Tableau d'une saisie
157 * @param Bool $regenerer Régénère un nouvel identifiant pour la saisie ?
158 * @return Array Tableau de la saisie complété de l'identifiant
159**/
160function saisie_identifier($saisie, $regenerer = false) {
161        if (!isset($saisie['identifiant']) or !$saisie['identifiant']) {
162                $saisie['identifiant'] = uniqid('@');
163        } elseif ($regenerer) {
164                $saisie['identifiant'] = uniqid('@');
165        }
166        if (isset($saisie['saisies']) and is_array($saisie['saisies'])) {
167                $saisie['saisies'] = saisies_identifier($saisie['saisies'], $regenerer);
168        }
169
170        return $saisie;
171}
172
173/**
174 * Vérifier tout un formulaire tel que décrit avec les Saisies
175 *
176 * @param array $formulaire Le contenu d'un formulaire décrit dans un tableau de Saisies
177 * @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).
178 * @param array &$erreurs_fichiers pour les saisies de type fichiers, un tableau qui va stocker champs par champs, puis fichier par fichier, les erreurs de chaque fichier, pour pouvoir ensuite éventuellement supprimer les fichiers erronées de $_FILES
179 * @return array Retourne un tableau d'erreurs
180 */
181function saisies_verifier($formulaire, $saisies_masquees_nulles = true, &$erreurs_fichiers = array()) {
182        include_spip('inc/verifier');
183        $erreurs = array();
184        $verif_fonction = charger_fonction('verifier', 'inc', true);
185
186        if ($saisies_masquees_nulles) {
187                $formulaire = saisies_verifier_afficher_si($formulaire);
188        }
189
190        $saisies = saisies_lister_par_nom($formulaire);
191        foreach ($saisies as $saisie) {
192                $obligatoire = isset($saisie['options']['obligatoire']) ? $saisie['options']['obligatoire'] : '';
193                $champ = $saisie['options']['nom'];
194                $file = (($saisie['saisie'] == 'input' and isset($saisie['options']['type']) and $saisie['options']['type'] == 'file') or $saisie['saisie'] == 'fichiers');
195                if (isset($saisie['verifier']) and $saisie['verifier']) {
196                        $verifier = $saisie['verifier'];
197                } else {
198                        $verifier = false;
199                }
200
201                // Cas de la saisie 'fichiers':
202                if ($file) {
203                        $infos_fichiers_precedents = _request('cvtupload_fichiers_precedents');
204                        if (isset($infos_fichiers_precedents[$champ])) { // si on a déjà envoyé des infos avants
205                                $valeur = $_FILES[$champ]; // on ne met pas true, car il faudra aussi vérifier les nouveaux fichiers du même champ qui viennent d'être envoyés.
206                        }
207                        elseif (isset($_FILES[$champ]['error'])) {//si jamais on a déja envoyé quelque chose dans le précédent envoi = ok
208                                $valeur = null; //On considère que par défaut on a envoyé aucun fichiers
209
210                                // Si c'est un champ unique
211                                if (!is_array($_FILES[$champ]['error']) and $_FILES[$champ]['error'] != 4) {
212                                        $valeur = $_FILES[$champ];
213                                }
214                                elseif (is_array($_FILES[$champ]['error'])) {
215                                        foreach ($_FILES[$champ]['error'] as $err) {
216                                                if ($err != 4) {
217                                                        //Si un seul fichier a été envoyé, même avec une erreur,
218                                                        // on considère que le critère obligatoire est rempli.
219                                                        // Il faudrait que verifier/fichiers.php vérifier les autres types d'erreurs.
220                                                        // Voir http://php.net/manual/fr/features.file-upload.errors.php
221                                                        $valeur = $_FILES[$champ];
222                                                        break;
223                                                }
224                                        }
225                                }
226                        }
227                        elseif (!isset($_FILES[$champ])) {
228                                $valeur = null;
229                        }
230                }
231                // Tout type de saisie, sauf fichiers
232                else {
233                        $valeur = saisies_request($champ);
234                        // Filtrer les tableaux. Ex d'application:
235                        // - saisie date/heure qui envoi des input texte en tableau > il faut pas que les champs envoyés soient vides
236                        // - saisie destintaire, qui pourrait avoir une première option vide
237                        if (is_array($valeur)) {
238                                $valeur = array_filter($valeur);
239                        }
240                }
241                // On regarde d'abord si le champ est obligatoire
242                if (
243                        $obligatoire
244                        and $obligatoire != 'non'
245                        and (
246                                ($file and $valeur==null)
247                                or (!$file and (
248                                        is_null($valeur)
249                                        or (is_string($valeur) and trim($valeur) == '')
250                                        or (is_array($valeur) and count($valeur) == 0)
251                                ))
252                        )
253                ) {
254                        $erreurs[$champ] =
255                                (isset($saisie['options']['erreur_obligatoire']) and $saisie['options']['erreur_obligatoire'])
256                                ? $saisie['options']['erreur_obligatoire']
257                                : _T('info_obligatoire');
258                }
259
260                // On continue seulement si ya pas d'erreur d'obligation et qu'il y a une demande de verif
261                if ((!isset($erreurs[$champ]) or !$erreurs[$champ]) and is_array($verifier) and $verif_fonction) {
262                        // Si on fait une vérification de type fichiers, il n'y a pas vraiment de normalisation, mais un retour d'erreur fichiers par fichiers
263                        if ($verifier['type'] == 'fichiers') {
264                                $normaliser = array();
265                        } else {
266                                $normaliser = null;
267                        }
268
269                        // Si le champ n'est pas valide par rapport au test demandé, on ajoute l'erreur
270                        $options = isset($verifier['options']) ? $verifier['options'] : array();
271                        if ($erreur_eventuelle = $verif_fonction($valeur, $verifier['type'], $options, $normaliser)) {
272                                $erreurs[$champ] = $erreur_eventuelle;
273
274                                if ($verifier['type'] == 'fichiers') { // Pour les vérification/saisies de type fichiers, ajouter les erreurs détaillées par fichiers dans le tableau des erreurs détaillées par fichier
275                                        $erreurs_fichiers[$champ] = $normaliser;
276                                }
277
278                        }
279                        // S'il n'y a pas d'erreur et que la variable de normalisation a été remplie, on l'injecte dans le POST
280                        elseif (!is_null($normaliser) and $verifier['type'] != 'fichiers') {
281                        // Si le nom du champ est un tableau indexé, il faut parser !
282                                if (preg_match('/([\w]+)((\[[\w]+\])+)/', $champ, $separe)) {//même regexp que plus haut, sur mêmes variables. Mais je (Maïeul) préfére faire une duplication car c'est vraiment un code éloigné. Des fois qu'un futur commit changerait la valeur de $separe entre les deux...
283                                        $nom_champ_principal = $separe[1];
284                                        $champ_principal  = _request($nom_champ_principal);
285                                        $enfant = &$champ_principal;
286                                        preg_match_all('/\[([\w]+)\]/', $separe[2], $index);
287                                        // On va chercher au fond du tableau
288                                        foreach ($index[1] as $cle) {
289                                                $enfant = &$enfant[$cle];
290                                        }
291                                        // Une fois descendu tout en bas, on normalise
292                                        $enfant = $normaliser;
293                                        // Et on reinjecte le tout
294                                        set_request($nom_champ_principal,$champ_principal);
295                                } else {
296                                        // Sinon la valeur est juste celle du nom
297                                        set_request($champ, $normaliser);
298                                }
299                        }
300                }
301        }
302        // Vérifier que les valeurs postées sont acceptables, à savoir par exemple que pour un select, ce soit ce qu'on a proposé.
303        if (isset($formulaire['options']['verifier_valeurs_acceptables'])
304                and $formulaire['options']['verifier_valeurs_acceptables']
305        ) {
306                $erreurs = saisies_verifier_valeurs_acceptables($saisies, $erreurs);
307        }
308
309        // Last but not least, on passe nos résultats à un pipeline
310        $erreurs = pipeline(
311                'saisies_verifier',
312                array(
313                        'args'=>array(
314                                'formulaire' => $formulaire,
315                                'saisies' => $saisies,
316                                'erreurs_fichiers' => $erreurs_fichiers,
317                        ),
318                        'data' => $erreurs
319                )
320        );
321
322        return $erreurs;
323}
324
325/**
326 * Vérifier que les valeurs postées sont acceptables,
327 * c'est-à-dire qu'elles ont été proposées lors de la conception de la saisie.
328 * Typiquement pour une saisie radio, vérifier que les gens n'ont pas postée une autre fleur.
329 * @param $saisies array tableau général des saisies, déjà aplati, classé par nom de champ
330 * @param $erreurs array tableau des erreurs
331 * @return array table des erreurs modifiés
332**/
333function saisies_verifier_valeurs_acceptables($saisies, $erreurs) {
334        foreach ($saisies as $saisie => $description) {
335                $type = $description['saisie'];
336
337                // Pas la peine de vérifier si par ailleurs il y a déjà une erreur
338                if (isset($erreurs[$saisie])) {
339                        continue;
340                }
341                //Il n'y a rien à vérifier sur une description / fieldset
342                if (in_array($description['saisie'], array('explication','fieldset'))) {
343                        continue;
344                }
345                if (include_spip("saisies/$type")) {
346                        $f = $type.'_valeurs_acceptables';
347                        if (function_exists($f)) {
348                                $valeur = saisies_request($saisie);
349                                if (!$f($valeur, $description)) {
350                                        $erreurs[$saisie] = _T("saisies:erreur_valeur_inacceptable");
351                                        spip_log("Tentative de poste de valeur innaceptable pour $saisie de type $type. Valeur postée : ".print_r(_request($saisie), true), "saisies"._LOG_AVERTISSEMENT);
352                                }
353                        } else {
354                                spip_log("Pas de fonction de vérification pour la saisie $saisie de type $type", "saisies"._LOG_INFO);
355                        }
356                } else {
357                        spip_log("Pas de fonction de vérification pour la saisie $saisie de type $type", "saisies"._LOG_INFO);
358                }
359        }
360        return $erreurs;
361}
362
363/**
364 * Trouve le résultat d'une saisie (_request())
365 * en tenant compte du fait que la saisie peut être décrit sous forme de sous entrées d'un tableau
366 * @param string $champ nom du champ de la saisie, y compris avec crochets pour sous entrées
367 * return string|array résultat du _request()
368**/
369function saisies_request($champ) {
370        if (preg_match('/([\w]+)((\[[\w]+\])+)/', $champ, $separe)) {
371                $valeur = _request($separe[1]);
372                preg_match_all('/\[([\w]+)\]/', $separe[2], $index);
373                // On va chercher au fond du tableau
374                foreach ($index[1] as $cle) {
375                        $valeur = isset($valeur[$cle]) ? $valeur[$cle] : null;
376                }
377        } else {
378                // Sinon la valeur est juste celle du champ
379                $valeur = _request($champ);
380        }
381        return $valeur;
382}
383/**
384 * Trouve le champ datas ou datas (pour raison historique)
385 * parmis les paramètres d'une saisie
386 * et le retourne après avoir l'avoir transformé en tableau si besoin
387 * @param array $description description de la saisie
388 * @bool $disable_choix : si true, supprime les valeurs contenu dans l'option disable_choix des data
389 * @return array data
390**/
391function saisies_trouver_data($description, $disable_choix = false) {
392        $options = $description['options'];
393        if (isset($options['data'])) {
394                $data = $options['data'];
395        } elseif (isset($options['datas'])) {
396                $data = $options['datas'];
397        } else {
398                $data = array();//normalement on peut pas mais bon
399        }
400        $data = saisies_chaine2tableau($data);
401
402        if ($disable_choix == true and isset($options['disable_choix'])) {
403                $disable_choix = array_flip(explode(',',$options['disable_choix']));
404                $data = array_diff_key($data,$disable_choix);
405        }
406        return $data;
407}
408
409/**
410 * Aplatit une description tabulaire en supprimant les sous-groupes.
411 * Ex : les data d'une saisie de type select
412 * @param string $tab Le tableau à aplatir
413 * @return $nouveau_tab
414 */
415function saisies_aplatir_tableau($tab) {
416        $nouveau_tab = array();
417
418        foreach ($tab as $entree => $contenu) {
419                if (is_array($contenu)) {
420                        foreach ($contenu as $cle => $valeur) {
421                                $nouveau_tab[$cle] = $valeur;
422                        }
423                } else {
424                        $nouveau_tab[$entree] = $contenu;
425                }
426        }
427
428        return $nouveau_tab;
429}
430
431/**
432 * Aplatit une description chaînée, en supprimant les sous-groupes.
433 * @param string $chaine La chaîne à aplatir
434 * @return $chaine
435 */
436function saisies_aplatir_chaine($chaine) {
437        return trim(preg_replace("#(?:^|\n)(\*(?:.*)|/\*)\n#i", "\n", $chaine));
438}
439
440/**
441 * Transforme une chaine en tableau avec comme principe :
442 *
443 * - une ligne devient une case
444 * - si la ligne est de la forme truc|bidule alors truc est la clé et bidule la valeur
445 * - si la ligne commence par * alors on commence un sous-tableau
446 * - si la ligne est égale à /*, alors on fini le sous-tableau
447 *
448 * @param string $chaine Une chaine à transformer
449 * @param string $separateur Séparateur utilisé
450 * @return array Retourne un tableau PHP
451 */
452function saisies_chaine2tableau($chaine, $separateur = "\n") {
453        if ($chaine and is_string($chaine)) {
454                $tableau = array();
455                $soustab = false;
456
457                // On découpe d'abord en lignes
458                $lignes = explode($separateur, $chaine);
459                foreach ($lignes as $i => $ligne) {
460                        $ligne = trim(trim($ligne), '|');
461                        // Si ce n'est pas une ligne sans rien
462                        if ($ligne !== '') {
463                                // si ca commence par * c'est qu'on va faire un sous tableau
464                                if (strpos($ligne, '*') === 0) {
465                                        $soustab=true;
466                                        $soustab_cle = _T_ou_typo(substr($ligne, 1), 'multi');
467                                        if (!isset($tableau[$soustab_cle])) {
468                                                $tableau[$soustab_cle] = array();
469                                        }
470                                } elseif ($ligne == '/*') {//si on finit sous tableau
471                                        $soustab=false;
472                                } else {
473                                        //sinon c'est une entrée normale
474                                        // Si on trouve un découpage dans la ligne on fait cle|valeur
475                                        if (strpos($ligne, '|') !== false) {
476                                                list($cle,$valeur) = explode('|', $ligne, 2);
477                                                // permettre les traductions de valeurs au passage
478                                                if ($soustab == true) {
479                                                        $tableau[$soustab_cle][$cle] = _T_ou_typo($valeur, 'multi');
480                                                } else {
481                                                        $tableau[$cle] = _T_ou_typo($valeur, 'multi');
482                                                }
483                                        } else {
484                                                // Sinon on génère la clé
485                                                if ($soustab == true) {
486                                                        $tableau[$soustab_cle][$i] = _T_ou_typo($ligne, 'multi');
487                                                } else {
488                                                        $tableau[$i] = _T_ou_typo($ligne, 'multi');
489                                                }
490                                        }
491                                }
492                        }
493                }
494                return $tableau;
495        }
496        elseif (is_array($chaine)) {
497                // Si c'est déjà un tableau on lui applique _T_ou_typo (qui fonctionne de manière récursive avant de le renvoyer
498                return _T_ou_typo($chaine, 'multi');
499        }
500        else {
501                return array();
502        }
503}
504
505/**
506 * Transforme un tableau en chaine de caractères avec comme principe :
507 *
508 * - une case de vient une ligne de la chaine
509 * - chaque ligne est générée avec la forme cle|valeur
510 * - si une entrée du tableau est elle même un tableau, on met une ligne de la forme *clef
511 * - pour marquer que l'on quitte un sous-tableau, on met une ligne commencant par /*, sauf si on bascule dans un autre sous-tableau.
512 *
513 * @param array $tableau Tableau à transformer
514 * @return string Texte représentant les données du tableau
515 */
516function saisies_tableau2chaine($tableau) {
517        if ($tableau and is_array($tableau)) {
518                $chaine = '';
519                $avant_est_tableau = false;
520
521                foreach ($tableau as $cle => $valeur) {
522                        if (is_array($valeur)) {
523                                $avant_est_tableau = true;
524                                $ligne=trim("*$cle");
525                                $chaine .= "$ligne\n";
526                                $chaine .= saisies_tableau2chaine($valeur)."\n";
527                        } else {
528                                if ($avant_est_tableau == true) {
529                                        $avant_est_tableau = false;
530                                        $chaine.="/*\n";
531                                }
532                                $ligne = trim("$cle|$valeur");
533                                $chaine .= "$ligne\n";
534                        }
535                }
536                $chaine = trim($chaine);
537
538                return $chaine;
539        }
540        elseif (is_string($tableau)) {
541                // Si c'est déjà une chaine on la renvoie telle quelle
542                return $tableau;
543        }
544        else {
545                return '';
546        }
547}
548
549/**
550 * Transforme une valeur en tableau d'élements si ce n'est pas déjà le cas
551 *
552 * @param mixed $valeur
553 * @return array Tableau de valeurs
554**/
555function saisies_valeur2tableau($valeur) {
556        if (is_array($valeur)) {
557                return $valeur;
558        }
559
560        if (!strlen($valeur)) {
561                return array();
562        }
563
564        $t = saisies_chaine2tableau($valeur);
565        if (count($t) > 1) {
566                return $t;
567        }
568
569        // qu'une seule valeur, c'est qu'elle a peut etre un separateur a virgule
570        // et a donc une cle est 0 dans ce cas la d'ailleurs
571        if (isset($t[0])) {
572                $t = saisies_chaine2tableau($t[0], ',');
573        }
574
575        return $t;
576}
577
578/**
579 * Pour les saisies multiples (type checkbox) proposant un choix alternatif,
580 * retrouve à partir des data de choix proposés
581 * et des valeurs des choix enregistrés
582 * le texte enregistré pour le choix alternatif.
583 *
584 * @param array $data
585 * @param array $valeur
586 * @return string choix_alternatif
587**/
588function saisies_trouver_choix_alternatif($data, $valeur) {
589        if (!is_array($valeur)) {
590                $valeur = saisies_chaine2tableau($valeur) ;
591        }
592        if (!is_array($data)) {
593                $data = saisies_chaine2tableau($data) ;
594        }
595
596        $choix_theorique = array_keys($data);
597        $choix_alternatif = array_values(array_diff($valeur, $choix_theorique));
598        if (isset($choix_alternatif[0])) {
599                return $choix_alternatif[0]; //on suppose que personne ne s'est amusé à proposer deux choix alternatifs
600        } else {
601                return '';
602        }
603}
604
605/**
606 * Génère une page d'aide listant toutes les saisies et leurs options
607 *
608 * Retourne le résultat du squelette `inclure/saisies_aide` auquel
609 * on a transmis toutes les saisies connues.
610 *
611 * @return string Code HTML
612 */
613function saisies_generer_aide() {
614        // On a déjà la liste par saisie
615        $saisies = saisies_lister_disponibles();
616
617        // On construit une liste par options
618        $options = array();
619        foreach ($saisies as $type_saisie => $saisie) {
620                $options_saisie = saisies_lister_par_nom($saisie['options'], false);
621                foreach ($options_saisie as $nom => $option) {
622                        // Si l'option n'existe pas encore
623                        if (!isset($options[$nom])) {
624                                $options[$nom] = _T_ou_typo($option['options']);
625                        }
626                        // On ajoute toujours par qui c'est utilisé
627                        $options[$nom]['utilisee_par'][] = $type_saisie;
628                }
629                ksort($options_saisie);
630                $saisies[$type_saisie]['options'] = $options_saisie;
631        }
632        ksort($options);
633
634        return recuperer_fond(
635                'inclure/saisies_aide',
636                array(
637                        'saisies' => $saisies,
638                        'options' => $options
639                )
640        );
641}
642
643/**
644 * Le tableau de saisies a-t-il une option afficher_si ?
645 *
646 * @param array $saisies Un tableau de saisies
647 * @return boolean
648 */
649function saisies_afficher_si($saisies) {
650        $saisies = saisies_lister_par_nom($saisies, true);
651
652        // Dès qu'il y a au moins une option afficher_si, on l'active
653        foreach ($saisies as $saisie) {
654                if (isset($saisie['options']['afficher_si'])) {
655                        return true;
656                }
657        }
658
659        return false;
660}
661
662
Note: See TracBrowser for help on using the repository browser.