Changeset 110112 in spip-zone


Ignore:
Timestamp:
May 6, 2018, 12:42:47 PM (19 months ago)
Author:
eric@…
Message:

Suite du refactoring des API page, bloc, objet pour plus de cohérence avec les API de N-Core.
On en profite pour éviter de charger pleins de fonctions qui ne servent jamais dans le public. Ajout de balises.

Location:
_plugins_/noizetier/trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/noizetier/trunk/bloc_preview.html

    r109907 r110112  
    44[(#OBJET|?{
    55        #SET{informations, #NOIZETIER_OBJET_INFOS{#OBJET, #ID_OBJET}},
    6         #SET{informations, #GET{page}|noizetier_page_informer}
     6        #SET{informations, #NOIZETIER_PAGE_INFOS{#ENV{page}}
    77})]
    88
  • _plugins_/noizetier/trunk/formulaires/configurer_noizetier.html

    r104771 r110112  
    2222                        ne proposer que les types d'objet potentiellement utilisables ]
    2323                <div class="editer-groupe">
    24                 #SET{objets_exclus, #VAL|noizetier_objet_lister_exclusions}
    2524                [(#SAISIE{choisir_objets, objets_noisettes,
    2625                        label=<:noizetier:configurer_objets_noisettes_label:>,
    2726                        explication=<:noizetier:configurer_objets_noisettes_explication:>,
    28                         exclus=#GET{objets_exclus}})]
     27                        exclus=#ENV{_objets_exclus}})]
    2928                </div>
    3029
  • _plugins_/noizetier/trunk/formulaires/configurer_noizetier.php

    r109907 r110112  
    33if (!defined('_ECRIRE_INC_VERSION')) {
    44        return;
     5}
     6
     7
     8function formulaires_configurer_noizetier_charger_dist() {
     9
     10        // On récupère les valeurs configurées
     11        include_spip('inc/cvt_configurer');
     12        $valeurs = cvtconf_formulaires_configurer_recense('configurer_noizetier');
     13
     14        // Injecter les objets exclus
     15        include_spip('inc/noizetier_objet');
     16        $valeurs['_objets_exclus'] = noizetier_objet_lister_exclusions();
     17
     18        $valeurs['editable'] = true;
     19
     20        return $valeurs;
    521}
    622
  • _plugins_/noizetier/trunk/formulaires/editer_page.php

    r110110 r110112  
    4646
    4747        include_spip('inc/noizetier_page');
    48         $description_page = noizetier_page_informer($page, false);
     48        $description_page = noizetier_page_lire($page, false);
    4949        if ($description_page) {
    5050                if ($edition == 'modifier') {
  • _plugins_/noizetier/trunk/inc/noizetier_bloc.php

    r110110 r110112  
    1010
    1111/**
    12  * La liste des blocs par defaut d'une page peut etre modifiee via le pipeline noizetier_blocs_defaut.
     12 * Renvoie la liste par défaut des identifiants des blocs d'une page.
     13 * Cette liste peut être modifiée via le pipeline noizetier_blocs_defaut, en particulier pour
     14 * supprimer certains blocs pour l'ensemble des pages et objets.
    1315 *
    1416 * @api
     
    1820function noizetier_bloc_defaut() {
    1921
     22        // Stocker la liste des blocs par défaut pour éviter le recalcul sur le même hit.
    2023        static $blocs_defaut = null;
    2124
    2225        if (is_null($blocs_defaut)) {
    2326                if (defined('_DIR_PLUGIN_ZCORE') and !empty($GLOBALS['z_blocs'])) {
     27                        // Z en version v2
    2428                        $blocs_defaut = $GLOBALS['z_blocs'];
    25                 }
    26                 else {
     29                } else {
     30                        // Z en version v1
    2731                        $blocs_defaut = array('contenu', 'navigation', 'extra');
    2832                }
     
    3741
    3842/**
    39  * Retourne la description complète d'un bloc, de tous les blocs ou une information
    40  * particulière d'un bloc donné.
    41  * La description complète de chaque bloc est inscrite dans un fichier YAML nommé bloc.yaml
     43 * Retourne la description complète ou une information particulière d'un bloc donné.
     44 * La description complète du bloc est inscrite dans un fichier YAML nommé `bloc.yaml`
    4245 * stocké dans le dossier du bloc concerné.
    4346 *
     
    4548 *
    4649 * @param string $bloc
     50 *        Identifiant du bloc, à savoir, le nom du dossier sous Z.
    4751 * @param string $information
     52 *        Champ précis à renvoyer ou cha^ne vide pour renvoyer tous les champs de l'objet.
    4853 *
    4954 * @return array|string
     55 *         La description complète sous forme de tableau ou l'information précise demandée.
    5056 */
    51 function noizetier_bloc_informer($bloc = '', $information = '') {
     57function noizetier_bloc_lire($bloc, $information = '') {
    5258
    53         static $blocs = null;
    5459        static $description_bloc = array();
     60        $retour = $information ? '' : array();
    5561
    56         if ((!$bloc and is_null($blocs))
    57         or ($bloc and !isset($description_bloc[$bloc]))) {
    58                 // On détermine les blocs pour lesquels on retourne la description
    59                 $liste_blocs = $bloc ? array($bloc) : noizetier_bloc_defaut();
    60 
    61                 foreach ($liste_blocs as $_bloc) {
    62                         if ($fichier = find_in_path("${_bloc}/bloc.yaml")) {
    63                                 // Il y a un fichier YAML de configuration dans le répertoire du bloc
     62        if (in_array($bloc, noizetier_bloc_defaut())) {
     63                if (!isset($description_bloc[$bloc])) {
     64                        if ($fichier = find_in_path("${bloc}/bloc.yaml")) {
     65                                // Il y a un fichier YAML de configuration dans le répertoire du bloc, on le lit.
    6466                                include_spip('inc/yaml');
    6567                                if ($description = yaml_charger_inclusions(yaml_decode_file($fichier))) {
     
    7274                                        }
    7375                                }
    74                         } elseif (!defined('_DIR_PLUGIN_ZCORE') and in_array($_bloc, array('contenu', 'navigation', 'extra'))) {
     76                        } elseif (!defined('_DIR_PLUGIN_ZCORE')) {
    7577                                // Avec Zpip v1, les blocs sont toujours les mêmes : on en donne une description standard.
    7678                                $description = array(
    77                                         'nom' => _T("noizetier:nom_bloc_${_bloc}"),
    78                                         'description' => _T("noizetier:description_bloc_${_bloc}"),
    79                                         'icon' => "bloc-${_bloc}-24.png",
     79                                        'nom' => _T("noizetier:nom_bloc_${bloc}"),
     80                                        'description' => _T("noizetier:description_bloc_${bloc}"),
     81                                        'icon' => "bloc-${bloc}-24.png",
    8082                                );
    8183                        } else {
    8284                                // Aucune description, on renvoie juste le nom qui coincide avec l'identifiant du bloc
    83                                 $description = array('nom' => ucfirst($_bloc));
     85                                $description = array('nom' => ucfirst($bloc));
    8486                        }
     87
    8588                        // Sauvegarde de la description du bloc pour une consultation ultérieure dans le même hit.
    86                         if ($bloc) {
    87                                 $description_bloc[$_bloc] = $description;
    88                         } else {
    89                                 $blocs[$_bloc] = $description;
    90                         }
     89                        $description_bloc[$bloc] = $description;
    9190                }
    9291        }
    9392
    94         if ($bloc) {
     93        if (isset($description_bloc[$bloc])) {
    9594                if (!$information) {
    96                         return $description_bloc[$bloc];
    97                 } else {
    98                         return isset($description_bloc[$bloc][$information])
    99                                 ? $description_bloc[$bloc][$information]
    100                                 : '';
     95                        $retour = $description_bloc[$bloc];
     96                } elseif (isset($description_bloc[$bloc][$information])) {
     97                        $retour = $description_bloc[$bloc][$information];
    10198                }
    102         } else {
    103                 return $blocs;
    104         }
    105 }
    106 
    107 /**
    108  *
    109  * @filtre
    110  *
    111  * @param       $page
    112  * @param array $blocs_exclus
    113  *
    114  * @return array
    115  */
    116 function noizetier_bloc_lister($page, $blocs_exclus = array()) {
    117 
    118         // Initialisation des blocs avec la liste des blocs par défaut
    119         $blocs = noizetier_bloc_defaut();
    120 
    121         // Si la liste des blocs exclus n'a pas été passé en argument on les cherche dans la configuration
    122         // de la page
    123         if (!$blocs_exclus) {
    124                 $where = array('page=' . sql_quote($page));
    125                 $blocs_exclus = sql_getfetsel('blocs_exclus', 'spip_noizetier_pages', $where);
    126                 $blocs_exclus = unserialize($blocs_exclus);
    12799        }
    128100
    129         if ($blocs_exclus) {
    130                 $blocs = array_diff($blocs, $blocs_exclus);
    131                 sort($blocs);
    132         }
    133 
    134         return $blocs;
     101        return $retour;
    135102}
    136 
    137 /**
    138  * Renvoie le nombre de noisettes de chaque bloc configurables d'une page, d'une composition
    139  * ou d'un objet.
    140  *
    141  * @api
    142  * @filtre
    143  *
    144  * @param string $page_ou_objet
    145  *              L'identifiant de la page, de la composition ou de l'objet au format:
    146  *              - pour une page : type
    147  *              - pour une composition : type-composition
    148  *              - pour un objet : type_objet-id_objet
    149  *
    150  * @return array
    151  */
    152 function noizetier_bloc_compter_noisettes($page_ou_objet) {
    153 
    154         static $blocs_compteur = array();
    155 
    156         if (!isset($blocs_compteur[$page_ou_objet])) {
    157                 // Initialisation des compteurs par bloc
    158                 $nb_noisettes = array();
    159 
    160                 // Le nombre de noisettes par bloc doit être calculé par une lecture de la table spip_noisettes.
    161                 $from = array('spip_noisettes');
    162                 $select = array('bloc', "count(type_noisette) as 'noisettes'");
    163                 // -- Contruction du where identifiant précisément la page ou l'objet concerné
    164                 $identifiants = explode('-', $page_ou_objet);
    165                 if (isset($identifiants[1]) and ($id = intval($identifiants[1]))) {
    166                         // L'identifiant est celui d'un objet
    167                         $where = array('objet=' . sql_quote($identifiants[0]), 'id_objet=' . $id);
    168                 } else {
    169                         if (!isset($identifiants[1])) {
    170                                 // L'identifiant est celui d'une page
    171                                 $identifiants[1] = '';
    172                         }
    173                         $where = array('type=' . sql_quote($identifiants[0]), 'composition=' . sql_quote($identifiants[1]));
    174                 }
    175                 $group = array('bloc');
    176                 $compteurs = sql_allfetsel($select, $from, $where, $group);
    177                 if ($compteurs) {
    178                         // On formate le tableau [bloc] = nb noisettes
    179                         foreach ($compteurs as $_compteur) {
    180                                 $nb_noisettes[$_compteur['bloc']] = $_compteur['noisettes'];
    181                         }
    182                 }
    183                 $blocs_compteur[$page_ou_objet] = $nb_noisettes;
    184         }
    185 
    186         return (isset($blocs_compteur[$page_ou_objet]) ? $blocs_compteur[$page_ou_objet] : array());
    187 }
  • _plugins_/noizetier/trunk/inc/noizetier_objet.php

    r110110 r110112  
    1111
    1212/**
    13  * Lister les contenus ayant des noisettes spécifiquement configurées pour leur page.
     13 * Renvoie la description complète ou uniquement une information précise pour un objet donné.
     14 * Cette fonction est utilisable dans le public via la balise #NOIZETIER_OBJET_INFOS.
    1415 *
    1516 * @api
    16  * @filtre
    1717 *
    1818 * @param string $type_objet
     19 *        Type de l'objet comme `article`.
    1920 * @param string $id_objet
    20  *        Id de l'objet ou 0.
     21 *        Id de l'objet.
    2122 * @param string $information
    22  *        Champ précis à renvoyer ou chaine vide pour renvoyer toutes les champs de l'objet.
     23 *        Champ précis à renvoyer ou chaîne vide pour renvoyer toutes les champs de l'objet.
    2324 *
    24  * @return array|string
    25  *        Si le type et l'id du contenu sont fournis, on renvoie la description de la page de ce contenu.
    26  *        Sinon, on renvoie le tableau des descriptions des pages de tous les contenus indexés par [type_objet][id_objet].
     25 * @return mixed
     26 *         La description complète sous forme de tableau ou l'information précise demandée.
    2727 */
    2828function noizetier_objet_lire($type_objet, $id_objet, $information = '') {
     
    5858
    5959                // On rajoute les blocs du type de page dont l'objet est une instance
    60                 include_spip('inc/noizetier_bloc');
    61                 $description['blocs'] = noizetier_bloc_lister($type_objet);
     60                include_spip('inc/noizetier_page');
     61                $description['blocs'] = noizetier_page_lister_blocs($type_objet);
    6262
    6363                // On sauvegarde finalement la description complète.
     
    8181/**
    8282 * Lister les contenus ayant des noisettes spécifiquement configurées pour leur page.
     83 * Cette fonction est utilisable dans le public via la balise #NOIZETIER_OBJET_LISTE.
    8384 *
    8485 * @api
    85  * @filtre
    8686 *
    8787 * @param array $filtres
    88  *              Liste des champs sur lesquels appliquer les filtres des objets.
     88 *            Liste des champs sur lesquels appliquer les filtres des objets.
    8989 *
    9090 * @return array|string
    91  *              Si le type et l'id du contenu sont fournis, on renvoie la description de la page de ce contenu.
    92  *              Sinon, on renvoie le tableau des descriptions des pages de tous les contenus indexés par [type_objet][id_objet].
     91 *                 Tableau des descriptions de chaque objet trouvés. Ce tableau est éventuellement filtré sur
     92 *         un ou plusieurs champs de la description.
    9393 */
    9494function noizetier_objet_repertorier($filtres = array()) {
     
    133133
    134134/**
    135  * Renvoie la liste des types d'objet ne pouvant pas être personnaliser car ne possédant pas de page
    136  * détectable par le noiZetier.
     135 * Renvoie la liste des types d'objet ne pouvant pas être personnalisés car ne possédant pas
     136 * de page détectable par le noiZetier.
    137137 *
    138138 * @api
     
    167167
    168168/**
    169  * Détermine si un type d'objet est activé par configuration du noiZetier.
     169 * Détermine si un type d'objet est activé dans la configuration du noiZetier.
    170170 * Si oui, ses objets peuvent recevoir une configuration de noisettes.
    171171 *
  • _plugins_/noizetier/trunk/inc/noizetier_page.php

    r110110 r110112  
    158158 *
    159159 * @api
    160  * @filtre
    161160 *
    162161 * @uses noizetier_bloc_defaut()
     
    171170 * @return array
    172171 */
    173 function noizetier_page_informer($page, $traitement_typo = true) {
     172function noizetier_page_lire($page, $traitement_typo = true) {
    174173
    175174        static $description_page = array();
     
    193192                        $description['branche'] = unserialize($description['branche']);
    194193                        // Calcul des blocs
    195                         include_spip('inc/noizetier_bloc');
    196                         $description['blocs'] = noizetier_bloc_lister($page, $description['blocs_exclus']);
     194                        $description['blocs'] = noizetier_page_lister_blocs($page, $description['blocs_exclus']);
    197195                        $description_page[$traitement_typo][$page] = $description;
    198196                } else {
     
    204202}
    205203
     204
     205
     206/**
     207 *
     208 * @api
     209 *
     210 * @param       $page
     211 * @param array $blocs_exclus
     212 *
     213 * @return array
     214 */
     215function noizetier_page_lister_blocs($page, $blocs_exclus = array()) {
     216
     217        // Initialisation des blocs avec la liste des blocs par défaut
     218        include_spip('inc/noizetier_bloc');
     219        $blocs = noizetier_bloc_defaut();
     220
     221        // Si la liste des blocs exclus n'a pas été passé en argument on les cherche dans la configuration
     222        // de la page
     223        if (!$blocs_exclus) {
     224                $where = array('page=' . sql_quote($page));
     225                $blocs_exclus = sql_getfetsel('blocs_exclus', 'spip_noizetier_pages', $where);
     226                $blocs_exclus = unserialize($blocs_exclus);
     227        }
     228
     229        if ($blocs_exclus) {
     230                $blocs = array_diff($blocs, $blocs_exclus);
     231                sort($blocs);
     232        }
     233
     234        return $blocs;
     235}
     236
     237
    206238/**
    207239 * Renvoie le type d'une page à partir de son identifiant.
    208240 *
    209241 * @api
    210  * @filtre
    211242 *
    212243 * @param string $page
  • _plugins_/noizetier/trunk/inc/noizetier_type_noisette.php

    r110110 r110112  
    1111
    1212/**
     13 * Renvoie le nombre de types de noisettes disponibles pour une page ou une composition donnée en distinguant
     14 * les types de noisettes communs à toutes les pages, les types de noisettes spécifiques à un type de page et
     15 * les types de noisettes spécifiques à une composition.
     16 *
     17 * @api
    1318 * @filtre
    1419 *
    1520 * @param $page
     21 *        Identifiant de la page ou de la composition.
    1622 *
    1723 * @return array
     24 *         Tableau associatif des compteurs avec les index `commun`, `type`, `composition` et `total`.
    1825 */
    1926function noizetier_type_noisette_compter($page) {
  • _plugins_/noizetier/trunk/noizetier_autorisations.php

    r110110 r110112  
    9696        if (autoriser('noizetier')
    9797        and (is_array($options) and !empty($options))) {
    98                 if (!empty($options['page']) and ($configuration = noizetier_page_informer($options['page'], false))
     98                if (!empty($options['page']) and ($configuration = noizetier_page_lire($options['page'], false))
    9999                and (!$configuration['composition']
    100100                        or (defined('_DIR_PLUGIN_COMPOSITIONS')
     
    145145        if (autoriser('noizetier')
    146146        and (is_array($options) and !empty($options))
    147         and (!empty($options['page']) and ($configuration = noizetier_page_informer($options['page'], false))
     147        and (!empty($options['page']) and ($configuration = noizetier_page_lire($options['page'], false))
    148148        and !$configuration['composition'])
    149149        and ($configuration['est_page_objet'] == 'oui')
     
    179179        if (autoriser('noizetier')
    180180        and (is_array($options) and !empty($options))
    181         and (!empty($options['page']) and ($configuration = noizetier_page_informer($options['page'], false))
     181        and (!empty($options['page']) and ($configuration = noizetier_page_lire($options['page'], false))
    182182        and !$configuration['composition'])
    183183        and (defined('_DIR_PLUGIN_COMPOSITIONS'))
     
    210210        if (autoriser('noizetier')
    211211        and (is_array($options) and !empty($options))
    212         and (!empty($options['page']) and ($configuration = noizetier_page_informer($options['page'], false))
     212        and (!empty($options['page']) and ($configuration = noizetier_page_lire($options['page'], false))
    213213        and $configuration['composition'])
    214214        and ($configuration['est_virtuelle'] == 'oui')) {
     
    239239        include_spip('inc/noizetier_page');
    240240        if ((is_array($options) and !empty($options))
    241         and (!empty($options['page']) and ($configuration = noizetier_page_informer($options['page'], false))
     241        and (!empty($options['page']) and ($configuration = noizetier_page_lire($options['page'], false))
    242242        and ($configuration['est_virtuelle'] == 'oui'))
    243243        and autoriser('creercomposition', 'noizetier', $id, $qui,  array('page' => $configuration['type']))) {
     
    270270        if (autoriser('noizetier')
    271271        and (is_array($options) and !empty($options))
    272         and (!empty($options['page']) and ($configuration = noizetier_page_informer($options['page'], false))
     272        and (!empty($options['page']) and ($configuration = noizetier_page_lire($options['page'], false))
    273273        and $configuration['composition'])
    274274        and defined('_DIR_PLUGIN_COMPOSITIONS')) {
  • _plugins_/noizetier/trunk/noizetier_fonctions.php

    r110110 r110112  
    7777// ---------------------------- API BLOCS ----------------------------
    7878// -------------------------------------------------------------------
    79 include_spip('inc/noizetier_bloc');
     79
     80/**
     81 * Renvoie le nombre de noisettes de chaque bloc configurables d'une page, d'une composition
     82 * ou d'un objet.
     83 *
     84 * @api
     85 * @filtre
     86 *
     87 * @param string $page_ou_objet
     88 *              L'identifiant de la page, de la composition ou de l'objet au format:
     89 *              - pour une page : type
     90 *              - pour une composition : type-composition
     91 *              - pour un objet : type_objet-id_objet
     92 *
     93 * @return array
     94 */
     95function noizetier_bloc_compter_noisettes($page_ou_objet) {
     96
     97        static $blocs_compteur = array();
     98
     99        if (!isset($blocs_compteur[$page_ou_objet])) {
     100                // Initialisation des compteurs par bloc
     101                $nb_noisettes = array();
     102
     103                // Le nombre de noisettes par bloc doit être calculé par une lecture de la table spip_noisettes.
     104                $from = array('spip_noisettes');
     105                $select = array('bloc', "count(type_noisette) as 'noisettes'");
     106                // -- Construction du where identifiant précisément la page ou l'objet concerné
     107                $identifiants = explode('-', $page_ou_objet);
     108                if (isset($identifiants[1]) and ($id = intval($identifiants[1]))) {
     109                        // L'identifiant est celui d'un objet
     110                        $where = array('objet=' . sql_quote($identifiants[0]), 'id_objet=' . $id);
     111                } else {
     112                        if (!isset($identifiants[1])) {
     113                                // L'identifiant est celui d'une page
     114                                $identifiants[1] = '';
     115                        }
     116                        $where = array('type=' . sql_quote($identifiants[0]), 'composition=' . sql_quote($identifiants[1]));
     117                }
     118                $group = array('bloc');
     119                $compteurs = sql_allfetsel($select, $from, $where, $group);
     120                if ($compteurs) {
     121                        // On formate le tableau [bloc] = nb noisettes
     122                        foreach ($compteurs as $_compteur) {
     123                                $nb_noisettes[$_compteur['bloc']] = $_compteur['noisettes'];
     124                        }
     125                }
     126                $blocs_compteur[$page_ou_objet] = $nb_noisettes;
     127        }
     128
     129        return (isset($blocs_compteur[$page_ou_objet]) ? $blocs_compteur[$page_ou_objet] : array());
     130}
    80131
    81132// -------------------------------------------------------------------
    82133// ---------------------------- API PAGES ----------------------------
    83134// -------------------------------------------------------------------
    84 include_spip('inc/noizetier_page');
    85135
    86136
     
    88138// ---------------------------- API OBJETS ----------------------------
    89139// --------------------------------------------------------------------
    90 include_spip('inc/noizetier_objet');
    91140
    92141
     
    117166
    118167        // Détermination du répertoire par défaut
     168        include_spip('inc/noizetier_page');
    119169        $repertoire = ($entite == 'page') ? noizetier_page_repertoire() : 'noisettes/';
    120170
  • _plugins_/noizetier/trunk/noizetier_pipelines.php

    r110110 r110112  
    119119                                        $page = isset($contexte['type']) ? $contexte['type'] : (isset($contexte['type-page']) ? $contexte['type-page'] : '');
    120120                                        $page .= (isset($contexte['composition']) && $contexte['composition']) ? '-'.$contexte['composition'] : '';
    121                                         $blocs = noizetier_bloc_lister($page);
     121                                        $blocs = noizetier_page_lister_blocs($page);
    122122                                        if (isset($blocs[$bloc])) {
    123123                                                $complements = recuperer_fond('bloc_preview', $contexte, array('raw' => true));
  • _plugins_/noizetier/trunk/prive/squelettes/contenu/noizetier_objets.html

    r109831 r110112  
    55<B_objet_types>
    66<p><:noizetier:editer_noizetier_explication_objets:></p>
    7 <BOUCLE_objet_types(DATA) {source table, #NOIZETIER_OBJET_INFOS}{par cle}>
     7<BOUCLE_objet_types(DATA) {source table, #NOIZETIER_OBJET_LISTE}{par cle}>
    88<h3>[(#CLE|objet_info{texte_objet}|_T)]</h3>
    99<ul class="liste-items liste-pages noizetier-liste-objets">
  • _plugins_/noizetier/trunk/prive/squelettes/contenu/noizetier_page.html

    r110110 r110112  
    3535        <br class="clear" />
    3636        <h3><:noizetier:menu_blocs:></h3>
    37         #SET{blocs, #ENV{page, #OBJET}|noizetier_bloc_lister}
     37        #SET{blocs, #NOIZETIER_PAGE_INFOS{#ENV{page, #OBJET}}|table_valeur{blocs}}
    3838        #SET{bloc_affiche, #ENV{bloc}|sinon{#GET{blocs}|reset}}
    3939        <INCLURE{fond=prive/squelettes/inclure/inc-nav_blocs,
     
    4444        [(#REM) <!-- Liste configurable des noisettes du bloc affiché --> ]
    4545        <div class="ajax">
    46                 #FORMULAIRE_LISTER_NOISETTES_BLOC{#ENV{page, #ARRAY{objet,#OBJET,id_objet,#ID_OBJET}}, #GET{bloc_affiche}}
     46                #FORMULAIRE_LISTER_NOISETTES_BLOC{#ENV{page, #ARRAY{objet, #OBJET, id_objet, #ID_OBJET}}, #GET{bloc_affiche}}
    4747        </div>
    4848
  • _plugins_/noizetier/trunk/prive/squelettes/navigation/noizetier_page.html

    r110102 r110112  
    2222                        env} />
    2323        </BOUCLE_si_page>
    24                 #SET{informations, #NOIZETIER_OBJET_INFOS{#OBJET, #ID_OBJET}}
    2524                #SET{explication, noizetier:explication_objet}
    2625                <INCLURE{fond=prive/squelettes/inclure/inc-infos_page,
  • _plugins_/noizetier/trunk/public/noizetier_balises.php

    r110110 r110112  
    66
    77// Cette balise renvoie le tableau de la liste des objets possédant des noisettes configurées
    8 function balise_NOIZETIER_OBJET_INFOS_dist($p) {
    9         $objet = interprete_argument_balise(1, $p);
    10         if (isset($objet)) {
    11                 $objet = str_replace('\'', '"', $objet);
    12                 $id_objet = interprete_argument_balise(2, $p);
    13                 $id_objet = isset($id_objet) ? $id_objet : '0';
    14                 $information = interprete_argument_balise(3, $p);
    15                 $information = isset($information) ? str_replace('\'', '"', $information) : '""';
    16                 $p->code = "noizetier_objet_lire($objet, $id_objet, $information)";
    17         } else {
    18                 $p->code = "noizetier_objet_repertorier()";
    19         }
     8function balise_NOIZETIER_PAGE_INFOS_dist($p) {
     9
     10        // Récupération des arguments de la balise.
     11        // -- seul l'argument information est optionnel.
     12        $page = interprete_argument_balise(1, $p);
     13        $page = str_replace('\'', '"', $page);
     14        $information = interprete_argument_balise(3, $p);
     15        $information = isset($information) ? str_replace('\'', '"', $information) : '""';
     16
     17        // Calcul de la balise
     18        $p->code = "calculer_infos_page($page, $information)";
    2019
    2120        return $p;
    2221}
    2322
     23function calculer_infos_page($page, $information = '') {
    2424
    25 // Cette balise renvoie le tableau de la liste des blocs
     25        include_spip('inc/noizetier_page');
     26        return noizetier_page_lire($page, $information);
     27}
     28
     29// Cette balise renvoie le tableau de la liste des objets possédant des noisettes configurées
     30function balise_NOIZETIER_OBJET_INFOS_dist($p) {
     31
     32        // Récupération des arguments de la balise.
     33        // -- seul l'argument information est optionnel.
     34        $objet = interprete_argument_balise(1, $p);
     35        $objet = str_replace('\'', '"', $objet);
     36        $id_objet = interprete_argument_balise(2, $p);
     37        $id_objet = isset($id_objet) ? $id_objet : '0';
     38        $information = interprete_argument_balise(3, $p);
     39        $information = isset($information) ? str_replace('\'', '"', $information) : '""';
     40
     41        // Calcul de la balise
     42        $p->code = "calculer_infos_objet($objet, $id_objet, $information)";
     43
     44        return $p;
     45}
     46
     47function calculer_infos_objet($objet, $id_objet, $information = '') {
     48
     49        include_spip('inc/noizetier_objet');
     50        return noizetier_objet_lire($objet, $id_objet, $information);
     51}
     52
     53
     54// Cette balise renvoie le tableau de la liste des objets possédant des noisettes configurées
     55function balise_NOIZETIER_OBJET_LISTE_dist($p) {
     56
     57        // Aucun argument à la balise.
     58        $p->code = "calculer_liste_objets()";
     59
     60        return $p;
     61}
     62
     63function calculer_liste_objets() {
     64
     65        include_spip('inc/noizetier_objet');
     66        return noizetier_objet_repertorier();
     67}
     68
     69
     70// Cette balise renvoie la description complète ou l'info donnée d'un bloc
    2671function balise_NOIZETIER_BLOC_INFOS_dist($p) {
    2772        $bloc = interprete_argument_balise(1, $p);
    28         if (isset($bloc)) {
    29                 $bloc = str_replace('\'', '"', $bloc);
    30                 $information = interprete_argument_balise(2, $p);
    31                 $information = isset($information) ? str_replace('\'', '"', $information) : '""';
    32                 $p->code = "calculer_infos_bloc($bloc, $information)";
    33         } else {
    34                 $p->code = "calculer_infos_bloc()";
    35         }
     73        $bloc = str_replace('\'', '"', $bloc);
     74        $information = interprete_argument_balise(2, $p);
     75        $information = isset($information) ? str_replace('\'', '"', $information) : '""';
     76        $p->code = "calculer_infos_bloc($bloc, $information)";
    3677
    3778        return $p;
     
    4182
    4283        include_spip('inc/noizetier_bloc');
    43         return noizetier_bloc_informer($bloc, $information);
     84        return noizetier_bloc_lire($bloc, $information);
    4485}
    4586
Note: See TracChangeset for help on using the changeset viewer.