Changeset 104849 in spip-zone


Ignore:
Timestamp:
Jun 13, 2017, 7:19:03 PM (2 years ago)
Author:
eric@…
Message:

Un lot de modifications pour passer les pages en base de données.
Attention ça pète pas mal de choses.

Location:
_plugins_/noizetier/trunk
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/noizetier/trunk/base/noizetier_tables.php

    r104771 r104849  
    11<?php
    22
    3 // Sécurité
    43if (!defined('_ECRIRE_INC_VERSION')) {
    54        return;
    65}
    76
     7
     8/**
     9 * Déclaration des informations tierces (alias, traitements, jointures, etc)
     10 * sur les tables de la base de données modifiées ou ajoutées par le plugin.
     11 *
     12 * Le plugin se contente de déclarer les alias des tables.
     13 *
     14 * @pipeline declarer_tables_interfaces
     15 *
     16 * @param array $interface
     17 *              Tableau global des informations tierces sur les tables de la base de données
     18 * @return array
     19 *              Tableau fourni en entrée et mis à jour avec les nouvelles informations
     20 */
    821function noizetier_declarer_tables_interfaces($interface) {
    922        // 'spip_' dans l'index de $tables_principales
    1023        $interface['table_des_tables']['noisettes'] = 'noisettes';
     24        $interface['table_des_tables']['noisettes_pages'] = 'noisettes_pages';
    1125
    1226        return $interface;
    1327}
    1428
     29/**
     30 * Déclaration des nouvelles tables de la base de données propres au plugin.
     31 *
     32 * Le plugin déclare deux nouvelles tables qui sont :
     33 *
     34 * - `spip_noisettes_pages`, qui contient les éléments descriptifs des pages et compositions,
     35 * - `spip_noisettes`, qui contient la desxcription de l'utilisation des noisettes dans les pages concernées.
     36 *
     37 * @pipeline declarer_tables_principales
     38 *
     39 * @param array $tables_principales
     40 *              Tableau global décrivant la structure des tables de la base de données
     41 * @return array
     42 *              Tableau fourni en entrée et mis à jour avec les nouvelles déclarations
     43 */
    1544function noizetier_declarer_tables_principales($tables_principales) {
    16         //-- Table noisettes -----------------------------------------------------------
     45
     46        // Table spip_noisettes_pages
     47        $pages = array(
     48                'page'           => "VARCHAR(255) DEFAULT '' NOT NULL",
     49                'type'           => "VARCHAR(127) DEFAULT '' NOT NULL",
     50                'composition'    => "VARCHAR(127) DEFAULT '' NOT NULL",
     51                'nom'            => "text DEFAULT '' NOT NULL",
     52                'description'    => "text DEFAULT '' NOT NULL",
     53                'icon'           => "VARCHAR(255) DEFAULT '' NOT NULL",
     54                'blocs_exclus'   => "text DEFAULT '' NOT NULL",
     55                'necessite'      => "text DEFAULT '' NOT NULL",
     56                'branche'        => "text DEFAULT '' NOT NULL",
     57                'est_page_objet' => "VARCHAR(3) DEFAULT 'oui' NOT NULL",
     58                'est_virtuelle'  => "VARCHAR(3) DEFAULT 'non' NOT NULL",
     59                'image_exemple'  => "VARCHAR(255) DEFAULT '' NOT NULL",
     60                'class'          => "VARCHAR(255) DEFAULT '' NOT NULL",
     61                'configuration'  => "VARCHAR(255) DEFAULT '' NOT NULL",
     62                'signature'      => "VARCHAR(32) DEFAULT '' NOT NULL",
     63        );
     64
     65        $pages_cles = array(
     66                'PRIMARY KEY'        => 'page',
     67                'KEY type'           => 'type',
     68                'KEY composition'    => 'composition',
     69                "KEY est_page_objet" => "est_page_objet",
     70                "KEY est_virtuelle"  => "est_virtuelle",
     71        );
     72
     73        $tables_principales['spip_noisettes_pages'] = array(
     74                'field' => &$pages,
     75                'key' => &$pages_cles,
     76        );
     77
     78        // Table spip_noisettes
    1779        $noisettes = array(
    1880                'id_noisette' => 'bigint(21) NOT NULL',
    1981                'rang'        => "smallint DEFAULT '1' NOT NULL",
    20                 'type'        => "tinytext DEFAULT '' NOT NULL",
    21                 'composition' => "tinytext DEFAULT '' NOT NULL",
    22                 'objet'       => 'varchar(255) not null default ""',
     82                'type'        => "varchar(127) DEFAULT '' NOT NULL",
     83                'composition' => "varchar(127) DEFAULT '' NOT NULL",
     84                'objet'       => 'varchar(25) not null default ""',
    2385                'id_objet'    => 'bigint(21) not null default 0',
    2486                'bloc'        => "tinytext DEFAULT '' NOT NULL",
  • _plugins_/noizetier/trunk/demo/noizetier.html

    r104675 r104849  
    1212//      $infos = noizetier_noisette_informer('article-filariane');
    1313//      $infos = noizetier_lister_noisettes();
    14         $infos = noizetier_noisette_repertorier();
     14//      $infos = noizetier_noisette_repertorier();
     15
     16        noizetier_page_charger();
    1517
    1618        $timestamp_fin = microtime(true);
  • _plugins_/noizetier/trunk/noizetier_administrations.php

    r104787 r104849  
    66}
    77
    8 include_spip('inc/meta');
    9 
    10 // Installation et mise à jour
     8/**
     9 * Installation du schéma de données propre au plugin et gestion des migrations suivant
     10 * les évolutions du schéma.
     11 *
     12 * Le schéma comprend des tables et des variables de configuration propres au plugin.
     13 *
     14 * @api
     15 * @see boussole_declarer_tables_principales()
     16 * @see boussole_declarer_tables_interfaces()
     17 *
     18 * @param string $nom_meta_base_version
     19 *              Nom de la meta dans laquelle sera rangée la version du schéma
     20 * @param string $version_cible
     21 *              Version du schéma de données en fin d'upgrade
     22 *
     23 * @return void
     24 */
    1125function noizetier_upgrade($nom_meta_base_version, $version_cible) {
    1226        $maj = array();
     
    2034
    2135        $maj['create'] = array(
    22                 array('maj_tables',array('spip_noisettes')),
     36                array('maj_tables',array('spip_noisettes_pages', 'spip_noisettes')),
    2337                array('ecrire_config', 'noizetier', $config_060),
    2438        );
     
    5468}
    5569
    56 // Désinstallation
     70/**
     71 * Suppression de l'ensemble du schéma de données propre au plugin, c'est-à-dire
     72 * les tables et les variables de configuration.
     73 *
     74 * @api
     75 *
     76 * @param string $nom_meta_base_version
     77 *              Nom de la meta dans laquelle sera rangée la version du schéma
     78 *
     79 * @return void
     80 */
    5781function noizetier_vider_tables($nom_meta_version_base) {
    5882        // On efface les tables du plugin
     83        sql_drop_table('spip_noisettes_pages');
    5984        sql_drop_table('spip_noisettes');
    6085
    61         // On efface la version enregistrée
     86        // On efface la version enregistrée du schéma des données du plugin
    6287        effacer_meta($nom_meta_version_base);
    63         // On efface les compositions enregistrées
    64         effacer_meta('noizetier_compositions');
    65         // On efface la configuration
     88        // On efface la configuration du plugin
    6689        effacer_meta('noizetier');
    6790
     
    7396        supprimer_fichier(_CACHE_INCLUSIONS_NOISETTES);
    7497        supprimer_fichier(_CACHE_DESCRIPTIONS_NOISETTES);
     98        supprimer_fichier(_CACHE_MD5_PAGES);
    7599}
    76100
    77101/**
    78  * Transformer le tableau des compositions virtuelles stocké en meta et ajouter les
    79  * valeurs par défaut des paramètres de configuration.
    80  * Jusqu'au schéma 0.5.0 le tableau était de la forme [$type][$composition].
    81  * A partir du schéma 0.6.0 le tableau prend la forme [$type-$composition].
     102 * Migration du schéma 0.5 au 0.6.
    82103 *
     104 * Les actions effectuées sont les suivantes:
     105 * - ajout de la tables `spip_noisettes_pages` pour stocker l'ensemble des pages et compositions
     106 * explicites et virtuelles.
     107 * - ajout du champ `balise` à la table `spip_noisettes` pour déterminer si le noiZetier doit inclure
     108 * la noisette concernée dans un div englobant.
     109 * - mise à jour de la taille des champs type, composition et objet dans la table `spip_noisettes`
     110 * - ajout d'une liste de variables de configuration initialisées
     111 * - transfert des compositions virtuelles de la meta `noizetier_compositions` dans la nouvelle
     112 * table `spip_noisettes_pages` et suppression définitive de la meta.
     113 *
     114 * @param array $config_defaut
     115 *              Tableau des variables de configuration intialisées.
     116 *
     117 * @return void
    83118 */
    84119function maj_060($config_defaut) {
    85120
    86         // Ajout de la colonne div qui indique pour chaque noisette si le noiZetier doit l'inclure dans un div
     121        // Ajout de la tables des pages du noizetier qui contiendra pages et compositions qu'elles soient
     122        // explicites ou virtuelles.
     123        include_spip('base/create');
     124        maj_tables('spip_noisettes_pages');
     125
     126        // Ajout de la colonne 'balise' qui indique pour chaque noisette si le noiZetier doit l'inclure dans un div
    87127        // englobant ou pas. Le champ prend les valeurs 'on', '' ou 'defaut' qui indique qu'il faut prendre
    88         // en compte la valeur configurée par défaut pour toutes les noisettes.
    89         sql_alter("TABLE spip_noisettes ADD balise varchar(6) DEFAULT 'defaut' NOT NULL AFTER parametres");
     128        // en compte la valeur configurée par défaut (configuration du noizetier).
     129        sql_alter("TABLE spip_noisettes ADD balise VARCHAR(6) DEFAULT 'defaut' NOT NULL AFTER parametres");
     130        // Mise à jour des tailles des colonnes type, composition et objet pour cohérence
     131        sql_alter("TABLE spip_noisettes MODIFY type VARCHAR(127) NOT NULL");
     132        sql_alter("TABLE spip_noisettes MODIFY composition VARCHAR(127) NOT NULL");
     133        sql_alter("TABLE spip_noisettes MODIFY balise VARCHAR(25) NOT NULL");
    90134
    91135        // Mise à jour de la configuration du plugin
     
    97141        ecrire_config('noizetier', $config_defaut);
    98142
    99         // Mise à jour de la liste des compositions virtuelles
     143        // Insertion de la liste des compositions virtuelles dans la table 'spip_noisettes_pages'
    100144        $compositions = lire_config('noizetier_compositions', array());
    101145        if ($compositions) {
    102                 // On transforme le tableau de [type][composition] en [type-composition]
    103146                $compositions_060 = array();
    104147                foreach ($compositions as $_type => $_compositions) {
    105148                        foreach ($_compositions as $_composition => $_description) {
    106                                 $compositions_060["${_type}-${_composition}"] = $_description;
     149                                // Type et composition (ne sont jamais vides)
     150                                $_description['type'] = $_type;
     151                                $_description['composition'] = $_composition;
     152                                // Construction de l'identifiant de la page
     153                                $_description['page'] = "${_type}-${_composition}";
     154                                // Nom par défaut si non précisé (identifiant de la page)
     155                                if (empty($_description['nom'])) {
     156                                        $_description['nom'] = $_description['page'];
     157                                }
     158                                // Icone par défaut si non précisé
     159                                if (empty($_description['icon'])) {
     160                                        $_description['icon'] = 'composition-24.png';
     161                                }
     162                                // Blocs, necessite et branche: des tableaux à sérialiser
     163                                $_description['blocs_exclus'] = isset($_description['blocs_exclus'])
     164                                        ? serialize($_description['blocs_exclus'])
     165                                        : serialize(array());
     166                                $_description['necessite'] = isset($_description['necessite'])
     167                                        ? serialize($_description['necessite'])
     168                                        : serialize(array());
     169                                $_description['branche'] = isset($_description['branche'])
     170                                        ? serialize($_description['branche'])
     171                                        : serialize(array());
     172                                // Indicateur de type d'objet
     173                                include_spip('base/objets');
     174                                $tables_objets = array_keys(lister_tables_objets_sql());
     175                                $_description['est_page_objet'] = in_array(table_objet_sql($_type), $tables_objets) ? 'oui' : 'non';
     176                                // Indicateur de composition virtuelle
     177                                $description['est_virtuelle'] = 'oui';
     178                                $compositions_060[] = $_description;
    107179                        }
    108180                }
    109                 ecrire_config('noizetier_compositions', $compositions_060);
     181                // Insertion dans la table spip_noisettes_pages
     182                if ($compositions_060) {
     183                        sql_insertq_multi('spip_noisettes_pages', $compositions_060);
     184                }
    110185        }
     186        // On efface la meta des compositions maintenant que celles-ci sont stockées
     187        // dans une table dédiées aux pages du noizetier
     188        effacer_meta('noizetier_compositions');
    111189}
  • _plugins_/noizetier/trunk/noizetier_autorisations.php

    r104759 r104849  
    185185        if ((is_array($opt) and !empty($opt))
    186186        and (!empty($opt['page']) and ($configuration = noizetier_page_informer($opt['page']))
    187         and $configuration['est_virtuelle'])
     187        and ($configuration['est_virtuelle'] == 'oui'))
    188188        and autoriser('creercomposition', 'noizetier', $id, $qui,  array('page' => $configuration['type']))) {
    189189                $autoriser = true;
  • _plugins_/noizetier/trunk/noizetier_fonctions.php

    r104787 r104849  
    1010define('_CACHE_DESCRIPTIONS_NOISETTES', _DIR_CACHE . 'noisettes_descriptions.php');
    1111define('_CACHE_INCLUSIONS_NOISETTES', _DIR_CACHE . 'noisettes_inclusions.php');
     12define('_CACHE_MD5_PAGES', _DIR_CACHE . 'noisettes_pages_md5.php');
    1213
    1314
     
    3839                                foreach ($fichiers as $_fichier => $_chemin) {
    3940                                        $noisette = basename($_fichier, '.yaml');
    40                                         $options = array('reload' => true, 'yaml' => $_chemin);
     41                                        $options = array('recharger' => true, 'yaml' => $_chemin);
    4142                                        if ($configuration = noizetier_noisette_informer($noisette, '', $options)) {
    4243                                                // On n'inclue la noisette que si les plugins qu'elle nécessite explicitement dans son
     
    99100
    100101        if (!isset($description_noisette[$noisette])) {
    101                 // On essaye d'abord de récupérer la description dans le cache sauf si l'option reload est activée
    102                 if (empty($options['reload'])) {
     102                // On essaye d'abord de récupérer la description dans le cache sauf si l'option recharger est activée
     103                if (empty($options['recharger'])) {
    103104                        if (lire_fichier_securise(_CACHE_DESCRIPTIONS_NOISETTES, $contenu)) {
    104105                                $cache_noisettes = unserialize($contenu);
     
    107108                                } else {
    108109                                        // On a pas trouvé la noisette dans le cache, on essaye de la charger directement
    109                                         $options['reload'] = true;
    110                                 }
    111                         }
    112                 }
    113 
    114                 if (!empty($options['reload'])) {
     110                                        $options['recharger'] = true;
     111                                }
     112                        }
     113                }
     114
     115                if (!empty($options['recharger'])) {
    115116                        // Initialisation de la description et d'une description par défaut
    116117                        $description = array();
     
    10291030// -------------------------------------------------------------------
    10301031
     1032function noizetier_page_charger($recharger = false) {
     1033
     1034        // Retour de la fonction
     1035        $retour = false;
     1036
     1037        // Initialiser les blocs par défaut
     1038        $options['blocs_defaut'] = noizetier_bloc_defaut();
     1039
     1040        // Choisir le bon répertoire des pages
     1041        $options['repertoire_pages'] = noizetier_page_obtenir_dossier();
     1042
     1043        // Initialiser le contexte de rechargement
     1044        // TODO : en attente de voir si on rajoute un var_mode
     1045        $forcer_chargement = $recharger;
     1046
     1047        // Initaliser le where des pages non vrituelles
     1048        $where = array('est_virtuelle=' . sql_quote('non'));
     1049
     1050        // On recherche les pages et les compositions explicites par le fichier HTML en premier
     1051        // Si on le trouve, on récupère la configuration du fichier XML ou YAML.
     1052        if ($fichiers = find_all_in_path($options['repertoire_pages'], '.+[.]html$')) {
     1053                $pages_nouvelles = $pages_modifiees = $pages_obsoletes = array();
     1054                // Récupération des signatures md5 des pages déjà enregistrées.
     1055                // Si on force le rechargement il est inutile de gérer les signatures et les pages modifiées ou obsolètes.
     1056                $signatures = array();
     1057                if (!$forcer_chargement) {
     1058                        $select = array('page', 'signature');
     1059                        if ($signatures = sql_allfetsel($select, 'spip_noisettes_pages', $where)) {
     1060                                $signatures = array_column($signatures, 'signature', 'page');
     1061                        }
     1062                        // On initialise la liste des pages à supprimer avec l'ensemble des pages non virtuelles
     1063                        $pages_obsoletes = $signatures ? array_keys($signatures) : array();
     1064                }
     1065
     1066                foreach ($fichiers as $_squelette => $_chemin) {
     1067                        $page = basename($_squelette, '.html');
     1068                        $dossier = dirname($_chemin);
     1069                        $est_composition = noizetier_page_est_composition($page);
     1070                        // Exclure certaines pages :
     1071                        // -- celles du privé situes dans prive/contenu
     1072                        // -- page liée au plugin Zpip en v1
     1073                        // -- z_apl liée aux plugins Zpip v1 et Zcore
     1074                        // -- les compositions explicites si le plugin Compositions n'est pas activé
     1075                        if ((substr($dossier, -13) != 'prive/contenu')
     1076                        and (($page != 'page') or !defined('_DIR_PLUGIN_Z'))
     1077                        and (($page != 'z_apl') or (!defined('_DIR_PLUGIN_Z') and !defined('_DIR_PLUGIN_ZCORE')))
     1078                        and (!$est_composition or ($est_composition     and defined('_DIR_PLUGIN_COMPOSITIONS')))) {
     1079                                // On passe le md5 de la page si il existe sinon la chaine vide. Cela permet de déterminer
     1080                                // si on doit ajouter la page ou la mettre à jour.
     1081                                // Si le md5 est le même et qu'il n'est donc pas utile de recharger la page, la configuration
     1082                                // retournée est vide.
     1083                                $options['md5'] = isset($signatures[$page]) ? $signatures[$page] : '';
     1084                                $options['recharger'] = $forcer_chargement;
     1085                                if ($configuration = noizetier_page_phraser($page, $options)) {
     1086                                        if (empty($configuration['identique'])) {
     1087                                                // La page a été chargée (nouvelle) ou rechargée (modifiée).
     1088                                                // Néanmoins, on n'inclue cette page que si les plugins qu'elle nécessite explicitement dans son
     1089                                                // fichier de configuration sont bien tous activés.
     1090                                                // Rappel: si une page est incluse dans un plugin non actif elle ne sera pas détectée
     1091                                                //         lors du find_all_in_path() puisque le plugin n'est pas dans le path SPIP.
     1092                                                //         Ce n'est pas ce cas qui est traité ici.
     1093                                                $page_a_garder = true;
     1094                                                $necessite = unserialize($configuration['necessite']);
     1095                                                if (!empty($necessite)) {
     1096                                                        foreach ($necessite as $plugin) {
     1097                                                                if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
     1098                                                                        $page_a_garder = false;
     1099                                                                        break;
     1100                                                                }
     1101                                                        }
     1102                                                }
     1103
     1104                                                // Si la page est à garder on détermine si elle est nouvelle ou modifiée.
     1105                                                // En mode rechargement forcé toute page est considérée comme nouvelle.
     1106                                                // Sinon, la page doit être retirée de la base car un plugin qu'elle nécessite a été désactivée:
     1107                                                // => il suffit pour cela de la laisser dans la liste des pages obsolètes.
     1108                                                if ($page_a_garder) {
     1109                                                        if (!$options['md5'] or $forcer_chargement) {
     1110                                                                // La page est soit nouvelle soit on est en mode rechargement forcé:
     1111                                                                // => il faut la rajouter dans la table.
     1112                                                                $pages_nouvelles[] = $configuration;
     1113                                                        } else {
     1114                                                                // La configuration stockée dans la table a été modifiée et le mode ne force pas le rechargement:
     1115                                                                // => il faut mettre à jour la page dans la table.
     1116                                                                $pages_modifiees[] = $configuration;
     1117                                                                // => il faut donc la supprimer de la liste des pages obsolètes
     1118                                                                $pages_obsoletes = array_diff($pages_obsoletes, array($page));
     1119                                                        }
     1120                                                }
     1121                                        } else {
     1122                                                // La page n'a pas changée et n'a donc pas été réchargée:
     1123                                                // => Il faut donc juste indiquer qu'elle n'est pas obsolète.
     1124                                                $pages_obsoletes = array_diff($pages_obsoletes, array($page));
     1125                                        }
     1126                                } else {
     1127                                        // Il y a eu une erreur sur lors du rechargement de la page.
     1128                                        // Ce peut être en particulier le cas où une page HTML sans XML n'est plus détectée car le
     1129                                        // paramètre _NOIZETIER_LISTER_PAGES_SANS_XML a été positionné de true à false.
     1130                                        // => il faut donc ne rien faire pour laisser la page dans les obsolètes
     1131                                }
     1132                        }
     1133                }
     1134
     1135                // Mise à jour de la table des pages
     1136                // -- Suppression des pages obsolètes ou de toute les pages non virtuelles si on est en mode
     1137                //    rechargement forcé.
     1138                if ($pages_obsoletes) {
     1139                        sql_replace_multi('spip_noisettes_pages', $pages_obsoletes);
     1140                } elseif ($forcer_chargement) {
     1141                        sql_delete('spip_noisettes_pages', $where);
     1142                }
     1143                // -- Update des pages modifiées
     1144                if ($pages_modifiees) {
     1145                        sql_replace_multi('spip_noisettes_pages', $pages_modifiees);
     1146                }
     1147                // -- Insertion des nouvelles pages
     1148                if ($pages_nouvelles) {
     1149                        sql_insertq_multi('spip_noisettes_pages', $pages_nouvelles);
     1150                }
     1151
     1152                $retour = true;
     1153        }
     1154
     1155        return $retour;
     1156}
     1157
     1158
     1159function noizetier_page_phraser($page, $options = array()) {
     1160
     1161        // Initialisation de la description
     1162        $description = array();
     1163
     1164        // Choisir le bon répertoire des pages
     1165        if (empty($options['repertoire_pages'])) {
     1166                $options['repertoire_pages'] = noizetier_page_obtenir_dossier();
     1167        }
     1168
     1169        // Initialiser les blocs par défaut
     1170        if (empty($options['blocs_defaut'])) {
     1171                $options['blocs_defaut'] = noizetier_bloc_defaut();
     1172        }
     1173
     1174        // Initialiser le contexte de chargment
     1175        if (!isset($options['recharger'])) {
     1176                $options['recharger'] = false;
     1177        }
     1178        if (!isset($options['md5']) or $options['recharger']) {
     1179                $options['md5'] = '';
     1180        }
     1181
     1182        // Initialiser les composants de l'identifiant de la page:
     1183        // - type-composition si la page est une composition
     1184        // - type sinon
     1185        // On gère aussi le cas de Zpip v1 où page-xxxx désigne une page et non une composition.
     1186        // Dans ce cas, on doit donc obtenir type = xxxx et composition vide.
     1187        $identifiants = explode('-', $page);
     1188        if (!isset($identifiants[1])) {
     1189                $identifiants[1] = '';
     1190        } elseif ($identifiants[0] == 'page') {
     1191                $identifiants[0] = $identifiants[1];
     1192                $identifiants[1] = '';
     1193        }
     1194
     1195        // Initialisation de la description par défaut de la page
     1196        $description_defaut = array(
     1197                'page'           => $page,
     1198                'type'           => $identifiants[0],
     1199                'composition'    => $identifiants[1],
     1200                'nom'            => $page,
     1201                'description'    => '',
     1202                'icon'           => 'page-24.png',
     1203                'blocs_exclus'   => array(),
     1204                'necessite'      => array(),
     1205                'branche'        => array(),
     1206                'est_virtuelle'  => 'non',
     1207                'est_page_objet' => 'non',
     1208                'signature'      => '',
     1209        );
     1210
     1211        // Recherche des pages ou compositions explicites suivant le processus :
     1212        // a- Le fichier YAML est recherché en premier,
     1213        // b- ensuite le fichier XML pour compatibilité ascendante.
     1214        // c- enfin, si il n'y a ni YAML, ni XML et que le mode le permet, on renvoie une description standard minimale
     1215        //    basée sur le fichier HTML uniquement
     1216        $md5 = '';
     1217        if ($fichier = find_in_path("{$options['repertoire_pages']}${page}.yaml")) {
     1218                // 1a- il y a un fichier YAML de configuration, on vérifie le md5 avant de charger le contenu.
     1219                $md5 = md5_file($fichier);
     1220                if ($md5 != $options['md5']) {
     1221                        include_spip('inc/yaml');
     1222                        $description = yaml_charger_inclusions(yaml_decode_file($fichier));
     1223                }
     1224        } elseif ($fichier = find_in_path("{$options['repertoire_pages']}${page}.xml")) {
     1225                // 1b- il y a un fichier XML de configuration, on vérifie le md5 avant de charger le contenu.
     1226                //     on extrait et on parse le XML de configuration en tenant compte que ce peut être
     1227                //     celui d'une page ou d'une composition, ce qui change la balise englobante.
     1228                $md5 = md5_file($fichier);
     1229                if ($md5 != $options['md5']) {
     1230                        include_spip('inc/xml');
     1231                        if ($xml = spip_xml_load($fichier, false)
     1232                        and (isset($xml['page']) or isset($xml['composition']))) {
     1233                                $xml = isset($xml['page']) ? reset($xml['page']) : reset($xml['composition']);
     1234                                // Titre (nom), description et icone
     1235                                if (isset($xml['nom'])) {
     1236                                        $description['nom'] = spip_xml_aplatit($xml['nom']);
     1237                                }
     1238                                if (isset($xml['description'])) {
     1239                                        $description['description'] = spip_xml_aplatit($xml['description']);
     1240                                }
     1241                                if (isset($xml['icon'])) {
     1242                                        $description['icon'] = reset($xml['icon']);
     1243                                }
     1244
     1245                                // Liste des blocs autorisés pour la page. On vérifie que les blocs configurés sont bien dans
     1246                                // la liste des blocs par défaut et on calcule les blocs exclus qui sont les seuls insérés en base.
     1247                                $blocs_inclus = array();
     1248                                if (spip_xml_match_nodes(',^bloc,', $xml, $blocs)) {
     1249                                        foreach (array_keys($blocs) as $_bloc) {
     1250                                                list(, $attributs) = spip_xml_decompose_tag($_bloc);
     1251                                                $blocs_inclus[] = $attributs['id'];
     1252                                        }
     1253                                }
     1254                                if ($blocs_inclus) {
     1255                                        $description['blocs_exclus'] = array_diff($options['blocs_defaut'], array_intersect($options['blocs_defaut'], $blocs_inclus));
     1256                                }
     1257
     1258                                // Liste des plugins nécessaires pour utiliser la page
     1259                                if (spip_xml_match_nodes(',^necessite,', $xml, $necessites)) {
     1260                                        $description['necessite'] = array();
     1261                                        foreach (array_keys($necessites) as $_necessite) {
     1262                                                list(, $attributs) = spip_xml_decompose_tag($_necessite);
     1263                                                $description['necessite'][] = $attributs['id'];
     1264                                        }
     1265                                }
     1266
     1267                                // Liste des héritages
     1268                                if (spip_xml_match_nodes(',^branche,', $xml, $branches)) {
     1269                                        $description['branche'] = array();
     1270                                        foreach (array_keys($branches) as $_branche) {
     1271                                                list(, $attributs) = spip_xml_decompose_tag($_branche);
     1272                                                $description['branche'][$attributs['type']] = $attributs['composition'];
     1273                                        }
     1274                                }
     1275                        }
     1276                }
     1277        } elseif (defined('_NOIZETIER_LISTER_PAGES_SANS_XML') ? _NOIZETIER_LISTER_PAGES_SANS_XML : false) {
     1278                // 1c- il est autorisé de ne pas avoir de fichier XML de configuration
     1279                // Ces pages sans XML sont toujours rechargées.
     1280                $description['icon'] = 'page_noxml-24.png';
     1281                $md5 = md5('_NOIZETIER_LISTER_PAGES_SANS_XML');
     1282        }
     1283
     1284        // Si la description est remplie c'est que le chargement a correctement eu lieu.
     1285        // Sinon, si la page n'a pas changée on renvoie une description limitée à un indicateur d'identité pour
     1286        // distinguer ce cas avec une erreur de chargement qui renvoie une description vide.
     1287        if ($description) {
     1288                // Mise à jour du md5
     1289                $description['signature'] = $md5;
     1290                // Identifie si la page est celle d'un objet SPIP
     1291                include_spip('base/objets');
     1292                $tables_objets = array_keys(lister_tables_objets_sql());
     1293                $description['est_page_objet'] = in_array(table_objet_sql($description_defaut['type']), $tables_objets) ? 'oui' : 'non';
     1294                // Complétude de la description avec les valeurs par défaut
     1295                $description = array_merge($description_defaut, $description);
     1296                // Sérialisation des champs blocs_exclus, necessite et branche qui sont des tableaux
     1297                $description['blocs_exclus'] = serialize($description['blocs_exclus']);
     1298                $description['necessite'] = serialize($description['necessite']);
     1299                $description['branche'] = serialize($description['branche']);
     1300        } elseif ($md5 == $options['md5']) {
     1301                $description['identique'] = true;
     1302        }
     1303
     1304        return $description;
     1305}
     1306
     1307
     1308function noizetier_page_blocs_autorises($page) {}
     1309
    10311310/**
    10321311 * Retourne la liste des pages, des compositions explicites et des compositions virtuelles.
    10331312 * Chaque page est fournie avec l'ensemble de sa configuration.
    10341313 * Si le plugin Compositions n'est pas actif, les compositions explicites ou virtuelles ne sont
    1035  * pas listées.
     1314 * pas retournées.
    10361315 *
    10371316 * @package SPIP\NOIZETIER\API\PAGE
     
    10451324 *              Tableau des pages, l'index est l'identifiant de la page.
    10461325 */
    1047 function noizetier_page_repertorier($filtres = array()) {
     1326function noizetier_page_repertorier($filtres = array(), $options = array()) {
    10481327        static $pages = null;
    10491328
    10501329        if (is_null($pages)) {
    1051                 // Choisir le bon répertoire des pages
    1052                 $options['repertoire_pages'] = noizetier_page_obtenir_dossier();
    1053 
    1054                 if ($options['repertoire_pages']) {
    1055                         // Initialiser les blocs par défaut
    1056                         $options['blocs_defaut'] = noizetier_bloc_defaut();
    1057 
    1058                         // On recherche en premier lieu les pages et les compositions explicites
    1059                         // -- on optimise la recherche si on a un filtre est_vrituelle à true inutile de récupérer les pages
    1060                         //    et compositions explicites
    1061                         if ($fichiers = find_all_in_path($options['repertoire_pages'], '.+[.]html$')) {
    1062                                 foreach ($fichiers as $_squelette => $_chemin) {
    1063                                         $page = basename($_squelette, '.html');
    1064                                         $dossier = dirname($_chemin);
    1065                                         $est_composition = noizetier_page_est_composition($page);
    1066                                         // Exclure certaines pages :
    1067                                         // -- celles du privé situes dans prive/contenu
    1068                                         // -- page liée au plugin Zpip en v1
    1069                                         // -- z_apl liée aux plugins Zpip v1 et Zcore
    1070                                         // -- les compositions explicites si le plugin Compositions n'est pas activé
    1071                                         if ((substr($dossier, -13) != 'prive/contenu')
    1072                                         and (($page != 'page') or !defined('_DIR_PLUGIN_Z'))
    1073                                         and (($page != 'z_apl') or (!defined('_DIR_PLUGIN_Z') and !defined('_DIR_PLUGIN_ZCORE')))
    1074                                         and (!$est_composition or ($est_composition     and defined('_DIR_PLUGIN_COMPOSITIONS')))) {
    1075                                                 if ($configuration = noizetier_page_informer($page, '', $options)) {
    1076                                                         // On n'inclue la page que si les plugins qu'elle nécessite explicitement dans son
    1077                                                         // fichier de configuration sont bien tous activés.
    1078                                                         // Rappel : si une page est incluse dans un plugin non actif elle ne sera pas détectée
    1079                                                         //          lors du find_all_in_path() puisque le plugin n'est pas dans le path SPIP.
    1080                                                         $page_a_garder = true;
    1081                                                         if (isset($configuration['necessite'])) {
    1082                                                                 foreach ($configuration['necessite'] as $plugin) {
    1083                                                                         if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
    1084                                                                                 $page_a_garder = false;
    1085                                                                                 break;
     1330                // Les compositions virtuelles sont insérées directement dans la table spip_noisettes_pages.
     1331                // Les pages et compositions explicites sont décrites par un fichier XML ou YAML et la description
     1332                // contenue dans le fichier est inséré dans la même stable spip_noisettes_pages.
     1333                // Pour savoir si il faut recharger la base et donc le tableau statique il faut vérifier que soit il n'y
     1334                // a aucune page ou composition explicite dans la table ou que l'option de rechargement est activée.
     1335
     1336                // Détermination des blocs par défaut
     1337                $blocs_defaut = noizetier_bloc_defaut();
     1338
     1339                // Lecture des pages et compositions explicites si elle existe
     1340                $select = array('spip_noisettes_pages');
     1341                $where = array('est_virtuelle=' . sql_quote('non'));
     1342                if ((sql_countsel($select, $where) > 0) and !$options['recharger']) {
     1343                        // A priori la liste est à jour en base de données, on peut donc lire toutes les pages et compositions
     1344                        // et stocker leur description dans le tableau statique.
     1345                        $configurations = sql_allfetsel('*', $select, '', '', array('type', 'composition'));
     1346
     1347                        // Mise au point du tableau issu de la base de données
     1348                        foreach ($configurations as $_configuration) {
     1349                                $configurations[$_configuration]['nom'] = _T_ou_typo($_configuration['nom']);
     1350                                $configurations[$_configuration]['description'] = _T_ou_typo($_configuration['nom']);
     1351                                $configurations[$_configuration]['blocs_exclus'] = $_configuration['blocs_exclus']
     1352                                        ? unserialize($_configuration['blocs_exclus'])
     1353                                        : array();
     1354                                if (!isset($_configuration['blocs_exclus'])) {
     1355                                        $configurations[$_configuration]['blocs'] = $blocs_defaut;
     1356                                } else {
     1357                                        $configurations[$_configuration]['blocs'] = array_diff($blocs_defaut, $_configuration['blocs_exclus']);
     1358                                }
     1359                                $configurations[$_configuration]['necessite'] = $_configuration['necessite']
     1360                                        ? unserialize($_configuration['necessite'])
     1361                                        : array();
     1362                                $configurations[$_configuration]['branche'] = $_configuration['branche']
     1363                                        ? unserialize($_configuration['branche'])
     1364                                        : array();
     1365                        }
     1366
     1367                        // Mise à jour du tableau statique des pages
     1368                        $pages = $configurations;
     1369                        $table_a_maj = false;
     1370                }
     1371                else {
     1372                        // Il faut recalculer les pages et les compositions explicites à partir de leurs fichiers XML ou YAML.
     1373                        // Les compositions virtuelles ne sont pas concernées car elles sont mise à jour directement en base.
     1374                        $options['recharger'] = true;
     1375                        $table_a_maj = true;
     1376                        // Choisir le bon répertoire des pages
     1377                        $options['repertoire_pages'] = noizetier_page_obtenir_dossier();
     1378                        if ($options['repertoire_pages']) {
     1379                                // Initialiser les blocs par défaut
     1380                                $options['blocs_defaut'] = $blocs_defaut;
     1381
     1382                                // On recherche les pages et les compositions explicites par le fichier HTML en premier
     1383                                // Si on le trouve, on récupère la configuration du fichier XML ou YAML.
     1384                                if ($fichiers = find_all_in_path($options['repertoire_pages'], '.+[.]html$')) {
     1385                                        foreach ($fichiers as $_squelette => $_chemin) {
     1386                                                $page = basename($_squelette, '.html');
     1387                                                $dossier = dirname($_chemin);
     1388                                                $est_composition = noizetier_page_est_composition($page);
     1389                                                // Exclure certaines pages :
     1390                                                // -- celles du privé situes dans prive/contenu
     1391                                                // -- page liée au plugin Zpip en v1
     1392                                                // -- z_apl liée aux plugins Zpip v1 et Zcore
     1393                                                // -- les compositions explicites si le plugin Compositions n'est pas activé
     1394                                                if ((substr($dossier, -13) != 'prive/contenu')
     1395                                                and (($page != 'page') or !defined('_DIR_PLUGIN_Z'))
     1396                                                and (($page != 'z_apl') or (!defined('_DIR_PLUGIN_Z') and !defined('_DIR_PLUGIN_ZCORE')))
     1397                                                and (!$est_composition or ($est_composition     and defined('_DIR_PLUGIN_COMPOSITIONS')))) {
     1398                                                        if ($configuration = noizetier_page_informer($page, '', $options)) {
     1399                                                                // On n'inclue la page que si les plugins qu'elle nécessite explicitement dans son
     1400                                                                // fichier de configuration sont bien tous activés.
     1401                                                                // Rappel : si une page est incluse dans un plugin non actif elle ne sera pas détectée
     1402                                                                //          lors du find_all_in_path() puisque le plugin n'est pas dans le path SPIP.
     1403                                                                $page_a_garder = true;
     1404                                                                if (isset($configuration['necessite'])) {
     1405                                                                        foreach ($configuration['necessite'] as $plugin) {
     1406                                                                                if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
     1407                                                                                        $page_a_garder = false;
     1408                                                                                        break;
     1409                                                                                }
    10861410                                                                        }
    10871411                                                                }
    1088                                                         }
    1089 
    1090                                                         if ($page_a_garder) {
    1091                                                                 $pages[$page] = $configuration;
     1412
     1413                                                                if ($page_a_garder) {
     1414                                                                        $pages[$page] = $configuration;
     1415                                                                }
    10921416                                                        }
    10931417                                                }
     
    10951419                                }
    10961420                        }
    1097 
    1098                         // Si le plugin Compositions est activé, on ajoute les compositions virtuelles
    1099                         // qui ne sont définies que dans une meta propre au noiZetier.
    1100                         // -- on optimise la recherche si on a un filtre est_virtuelle ou est_composition à false inutile de récupérer les
    1101                         //    compositions virtuelles du noiZetier
    1102                         if (defined('_DIR_PLUGIN_COMPOSITIONS')) {
    1103                                 include_spip('inc/config');
    1104                                 $options['compositions'] = lire_config('noizetier_compositions', array());
    1105                                 if ($options['compositions']) {
    1106                                         foreach ($options['compositions'] as $_composition => $_configuration) {
    1107                                                 if ($configuration = noizetier_page_informer($_composition, '', $options)) {
    1108                                                                 $pages[$_composition] = $configuration;
    1109                                                 }
    1110                                         }
    1111                                 }
    1112                         }
    1113 
    1114                         // Appel du pipeline noizetier_lister_pages pour éventuellement compléter ou modifier la liste
    1115                         $pages = pipeline('noizetier_lister_pages', $pages);
     1421                }
     1422
     1423                // Appel du pipeline noizetier_lister_pages pour éventuellement compléter ou modifier la liste des pages
     1424                $pages = pipeline('noizetier_lister_pages', $pages);
     1425
     1426                // Mise à jour de la table spip_noisettes_pages si on est en mode recalcul
     1427                if ($table_a_maj) {
     1428
    11161429                }
    11171430        }
     
    11981511                        $identifiants[1] = '';
    11991512                }
    1200                 $est_virtuelle = false;
     1513                $est_virtuelle = 'non';
    12011514
    12021515                // La recherche de la page est basée sur l'heuristique suivante:
     
    12491562                                        }
    12501563                                }
    1251                                 $description['blocs'] = $description['blocs'] ? array_intersect($options['blocs_defaut'], $blocs) : $options['blocs_defaut'];
     1564                                $description['blocs'] = $description['blocs'] ? array_intersect($options['blocs_defaut'], $description['blocs']) : $options['blocs_defaut'];
    12521565
    12531566                                // Liste des plugins nécessaires pour utiliser la page
     
    12971610                                        $description['blocs'] = array_diff($options['blocs_defaut'], $description['blocs_exclus']);
    12981611                                }
    1299                                 $est_virtuelle = true;
     1612                                $est_virtuelle = 'oui';
    13001613                        }
    13011614                }
     
    18332146        return true;
    18342147}
     2148
     2149function maj_noisettes_pages() {
     2150        include_spip('inc/config');
     2151        $compositions = lire_config('noizetier_compositions', array());
     2152        if ($compositions) {
     2153                $compositions_060 = array();
     2154                foreach ($compositions as $_page => $_composition) {
     2155                        $_composition['type'] = noizetier_page_type($_page);
     2156                        $_composition['composition'] = noizetier_page_composition($_page);
     2157                        if (empty($_composition['nom'])) {
     2158                                $_description['nom'] = $_page;
     2159                        }
     2160                        if (empty($_composition['icon'])) {
     2161                                $_composition['icon'] = 'composition-24.png';
     2162                        }
     2163                        $_composition['blocs_exclus'] = isset($_composition['blocs_exclus'])
     2164                                ? serialize($_composition['blocs_exclus'])
     2165                                : serialize(array());
     2166                        $_composition['necessite'] = isset($_composition['necessite'])
     2167                                ? serialize($_composition['necessite'])
     2168                                : serialize(array());
     2169                        $_composition['branche'] = isset($_composition['branche'])
     2170                                ? serialize($_composition['branche'])
     2171                                : serialize(array());
     2172                        include_spip('base/objets');
     2173                        $tables_objets = array_keys(lister_tables_objets_sql());
     2174                        $_composition['est_page_objet'] = in_array(table_objet_sql($_composition['type']), $tables_objets) ? 'oui' : 'non';
     2175                        $_composition['est_virtuelle'] = 'oui';
     2176                        $compositions_060[] = $_composition;
     2177                }
     2178                if ($compositions_060) {
     2179                        sql_insertq_multi('spip_noisettes_pages', $compositions_060);
     2180                }
     2181        }
     2182}
  • _plugins_/noizetier/trunk/noizetier_pipelines.php

    r104787 r104849  
    186186        // Récupération des compositions virtuelles du noiZetier afin de les injecter dans le pipeline
    187187        // étant donné qu'elles ne peuvent pas être détectées par Compositions car sans XML
    188         // -- filtre sur l'indicateur est_virtuelle qui n'est à vrai que pour les compositions
     188        // -- filtre sur l'indicateur est_virtuelle qui n'est à oui que pour les compositions
    189189        // -- filtre sur le type de contenu ou pas suivant l'appel
    190         $filtres = array('est_virtuelle' => true);
     190        $filtres = array('est_virtuelle' => 'oui');
    191191        if ($type) {
    192192                $filtres['type'] = $type;
  • _plugins_/noizetier/trunk/prive/squelettes/contenu/noizetier_pages.html

    r104759 r104849  
    77<ul class="liste-items liste-pages noizetier-liste-pages">
    88<BOUCLE_pages(DATA) {source table, #NOIZETIER_PAGE_INFOS}{est_page_objet?}{par cle}>
    9         <li class="item page[ virtuelle"(#VALEUR{est_virtuelle}|oui)]">
     9        <li class="item page[ virtuelle"(#VALEUR{est_virtuelle}|=={oui}|oui)]">
    1010                <div[ class="composition"(#VALEUR{composition}|oui)]>
    1111                        [(#REM) Informations de base sur la page ]
  • _plugins_/noizetier/trunk/prive/squelettes/navigation/noizetier_page.html

    r104759 r104849  
    1212                        #SET{informations, #NOIZETIER_PAGE_INFOS{#ENV{page}}}
    1313                        [(#ENV{page}|et{#GET{informations/composition}}|oui)
    14                                 [(#GET{informations/est_virtuelle}|?{
     14                                [(#GET{informations/est_virtuelle}|=={oui}|?{
    1515                                        #SET{explication, noizetier:explication_composition_virtuelle},
    1616                                        #SET{explication, noizetier:explication_composition}})]
     
    3333                                |icone_horizontale{<:noizetier:activer_composition:>, composition-set-24, '', #LANG_LEFT ajax})]
    3434                ]
    35                 [(#ENV{page}|et{#GET{informations/est_virtuelle}}|oui)
     35                [(#ENV{page}|et{#GET{informations/est_virtuelle}|=={oui}}|oui)
    3636                        [(#URL_ACTION_AUTEUR{supprimer_composition, #ENV{page}, #URL_ECRIRE{noizetier_pages}|parametre_url{est_page_objet, #GET{informations/est_page_objet}}}
    3737                                |icone_horizontale{<:noizetier:formulaire_supprimer_page:>, composition, del, #LANG_LEFT})]
Note: See TracChangeset for help on using the changeset viewer.