source: spip-zone/_plugins_/noizetier/trunk/inc/noizetier_page.php @ 113625

Last change on this file since 113625 was 113625, checked in by eric@…, 4 months ago

Par cohérence avec les autres API on rajoute l'argument $information en deuxème position de page_noizetier_lire() et par conséquence on revoit les appels (l'argument $traiter_typo est mis à false par défaut).
Et en plus on corrige la balise #PAGE_NOIZETIER_INFOS qui ne fonctionnait pas pour une demande d'information unique car justement l'API précédente ne le permettait pas !

  • Property svn:eol-style set to native
File size: 23.7 KB
Line 
1<?php
2/**
3 * Ce fichier contient l'API de gestion des pages et compositions configurables par le noiZetier.
4 *
5 * @package SPIP\NOIZETIER\PAGE\API
6 */
7if (!defined('_ECRIRE_INC_VERSION')) {
8        return;
9}
10
11
12/**
13 *
14 * @api
15 *
16 * @param bool $recharger
17 *
18 * @return bool
19 */
20function page_noizetier_charger($recharger = false) {
21
22        // Retour de la fonction
23        $retour = false;
24
25        // Initialiser les blocs par défaut
26        include_spip('inc/noizetier_bloc');
27        $options['blocs_defaut'] = bloc_z_lister_defaut();
28
29        // Choisir le bon répertoire des pages
30        $options['repertoire_pages'] = page_noizetier_initialiser_dossier();
31
32        // Initialiser le contexte de rechargement
33        $forcer_chargement = $recharger;
34
35        // Initialiser la table et le where des pages non virtuelles qui sont utilisés plusieurs fois.
36        $from ='spip_noizetier_pages';
37        $where = array('est_virtuelle=' . sql_quote('non'));
38
39        // On recherche les pages et les compositions explicites par le fichier HTML en premier
40        // Si on le trouve, on récupère la configuration du fichier XML ou YAML.
41        if ($fichiers = find_all_in_path($options['repertoire_pages'], '.+[.]html$')) {
42                $pages_nouvelles = $pages_modifiees = $pages_obsoletes = array();
43                // Récupération pour les divers traitements qui suivent:
44                // - des signatures md5 des pages déjà enregistrées pour déterminer si les fichiers YAML/XML
45                //   ont subi des changements.
46                // - des blocs exclus qui sont éditables après chargement, il faut donc conserver les modifications éventuelles.
47                // - des plugins nécessités et des indicateurs d'activité (voir fin de traitement).
48                $trouver_table = charger_fonction('trouver_table', 'base');
49                $table = $trouver_table($from);
50                $select = array_diff(array_keys($table['field']), array('maj'));
51                $signatures = array();
52                if ($pages_existantes = sql_allfetsel($select, $from, $where)) {
53                        // On construit le tableau des pages déjà enregistrée en base indexé par identifiant de page.
54                        $pages_existantes = array_column($pages_existantes, null, 'page');
55
56                        // Si on force le rechargement il est inutile de gérer les signatures, les indicateurs d'activité
57                        // et les pages modifiées ou obsolètes.
58                        if (!$forcer_chargement) {
59                                $signatures = array_column($pages_existantes, 'signature', 'page');
60                                // On initialise la liste des pages à supprimer avec l'ensemble des pages non virtuelles
61                                $pages_obsoletes = $signatures ? array_keys($signatures) : array();
62                        }
63                }
64
65                foreach ($fichiers as $_squelette => $_chemin) {
66                        $page = basename($_squelette, '.html');
67                        $dossier = dirname($_chemin);
68                        $est_composition = (page_noizetier_extraire_composition($page) != '');
69                        // Exclure certaines pages :
70                        // -- celles du privé situes dans prive/contenu
71                        // -- page liée au plugin Zpip en v1
72                        // -- z_apl liée aux plugins Zpip v1 et Zcore
73                        // -- les compositions explicites si le plugin Compositions n'est pas activé
74                        if ((substr($dossier, -13) != 'prive/contenu')
75                        and (($page != 'page') or !defined('_DIR_PLUGIN_Z'))
76                        and (($page != 'z_apl') or (!defined('_DIR_PLUGIN_Z') and !defined('_DIR_PLUGIN_ZCORE')))
77                        and (!$est_composition or ($est_composition     and defined('_DIR_PLUGIN_COMPOSITIONS')))) {
78                                // On passe le md5 de la page si il existe sinon la chaîne vide. Cela permet de déterminer
79                                // si on doit ajouter la page ou la mettre à jour.
80                                // Si le md5 est le même et qu'il n'est donc pas utile de recharger la page, la configuration
81                                // retournée est vide.
82                                $options['md5'] = isset($signatures[$page]) ? $signatures[$page] : '';
83                                $options['recharger'] = $forcer_chargement;
84                                if ($configuration = phraser_fichier_descriptif_page($page, $options)) {
85                                        if (empty($configuration['identique'])) {
86                                                // On met à jour les blocs exclus avec la sauvegarde effectuée au préalable (si la page
87                                                // existait déjà en base).
88                                                if (isset($pages_existantes[$page])) {
89                                                        $configuration['blocs_exclus'] = $pages_existantes[$page]['blocs_exclus'];
90                                                }
91                                                // On détermine si la page est nouvelle ou modifiée.
92                                                // En mode rechargement forcé toute page est considérée comme nouvelle.
93                                                if (!$options['md5'] or $forcer_chargement) {
94                                                        // La page est soit nouvelle soit on est en mode rechargement forcé:
95                                                        // => il faut la rajouter dans la table.
96                                                        $pages_nouvelles[] = $configuration;
97                                                } else {
98                                                        // La configuration stockée dans la table a été modifiée et pas de forçage du rechargement:
99                                                        // => il faut mettre à jour la page dans la table.
100                                                        $pages_modifiees[] = $configuration;
101                                                        // => il faut donc la supprimer de la liste des pages obsolètes
102                                                        $pages_obsoletes = array_diff($pages_obsoletes, array($page));
103                                                }
104                                        } else {
105                                                // La page n'a pas changée et n'a donc pas été réchargée:
106                                                // => Il faut donc juste indiquer qu'elle n'est pas obsolète.
107                                                $pages_obsoletes = array_diff($pages_obsoletes, array($page));
108                                        }
109                                } else {
110                                        // Il y a eu une erreur sur lors du rechargement de la page.
111                                        // Ce peut être en particulier le cas où une page HTML sans XML n'est plus détectée car le
112                                        // paramètre _NOIZETIER_LISTER_PAGES_SANS_XML a été positionné de true à false.
113                                        // => il faut donc ne rien faire pour laisser la page dans les obsolètes
114                                        continue;
115                                }
116                        }
117                }
118
119                // On complète la liste des pages à changer avec les pages dont l'indicateur d'activité est modifié suite
120                // à l'activation ou à la désactivation d'un plugin (le fichier XML/YAML lui n'a pas changé). Il est inutile de
121                // le faire si on recharge tout.
122                // -- on cherche ces pages en excluant les pages obsolètes et celles à changer qui ont déjà recalculé
123                //    l'indicateur lors de la lecture du fichier XML/YAML.
124                if (!$forcer_chargement) {
125                        $pages_exclues = $pages_modifiees
126                                ? array_merge(array_column($pages_modifiees, 'page'), $pages_obsoletes)
127                                : $pages_obsoletes;
128                        $pages_a_verifier = $pages_exclues
129                                ? array_diff_key($pages_existantes, array_flip($pages_exclues))
130                                : $pages_existantes;
131
132                        if ($pages_a_verifier) {
133                                foreach ($pages_a_verifier as $_page => $_description) {
134                                        $est_active = 'oui';
135                                        $plugins_necessites = unserialize($_description['necessite']);
136                                        if ($plugins_necessites) {
137                                                foreach ($plugins_necessites as $_plugin_necessite) {
138                                                        if (!defined('_DIR_PLUGIN_' . strtoupper($_plugin_necessite))) {
139                                                                $est_active = 'non';
140                                                                break;
141                                                        }
142                                                }
143                                        }
144                                        if ($est_active != $_description['est_active']) {
145                                                // On stocke la mise à jour dans les types à changer.
146                                                $_description['est_active'] = $est_active;
147                                                $pages_modifiees[] = $_description;
148                                        }
149
150                                }
151                        }
152                }
153
154                // Mise à jour de la table des pages
155                // -- Suppression des pages obsolètes ou de toute les pages non virtuelles si on est en mode
156                //    rechargement forcé.
157                if (sql_preferer_transaction()) {
158                        sql_demarrer_transaction();
159                }
160                if ($pages_obsoletes) {
161                        sql_delete($from, sql_in('page', $pages_obsoletes));
162                } elseif ($forcer_chargement) {
163                        sql_delete($from, $where);
164                }
165                // -- Update des pages modifiées
166                if ($pages_modifiees) {
167                        sql_replace_multi($from, $pages_modifiees);
168                }
169                // -- Insertion des nouvelles pages
170                if ($pages_nouvelles) {
171                        sql_insertq_multi($from, $pages_nouvelles);
172                }
173                if (sql_preferer_transaction()) {
174                        sql_terminer_transaction();
175                }
176
177                $retour = true;
178        }
179
180        return $retour;
181}
182
183/**
184 * Retourne la description complète de la page, de la composition explicite ou de la composition virtuelle demandée ou
185 * une information donnée uniquement.
186 * La description est stockée en base de données, certains champs sont recalculés avant d'être fournis.
187 *
188 * @api
189 *
190 * @uses page_noizetier_lister_blocs()
191 *
192 * @param string        $page
193 *              Identifiant de la page ou de la composition.
194 * @param string  $information
195 *        Information spécifique à retourner ou vide pour retourner toute la description.
196 * @param boolean       $traiter_typo
197 *      Indique si les données textuelles doivent être retournées brutes ou si elles doivent être traitées
198 *      en utilisant la fonction typo.
199 *              Les champs sérialisés sont toujours désérialisés.
200 *
201 * @return array|string
202 *        La description complète ou un champ précis demandé pour une page donnée. Les champs
203 *        de type tableau sont systématiquement désérialisés et si demandé, les champs textuels peuvent être
204 *        traités avec la fonction typo().
205 */
206function page_noizetier_lire($page, $information = '', $traiter_typo = false) {
207
208        static $description_page = array();
209
210        if (!isset($description_page[$traiter_typo][$page])) {
211                // Chargement de toute la configuration de la page en base de données.
212                $description = sql_fetsel('*', 'spip_noizetier_pages', array('page=' . sql_quote($page)));
213
214                // Sauvegarde de la description de la page pour une consultation ultérieure dans le même hit.
215                if ($description) {
216                        // Traitements des champs textuels
217                        if ($traiter_typo) {
218                                $description['nom'] = typo($description['nom']);
219                                if ($description['description']) {
220                                        $description['description'] = typo($description['description']);
221                                }
222                        }
223
224                        // Traitements des champs tableaux sérialisés
225                        $description['blocs_exclus'] = unserialize($description['blocs_exclus']);
226                        $description['necessite'] = unserialize($description['necessite']);
227                        $description['branche'] = unserialize($description['branche']);
228
229                        // Calcul des blocs
230                        $description['blocs'] = page_noizetier_lister_blocs($page, $description['blocs_exclus']);
231
232                        // Stockage de la description
233                        $description_page[$traiter_typo][$page] = $description;
234                } else {
235                        // En cas d'erreur stocker une description vide
236                        $description_page[$traiter_typo][$page] = array();
237                }
238        }
239
240        if ($information) {
241                if (isset($description_page[$traiter_typo][$page][$information])) {
242                        $page_lue = $description_page[$traiter_typo][$page][$information];
243                } else {
244                        $page_lue = '';
245                }
246        } else {
247                $page_lue = $description_page[$traiter_typo][$page];
248        }
249
250        return $page_lue;
251}
252
253/**
254 * Retourne la description complète ou partielle d'une liste de pages explicites, compositions explicite et
255 * compositions virtuelles filtrées sur une liste de critères.
256 *
257 * @api
258 *
259 * @param string  $information
260 *        Information spécifique à retourner ou vide pour retourner toute la description. L'information peut être une
261 *        chaine correspondant à un champ de la page ou un tableau avec une liste de champs.
262 * @param array   $filtres
263 *        Tableau associatif `[champ] = valeur` de critères de filtres sur les descriptions de types de noisette.
264 *        Le seul opérateur possible est l'égalité.
265 * @param boolean $indexer_par_page
266 *      Indique si le tableau doit être indexé par d'identifiant de page ou pas. `true` par défaut.
267 *
268 * @return array
269 *        Tableau des descriptions des pages et compositions trouvées indexé par l'identifiant de la page ou par
270 *        entier de 0 à n.
271 */
272function page_noizetier_repertorier($information = array(), $filtres = array(), $indexer_par_page = true) {
273
274        // Initialiser la sortie.
275        $pages = array();
276
277        // On initialise la liste des champs de la table des pages
278        $trouver_table = charger_fonction('trouver_table', 'base');
279        $table = $trouver_table('spip_noizetier_pages');
280
281        // On vérifie les champs à retourner et on calcule le contenu du select.
282        $champs = array_diff(array_keys($table['field']), array('maj'));
283        $information_valide = true;
284        $information_unique = false;
285        if (!$information) {
286                $select = $champs;
287        } else {
288                if (is_string($information)) {
289                        $select = array($information);
290                        $information_unique = true;
291                } else {
292                        $select = $information;
293                }
294
295                // On vérifie que les champs sont bien valides.
296                foreach ($select as $_champ) {
297                        if (!in_array($_champ, $champs)) {
298                                $information_valide = false;
299                                break;
300                        }
301                }
302
303                // On ajoute toujours l'identifiant page car il sert à l'indexation du tableau de sortie.
304                if ($indexer_par_page
305                and $information_valide
306                and !in_array('page', $select)) {
307                        $select[] = 'page';
308                }
309        }
310
311        if ($information_valide) {
312                // On calcule le where à partir des filtres sachant que tous les champs sont des chaines.
313                $where = array();
314                if ($filtres) {
315                        foreach ($filtres as $_champ => $_critere) {
316                                $operateur = '=';
317                                $valeur = $_critere;
318                                if (substr($_critere, 0, 1) == '!') {
319                                        $operateur = '!=';
320                                        $valeur = ltrim($_critere, '!');
321                                }
322                                $where[] = $_champ . $operateur . sql_quote($valeur);
323                        }
324                }
325
326                // Chargement des pages et compositions.
327                $pages = sql_allfetsel($select, 'spip_noizetier_pages', $where);
328
329                // On renvoie l'information demandée indexée par page si demandé ainsi.
330                if ($indexer_par_page) {
331                        if ($information_unique) {
332                                $pages = array_column($pages, $information, 'page');
333                        } else {
334                                $pages = array_column($pages, null, 'page');
335                                if ($information and !in_array('page', $information)) {
336                                        // On supprime le champ 'page' qui n'a pas été demandé
337                                        foreach ($pages as $_id_page => $_page) {
338                                                unset($pages[$_id_page]['page']);
339                                        }
340                                }
341                        }
342                }
343        }
344
345        return $pages;
346}
347
348
349/**
350 *
351 * @api
352 *
353 * @param       $page
354 * @param array $blocs_exclus
355 *
356 * @return array
357 */
358function page_noizetier_lister_blocs($page, $blocs_exclus = array()) {
359
360        // Initialisation des blocs avec la liste des blocs par défaut
361        include_spip('inc/noizetier_bloc');
362        $blocs = bloc_z_lister_defaut();
363
364        // Si la liste des blocs exclus n'a pas été passé en argument on les cherche dans la configuration
365        // de la page
366        if (!$blocs_exclus) {
367                include_spip('base/abstract_sql');
368                $where = array('page=' . sql_quote($page));
369                $blocs_exclus = sql_getfetsel('blocs_exclus', 'spip_noizetier_pages', $where);
370                $blocs_exclus = unserialize($blocs_exclus);
371        }
372
373        if ($blocs_exclus) {
374                $blocs = array_diff($blocs, $blocs_exclus);
375                sort($blocs);
376        }
377
378        return $blocs;
379}
380
381
382/**
383 * Renvoie le type d'une page à partir de son identifiant.
384 *
385 * @api
386 *
387 * @param string $page
388 *              L'identifiant de la page.
389 *
390 * @return string
391 *              Le type de la page choisie, c'est-à-dire:
392 *              - soit l'identifiant complet de la page,
393 *              - soit le mot précédent le tiret dans le cas d'une composition.
394 */
395function page_noizetier_extraire_type($page) {
396
397        $type = explode('-', $page, 2);
398        $type = $type[0];
399
400        return $type;
401}
402
403/**
404 * Détermine, à partir de son identifiant, la composition d'une page si elle existe.
405 *
406 * @api
407 *
408 * @param string $page
409 *              L'identifiant de la page.
410 *
411 * @return string
412 *      La composition de la page choisie, à savoir, le mot suivant le tiret,
413 *              ou la chaine vide sinon.
414 */
415function page_noizetier_extraire_composition($page) {
416
417        $composition = explode('-', $page, 2);
418        $composition = isset($composition[1]) ? $composition[1] : '';
419
420        return $composition;
421}
422
423/**
424 * Détermine si les compositions sont possibles sur un type de page.
425 *
426 * @api
427 *
428 * @param string $type
429 *              Identifiant du type de page.
430 *
431 * @return boolean
432 *              True si les compositions sont autorisées, false sinon.
433 */
434function page_noizetier_composition_activee($type) {
435
436        $est_activee = false;
437
438        if (defined('_DIR_PLUGIN_COMPOSITIONS')) {
439                include_spip('compositions_fonctions');
440                if (in_array($type, compositions_objets_actives())) {
441                        $est_activee = true;
442                }
443        }
444
445        return $est_activee;
446}
447
448/**
449 * Déterminer le répertoire dans lequel le NoiZetier peut lister les pages pouvant supporter
450 * l'insertion de noisettes.
451 *
452 * @api
453 *
454 * @return string
455 *              Le répertoire des pages sous la forme dossier/.
456 */
457function page_noizetier_initialiser_dossier() {
458
459        if (defined('_NOIZETIER_REPERTOIRE_PAGES')) {
460                $repertoire_pages = _NOIZETIER_REPERTOIRE_PAGES;
461        } elseif (isset($GLOBALS['z_blocs'])) {
462                $premier_bloc = reset($GLOBALS['z_blocs']);
463                $repertoire_pages = "$premier_bloc/";
464        } else {
465                $repertoire_pages = 'contenu/';
466        }
467
468        return $repertoire_pages;
469}
470
471/**
472 * Détermine, pour une page donnée, la liste des blocs ayant des noisettes incluses et renvoie leur nombre.
473 *
474 * @api
475 *
476 * @param string $page
477 *            L'identifiant de la page ou de la composition.
478 *
479 * @return array
480 *             Tableau des nombre de noisettes incluses par bloc de la forme [bloc] = nombre de noisettes.
481 */
482function page_noizetier_compter_noisettes($page) {
483
484        static $blocs_compteur = array();
485
486        if (!isset($blocs_compteur[$page])) {
487                // Initialisation des compteurs par bloc
488                $nb_noisettes = array();
489
490                // Le nombre de noisettes par bloc doit être calculé par une lecture de la table spip_noisettes.
491                $from = array('spip_noisettes');
492                $select = array('bloc', "count(type_noisette) as 'noisettes'");
493                // -- Construction du where identifiant précisément le type et la composition de la page
494                $where = array(
495                        'plugin=' . sql_quote('noizetier'),
496                        'type=' . sql_quote(page_noizetier_extraire_type($page)),
497                        'composition=' . sql_quote(page_noizetier_extraire_composition($page))
498                );
499                $group = array('bloc');
500                $blocs_non_vides = sql_allfetsel($select, $from, $where, $group);
501                if ($blocs_non_vides) {
502                        // On formate le tableau [bloc] = nb noisettes
503                        $nb_noisettes = array_column($blocs_non_vides, 'noisettes', 'bloc');
504                }
505
506                // Sauvegarde des compteurs pour les blocs concernés.
507                $blocs_compteur[$page] = $nb_noisettes;
508        }
509
510        return $blocs_compteur[$page];
511}
512
513/**
514 * Phrase le fichier XML ou YAML des pages et compositions configurables par le noiZetier et renvoie
515 * un tableau des caractéristiques complètes.
516 *
517 * @internal
518 *
519 * @uses page_noizetier_initialiser_dossier()
520 * @uses bloc_z_lister_defaut()
521 *
522 * @param       $page
523 * @param array $options
524 *
525 * @return array
526 */
527function phraser_fichier_descriptif_page($page, $options = array()) {
528
529        // Initialisation de la description
530        $description = array();
531
532        // Choisir le bon répertoire des pages
533        if (empty($options['repertoire_pages'])) {
534                $options['repertoire_pages'] = page_noizetier_initialiser_dossier();
535        }
536
537        // Initialiser les blocs par défaut
538        if (empty($options['blocs_defaut'])) {
539                include_spip('inc/noizetier_bloc');
540                $options['blocs_defaut'] = bloc_z_lister_defaut();
541        }
542
543        // Initialiser le contexte de chargement
544        if (!isset($options['recharger'])) {
545                $options['recharger'] = false;
546        }
547        if (!isset($options['md5']) or $options['recharger']) {
548                $options['md5'] = '';
549        }
550
551        // Initialiser les composants de l'identifiant de la page:
552        // - type-composition si la page est une composition
553        // - type sinon
554        // On gère aussi le cas de Zpip v1 où page-xxxx désigne une page et non une composition.
555        // Dans ce cas, on doit donc obtenir type = xxxx et composition vide.
556        $identifiants = explode('-', $page);
557        if (!isset($identifiants[1])) {
558                $identifiants[1] = '';
559        } elseif ($identifiants[0] == 'page') {
560                $identifiants[0] = $identifiants[1];
561                $identifiants[1] = '';
562        }
563
564        // Initialisation de la description par défaut de la page
565        $description_defaut = array(
566                'page'           => $page,
567                'type'           => $identifiants[0],
568                'composition'    => $identifiants[1],
569                'nom'            => $page,
570                'description'    => '',
571                'icon'           => 'page-24.png',
572                'blocs_exclus'   => array(),
573                'necessite'      => array(),
574                'est_active'     => 'oui',
575                'branche'        => array(),
576                'est_virtuelle'  => 'non',
577                'est_page_objet' => 'non',
578                'signature'      => '',
579        );
580
581        // Recherche des pages ou compositions explicites suivant le processus :
582        // a- Le fichier YAML est recherché en premier,
583        // b- ensuite le fichier XML pour compatibilité ascendante.
584        // c- enfin, si il n'y a ni YAML, ni XML et que le mode le permet, on renvoie une description standard minimale
585        //    basée sur le fichier HTML uniquement
586        $md5 = '';
587        if ($fichier = find_in_path("{$options['repertoire_pages']}${page}.yaml")) {
588                // 1a- il y a un fichier YAML de configuration, on vérifie le md5 avant de charger le contenu.
589                //     Un YAML de page ne peut pas contenir d'inclusion YAML.
590                $md5 = md5_file($fichier);
591                if ($md5 != $options['md5']) {
592                        include_spip('inc/yaml');
593                        $description = yaml_decode_file($fichier);
594                }
595        } elseif ($fichier = find_in_path("{$options['repertoire_pages']}${page}.xml")) {
596                // 1b- il y a un fichier XML de configuration, on vérifie le md5 avant de charger le contenu.
597                //     on extrait et on parse le XML de configuration en tenant compte que ce peut être
598                //     celui d'une page ou d'une composition, ce qui change la balise englobante.
599                $md5 = md5_file($fichier);
600                if ($md5 != $options['md5']) {
601                        include_spip('inc/xml');
602                        if ($xml = spip_xml_load($fichier, false)
603                        and (isset($xml['page']) or isset($xml['composition']))) {
604                                $xml = isset($xml['page']) ? reset($xml['page']) : reset($xml['composition']);
605                                // Titre (nom), description et icone
606                                if (isset($xml['nom'])) {
607                                        $description['nom'] = spip_xml_aplatit($xml['nom']);
608                                }
609                                if (isset($xml['description'])) {
610                                        $description['description'] = spip_xml_aplatit($xml['description']);
611                                }
612                                if (isset($xml['icon'])) {
613                                        $description['icon'] = reset($xml['icon']);
614                                }
615
616                                // Liste des blocs autorisés pour la page. On vérifie que les blocs configurés sont bien dans
617                                // la liste des blocs par défaut et on calcule les blocs exclus qui sont les seuls insérés en base.
618                                $blocs_inclus = array();
619                                if (spip_xml_match_nodes(',^bloc,', $xml, $blocs)) {
620                                        foreach (array_keys($blocs) as $_bloc) {
621                                                list(, $attributs) = spip_xml_decompose_tag($_bloc);
622                                                $blocs_inclus[] = $attributs['id'];
623                                        }
624                                }
625                                if ($blocs_inclus) {
626                                        $description['blocs_exclus'] = array_diff($options['blocs_defaut'], array_intersect($options['blocs_defaut'], $blocs_inclus));
627                                }
628
629                                // Liste des plugins nécessaires pour utiliser la page
630                                if (spip_xml_match_nodes(',^necessite,', $xml, $necessites)) {
631                                        $description['necessite'] = array();
632                                        foreach (array_keys($necessites) as $_necessite) {
633                                                list(, $attributs) = spip_xml_decompose_tag($_necessite);
634                                                $description['necessite'][] = $attributs['id'];
635                                        }
636                                }
637
638                                // Liste des héritages
639                                if (spip_xml_match_nodes(',^branche,', $xml, $branches)) {
640                                        $description['branche'] = array();
641                                        foreach (array_keys($branches) as $_branche) {
642                                                list(, $attributs) = spip_xml_decompose_tag($_branche);
643                                                $description['branche'][$attributs['type']] = $attributs['composition'];
644                                        }
645                                }
646                        }
647                }
648        } elseif (defined('_NOIZETIER_LISTER_PAGES_SANS_XML') ? _NOIZETIER_LISTER_PAGES_SANS_XML : true) {
649                // 1c- il est autorisé de ne pas avoir de fichier XML de configuration.
650                // Ces pages sans XML ne sont chargées qu'une fois, la première. Ensuite, aucune mise à jour n'est nécessaire.
651                if (!$options['md5']) {
652                        $description['icon'] = 'page_noxml-24.png';
653                        $md5 = md5('_NOIZETIER_LISTER_PAGES_SANS_XML');
654                }
655        }
656
657        // Si la description est remplie c'est que le chargement a correctement eu lieu.
658        // Sinon, si la page n'a pas changée on renvoie une description limitée à un indicateur d'identité pour
659        // distinguer ce cas avec une erreur de chargement qui renvoie une description vide.
660        if ($description) {
661                // Mise à jour du md5
662                $description['signature'] = $md5;
663                // Identifie si la page est celle d'un objet SPIP
664                include_spip('base/objets');
665                $tables_objets = array_keys(lister_tables_objets_sql());
666                $description['est_page_objet'] = in_array(table_objet_sql($description_defaut['type']), $tables_objets) ? 'oui' : 'non';
667                // Complétude de la description avec les valeurs par défaut
668                $description = array_merge($description_defaut, $description);
669                // Traitement des necessite pour identifier l'activité de la page
670                $description['est_active'] = 'oui';
671                if ($description['necessite']) {
672                        foreach ($description['necessite'] as $_plugin_necessite) {
673                                if (!defined('_DIR_PLUGIN_' . strtoupper($_plugin_necessite))) {
674                                        $description['est_active'] = 'non';
675                                        break;
676                                }
677                        }
678                }
679                // Sérialisation des champs blocs_exclus, necessite et branche qui sont des tableaux
680                $description['blocs_exclus'] = serialize($description['blocs_exclus']);
681                $description['necessite'] = serialize($description['necessite']);
682                $description['branche'] = serialize($description['branche']);
683        } elseif ($md5 == $options['md5']) {
684                $description['identique'] = true;
685        }
686
687        return $description;
688}
Note: See TracBrowser for help on using the repository browser.