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