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

Last change on this file since 115409 was 109646, checked in by marcimat@…, 3 years ago

Notices PHP en moins et parenthèses en trop dans un squelette.

File size: 45.0 KB
Line 
1<?php
2
3/**
4 * Fonctions utiles pour les squelettes de la fabrique
5 *
6 * @package SPIP\Fabrique\Fonctions
7**/
8
9if (!defined('_ECRIRE_INC_VERSION')) {
10        return;
11}
12
13
14// Liste des categories de plugin
15function filtre_svp_categories_fallback_dist() {
16        $categories = array(
17                'communication',
18                'edition',
19                'multimedia',
20                'navigation',
21                'date',
22                'divers',
23                'auteur',
24                'statistique',
25                'performance',
26                'maintenance',
27                'outil',
28                'theme',
29                'squelette',
30                'aucune'
31        );
32        return array_combine($categories, $categories);
33}
34
35/**
36 * Déterminer le répertoire de travail
37 * de la Fabrique.
38 *
39 * Dans :
40 * - plugins/fabrique_auto si possible, sinon dans
41 * - tmp/cache/fabrique
42 *
43 * @return string
44 *     Le chemin de destination depuis la racine de SPIP.
45**/
46function fabrique_destination() {
47        static $destination = null;
48        if (is_null($destination)) {
49                if (is_writable(_DIR_PLUGINS . rtrim(FABRIQUE_DESTINATION_PLUGINS, '/'))) {
50                        $destination = _DIR_PLUGINS . FABRIQUE_DESTINATION_PLUGINS;
51                } else {
52                        sous_repertoire(_DIR_CACHE, rtrim(FABRIQUE_DESTINATION_CACHE, '/'));
53                        $destination = _DIR_CACHE . FABRIQUE_DESTINATION_CACHE;
54                }
55        }
56        return $destination;
57}
58
59
60/**
61 * Crée l'arborescence manquante
62 *
63 * Crée tous les répertoires manquants dans une arborescence donnée.
64 * Les répertoires sont séparés par des '/'
65 *
66 * @example
67 *     sous_repertoire_complet('a/b/c/d');
68 *     appelle sous_repertoire() autant de fois que nécéssaire.
69 *
70 * @param string $arbo
71 *     Arborescence, tel que 'prive/squelettes/contenu'
72 * @return void
73**/
74function sous_repertoire_complet($arbo) {
75        $a = explode('/', $arbo);
76        if ($a[0] == '.' OR $a[0] == '..') {
77                $base = $a[0] . '/' . $a[1];
78                array_shift($a);
79                array_shift($a);
80        } else {
81                $base = $a[0];
82                array_shift($a);
83        }
84
85        foreach ($a as $dir) {
86                $base .= '/' . $dir;
87                sous_repertoire($base);
88        }
89}
90
91
92/**
93 * Concatène en utilisant implode, un tableau, de maniere récursive
94 *
95 * @param array $tableau
96 *     Tableau à transformer
97 * @param string $glue
98 *     Chaine insérée entre les valeurs
99 * @return string|bool
100 *     - False si pas un tableau
101 *     - Chaine concaténée sinon
102**/
103function fabrique_implode_recursif($tableau, $glue='') {
104        if (!is_array($tableau)) {
105                return false;
106        }
107
108        foreach ($tableau as $c =>$valeur) {
109                if (is_array($valeur)) {
110                        $tableau[$c] = fabrique_implode_recursif($valeur, $glue);
111                }
112        }
113
114        return implode($glue, $tableau);
115}
116
117
118/**
119 * Écrit une ouverture de code PHP
120 *
121 * Fait écrire '<?php' sans que ce php soit executé par SPIP !
122 *
123 * @param Champ $p
124 *     Pile au niveau de la balise
125 * @return Champ
126 *     Pile complétée du code à produire
127**/
128function balise_PHP_dist($p) {
129        $p->code = "'<?php echo \'<?php\n\'; ?>'";
130        $p->interdire_scripts = false;
131        return $p;
132}
133
134/**
135 * Convertie une chaîne pour en faire une chaîne de langue
136 *
137 * Permet d'insérer un texte comme valeur d'une clé de langue, lorsqu'on
138 * crée un fichier de langue avec la fabrique.
139 *
140 * Transforme les caractères &# et échappe les apostrophes :
141 * - &#xxx => le bon caractère
142 * - ' => \'
143 *
144 * @example
145 *     '#ENV{prefixe}_description' => '[(#ENV{paquet/description}|chaine_de_langue)]',
146 *
147 * @link http://www.php.net/manual/fr/function.html-entity-decode.php#104617
148 * @param string $texte
149 *     Le texte à écrire dans la chaîne de langue
150 * @return string
151 *     Le texte transformé
152**/
153function chaine_de_langue($texte) {
154        $texte = html_entity_decode($texte, ENT_QUOTES, 'UTF-8');
155        # egalement
156        # http://www.php.net/manual/fr/function.html-entity-decode.php#104617
157
158        return addslashes($texte);
159}
160
161/**
162 * Modifie le nom de la clé de langue pour
163 * utiliser le vrai nom de l'objet
164 *
165 * Remplace 'objets' par le nom de l'objet, et 'objet' par le type d'objet,
166 * mais ne touche pas à '\objets' ou '\objet'.
167 *
168 * @note
169 *     Cette fonction ne sert pas uniquement à définir des clés pour
170 *     les fichiers de chaînes de langue, et pourrait être renommée
171 *
172 * @example
173 *     ```
174 *     cle_de_langue('titre_objets') => titre_chats
175 *     cle_de_langue('icone_creer_objet') => icone_creer_chat
176 *     cle_de_langue('prive/\objets/infos/objet.html') => prive/objets/infos/chat.html
177 *     ```
178 * @param string $cle
179 *     La clé à transformer
180 * @param array $desc_objet
181 *     Couples d'information sur l'objet en cours, avec les index
182 *     'objet' et 'type' définis
183 * @return string
184 *     La clé transformée
185**/
186function cle_de_langue($cle, $desc_objet) {
187        // on permet d'echapper \objets pour trouver 'objets' au bout du compte
188        // sans qu'il soit transforme dans le nom reel de l'objet
189        // cas : 'prive/\objets/infos/objet.html' => 'prive/objets/infos/nom.html'
190        $cle = str_replace("\o", "\1o\\", $cle);
191        $cle =  str_replace(
192                array('objets', 'objet'),
193                array($desc_objet['objet'], $desc_objet['type']), $cle);
194        return str_replace("\1o\\", "o", $cle);
195}
196
197/**
198 * Identique à |cle_de_langue sur toutes les valeurs d'un tableau
199 *
200 * @see cle_de_langue()
201 * @param array $tableau
202 *     Tableau dont on veut transformer les valeurs
203 * @param array $desc_objet
204 *     Couples d'information sur l'objet en cours, avec les index
205 *     'objet' et 'type' définis
206 * @return array
207 *     Tableau avec les valeurs transformées
208**/
209function tab_cle_de_langue($tableau, $desc_objet) {
210        foreach($tableau as $c => $v) {
211                $tableau[$c] = cle_de_langue($v, $desc_objet);
212        }
213        return $tableau;
214}
215
216/**
217 * Cherche s'il existe une chaîne de langue pour les clés de tableaux
218 * et ajoute alors la traduction dans la valeur de ce tableau
219 *
220 * @param array $tableau
221 *     Couples (clé => texte)
222 * @param string $prefixe_cle
223 *     Préfixe ajouté aux clés pour chercher les trads
224 * @param string $sep
225 *     Séparateur entre l'ancienne valeur et la concaténation de traduction
226 * @return array
227 *     Couples (clé => texte complété de la traduction si elle existe)
228**/
229function tab_cle_traduite_ajoute_dans_valeur($tableau, $prefixe_cle="", $sep = "&nbsp;: ") {
230        foreach($tableau as $c => $v) {
231                $trad = _T("fabrique:". $prefixe_cle . $c, array(), array('force' => false));
232                if ($trad) {
233                        $tableau[$c] = $v . $sep . $trad;
234                } else {
235                        $tableau[$c] = $v;
236                }
237        }
238        return $tableau;
239}
240
241/**
242 * Équivalent de wrap() sur les valeurs du tableau
243 *
244 * @param array $tableau
245 *     Tableau cle => texte
246 * @param string $balise
247 *     Balise qui encapsule
248 * @return array $tableau
249 *     Tableau clé => <balise>texte</balise>
250**/
251function tab_wrap($tableau, $balise) {
252        foreach ($tableau as $c => $v) {
253                $tableau[$c] = wrap($v, $balise);
254        }
255        return $tableau;
256}
257
258
259/**
260 * Fabrique un tableau de chaînes de langues
261 * avec des clés d'origines passées dans la fonctions
262 * cle_de_langue, et trie.
263 *
264 * @param array $objet
265 *     Description de l'objet dans la fabrique
266 * @return array
267 *     Couples (clé de langue => Texte)
268**/
269function fabriquer_tableau_chaines($objet) {
270        $chaines = array();
271        if (!is_array($objet)) { return $chaines; }
272        if (!$table = $objet['table'] OR !isset($objet['chaines']) OR !is_array($objet['chaines'])) {
273                return $chaines;
274        }
275        // les chaines definies pour l'objet
276        foreach ($objet['chaines'] as $cle => $chaine) {
277                $chaines[ cle_de_langue($cle, $objet) ] = $chaine;
278        }
279        // les chaines definies pour chaque champ de l'objet
280        if (is_array($objet['champs'])) {
281                foreach ($objet['champs'] as $info) {
282                        $chaines[ cle_de_langue('champ_' . $info['champ'] . '_label', $objet) ] = $info['nom'];
283                        if ($info['explication']) {
284                                $chaines[ cle_de_langue('champ_' . $info['champ'] . '_explication', $objet) ] = $info['explication'];
285                        }
286                }
287        }
288        // les rôles définis
289        if ($roles = fabrique_description_roles($objet)) {
290                foreach ($roles['roles_trads'] as $cle => $texte) {
291                        $chaines[ $cle ] = $texte;
292                }
293        }
294
295        ksort($chaines);
296        return $chaines;
297}
298
299/**
300 * Retourne la description des rôles pour un objet
301 *
302 * @param array $objet
303 *     Descrption de l'objet
304 * @return array
305 *     Description des rôles. 4 index :
306 *     - roles_colonne : la colonne utilisée, toujours 'role'
307 *     - roles_titre   : couples clé du role, clé de langue du role
308 *     - roles_objets  : tableau objet => liste des clés de roles
309 *     - roles_trads   : couples clé de langue => Texte
310 *     - roles_defaut  : la clé du role par défaut
311 */
312function fabrique_description_roles($objet) {
313        $desc = array();
314        // les rôles définis
315        if (!options_presentes($objet, array('table_liens', 'roles'))
316        OR !($roles = trim($objet['roles']))) {
317                return $desc;
318        }
319        $desc['roles_colonne'] = 'role';
320        $desc['roles_titres'] = array(); # cle => cle_langue
321        $desc['roles_objets'] = array();
322        $desc['roles_trads']  = array(); # cle_langue => Texte
323        $desc['roles_defaut']  = '';
324
325        $roles = explode("\n", $roles);
326        foreach ($roles as $i=>$r) {
327                list($cle, $texte) = explode(',', $r, 2);
328                $cle = trim($cle);
329                if (!$i) $desc['roles_defaut'] = $cle; # la valeur par défaut est la première indiquée
330                $cle_langue = 'role_' . $cle;
331                $desc['roles_titres'][$cle] = $objet['type'] . ':' . $cle_langue;
332                $desc['roles_trads'][$cle_langue] = trim($texte);
333        }
334        $liens = array_map('table_objet', $objet['vue_liens']);
335        foreach ($liens as $l) {
336                $desc['roles_objets'][$l] = array_keys($desc['roles_titres']);
337        }
338        return $desc;
339}
340
341
342/**
343 * Indique si le champ est présent dans l'objet
344 *
345 * Champ, au sens de colonne SQL
346 *
347 * @param array $objet
348 *     Descrption de l'objet
349 * @param string $champ
350 *     Nom du champ SQL à tester
351 * @return string
352 *     Même retour que le filtre |oui :
353 *     - Un espace si le champ SQL exsitera dans l'objet
354 *     - Chaîne vide sinon
355**/
356function champ_present($objet, $champ) {
357        if (!$objet) {
358                return false;
359        }
360        if (isset($objet['champs']) and is_array($objet['champs'])) {
361                foreach ($objet['champs'] as $info) {
362                        if (isset($info['champ']) and $info['champ'] == $champ) {
363                                return ' '; // true
364                        }
365                }
366        }
367        // id_rubrique, id_secteur
368        if (isset($objet['rubriques']) and is_array($objet['rubriques'])) {
369                if (in_array($champ, $objet['rubriques'])) {
370                        return ' '; // true
371                }
372        }
373        // lang, langue_choisie, id_trad
374        if (isset($objet['langues']) and is_array($objet['langues'])) {
375                if (in_array($champ, $objet['langues'])) {
376                        return ' '; // true
377                }
378                if (isset($objet['langues']['lang'])
379                        and ($objet['langues']['lang'])
380                        and ($champ == 'langue_choisie')) {
381                                return ' '; // true
382                }
383        }
384        // date
385        if ($objet['champ_date']) {
386                if ($champ == $objet['champ_date']) {
387                        return ' '; // true
388                }
389        }
390        // statut
391        if ($objet['statut']) {
392                if ($champ == 'statut') {
393                        return ' '; // true
394                }
395        }
396
397        return ""; // false
398}
399
400
401/**
402 * Indique si toutes les options sont présentes dans l'objet
403 *
404 * Option au sens de clé de configuration, pas un nom de champ SQL
405 *
406 * @param array $objet
407 *     Descrption de l'objet
408 * @param array $champs
409 *     Liste de nom d'options à tester
410 * @return string
411 *     Même retour que le filtre |oui :
412 *     - Un espace si toutes les options sont présentes dans l'objet
413 *     - Chaîne vide sinon
414**/
415function options_presentes($objet, $champs) {
416        if (!$champs) return false;
417        if (!is_array($champs)) $champs = array($champs);
418        foreach ($champs as $champ) {
419                if (!option_presente($objet, $champ)) {
420                        return ""; // false
421                }
422        }
423        return ' '; // true
424
425}
426
427/**
428 * Indique si une option est présente dans l'objet
429 *
430 * Option au sens de clé de configuration, pas un nom de champ SQL
431 *
432 * @param array $objet
433 *     Descrption de l'objet
434 * @param string $champ
435 *     Nom de l'option à tester
436 * @return string
437 *     Même retour que le filtre |oui :
438 *     - Un espace si l'option est présente dans l'objet
439 *     - Chaîne vide sinon
440**/
441function option_presente($objet, $champ) {
442        // a la racine
443        if (isset($objet[$champ]) and $objet[$champ]) {
444                return ' '; // true
445        }
446
447        // id_rubrique, vue_rubrique, plan
448        if (isset($objet['rubriques']) and is_array($objet['rubriques'])) {
449                if (in_array($champ, $objet['rubriques'])) {
450                        return ' '; // true
451                }
452        }
453
454        // lang, id_trad
455        if (isset($objet['langues']) and is_array($objet['langues'])) {
456                if (in_array($champ, $objet['langues'])) {
457                        return ' '; // true
458                }
459        }
460
461        // menu_edition, outils_rapides
462        if (isset($objet['boutons']) and is_array($objet['boutons'])) {
463                if (in_array($champ, $objet['boutons'])) {
464                        return ' '; // true
465                }
466        }
467
468        return ""; // false
469}
470
471
472/**
473 * Indique si une saisie est présente dans l'objet
474 *
475 * @param array $objet
476 *     Descrption de l'objet
477 * @param array $saisie
478 *     Nom de la saisie à tester
479 * @return string
480 *     Même retour que le filtre |oui :
481 *     - Un espace si l'option est présente dans l'objet
482 *     - Chaîne vide sinon
483**/
484function saisie_presente($objet, $saisie) {
485        if (isset($objet['champs']) and is_array($objet['champs'])) {
486                foreach ($objet['champs'] as $champ) {
487                        if (isset($champ['saisie']) and $champ['saisie'] == $saisie) {
488                                return ' '; // true
489                        }
490                }
491        }
492        return ""; // false
493}
494
495
496/**
497 * Indique si une option donnée est presente dans la définition d'un champ
498 * de la fabrique
499 *
500 * @param array $champ
501 *     Description d'un champ SQL d'un objet créé avec la fabrique
502 * @param string $option
503 *     Option testée
504 * @return string
505 *     Même retour que le filtre |oui :
506 *     - Un espace si l'option est présente dans le champ de l'objet
507 *     - Chaîne vide sinon
508 */
509function champ_option_presente($champ, $option) {
510        if (isset($champ[$option]) and $champ[$option]) {
511                return ' '; // true
512        }
513
514        // editable, versionne, obligatoire
515        if (isset($champ['caracteristiques']) and is_array($champ['caracteristiques'])) {
516                if (in_array($option, $champ['caracteristiques'])) {
517                        return ' '; // true
518                }
519        }
520
521        return false;
522}
523
524
525/**
526 * Indique si une saisie donnée est presente dans la définition d'un champ
527 * de la fabrique
528 *
529 * @param array $champ
530 *     Description d'un champ SQL d'un objet créé avec la fabrique
531 * @param string $saisie
532 *     Saisie testée
533 * @return string
534 *     Même retour que le filtre |oui :
535 *     - Un espace si l'option est présente dans le champ de l'objet
536 *     - Chaîne vide sinon
537 */
538function champ_saisie_presente($champ, $saisie) {
539        if (isset($champ['saisie']) and $champ['saisie'] == $saisie) {
540                return ' '; // true
541        }
542        return false;
543}
544
545
546/**
547 * Retourne les objets possédant un certain champ SQL
548 *
549 * Cela simplifie des boucles DATA
550 *
551 * @example
552 *     - `#OBJETS|objets_champ_present{id_rubrique}`
553 *     - On peut ne retourner qu'une liste de type de valeur (objet, type, id_objet)
554 *       `#OBJETS|objets_champ_present{id_rubrique, objet}` // chats,souris
555 *
556 * @param array $objets
557 *     Liste des descriptions d'objets créés avec la fabrique
558 * @param string $champ
559 *     Type de champ sélectionné
560 * @param string $type
561 *     Information de retour désiré :
562 *     - vide pour toute la description de l'objet
563 *     - clé dans la description de l'objet pour obtenir uniquement ces descriptions
564 * @return array
565 *     - tableau de description des objets sélectionnés (si type non défini)
566 *     - tableau les valeurs du type demandé dans les objets sélectionnés (si type défini)
567**/
568function objets_champ_present($objets, $champ, $type='') {
569        return _tableau_option_presente('champ_present', $objets, $champ, $type);
570}
571
572
573/**
574 * Retourne les objets possédant une certaine option
575 *
576 * Option au sens des clés du formulaire de configuration de l'objet
577 *
578 * @example
579 *     - `#OBJETS|objets_option_presente{vue_rubrique}`
580 *     - `#OBJETS|objets_option_presente{auteurs_liens}`
581 *     - On peut ne retourner qu'une liste de type de valeur (objet, type, id_objet)
582 *       `#OBJETS|objets_option_presente{auteurs_liens, objet}` // chats,souris
583 *
584 * @param array $objets
585 *     Liste des descriptions d'objets créés avec la fabrique
586 * @param string $option
587 *     Type d'option sélectionnée
588 * @param string $type
589 *     Information de retour désiré :
590 *     - vide pour toute la description de l'objet
591 *     - clé dans la description de l'objet pour obtenir uniquement ces descriptions
592 * @return array
593 *     - tableau de description des objets sélectionnés (si type non défini)
594 *     - tableau les valeurs du type demandé dans les objets sélectionnés (si type défini)
595**/
596function objets_option_presente($objets, $option, $type='') {
597        return _tableau_option_presente('option_presente', $objets, $option, $type);
598}
599
600
601/**
602 * Retourne les objets possédant une certaine saisie
603 *
604 * @example
605 *     - `#OBJETS|objets_saisie_presente{date}`
606 *     - On peut ne retourner qu'une liste de type de valeur (objet, type, id_objet)
607 *       `#OBJETS|objets_saisie_presente{date, objet}` // chats,souris
608 *
609 * @param array $objets
610 *     Liste des descriptions d'objets créés avec la fabrique
611 * @param string $saisie
612 *     Type de saisie sélectionnée
613 * @param string $type
614 *     Information de retour désiré :
615 *     - vide pour toute la description de l'objet
616 *     - clé dans la description de l'objet pour obtenir uniquement ces descriptions
617 * @return array
618 *     - tableau de description des objets sélectionnés (si type non défini)
619 *     - tableau les valeurs du type demandé dans les objets sélectionnés (si type défini)
620**/
621function objets_saisie_presente($objets, $saisie, $type='') {
622        return _tableau_option_presente('saisie_presente', $objets, $saisie, $type);
623}
624
625
626/**
627 * Retourne les objets possédant plusieurs options
628 *
629 * Option au sens des clés du formulaire de configuration de l'objet
630 *
631 * @example
632 *     - `#OBJETS|objets_options_presentes{#LISTE{table_liens,vue_liens}}`
633 *     - On peut ne retourner qu'une liste de type de valeur (objet, type, id_objet)
634 *       `#OBJETS|objets_options_presentes{#LISTE{table_liens,vue_liens}, objet}` // chats,souris
635 *
636 * @param array $objets
637 *     Liste des descriptions d'objets créés avec la fabrique
638 * @param array $options
639 *     Liste de type d'option à sélectionner
640 * @param string $type
641 *     Information de retour désiré :
642 *     - vide pour toute la description de l'objet
643 *     - clé dans la description de l'objet pour obtenir uniquement ces descriptions
644 * @return array
645 *     - tableau de description des objets sélectionnés (si type non défini)
646 *     - tableau les valeurs du type demandé dans les objets sélectionnés (si type défini)
647**/
648function objets_options_presentes($objets, $options, $type='') {
649        return _tableau_options_presentes('option_presente', $objets, $options, $type);
650}
651
652/**
653 * Retourne des champs en fonction d'une option trouvée
654 *
655 * @example
656 *     - `#CHAMPS|champs_option_presente{editable}`
657 *     - `#CHAMPS|champs_option_presente{versionne}`
658 *
659 * @param array $champs
660 *     Liste des descriptions de champs d'un objet créé avec la fabrique
661 * @param string $option
662 *     Type d'option sélectionnée
663 * @param string $type
664 *     Information de retour désiré :
665 *     - vide pour toute la description du champ
666 *     - clé dans la description du champ pour obtenir uniquement ces descriptions
667 * @return array
668 *     - tableau de description des champs sélectionnés (si type non défini)
669 *     - tableau les valeurs du type demandé dans les champs sélectionnés (si type défini)
670**/
671function champs_option_presente($champs, $option, $type='') {
672        return _tableau_option_presente('champ_option_presente', $champs, $option, $type);
673}
674
675/**
676 * Retourne des champs en fonction des options trouvées
677 *
678 * @example
679 *     `#CHAMPS|champs_options_presentes{#LISTE{obligatoire,saisie}}`
680 *
681 * @param array $champs
682 *     Liste des descriptions de champs d'un objet créé avec la fabrique
683 * @param array $options
684 *     Liste de type d'options à sélectionner
685 * @param string $type
686 *     Information de retour désiré :
687 *     - vide pour toute la description du champ
688 *     - clé dans la description du champ pour obtenir uniquement ces descriptions
689 * @return array
690 *     - tableau de description des champs sélectionnés (si type non défini)
691 *     - tableau les valeurs du type demandé dans les champs sélectionnés (si type défini)
692**/
693function champs_options_presentes($champs, $options, $type='') {
694        return _tableau_options_presentes('champ_option_presente', $champs, $options, $type);
695}
696
697/**
698 * Retourne des champs en fonction d'une option trouvée
699 *
700 * @example
701 *     `#CHAMPS|champs_saisie_presente{date}`
702 *
703 * @param array $champs
704 *     Liste des descriptions de champs d'un objet créé avec la fabrique
705 * @param string $saisie
706 *     Type de saisie sélectionnée
707 * @param string $type
708 *     Information de retour désiré :
709 *     - vide pour toute la description du champ
710 *     - clé dans la description du champ pour obtenir uniquement ces descriptions
711 * @return array
712 *     - tableau de description des champs sélectionnés (si type non défini)
713 *     - tableau les valeurs du type demandé dans les champs sélectionnés (si type défini)
714**/
715function champs_saisie_presente($champs, $saisie, $type='') {
716        return _tableau_option_presente('champ_saisie_presente', $champs, $saisie, $type);
717}
718
719/**
720 * Fonction générique pour retourner une liste de choses dans un tableau
721 *
722 * @param string $func
723 *     Nom de la fonction à appeler, tel que
724 *     - champ_option_presente
725 *     - option_presente
726 *     - ...
727 * @param array $tableau
728 *     Tableau de descriptions (descriptions d'objet ou descriptions de champ d'objet)
729 * @param string $option
730 *     Nom de l'option dont on teste la présence
731 * @param string $type
732 *     Information de retour désiré :
733 *     - vide pour toute la description
734 *     - clé dans la description pour obtenir uniquement ces descriptions
735 * @return array
736 *     Liste des descriptions correspondant à l'option demandée
737 */
738function _tableau_option_presente($func, $tableau, $option, $type='') {
739        $o = array();
740
741        if (!is_array($tableau) OR !$func) {
742                return $o;
743        }
744        // tableau est un tableau complexe de donnee
745        foreach ($tableau as $objet) {
746                // on cherche la donnee 'option' dans le tableau
747                // en utilisant une fonction specifique de recherche (option_presente, champ_present, ...)
748                if ($func($objet, $option)) {
749                        // si on a trouve notre option :
750                        // type permet de recuperer une cle specifique dans la liste des cles parcourues.
751                        // sinon, retourne tout le sous tableau.
752                        if ($type and isset($objet[$type])) {
753                                $o[] = $objet[$type];
754                        } elseif (!$type) {
755                                $o[] = $objet;
756                        }
757                }
758        }
759        return $o;
760}
761
762/**
763 * Fonction générique pour retourner une liste de choses multiples dans un tableau
764 *
765 * @param string $func
766 *     Nom de la fonction à appeler, tel que
767 *     - champ_option_presente
768 *     - option_presente
769 *     - ...
770 * @param array $tableau
771 *     Tableau de descriptions (descriptions d'objet ou descriptions de champ d'objet)
772 * @param array $options
773 *     Nom des l'options dont on teste leur présence
774 * @param string $type
775 *     Information de retour désiré :
776 *     - vide pour toute la description
777 *     - clé dans la description pour obtenir uniquement ces descriptions
778 * @return array
779 *     Liste des descriptions correspondant aux options demandées
780 */
781function _tableau_options_presentes($func, $tableau, $options, $type='') {
782        if (!$options) return array();
783
784        if (!is_array($options)) {
785                $options = array($options);
786        }
787
788        $first = false;
789        foreach ($options as $option) {
790                $r = _tableau_option_presente($func, $tableau, $option, $type);
791                if (!$first) {
792                        $res = $r;
793                        $first = true;
794                } else {
795                        #$res = array_intersect($res, $r);
796                        // array_intersect() ne prend pas en compte les sous tableaux
797                        foreach ($res as $i => $v) {
798                                if (false === array_search($v, $r)) {
799                                        unset($res[$i]);
800                                }
801                        }
802                        $res = array_values($res);
803                }
804        }
805
806        return $res;
807}
808
809/**
810 * Retrouve si cet objet a des enfants déclarés dans un autre objet
811 *
812 * @param array $objet
813 *     Description de l'objet dans la fabrique
814 * @param array $objets
815 *     Description de tous les objets dans la fabrique
816 * @return
817**/
818function fabrique_objets_enfants_directs($objet, $objets) {
819        $liste = array();
820        foreach ($objets as $autre_objet) {
821                if ($autre_objet !== $objet) {
822                        if (option_presente($autre_objet, 'liaison_directe')) {
823                                if ($objet['table'] == $autre_objet['liaison_directe']) {
824                                        $liste[] = $autre_objet;
825                                }
826                        }
827                }
828        }
829        return $liste;
830}
831
832/**
833 * Retourne une écriture de critères `{id_xxx ?}`
834 *
835 * Tous les champs déclarés commençant par `id_x` sont retournés
836 * sous forme d'une écriture de critère, tel que `{id_parent?}{id_documentation?}`
837 *
838 * La clé primaire est également ajoutée, sauf contre indication.
839 *
840 * Les champs indirects `{B_liens.id_B ?}` sont aussi ajoutés s'ils sont déclarés
841 * dans la Fabrique en même temps.
842 *
843 * @param array $objet
844 *     Description de l'objet dans la fabrique
845 * @param array $objets
846 *     Description de tous les objets dans la fabrique
847 * @param bool $avec_cle_primaire
848 *     Ajouter la clé primaire de la table également
849 * @return string
850 *     L'écriture des critères de boucle
851**/
852function criteres_champs_id($objet, $objets, $avec_cle_primaire = true) {
853        $ids = array();
854
855        if ($avec_cle_primaire) {
856                $ids[] = $objet['id_objet'];
857        }
858
859        // parenté directe sur Rubrique ?
860        if (champ_present($objet, 'id_rubrique')) {
861                $ids[] = 'id_rubrique';
862        }
863        if (champ_present($objet, 'id_secteur')) {
864                $ids[] = 'id_secteur';
865        }
866
867        // parenté directe sur un autre objet ?
868        if (option_presente($objet, 'liaison_directe') and $_id = fabrique_id_table_objet($objet['liaison_directe'], $objets)) {
869                $ids[] = $_id;
870        }
871        if (is_array($objet['champs'])) {
872                foreach ($objet['champs'] as $info) {
873                        if (substr($info['champ'], 0, 3) == 'id_') {
874                                $ids[] = $info['champ'];
875                        }
876                }
877        }
878
879        // Liaisons indirectes via table de liens déclarée dans la Fabrique ?
880        // D'autres objets peuvent avoir une table de liens et demander à être lié sur cet objet.
881        // On ajoute leurs champs de liaison.
882        foreach ($objets as $autre_objet) {
883                if ($autre_objet !== $objet) {
884                        if (options_presentes($autre_objet, array('table_liens', 'vue_liens'))) {
885                                if (in_array($objet['table'], $autre_objet['vue_liens'])) {
886                                        $ids[] = $autre_objet['objet'] . '_liens.' . $autre_objet['id_objet'];
887                                }
888                        }
889                }
890        }
891
892        if (!$ids) {
893                return "";
894        }
895        return "{" . implode("?}{", $ids) . "?}";
896}
897
898/**
899 * Retourne un tableau de toutes les tables SQL
900 * pour tous les objets.
901 *
902 * @param array $objets
903 *     Liste des descriptions d'objets créés avec la fabrique
904 * @param string $quoi
905 *     Choix du retour désiré :
906 *     - 'tout'   => toutes les tables (par défaut)
907 *     - 'objets' => les tables d'objet (spip_xx, spip_yy)
908 *     - 'liens'  => les tables de liens (spip_xx_liens, spip_yy_liens)
909 * @return array
910 *     Liste des tables
911**/
912function fabrique_lister_tables($objets, $quoi='tout') {
913        static $tables = array();
914
915        if (!$objets) return array();
916
917        $hash = md5(serialize($objets));
918
919        if (!isset($tables[$hash])) {
920                $tables[$hash] = array(
921                        'tout' => array(),
922                        'objets' => array(),
923                        'liens' => array(),
924                );
925                foreach ($objets as $o) {
926                        // tables principales
927                        if (isset($o['table']) and $o['table']) {
928                                $tables[$hash]['objets'][] = $o['table'];
929                                $tables[$hash]['tout'][] = $o['table'];
930                                // tables de liens
931                                if ($o['table_liens']) {
932                                        $tables[$hash]['liens'][] = $o['nom_table_liens'];
933                                        $tables[$hash]['tout'][]  = $o['nom_table_liens'];
934                                }
935                        }
936                }
937        }
938
939        return $tables[$hash][$quoi];
940}
941
942
943/**
944 * Retourne la liste des noms de certains champs pour cet objet
945 *
946 * Champs déclarés complétés des champs spéciaux (editable, versionne, obligatoire)
947 *
948 * @param array $objet
949 *     Description de l'objet concerné
950 * @param string $option
951 *     Option souhaitée.
952 * @param array $objets
953 *     Description de l'ensemble des objets générés par la Fabrique.
954 * @return array
955 *     Liste des champs concernés
956**/
957function fabrique_lister_objet_champs($objet, $option) {
958        if (!$objet) {
959                return array();
960        }
961        $liste = array();
962        if (is_array($objet['champs'])) {
963                $liste = champs_option_presente($objet['champs'], $option, 'champ');
964        }
965        if (champ_present($objet, 'id_rubrique')) {
966                $liste[] = 'id_rubrique';
967        }
968        if (champ_present($objet, 'id_secteur')) {
969                $liste[] = 'id_secteur';
970        }
971        if (option_presente($objet, 'liaison_directe')) {
972                $liste[] = $objet['parent']['id_objet'];
973        }
974        return $liste;
975}
976
977
978/**
979 * Indique si un des objets a besoin du pipeline demandé
980 *
981 * @param array $objets
982 *     Liste des descriptions d'objets créés avec la fabrique
983 * @param string $pipeline
984 *     Nom du pipeline
985 * @return array
986 *     Liste des objets (descriptions) utilisant le pipeline
987 */
988function fabrique_necessite_pipeline($objets, $pipeline) {
989
990        if (!$objets) return false;
991
992        switch ($pipeline) {
993                case "autoriser":
994                case "declarer_tables_objets_sql":
995                case "declarer_tables_interfaces":
996                        return (bool)fabrique_lister_tables($objets, 'objets');
997                        break;
998
999                case "declarer_tables_auxiliaires":
1000                        return (bool)fabrique_lister_tables($objets, 'liens');
1001                        break;
1002
1003                case "affiche_enfants":
1004                        if (objets_option_presente($objets, 'vue_rubrique')
1005                                OR objets_option_presente($objets, 'liaison_directe')) {
1006                                return true;
1007                        }
1008                        break;
1009
1010                case "affiche_milieu":
1011                        if (objets_option_presente($objets, 'auteurs_liens')
1012                        OR  objets_options_presentes($objets, array('table_liens', 'vue_liens'))) {
1013                                return true;
1014                        }
1015                        break;
1016
1017                case "affiche_auteurs_interventions":
1018                        if (objets_option_presente($objets, 'vue_auteurs_liens')) {
1019                                return true;
1020                        }
1021                        break;
1022
1023                case "afficher_contenu_objet":
1024                        return false;
1025                        break;
1026
1027                case "boite_infos":
1028                        if (objets_option_presente($objets, 'id_rubrique')
1029                                or objets_option_presente($objets, 'liaison_directe')) {
1030                                return true;
1031                        }
1032                        break;
1033
1034                case "objet_compte_enfants":
1035                        if (objets_options_presentes($objets, array('id_rubrique', 'statut_rubrique'))
1036                                or objets_option_presente($objets, 'liaison_directe')) {
1037                                return true;
1038                        }
1039                        break;
1040
1041
1042                case "optimiser_base_disparus":
1043                        # nettoie depuis spip_{objet}_liens
1044                        # mais aussi les liaisions vers spip_{objet} (uniquement si une table de liens existe)
1045                        if (fabrique_lister_tables($objets, 'liens')) {
1046                                return true;
1047                        }
1048                        # nettoie aussi les objets à la poubelle (si avec statut)
1049                        if (objets_champ_present($objets, 'statut')) {
1050                                return true;
1051                        }
1052                        break;
1053
1054                case "trig_propager_les_secteurs":
1055                        if (objets_options_presentes($objets, array('id_rubrique', 'id_secteur'))) {
1056                                return true;
1057                        }
1058                        break;
1059        }
1060        return false;
1061}
1062
1063
1064/**
1065 * Crée le code PHP de création d'un tableau
1066 *
1067 * Fonction un peu équivalente à var_export()
1068 *
1069 * @param array $tableau
1070 *     Le tableau dont on veut obtenir le code de création array( ... )
1071 * @param bool $quote
1072 *     Appliquer sql_quote() sur chaque valeur (dans le code retourne)
1073 * @param string $defaut
1074 *     Si $tableau est vide ou n'est pas une chaîne, la fonction retourne cette valeur
1075 * @return string
1076 *     - Le code de création du tableau, avec éventuellement le code pour appliquer sql_quote.
1077 *     - $defaut si le tableau est vide
1078**/
1079function ecrire_tableau($tableau, $quote = false, $defaut = "array()") {
1080        // pas de tableau ?
1081        if (!is_array($tableau) OR !count($tableau)) {
1082                return $defaut;
1083        }
1084
1085        $res = "array('" . implode("', '", array_map('addslashes', $tableau)) . "')";
1086
1087        if ($quote) {
1088                $res = "array_map('sql_quote', $res)";
1089        }
1090        return $res;
1091}
1092
1093/**
1094 * Crée le code PHP de création d'un tableau sauf s'il est vide
1095 *
1096 * Identique à ecrire_tableau() mais ne retourne rien si le tableau est vide
1097 * @see ecrire_tableau()
1098 *
1099 * @param array $tableau
1100 *     Le tableau dont on veut obtenir le code de création array( ... )
1101 * @param bool $quote
1102 *     Appliquer sql_quote() sur chaque valeur (dans le code retourne)
1103 * @return string
1104 *     - Le code de création du tableau, avec éventuellement le code pour appliquer sql_quote.
1105 *     - Chaîne vide si le tableau est vide
1106**/
1107function ecrire_tableau_sinon_rien($tableau, $quote = false) {
1108        return ecrire_tableau($tableau, $quote, "");
1109}
1110
1111/**
1112 * Ajoute autant des espaces à la fin d'une chaîne jusqu'à la taille indiquée
1113 *
1114 * Fonction un peu equivalente à str_pad() mais avec une valeur par défaut
1115 * définie par la constante `_FABRIQUE_ESPACER`
1116 *
1117 * @param string $texte
1118 *     Texte à compléter
1119 * @param int $taille
1120 *     Taille spécifique, utilisée à la place de la constante si renseignée
1121 * @return
1122 *     Texte complété des espaces de fin
1123 */
1124function espacer($texte, $taille = 0) {
1125        if (!$taille) $taille = _FABRIQUE_ESPACER;
1126        return str_pad($texte, $taille);
1127}
1128
1129
1130/**
1131 * Tabule à gauche chaque ligne du nombre de tabulations indiquées
1132 * + on enleve les espaces sur les lignes vides
1133 *
1134 * @param string $texte
1135 *     Un texte, qui peut avoir plusieurs lignes
1136 * @param int $nb_tabulations
1137 *     Nombre de tabulations à appliquer à gauche de chaque ligne
1138 * @return string
1139 *     Texte indenté du nombre de tabulations indiqué
1140 */
1141function fabrique_tabulations($texte, $nb_tabulations) {
1142        $tab = "";
1143        if ($nb_tabulations) {
1144                $tab = str_pad("\t", $nb_tabulations);
1145        }
1146        $texte = explode("\n", $texte);
1147        foreach ($texte as $c => $ligne) {
1148                $l = ltrim(ltrim($ligne), "\t");
1149                if (!$l) {
1150                        $texte[$c] = "";
1151                } else {
1152                        $texte[$c] = $tab . $ligne;
1153                }
1154        }
1155        return implode("\n", $texte);
1156}
1157
1158
1159
1160
1161/**
1162 * Passer en majuscule en utilisant mb de préférence
1163 * s'il est disponible.
1164 *
1165 * @param string $str
1166 *     La chaine à passer en majuscule
1167 * @return string
1168 *     La chaine en majuscule
1169**/
1170function fabrique_mb_strtoupper($str) {
1171        if (function_exists('mb_strtoupper')) {
1172                return mb_strtoupper($str);
1173        } else {
1174                return strtoupper($str);
1175        }
1176}
1177
1178/**
1179 * Passer en minuscule en utilisant mb de préférence
1180 * s'il est disponible.
1181 *
1182 * @param string $str
1183 *              La chaine à passer en minuscule
1184 * @return string
1185 *              La chaine en minuscule
1186**/
1187function fabrique_mb_strtolower($str) {
1188        if (function_exists('mb_strtolower')) {
1189                return mb_strtolower($str);
1190        } else {
1191                return strtolower($str);
1192        }
1193}
1194
1195
1196/**
1197 * Crée une balise HTML <img> à partir d'un fichier,
1198 * réactualisée à chaque calcul, selon une réduction donnée.
1199 *
1200 * Cela évite un |array_shift qui ne passe pas en PHP 5.4
1201 *
1202 * Attention à bien rafraîchir l'image réduite lorsqu'on change de logo.
1203 *
1204 * @example
1205 *     `#URL_IMAGE|fabrique_miniature_image{128}`
1206 *     Applique l'équivalent de :
1207 *     ```
1208 *     #URL_IMAGE
1209 *         |image_reduire{128}|extraire_attribut{src}
1210 *         |explode{?}|array_shift|timestamp|balise_img
1211 *     ```
1212 *
1213 * @param string $fichier
1214 *     Chemin du fichier
1215 * @param int $taille
1216 *     Taille de réduction de l'image
1217 * @return string
1218 *     Balise HTML IMG de l'image réduite et à jour
1219 */
1220function filtre_fabrique_miniature_image($fichier, $taille=256) {
1221        $im = filtrer('image_reduire', $fichier, $taille);
1222        $im = extraire_attribut($im, 'src');
1223        $im = explode('?', $im);
1224        $im = array_shift($im);
1225        $im = timestamp($im);
1226        $im = filtrer('balise_img', $im);
1227        return $im;
1228}
1229
1230
1231
1232/**
1233 * Retourne un tableau table_sql=>Nom des objets de SPIP
1234 * complété des objets declares dans la fabrique ainsi
1235 * que de tables indiquees même si elles ne font pas parties
1236 * de declarations connues.
1237 *
1238 * @param array $objets_fabrique
1239 *              Déclaration d'objets de la fabrique
1240 * @param array $inclus
1241 *              Liste de tables SQL que l'on veut forcement presentes
1242 *              meme si l'objet n'est pas declare
1243 * @param array $exclus
1244 *              Liste de tables SQL que l'on veut forcement exclues
1245 *              meme si l'objet n'est pas declare
1246 * @return array
1247 *              Tableau table_sql => Nom
1248**/
1249function filtre_fabrique_lister_objets_editoriaux($objets_fabrique, $inclus=array(), $exclus=array()) {
1250        if (!is_array($inclus)) {
1251                $inclus = $inclus ? array($inclus) : array();
1252        }
1253        if (!is_array($exclus)) {
1254                $exclus = $exclus ? array($exclus) : array();
1255        }
1256
1257        // les objets existants
1258        $objets = lister_tables_objets_sql();
1259        foreach ($objets as $sql => $o) {
1260                if ($o['editable']) {
1261                        $liste[$sql] = _T($o['texte_objets']);
1262                }
1263        }
1264        unset($objets);
1265
1266        // les objets de la fabrique
1267        foreach ($objets_fabrique as $o) {
1268                if (isset($o['table']) and !isset($liste[$o['table']])) {
1269                        $liste[ $o['table'] ] = $o['nom'];
1270                }
1271        }
1272
1273        // des objets qui n'existent pas mais qui sont actuellement coches dans la saisie
1274        foreach ($inclus as $sql) {
1275                if (!isset($liste[$sql])) {
1276                        $liste[$sql] = $sql; // on ne connait pas le nom
1277                }
1278        }
1279
1280        // tables forcement exclues
1281        foreach ($exclus as $sql) {
1282                unset($liste[$sql]);
1283        }
1284        // enlever un eventuel element vide
1285        unset($liste['']);
1286
1287        asort($liste);
1288
1289        return $liste;
1290}
1291
1292
1293/**
1294 * Indique si cet objet a un parent direct déclaré
1295 *
1296 * @param array $objet
1297 *     Déclaration d'un objet dans la Fabrique
1298 * @param array $objets
1299 *     Déclaration de tous les objets dans la Fabrique
1300 * @return array
1301 *     Description du parent
1302**/
1303function fabrique_parent($objet, $objets) {
1304        $table = '';
1305        if (champ_present($objet, 'id_rubrique')) {
1306                $table = 'spip_rubriques';
1307        }
1308        if (option_presente($objet, 'liaison_directe')) {
1309                $table = $objet['liaison_directe'];
1310        }
1311        if (!$table) {
1312                return array();
1313        }
1314
1315        $desc = array(
1316                'table' => $table,
1317                'id_objet' => fabrique_id_table_objet($table, $objets),
1318                'type' => fabrique_objet_type($table, $objets),
1319                'objet' => fabrique_table_objet($table, $objets),
1320        );
1321        $desc['mid_objet'] = strtoupper($desc['id_objet']);
1322        $desc['mobjet'] = strtoupper($desc['objet']);
1323        $desc['lobjet'] = $desc['objet'];
1324        $desc['mtype'] = strtoupper($desc['type']);
1325
1326        return $desc;
1327}
1328
1329/**
1330 * Appliquer un équivalent d'array_map sur une des fonctions de la fabrique
1331 *
1332 * @param array $tableau
1333 * @param string $fonction
1334 * @param array $objets
1335 * @return array
1336 */
1337function fabrique_array_map($tableau, $fonction, $objets) {
1338        if (function_exists($f = 'fabrique_' . $fonction)) {
1339                foreach ($tableau as $i => $valeur) {
1340                        $tableau[$i] = $f($valeur, $objets);
1341                }
1342        } elseif (function_exists($fonction)) {
1343                $tableau = array_map($fonction, $tableau);
1344        }
1345        return $tableau;
1346}
1347
1348/**
1349 * Retrouve la clé primaire d'un objet éditorial
1350 *
1351 * D'abord en cherchant dans les déclaration de la Fabrique,
1352 * sinon en cherchant dans les objets actifs sur ce SPIP.
1353 *
1354 * @param string $table
1355 *     Table SQL
1356 * @param array $objets
1357 *     Description des objets générés par la Fabrique.
1358 * @return string
1359**/
1360function fabrique_id_table_objet($table, $objets) {
1361        if (!$table) {
1362                return '';
1363        }
1364        // déclaré dans la Fabrique
1365        foreach ($objets as $objet) {
1366                if (isset($objet['table']) and $objet['table'] == $table) {
1367                        return $objet['id_objet'];
1368                }
1369        }
1370        // déclaré dans SPIP
1371        return id_table_objet($table);
1372}
1373
1374/**
1375 * Retrouve le nom d'objet d'un objet éditorial
1376 *
1377 * D'abord en cherchant dans les déclaration de la Fabrique,
1378 * sinon en cherchant dans les objets actifs sur ce SPIP.
1379 *
1380 * @param string $table
1381 *     Table SQL
1382 * @param array $objets
1383 *     Description des objets générés par la Fabrique.
1384 * @return string
1385**/
1386function fabrique_table_objet($table, $objets) {
1387        if (!$table) {
1388                return '';
1389        }
1390        // déclaré dans la Fabrique
1391        foreach ($objets as $objet) {
1392                if (isset($objet['table']) and $objet['table'] == $table) {
1393                        return $objet['objet'];
1394                }
1395        }
1396        // déclaré dans SPIP
1397        return table_objet($table);
1398}
1399
1400/**
1401 * Retrouve le type d'un objet éditorial
1402 *
1403 * D'abord en cherchant dans les déclaration de la Fabrique,
1404 * sinon en cherchant dans les objets actifs sur ce SPIP.
1405 *
1406 * @param string $table
1407 *     Table SQL
1408 * @param array $objets
1409 *     Description des objets générés par la Fabrique.
1410 * @return string
1411**/
1412function fabrique_objet_type($table, $objets) {
1413        if (!$table) {
1414                return '';
1415        }
1416        // déclaré dans la Fabrique
1417        foreach ($objets as $objet) {
1418                if (isset($objet['table']) and $objet['table'] == $table) {
1419                        return $objet['type'];
1420                }
1421        }
1422        // déclaré dans SPIP
1423        return objet_type($table);
1424}
1425
1426
1427/**
1428 * Retourne le code pour tester un type d'autorisation
1429 *
1430 * @param string $type
1431 *     Quel type d'autorisation est voulue
1432 * @param string $prefixe
1433 *     Préfixe du plugin généré
1434 * @param array $objet
1435 *     Description de l'objet dans la Fabrique
1436 * @return string
1437 *     Code de test de l'autorisation
1438**/
1439function fabrique_code_autorisation($type, $prefixe, $objet) {
1440
1441        switch($type) {
1442
1443                case "jamais":
1444                        return "false";
1445                        break;
1446
1447                case "toujours":
1448                        return "true";
1449                        break;
1450
1451                // au moins auteur de l'objet, ou administrateur complet ou admin restreint sur rubrique de l'objet
1452                case "auteur_objet":
1453                        $auteurs_objet = '$auteurs = ' . $prefixe . '_auteurs_objet(\'' . $objet['type'] . '\', $id) and in_array($qui[\'id_auteur\'], $auteurs)';
1454                        if (champ_present($objet, 'id_rubrique')) {
1455                                $admin = $prefixe . '_autoriser_admins(\'' . $objet['type'] . '\', $id, $qui)';
1456                        } else {
1457                                $admin = '($qui[\'statut\'] == \'0minirezo\' and !$qui[\'restreint\'])';
1458                        }
1459                        return "$admin\n\t\tor ($auteurs_objet)";
1460                        break;
1461
1462                // au moins auteur de l'objet si l'objet n'est pas publié, ou administrateur complet ou admin restreint sur la rubrique de l'objet
1463                // Note : normalement statut doit forcément être présent pour ce test !
1464                case "auteur_objet_statut":
1465                        $auteurs_objet = '$auteurs = ' . $prefixe . '_auteurs_objet(\'' . $objet['type'] . '\', $id) and in_array($qui[\'id_auteur\'], $auteurs)';
1466                        $test_statut = $prefixe . '_autoriser_statuts(\'' . $objet['type'] . '\', $id, $qui, $opt)';
1467                        if (champ_present($objet, 'id_rubrique')) {
1468                                $admin = $prefixe . '_autoriser_admins(\'' . $objet['type'] . '\', $id, $qui)';
1469                        } else {
1470                                $admin = '($qui[\'statut\'] == \'0minirezo\' and !$qui[\'restreint\'])';
1471                        }
1472                        if (champ_present($objet, 'statut')) {
1473                                return "$admin\n\t\tor ($test_statut\n\t\t\tand $auteurs_objet)";
1474                        } else {
1475                                return "$admin\n\t\tor ($auteurs_objet)";
1476                        }
1477                        break;
1478
1479                case "redacteur":
1480                        return "in_array(\$qui['statut'], array('0minirezo', '1comite'))";
1481                        break;
1482
1483                // Au moins administrateur complet ou restreint sur la rubrique sur l'objet
1484                // Note : normalement id_rubrique doit forcément être présent pour ce test !
1485                case "administrateur_restreint_objet":
1486                        if (champ_present($objet, 'id_rubrique')) {
1487                                $admin = $prefixe . '_autoriser_admins(\'' . $objet['type'] . '\', $id, $qui)';
1488                        } else {
1489                                $admin = '$qui[\'statut\'] == \'0minirezo\' and !$qui[\'restreint\']';
1490                        }
1491                        return $admin;
1492                        break;
1493
1494                case "administrateur_restreint":
1495                        return "\$qui['statut'] == '0minirezo'";
1496                        break;
1497
1498                case "administrateur":
1499                        return "\$qui['statut'] == '0minirezo' and !\$qui['restreint']";
1500                        break;
1501
1502                case "webmestre":
1503                        return "autoriser('webmestre', '', '', \$qui)";
1504                        break;
1505
1506        }
1507
1508        return "";
1509}
1510
1511/**
1512 * Retourne la valeur de type d'autorisation
1513 * qui s'applique par defaut pour une autorisation donnee
1514 *
1515 * @param string $autorisation
1516 *              Nom de l'autorisation (objet et objets remplacent le veritable type et nom d'objet)
1517 * @return string
1518 *              Type d'autorisation par defaut (jamais, toujours, redacteur, ...)
1519**/
1520function fabrique_autorisation_defaut($autorisation) {
1521        switch ($autorisation) {
1522                case 'objet_voir':
1523                        return 'toujours';
1524                        break;
1525
1526                case 'objet_creer':
1527                case 'objet_modifier':
1528                        return 'redacteur';
1529                        break;
1530
1531                case 'objet_supprimer':
1532                case 'associerobjet':
1533                        return 'administrateur';
1534                        break;
1535        }
1536}
1537
1538/**
1539 * Retourne le code d'autorisation indique
1540 * sinon celui par defaut pour une fonction d'autorisation
1541 *
1542 * @param array $autorisations
1543 *     Les autorisations renseignees par l'interface pour un objet
1544 * @param string $autorisation
1545 *     Le nom de l'autorisation souhaitee
1546 * @param string $prefixe
1547 *     Préfixe du plugin généré
1548 * @param array $objet
1549 *     Description le l'objet dans la Fabrique
1550 * @return string
1551 *     Code de l'autorisation
1552**/
1553function fabrique_code_autorisation_defaut($autorisations, $autorisation, $prefixe, $objet) {
1554        if (!$autorisation) {
1555                return '';
1556        }
1557
1558        // trouver le type d'autorisation souhaitee, soit indiquee, soit par defaut
1559        if (!isset($autorisations[$autorisation]) or !$type = $autorisations[$autorisation]) {
1560                $type = fabrique_autorisation_defaut($autorisation);
1561        }
1562
1563        // retourner le code PHP correspondant
1564        return fabrique_code_autorisation($type, $prefixe, $objet);
1565}
1566
1567/**
1568 * Retourne vrai si un test d'autorisation est d'un type spécifié
1569 * dans l'ensemble des autorisations à configurer de tous les objets
1570 *
1571 * @param array $objets
1572 *              Descriptions des objets de la Fabrique
1573 * @param string $recherche
1574 *              Le type d'autorisation recherché
1575 * @return bool
1576**/
1577function objets_autorisation_presente($objets, $recherche) {
1578        foreach ($objets as $objet) {
1579                if (autorisation_presente($objet, $recherche)) {
1580                        return true;
1581                }
1582        }
1583        return false;
1584}
1585
1586
1587/**
1588 * Retourne vrai si au moins une autorisation est d'un des types spécifiés
1589 * dans l'ensemble des autorisations à configurer de tous les objets
1590 *
1591 * @param array $objets
1592 *              Descriptions des objets de la Fabrique
1593 * @param string[] $recherches
1594 *              Les types d'autorisations recherchés
1595 * @return bool
1596**/
1597function objets_autorisations_presentes($objets, $recherches) {
1598        foreach ($recherches as $autorisation) {
1599                if (objets_autorisation_presente($objets, $autorisation)) {
1600                        return true;
1601                }
1602        }
1603        return false;
1604}
1605
1606/**
1607 * Retourne vrai si un test d'autorisation est d'un type spécifié
1608 * dans l'ensemble des autorisations à configurer d'un objet
1609 *
1610 * @param array $objet
1611 *              Description d'un objet de la Fabrique
1612 * @param string $recherche
1613 *              Le type d'autorisation recherché
1614 * @return bool
1615**/
1616function autorisation_presente($objet, $recherche) {
1617        foreach ($objet['autorisations'] as $autorisation => $type) {
1618                if (!$type) {
1619                        $type = fabrique_autorisation_defaut($autorisation);
1620                }
1621                if ($type == $recherche) {
1622                        return true;
1623                }
1624        }
1625        return false;
1626}
1627
1628/**
1629 * Retourne le type pour le nom d'une fonction d'autorisation
1630 * 'article' => 'article'
1631 * 'truc_muche' => 'trucmuche'
1632 *
1633 * @param string $type
1634 *              Type ou objet
1635 * @return string
1636 *              Type pour le nom d'autorisation
1637**/
1638function fabrique_type_autorisation($type) {
1639        return str_replace('_', '', $type);
1640}
Note: See TracBrowser for help on using the repository browser.