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

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

ergonomie : en cas d'erreur sur l'envoi d'un fichier, indiquer que le fichier n'a pas été conservé et qu'on peut donc en renvoyer un autre

File size: 21.2 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                                        $erreurs[$champ].= "<br />"._T('saisies:fichier_erreur_explication_renvoi');
277                                }
278
279                        }
280                        // S'il n'y a pas d'erreur et que la variable de normalisation a été remplie, on l'injecte dans le POST
281                        elseif (!is_null($normaliser) and $verifier['type'] != 'fichiers') {
282                        // Si le nom du champ est un tableau indexé, il faut parser !
283                                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...
284                                        $nom_champ_principal = $separe[1];
285                                        $champ_principal  = _request($nom_champ_principal);
286                                        $enfant = &$champ_principal;
287                                        preg_match_all('/\[([\w]+)\]/', $separe[2], $index);
288                                        // On va chercher au fond du tableau
289                                        foreach ($index[1] as $cle) {
290                                                $enfant = &$enfant[$cle];
291                                        }
292                                        // Une fois descendu tout en bas, on normalise
293                                        $enfant = $normaliser;
294                                        // Et on reinjecte le tout
295                                        set_request($nom_champ_principal,$champ_principal);
296                                } else {
297                                        // Sinon la valeur est juste celle du nom
298                                        set_request($champ, $normaliser);
299                                }
300                        }
301                }
302        }
303        // Vérifier que les valeurs postées sont acceptables, à savoir par exemple que pour un select, ce soit ce qu'on a proposé.
304        if (isset($formulaire['options']['verifier_valeurs_acceptables'])
305                and $formulaire['options']['verifier_valeurs_acceptables']
306        ) {
307                $erreurs = saisies_verifier_valeurs_acceptables($saisies, $erreurs);
308        }
309
310        // Last but not least, on passe nos résultats à un pipeline
311        $erreurs = pipeline(
312                'saisies_verifier',
313                array(
314                        'args'=>array(
315                                'formulaire' => $formulaire,
316                                'saisies' => $saisies,
317                                'erreurs_fichiers' => $erreurs_fichiers,
318                        ),
319                        'data' => $erreurs
320                )
321        );
322
323        return $erreurs;
324}
325
326/**
327 * Vérifier que les valeurs postées sont acceptables,
328 * c'est-à-dire qu'elles ont été proposées lors de la conception de la saisie.
329 * Typiquement pour une saisie radio, vérifier que les gens n'ont pas postée une autre fleur.
330 * @param $saisies array tableau général des saisies, déjà aplati, classé par nom de champ
331 * @param $erreurs array tableau des erreurs
332 * @return array table des erreurs modifiés
333**/
334function saisies_verifier_valeurs_acceptables($saisies, $erreurs) {
335        foreach ($saisies as $saisie => $description) {
336                $type = $description['saisie'];
337
338                // Pas la peine de vérifier si par ailleurs il y a déjà une erreur
339                if (isset($erreurs[$saisie])) {
340                        continue;
341                }
342                //Il n'y a rien à vérifier sur une description / fieldset
343                if (in_array($description['saisie'], array('explication','fieldset'))) {
344                        continue;
345                }
346                if (include_spip("saisies/$type")) {
347                        $f = $type.'_valeurs_acceptables';
348                        if (function_exists($f)) {
349                                $valeur = saisies_request($saisie);
350                                if (!$f($valeur, $description)) {
351                                        $erreurs[$saisie] = _T("saisies:erreur_valeur_inacceptable");
352                                        spip_log("Tentative de poste de valeur innaceptable pour $saisie de type $type. Valeur postée : ".print_r(_request($saisie), true), "saisies"._LOG_AVERTISSEMENT);
353                                }
354                        } else {
355                                spip_log("Pas de fonction de vérification pour la saisie $saisie de type $type", "saisies"._LOG_INFO);
356                        }
357                } else {
358                        spip_log("Pas de fonction de vérification pour la saisie $saisie de type $type", "saisies"._LOG_INFO);
359                }
360        }
361        return $erreurs;
362}
363
364/**
365 * Trouve le résultat d'une saisie (_request())
366 * en tenant compte du fait que la saisie peut être décrit sous forme de sous entrées d'un tableau
367 * @param string $champ nom du champ de la saisie, y compris avec crochets pour sous entrées
368 * return string|array résultat du _request()
369**/
370function saisies_request($champ) {
371        if (preg_match('/([\w]+)((\[[\w]+\])+)/', $champ, $separe)) {
372                $valeur = _request($separe[1]);
373                preg_match_all('/\[([\w]+)\]/', $separe[2], $index);
374                // On va chercher au fond du tableau
375                foreach ($index[1] as $cle) {
376                        $valeur = isset($valeur[$cle]) ? $valeur[$cle] : null;
377                }
378        } else {
379                // Sinon la valeur est juste celle du champ
380                $valeur = _request($champ);
381        }
382        return $valeur;
383}
384/**
385 * Trouve le champ datas ou datas (pour raison historique)
386 * parmis les paramètres d'une saisie
387 * et le retourne après avoir l'avoir transformé en tableau si besoin
388 * @param array $description description de la saisie
389 * @bool $disable_choix : si true, supprime les valeurs contenu dans l'option disable_choix des data
390 * @return array data
391**/
392function saisies_trouver_data($description, $disable_choix = false) {
393        $options = $description['options'];
394        if (isset($options['data'])) {
395                $data = $options['data'];
396        } elseif (isset($options['datas'])) {
397                $data = $options['datas'];
398        } else {
399                $data = array();//normalement on peut pas mais bon
400        }
401        $data = saisies_chaine2tableau($data);
402
403        if ($disable_choix == true and isset($options['disable_choix'])) {
404                $disable_choix = array_flip(explode(',',$options['disable_choix']));
405                $data = array_diff_key($data,$disable_choix);
406        }
407        return $data;
408}
409
410/**
411 * Aplatit une description tabulaire en supprimant les sous-groupes.
412 * Ex : les data d'une saisie de type select
413 * @param string $tab Le tableau à aplatir
414 * @return $nouveau_tab
415 */
416function saisies_aplatir_tableau($tab) {
417        $nouveau_tab = array();
418
419        foreach ($tab as $entree => $contenu) {
420                if (is_array($contenu)) {
421                        foreach ($contenu as $cle => $valeur) {
422                                $nouveau_tab[$cle] = $valeur;
423                        }
424                } else {
425                        $nouveau_tab[$entree] = $contenu;
426                }
427        }
428
429        return $nouveau_tab;
430}
431
432/**
433 * Aplatit une description chaînée, en supprimant les sous-groupes.
434 * @param string $chaine La chaîne à aplatir
435 * @return $chaine
436 */
437function saisies_aplatir_chaine($chaine) {
438        return trim(preg_replace("#(?:^|\n)(\*(?:.*)|/\*)\n#i", "\n", $chaine));
439}
440
441/**
442 * Transforme une chaine en tableau avec comme principe :
443 *
444 * - une ligne devient une case
445 * - si la ligne est de la forme truc|bidule alors truc est la clé et bidule la valeur
446 * - si la ligne commence par * alors on commence un sous-tableau
447 * - si la ligne est égale à /*, alors on fini le sous-tableau
448 *
449 * @param string $chaine Une chaine à transformer
450 * @param string $separateur Séparateur utilisé
451 * @return array Retourne un tableau PHP
452 */
453function saisies_chaine2tableau($chaine, $separateur = "\n") {
454        if ($chaine and is_string($chaine)) {
455                $tableau = array();
456                $soustab = false;
457
458                // On découpe d'abord en lignes
459                $lignes = explode($separateur, $chaine);
460                foreach ($lignes as $i => $ligne) {
461                        $ligne = trim(trim($ligne), '|');
462                        // Si ce n'est pas une ligne sans rien
463                        if ($ligne !== '') {
464                                // si ca commence par * c'est qu'on va faire un sous tableau
465                                if (strpos($ligne, '*') === 0) {
466                                        $soustab=true;
467                                        $soustab_cle = _T_ou_typo(substr($ligne, 1), 'multi');
468                                        if (!isset($tableau[$soustab_cle])) {
469                                                $tableau[$soustab_cle] = array();
470                                        }
471                                } elseif ($ligne == '/*') {//si on finit sous tableau
472                                        $soustab=false;
473                                } else {
474                                        //sinon c'est une entrée normale
475                                        // Si on trouve un découpage dans la ligne on fait cle|valeur
476                                        if (strpos($ligne, '|') !== false) {
477                                                list($cle,$valeur) = explode('|', $ligne, 2);
478                                                // permettre les traductions de valeurs au passage
479                                                if ($soustab == true) {
480                                                        $tableau[$soustab_cle][$cle] = _T_ou_typo($valeur, 'multi');
481                                                } else {
482                                                        $tableau[$cle] = _T_ou_typo($valeur, 'multi');
483                                                }
484                                        } else {
485                                                // Sinon on génère la clé
486                                                if ($soustab == true) {
487                                                        $tableau[$soustab_cle][$i] = _T_ou_typo($ligne, 'multi');
488                                                } else {
489                                                        $tableau[$i] = _T_ou_typo($ligne, 'multi');
490                                                }
491                                        }
492                                }
493                        }
494                }
495                return $tableau;
496        }
497        elseif (is_array($chaine)) {
498                // Si c'est déjà un tableau on lui applique _T_ou_typo (qui fonctionne de manière récursive avant de le renvoyer
499                return _T_ou_typo($chaine, 'multi');
500        }
501        else {
502                return array();
503        }
504}
505
506/**
507 * Transforme un tableau en chaine de caractères avec comme principe :
508 *
509 * - une case de vient une ligne de la chaine
510 * - chaque ligne est générée avec la forme cle|valeur
511 * - si une entrée du tableau est elle même un tableau, on met une ligne de la forme *clef
512 * - pour marquer que l'on quitte un sous-tableau, on met une ligne commencant par /*, sauf si on bascule dans un autre sous-tableau.
513 *
514 * @param array $tableau Tableau à transformer
515 * @return string Texte représentant les données du tableau
516 */
517function saisies_tableau2chaine($tableau) {
518        if ($tableau and is_array($tableau)) {
519                $chaine = '';
520                $avant_est_tableau = false;
521
522                foreach ($tableau as $cle => $valeur) {
523                        if (is_array($valeur)) {
524                                $avant_est_tableau = true;
525                                $ligne=trim("*$cle");
526                                $chaine .= "$ligne\n";
527                                $chaine .= saisies_tableau2chaine($valeur)."\n";
528                        } else {
529                                if ($avant_est_tableau == true) {
530                                        $avant_est_tableau = false;
531                                        $chaine.="/*\n";
532                                }
533                                $ligne = trim("$cle|$valeur");
534                                $chaine .= "$ligne\n";
535                        }
536                }
537                $chaine = trim($chaine);
538
539                return $chaine;
540        }
541        elseif (is_string($tableau)) {
542                // Si c'est déjà une chaine on la renvoie telle quelle
543                return $tableau;
544        }
545        else {
546                return '';
547        }
548}
549
550/**
551 * Transforme une valeur en tableau d'élements si ce n'est pas déjà le cas
552 *
553 * @param mixed $valeur
554 * @return array Tableau de valeurs
555**/
556function saisies_valeur2tableau($valeur) {
557        if (is_array($valeur)) {
558                return $valeur;
559        }
560
561        if (!strlen($valeur)) {
562                return array();
563        }
564
565        $t = saisies_chaine2tableau($valeur);
566        if (count($t) > 1) {
567                return $t;
568        }
569
570        // qu'une seule valeur, c'est qu'elle a peut etre un separateur a virgule
571        // et a donc une cle est 0 dans ce cas la d'ailleurs
572        if (isset($t[0])) {
573                $t = saisies_chaine2tableau($t[0], ',');
574        }
575
576        return $t;
577}
578
579/**
580 * Pour les saisies multiples (type checkbox) proposant un choix alternatif,
581 * retrouve à partir des data de choix proposés
582 * et des valeurs des choix enregistrés
583 * le texte enregistré pour le choix alternatif.
584 *
585 * @param array $data
586 * @param array $valeur
587 * @return string choix_alternatif
588**/
589function saisies_trouver_choix_alternatif($data, $valeur) {
590        if (!is_array($valeur)) {
591                $valeur = saisies_chaine2tableau($valeur) ;
592        }
593        if (!is_array($data)) {
594                $data = saisies_chaine2tableau($data) ;
595        }
596
597        $choix_theorique = array_keys($data);
598        $choix_alternatif = array_values(array_diff($valeur, $choix_theorique));
599        if (isset($choix_alternatif[0])) {
600                return $choix_alternatif[0]; //on suppose que personne ne s'est amusé à proposer deux choix alternatifs
601        } else {
602                return '';
603        }
604}
605
606/**
607 * Génère une page d'aide listant toutes les saisies et leurs options
608 *
609 * Retourne le résultat du squelette `inclure/saisies_aide` auquel
610 * on a transmis toutes les saisies connues.
611 *
612 * @return string Code HTML
613 */
614function saisies_generer_aide() {
615        // On a déjà la liste par saisie
616        $saisies = saisies_lister_disponibles();
617
618        // On construit une liste par options
619        $options = array();
620        foreach ($saisies as $type_saisie => $saisie) {
621                $options_saisie = saisies_lister_par_nom($saisie['options'], false);
622                foreach ($options_saisie as $nom => $option) {
623                        // Si l'option n'existe pas encore
624                        if (!isset($options[$nom])) {
625                                $options[$nom] = _T_ou_typo($option['options']);
626                        }
627                        // On ajoute toujours par qui c'est utilisé
628                        $options[$nom]['utilisee_par'][] = $type_saisie;
629                }
630                ksort($options_saisie);
631                $saisies[$type_saisie]['options'] = $options_saisie;
632        }
633        ksort($options);
634
635        return recuperer_fond(
636                'inclure/saisies_aide',
637                array(
638                        'saisies' => $saisies,
639                        'options' => $options
640                )
641        );
642}
643
644/**
645 * Le tableau de saisies a-t-il une option afficher_si ?
646 *
647 * @param array $saisies Un tableau de saisies
648 * @return boolean
649 */
650function saisies_afficher_si($saisies) {
651        $saisies = saisies_lister_par_nom($saisies, true);
652
653        // Dès qu'il y a au moins une option afficher_si, on l'active
654        foreach ($saisies as $saisie) {
655                if (isset($saisie['options']['afficher_si'])) {
656                        return true;
657                }
658        }
659
660        return false;
661}
662
663
Note: See TracBrowser for help on using the repository browser.