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

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

Amélioration de l'API page_noizetier_repertorier qui permet d'indexer le tableau de sortie de façon numérique.
Mise en conformité de ieconfig avec cette API et correction dans la foulée de l'importation des compositions virtuelles.

  • Property svn:eol-style set to native
File size: 23.0 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 configuration de la page, de la composition explicite ou de la composition virtuelle demandée.
185 * La configuration est stockée en base de données, certains champs sont recalculés avant d'être fournis.
186 *
187 * @api
188 *
189 * @uses bloc_z_lister_defaut()
190 *
191 * @param string        $page
192 *              Identifiant de la page ou de la composition.
193 * @param boolean       $traitement_typo
194 *      Indique si les données textuelles doivent être retournées brutes ou si elles doivent être traitées
195 *      en utilisant la fonction typo.
196 *              Les champs sérialisés sont toujours désérialisés.
197 *
198 * @return array
199 */
200function page_noizetier_lire($page, $traitement_typo = true) {
201
202        static $description_page = array();
203
204        if (!isset($description_page[$traitement_typo][$page])) {
205                // Chargement de toute la configuration de la page en base de données.
206                $description = sql_fetsel('*', 'spip_noizetier_pages', array('page=' . sql_quote($page)));
207
208                // Sauvegarde de la description de la page pour une consultation ultérieure dans le même hit.
209                if ($description) {
210                        // Traitements des champs textuels
211                        if ($traitement_typo) {
212                                $description['nom'] = typo($description['nom']);
213                                if (isset($description['description'])) {
214                                        $description['description'] = typo($description['description']);
215                                }
216                        }
217                        // Traitements des champs tableaux sérialisés
218                        $description['blocs_exclus'] = unserialize($description['blocs_exclus']);
219                        $description['necessite'] = unserialize($description['necessite']);
220                        $description['branche'] = unserialize($description['branche']);
221                        // Calcul des blocs
222                        $description['blocs'] = page_noizetier_lister_blocs($page, $description['blocs_exclus']);
223                        $description_page[$traitement_typo][$page] = $description;
224                } else {
225                        $description_page[$traitement_typo][$page] = array();
226                }
227        }
228
229        return $description_page[$traitement_typo][$page];
230}
231
232/**
233 * Retourne la description complète ou partielle d'une liste de pages explicites, compositions explicite et
234 * compositions virtuelles filtrées sur une liste de critères.
235 *
236 * @api
237 *
238 * @param string  $information
239 *        Information spécifique à retourner ou vide pour retourner toute la description. L'information peut être une
240 *        chaine correspondant à un champ de la page ou un tableau avec une liste de champs.
241 * @param array   $filtres
242 *        Tableau associatif `[champ] = valeur` de critères de filtres sur les descriptions de types de noisette.
243 *        Le seul opérateur possible est l'égalité.
244 * @param boolean $indexer_par_page
245 *      Indique si le tableau doit être indexé par d'identifiant de page ou pas. `true` par défaut.
246 *
247 * @return array
248 *        Tableau des descriptions des pages et compositions trouvées indexé par l'identifiant de la page ou par
249 *        entier de 0 à n.
250 */
251function page_noizetier_repertorier($information = array(), $filtres = array(), $indexer_par_page = true) {
252
253        // Initialiser la sortie.
254        $pages = array();
255
256        // On initialise la liste des champs de la table des pages
257        $trouver_table = charger_fonction('trouver_table', 'base');
258        $table = $trouver_table('spip_noizetier_pages');
259
260        // On vérifie les champs à retourner et on calcule le contenu du select.
261        $champs = array_diff(array_keys($table['field']), array('maj'));
262        $information_valide = true;
263        $information_unique = false;
264        if (!$information) {
265                $select = $champs;
266        } else {
267                if (is_string($information)) {
268                        $select = array($information);
269                        $information_unique = true;
270                } else {
271                        $select = $information;
272                }
273
274                // On vérifie que les champs sont bien valides.
275                foreach ($select as $_champ) {
276                        if (!in_array($_champ, $champs)) {
277                                $information_valide = false;
278                                break;
279                        }
280                }
281
282                // On ajoute toujours l'identifiant page car il sert à l'indexation du tableau de sortie.
283                if ($indexer_par_page
284                and $information_valide
285                and !in_array('page', $select)) {
286                        $select[] = 'page';
287                }
288        }
289
290        if ($information_valide) {
291                // On calcule le where à partir des filtres sachant que tous les champs sont des chaines.
292                $where = array();
293                if ($filtres) {
294                        foreach ($filtres as $_champ => $_critere) {
295                                $operateur = '=';
296                                $valeur = $_critere;
297                                if (substr($_critere, 0, 1) == '!') {
298                                        $operateur = '!=';
299                                        $valeur = ltrim($_critere, '!');
300                                }
301                                $where[] = $_champ . $operateur . sql_quote($valeur);
302                        }
303                }
304
305                // Chargement des pages et compositions.
306                $pages = sql_allfetsel($select, 'spip_noizetier_pages', $where);
307
308                // On renvoie l'information demandée indexée par page si demandé ainsi.
309                if ($indexer_par_page) {
310                        if ($information_unique) {
311                                $pages = array_column($pages, $information, 'page');
312                        } else {
313                                $pages = array_column($pages, null, 'page');
314                                if ($information and !in_array('page', $information)) {
315                                        // On supprime le champ 'page' qui n'a pas été demandé
316                                        foreach ($pages as $_id_page => $_page) {
317                                                unset($pages[$_id_page]['page']);
318                                        }
319                                }
320                        }
321                }
322        }
323
324        return $pages;
325}
326
327
328/**
329 *
330 * @api
331 *
332 * @param       $page
333 * @param array $blocs_exclus
334 *
335 * @return array
336 */
337function page_noizetier_lister_blocs($page, $blocs_exclus = array()) {
338
339        // Initialisation des blocs avec la liste des blocs par défaut
340        include_spip('inc/noizetier_bloc');
341        $blocs = bloc_z_lister_defaut();
342
343        // Si la liste des blocs exclus n'a pas été passé en argument on les cherche dans la configuration
344        // de la page
345        if (!$blocs_exclus) {
346                include_spip('base/abstract_sql');
347                $where = array('page=' . sql_quote($page));
348                $blocs_exclus = sql_getfetsel('blocs_exclus', 'spip_noizetier_pages', $where);
349                $blocs_exclus = unserialize($blocs_exclus);
350        }
351
352        if ($blocs_exclus) {
353                $blocs = array_diff($blocs, $blocs_exclus);
354                sort($blocs);
355        }
356
357        return $blocs;
358}
359
360
361/**
362 * Renvoie le type d'une page à partir de son identifiant.
363 *
364 * @api
365 *
366 * @param string $page
367 *              L'identifiant de la page.
368 *
369 * @return string
370 *              Le type de la page choisie, c'est-à-dire:
371 *              - soit l'identifiant complet de la page,
372 *              - soit le mot précédent le tiret dans le cas d'une composition.
373 */
374function page_noizetier_extraire_type($page) {
375
376        $type = explode('-', $page, 2);
377        $type = $type[0];
378
379        return $type;
380}
381
382/**
383 * Détermine, à partir de son identifiant, la composition d'une page si elle existe.
384 *
385 * @api
386 *
387 * @param string $page
388 *              L'identifiant de la page.
389 *
390 * @return string
391 *      La composition de la page choisie, à savoir, le mot suivant le tiret,
392 *              ou la chaine vide sinon.
393 */
394function page_noizetier_extraire_composition($page) {
395
396        $composition = explode('-', $page, 2);
397        $composition = isset($composition[1]) ? $composition[1] : '';
398
399        return $composition;
400}
401
402/**
403 * Détermine si les compositions sont possibles sur un type de page.
404 *
405 * @api
406 *
407 * @param string $type
408 *              Identifiant du type de page.
409 *
410 * @return boolean
411 *              True si les compositions sont autorisées, false sinon.
412 */
413function page_noizetier_composition_activee($type) {
414
415        $est_activee = false;
416
417        if (defined('_DIR_PLUGIN_COMPOSITIONS')) {
418                include_spip('compositions_fonctions');
419                if (in_array($type, compositions_objets_actives())) {
420                        $est_activee = true;
421                }
422        }
423
424        return $est_activee;
425}
426
427/**
428 * Déterminer le répertoire dans lequel le NoiZetier peut lister les pages pouvant supporter
429 * l'insertion de noisettes.
430 *
431 * @api
432 *
433 * @return string
434 *              Le répertoire des pages sous la forme dossier/.
435 */
436function page_noizetier_initialiser_dossier() {
437
438        if (defined('_NOIZETIER_REPERTOIRE_PAGES')) {
439                $repertoire_pages = _NOIZETIER_REPERTOIRE_PAGES;
440        } elseif (isset($GLOBALS['z_blocs'])) {
441                $premier_bloc = reset($GLOBALS['z_blocs']);
442                $repertoire_pages = "$premier_bloc/";
443        } else {
444                $repertoire_pages = 'contenu/';
445        }
446
447        return $repertoire_pages;
448}
449
450/**
451 * Détermine, pour une page donnée, la liste des blocs ayant des noisettes incluses et renvoie leur nombre.
452 *
453 * @api
454 *
455 * @param string $page
456 *            L'identifiant de la page ou de la composition.
457 *
458 * @return array
459 *             Tableau des nombre de noisettes incluses par bloc de la forme [bloc] = nombre de noisettes.
460 */
461function page_noizetier_compter_noisettes($page) {
462
463        static $blocs_compteur = array();
464
465        if (!isset($blocs_compteur[$page])) {
466                // Initialisation des compteurs par bloc
467                $nb_noisettes = array();
468
469                // Le nombre de noisettes par bloc doit être calculé par une lecture de la table spip_noisettes.
470                $from = array('spip_noisettes');
471                $select = array('bloc', "count(type_noisette) as 'noisettes'");
472                // -- Construction du where identifiant précisément le type et la composition de la page
473                $where = array(
474                        'plugin=' . sql_quote('noizetier'),
475                        'type=' . sql_quote(page_noizetier_extraire_type($page)),
476                        'composition=' . sql_quote(page_noizetier_extraire_composition($page))
477                );
478                $group = array('bloc');
479                $blocs_non_vides = sql_allfetsel($select, $from, $where, $group);
480                if ($blocs_non_vides) {
481                        // On formate le tableau [bloc] = nb noisettes
482                        $nb_noisettes = array_column($blocs_non_vides, 'noisettes', 'bloc');
483                }
484
485                // Sauvegarde des compteurs pour les blocs concernés.
486                $blocs_compteur[$page] = $nb_noisettes;
487        }
488
489        return $blocs_compteur[$page];
490}
491
492/**
493 * Phrase le fichier XML ou YAML des pages et compositions configurables par le noiZetier et renvoie
494 * un tableau des caractéristiques complètes.
495 *
496 * @internal
497 *
498 * @uses page_noizetier_initialiser_dossier()
499 * @uses bloc_z_lister_defaut()
500 *
501 * @param       $page
502 * @param array $options
503 *
504 * @return array
505 */
506function phraser_fichier_descriptif_page($page, $options = array()) {
507
508        // Initialisation de la description
509        $description = array();
510
511        // Choisir le bon répertoire des pages
512        if (empty($options['repertoire_pages'])) {
513                $options['repertoire_pages'] = page_noizetier_initialiser_dossier();
514        }
515
516        // Initialiser les blocs par défaut
517        if (empty($options['blocs_defaut'])) {
518                include_spip('inc/noizetier_bloc');
519                $options['blocs_defaut'] = bloc_z_lister_defaut();
520        }
521
522        // Initialiser le contexte de chargement
523        if (!isset($options['recharger'])) {
524                $options['recharger'] = false;
525        }
526        if (!isset($options['md5']) or $options['recharger']) {
527                $options['md5'] = '';
528        }
529
530        // Initialiser les composants de l'identifiant de la page:
531        // - type-composition si la page est une composition
532        // - type sinon
533        // On gère aussi le cas de Zpip v1 où page-xxxx désigne une page et non une composition.
534        // Dans ce cas, on doit donc obtenir type = xxxx et composition vide.
535        $identifiants = explode('-', $page);
536        if (!isset($identifiants[1])) {
537                $identifiants[1] = '';
538        } elseif ($identifiants[0] == 'page') {
539                $identifiants[0] = $identifiants[1];
540                $identifiants[1] = '';
541        }
542
543        // Initialisation de la description par défaut de la page
544        $description_defaut = array(
545                'page'           => $page,
546                'type'           => $identifiants[0],
547                'composition'    => $identifiants[1],
548                'nom'            => $page,
549                'description'    => '',
550                'icon'           => 'page-24.png',
551                'blocs_exclus'   => array(),
552                'necessite'      => array(),
553                'est_active'     => 'oui',
554                'branche'        => array(),
555                'est_virtuelle'  => 'non',
556                'est_page_objet' => 'non',
557                'signature'      => '',
558        );
559
560        // Recherche des pages ou compositions explicites suivant le processus :
561        // a- Le fichier YAML est recherché en premier,
562        // b- ensuite le fichier XML pour compatibilité ascendante.
563        // c- enfin, si il n'y a ni YAML, ni XML et que le mode le permet, on renvoie une description standard minimale
564        //    basée sur le fichier HTML uniquement
565        $md5 = '';
566        if ($fichier = find_in_path("{$options['repertoire_pages']}${page}.yaml")) {
567                // 1a- il y a un fichier YAML de configuration, on vérifie le md5 avant de charger le contenu.
568                //     Un YAML de page ne peut pas contenir d'inclusion YAML.
569                $md5 = md5_file($fichier);
570                if ($md5 != $options['md5']) {
571                        include_spip('inc/yaml');
572                        $description = yaml_decode_file($fichier);
573                }
574        } elseif ($fichier = find_in_path("{$options['repertoire_pages']}${page}.xml")) {
575                // 1b- il y a un fichier XML de configuration, on vérifie le md5 avant de charger le contenu.
576                //     on extrait et on parse le XML de configuration en tenant compte que ce peut être
577                //     celui d'une page ou d'une composition, ce qui change la balise englobante.
578                $md5 = md5_file($fichier);
579                if ($md5 != $options['md5']) {
580                        include_spip('inc/xml');
581                        if ($xml = spip_xml_load($fichier, false)
582                        and (isset($xml['page']) or isset($xml['composition']))) {
583                                $xml = isset($xml['page']) ? reset($xml['page']) : reset($xml['composition']);
584                                // Titre (nom), description et icone
585                                if (isset($xml['nom'])) {
586                                        $description['nom'] = spip_xml_aplatit($xml['nom']);
587                                }
588                                if (isset($xml['description'])) {
589                                        $description['description'] = spip_xml_aplatit($xml['description']);
590                                }
591                                if (isset($xml['icon'])) {
592                                        $description['icon'] = reset($xml['icon']);
593                                }
594
595                                // Liste des blocs autorisés pour la page. On vérifie que les blocs configurés sont bien dans
596                                // la liste des blocs par défaut et on calcule les blocs exclus qui sont les seuls insérés en base.
597                                $blocs_inclus = array();
598                                if (spip_xml_match_nodes(',^bloc,', $xml, $blocs)) {
599                                        foreach (array_keys($blocs) as $_bloc) {
600                                                list(, $attributs) = spip_xml_decompose_tag($_bloc);
601                                                $blocs_inclus[] = $attributs['id'];
602                                        }
603                                }
604                                if ($blocs_inclus) {
605                                        $description['blocs_exclus'] = array_diff($options['blocs_defaut'], array_intersect($options['blocs_defaut'], $blocs_inclus));
606                                }
607
608                                // Liste des plugins nécessaires pour utiliser la page
609                                if (spip_xml_match_nodes(',^necessite,', $xml, $necessites)) {
610                                        $description['necessite'] = array();
611                                        foreach (array_keys($necessites) as $_necessite) {
612                                                list(, $attributs) = spip_xml_decompose_tag($_necessite);
613                                                $description['necessite'][] = $attributs['id'];
614                                        }
615                                }
616
617                                // Liste des héritages
618                                if (spip_xml_match_nodes(',^branche,', $xml, $branches)) {
619                                        $description['branche'] = array();
620                                        foreach (array_keys($branches) as $_branche) {
621                                                list(, $attributs) = spip_xml_decompose_tag($_branche);
622                                                $description['branche'][$attributs['type']] = $attributs['composition'];
623                                        }
624                                }
625                        }
626                }
627        } elseif (defined('_NOIZETIER_LISTER_PAGES_SANS_XML') ? _NOIZETIER_LISTER_PAGES_SANS_XML : true) {
628                // 1c- il est autorisé de ne pas avoir de fichier XML de configuration.
629                // Ces pages sans XML ne sont chargées qu'une fois, la première. Ensuite, aucune mise à jour n'est nécessaire.
630                if (!$options['md5']) {
631                        $description['icon'] = 'page_noxml-24.png';
632                        $md5 = md5('_NOIZETIER_LISTER_PAGES_SANS_XML');
633                }
634        }
635
636        // Si la description est remplie c'est que le chargement a correctement eu lieu.
637        // Sinon, si la page n'a pas changée on renvoie une description limitée à un indicateur d'identité pour
638        // distinguer ce cas avec une erreur de chargement qui renvoie une description vide.
639        if ($description) {
640                // Mise à jour du md5
641                $description['signature'] = $md5;
642                // Identifie si la page est celle d'un objet SPIP
643                include_spip('base/objets');
644                $tables_objets = array_keys(lister_tables_objets_sql());
645                $description['est_page_objet'] = in_array(table_objet_sql($description_defaut['type']), $tables_objets) ? 'oui' : 'non';
646                // Complétude de la description avec les valeurs par défaut
647                $description = array_merge($description_defaut, $description);
648                // Traitement des necessite pour identifier l'activité de la page
649                $description['est_active'] = 'oui';
650                if ($description['necessite']) {
651                        foreach ($description['necessite'] as $_plugin_necessite) {
652                                if (!defined('_DIR_PLUGIN_' . strtoupper($_plugin_necessite))) {
653                                        $description['est_active'] = 'non';
654                                        break;
655                                }
656                        }
657                }
658                // Sérialisation des champs blocs_exclus, necessite et branche qui sont des tableaux
659                $description['blocs_exclus'] = serialize($description['blocs_exclus']);
660                $description['necessite'] = serialize($description['necessite']);
661                $description['branche'] = serialize($description['branche']);
662        } elseif ($md5 == $options['md5']) {
663                $description['identique'] = true;
664        }
665
666        return $description;
667}
Note: See TracBrowser for help on using the repository browser.