source: spip-zone/_plugins_/noizetier/trunk/noizetier_fonctions.php @ 95531

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

Une bête de modif de plein de fichiers, mais qui normalement n'ajoute que peu de chose et sans rien changer à l'ancien.

On peut maintenant éditer les noisettes D'UN contenu PRÉCIS et uniquement lui.

Pour ça il faut aller configurer sur quels objets on accepte ça. Et ensuite sur le côté sous l'identifiant on a "Aucune noisette configurée" (ou "12 noisettes configurées" si on l'a déjà fait).

Ce qui amène à l'interface de composition de noisettes mais pour CET objet/id uniquement.

J'ai passé des heures à tout passer au peigne fin du comportement existant : à priori tout marche AUSSI pour toutes les modifs publiques avec voir=noisettes !

À tester !

File size: 30.9 KB
Line 
1<?php
2
3// Securite
4if (!defined('_ECRIRE_INC_VERSION')) {
5        return;
6}
7
8define('_CACHE_AJAX_NOISETTES', 'noisettes_ajax.php');
9define('_CACHE_CONTEXTE_NOISETTES', 'noisettes_contextes.php');
10define('_CACHE_DESCRIPTIONS_NOISETTES', 'noisettes_descriptions.php');
11define('_CACHE_INCLUSIONS_NOISETTES', 'noisettes_inclusions.php');
12
13/**
14 * Lister les noisettes disponibles dans les dossiers noisettes/.
15 *
16 * @staticvar array $liste_noisettes
17 *
18 * @param text $type     renvoyer seulement un type de noisettes
19 * @param text $noisette renvoyer spécifiquement une noisette données
20 *
21 * @return array
22 */
23function noizetier_lister_noisettes($type = 'tout') {
24        static $liste_noisettes = array();
25        if ($type == 'tout') {
26                return noizetier_obtenir_infos_noisettes();
27        }
28        if (isset($liste_noisettes[$type])) {
29                return $liste_noisettes[$type];
30        }
31
32        $noisettes = noizetier_obtenir_infos_noisettes();
33        if ($type == '') {
34                $match = '^[^-]*$';
35        } else {
36                $match = $type.'-[^-]*$';
37        }
38
39        foreach ($noisettes as $noisette => $description) {
40                if (preg_match("/$match/", $noisette)) {
41                        $liste_noisettes[$type][$noisette] = $description;
42                }
43        }
44
45        return isset($liste_noisettes[$type]) ? $liste_noisettes[$type]: '';
46}
47
48/**
49 * Renvoie les info d'une seule noisette.
50 *
51 * @param text $noisette renvoyer spécifiquement une noisette données
52 *
53 * @return array
54 */
55function noizetier_info_noisette($noisette) {
56        $noisettes = noizetier_obtenir_infos_noisettes();
57
58        return $noisettes[$noisette];
59}
60
61/**
62 * Obtenir les infos de toutes les noisettes disponibles dans les dossiers noisettes/
63 * On utilise un cache php pour alleger le calcul.
64 *
65 * @param
66 *
67 * @return
68 **/
69function noizetier_obtenir_infos_noisettes() {
70        static $noisettes = false;
71
72        // seulement 1 fois par appel, on lit ou calcule tous les contextes
73        if ($noisettes === false) {
74                // lire le cache des descriptions sauvees
75                lire_fichier_securise(_DIR_CACHE._CACHE_DESCRIPTIONS_NOISETTES, $noisettes);
76                $noisettes = @unserialize($noisettes);
77                // s'il en mode recalcul, on recalcule toutes les descriptions des noisettes trouvees.
78                // ou si le cache est desactive
79                if (!$noisettes or (_request('var_mode') == 'recalcul') or (defined('_NO_CACHE') and _NO_CACHE != 0)) {
80                        $noisettes = noizetier_obtenir_infos_noisettes_direct();
81                        ecrire_fichier_securise(_DIR_CACHE._CACHE_DESCRIPTIONS_NOISETTES, serialize($noisettes));
82                }
83        }
84
85        return $noisettes;
86}
87
88/**
89 * Obtenir les infos de toutes les noisettes disponibles dans les dossiers noisettes/
90 * C'est un GROS calcul lorsqu'il est a faire.
91 *
92 * @return array
93 */
94function noizetier_obtenir_infos_noisettes_direct() {
95        $liste_noisettes = array();
96
97        $match = '[^-]*[.]html$';
98        $liste = find_all_in_path('noisettes/', $match);
99
100        if (count($liste)) {
101                foreach ($liste as $squelette => $chemin) {
102                        $noisette = preg_replace(',[.]html$,i', '', $squelette);
103                        $dossier = str_replace($squelette, '', $chemin);
104                        // On ne garde que les squelettes ayant un fichier YAML de config
105                        if (file_exists("$dossier$noisette.yaml")
106                                and ($infos_noisette = noizetier_charger_infos_noisette_yaml($dossier.$noisette))
107                        ) {
108                                $liste_noisettes[$noisette] = $infos_noisette;
109                        }
110                }
111        }
112
113        // supprimer de la liste les noisettes necissant un plugin qui n'est pas actif
114        foreach ($liste_noisettes as $noisette => $infos_noisette) {
115                if (isset($infos_noisette['necessite'])) {
116                        foreach ($infos_noisette['necessite'] as $plugin) {
117                                if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
118                                        unset($liste_noisettes[$noisette]);
119                                }
120                        }
121                }
122        }
123
124        return $liste_noisettes;
125}
126
127/**
128 * Charger les informations contenues dans le YAML d'une noisette.
129 *
130 * @param string $noisette
131 * @param string $info
132 *
133 * @return array
134 */
135function noizetier_charger_infos_noisette_yaml($noisette, $info = '') {
136        include_spip('inc/yaml');
137        include_spip('inc/texte');
138       
139        // on peut appeler avec le nom du squelette
140        $fichier = preg_replace(',[.]html$,i', '', $noisette).'.yaml';
141       
142        $infos_noisette = array();
143        if ($infos_noisette = yaml_charger_inclusions(yaml_decode_file($fichier))) {
144                if (isset($infos_noisette['nom'])) {
145                        $infos_noisette['nom'] = _T_ou_typo($infos_noisette['nom']);
146                }
147                if (isset($infos_noisette['description'])) {
148                        $infos_noisette['description'] = _T_ou_typo($infos_noisette['description']);
149                }
150                if (isset($infos_noisette['icon'])) {
151                        $infos_noisette['icon'] = $infos_noisette['icon'];
152                }
153
154                if (!isset($infos_noisette['parametres'])) {
155                        $infos_noisette['parametres'] = array();
156                }
157
158                // contexte
159                if (!isset($infos_noisette['contexte'])) {
160                        $infos_noisette['contexte'] = array();
161                }
162               
163                if (is_string($infos_noisette['contexte'])) {
164                        $infos_noisette['contexte'] = array($infos_noisette['contexte']);
165                }
166
167                // ajax
168                if (!isset($infos_noisette['ajax'])) {
169                        $infos_noisette['ajax'] = 'oui';
170                }
171               
172                // inclusion
173                if (!isset($infos_noisette['inclusion'])) {
174                        $infos_noisette['inclusion'] = 'statique';
175                }
176        }
177
178        if (!$info) {
179                return $infos_noisette;
180        } else {
181                return isset($infos_noisette[$info]) ? $infos_noisette[$info] : '';
182        }
183}
184
185/**
186 * Charger les informations des contexte pour une noisette.
187 *
188 * @param string $noisette
189 * @staticvar array $params_noisettes
190 *
191 * @return array
192 */
193function noizetier_charger_contexte_noisette($noisette) {
194        static $contexte_noisettes = null;
195
196        if (is_null($contexte_noisettes[$noisette])) {
197                $noisettes = noizetier_lister_noisettes();
198                $contexte_noisettes[$noisette] = $noisettes[$noisette]['contexte'];
199        }
200
201        return $contexte_noisettes[$noisette];
202}
203
204/**
205 * Lister les pages pouvant recevoir des noisettes
206 * Par defaut, cette liste est basee sur le contenu du repertoire contenu/
207 * Le tableau de resultats peut-etre modifie via le pipeline noizetier_lister_pages.
208 *
209 * @param string $page_specifique (renvoyer les données d'une page spécifique)
210 * @staticvar array $liste_pages
211 *
212 * @return array
213 */
214function noizetier_lister_pages($page_specifique = '') {
215        static $liste_pages = null;
216
217        if (is_null($liste_pages)) {
218                $liste_pages = array();
219                $match = '.+[.]html$';
220
221                // Choisir le bon répertoire des pages
222                if (defined('_NOIZETIER_REPERTOIRE_PAGES')) {
223                        $rep = _NOIZETIER_REPERTOIRE_PAGES;
224                }
225                elseif (defined('_DIR_PLUGIN_ZCORE')) {
226                        $rep = 'content/';
227                }
228                else {
229                        $rep = 'contenu/';
230                }
231               
232                // Lister les fonds disponibles dans le repertoire contenu
233                $liste = find_all_in_path($rep, $match);
234                if (count($liste)) {
235                        foreach ($liste as $squelette => $chemin) {
236                                $page = preg_replace(',[.]html$,i', '', $squelette);
237                                $dossier = str_replace($squelette, '', $chemin);
238                                // Les elements situes dans prive/contenu sont ecartes
239                                if (substr($dossier, -14) != 'prive/contenu/') {
240                                        if (count($infos_page = noizetier_charger_infos_page($dossier, $page)) > 0) {
241                                                $liste_pages[$page] = $infos_page;
242                                        }
243                                }
244                        }
245                }
246
247                // Dans le cas de Zpip, il faut supprimer la page 'page.html' et la page 'z_apl.html'
248                if (defined('_DIR_PLUGIN_Z') or defined('_DIR_PLUGIN_ZCORE')) {
249                        unset($liste_pages['page']);
250                        unset($liste_pages['z_apl']);
251                }
252
253                // supprimer de la liste les pages necissant un plugin qui n'est pas actif
254                foreach ($liste_pages as $page => $infos_page) {
255                        if (isset($infos_page['necessite'])) {
256                                foreach ($infos_page['necessite'] as $plugin) {
257                                        if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
258                                                unset($liste_pages[$page]);
259                                        }
260                                }
261                        }
262                }
263
264                $liste_pages = pipeline('noizetier_lister_pages', $liste_pages);
265               
266                // On ajoute les compositions du noizetier
267                if (defined('_DIR_PLUGIN_COMPOSITIONS')) {
268                        $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
269                        // On doit transformer le tableau de [type][compo] en [type-compo]
270                        $liste_compos = array();
271                        if (is_array($noizetier_compositions)) {
272                                foreach ($noizetier_compositions as $type => $compos_type) {
273                                        foreach ($compos_type as $compo => $infos_compo) {
274                                                $infos_compo['nom'] = typo($infos_compo['nom']);
275                                                $infos_compo['description'] = propre($infos_compo['description']);
276                                                if ($infos_compo['icon'] == '') {
277                                                        $infos_compo['icon'] = (isset($liste_pages[$type]) && isset($liste_pages[$type]['icon']) && $liste_pages[$type]['icon'] != '') ? $liste_pages[$type]['icon'] : 'composition-24.png';
278                                                }
279                                                if (isset($liste_pages[$type])) {
280                                                        $infos_compo['blocs'] = $liste_pages[$type]['blocs'];
281                                                } else {
282                                                        $infos_compo['blocs'] = noizetier_blocs_defaut();
283                                                }
284                                                $liste_compos[$type.'-'.$compo] = $infos_compo;
285                                        }
286                                }
287                        }
288                        $liste_pages = $liste_pages + $liste_compos;
289                }
290        }
291        if ($page_specifique) {
292                return $liste_pages[$page_specifique];
293        } else {
294                return $liste_pages;
295        }
296}
297
298/**
299 * Charger les informations d'une page, contenues dans un xml de config s'il existe.
300 *
301 * @param string $dossier
302 * @param string $page
303 * @param string $info
304 *
305 * @return array
306 */
307function noizetier_charger_infos_page($dossier, $page, $info = '') {
308        // on peut appeler avec le nom du squelette
309        $page = preg_replace(',[.]html$,i', '', $page);
310       
311        // Choisir le bon répertoire des pages
312        if (defined('_NOIZETIER_REPERTOIRE_PAGES')) {
313                $rep = _NOIZETIER_REPERTOIRE_PAGES;
314        }
315        elseif (defined('_DIR_PLUGIN_ZCORE')) {
316                $rep = 'content/';
317        }
318        else {
319                $rep = 'contenu/';
320        }
321       
322        // On autorise le fait que le fichier xml ne soit pas dans le meme plugin que le fichier .html
323        // Au cas ou le fichier .html soit surcharge sans que le fichier .xml ne le soit
324        $fichier = find_in_path("$rep$page.xml");
325
326        include_spip('inc/xml');
327        include_spip('inc/texte');
328        $infos_page = array();
329       
330        // S'il existe un fichier xml de configuration (s'il s'agit d'une composition on utilise l'info de la composition)
331        if (file_exists($fichier) and $xml = spip_xml_load($fichier, false) and count($xml['page'])) {
332                $xml = reset($xml['page']);
333        } elseif (file_exists($fichier) and $xml = spip_xml_load($fichier, false) and count($xml['composition'])) {
334                $xml = reset($xml['composition']);
335        } else {
336                $xml = '';
337        }
338       
339        if ($xml != '') {
340                $infos_page['nom'] = _T_ou_typo(spip_xml_aplatit($xml['nom']));
341                $infos_page['description'] = isset($xml['description']) ? _T_ou_typo(spip_xml_aplatit($xml['description'])) : '';
342                $infos_page['icon'] = isset($xml['icon']) ? reset($xml['icon']) : 'page-24.png';
343                        // Decomposition des blocs
344                        if (spip_xml_match_nodes(',^bloc,', $xml, $blocs)) {
345                                $infos_page['blocs'] = array();
346                                foreach (array_keys($blocs) as $bloc) {
347                                        list($balise, $attributs) = spip_xml_decompose_tag($bloc);
348                                        $infos_page['blocs'][$attributs['id']] = array(
349                                                'nom' => $attributs['nom'] ? _T($attributs['nom']) : $attributs['id'],
350                                                'icon' => isset($attributs['icon']) ? $attributs['icon'] : '',
351                                                'description' => _T($attributs['description']),
352                                        );
353                                }
354                        }
355                if (spip_xml_match_nodes(',^necessite,', $xml, $necessites)) {
356                        $infos_page['necessite'] = array();
357                        foreach (array_keys($necessites) as $necessite) {
358                                list($balise, $attributs) = spip_xml_decompose_tag($necessite);
359                                $infos_page['necessite'][] = $attributs['id'];
360                        }
361                }
362        }
363                // S'il n'y a pas de fichier XML de configuration
364                elseif (defined('_NOIZETIER_LISTER_PAGES_SANS_XML') ? _NOIZETIER_LISTER_PAGES_SANS_XML : true) {
365                        $infos_page['nom'] = $page;
366                        $infos_page['icon'] = 'img/ic_page.png';
367                }
368
369                // Si les blocs n'ont pas ete definis, on applique les blocs par defaut
370                if (count($infos_page) > 0 and !isset($infos_page['blocs'])) {
371                        $infos_page['blocs'] = noizetier_blocs_defaut();
372                }
373
374                // On renvoie les infos
375                if (!$info) {
376                        return $infos_page;
377                } else {
378                        return isset($infos_page[$info]) ? $infos_page[$info] : '';
379                }
380}
381
382/**
383 * La liste des blocs par defaut d'une page peut etre modifiee via le pipeline noizetier_blocs_defaut.
384 *
385 * @staticvar array $blocs_defaut
386 *
387 * @return array
388 */
389function noizetier_blocs_defaut() {
390        static $blocs_defaut = null;
391
392        if (is_null($blocs_defaut)) {
393                if (defined('_DIR_PLUGIN_ZCORE') and isset($GLOBALS['z_blocs']) and is_array($GLOBALS['z_blocs'])) {
394                        $blocs_defaut = array();
395                       
396                        foreach ($GLOBALS['z_blocs'] as $z_bloc) {
397                                $blocs_defaut[$z_bloc] = array(
398                                        'nom' => ucfirst($z_bloc),
399                                );
400                        }
401                }
402                else {
403                        $blocs_defaut = array(
404                                'contenu' => array(
405                                        'nom' => _T('noizetier:nom_bloc_contenu'),
406                                        'description' => _T('noizetier:description_bloc_contenu'),
407                                        'icon' => 'bloc-contenu-24.png',
408                                        ),
409                                'navigation' => array(
410                                        'nom' => _T('noizetier:nom_bloc_navigation'),
411                                        'description' => _T('noizetier:description_bloc_navigation'),
412                                        'icon' => 'bloc-navigation-24.png',
413                                        ),
414                                'extra' => array(
415                                        'nom' => _T('noizetier:nom_bloc_extra'),
416                                        'description' => _T('noizetier:description_bloc_extra'),
417                                        'icon' => 'bloc-extra-24.png',
418                                        ),
419                        );
420                }
421               
422                $blocs_defaut = pipeline('noizetier_blocs_defaut', $blocs_defaut);
423        }
424
425        return $blocs_defaut;
426}
427
428/**
429 * Supprime de spip_noisettes les noisettes liees a une page.
430 *
431 * @param string|array $page
432 */
433function noizetier_supprimer_noisettes_page($page) {
434        $objet = '';
435        $id_objet = 0;
436        $type = '';
437        $composition = '';
438       
439        if (is_array($page)) {
440                $objet = $page['objet'];
441                $id_objet = $page['id_objet'];
442        }
443        else {
444                $type_compo = explode('-', $page, 2);
445                $type = $type_compo[0];
446               
447                if (isset($type_compo[1])) {
448                        $composition = $type_compo[1];
449                }
450        }
451       
452        if (autoriser('configurer', 'noizetier')) {
453                sql_delete(
454                        'spip_noisettes',
455                        'type = '.sql_quote($type)
456                        .' AND composition = '.sql_quote($composition)
457                        .' AND objet = '.sql_quote($objet)
458                        .' AND id_objet = '.intval($id_objet)
459                );
460               
461                // On invalide le cache
462                include_spip('inc/invalideur');
463                suivre_invalideur("id='page/$page'");
464        }
465}
466
467/**
468 * Supprime de spip_noisettes une noisette particuliere.
469 *
470 * @param text $id_noisette
471 */
472function noizetier_supprimer_noisette($id_noisette) {
473        if (autoriser('configurer', 'noizetier') and intval($id_noisette)) {
474                sql_delete('spip_noisettes', 'id_noisette='.intval($id_noisette));
475                // On invalide le cache
476                include_spip('inc/invalideur');
477                suivre_invalideur("id='noisette/$id_noisette'");
478        }
479}
480
481/**
482 * Ajoute une noisette à un bloc d'une page
483 *
484 * @param string $noisette
485 *              Nom de la noisette à ajouter
486 * @param string|array $page
487 *              Nom de la page-composition OU tableau contenant l'objet et l'id_objet
488 * @param string $bloc
489 *              Nom du bloc où ajouter la noisette
490 *
491 * @return int
492 *              Retourne l'identifiant de la nouvelle noisette
493 **/
494function noizetier_ajouter_noisette($noisette, $page, $bloc) {
495        $objet = '';
496        $id_objet = 0;
497        if (is_array($page)) {
498                $objet = $page['objet'];
499                $id_objet = $page['id_objet'];
500                $page = null;
501        }
502       
503        if (autoriser('configurer', 'noizetier') && $noisette) {
504                include_spip('inc/saisies');
505                $info_noisette = noizetier_info_noisette($noisette);
506                $parametres = saisies_lister_valeurs_defaut($info_noisette['parametres']);
507               
508                // On construit le where pour savoir quelles noisettes chercher
509                $where = array();
510                if ($page) {
511                        $where[] = 'type = '.sql_quote(noizetier_page_type($page));
512                        $where[] = 'composition = '.sql_quote(noizetier_page_composition($page));
513                }
514                else {
515                        $where[] = 'objet = '.sql_quote($objet);
516                        $where[] = 'id_objet = '.intval($id_objet);
517                }
518                $where[] = 'bloc = '.sql_quote($bloc);
519               
520                // On cherche le rang suivant
521                $rang = intval(sql_getfetsel(
522                        'rang',
523                        'spip_noisettes',
524                        $where,
525                        '',
526                        'rang DESC',
527                        '0,1'
528                )) + 1;
529               
530                $id_noisette = sql_insertq(
531                        'spip_noisettes',
532                        array(
533                                'type' => noizetier_page_type($page),
534                                'composition' => noizetier_page_composition($page),
535                                'objet' => $objet,
536                                'id_objet' => $id_objet,
537                                'bloc' => $bloc,
538                                'noisette' => $noisette,
539                                'rang' => $rang,
540                                'parametres' => serialize($parametres),
541                        )
542                );
543
544                if ($id_noisette) {
545                        // On invalide le cache
546                        include_spip('inc/invalideur');
547                        suivre_invalideur("id='noisette/$id_noisette'");
548
549                        return $id_noisette;
550                }
551        }
552       
553        return 0;
554}
555
556/**
557 * Tri les noisettes d'une page
558 * Attention : parfois la page est transmise dans $ordre (et peu éventuellement changer en cours, cas de la page-dist de Zpip-vide).
559 *
560 * @param text  $page
561 * @param array $ordre
562 *
563 * @return bool
564 */
565function noizetier_trier_noisette($page, $ordre) {
566        // Vérifications
567        if (
568                !autoriser('configurer', 'noizetier')
569                or !is_array($ordre)
570                or substr($ordre[0], 0, 4) != 'bloc'
571        ) {
572                return false;
573        }
574       
575        $objet = '';
576        $id_objet = 0;
577        if (is_array($page)) {
578                $objet = $page['objet'];
579                $id_objet = $page['id_objet'];
580                $type = '';
581                $composition = '';
582        }
583        elseif ($page) {
584                $type = noizetier_page_type($page);
585                $composition = noizetier_page_composition($page);
586        }
587       
588        $modifs = array();
589        foreach ($ordre as $entree) {
590                $entree = explode('-', $entree, 2);
591               
592                if ($entree[0] == 'bloc') {
593                        $bloc = $entree[1];
594                        $rang = 1;
595                }
596                if ($entree[0] == 'page') {
597                        $page = $entree[1];
598                        $type = noizetier_page_type($page);
599                        $composition = noizetier_page_composition($page);
600                }
601                if ($entree[0] == 'objet') {
602                        $objet = $entree[1];
603                }
604                if ($entree[0] == 'id_objet') {
605                        $id_objet = intval($entree[1]);
606                }
607                if ($entree[0] == 'noisette') {
608                        $modifs[$entree[1]] = array(
609                                'bloc' => $bloc,
610                                'type' => $type,
611                                'composition' => $composition,
612                                'objet' => $objet,
613                                'id_objet' => $id_objet,
614                                'rang' => $rang,
615                        );
616                        $rang += 1;
617                }
618                if ($entree[0] == 'ajouter') {
619                        $id_noisette = noizetier_ajouter_noisette($entree[1], $page, $bloc);
620                        $modifs[$id_noisette] = array(
621                                'bloc' => $bloc,
622                                'type' => $type,
623                                'composition' => $composition,
624                                'objet' => $objet,
625                                'id_objet' => $id_objet,
626                                'rang' => $rang,
627                        );
628                        $rang += 1;
629                }
630        }
631
632        foreach ($modifs as $id_noisette => $valeurs) {
633                sql_updateq('spip_noisettes', $valeurs, 'id_noisette='.intval($id_noisette));
634        }
635
636        return true;
637}
638
639/**
640 * Déplace une noisette au sein d'un bloc.
641 *
642 * @param text $id_noisette
643 * @param text $sens
644 */
645function noizetier_deplacer_noisette($id_noisette, $sens) {
646        $id_noisette = intval($id_noisette);
647        if ($sens != 'bas') {
648                $sens = 'haut';
649        }
650       
651        if (autoriser('configurer', 'noizetier') and $id_noisette) {
652                // On récupère des infos sur le placement actuel
653                $noisette = sql_fetsel(
654                        'bloc, type, composition, objet, id_objet, rang',
655                        'spip_noisettes',
656                        'id_noisette = '.$id_noisette
657                );
658                $bloc = $noisette['bloc'];
659                $type = $noisette['type'];
660                $composition = $noisette['composition'];
661                $objet = $noisette['objet'];
662                $id_objet = intval($noisette['id_objet']);
663                $rang_actuel = intval($noisette['rang']);
664
665                // On teste si y a une noisette suivante
666                $dernier_rang = intval(sql_getfetsel(
667                        'rang',
668                        'spip_noisettes',
669                        array(
670                                'bloc = '.sql_quote($bloc),
671                                'type = '.sql_quote($type),
672                                'composition = '.sql_quote($composition),
673                                'objet = '.sql_quote($objet),
674                                'id_objet = '.$id_objet,
675                        ),
676                        '',
677                        'rang desc',
678                        '0,1'
679                ));
680
681                // Tant qu'on ne veut pas faire de tour complet
682                if (!($sens == 'bas' and $rang_actuel == $dernier_rang) and !($sens == 'haut' and $rang_actuel == 1)) {
683                        // Alors on ne fait qu'échanger deux noisettes
684                        $rang_echange = ($sens == 'bas') ? ($rang_actuel + 1) : ($rang_actuel - 1);
685                        $ok = sql_updateq(
686                                'spip_noisettes',
687                                array(
688                                        'rang' => $rang_actuel,
689                                ),
690                                array(
691                                        'bloc = '.sql_quote($bloc),
692                                        'type = '.sql_quote($type),
693                                        'composition = '.sql_quote($composition),
694                                        'objet = '.sql_quote($objet),
695                                        'id_objet = '.$id_objet,
696                                        'rang = '.$rang_echange,
697                                )
698                        );
699                        if ($ok) {
700                                $ok = sql_updateq(
701                                        'spip_noisettes',
702                                        array(
703                                                'rang' => $rang_echange,
704                                        ),
705                                        'id_noisette = '.$id_noisette
706                                );
707                        }
708                }
709                // Sinon on fait un tour complet en déplaçant tout
710                else {
711                        if ($sens == 'bas') {
712                                // Tout le monde descend d'un rang
713                                $ok = sql_update(
714                                        'spip_noisettes',
715                                        array(
716                                                'rang' => 'rang + 1',
717                                        ),
718                                        array(
719                                                'bloc = '.sql_quote($bloc),
720                                                'type = '.sql_quote($type),
721                                                'composition = '.sql_quote($composition),
722                                                'objet = '.sql_quote($objet),
723                                                'id_objet = '.$id_objet,
724                                        )
725                                );
726                                // La noisette passe tout en haut
727                                if ($ok) {
728                                        $ok = sql_updateq(
729                                                'spip_noisettes',
730                                                array(
731                                                        'rang' => 1,
732                                                ),
733                                                'id_noisette = '.$id_noisette
734                                        );
735                                }
736                        } else {
737                                // Tout le monde monte d'un rang
738                                $ok = sql_update(
739                                        'spip_noisettes',
740                                        array(
741                                                'rang' => 'rang - 1',
742                                        ),
743                                        array(
744                                                'bloc = '.sql_quote($bloc),
745                                                'type = '.sql_quote($type),
746                                                'composition = '.sql_quote($composition),
747                                                'objet = '.sql_quote($objet),
748                                                'id_objet = '.$id_objet,
749                                        )
750                                );
751                                // La noisette passe tout en bas
752                                if ($ok) {
753                                        $ok = sql_updateq(
754                                                'spip_noisettes',
755                                                array(
756                                                        'rang' => $dernier_rang,
757                                                ),
758                                                'id_noisette = '.$id_noisette
759                                        );
760                                }
761                        }
762                }
763                // On invalide le cache
764                include_spip('inc/invalideur');
765                suivre_invalideur("id='noisette/$id_noisette'");
766        }
767}
768
769/**
770 * Supprime une composition du noizetier.
771 *
772 * @param text $page
773 *
774 * @return text
775 */
776function noizetier_supprimer_composition($page) {
777        $type_page = noizetier_page_type($page);
778        $composition = noizetier_page_composition($page);
779        $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
780        unset($noizetier_compositions[$type_page][$composition]);
781        if (count($noizetier_compositions[$type_page]) == 0) {
782                unset($noizetier_compositions[$type_page]);
783        }
784        ecrire_meta('noizetier_compositions', serialize($noizetier_compositions));
785}
786
787/**
788 * Renvoie le type d'une page.
789 *
790 * @param text $page
791 *
792 * @return text
793 */
794function noizetier_page_type($page) {
795        $type_compo = explode('-', $page, 2);
796
797        return $type_compo[0];
798}
799
800/**
801 * Renvoie la composition d'une page.
802 *
803 * @param text $page
804 *
805 * @return text
806 */
807function noizetier_page_composition($page) {
808        $type_compo = explode('-', $page, 2);
809        $type_compo = isset($type_compo[1]) ? $type_compo[1] : '';
810
811        return $type_compo;
812}
813
814/**
815 * Liste les blocs pour lesquels il y a des noisettes a inserer.
816 *
817 * @staticvar array $liste_blocs
818 *
819 * @return array
820 */
821function noizetier_lister_blocs_avec_noisettes() {
822        static $liste_blocs = null;
823
824        if (is_null($liste_blocs)) {
825                include_spip('base/abstract_sql');
826               
827                $liste_blocs = array();
828                $resultats = sql_allfetsel(
829                        array('bloc', 'type', 'composition'),
830                        'spip_noisettes',
831                        '1',
832                        array('bloc', 'type', 'composition')
833                );
834                foreach ($resultats as $res) {
835                        if ($res['composition']) {
836                                $liste_blocs[] = $res['bloc'].'/'.$res['type'].'-'.$res['composition'];
837                        } else {
838                                $liste_blocs[] = $res['bloc'].'/'.$res['type'];
839                        }
840                }
841        }
842
843        return $liste_blocs;
844}
845
846/**
847 * Liste les blocs pour lesquels il y a des noisettes a inserer POUR UN OBJET
848 *
849 * @staticvar array $liste_blocs
850 *
851 * @return array
852 */
853function noizetier_lister_blocs_avec_noisettes_objet($objet, $id_objet) {
854        static $liste_blocs = null;
855
856        if (is_null($liste_blocs[$objet][$id_objet])) {
857                include_spip('base/abstract_sql');
858               
859                $liste_blocs[$objet][$id_objet] = array();
860                $resultats = sql_allfetsel(
861                        array('bloc'),
862                        'spip_noisettes',
863                        array(
864                                'objet = '.sql_quote($objet),
865                                'id_objet = '.intval($id_objet),
866                        ),
867                        array('bloc')
868                );
869                foreach ($resultats as $res) {
870                        $liste_blocs[$objet][$id_objet][] = $res['bloc'].'/'.$objet;
871                }
872        }
873
874        return $liste_blocs[$objet][$id_objet];
875}
876
877/**
878 * Liste d'icones en 24px obtenues en fouillant le theme.
879 *
880 * @staticvar array $liste_icones
881 *
882 * @return array
883 */
884function noizetier_lister_icones() {
885        static $liste_icones = null;
886
887        if (is_null($liste_icones)) {
888                $match = '.+-24[.](jpg|jpeg|png|gif)$';
889                $liste_icones = find_all_in_path('prive/themes/spip/images/', $match);
890        }
891
892        return $liste_icones;
893}
894
895/**
896 * Teste si une page fait partie des compositions du noizetier.
897 *
898 * @param text $page
899 *
900 * @return text
901 */
902function noizetier_test_compo_noizetier($page) {
903        $compos = isset($GLOBALS['meta']['noizetier_compositions']) ? unserialize($GLOBALS['meta']['noizetier_compositions']) : array();
904        $type = noizetier_page_type($page);
905        $composition = noizetier_page_composition($page);
906
907        return (isset($compos[$type][$composition]) and is_array($compos[$type][$composition])) ? 'on' : '';
908}
909
910/**
911 * Retourne les elements du contexte uniquement
912 * utiles a la noisette demande.
913 *
914 * @param
915 *
916 * @return
917 **/
918function noizetier_choisir_contexte($noisette, $contexte_entrant, $id_noisette) {
919        $contexte_noisette = array_flip(noizetier_obtenir_contexte($noisette));
920
921        // On transmet toujours l'id_noisette et les variables se terminant par _$id_noisette (utilisees par exemple par Aveline pour la pagination)
922        $contexte_min = array('id_noisette' => $id_noisette);
923
924        if (isset($contexte_noisette['env'])) {
925                return array_merge($contexte_entrant, $contexte_min);
926        }
927
928        $l = -1 * (strlen($id_noisette) + 1);
929        foreach ($contexte_entrant as $variable => $valeur) {
930                if (substr($variable, $l) == '_'.$id_noisette) {
931                        $contexte_min[$variable] = $valeur;
932                }
933        }
934
935        if (isset($contexte_noisette['aucun'])) {
936                return $contexte_min;
937        }
938        if ($contexte_noisette) {
939                return array_merge(array_intersect_key($contexte_entrant, $contexte_noisette), $contexte_min);
940        }
941
942        return $contexte_entrant;
943}
944
945/**
946 * Retourne la liste des contextes donc peut avoir besoin une noisette.
947 *
948 * @param
949 *
950 * @return
951 **/
952function noizetier_obtenir_contexte($noisette) {
953        static $noisettes = false;
954
955        // seulement 1 fois par appel, on lit ou calcule tous les contextes
956        if ($noisettes === false) {
957                // lire le cache des contextes sauves
958                lire_fichier_securise(_DIR_CACHE._CACHE_CONTEXTE_NOISETTES, $noisettes);
959                $noisettes = @unserialize($noisettes);
960
961                // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
962                if (!$noisettes or (_request('var_mode') == 'recalcul')) {
963                        $infos = noizetier_lister_noisettes();
964                        $noisettes = array();
965                        foreach ($infos as $cle_noisette => $infos) {
966                                $noisettes[$cle_noisette] = ($infos['contexte'] ? $infos['contexte'] : array());
967                        }
968                        ecrire_fichier_securise(_DIR_CACHE._CACHE_CONTEXTE_NOISETTES, serialize($noisettes));
969                }
970        }
971
972        if (isset($noisettes[$noisette])) {
973                return $noisettes[$noisette];
974        }
975
976        return array();
977}
978
979/**
980 * Retourne true ou false pour indiquer si la noisette doit être inclue en ajax.
981 *
982 * @param
983 *
984 * @return
985 **/
986function noizetier_ajaxifier_noisette($noisette) {
987        static $noisettes = false;
988
989        // seulement 1 fois par appel, on lit ou calcule tous les contextes
990        if ($noisettes === false) {
991                // lire le cache des contextes sauves
992                lire_fichier_securise(_DIR_CACHE._CACHE_AJAX_NOISETTES, $noisettes);
993                $noisettes = @unserialize($noisettes);
994
995                // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
996                if (!$noisettes or (_request('var_mode') == 'recalcul')) {
997                        $infos = noizetier_lister_noisettes();
998                        $noisettes = array();
999                        foreach ($infos as $cle_noisette => $infos) {
1000                                $noisettes[$cle_noisette] = ($infos['ajax'] == 'non') ? false : true;
1001                        }
1002                        ecrire_fichier_securise(_DIR_CACHE._CACHE_AJAX_NOISETTES, serialize($noisettes));
1003                }
1004        }
1005
1006        if (isset($noisettes[$noisette])) {
1007                return $noisettes[$noisette];
1008        }
1009
1010        return true;
1011}
1012
1013/**
1014 * Retourne true ou false pour indiquer si la noisette doit être inclue dynamiquement.
1015 *
1016 * @param
1017 *
1018 * @return
1019 **/
1020function noizetier_inclusion_dynamique($noisette) {
1021        static $noisettes = false;
1022
1023        // seulement 1 fois par appel, on lit ou calcule tous les contextes
1024        if ($noisettes === false) {
1025                // lire le cache des contextes sauves
1026                lire_fichier_securise(_DIR_CACHE._CACHE_INCLUSIONS_NOISETTES, $noisettes);
1027                $noisettes = @unserialize($noisettes);
1028
1029                // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
1030                if (!$noisettes or (_request('var_mode') == 'recalcul')) {
1031                        $infos = noizetier_lister_noisettes();
1032                        $noisettes = array();
1033                        foreach ($infos as $cle_noisette => $infos) {
1034                                $noisettes[$cle_noisette] = ($infos['inclusion'] == 'dynamique') ? true : false;
1035                        }
1036                        ecrire_fichier_securise(_DIR_CACHE._CACHE_INCLUSIONS_NOISETTES, serialize($noisettes));
1037                }
1038        }
1039
1040        if (isset($noisettes[$noisette])) {
1041                return $noisettes[$noisette];
1042        }
1043
1044        return false;
1045}
1046
1047/**
1048 * Retourne le tableau des noisettes et des compositions du noizetier pour les exports.
1049 *
1050 * @return
1051 **/
1052function noizetier_tableau_export() {
1053        $data = array();
1054
1055        // On calcule le tableau des noisettes
1056        $data['noisettes'] = sql_allfetsel(
1057                'type, composition, bloc, noisette, parametres, css',
1058                'spip_noisettes',
1059                '1',
1060                '',
1061                'type, composition, bloc, rang'
1062        );
1063
1064        // On remet au propre les parametres
1065        foreach ($data['noisettes'] as $cle => $noisette) {
1066                $data['noisettes'][$cle]['parametres'] = unserialize($noisette['parametres']);
1067        }
1068
1069        // On recupere les compositions du noizetier
1070        $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
1071        if (is_array($noizetier_compositions) and count($noizetier_compositions) > 0) {
1072                $data['noizetier_compositions'] = $noizetier_compositions;
1073        }
1074
1075        $data = pipeline('noizetier_config_export', $data);
1076
1077        return $data;
1078}
1079
1080/**
1081 * Importe une configuration de noisettes et de compositions.
1082 *
1083 * @param text  $type_import
1084 * @param text  $import_compos
1085 * @param array $config
1086 *
1087 * @return bool
1088 */
1089function noizetier_importer_configuration($type_import, $import_compos, $config) {
1090        if ($type_import != 'remplacer') {
1091                $type_import = 'fusion';
1092        }
1093        if ($import_compos != 'oui') {
1094                $import_compos = 'non';
1095        }
1096
1097        $config = pipeline('noizetier_config_import', $config);
1098
1099        // On s'occupe deja des noisettes
1100        $noisettes = $config['noisettes'];
1101        include_spip('base/abstract_sql');
1102        if (is_array($noisettes) and count($noisettes) > 0) {
1103                $noisettes_insert = array();
1104                $rang = 1;
1105                $page = '';
1106               
1107                if ($type_import == 'remplacer') {
1108                        sql_delete('spip_noisettes', '1');
1109                }
1110               
1111                foreach ($noisettes as $noisette) {
1112                        $type = $noisette['type'];
1113                        $composition = $noisette['composition'];
1114                        if ($type.'-'.$composition != $page) {
1115                                $page = $type.'-'.$composition;
1116                                $rang = 1;
1117                                if ($type_import == 'fusion') {
1118                                        $rang = sql_getfetsel('rang', 'spip_noisettes', 'type='.sql_quote($type).' AND composition='.sql_quote($composition), '', 'rang DESC') + 1;
1119                                }
1120                        } else {
1121                                $rang = $rang + 1;
1122                        }
1123                        $noisette['rang'] = $rang;
1124                        $noisette['parametres'] = serialize($noisette['parametres']);
1125                        $noisettes_insert[] = $noisette;
1126                }
1127               
1128                $ok = sql_insertq_multi('spip_noisettes', $noisettes_insert);
1129        }
1130
1131        // On s'occupe des compositions du noizetier
1132        if ($import_compos == 'oui') {
1133                include_spip('inc/meta');
1134                $compos_importees = $config['noizetier_compositions'];
1135                if (is_array($compos_importees) and count($compos_importees) > 0) {
1136                        if ($type_import == 'remplacer') {
1137                                effacer_meta('noizetier_compositions');
1138                        } else {
1139                                $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
1140                        }
1141
1142                        if (!is_array($noizetier_compositions)) {
1143                                $noizetier_compositions = array();
1144                        }
1145
1146                        foreach ($compos_importees as $type => $compos_type) {
1147                                foreach ($compos_type as $composition => $info_compo) {
1148                                        $noizetier_compositions[$type][$composition] = $info_compo;
1149                                }
1150                        }
1151
1152                        ecrire_meta('noizetier_compositions', serialize($noizetier_compositions));
1153                        ecrire_metas();
1154                }
1155        }
1156
1157        // On invalide le cache
1158        include_spip('inc/invalideur');
1159        suivre_invalideur('noizetier-import-config');
1160
1161        return $ok;
1162}
1163
1164/**
1165 * Retourne le chemin complet d'une icone, vérifie d'abord chemin_image, sinon passe par find_in_path.
1166 *
1167 * @param text $icone
1168 *
1169 * @return text
1170 */
1171function noizetier_chemin_icone($icone){
1172        if ($i = chemin_image($icone)) {
1173                return $i;
1174        } else {
1175                return find_in_path($icone);
1176        }
1177}
Note: See TracBrowser for help on using the repository browser.