source: spip-zone/_plugins_/fabrique/branches/v1/fabrique_fonctions.php @ 79327

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

2è version de l'option qui change le statut des rubriques (peetdu) :

  • manquait la déclaration du pipeline,
  • utiliser le nom d'objet, pas son type ;
  • id_rubrique correctement déclaré !
File size: 31.3 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/**
13 * Déterminer le répertoire de travail
14 * de la Fabrique.
15 *
16 * Dans :
17 * - plugins/fabrique_auto si possible, sinon dans
18 * - tmp/cache/fabrique
19 *
20 * @return string
21 *     Le chemin de destination depuis la racine de SPIP.
22**/
23function fabrique_destination() {
24        static $destination = null;
25        if (is_null($destination)) {
26                if (is_writable(_DIR_PLUGINS . rtrim(FABRIQUE_DESTINATION_PLUGINS, '/'))) {
27                        $destination = _DIR_PLUGINS . FABRIQUE_DESTINATION_PLUGINS;
28                } else {
29                        sous_repertoire(_DIR_CACHE, rtrim(FABRIQUE_DESTINATION_CACHE, '/'));
30                        $destination = _DIR_CACHE . FABRIQUE_DESTINATION_CACHE;
31                }
32        }
33        return $destination;
34}
35
36
37/**
38 * Crée l'arborescence manquante
39 *
40 * Crée tous les répertoires manquants dans une arborescence donnée.
41 * Les répertoires sont séparés par des '/'
42 *
43 * @example
44 *     sous_repertoire_complet('a/b/c/d');
45 *     appelle sous_repertoire() autant de fois que nécéssaire.
46 *
47 * @param string $arbo
48 *     Arborescence, tel que 'prive/squelettes/contenu'
49 * @return void
50**/
51function sous_repertoire_complet($arbo) {
52        $a = explode('/', $arbo);
53        if ($a[0] == '.' OR $a[0] == '..') {
54                $base = $a[0] . '/' . $a[1];
55                array_shift($a);
56                array_shift($a);
57        } else {
58                $base = $a[0];
59                array_shift($a);
60        }
61
62        foreach ($a as $dir) {
63                $base .= '/' . $dir;
64                sous_repertoire($base);
65        }
66}
67
68
69/**
70 * Concatène en utilisant implode, un tableau, de maniere récursive
71 *
72 * @param array $tableau
73 *     Tableau à transformer
74 * @param string $glue
75 *     Chaine insérée entre les valeurs
76 * @return string|bool
77 *     - False si pas un tableau
78 *     - Chaine concaténée sinon
79**/
80function fabrique_implode_recursif($tableau, $glue='') {
81        if (!is_array($tableau)) {
82                return false;
83        }
84
85        foreach ($tableau as $c =>$valeur) {
86                if (is_array($valeur)) {
87                        $tableau[$c] = fabrique_implode_recursif($valeur, $glue);
88                }
89        }
90
91        return implode($glue, $tableau);
92}
93
94
95/**
96 * Écrit une ouverture de code PHP
97 *
98 * Fait écrire '<?php' sans que ce php soit executé par SPIP !
99 *
100 * @param Champ $p
101 *     Pile au niveau de la balise
102 * @return Champ
103 *     Pile complétée du code à produire
104**/
105function balise_PHP_dist($p) {
106        $p->code = "'<?php echo \'<?php\n\'; ?>'";
107        $p->interdire_scripts = false;
108        return $p;
109}
110
111/**
112 * Convertie une chaîne pour en faire une chaîne de langue
113 *
114 * Permet d'insérer un texte comme valeur d'une clé de langue, lorsqu'on
115 * crée un fichier de langue avec la fabrique.
116 *
117 * Transforme les caractères &# et échappe les apostrophes :
118 * - &#xxx => le bon caractère
119 * - ' => \'
120 *
121 * @example
122 *     '#ENV{prefixe}_description' => '[(#ENV{paquet/description}|chaine_de_langue)]',
123 *
124 * @link http://www.php.net/manual/fr/function.html-entity-decode.php#104617
125 * @param string $texte
126 *     Le texte à écrire dans la chaîne de langue
127 * @return string
128 *     Le texte transformé
129**/
130function chaine_de_langue($texte) {
131        $texte = html_entity_decode($texte, ENT_QUOTES, 'UTF-8');
132        # egalement
133        # http://www.php.net/manual/fr/function.html-entity-decode.php#104617
134
135        return addslashes($texte);
136}
137
138/**
139 * Modifie le nom de la clé de langue pour
140 * utiliser le vrai nom de l'objet
141 *
142 * Remplace 'objets' par le nom de l'objet, et 'objet' par le type d'objet,
143 * mais ne touche pas à '\objets' ou '\objet'.
144 *
145 * @note
146 *     Cette fonction ne sert pas uniquement à définir des clés pour
147 *     les fichiers de chaînes de langue, et pourrait être renommée
148 *
149 * @example
150 *     cle_de_langue('titre_objets') => titre_chats
151 *     cle_de_langue('icone_creer_objet') => icone_creer_chat
152 *     cle_de_langue('prive/\objets/infos/objet.html') => prive/objets/infos/chat.html
153 * @param string $cle
154 *     La clé à transformer
155 * @param array $desc_objet
156 *     Couples d'information sur l'objet en cours, avec les index
157 *     'objet' et 'type' définis
158 * @retrun string
159 *     La clé transformée
160**/
161function cle_de_langue($cle, $desc_objet) {
162        // on permet d'echapper \objets pour trouver 'objets' au bout du compte
163        // sans qu'il soit transforme dans le nom reel de l'objet
164        // cas : 'prive/\objets/infos/objet.html' => 'prive/objets/infos/nom.html'
165        $cle = str_replace("\o", "\1o\\", $cle);
166        $cle =  str_replace(
167                array('objets', 'objet'),
168                array($desc_objet['objet'], $desc_objet['type']), $cle);
169        return str_replace("\1o\\", "o", $cle);
170}
171
172/**
173 * Identique à |cle_de_langue sur toutes les valeurs d'un tableau
174 *
175 * @see cle_de_langue()
176 * @param array $tableau
177 *     Tableau dont on veut transformer les valeurs
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 array
182 *     Tableau avec les valeurs transformées
183**/
184function tab_cle_de_langue($tableau, $desc_objet) {
185        foreach($tableau as $c => $v) {
186                $tableau[$c] = cle_de_langue($v, $desc_objet);
187        }
188        return $tableau;
189}
190
191/**
192 * Cherche s'il existe une chaîne de langue pour les clés de tableaux
193 * et ajoute alors la traduction dans la valeur de ce tableau
194 *
195 * @param array $tableau
196 *     Couples (clé => texte)
197 * @param string $prefixe_cle
198 *     Préfixe ajouté aux clés pour chercher les trads
199 * @param string $sep
200 *     Séparateur entre l'ancienne valeur et la concaténation de traduction
201 * @return array
202 *     Couples (clé => texte complété de la traduction si elle existe)
203**/
204function tab_cle_traduite_ajoute_dans_valeur($tableau, $prefixe_cle="", $sep = "&nbsp;: ") {
205        foreach($tableau as $c => $v) {
206                $trad = _T("fabrique:". $prefixe_cle . $c, array(), array('force' => false));
207                if ($trad) {
208                        $tableau[$c] = $v . $sep . $trad;
209                } else {
210                        $tableau[$c] = $v;
211                }
212        }
213        return $tableau;
214}
215
216/**
217 * Équivalent de wrap() sur les valeurs du tableau
218 *
219 * @param array $tableau
220 *     Tableau cle => texte
221 * @param string $balise
222 *     Balise qui encapsule
223 * @return array $tableau
224 *     Tableau clé => <balise>texte</balise>
225**/
226function tab_wrap($tableau, $balise) {
227        foreach ($tableau as $c => $v) {
228                $tableau[$c] = wrap($v, $balise);
229        }
230        return $tableau;
231}
232
233
234/**
235 * Fabrique un tableau de chaînes de langues
236 * avec des clés d'origines passées dans la fonctions
237 * cle_de_langue, et trie.
238 *
239 * @param array $objet
240 *     Description de l'objet dans la fabrique
241 * @return array
242 *     Couples (clé de langue => Texte)
243**/
244function fabriquer_tableau_chaines($objet) {
245        $chaines = array();
246        if (!is_array($objet)) { return $chaines; }
247        if (!$table = $objet['table'] OR !isset($objet['chaines']) OR !is_array($objet['chaines'])) { 
248                return $chaines;
249        }
250        // les chaines definies pour l'objet
251        foreach ($objet['chaines'] as $cle => $chaine) {
252                $chaines[ cle_de_langue($cle, $objet) ] = $chaine;
253        }
254        // les chaines definies pour chaque champ de l'objet
255        if (is_array($objet['champs'])) {
256                foreach ($objet['champs'] as $info) {
257                        $chaines[ cle_de_langue('label_' . $info['champ'], $objet) ] = $info['nom'];
258                        if ($info['explication']) {
259                                $chaines[ cle_de_langue('explication_' . $info['champ'], $objet) ] = $info['explication'];
260                        }
261                }
262        }
263        // les rôles définis
264        if ($roles = fabrique_description_roles($objet)) {
265                foreach ($roles['roles_trads'] as $cle => $texte) {
266                        $chaines[ $cle ] = $texte;
267                }
268        }
269
270        ksort($chaines);
271        return $chaines;
272}
273
274/**
275 * Retourne la description des rôles pour un objet
276 *
277 * @param array $objet
278 *     Descrption de l'objet
279 * @return array
280 *     Description des rôles. 4 index :
281 *     - roles_colonne : la colonne utilisée, toujours 'role'
282 *     - roles_titre   : couples clé du role, clé de langue du role
283 *     - roles_objets  : tableau objet => liste des clés de roles
284 *     - roles_trads   : couples clé de langue => Texte
285 *     - roles_defaut  : la clé du role par défaut
286 */
287function fabrique_description_roles($objet) {
288        $desc = array();
289        // les rôles définis
290        if (!options_presentes($objet, array('table_liens', 'roles'))
291        OR !($roles = trim($objet['roles']))) {
292                return $desc;
293        }
294        $desc['roles_colonne'] = 'role';
295        $desc['roles_titres'] = array(); # cle => cle_langue
296        $desc['roles_objets'] = array();
297        $desc['roles_trads']  = array(); # cle_langue => Texte
298        $desc['roles_defaut']  = '';
299
300        $roles = explode("\n", $roles);
301        foreach ($roles as $i=>$r) {
302                list($cle, $texte) = explode(',', $r, 2);
303                $cle = trim($cle);
304                if (!$i) $desc['roles_defaut'] = $cle; # la valeur par défaut est la première indiquée
305                $cle_langue = 'role_' . $cle;
306                $desc['roles_titres'][$cle] = $objet['type'] . ':' . $cle_langue;
307                $desc['roles_trads'][$cle_langue] = trim($texte);
308        }
309        $liens = array_map('table_objet', $objet['vue_liens']);
310        foreach ($liens as $l) {
311                $desc['roles_objets'][$l] = array_keys($desc['roles_titres']);
312        }
313        return $desc;
314}
315
316
317/**
318 * Indique si le champ est présent dans l'objet
319 *
320 * Champ, au sens de colonne SQL
321 *
322 * @param array $objet
323 *     Descrption de l'objet
324 * @param string $champ
325 *     Nom du champ SQL à tester
326 * @return string
327 *     Même retour que le filtre |oui :
328 *     - Un espace si le champ SQL exsitera dans l'objet
329 *     - Chaîne vide sinon
330**/
331function champ_present($objet, $champ) {
332        if (is_array($objet['champs'])) {
333                foreach ($objet['champs'] as $info) {
334                        if ($info['champ'] == $champ) {
335                                return " "; // true
336                        }
337                }
338        }
339        // id_rubrique, id_secteur
340        if (isset($objet['rubriques']) AND is_array($objet['rubriques'])) {
341                if (in_array($champ, $objet['rubriques'])) {
342                        return " "; // true
343                }
344        }
345        // lang, langue_choisie, id_trad
346        if (isset($objet['langues']) AND is_array($objet['langues'])) {
347                if (in_array($champ, $objet['langues'])) {
348                        return " "; // true
349                }
350                if (isset($objet['langues']['lang'])
351                        and ($objet['langues']['lang'])
352                        and ($champ == 'langue_choisie')) {
353                                return " "; // true
354                }
355        }
356        // date
357        if ($objet['champ_date']) {
358                if ($champ == $objet['champ_date']) {
359                        return " "; // true
360                }
361        }
362        // statut
363        if ($objet['statut']) {
364                if ($champ == 'statut') {
365                        return " "; // true
366                }
367        }
368
369        return ""; // false
370}
371
372
373/**
374 * Indique si toutes les options sont présentes dans l'objet
375 *
376 * Option au sens de clé de configuration, pas un nom de champ SQL
377 *
378 * @param array $objet
379 *     Descrption de l'objet
380 * @param array $champs
381 *     Liste de nom d'options à tester
382 * @return string
383 *     Même retour que le filtre |oui :
384 *     - Un espace si toutes les options sont présentes dans l'objet
385 *     - Chaîne vide sinon
386**/
387function options_presentes($objet, $champs) {
388        if (!$champs) return false;
389        if (!is_array($champs)) $champs = array($champs);
390        foreach ($champs as $champ) {
391                if (!option_presente($objet, $champ)) {
392                        return ""; // false
393                }
394        }
395        return " "; // true
396
397}
398
399/**
400 * Indique si une option est présente 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 $champ
407 *     Nom de l'option à tester
408 * @return string
409 *     Même retour que le filtre |oui :
410 *     - Un espace si l'option est présente dans l'objet
411 *     - Chaîne vide sinon
412**/
413function option_presente($objet, $champ) {
414        // a la racine
415        if (isset($objet[$champ]) and $objet[$champ]) {
416                return " "; // true
417        }
418
419        // id_rubrique, vue_rubrique
420        if (isset($objet['rubriques']) AND is_array($objet['rubriques'])) {
421                if (in_array($champ, $objet['rubriques'])) {
422                        return " "; // true
423                }
424        }
425
426        // lang, id_trad
427        if (isset($objet['langues']) AND is_array($objet['langues'])) {
428                if (in_array($champ, $objet['langues'])) {
429                        return " "; // true
430                }
431        }
432       
433        // menu_edition, outils_rapides
434        if (isset($objet['boutons']) AND is_array($objet['boutons'])) {
435                if (in_array($champ, $objet['boutons'])) {
436                        return " "; // true
437                }
438        }
439
440        return ""; // false
441}
442
443
444/**
445 * Indique si une option donnée est presente dans la définition d'un champ
446 * de la fabrique
447 *
448 * @param array $champ
449 *     Description d'un champ SQL d'un objet créé avec la fabrique
450 * @param string $option
451 *     Option testée
452 * @return string
453 *     Même retour que le filtre |oui :
454 *     - Un espace si l'option est présente dans le champ de l'objet
455 *     - Chaîne vide sinon
456 */
457function champ_option_presente($champ, $option) {
458        if (isset($champ[$option]) and $champ[$option]) {
459                return " "; // true
460        }
461
462        // editable, versionne, obligatoire
463        if (isset($champ['caracteristiques']) and is_array($champ['caracteristiques'])) {
464                if (in_array($option, $champ['caracteristiques'])) {
465                        return " "; // true
466                }
467        }
468
469        return false;
470}
471
472/**
473 * Retourne les objets possédant un certain champ SQL
474 *
475 * Cela simplifie des boucles DATA
476 *
477 * @example
478 *     #OBJETS|objets_champ_present{id_rubrique}
479 *
480 *     On peut ne retourner qu'une liste de type de valeur (objet, type, id_objet)
481 *     #OBJETS|objets_champ_present{id_rubrique, objet} // chats,souris
482 *
483 * @param array $objets
484 *     Liste des descriptions d'objets créés avec la fabrique
485 * @param string $champ
486 *     Type de champ sélectionné
487 * @param string $type
488 *     Information de retour désiré :
489 *     - vide pour toute la description de l'objet
490 *     - clé dans la description de l'objet pour obtenir uniquement ces descriptions
491 * @return array
492 *     - tableau de description des objets sélectionnés (si type non défini)
493 *     - tableau les valeurs du type demandé dans les objets sélectionnés (si type défini)
494**/
495function objets_champ_present($objets, $champ, $type='') {
496        return _tableau_option_presente('champ_present', $objets, $champ, $type);
497}
498
499
500/**
501 * Retourne les objets possédant une certaine option
502 *
503 * Option au sens des clés du formulaire de configuration de l'objet
504 *
505 * @example
506 *     #OBJETS|objets_option_presente{vue_rubrique}
507 *     #OBJETS|objets_option_presente{auteurs_liens}
508 *
509 *     On peut ne retourner qu'une liste de type de valeur (objet, type, id_objet)
510 *     #OBJETS|objets_option_presente{auteurs_liens, objet} // chats,souris
511 *
512 * @param array $objets
513 *     Liste des descriptions d'objets créés avec la fabrique
514 * @param string $option
515 *     Type d'option sélectionnée
516 * @param string $type
517 *     Information de retour désiré :
518 *     - vide pour toute la description de l'objet
519 *     - clé dans la description de l'objet pour obtenir uniquement ces descriptions
520 * @return array
521 *     - tableau de description des objets sélectionnés (si type non défini)
522 *     - tableau les valeurs du type demandé dans les objets sélectionnés (si type défini)
523**/
524function objets_option_presente($objets, $option, $type='') {
525        return _tableau_option_presente('option_presente', $objets, $option, $type);
526}
527
528
529/**
530 * Retourne les objets possédant plusieurs options
531 *
532 * Option au sens des clés du formulaire de configuration de l'objet
533 *
534 * @example
535 *     #OBJETS|objets_options_presentes{#LISTE{table_liens,vue_liens}}
536 *
537 *     On peut ne retourner qu'une liste de type de valeur (objet, type, id_objet)
538 *     #OBJETS|objets_options_presentes{#LISTE{table_liens,vue_liens}, objet} // chats,souris
539 *
540 * @param array $objets
541 *     Liste des descriptions d'objets créés avec la fabrique
542 * @param array $options
543 *     Liste de type d'option à sélectionner
544 * @param string $type
545 *     Information de retour désiré :
546 *     - vide pour toute la description de l'objet
547 *     - clé dans la description de l'objet pour obtenir uniquement ces descriptions
548 * @return array
549 *     - tableau de description des objets sélectionnés (si type non défini)
550 *     - tableau les valeurs du type demandé dans les objets sélectionnés (si type défini)
551**/
552function objets_options_presentes($objets, $options, $type='') {
553        return _tableau_options_presentes('option_presente', $objets, $options, $type);
554}
555
556/**
557 * Retourne des champs en fonction d'une option trouvée
558 *
559 * @example
560 *     #CHAMPS|champs_option_presente{editable}
561 *     #CHAMPS|champs_option_presente{versionne}
562 *
563 * @param array $champs
564 *     Liste des descriptions de champs d'un objet créé avec la fabrique
565 * @param string $option
566 *     Type d'option sélectionnée
567 * @param string $type
568 *     Information de retour désiré :
569 *     - vide pour toute la description du champ
570 *     - clé dans la description du champ pour obtenir uniquement ces descriptions
571 * @return array
572 *     - tableau de description des champs sélectionnés (si type non défini)
573 *     - tableau les valeurs du type demandé dans les champs sélectionnés (si type défini)
574**/
575function champs_option_presente($champs, $option, $type='') {
576        return _tableau_option_presente('champ_option_presente', $champs, $option, $type);
577}
578
579/**
580 * Retourne des champs en fonction des options trouvées
581 *
582 * @example
583 *     #CHAMPS|champs_options_presentes{#LISTE{obligatoire,saisie}}
584 *
585 * @param array $champs
586 *     Liste des descriptions de champs d'un objet créé avec la fabrique
587 * @param array $options
588 *     Liste de type d'options à sélectionner
589 * @param string $type
590 *     Information de retour désiré :
591 *     - vide pour toute la description du champ
592 *     - clé dans la description du champ pour obtenir uniquement ces descriptions
593 * @return array
594 *     - tableau de description des champs sélectionnés (si type non défini)
595 *     - tableau les valeurs du type demandé dans les champs sélectionnés (si type défini)
596**/
597function champs_options_presentes($champs, $options, $type='') {
598        return _tableau_options_presentes('champ_option_presente', $champs, $options, $type);
599}
600
601
602/**
603 * Fonction générique pour retourner une liste de choses dans un tableau
604 *
605 * @param string $func
606 *     Nom de la fonction à appeler, tel que
607 *     - champ_option_presente
608 *     - option_presente
609 *     - ...
610 * @param array $tableau
611 *     Tableau de descriptions (descriptions d'objet ou descriptions de champ d'objet)
612 * @param string $option
613 *     Nom de l'option dont on teste la présence
614 * @param string $type
615 *     Information de retour désiré :
616 *     - vide pour toute la description
617 *     - clé dans la description pour obtenir uniquement ces descriptions
618 * @return array
619 *     Liste des descriptions correspondant à l'option demandée
620 */
621function _tableau_option_presente($func, $tableau, $option, $type='') {
622        $o = array();
623
624        if (!is_array($tableau) OR !$func) {
625                return $o;
626        }
627        // tableau est un tableau complexe de donnee
628        foreach ($tableau as $objet) {
629                // on cherche la donnee 'option' dans le tableau
630                // en utilisant une fonction specifique de recherche (option_presente, champ_present, ...)
631                if ($func($objet, $option)) {
632                        // si on a trouve notre option :
633                        // type permet de recuperer une cle specifique dans la liste des cles parcourues.
634                        // sinon, retourne tout le sous tableau.
635                        if ($type and isset($objet[$type])) {
636                                $o[] = $objet[$type];
637                        } elseif (!$type) {
638                                $o[] = $objet;
639                        }
640                }
641        }
642        return $o;
643}
644
645/**
646 * Fonction générique pour retourner une liste de choses multiples dans un tableau
647 *
648 * @param string $func
649 *     Nom de la fonction à appeler, tel que
650 *     - champ_option_presente
651 *     - option_presente
652 *     - ...
653 * @param array $tableau
654 *     Tableau de descriptions (descriptions d'objet ou descriptions de champ d'objet)
655 * @param array $options
656 *     Nom des l'options dont on teste leur présence
657 * @param string $type
658 *     Information de retour désiré :
659 *     - vide pour toute la description
660 *     - clé dans la description pour obtenir uniquement ces descriptions
661 * @return array
662 *     Liste des descriptions correspondant aux options demandées
663 */
664function _tableau_options_presentes($func, $tableau, $options, $type='') {
665        if (!$options) return array();
666
667        if (!is_array($options)) {
668                $options = array($options);
669        }
670
671        $first = false;
672        foreach ($options as $option) {
673                $r = _tableau_option_presente($func, $tableau, $option, $type);
674                if (!$first) {
675                        $res = $r;
676                        $first = true;
677                } else {
678                        #$res = array_intersect($res, $r);
679                        // array_intersect() ne prend pas en compte les sous tableaux
680                        foreach ($res as $i => $v) {
681                                if (false === array_search($v, $r)) {
682                                        unset($res[$i]);
683                                }
684                        }
685                        $res = array_values($res);
686                }
687        }
688
689        return $res;
690}
691
692
693/**
694 * Retourne une ecriture de criteres
695 * {id_parent?}{id_documentation?}
696 * avec tous les champs id_x declarés dans l'interface
697 * dans la liste des champs.
698 *
699 * Cela ne concerne pas les champs speciaux (id_rubrique, id_secteur, id_trad)
700 * qui ne seront pas inclus.
701 *
702 * @param array $objet
703 *     Description de l'objet dans la fabrique
704 * @return string
705 *     L'écriture des critères de boucle
706**/
707function criteres_champs_id($objet) {
708        $ids = array();
709        if (is_array($objet['champs'])) {
710                foreach ($objet['champs'] as $info) {
711                        if (substr($info['champ'], 0, 3) == 'id_') {
712                                $ids[] = $info['champ'];
713                        }
714                }
715        }
716        if (!$ids) {
717                return "";
718        }
719        return "{" . implode("?}{", $ids) . "?}";
720}
721
722/**
723 * Retourne un tableau de toutes les tables SQL
724 * pour tous les objets.
725 *
726 * @param array $objets
727 *     Liste des descriptions d'objets créés avec la fabrique
728 * @param string $quoi
729 *     Choix du retour désiré :
730 *     - 'tout'   => toutes les tables (par défaut)
731 *     - 'objets' => les tables d'objet (spip_xx, spip_yy)
732 *     - 'liens'  => les tables de liens (spip_xx_liens, spip_yy_liens)
733 * @return array
734 *     Liste des tables
735**/
736function fabrique_lister_tables($objets, $quoi='tout') {
737        static $tables = array();
738
739        if (!$objets) return array();
740
741        $hash = md5(serialize($objets));
742       
743        if (!isset($tables[$hash])) {
744                $tables[$hash] = array(
745                        'tout' => array(),
746                        'objets' => array(),
747                        'liens' => array(),
748                );
749                foreach ($objets as $o) {
750                        // tables principales
751                        if (isset($o['table']) and $o['table']) {
752                                $tables[$hash]['objets'][] = $o['table'];
753                                $tables[$hash]['tout'][] = $o['table'];
754                                // tables de liens
755                                if ($o['table_liens']) {
756                                        $tables[$hash]['liens'][] = $o['nom_table_liens'];
757                                        $tables[$hash]['tout'][]  = $o['nom_table_liens'];
758                                }
759                        }
760                }
761        }
762       
763        return $tables[$hash][$quoi];
764}
765
766
767/**
768 * Indique si un des objets a besoin du pipeline demandé
769 *
770 * @param array $objets
771 *     Liste des descriptions d'objets créés avec la fabrique
772 * @param string $pipeline
773 *     Nom du pipeline
774 * @return array
775 *     Liste des objets (descriptions) utilisant le pipeline
776 */
777function fabrique_necessite_pipeline($objets, $pipeline) {
778
779        if (!$objets) return false;
780
781        switch ($pipeline) {
782                case "autoriser":
783                case "declarer_tables_objets_sql":
784                case "declarer_tables_interfaces":
785                        return (bool)fabrique_lister_tables($objets, 'objets');
786                        break;
787
788                case "declarer_tables_auxiliaires":
789                        return (bool)fabrique_lister_tables($objets, 'liens');
790                        break;
791
792                case "affiche_enfants":
793                        if (objets_option_presente($objets, 'vue_rubrique')) {
794                                return true;
795                        }
796                        break;
797
798                case "affiche_milieu":
799                        if (objets_option_presente($objets, 'auteurs_liens')
800                        OR  objets_options_presentes($objets, array('table_liens', 'vue_liens'))) {
801                                return true;
802                        }
803                        break;
804
805                case "affiche_auteurs_interventions":
806                        if (objets_option_presente($objets, 'vue_auteurs_liens')) {
807                                return true;
808                        }
809                        break;
810
811                case "afficher_contenu_objet":
812                        return false;
813                        break;
814
815                case "objet_compte_enfants":
816                        if (objets_options_presentes($objets, array('id_rubrique', 'statut_rubrique'))) {
817                                return true;
818                        }
819                        break;
820
821                case "optimiser_base_disparus":
822                        # nettoie depuis spip_{objet}_liens
823                        # mais aussi les liaisions vers spip_{objet} (uniquement si une table de liens existe)
824                        return (bool)fabrique_lister_tables($objets, 'liens');
825                        #return (bool)fabrique_lister_tables($objets, 'objets');
826                        break;
827        }
828        return false;
829}
830
831
832/**
833 * Crée le code PHP de création d'un tableau
834 *
835 * Fonction un peu équivalente à var_export()
836 *
837 * @param array $tableau
838 *     Le tableau dont on veut obtenir le code de création array( ... )
839 * @param bool $quote
840 *     Appliquer sql_quote() sur chaque valeur (dans le code retourne)
841 * @param string $defaut
842 *     Si $tableau est vide ou n'est pas une chaîne, la fonction retourne cette valeur
843 * @return string
844 *     - Le code de création du tableau, avec éventuellement le code pour appliquer sql_quote.
845 *     - $defaut si le tableau est vide
846**/
847function ecrire_tableau($tableau, $quote = false, $defaut = "array()") {
848        // pas de tableau ?
849        if (!is_array($tableau) OR !count($tableau)) {
850                return $defaut;
851        }
852
853        $res = "array('" . implode("', '", array_map('addslashes', $tableau)) . "')";
854
855        if ($quote) {
856                $res = "array_map('sql_quote', $res)";
857        }
858        return $res;
859}
860
861/**
862 * Crée le code PHP de création d'un tableau sauf s'il est vide
863 *
864 * Identique à ecrire_tableau() mais ne retourne rien si le tableau est vide
865 * @see ecrire_tableau()
866 *
867 * @param array $tableau
868 *     Le tableau dont on veut obtenir le code de création array( ... )
869 * @param bool $quote
870 *     Appliquer sql_quote() sur chaque valeur (dans le code retourne)
871 * @return string
872 *     - Le code de création du tableau, avec éventuellement le code pour appliquer sql_quote.
873 *     - Chaîne vide si le tableau est vide
874**/
875function ecrire_tableau_sinon_rien($tableau, $quote = false) {
876        return ecrire_tableau($tableau, $quote, "");
877}
878
879/**
880 * Ajoute autant des espaces à la fin d'une chaîne jusqu'à la taille indiquée
881 *
882 * Fonction un peu equivalente à str_pad() mais avec une valeur par défaut
883 * définie par la constante _FABRIQUE_ESPACER
884 *
885 * @param string $texte
886 *     Texte à compléter
887 * @param int $taille
888 *     Taille spécifique, utilisée à la place de la constante si renseignée
889 * @return
890 *     Texte complété des espaces de fin
891 */
892function espacer($texte, $taille = 0) {
893        if (!$taille) $taille = _FABRIQUE_ESPACER;
894        return str_pad($texte, $taille);
895}
896
897
898/**
899 * Tabule à gauche chaque ligne du nombre de tabulations indiquées
900 * + on enleve les espaces sur les lignes vides
901 *
902 * @param string $texte
903 *     Un texte, qui peut avoir plusieurs lignes
904 * @param int $nb_tabulations
905 *     Nombre de tabulations à appliquer à gauche de chaque ligne
906 * @return string
907 *     Texte indenté du nombre de tabulations indiqué
908 */
909function fabrique_tabulations($texte, $nb_tabulations) {
910        $tab = "";
911        if ($nb_tabulations) {
912                $tab = str_pad("\t", $nb_tabulations);
913        }
914        $texte = explode("\n", $texte);
915        foreach ($texte as $c => $ligne) {
916                $l = ltrim(ltrim($ligne), "\t");
917                if (!$l) {
918                        $texte[$c] = "";
919                } else {
920                        $texte[$c] = $tab . $ligne;
921                }
922        }
923        return implode("\n", $texte);
924}
925
926
927
928
929/**
930 * Passer en majuscule en utilisant mb de préférence
931 * s'il est disponible.
932 *
933 * @param string $str
934 *     La chaine à passer en majuscule
935 * @return string
936 *     La chaine en majuscule
937**/
938function fabrique_mb_strtoupper($str) {
939        if (function_exists('mb_strtoupper')) {
940                return mb_strtoupper($str);
941        } else {
942                return strtoupper($str);
943        }
944}
945
946/**
947 * Passer en minuscule en utilisant mb de préférence
948 * s'il est disponible.
949 *
950 * @param string $str
951 *              La chaine à passer en minuscule
952 * @return string
953 *              La chaine en minuscule
954**/
955function fabrique_mb_strtolower($str) {
956        if (function_exists('mb_strtolower')) {
957                return mb_strtolower($str);
958        } else {
959                return strtolower($str);
960        }
961}
962
963
964/**
965 * Crée une balise HTML <img> à partir d'un fichier,
966 * réactualisée à chaque calcul, selon une réduction donnée.
967 *
968 * Cela évite un |array_shift qui ne passe pas en PHP 5.4
969 *
970 * Attention à bien rafraîchir l'image réduite lorsqu'on change de logo.
971 *
972 * @example
973 *     #URL_IMAGE|fabrique_miniature_image{128}
974 *
975 *     Applique l'équivalent de :
976 *     #URL_IMAGE|image_reduire{128}|extraire_attribut{src}
977 *         |explode{?}|array_shift|timestamp|balise_img
978 *
979 * @param string $fichier
980 *     Chemin du fichier
981 * @param int $taille
982 *     Taille de réduction de l'image
983 * @return string
984 *     Balise HTML IMG de l'image réduite et à jour
985 */
986function filtre_fabrique_miniature_image($fichier, $taille=256) {
987        $im = filtrer('image_reduire', $fichier, $taille);
988        $im = extraire_attribut($im, 'src');
989        $im = explode('?', $im);
990        $im = array_shift($im);
991        $im = timestamp($im);
992        $im = filtrer('balise_img', $im);
993        return $im;
994}
995
996
997
998/**
999 * Retourne un tableau table_sql=>Nom des objets de SPIP
1000 * complété des objets declares dans la fabrique ainsi
1001 * que de tables indiquees même si elles ne font pas parties
1002 * de declarations connues.
1003 *
1004 * @param array $objets_fabrique
1005 *              Déclaration d'objets de la fabrique
1006 * @param array $inclus
1007 *              Liste de tables SQL que l'on veut forcement presentes
1008 *              meme si l'objet n'est pas declare
1009 * @param array $exclus
1010 *              Liste de tables SQL que l'on veut forcement exclues
1011 *              meme si l'objet n'est pas declare
1012 * @return array
1013 *              Tableau table_sql => Nom
1014**/
1015function filtre_fabrique_lister_objets_editoriaux($objets_fabrique, $inclus=array(), $exclus=array()) {
1016
1017        // les objets existants
1018        $objets = lister_tables_objets_sql();
1019        foreach ($objets as $sql => $o) {
1020                if ($o['editable']) {
1021                        $liste[$sql] = _T($o['texte_objets']);
1022                }
1023        }
1024        unset($objets);
1025
1026        // les objets de la fabrique
1027        foreach ($objets_fabrique as $o) {
1028                if (isset($o['table']) and !isset($liste[$o['table']])) {
1029                        $liste[ $o['table'] ] = $o['nom'];
1030                }
1031        }
1032
1033        // des objets qui n'existent pas mais qui sont actuellement coches dans la saisie
1034        foreach ($inclus as $sql) {
1035                if (!isset($liste[$sql])) {
1036                        $liste[$sql] = $sql; // on ne connait pas le nom
1037                }
1038        }
1039
1040        // tables forcement exclues
1041        foreach ($exclus as $sql) {
1042                unset($liste[$sql]);
1043        }
1044        // enlever un eventuel element vide
1045        unset($liste['']);
1046
1047        asort($liste);
1048
1049        return $liste;
1050}
1051
1052
1053/**
1054 * Retourne le code pour tester un type d'autorisation
1055 *
1056 * @param string $type
1057 *              Quelle type d'autorisation est voulue
1058 * @return string
1059 *              Code de test de l'autorisation
1060**/
1061function fabrique_code_autorisation($type) {
1062        switch($type) {
1063
1064                case "jamais":
1065                        return "false";
1066                        break;
1067
1068                case "toujours":
1069                        return "true";
1070                        break;
1071
1072                case "redacteur":
1073                        return "in_array(\$qui['statut'], array('0minirezo', '1comite'))";
1074                        break;
1075
1076                case "administrateur_restreint":
1077                        return "\$qui['statut'] == '0minirezo'";
1078                        break;
1079
1080                case "administrateur":
1081                        return "\$qui['statut'] == '0minirezo' AND !\$qui['restreint']";
1082                        break;
1083
1084                case "webmestre":
1085                        return "autoriser('webmestre', '', '', \$qui)";
1086                        break;
1087
1088        }
1089
1090        return "";
1091}
1092
1093/**
1094 * Retourne la valeur de type d'autorisation
1095 * qui s'applique par defaut pour une autorisation donnee
1096 *
1097 * @param string $autorisation
1098 *              Nom de l'autorisation (objet et objets remplacent le veritable type et nom d'objet)
1099 * @return string
1100 *              Type d'autorisation par defaut (jamais, toujours, redacteur, ...)
1101**/
1102function fabrique_autorisation_defaut($autorisation) {
1103        switch($autorisation) {
1104                case 'objet_voir':
1105                        return "toujours";
1106                        break;
1107
1108                case 'objet_creer':
1109                case 'objet_modifier':
1110                        return "redacteur";
1111                        break;
1112
1113                case 'objet_supprimer':
1114                case 'associerobjet':
1115                        return "administrateur";
1116                        break;
1117        }
1118}
1119
1120/**
1121 * Retourne le code d'autorisation indique
1122 * sinon celui par defaut pour une fonction d'autorisation
1123 *
1124 * @param array $autorisations
1125 *              Les autorisations renseignees par l'interface pour un objet
1126 * @param string $autorisation
1127 *              Le nom de l'autorisation souhaitee
1128 * @return string
1129 *              Code de l'autorisation
1130**/
1131function fabrique_code_autorisation_defaut($autorisations, $autorisation) {
1132        if (!$autorisation) return "";
1133
1134        // trouver le type d'autorisation souhaitee, soit indiquee, soit par defaut
1135        if (!isset($autorisations[$autorisation]) OR !$type = $autorisations[$autorisation]) {
1136                $type = fabrique_autorisation_defaut($autorisation);
1137        }
1138
1139        // retourner le code PHP correspondant
1140        return fabrique_code_autorisation($type);
1141}
1142
1143/**
1144 * Retourne le type pour le nom d'une fonction d'autorisation
1145 * 'article' => 'article'
1146 * 'truc_muche' => 'trucmuche'
1147 *
1148 * @param string $type
1149 *              Type ou objet
1150 * @return string
1151 *              Type pour le nom d'autorisation
1152**/
1153function fabrique_type_autorisation($type) {
1154        return str_replace('_', '', $type);
1155}
1156
1157?>
Note: See TracBrowser for help on using the repository browser.