source: spip-zone/_plugins_/fabrique/fabrique_fonctions.php @ 62782

Last change on this file since 62782 was 62782, checked in by marcimat@…, 7 years ago

Encore des notices PHP à la création d'un nouvel objet

File size: 20.1 KB
Line 
1<?php
2
3if (!defined("_ECRIRE_INC_VERSION")) return;
4
5
6/**
7 * Determiner le repertoire de travail
8 * de la Fabrique. Dans
9 * - plugins/fabrique_auto si possible, sinon dans
10 * - tmp/cache/fabrique
11 *
12 * @return string
13 *              Le chemin de destination depuis la racine de SPIP.
14**/
15function fabrique_destination() {
16        static $destination = null;
17        if (is_null($destination)) {
18                if (is_writable(_DIR_PLUGINS . rtrim(FABRIQUE_DESTINATION_PLUGINS, '/'))) {
19                        $destination = _DIR_PLUGINS . FABRIQUE_DESTINATION_PLUGINS;
20                } else {
21                        sous_repertoire(_DIR_CACHE, rtrim(FABRIQUE_DESTINATION_CACHE, '/'));
22                        $destination = _DIR_CACHE . FABRIQUE_DESTINATION_CACHE;
23                }
24        }
25        return $destination;
26}
27
28
29/**
30 * Crée l'arborescence manquante
31 * sous_repertoire_complet('a/b/c/d');
32 * appelle sous_repertoire() autant de fois que necessaire.
33**/
34function sous_repertoire_complet($arbo) {
35        $a = explode('/', $arbo);
36        if ($a[0] == '.' OR $a[0] == '..') {
37                $base = $a[0] . '/' . $a[1];
38                array_shift($a);
39                array_shift($a);
40        } else {
41                $base = $a[0];
42                array_shift($a);
43        }
44
45        foreach ($a as $dir) {
46                $base .= '/' . $dir;
47                sous_repertoire($base);
48        }
49}
50
51
52/**
53 * Concatene en utilisant implode un tableau, de maniere recursive
54 *
55 * @param array $tableau
56 *              Tableau a transformer
57 * @param string $glue
58 *              Chaine inseree entre les valeurs
59 * @return string
60 *              Chaine concatenee
61**/
62function fabrique_implode_recursif($tableau, $glue='') {
63        if (!is_array($tableau)) {
64                return false;
65        }
66
67        foreach ($tableau as $c =>$valeur) {
68                if (is_array($valeur)) {
69                        $tableau[$c] = fabrique_implode_recursif($valeur, $glue);
70                }
71        }
72
73        return implode($glue, $tableau);
74}
75
76
77/**
78 * Fait écrire <?php 
79 * sans que ce php soit execute par SPIP !
80**/
81function balise_PHP_dist($p) {
82        $p->code = "'<?php echo \'<?php\n\'; ?>'";
83        $p->interdire_scripts = false;
84        return $p;
85}
86
87/**
88 * Convertie une chaine pour en faire une chaine de langue
89 * &#xxx => le bon caractère
90 * ' => \'
91 *
92**/
93function chaine_de_langue($texte) {
94        $texte = html_entity_decode($texte, ENT_QUOTES, 'UTF-8');
95        # egalement
96        # http://www.php.net/manual/fr/function.html-entity-decode.php#104617
97
98        return addslashes($texte);
99}
100
101/**
102 * Modifie le nom de la cle de langue pour
103 * utiliser le vrai nom de l'objet
104 *
105 * titre_objets => titre_chats
106 * icone_creer_objet => icone_creer_chat
107**/
108function cle_de_langue($cle, $desc_objet) {
109        // on permet d'echapper \objets pour trouver 'objets' au bout du compte
110        // sans qu'il soit transforme dans le nom reel de l'objet
111        // cas : 'prive/\objets/infos/objet.html' => 'prive/objets/infos/nom.html'
112        $cle = str_replace("\o", "\1o\\", $cle);
113        $cle =  str_replace(
114                array('objets', 'objet'),
115                array($desc_objet['objet'], $desc_objet['type']), $cle);
116        return str_replace("\1o\\", "o", $cle);
117}
118
119/**
120 * Identique a |cle_de_langue sur toutes les valeurs d'un tableau
121 *
122**/
123function tab_cle_de_langue($tableau, $desc_objet) {
124        foreach($tableau as $c => $v) {
125                $tableau[$c] = cle_de_langue($v, $desc_objet);
126        }
127        return $tableau;
128}
129
130/**
131 * Cherche s'il existe une chaine de langue pour les cles de tableaux
132 * et ajoute alors la traduction dans la valeur de ce tableau
133 *
134 * @param array $tableau
135 *              Tableau cle => texte
136 * @param string $prefixe_cle
137 *              Prefixe ajoute aux cles pour chercher les trads
138 * @param string $sep
139 *              Séparateur entre l'ancienne valeur et la concaténation de traduction
140 * @return array
141 *              Le tableau complété
142**/
143function tab_cle_traduite_ajoute_dans_valeur($tableau, $prefixe_cle="", $sep = "&nbsp;: ") {
144        foreach($tableau as $c => $v) {
145                $trad = _T("fabrique:". $prefixe_cle . $c, array(), array('force' => false));
146                if ($trad) {
147                        $tableau[$c] = $v . $sep . $trad;
148                } else {
149                        $tableau[$c] = $v;
150                }
151        }
152        return $tableau;
153}
154
155/**
156 * Équivalent de wrap() sur les valeurs du tableau
157 *
158 * @param array $tableau
159 *              Tableau cle => texte
160 * @param string $balise
161 *              Balise qui encapsule
162 * @return array $tableau
163 *              Tableau cle => <balise>texte</balise>
164**/
165function tab_wrap($tableau, $balise) {
166        foreach ($tableau as $c => $v) {
167                $tableau[$c] = wrap($v, $balise);
168        }
169        return $tableau;
170}
171
172
173/**
174 * Fabrique un tableau de chaines de langues
175 * avec des cles d'origines passees dans la fonctions
176 * cle_de_langue, et trie.
177**/
178function fabriquer_tableau_chaines($objet) {
179        $chaines = array();
180        if (!is_array($objet)) { return $chaines; }
181        if (!$table = $objet['table'] OR !is_array($objet['chaines'])) { return $chaines; }
182        // les chaines definies pour l'objet
183        foreach ($objet['chaines'] as $cle => $chaine) {
184                $chaines[ cle_de_langue($cle, $objet) ] = $chaine;
185        }
186        // les chaines definies pour chaque champ de l'objet
187        if (is_array($objet['champs'])) {
188                foreach ($objet['champs'] as $info) {
189                        $chaines[ cle_de_langue('label_' . $info['champ'], $objet) ] = $info['nom'];
190                        if ($info['explication']) {
191                                $chaines[ cle_de_langue('explication_' . $info['champ'], $objet) ] = $info['explication'];
192                        }
193                }
194        }
195        ksort($chaines);
196        return $chaines;
197}
198
199
200/**
201 * Indique si le champ est présent dans l'objet
202 * (un champ au sens sql)
203**/
204function champ_present($objet, $champ) {
205        if (is_array($objet['champs'])) {
206                foreach ($objet['champs'] as $info) {
207                        if ($info['champ'] == $champ) {
208                                return " "; // true
209                        }
210                }
211        }
212        // id_rubrique, id_secteur
213        if (isset($objet['rubriques']) AND is_array($objet['rubriques'])) {
214                if (in_array($champ, $objet['rubriques'])) {
215                        return " "; // true
216                }
217        }
218        // lang, langue_choisie, id_trad
219        if (isset($objet['langues']) AND is_array($objet['langues'])) {
220                if (in_array($champ, $objet['langues'])) {
221                        return " "; // true
222                }
223                if ($objet['langues']['lang'] and ($champ == 'langue_choisie')) {
224                        return " "; // true
225                }
226        }
227        // date
228        if ($objet['champ_date']) {
229                if ($champ == $objet['champ_date']) {
230                        return " "; // true
231                }
232        }
233        // statut
234        if ($objet['statut']) {
235                if ($champ == 'statut') {
236                        return " "; // true
237                }
238        }
239
240        return ""; // false
241}
242
243
244/**
245 * Indique si toutes les options sont présentes dans l'objet
246 * (c'est a dire une cle de configuration, pas un nom de champ SQL)
247**/
248function options_presentes($objet, $champs) {
249        if (!$champs) return false;
250        if (!is_array($champs)) $champs = array($champs);
251        foreach ($champs as $champ) {
252                if (!option_presente($objet, $champ)) {
253                        return ""; // false
254                }
255        }
256        return " "; // true
257
258}
259
260/**
261 * Indique si une option est présente dans l'objet
262 * (c'est a dire une cle de configuration, pas un nom de champ SQL)
263**/
264function option_presente($objet, $champ) {
265        // a la racine
266        if (isset($objet[$champ]) and $objet[$champ]) {
267                return " "; // true
268        }
269
270        // id_rubrique, vue_rubrique
271        if (isset($objet['rubriques']) AND is_array($objet['rubriques'])) {
272                if (in_array($champ, $objet['rubriques'])) {
273                        return " "; // true
274                }
275        }
276
277        // lang, id_trad
278        if (isset($objet['langues']) AND is_array($objet['langues'])) {
279                if (in_array($champ, $objet['langues'])) {
280                        return " "; // true
281                }
282        }
283       
284        // menu_edition, outils_rapides
285        if (isset($objet['boutons']) AND is_array($objet['boutons'])) {
286                if (in_array($champ, $objet['boutons'])) {
287                        return " "; // true
288                }
289        }
290
291        return ""; // false
292}
293
294
295// indique si une option donnée est presente dans le champ
296function champ_option_presente($champ, $option) {
297        if (isset($champ[$option]) and $champ[$option]) {
298                return " "; // true
299        }
300
301        // editable, versionne, obligatoire
302        if (is_array($champ['caracteristiques'])) {
303                if (in_array($option, $champ['caracteristiques'])) {
304                        return " "; // true
305                }
306        }
307
308        return false;
309}
310
311/**
312 * Retourne les objets possedant un certain champ (au sens sql)
313 * Cela simplifie des boucles DATA
314 * #OBJETS|objets_champ_present{id_rubrique}
315 *
316 * On peut ne retourner qu'une liste de type de valeur (objet, type, id_objet)
317 * #OBJETS|objets_champ_present{id_rubrique, objet} // chats,souris
318**/
319function objets_champ_present($objets, $champ, $type='') {
320        return _tableau_option_presente('champ_present', $objets, $champ, $type);
321}
322
323
324/**
325 * Retourne les objets possedant une certaine option
326 * (au sens des cles du formulaire de configuration de l'objet)
327 *
328 * #OBJETS|objets_option_presente{vue_rubrique}
329 * #OBJETS|objets_option_presente{auteurs_liens}
330 *
331 * On peut ne retourner qu'une liste de type de valeur (objet, type, id_objet)
332 * #OBJETS|objets_option_presente{auteurs_liens, objet} // chats,souris
333 *
334**/
335function objets_option_presente($objets, $option, $type='') {
336        return _tableau_option_presente('option_presente', $objets, $option, $type);
337}
338
339
340/**
341 * Retourne les objets possedant plusieurs options
342 * (au sens des cles du formulaire de configuration de l'objet)
343 *
344 * #OBJETS|objets_options_presentes{#LISTE{table_liens,vue_liens}}
345 *
346 * On peut ne retourner qu'une liste de type de valeur (objet, type, id_objet)
347 * #OBJETS|objets_options_presentes{#LISTE{table_liens,vue_liens}, objet} // chats,souris
348 *
349**/
350function objets_options_presentes($objets, $options, $type='') {
351        return _tableau_options_presentes('option_presente', $objets, $options, $type);
352}
353
354/**
355 * Retourne des champs en fonction des options trouvees
356 * #CHAMPS|champs_option_presente{editable}
357 * #CHAMPS|champs_option_presente{versionne}
358**/
359function champs_option_presente($champs, $option, $type='') {
360        return _tableau_option_presente('champ_option_presente', $champs, $option, $type);
361}
362
363/**
364 * Retourne des champs en fonction des options trouvees
365 * #CHAMPS|champs_options_presentes{#LISTE{obligatoire,saisie}}
366**/
367function champs_options_presentes($champs, $options, $type='') {
368        return _tableau_options_presentes('champ_option_presente', $champs, $options, $type);
369}
370
371
372// fonction generique pour retourner une liste de choses dans un tableau
373function _tableau_option_presente($func, $tableau, $option, $type='') {
374        $o = array();
375
376        if (!is_array($tableau) OR !$func) {
377                return $o;
378        }
379        // tableau est un tableau complexe de donnee
380        foreach ($tableau as $objet) {
381                // on cherche la donnee 'option' dans le tableau
382                // en utilisant une fonction specifique de recherche (option_presente, champ_present, ...)
383                if ($func($objet, $option)) {
384                        // si on a trouve notre option :
385                        // type permet de recuperer une cle specifique dans la liste des cles parcourues.
386                        // sinon, retourne tout le sous tableau.
387                        if ($type and isset($objet[$type])) {
388                                $o[] = $objet[$type];
389                        } elseif (!$type) {
390                                $o[] = $objet;
391                        }
392                }
393        }
394        return $o;
395}
396
397// fonction generique pour retourner une liste de choses multiples dans un tableau
398function _tableau_options_presentes($func, $tableau, $options, $type='') {
399        if (!$options) return array();
400
401        if (!is_array($options)) {
402                $options = array($options);
403        }
404
405        $first = false;
406        foreach ($options as $option) {
407                $r = _tableau_option_presente($func, $tableau, $option, $type);
408                if (!$first) {
409                        $res = $r;
410                        $first = true;
411                } else {
412                        $res = array_intersect($res, $r);
413                }
414        }
415
416        return $res;
417}
418
419
420/**
421 * Retourne une ecriture de criteres
422 * {id_parent?}{id_documentation?}
423 * avec tous les champs id_x declares dans l'interface
424 * dans la liste des champs.
425 *
426 * Cela ne concerne pas les champs speciaux (id_rubrique, id_secteur, id_trad)
427 * qui ne seront pas inclus.
428 *
429 * @param array $objet
430 *              Description de l'objet
431 * @return string
432 *              L'écriture des criteres de boucle
433**/
434function criteres_champs_id($objet) {
435        $ids = array();
436        if (is_array($objet['champs'])) {
437                foreach ($objet['champs'] as $info) {
438                        if (substr($info['champ'], 0, 3) == 'id_') {
439                                $ids[] = $info['champ'];
440                        }
441                }
442        }
443        if (!$ids) {
444                return "";
445        }
446        return "{" . implode("?}{", $ids) . "?}";
447}
448
449/**
450 * Retourne un tableau de toutes les tables SQL
451 * pour tous les objets.
452 *
453 * Avec le second paramètre, on peut ne récupérer que :
454 * - 'tout' => toutes les tables (par défaut)
455 * - 'objets' => les tables d'objet (spip_xx, spip_yy)
456 * - 'liens' => les tables de liens (spip_xx_liens, spip_yy_liens)
457 *
458**/
459function fabrique_lister_tables($objets, $quoi='tout') {
460        static $tables = array();
461
462        if (!$objets) return array();
463
464        $hash = md5(serialize($objets));
465       
466        if (!isset($tables[$hash])) {
467                $tables[$hash] = array(
468                        'tout' => array(),
469                        'objets' => array(),
470                        'liens' => array(),
471                );
472                foreach ($objets as $o) {
473                        // tables principales
474                        if (isset($o['table']) and $o['table']) {
475                                $tables[$hash]['objets'][] = $o['table'];
476                                $tables[$hash]['tout'][] = $o['table'];
477                                // tables de liens
478                                if ($o['table_liens']) {
479                                        $tables[$hash]['liens'][] = $o['nom_table_liens'];
480                                        $tables[$hash]['tout'][]  = $o['nom_table_liens'];
481                                }
482                        }
483                }
484        }
485       
486        return $tables[$hash][$quoi];
487}
488
489
490// indique si un des objets a besoin du pipeline demande
491function fabrique_necessite_pipeline($objets, $pipeline) {
492
493        if (!$objets) return false;
494
495        switch ($pipeline) {
496                case "autoriser":
497                case "declarer_tables_objets_sql":
498                case "declarer_tables_interfaces":
499                        return (bool)fabrique_lister_tables($objets, 'objets');
500                        break;
501
502                case "declarer_tables_auxiliaires":
503                        return (bool)fabrique_lister_tables($objets, 'liens');
504                        break;
505
506                case "affiche_enfants":
507                        if (objets_option_presente($objets, 'vue_rubrique')) {
508                                return true;
509                        }
510                        break;
511
512                case "affiche_milieu":
513                        if (objets_option_presente($objets, 'auteurs_liens')
514                        OR  objets_options_presentes($objets, array('table_liens', 'vue_liens'))) {
515                                return true;
516                        }
517                        break;
518
519                case "affiche_auteurs_interventions":
520                        if (objets_option_presente($objets, 'vue_auteurs_liens')) {
521                                return true;
522                        }
523                        break;
524
525                case "afficher_contenu_objet":
526                        return false;
527                        break;
528
529                case "optimiser_base_disparus":
530                        # nettoie depuis spip_{objet}_liens
531                        # mais aussi les liaisions vers spip_{objet} (uniquement si une table de liens existe)
532                        return (bool)fabrique_lister_tables($objets, 'liens');
533                        #return (bool)fabrique_lister_tables($objets, 'objets');
534                        break;
535        }
536        return false;
537}
538
539
540/**
541 * Un peu equivalent a var_export
542 * si $quote = true, on applique sql_quote sur tous les champs
543 *
544 * @param array $tableau
545 *              Le tableau dont on veut obtenir le code de creation array( ... )
546 * @param bool $quote
547 *              Appliquer sql_quote() sur chaque valeur (dans le code retourne)
548 * @param string $defaut
549 *              Si $tableau est vide ou n'est pas une chaine, la fonction retourne cette valeur
550 * @return string
551 *              Le code de creation du tableau, avec eventuellement le code pour appliquer sql_quote.
552 *
553**/
554function ecrire_tableau($tableau, $quote = false, $defaut = "array()") {
555        // pas de tableau ?
556        if (!is_array($tableau) OR !count($tableau)) {
557                return $defaut;
558        }
559
560        $res = "array('" . implode("', '", array_map('addslashes', $tableau)) . "')";
561
562        if ($quote) {
563                $res = "array_map('sql_quote', $res)";
564        }
565        return $res;
566}
567
568/**
569 * Identique a ecrire_tableau() mais ne retourne rien si le tableau est vide
570 *
571**/
572function ecrire_tableau_sinon_rien($tableau, $quote = false) {
573        return ecrire_tableau($tableau, $quote, "");
574}
575
576// un peu equivalent a str_pad mais avec une valeur par defaut.
577function espacer($texte, $taille = 0) {
578        if (!$taille) $taille = _FABRIQUE_ESPACER;
579        return str_pad($texte, $taille);
580}
581
582
583// tabule a gauche chaque ligne du nombre de tabulations indiquees
584// + on enleve les espaces sur les lignes vides
585function fabrique_tabulations($texte, $nb_tabulations) {
586        $tab = "";
587        if ($nb_tabulations) {
588                $tab = str_pad("\t", $nb_tabulations);
589        }
590        $texte = explode("\n", $texte);
591        foreach ($texte as $c => $ligne) {
592                $l = ltrim(ltrim($ligne), "\t");
593                if (!$l) {
594                        $texte[$c] = "";
595                } else {
596                        $texte[$c] = $tab . $ligne;
597                }
598        }
599        return implode("\n", $texte);
600}
601
602
603
604
605/**
606 * Passer en majuscule en utilisant mb de preference
607 * s'il est disponible.
608 *
609 * @param string $str
610 *              La chaine a passer en majuscule
611 * @return string
612 *              La chaine en majuscule
613**/
614function fabrique_mb_strtoupper($str) {
615        if (function_exists('mb_strtoupper')) {
616                return mb_strtoupper($str);
617        } else {
618                return strtoupper($str);
619        }
620}
621
622/**
623 * Passer en minuscule en utilisant mb de preference
624 * s'il est disponible.
625 *
626 * @param string $str
627 *              La chaine a passer en minuscule
628 * @return string
629 *              La chaine en minuscule
630**/
631function fabrique_mb_strtolower($str) {
632        if (function_exists('mb_strtolower')) {
633                return mb_strtolower($str);
634        } else {
635                return strtolower($str);
636        }
637}
638
639
640// Afficher une image a partir d'un fichier, selon une reduction donnee
641// (evite un |array_shift qui passe pas en PHP 5.4)
642// Attention à bien rafraichir l'image reduite lorsqu'on change de logo
643// #URL_IMAGE|image_reduire{128}|extraire_attribut{src}|explode{?}|array_shift|timestamp|balise_img
644function filtre_fabrique_miniature_image($fichier, $taille=256) {
645        $im = filtrer('image_reduire', $fichier, $taille);
646        $im = extraire_attribut($im, 'src');
647        $im = explode('?', $im);
648        $im = array_shift($im);
649        $im = timestamp($im);
650        $im = filtrer('balise_img', $im);
651        return $im;
652}
653
654
655
656/**
657 * Retourne un tableau table_sql=>Nom des objets de SPIP
658 * complété des objets declares dans la fabrique ainsi
659 * que de tables indiquees même si elles ne font pas parties
660 * de declarations connues.
661 *
662 * @param array $objets_fabrique
663 *              Déclaration d'objets de la fabrique
664 * @param array $inclus
665 *              Liste de tables SQL que l'on veut forcement presentes
666 *              meme si l'objet n'est pas declare
667 * @param array $exclus
668 *              Liste de tables SQL que l'on veut forcement exclues
669 *              meme si l'objet n'est pas declare
670 * @return array
671 *              Tableau table_sql => Nom
672**/
673function filtre_fabrique_lister_objets_editoriaux($objets_fabrique, $inclus=array(), $exclus=array()) {
674
675        // les objets existants
676        $objets = lister_tables_objets_sql();
677        foreach ($objets as $sql => $o) {
678                if ($o['editable']) {
679                        $liste[$sql] = _T($o['texte_objets']);
680                }
681        }
682        unset($objets);
683
684        // les objets de la fabrique
685        foreach ($objets_fabrique as $o) {
686                if (isset($o['table']) and !isset($liste[$o['table']])) {
687                        $liste[ $o['table'] ] = $o['nom'];
688                }
689        }
690
691        // des objets qui n'existent pas mais qui sont actuellement coches dans la saisie
692        foreach ($inclus as $sql) {
693                if (!isset($liste[$sql])) {
694                        $liste[$sql] = $sql; // on ne connait pas le nom
695                }
696        }
697
698        // tables forcement exclues
699        foreach ($exclus as $sql) {
700                unset($liste[$sql]);
701        }
702        // enlever un eventuel element vide
703        unset($liste['']);
704
705        asort($liste);
706
707        return $liste;
708}
709
710
711/**
712 * Retourne le code pour tester un type d'autorisation
713 *
714 * @param string $type
715 *              Quelle type d'autorisation est voulue
716 * @return string
717 *              Code de test de l'autorisation
718**/
719function fabrique_code_autorisation($type) {
720        switch($type) {
721
722                case "jamais":
723                        return "false";
724                        break;
725
726                case "toujours":
727                        return "true";
728                        break;
729
730                case "redacteur":
731                        return "in_array(\$qui['statut'], array('0minirezo', '1comite'))";
732                        break;
733
734                case "administrateur_restreint":
735                        return "\$qui['statut'] == '0minirezo'";
736                        break;
737
738                case "administrateur":
739                        return "\$qui['statut'] == '0minirezo' AND !\$qui['restreint']";
740                        break;
741
742                case "webmestre":
743                        return "autoriser('webmestre', '', '', \$qui)";
744                        break;
745
746        }
747
748        return "";
749}
750
751/**
752 * Retourne la valeur de type d'autorisation
753 * qui s'applique par defaut pour une autorisation donnee
754 *
755 * @param string $autorisation
756 *              Nom de l'autorisation (objet et objets remplacent le veritable type et nom d'objet)
757 * @return string
758 *              Type d'autorisation par defaut (jamais, toujours, redacteur, ...)
759**/
760function fabrique_autorisation_defaut($autorisation) {
761        switch($autorisation) {
762                case 'objet_voir':
763                        return "toujours";
764                        break;
765
766                case 'objet_creer':
767                case 'objet_modifier':
768                        return "redacteur";
769                        break;
770
771                case 'objet_supprimer':
772                case 'associerobjet':
773                        return "administrateur";
774                        break;
775        }
776}
777
778/**
779 * Retourne le code d'autorisation indique
780 * sinon celui par defaut pour une fonction d'autorisation
781 *
782 * @param array $autorisations
783 *              Les autorisations renseignees par l'interface pour un objet
784 * @param string $autorisation
785 *              Le nom de l'autorisation souhaitee
786 * @return string
787 *              Code de l'autorisation
788**/
789function fabrique_code_autorisation_defaut($autorisations, $autorisation) {
790        if (!$autorisation) return "";
791
792        // trouver le type d'autorisation souhaitee, soit indiquee, soit par defaut
793        if (!isset($autorisations[$autorisation]) OR !$type = $autorisations[$autorisation]) {
794                $type = fabrique_autorisation_defaut($autorisation);
795        }
796
797        // retourner le code PHP correspondant
798        return fabrique_code_autorisation($type);
799}
800
801/**
802 * Retourne le type pour le nom d'une fonction d'autorisation
803 * 'article' => 'article'
804 * 'truc_muche' => 'trucmuche'
805 *
806 * @param string $type
807 *              Type ou objet
808 * @return string
809 *              Type pour le nom d'autorisation
810**/
811function fabrique_type_autorisation($type) {
812        return str_replace('_', '', $type);
813}
814
815?>
Note: See TracBrowser for help on using the repository browser.