source: spip-zone/_plugins_/noiZetier/inc/noizetier.php @ 37304

Last change on this file since 37304 was 37304, checked in by joseph@…, 10 years ago

oups coquilles

File size: 14.7 KB
Line 
1<?php
2
3// Sécurité
4if (!defined("_ECRIRE_INC_VERSION")) return;
5
6/**
7 * Lister les noisettes disponibles dans les dossiers noisettes/
8 *
9 * @staticvar array $liste_noisettes
10 * @param text $type
11 * @return array
12 */
13function noizetier_lister_noisettes($type='tout'){
14        static $liste_noisettes = null;
15
16        if (is_null($liste_noisettes[$type])){
17                $liste_noisettes[$type] = array();
18               
19                // Si $type='tout' on recherche toutes les noisettes sinon seules celles qui commencent par $type
20                if ($type=='tout')
21                        $match = "[^-]*[.]html$";
22                elseif ($type=='')
23                        $match = "^[^-]*[.]html$";
24                else
25                        $match = $type."-[^-]*[.]html$";
26
27                // lister les noisettes disponibles
28                $liste = find_all_in_path('noisettes/', $match);
29                if (count($liste)){
30                        foreach($liste as $squelette=>$chemin) {
31                                $noisette = preg_replace(',[.]html$,i', '', $squelette);
32                                $dossier = str_replace($squelette, '', $chemin);
33                                // On ne garde que les squelettes ayant un fichier YAML de config (si yaml est activé)
34                                if (file_exists("$dossier$noisette.yaml") AND defined('_DIR_PLUGIN_YAML')
35                                        AND ($infos_noisette = noizetier_charger_infos_noisette_yaml($dossier.$noisette))
36                                ){
37                                        $liste_noisettes[$type][$noisette] = $infos_noisette;
38                                }
39                                // ou les squelettes ayant un XML de config
40                                elseif (file_exists("$dossier$noisette.xml")
41                                        AND ($infos_noisette = noizetier_charger_infos_noisette_xml($dossier.$noisette))
42                                ){
43                                        $liste_noisettes[$type][$noisette] = $infos_noisette;
44                                }
45                        }
46                }
47                // supprimer de la liste les noisettes necissant un plugin qui n'est pas actif
48                foreach ($liste_noisettes[$type] as $noisette => $infos_noisette)
49                        if (isset($infos_noisette['necessite']))
50                                foreach ($infos_noisette['necessite'] as $plugin)
51                                        if (!defined('_DIR_PLUGIN_'.strtoupper($plugin)))
52                                                unset($liste_noisettes[$type][$noisette]);
53        }
54        return $liste_noisettes[$type];
55}
56
57/**
58 * Charger les informations contenues dans le xml d'une noisette
59 *
60 * @param string $noisette
61 * @param string $info
62 * @return array
63 */
64function noizetier_charger_infos_noisette_xml($noisette, $info=""){
65                // on peut appeler avec le nom du squelette
66                $fichier = preg_replace(',[.]html$,i','',$noisette).".xml";
67                include_spip('inc/xml');
68                include_spip('inc/texte');
69                $infos_noisette = array();
70                if ($xml = spip_xml_load($fichier, false)){
71                        if (count($xml['noisette'])){
72                                $xml = reset($xml['noisette']);
73                                $infos_noisette['nom'] = _T_ou_typo(spip_xml_aplatit($xml['nom']));
74                                $infos_noisette['description'] = isset($xml['description']) ? _T_ou_typo(spip_xml_aplatit($xml['description'])) : '';
75                                $infos_noisette['icon'] = isset($xml['icon']) ? find_in_path(reset($xml['icon'])) : '';
76                                // Décomposition des paramètres (enregistrer sous la forme d'un tableau respectant la norme de saisies
77                                $infos_noisette['parametres'] = array();
78                                if (spip_xml_match_nodes(',^parametre,', $xml, $parametres)){
79                                        foreach (array_keys($parametres) as $parametre){
80                                                list($balise, $attributs) = spip_xml_decompose_tag($parametre);
81                                                $infos_noisette['parametres'][] = array(
82                                                        'saisie' => $attributs['saisie'] ? $attributs['saisie'] : 'input',
83                                                        'options' => array(
84                                                                'nom' => $attributs['nom'],
85                                                                'label' => $attributs['label'] ? _T($attributs['label']) : $attributs['nom'],
86                                                                'defaut' => $attributs['defaut'],
87                                                                'obligatoire' => $attributs['obligatoire'] == 'oui' ? 'oui' : 'non'
88                                                        )
89                                                );
90                                        }
91                                }
92                                if (spip_xml_match_nodes(',^necessite,', $xml, $necessites)){
93                                        $infos_noisette['necessite'] = array();
94                                        foreach (array_keys($necessites) as $necessite){
95                                                list($balise, $attributs) = spip_xml_decompose_tag($necessite);
96                                                $infos_noisette['necessite'][] = $attributs['id'];
97                                        }
98                                }
99                        }
100                }
101                if (!$info)
102                        return $infos_noisette;
103                else 
104                        return isset($infos_noisette[$info]) ? $infos_noisette[$info] : "";
105}
106
107
108/**
109 * Charger les informations contenues dans le YAML d'une noisette
110 *
111 * @param string $noisette
112 * @param string $info
113 * @return array
114 */
115function noizetier_charger_infos_noisette_yaml($noisette, $info=""){
116                // on peut appeler avec le nom du squelette
117                $fichier = preg_replace(',[.]html$,i','',$noisette).".yaml";
118                include_spip('inc/yaml');
119                include_spip('inc/texte');
120                $infos_noisette = array();
121                if ($infos_noisette = yaml_decode_file($fichier)) {
122                        if (isset($infos_noisette['nom']))
123                                $infos_noisette['nom'] = _T_ou_typo($infos_noisette['nom']);
124                        if (isset($infos_noisette['description']))
125                                $infos_noisette['description'] = _T_ou_typo($infos_noisette['description']);
126                        if (isset($infos_noisette['icon']))
127                                $infos_noisette['icon'] = find_in_path($infos_noisette['icon']);
128                               
129                }
130
131                if (!$info)
132                        return $infos_noisette;
133                else 
134                        return isset($infos_noisette[$info]) ? $infos_noisette[$info] : "";
135}
136
137/**
138 * Charger les informations des paramètres d'une noisette
139 *
140 * @param string $noisette
141 * @staticvar array $params_noisettes
142 * @return array
143 */
144function noizetier_charger_parametres_noisette($noisette){
145        static $params_noisettes = null;
146
147        if (is_null($params_noisettes[$noisette])){
148                $noisettes = noizetier_lister_noisettes();
149                $infos = $noisettes[$noisette];
150                $params_noisettes[$noisette] = extrait_parametres_noisette($infos['parametres']);
151        }
152        return $params_noisettes[$noisette];
153}
154
155/**
156 * Transforme un tableau au format du plugin saisies en un tableau de parametres dont les clés sont les noms des paramètres
157 * S'il y a de fieldset, les paramètres sont extraits de son entrée saisie
158 *
159 * @param string $parametres
160 * @return array
161 */
162function extrait_parametres_noisette($parametres){
163        $res = array();
164        foreach($parametres as $parametre) {
165                if ($parametre['saisie']!='fieldset') {
166                        $nom = $parametre['options']['nom'];
167                        $res[$nom] = $parametre['options'];
168                        $res[$nom]['saisie'] = $parametre['saisie'];
169                        if(isset($parametre['verifier']))
170                                $res[$nom]['verifier']=$parametre['verifier'];
171                        if(isset($res[$nom]['label']))
172                                $res[$nom]['label'] = _T_ou_typo($res[$nom]['label']);
173                        if(isset($res[$nom]['datas']))
174                                foreach($res[$nom]['datas'] as $cle => $valeur)
175                                        $res[$nom]['datas'][$cle] = _T_ou_typo($res[$nom]['datas'][$cle]);
176                }
177                else {
178                        $res = array_merge($res,extrait_parametres_noisette($parametre['saisies']));
179                }
180        }
181        return $res;
182}
183
184/**
185 * Lister les pages pouvant recevoir des noisettes
186 * Par défaut, cette liste est basée sur le contenu du répertoire contenu/
187 * Le tableau de résultats peut-être modifié via le pipeline noizetier_lister_pages.
188 *
189 * @staticvar array $liste_pages
190 * @return array
191 */
192function noizetier_lister_pages(){
193        static $liste_pages = null;
194
195        if (is_null($liste_pages)){
196                $liste_pages = array();
197                $match = ".+[.]html$";
198
199                // lister les fonds disponibles dans le répertoire contenu
200                $liste = find_all_in_path('contenu/', $match);
201                if (count($liste)){
202                        foreach($liste as $squelette=>$chemin) {
203                                $page = preg_replace(',[.]html$,i', '', $squelette);
204                                $dossier = str_replace($squelette, '', $chemin);
205                                // Les éléments situés dans prive/contenu sont écartés
206                                if (substr($dossier,-14)!='prive/contenu/')
207                                        $liste_pages[$page] = noizetier_charger_infos_page($dossier,$page);
208                        }
209                }
210                // Dans le cas de Zpip, il faut supprimer la page 'page.html'
211                if (defined('_DIR_PLUGIN_Z'))
212                        unset($liste_pages['page']);
213               
214                $liste_pages = pipeline('noizetier_lister_pages',$liste_pages);
215               
216                // On ajoute les compositions du noizetier
217                if(defined('_DIR_PLUGIN_COMPOSITIONS')){
218                        $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
219                        // On doit transformer le tableau de [type][compo] en [type-compo]
220                        $liste_compos = array();
221                        if (is_array($noizetier_compositions)) {
222                                foreach($noizetier_compositions as $type => $compos_type)
223                                        foreach($compos_type as $compo => $infos_compo) {
224                                                $infos_compo['nom'] = typo($infos_compo['nom']);
225                                                $infos_compo['description'] = propre($infos_compo['description']);
226                                                $infos_compo['icon'] = $infos_compo['icon']!='' ? find_in_path($infos_compo['icon']) : '';
227                                                $infos_compo['blocs'] = $liste_pages[$type]['blocs'];
228                                                $liste_compos[$type.'-'.$compo] = $infos_compo;
229                                                }
230                        }
231                        $liste_pages = array_merge($liste_pages,$liste_compos);
232                }
233        }
234        return $liste_pages;
235}
236
237/**
238 * Charger les informations d'une page, contenues dans un xml de config s'il existe
239 *
240 * @param string $dossier
241 * @param string $page
242 * @param string $info
243 * @return array
244 */
245function noizetier_charger_infos_page($dossier,$page, $info=""){
246                // on peut appeler avec le nom du squelette
247                $page = preg_replace(',[.]html$,i','',$page);
248               
249                // On autorise le fait que le fichier xml ne soit pas dans le même plugin que le fichier .html
250                // Au cas où le fichier .html soit surchargé sans que le fichier .xml ne le soit
251                $fichier = find_in_path("contenu/$page.xml");
252               
253                include_spip('inc/xml');
254                include_spip('inc/texte');
255                $infos_page = array();
256                // S'il existe un fichier xml de configuration (s'il s'agit d'une composition on utilise l'info de la composition)
257                if (file_exists($fichier) AND $xml = spip_xml_load($fichier, false) AND count($xml['page']))
258                        $xml = reset($xml['page']);
259                elseif (file_exists($fichier) AND $xml = spip_xml_load($fichier, false) AND count($xml['composition']))
260                        $xml = reset($xml['composition']);
261                else
262                        $xml = '';
263                if ($xml != '') {
264                        $infos_page['nom'] = _T_ou_typo(spip_xml_aplatit($xml['nom']));
265                        $infos_page['description'] = isset($xml['description']) ? _T_ou_typo(spip_xml_aplatit($xml['description'])) : '';
266                        $infos_page['icon'] = isset($xml['icon']) ? find_in_path(reset($xml['icon'])) : '';
267                        // Décomposition des blocs
268                        if (spip_xml_match_nodes(',^bloc,', $xml, $blocs)){
269                                $infos_page['blocs'] = array();
270                                foreach (array_keys($bloc) as $bloc){
271                                        list($balise, $attributs) = spip_xml_decompose_tag($bloc);
272                                        $infos_page['blocs'][$attributs['id']] = array(
273                                                'nom' => $attributs['nom'] ? _T($attributs['nom']) : $attributs['id'],
274                                                'icon' => isset($attributs['icon']) ? find_in_path(reset($attributs['icon'])) : '',
275                                                'description' => $attributs['description']
276                                        );
277                                }
278                        }
279                }
280                // S'il n'y a pas de fichier XML de configuration
281                else {
282                        $infos_page['nom'] = $page;
283                        $infos_page['icon'] = find_in_path('img/ic_page.png');
284                }
285               
286                // Si les blocs n'ont pas été définis, on applique les blocs par défaut
287                if (!isset($infos_page['blocs']))
288                        $infos_page['blocs'] = noizetier_blocs_defaut();
289               
290                // On renvoie les infos
291                if (!$info)
292                        return $infos_page;
293                else 
294                        return isset($infos_page[$info]) ? $infos_page[$info] : "";
295}
296
297/**
298 * Charger les informations d'une page, contenues dans un xml de config s'il existe
299 * La liste des blocs par défaut d'une page peut être modifiée via le pipeline noizetier_blocs_defaut.
300 *
301 * @staticvar array $blocs_defaut
302 * @return array
303 */
304function noizetier_blocs_defaut(){
305        static $blocs_defaut = null;
306
307        if (is_null($blocs_defaut)){
308        $blocs_defaut = array (
309                'contenu' => array(
310                        'nom' => _T('noizetier:nom_bloc_contenu'),
311                        'description' => _T('noizetier:description_bloc_contenu'),
312                        'icon' => find_in_path('img/ic_bloc_contenu.png')
313                        ),
314                'navigation' => array(
315                        'nom' => _T('noizetier:nom_bloc_navigation'),
316                        'description' => _T('noizetier:description_bloc_navigation'),
317                        'icon' => find_in_path('img/ic_bloc_navigation.png')
318                        ),
319                'extra' => array(
320                        'nom' => _T('noizetier:nom_bloc_extra'),
321                        'description' => _T('noizetier:description_bloc_extra'),
322                        'icon' => find_in_path('img/ic_bloc_extra.png')
323                        ),
324        );
325        $blocs_defaut = pipeline('noizetier_blocs_defaut',$blocs_defaut);
326        }
327        return $blocs_defaut;
328}
329
330/**
331 * Supprime de spip_noisettes les noisettes liées à une page
332 *
333 * @param text $page
334 *
335 */
336function supprimer_noisettes_page_noizetier($page) {
337        $type_compo = explode ('-',$page,2);
338        $type = $type_compo[0];
339        $page = $type_compo[1];
340       
341        sql_delete('spip_noisettes','type='.sql_quote($type).'and composition='.sql_quote($composition));
342
343        // On invalide le cache
344        include_spip('inc/invalideur');
345        suivre_invalideur($page);
346}
347
348/**
349 * Renvoie le type d'une page
350 *
351 * @param text $page
352 * @return text
353 */
354function noizetier_page_type($page) {
355        $type_compo = explode ('-',$page,2);
356        return $type_compo[0];
357}
358
359/**
360 * Renvoie la composition d'une page
361 *
362 * @param text $page
363 * @return text
364 */
365function noizetier_page_composition($page) {
366        $type_compo = explode ('-',$page,2);
367        return $type_compo[1];
368}
369
370/**
371 * Liste les blocs pour lesquels il y a des noisettes à insérer.
372 *
373 * @staticvar array $liste_blocs
374 * @return array
375 */
376function noizetier_lister_blocs_avec_noisettes(){
377        static $liste_blocs = null;
378       
379        if (is_null($liste_blocs)){
380                $liste_blocs = array();
381                include_spip('base/abstract_sql');
382                $resultats = sql_allfetsel (
383                        "CONCAT(`bloc`,'/',`type`,'-',`composition`)",
384                        'spip_noisettes',
385                        '1',
386                        '`bloc`,`type`,`composition`'
387                );
388                foreach ($resultats as $res) {
389                        $res = array_values($res);
390                        if (substr($res[0],-1)=='-')
391                                $liste_blocs[] = substr($res[0],0,-1);
392                        else
393                                $liste_blocs[] = $res[0];
394                }
395        }
396       
397        return $liste_blocs;
398}
399
400/**
401 * Liste d'icônes obtenues en fouillant les répertoires img/ images/ image/ et /img-pack.
402 *
403 * @staticvar array $liste_icones
404 * @return array
405 */
406function noizetier_lister_icones(){
407        static $liste_icones = null;
408       
409        if (is_null($liste_icones)){
410                $match = ".+[.](jpg|jpeg|png|gif)$";
411                $liste_icones = array(
412                        'img' => find_all_in_path('img/', $match),
413                        'img-pack' => find_all_in_path('img-pack/', $match),
414                        'image' => find_all_in_path('image/', $match),
415                        'images' => find_all_in_path('images/', $match)
416                );
417        }
418       
419        return $liste_icones;
420}
421
422/**
423 * Liste des configurations du noizetier disponibles
424 * Fichiers YAML situés dans un sous-répertoire config_noizetier
425 *
426 * @staticvar array $liste_config
427 * @return array
428 */
429function noizetier_lister_config(){
430        static $liste_config = null;
431        include_spip('inc/yaml');
432       
433        if (is_null($liste_config)){
434                $liste_config = array();
435                $match = ".+[.]yaml$";
436                foreach (find_all_in_path('config_noizetier/', $match) as $fichier => $chemin) {
437                        // On lit le fichier, on vérifie les plugins demandé on vérifie s'il y a un champs nom
438                        $config = yaml_decode_file($chemin);
439                        $ok = true;
440                        if (isset($config['necessite']))
441                                foreach($config['necessite'] as $plugin)
442                                        if (!defined('_DIR_PLUGIN_'.strtoupper($plugin)))
443                                                $ok = false;
444                        //on vérifie s'il y a un champs nom
445                        if ($ok) {
446                                if (isset($config['nom']))
447                                        $liste_config[$chemin] = _T_ou_typo($config['nom']);
448                                else
449                                        $liste_config[$chemin] = $fichier;
450                        }
451                }
452        }
453        return $liste_config;
454}
455
456?>
Note: See TracBrowser for help on using the repository browser.