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

Last change on this file since 100766 was 100766, checked in by cedric@…, 4 years ago

permettre la creation de plugin meme si on a pas SVP - ca sera moins joli car pas de chaines de langue, mais fonctionnel

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