source: spip-zone/_plugins_/noizetier/trunk/noizetier_pipelines.php @ 113568

Last change on this file since 113568 was 113528, checked in by root, 5 months ago

On supprime un pipeline qui est devenu inutile aujourd'hui enfin pour l'instant, à voir plus tard.

File size: 15.1 KB
Line 
1<?php
2
3// Sécurité
4if (!defined('_ECRIRE_INC_VERSION')) {
5        return;
6}
7
8/**
9 * Pipeline recuperer_fond pour ajouter les noisettes.
10 *
11 * @param array $flux
12 *
13 * @return array
14 */
15function noizetier_recuperer_fond($flux) {
16
17        // Le noiZetier v3 est essentiellement dédié aux squelettes Z.
18        // De fait, il intercepte systématiquement tout appel à la fonction recuperer_fond() à partir du moment où celui-ci
19        // ne concerne pas le privé.
20        // Le fonctionnement du pipeline consiste à détecter si le squelette concerné par l'appel à recuperer_fond() est
21        // celui d'un bloc autorisé pour une page ou un objet donné.
22        if (!test_espace_prive()
23        and isset($flux['data']['contexte'])
24        and ($contexte = $flux['data']['contexte'])
25        and !isset($contexte['fond_compilation_noizetier'])) {
26                // On récupère le squelette en cours de traitement et on identifie si celui-ci est un bloc autorisé d'une
27                // page ou d'un objet.
28                // On exclut le squelette structure.html et les noisettes elles-mêmes.
29                include_spip('ncore_fonctions');
30                $squelette = isset($flux['args']['fond']) ? $flux['args']['fond'] : '';
31                $dossier_squelette = dirname($squelette);
32                if ($squelette
33                and ($squelette != 'body')
34                and ($squelette != 'structure')
35                and ($dossier_squelette != trim(type_noisette_localiser('noizetier'), '/'))
36                and ($dossier_squelette != trim(type_noisette_localiser('ncore'), '/'))) {
37                        // On détermine la page et le bloc à partir du squelette qui, en Z, est toujours de la forme bloc/page
38                        // ou bloc/type_objet.
39                        $extension = pathinfo($squelette,  PATHINFO_EXTENSION);
40                        $squelette = explode('/', $squelette);
41
42                        // Si le squelette n'est pas de la forme bloc/page alors on n'est pas en présence d'un bloc configurable
43                        // avec des noisettes.
44                        // On élimine aussi les js et css qui sont les seuls à avoir une extension.
45                        if ((count($squelette) == 2) and (!$extension)) {
46                                $bloc = $squelette[0];
47                                $page = $squelette[1];
48
49                                // On vérifie que le bloc fait bien partie de la liste des blocs configurables de la page.
50                                include_spip('inc/noizetier_page');
51                                $blocs = page_noizetier_lister_blocs($page);
52                                if (in_array($bloc, $blocs)) {
53                                        // Traitement des cas particuliers de certaines compositions
54                                        // TODO : cela sert à quoi ?
55                                        $composition = isset($flux['args']['contexte']['composition'])
56                                                ? $flux['args']['contexte']['composition']
57                                                : '';
58                                        // Si une composition est définie et si elle n'est pas déjà dans le fond, on l'ajoute au fond
59                                        // sauf s'il s'agit d'une page de type page (les squelettes page.html assurant la redirection)
60                                        if ($composition != '' and page_noizetier_extraire_composition($page) == '' and page_noizetier_extraire_type($page) != 'page') {
61                                                $page .= '-' . $composition;
62                                        }
63
64                                        // On détermine si on est en présence d'un objet ou d'une page (ou composition).
65                                        // Attention même s'il s'agit d'un objet, il n'y a pas forcément des noisettes propres à celui-ci,
66                                        // dans ce cas on se rabat sur les noisettes de la page.
67                                        // -- recherche en priorité d'une correspondance d'objet précis
68                                        // -- ajout de l'id_conteneur dans le contexte
69                                        include_spip('inc/noizetier_conteneur');
70                                        include_spip('inc/noizetier_objet');
71                                        if (
72                                                (isset($flux['args']['contexte']['type-page'])
73                                                and ($objet = $flux['args']['contexte']['type-page'])
74                                                and ($cle_objet = id_table_objet($objet))
75                                                and (isset($flux['args']['contexte'][$cle_objet]))
76                                                and ($id_objet = intval($flux['args']['contexte'][$cle_objet])))
77                                                and $compteurs_noisette = objet_noizetier_compter_noisettes($objet, $id_objet)
78                                        ) {
79                                                // C'est un objet.
80                                                $est_objet = true;
81                                                // -- identification de l'objet
82                                                $contexte['objet'] = $objet;
83                                                $contexte['id_objet'] = $id_objet;
84                                                // -- identification du conteneur
85                                                $contexte['id_conteneur'] = conteneur_noizetier_composer($contexte, $bloc);
86                                                // -- identification du bloc et des compteurs de noisettes de chaque bloc de l'objet.
87                                                $contexte['bloc'] = $bloc;
88                                        } else {
89                                                // C'est une page ou une composition.
90                                                $est_objet = false;
91                                                // -- identification du conteneur
92                                                $contexte['id_conteneur'] = conteneur_noizetier_composer($page, $bloc);
93                                                // -- identification du bloc et des compteurs de noisettes de chaque bloc de la page.
94                                                $contexte['bloc'] = $bloc;
95                                                $compteurs_noisette = page_noizetier_compter_noisettes($page);
96                                        }
97                                        $bloc_avec_noisettes = array_key_exists($bloc, $compteurs_noisette);
98
99                                        // Suivant le mode, affichage normal ou prévisualisation (voir=noisettes), on affiche ou pas les
100                                        // blocs vides.
101                                        $fond_compilation_bloc = '';
102                                        if (isset($flux['args']['contexte']['voir']) and ($flux['args']['contexte']['voir'] == 'noisettes')) {
103                                                // Mode de prévisualisation.
104                                                // -- Étant donné que la prévisualisation permet de configurer aussi les noisettes dans les blocs
105                                                //    de la page ou de l'objet affiché, on teste l'autorisation (identique à noizetier_page
106                                                //    du privé).
107                                                include_spip('inc/autoriser');
108                                                if (autoriser('configurer', 'noizetier')
109                                                and ($bloc_avec_noisettes
110                                                        or (!$bloc_avec_noisettes and !$est_objet)
111                                                        or (!$bloc_avec_noisettes and $est_objet and $compteurs_noisette))) {
112                                                        $fond_compilation_bloc = 'bloc_compiler_editer';
113                                                }
114                                        } elseif ($bloc_avec_noisettes) {
115                                                // Mode normal d'afichage
116                                                $fond_compilation_bloc = 'conteneur_compiler';
117                                        }
118
119                                        // Si le fond n'est pas vide c'est qu'il faut bien compiler soit une liste de noisettes
120                                        // soit un bloc vide et l'ajouter au flux.
121                                        if ($fond_compilation_bloc) {
122                                                // On passe un indicateur dans le contexte qui permet de sortir rapidement du pipeline
123                                                // lors des appels successifs liées à cette compilation.
124                                                $contexte['fond_compilation_noizetier'] = true;
125                                                $complements = recuperer_fond($fond_compilation_bloc, $contexte, array('raw' => true));
126
127                                                // S'il y a une indication d'insertion explicite
128                                                if (strpos($flux['data']['texte'], '<!--noisettes-->') !== false) {
129                                                        $flux['data']['texte'] = preg_replace(
130                                                                '%(<!--noisettes-->)%is',
131                                                                "${complements['texte']}\n" . '$1',
132                                                                $flux['data']['texte']
133                                                        );
134                                                }
135                                                else {
136                                                        $flux['data']['texte'] .= $complements['texte'];
137                                                }
138                                        }
139                                }
140                        }
141                }
142        }
143
144        return $flux;
145}
146
147/**
148 * Pipeline compositions_lister_disponibles pour ajouter les compositions du noizetier.
149 *
150 * @param array $flux
151 *
152 * @return array
153 */
154function noizetier_compositions_lister_disponibles($flux) {
155
156        // Initialisation des arguments du pipeline
157        $type = $flux['args']['type'];
158        $informer = $flux['args']['informer'];
159
160        // Récupération des compositions virtuelles du noiZetier afin de les injecter dans le pipeline
161        // étant donné qu'elles ne peuvent pas être détectées par Compositions car sans XML
162        // -- filtre sur l'indicateur est_virtuelle qui n'est à oui que pour les compositions
163        // -- filtre sur le type de contenu ou pas suivant l'appel
164        $select = array('page', 'type', 'composition', 'nom', 'description', 'icon', 'branche');
165        $where = array('est_virtuelle=' . sql_quote('oui'));
166        if ($type) {
167                $where[] = 'type=' . sql_quote($type);
168        }
169        $compositions_virtuelles = sql_allfetsel($select, 'spip_noizetier_pages', $where);
170
171        if ($compositions_virtuelles) {
172                // On réindexe le tableau entier par l'identifiant de la page
173                $compositions_virtuelles = array_column($compositions_virtuelles, null, 'page');
174
175                // On insère les compositions virtuelles selon le format imposé par le plugin Compositions
176                foreach ($compositions_virtuelles as $_identifiant => $_configuration) {
177                        if ($informer){
178                                $flux['data'][$_configuration['type']][$_configuration['composition']] = array(
179                                        'nom'                   => typo($_configuration['nom']),
180                                        'description'   => isset($_configuration['description']) ? typo($_configuration['description']) : '',
181                                        'icon'                  => chemin_image($_configuration['icon']),
182                                        'branche'               => unserialize($_configuration['branche']),
183                                        'class'                 => '',
184                                        'configuration' => '',
185                                        'image_exemple' => '',
186                                );
187                        } else {
188                                $flux['date'][$_configuration['type']][$_configuration['composition']] = 1;
189                        }
190                }
191        }
192
193        return $flux;
194}
195
196/**
197 * Pipeline styliser pour les compositions du noizetier de type page si celles-ci sont activées.
198 *
199 * @param array $flux
200 *
201 * @return array
202 */
203 // TODO : revoir l'utilité de ce code qui est mort à priori car on a toujours une page source pour une composition
204//function noizetier_styliser($flux) {
205//      if (defined('_NOIZETIER_COMPOSITIONS_TYPE_PAGE') and _NOIZETIER_COMPOSITIONS_TYPE_PAGE) {
206//              $squelette = $flux['data'];
207//              $fond = $flux['args']['fond'];
208//              $ext = $flux['args']['ext'];
209//
210//              // Si on n'a pas trouvé de squelette
211//              if (!$squelette) {
212//                      $noizetier_compositions = (isset($GLOBALS['meta']['noizetier_compositions'])) ? unserialize($GLOBALS['meta']['noizetier_compositions']) : array();
213//                      // On vérifie qu'on n'a pas demandé une composition du noizetier de type page et qu'on appele ?page=type
214//                      if (isset($noizetier_compositions['page'][$fond])) {
215//                              $flux['data'] = substr(find_in_path("page.$ext"), 0, -strlen(".$ext"));
216//                              $flux['args']['composition'] = $fond;
217//                      }
218//              }
219//      }
220//
221//      return $flux;
222//}
223
224/**
225 * Pipeline jqueryui_forcer pour demander au plugin l'insertion des scripts pour .sortable().
226 *
227 * @param array $plugins
228 *
229 * @return array
230 */
231function noizetier_jqueryui_forcer($plugins) {
232        $plugins[] = 'jquery.ui.core';
233        $plugins[] = 'jquery.ui.widget';
234        $plugins[] = 'jquery.ui.mouse';
235        $plugins[] = 'jquery.ui.sortable';
236        $plugins[] = 'jquery.ui.droppable';
237        $plugins[] = 'jquery.ui.draggable';
238        $plugins[] = 'jquery.ui.accordion';
239
240        return $plugins;
241}
242
243/**
244 * @param $flux
245 *
246 * @return mixed
247 */
248function noizetier_noizetier_blocs_defaut($flux) {
249        return $flux;
250}
251
252/**
253 * @param $flux
254 *
255 * @return mixed
256 */
257function noizetier_noizetier_config_export($flux) {
258        return $flux;
259}
260
261/**
262 * @param $flux
263 *
264 * @return mixed
265 */
266function noizetier_noizetier_config_import($flux) {
267        return $flux;
268}
269
270// les boutons d'administration : ajouter le mode voir=noisettes
271/**
272 * @param $flux
273 *
274 * @return mixed
275 */
276function noizetier_formulaire_admin($flux) {
277//      if (autoriser('configurer', 'noizetier')) {
278//              $bouton = recuperer_fond('prive/squelettes/inclure/inc-bouton_voir_noisettes');
279//              $flux['data'] = preg_replace('%(<!--extra-->)%is', $bouton.'$1', $flux['data']);
280//      }
281
282        return $flux;
283}
284
285
286/**
287 * Ajouter du contenu au centre de la page sur les pages privées
288 *
289 * Page d'adminisration des plugin : on supprime le cache des noisettes.
290 * C'est un peu grossier mais pas trouvé de pipeline pour agir à la mise à jour d'un plugin.
291 * Au moins, le cache est supprimé à chaque changement, mise à jour des plugins.
292 *
293 * Page d'un objet : inclure le squelette qui affiche un lien pour configurer les noisettes.
294 *
295 * @param $flux
296 * @return mixed
297 */
298function noizetier_affiche_milieu($flux) {
299
300        if (isset($flux['args']['exec'])) {
301                // Initialisation de la page du privé
302                $exec = $flux['args']['exec'];
303
304                if ($exec == 'admin_plugin') {
305                        // Administration des plugins
306                        // On recharge les pages du noiZetier dont la liste ou l'activité a pu changer. Inutile de forcer un
307                        // rechargement complet.
308                        include_spip('inc/noizetier_page');
309                        page_noizetier_charger();
310                        // On recharge les types de noisettes dont la liste ou l'activité a pu changer. Inutile de forcer un
311                        // rechargement complet.
312                        include_spip('inc/ncore_type_noisette');
313                        type_noisette_charger('noizetier');
314
315                        // Suppression des caches N-Core nécessaires à la compilation des noisettes
316                        include_spip('inc/ncore_cache');
317                        cache_supprimer('noizetier', _NCORE_NOMCACHE_TYPE_NOISETTE_CONTEXTE);
318                        cache_supprimer('noizetier', _NCORE_NOMCACHE_TYPE_NOISETTE_AJAX);
319                        cache_supprimer('noizetier', _NCORE_NOMCACHE_TYPE_NOISETTE_INCLUSION);
320
321                } elseif (
322                        ($objet_exec = trouver_objet_exec($exec))
323                        and !$objet_exec['edition']
324                        and include_spip('inc/autoriser')
325                        and autoriser('configurerpage', 'noizetier', 0, '', array('page' => $flux['args']['exec']))
326                ) {
327
328                        // Page d'un objet
329                        $cle_objet = $objet_exec['id_table_objet'];
330                        $objet     = $objet_exec['type'];
331                        $id_objet  = $flux['args'][$cle_objet];
332
333                        // Identifier la page et la composition
334                        $composition = '';
335                        if (test_plugin_actif('compositions')) {
336                                include_spip('inc/compositions');
337                                $composition = compositions_determiner($objet, $id_objet);
338                        };
339                        $page = $composition ? "$objet-$composition" : $objet;
340
341                        $contexte = array(
342                                'objet'       => $objet,
343                                'id_objet'    => $id_objet,
344                                'page'        => $page,
345                                'composition' => $composition,
346                        );
347                        if ($texte = recuperer_fond('prive/squelettes/inclure/inc-noisettes_objet', $contexte)) {
348                                if ($pos = strpos($flux['data'],'<!--affiche_milieu-->')) {
349                                        $flux['data'] = substr_replace($flux['data'], $texte, $pos, 0);
350                                } else {
351                                        $flux['data'] .= $texte;
352                                }
353                        }
354
355                }
356        }
357
358        return $flux;
359}
360
361
362
363/**
364 * Ajout de bulles de compagnon sur les pages de listing des pages et objets supportant des noisettes.
365 *
366 * @param array $flux
367 *              Données du pipeline
368 *
369 * @return array
370 *              Données du pipeline mises à jour
371**/
372function noizetier_compagnon_messages($flux) {
373
374        $exec = $flux['args']['exec'];
375        $pipeline = $flux['args']['pipeline'];
376        $aides = &$flux['data'];
377
378        switch ($pipeline) {
379                case 'affiche_milieu':
380                        switch ($exec) {
381                                case 'noizetier_pages':
382                                case 'noizetier_objets':
383                                        // Rappeler l'utilité du plugin Compositions si celui-ci n'est pas actif
384                                        if (!defined('_DIR_PLUGIN_COMPOSITIONS')) {
385                                                $aides[] = array(
386                                                        'id'      => 'composition',
387                                                        'titre'   => _T('noizetier:noizetier'),
388                                                        'texte'   => _T('noizetier:compositions_non_installe'),
389                                                        'statuts' => array('1comite', '0minirezo', 'webmestre')
390                                                );
391                                        }
392
393                                        // Rappeler l'utilité du plugin IEconfig si celui-ci n'est pas actif
394                                        if (!defined('_DIR_PLUGIN_IECONFIG')) {
395                                                $aides[] = array(
396                                                        'id'      => 'ieconfig',
397                                                        'titre'   => _T('noizetier:noizetier'),
398                                                        'texte'   => _T('noizetier:ieconfig_non_installe'),
399                                                        'statuts' => array('1comite', '0minirezo', 'webmestre')
400                                                );
401                                        }
402                                        break;
403                        }
404                        break;
405        }
406
407        return $flux;
408}
409
410
411/**
412 * @param $boucle
413 *
414 * @return mixed
415 */
416function noizetier_pre_boucle($boucle) {
417
418        if (!defined('_DIR_PLUGIN_COMPOSITIONS')) {
419                // Si le plugin Compositions n'est pas actif, il faut exclure les compositions de la boucle NOIZETIER_PAGES.
420                if ($boucle->type_requete == 'noizetier_pages'
421                and empty($boucle->modificateur['tout'])) {
422                        // Pour exclure les compositions il faut insérer le critère {composition=''} systématiquement.
423                        $boucle->where[] = array("'='", "'noizetier_pages.composition'", "'\"\"'");
424                }
425        }
426
427        return $boucle;
428}
429
430
431// Insertion des css du noiZetier pour l'édition avec le mode voir_noisettes.
432/**
433 * @param $flux
434 *
435 * @return string
436 */
437function noizetier_insert_head_css($flux) {
438        static $done = false;
439        if (!$done) {
440                $done = true;
441                if (_request('voir') == 'noisettes') {
442                        $flux .= '<link rel="stylesheet" href="' . find_in_path('css/noizetier.css') . '" type="text/css" media="all" />';
443                }
444        }
445
446        return $flux;
447}
448
449/**
450 * @param $flux
451 *
452 * @return string
453 */
454function noizetier_insert_head($flux) {
455        // au cas ou il n'est pas implemente
456        $flux .= noizetier_insert_head_css($flux);
457
458        return $flux;
459}
Note: See TracBrowser for help on using the repository browser.