Changeset 104893 in spip-zone


Ignore:
Timestamp:
Jun 18, 2017, 4:30:08 PM (2 years ago)
Author:
eric@…
Message:

Renommage de la fonction page_informer afin d'en créer une nouvelle utilisant les informations en base.
Mise au point de la création des compositions virtuelles en base.
Ainsi toutes les pages sont dans la table spip_noizetier_pages.
Reste à décider comment on gère le _T_ou_typo() sur les champs nom et description ainsi que le unserialize() sur les champs array.

Location:
_plugins_/noizetier/trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/noizetier/trunk/formulaires/editer_page.php

    r104759 r104893  
    55}
    66
    7 // TODO : à quoi ça sert vraiement?
     7// TODO : à quoi ça sert vraiment?
    88if (!function_exists('autoriser')) {
    99        include_spip('inc/autoriser');
     
    4545        );
    4646
     47        // TODO : _T_ou_typo sur nom et description ???
    4748        if ($edition == 'modifier') {
    4849                // La page désignée par $page est déjà une composition virtuelle dont on souhaite modifier une
     
    102103
    103104/**
    104  * @param        $edition
    105  * @param        $description_page
     105 * @param string $edition
     106 *              Type d'édition à savoir :
     107 *              - `modifier`: édition de la configuration de base d'une composition virtuelle
     108 *              - `créer`: création d'une composition virtuelle à partir d'une page source
     109 *              - `dupliquer`: copie d'une composition pour créer une nouvelle composition virtuelle
     110 * @param array  $description_page
     111 *              La configuration complète d'une page ou composition :
     112 *              - `modifier`: la description de la composition virtuelle en cours d'édition
     113 *              - `créer`: la description de la page source
     114 *              - `dupliquer`: la description de la composition source
    106115 * @param string $redirect
     116 *              URL de redirection. La valeur dépend du type d'édition.
    107117 *
    108118 * @return array
     
    126136
    127137                include_spip('noizetier_fonctions');
    128                 $pages = noizetier_page_repertorier();
    129                 if (isset($pages[$type_page.'-'.$composition]) and is_array($pages[$type_page.'-'.$composition])) {
     138                // TODO : réduire la recherche aux compositions
     139                $pages = sql_allfetsel('page', 'spip_noizetier_pages');
     140                if (is_array($pages)) {
     141                        $pages = array_map('reset', $pages);
     142                }
     143                if (isset($pages[$type_page.'-'.$composition])) {
    130144                        $erreurs['composition'] = _T('noizetier:formulaire_identifiant_deja_pris');
    131145                }
     
    139153
    140154/**
    141  * @param        $edition
    142  * @param        $description_page
     155 *
     156 *
     157 * @param string $edition
     158 *              Type d'édition à savoir :
     159 *              - `modifier`: édition de la configuration de base d'une composition virtuelle
     160 *              - `créer`: création d'une composition virtuelle à partir d'une page source
     161 *              - `dupliquer`: copie d'une composition pour créer une nouvelle composition virtuelle
     162 * @param array  $description_page
     163 *              La configuration complète d'une page ou composition :
     164 *              - `modifier`: la description de la composition virtuelle en cours d'édition
     165 *              - `créer`: la description de la page source
     166 *              - `dupliquer`: la description de la composition source
    143167 * @param string $redirect
     168 *              URL de redirection. La valeur dépend du type d'édition.
    144169 *
    145170 * @return array
     
    148173
    149174        $retour = array();
     175        $description = array();
    150176
    151177        // Identifiant de la composition résultante.
    152         // -- on le recalcule systématiquement même si pour une modification il correspond à $page
    153178        $type_page = _request('type_page');
    154179        $composition = _request('composition');
    155180        $identifiant = "${type_page}-${composition}";
    156181
    157         // Mise à jour ou création des données de base de la composition virtuelle résultante
    158         include_spip('inc/config');
    159         $compositions_virtuelles = lire_config('noizetier_compositions', array());
    160         $compositions_virtuelles[$identifiant] = array(
    161                 'nom' => _request('nom'),
    162                 'description' => _request('description'),
    163                 'icon' => _request('icon'),
    164         );
     182        // Récupération des champs descriptifs et de l'icone.
     183        $description['nom'] = _request('nom');
     184        $description['description'] = _request('description');
     185        $description['icon'] = _request('icon');
    165186
    166187        // Traitement des blocs configurables
    167188        $blocs_exclus = _request('blocs_exclus');
    168         if ($blocs_exclus) {
    169                 $compositions_virtuelles[$identifiant]['blocs_exclus'] = $blocs_exclus;
    170                 // TODO : si on exclut des blocs il faut supprimer leurs éventuelles noisettes.
    171                 // Une autre solution serait d'interdire l'exclusion d'un bloc contenant une noisette
    172         }
     189        $description['blocs_exclus'] = $blocs_exclus;
     190        // TODO : si on exclut des blocs il faut supprimer leurs éventuelles noisettes.
     191        // Une autre solution serait d'interdire l'exclusion d'un bloc contenant une noisette
    173192
    174193        // Traitement des branches éventuelles pour la composition virtuelle résultante
     
    180199                }
    181200        }
    182         $compositions_virtuelles[$identifiant]['branche'] = $branche;
    183 
    184         // Mise à jour de la composition virtuelle dans la meta
    185         ecrire_config('noizetier_compositions', serialize($compositions_virtuelles));
    186 
    187         // Pour une modification, le traitement s'arrête ici.
     201        $description['branche'] = $branche;
     202
    188203        if ($edition != 'modifier') {
     204                // Initialisation de la description pour une composition virtuelle.
     205                $description_defaut = array(
     206                        'page'           => $identifiant,
     207                        'type'           => $type_page,
     208                        'composition'    => $composition,
     209                        'nom'            => $identifiant,
     210                        'description'    => '',
     211                        'icon'           => 'page-24.png',
     212                        'blocs_exclus'   => array(),
     213                        'necessite'      => array(),
     214                        'branche'        => array(),
     215                        'est_virtuelle'  => 'oui',
     216                        'est_page_objet' => 'non',
     217                        'signature'      => '',
     218                );
     219
     220                // Identifie si la page est celle d'un objet SPIP
     221                include_spip('base/objets');
     222                $tables_objets = array_keys(lister_tables_objets_sql());
     223                $description['est_page_objet'] = in_array(table_objet_sql($type_page), $tables_objets) ? 'oui' : 'non';
     224
     225                // Complétude de la description avec les valeurs par défaut
     226                $description = array_merge($description_defaut, $description);
     227        }
     228
     229        // On termine en sérialisant les tableaux des blocs exclus, necessite et branche.
     230        $description['blocs_exclus'] = serialize($description['blocs_exclus']);
     231        $description['branche'] = serialize($description['branche']);
     232        if (isset($description['necessite'])) {
     233                $description['necessite'] = serialize($description['necessite']);
     234        }
     235
     236        // Mise ou insertion de la composition virtuelle
     237        if ($edition == 'modifier') {
     238                // -- Update de la compositon modifiée
     239                $where = array('page=' . sql_quote($identifiant));
     240                $retour_sql = sql_updateq('spip_noizetier_pages', $description, $where);
     241        } else {
     242                // -- Insertion de la nouvelle composition
     243                $retour_sql = sql_insertq('spip_noizetier_pages', $description);
     244
    189245                // Pour une création ou un duplication, il faut traiter le peuplement automatique des noisettes
    190246                // de la page source si requis.
    191247                // -- on préremplit avec les noisettes de la page source, systématiquement en cas de duplication
    192248                //    ou si demandé, en cas de création.
    193                 if (($type_page != 'page')
    194                 and (($edition == 'dupliquer') or (($edition == 'creer') and _request('peupler')))) {
    195                         // Récupération des noisettes de la page source
    196                         $select = array('rang', 'type', 'composition', 'bloc', 'noisette', 'parametres');
    197                         $from = 'spip_noisettes';
    198                         $where = array('type=' . sql_quote($type_page), 'composition=' . sql_quote($description_page['composition']));
    199                         $noisettes_source = sql_allfetsel($select, $from, $where);
    200                         // Injection des noisettes de la source dans la composition virtuelle en cours de création qui diffère
    201                         // uniquement par l'identifiant de composition.
    202                         if ($noisettes_source) {
    203                                 foreach ($noisettes_source as $_index => $_noisette) {
    204                                         $noisettes_source[$_index]['composition'] = $composition;
     249                if ($retour_sql) {
     250                        if (($type_page != 'page')
     251                        and (($edition == 'dupliquer') or (($edition == 'creer') and _request('peupler')))) {
     252                                // Récupération des noisettes de la page source
     253                                $select = array('rang', 'type', 'composition', 'bloc', 'noisette', 'parametres');
     254                                $from = 'spip_noisettes';
     255                                $where = array('type=' . sql_quote($type_page), 'composition=' . sql_quote($description_page['composition']));
     256                                $noisettes_source = sql_allfetsel($select, $from, $where);
     257                                // Injection des noisettes de la source dans la composition virtuelle en cours de création qui diffère
     258                                // uniquement par l'identifiant de composition.
     259                                if ($noisettes_source) {
     260                                        foreach ($noisettes_source as $_index => $_noisette) {
     261                                                $noisettes_source[$_index]['composition'] = $composition;
     262                                        }
     263                                        sql_insertq_multi($from, $noisettes_source);
    205264                                }
    206                                 sql_insertq_multi($from, $noisettes_source);
    207265                        }
    208                 }
    209 
    210                 // On invalide le cache en cas de création ou  de dpulication
    211                 include_spip('inc/invalideur');
    212                 suivre_invalideur("id='page/$identifiant'");
    213         }
    214 
    215         $retour['message_ok'] = _T('noizetier:formulaire_composition_mise_a_jour');
    216         if (in_array($edition, array('creer', 'dupliquer'))) {
    217                 $retour['redirect'] = $redirect;
    218         } elseif ($redirect) {
    219                 if (strncmp($redirect, 'javascript:', 11) == 0) {
    220                         $retour['message_ok'] .= '<script type="text/javascript">/*<![CDATA[*/'.substr($redirect, 11).'/*]]>*/</script>';
    221                         $retour['editable'] = true;
    222                 } else {
     266
     267                        // On invalide le cache en cas de création ou  de duplication
     268                        include_spip('inc/invalideur');
     269                        suivre_invalideur("id='page/$identifiant'");
     270                }
     271        }
     272
     273        if ($retour_sql === false) {
     274                $retour['message_nok'] = _T('noizetier:formulaire_composition_erreur');
     275        } else {
     276                $retour['message_ok'] = _T('noizetier:formulaire_composition_mise_a_jour');
     277                if (in_array($edition, array('creer', 'dupliquer'))) {
    223278                        $retour['redirect'] = $redirect;
     279                } elseif ($redirect) {
     280                        if (strncmp($redirect, 'javascript:', 11) == 0) {
     281                                $retour['message_ok'] .= '<script type="text/javascript">/*<![CDATA[*/'.substr($redirect, 11).'/*]]>*/</script>';
     282                                $retour['editable'] = true;
     283                        } else {
     284                                $retour['redirect'] = $redirect;
     285                        }
    224286                }
    225287        }
  • _plugins_/noizetier/trunk/lang/noizetier_fr.php

    r104774 r104893  
    7171        'formulaire_composition_explication' => 'Mot-clé unique (minuscules, sans espace, sans tiret et sans accent) permettant d’identifier la composition.',
    7272        'formulaire_composition_mise_a_jour' => 'Composition mise à jour',
     73        'formulaire_composition_erreur' => 'Requête non aboutie pour la composition',
    7374        'formulaire_configurer_bloc' => 'Configurer le bloc :',
    7475        'formulaire_configurer_page' => 'Configurer la page :',
  • _plugins_/noizetier/trunk/noizetier_fonctions.php

    r104888 r104893  
    13131313}
    13141314
    1315 function noizetier_page_lister_blocs($page) {
    1316 
     1315function noizetier_page_lister_blocs($page, $blocs_exclus = array()) {
     1316
     1317        // Initialisation des blocs avec la liste des blocs par défaut
    13171318        $blocs = noizetier_bloc_defaut();
    1318         $where = array('page=' . sql_quote($page));
    1319         if ($blocs_exclus = sql_getfetsel('blocs_exclus', 'spip_noizetier_pages', $where)) {
    1320                 $blocs = array_diff($blocs, unserialize($blocs_exclus));
     1319
     1320        // Si la liste des blocs exclus n'a pas été passé en argument on les cherche dans la configuration
     1321        // de la page
     1322        if (!$blocs_exclus) {
     1323                $where = array('page=' . sql_quote($page));
     1324                $blocs_exclus = sql_getfetsel('blocs_exclus', 'spip_noizetier_pages', $where);
     1325                $blocs_exclus = unserialize($blocs_exclus);
     1326        }
     1327
     1328        if ($blocs_exclus) {
     1329                $blocs = array_diff($blocs, $blocs_exclus);
    13211330                sort($blocs);
    13221331        }
     
    13241333        return $blocs;
    13251334}
     1335
     1336/**
     1337 * Retourne la configuration de la page, de la composition explicite ou de la composition virtuelle demandée.
     1338 * La configuration est stockée en base de données, certains champs sont recalculés avant d'être fournis.
     1339 *
     1340 * @uses noizetier_bloc_defaut()
     1341
     1342 * @package SPIP\NOIZETIER\API\PAGE
     1343 * @api
     1344 * @filtre
     1345 *
     1346 * @param string        $page
     1347 *              Identifiant de la page ou de la composition.
     1348 *
     1349 * @return array
     1350 */
     1351function noizetier_page_informer($page) {
     1352
     1353        static $description_page = array();
     1354
     1355        if (!isset($description_page[$page])) {
     1356                // Chargement de toute la configuration de la page en base de données.
     1357                $description = sql_fetsel('*', 'spip_noizetier_pages', array('page=' . sql_quote($page)));
     1358
     1359                // Sauvegarde de la description de la page pour une consultation ultérieure dans le même hit.
     1360                if ($description) {
     1361                        // TODO : faut-il rajouter le _T_ou_typo sur les champs concernés ?
     1362                        // Traitements des champs sérialisés
     1363                        $description['blocs_exclus'] = unserialize($description['blocs_exclus']);
     1364                        $description['necessite'] = unserialize($description['necessite']);
     1365                        $description['branche'] = unserialize($description['branche']);
     1366                        // Calcul des blocs
     1367                        $description['blocs'] = noizetier_page_lister_blocs($page, $description['blocs_exclus']);
     1368                        $description_page[$page] = $description;
     1369                } else {
     1370                        $description_page[$page] = array();
     1371                }
     1372        }
     1373
     1374        return $description_page[$page];
     1375}
     1376
     1377
     1378/**
     1379 * Renvoie le type d'une page à partir de son identifiant.
     1380 *
     1381 * @package SPIP\NOIZETIER\API\PAGE
     1382 * @api
     1383 * @filtre
     1384 *
     1385 * @param string $page
     1386 *              L'identifiant de la page.
     1387 *
     1388 * @return string
     1389 *              Le type de la page choisie, c'est-à-dire:
     1390 *              - soit l'identifiant complet de la page,
     1391 *              - soit le mot précédent le tiret dans le cas d'une composition.
     1392 */
     1393function noizetier_page_type($page) {
     1394        $type = explode('-', $page, 2);
     1395
     1396        return $type[0];
     1397}
     1398
     1399/**
     1400 * Détermine, à partir de son identifiant, la composition d'une page si elle existe.
     1401 *
     1402 * @package SPIP\NOIZETIER\API\PAGE
     1403 * @api
     1404 * @filtre
     1405 *
     1406 * @param string $page
     1407 *              L'identifiant de la page.
     1408 *
     1409 * @return string
     1410 *      La composition de la page choisie, à savoir, le mot suivant le tiret,
     1411 *              ou la chaine vide sinon.
     1412 */
     1413function noizetier_page_composition($page) {
     1414        $composition = explode('-', $page, 2);
     1415        $composition = isset($composition[1]) ? $composition[1] : '';
     1416
     1417        return $composition;
     1418}
     1419
     1420/**
     1421 * Détermine, à partir de son identifiant, si la page est une composition.
     1422 *
     1423 * @package SPIP\NOIZETIER\API\PAGE
     1424 * @api
     1425 * @filtre
     1426 *
     1427 * @param string $page
     1428 *              L'identifiant de la page.
     1429 *
     1430 * @return boolean
     1431 *      `true` si la page est une composition, `false` sinon.
     1432 */
     1433function noizetier_page_est_composition($page) {
     1434        $est_composition = false;
     1435        if (strpos($page, '-') !== false) {
     1436                $est_composition = true;
     1437        }
     1438
     1439        return $est_composition;
     1440}
     1441
     1442
     1443
     1444/**
     1445 * Détermine si les compositions sont possibles sur un type de page.
     1446 *
     1447 * @package SPIP\NOIZETIER\API\OBJET
     1448 * @api
     1449 * @filtre
     1450 *
     1451 * @param string $type
     1452 *              Identifiant du type de page.
     1453 *
     1454 * @return boolean
     1455 *              True si les compositions sont autorisées, false sinon.
     1456 */
     1457function noizetier_page_composition_activee($type) {
     1458
     1459        $est_activee = false;
     1460
     1461        if (defined('_DIR_PLUGIN_COMPOSITIONS')) {
     1462                include_spip('compositions_fonctions');
     1463                if (in_array($type, compositions_objets_actives())) {
     1464                        $est_activee = true;
     1465                }
     1466        }
     1467
     1468        return $est_activee;
     1469}
     1470
     1471
     1472/**
     1473 * Déterminer le répertoire dans lequel le NoiZetier peut lister les pages pouvant supporter
     1474 * l'insertion de noisettes.
     1475 *
     1476 * @package SPIP\NOIZETIER\API\PAGE
     1477 * @api
     1478 * @filtre
     1479 *
     1480 * @return string
     1481 *              Le répertoire des pages sous la forme dossier/.
     1482 */
     1483function noizetier_page_obtenir_dossier() {
     1484
     1485        if (defined('_NOIZETIER_REPERTOIRE_PAGES')) {
     1486                $repertoire_pages = _NOIZETIER_REPERTOIRE_PAGES;
     1487        }
     1488        elseif (isset($GLOBALS['z_blocs'])) {
     1489                $premier_bloc = reset($GLOBALS['z_blocs']);
     1490                $repertoire_pages = "$premier_bloc/";
     1491        } else {
     1492                $repertoire_pages = 'contenu/';
     1493        }
     1494
     1495        return $repertoire_pages;
     1496}
     1497
     1498
     1499// --------------------------------------------------------------------
     1500// ---------------------------- API OBJETS ----------------------------
     1501// --------------------------------------------------------------------
     1502
     1503/**
     1504 * Lister les objets ayant des noisettes spéciquement configurées pour leur page.
     1505 *
     1506 * @package SPIP\NOIZETIER\API\OBJET
     1507 * @api
     1508 * @filtre
     1509 *
     1510 * @param string $objet
     1511 *              Type d'objet ou chaine vide.
     1512 * @param string $id_objet
     1513 *              Id de l'objet ou 0.
     1514 *
     1515 * @return array|string
     1516 *              Si le type et l'id de l'objet sont fournis, on renvoie la description de la page de cet objet.
     1517 *              Sinon, on renvoie le tableau de toutes les objets sous la forme [type_objet][id_objet].
     1518 */
     1519function noizetier_objet_informer($type_objet = '', $id_objet = 0, $information = '') {
     1520        static $objets = null;
     1521        static $description_objet = array();
     1522
     1523        if ((!$type_objet and !$id_objet and is_null($objets))
     1524        or ($type_objet and $id_objet and !isset($description_objet[$type_objet][$id_objet]))) {
     1525                // On récupère le ou les objets ayant des noisettes dans la table spip_noisettes.
     1526                $from = array('spip_noisettes');
     1527                $select = array('objet', 'id_objet', "count(noisette) as 'noisettes'");
     1528                $where = array('id_objet>0');
     1529                if ($type_objet and $id_objet) {
     1530                        $where = array('objet=' . sql_quote($type_objet), 'id_objet=' . intval($id_objet));
     1531                }
     1532                $group = array('objet', 'id_objet');
     1533                $objets_configures = sql_allfetsel($select, $from, $where, $group);
     1534                if ($objets_configures) {
     1535                        include_spip('inc/quete');
     1536                        include_spip('base/objets');
     1537                        foreach ($objets_configures as $_objet) {
     1538                                $description = array();
     1539                                // On calcule le titre de l'objet à partir de la fonction idoine
     1540                                $description['titre'] = generer_info_entite($_objet['id_objet'], $_objet['objet'], 'titre');
     1541                                // On recherche le logo de l'objet si il existe sinon on stocke le logo du type d'objet
     1542                                // (le chemin complet)
     1543                                $description['logo'] = '';
     1544                                if ($_objet['objet'] != 'document') {
     1545                                        $logo_infos = quete_logo(id_table_objet($_objet['objet']), 'on', $_objet['id_objet'], 0, false);
     1546                                        $description['logo'] = isset($logo_infos['src']) ? $logo_infos['src'] : '';
     1547                                }
     1548                                if (!$description['logo']) {
     1549                                        $description['logo'] = noizetier_icone_chemin("{$_objet['objet']}.png");
     1550                                }
     1551                                $description['noisettes'] = $_objet['noisettes'];
     1552
     1553                                // On rajoute les blocs du type de page dont l'objet est une instance et on sauvegarde
     1554                                // la description complète.
     1555                                if ($type_objet and $id_objet) {
     1556                                        $description['blocs'] = noizetier_page_lister_blocs($type_objet);
     1557                                        $description_objet[$type_objet][$id_objet] = $description;
     1558                                } else {
     1559                                        $description['blocs'] = noizetier_page_lister_blocs($_objet['objet']);
     1560                                        $objets[$_objet['objet']][$_objet['id_objet']] = $description;
     1561                                }
     1562                        }
     1563                }
     1564        }
     1565
     1566        if ($type_objet and $id_objet) {
     1567                if (!$information) {
     1568                        return isset($description_objet[$type_objet][$id_objet])
     1569                                ? $description_objet[$type_objet][$id_objet]
     1570                                : array();
     1571                } else {
     1572                        return isset($description_objet[$type_objet][$id_objet][$information])
     1573                                ? $description_objet[$type_objet][$id_objet][$information]
     1574                                : '';
     1575                }
     1576        } else {
     1577                // Filtrage des objets répertoriés:
     1578                // - de façon systématique, on ne retient que les objets dont le type est activé dans la configuration du plugin.
     1579                $objets_repertories = $objets;
     1580                foreach ($objets_repertories as $_type_objet => $_objets) {
     1581                        if (!noizetier_objet_type_active($_type_objet)) {
     1582                                unset($objets_repertories[$_type_objet]);
     1583                        }
     1584                }
     1585                return $objets_repertories;
     1586        }
     1587}
     1588
     1589
     1590/**
     1591 * Renvoie la liste des types d'objet ne pouvant pas être personnaliser car ne possédant pas de page
     1592 * détectable par le noiZetier.
     1593 *
     1594 * @package SPIP\NOIZETIER\API\OBJET
     1595 * @api
     1596 * @filtre
     1597 *
     1598 * @return array|null
     1599 */
     1600function noizetier_objet_lister_exclusions() {
     1601
     1602        static $exclusions = null;
     1603
     1604        if (is_null($exclusions)) {
     1605                $exclusions = array();
     1606                include_spip('base/objets');
     1607
     1608                // On récupère les tables d'objets sous la forme spip_xxxx.
     1609                $tables = lister_tables_objets_sql();
     1610                $tables = array_keys($tables);
     1611
     1612                // On récupère la liste des pages disponibles et on transforme le type d'objet en table SQL.
     1613                $filtres = array('est_composition' => false, 'est_page_objet' => 'oui');
     1614                $pages = noizetier_page_repertorier($filtres);
     1615                $pages = array_keys($pages);
     1616                $pages = array_map('table_objet_sql', $pages);
     1617
     1618                // On exclut donc les tables qui ne sont pas dans la liste issues des pages.
     1619                $exclusions = array_diff($tables, $pages);
     1620        }
     1621
     1622        return $exclusions;
     1623}
     1624
     1625
     1626/**
     1627 * Détermine si un type d'objet est activé par configuration du noiZetier.
     1628 * Si oui, ses objets peuvent recevoir une configuration de noisettes.
     1629 *
     1630 * @package SPIP\NOIZETIER\API\OBJET
     1631 * @api
     1632 * @filtre
     1633 *
     1634 * @param string $type_objet
     1635 *              Type d'objet SPIP comme article, rubrique...
     1636 *
     1637 * @return boolean
     1638 *              True si le type d'objet est activé, false sinon.
     1639 */
     1640function noizetier_objet_type_active($type_objet) {
     1641
     1642        $est_active = false;
     1643
     1644        include_spip('inc/config');
     1645        $tables_actives = lire_config('noizetier/objets_noisettes', array());
     1646        if ($tables_actives and in_array($type_objet, array_map('objet_type', $tables_actives))) {
     1647                $est_active = true;
     1648        }
     1649
     1650        return $est_active;
     1651}
     1652
     1653
     1654include_spip('public/noizetier_balises');
     1655
     1656
     1657// -------------------------------------------------------------------
     1658// API NOISETTES OBSOLETE : A VIRER A TERME
     1659// -------------------------------------------------------------------
     1660/**
     1661 * Lister les noisettes disponibles dans les dossiers noisettes/.
     1662 *
     1663 * @staticvar array $liste_noisettes
     1664 *
     1665 * @param string $type     renvoyer seulement un type de noisettes
     1666 * @param string $noisette renvoyer spécifiquement une noisette données
     1667 *
     1668 * @return array
     1669 */
     1670function noizetier_lister_noisettes($type = 'tout') {
     1671        static $liste_noisettes = array();
     1672        if ($type == 'tout') {
     1673                return noizetier_obtenir_infos_noisettes();
     1674        }
     1675        if (isset($liste_noisettes[$type])) {
     1676                return $liste_noisettes[$type];
     1677        }
     1678
     1679        $noisettes = noizetier_obtenir_infos_noisettes();
     1680        if ($type == '') {
     1681                $match = '^[^-]*$';
     1682        } else {
     1683                $match = $type.'-[^-]*$';
     1684        }
     1685
     1686        foreach ($noisettes as $noisette => $description) {
     1687                if (preg_match("/$match/", $noisette)) {
     1688                        $liste_noisettes[$type][$noisette] = $description;
     1689                }
     1690        }
     1691
     1692        return isset($liste_noisettes[$type]) ? $liste_noisettes[$type]: '';
     1693}
     1694
     1695/**
     1696 * Renvoie les info d'une seule noisette.
     1697 *
     1698 * @param string $noisette renvoyer spécifiquement une noisette données
     1699 *
     1700 * @return array
     1701 */
     1702function noizetier_info_noisette($noisette) {
     1703        $noisettes = noizetier_obtenir_infos_noisettes();
     1704        if (isset($noisettes[$noisette])) {
     1705                $noisette = $noisettes[$noisette];
     1706        } else {
     1707                $noisette = array('nom' => _T('noizetier:formulaire_erreur_noisette_introuvable', array('noisette' => $noisette)));
     1708        }
     1709
     1710        return $noisette;
     1711}
     1712
     1713/**
     1714 * Obtenir les infos de toutes les noisettes disponibles dans les dossiers noisettes/
     1715 * On utilise un cache php pour alleger le calcul.
     1716 *
     1717 * @param
     1718 *
     1719 * @return
     1720 **/
     1721function noizetier_obtenir_infos_noisettes() {
     1722        static $noisettes = false;
     1723
     1724        // seulement 1 fois par appel, on lit ou calcule tous les contextes
     1725        if ($noisettes === false) {
     1726                // lire le cache des descriptions sauvees
     1727                lire_fichier_securise(_CACHE_DESCRIPTIONS_NOISETTES, $noisettes);
     1728                $noisettes = @unserialize($noisettes);
     1729                // s'il en mode recalcul, on recalcule toutes les descriptions des noisettes trouvees.
     1730                // ou si le cache est desactive
     1731                if (!$noisettes or (_request('var_mode') == 'recalcul') or (defined('_NO_CACHE') and _NO_CACHE != 0)) {
     1732                        $noisettes = noizetier_obtenir_infos_noisettes_direct();
     1733                        ecrire_fichier_securise(_CACHE_DESCRIPTIONS_NOISETTES, serialize($noisettes));
     1734                }
     1735        }
     1736
     1737        return $noisettes;
     1738}
     1739
     1740/**
     1741 * Obtenir les infos de toutes les noisettes disponibles dans les dossiers noisettes/
     1742 * C'est un GROS calcul lorsqu'il est a faire.
     1743 *
     1744 * @return array
     1745 */
     1746function noizetier_obtenir_infos_noisettes_direct() {
     1747        $liste_noisettes = array();
     1748
     1749        $match = '[^-]*[.]html$';
     1750        $liste = find_all_in_path('noisettes/', $match);
     1751
     1752        if (count($liste)) {
     1753                foreach ($liste as $squelette => $chemin) {
     1754                        $noisette = preg_replace(',[.]html$,i', '', $squelette);
     1755                        $dossier = str_replace($squelette, '', $chemin);
     1756                        // On ne garde que les squelettes ayant un fichier YAML de config
     1757                        if (file_exists("$dossier$noisette.yaml")
     1758                                and ($infos_noisette = noizetier_charger_infos_noisette_yaml($dossier.$noisette))
     1759                        ) {
     1760                                $liste_noisettes[$noisette] = $infos_noisette;
     1761                        }
     1762                }
     1763        }
     1764
     1765        // supprimer de la liste les noisettes necessitant un plugin qui n'est pas actif.
     1766        // On s'arrête au premier inactif.
     1767        foreach ($liste_noisettes as $noisette => $infos_noisette) {
     1768                if (!empty($infos_noisette['necessite'])) {
     1769                        foreach ($infos_noisette['necessite'] as $plugin) {
     1770                                if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
     1771                                        unset($liste_noisettes[$noisette]);
     1772                                        break;
     1773                                }
     1774                        }
     1775                }
     1776        }
     1777
     1778        return $liste_noisettes;
     1779}
     1780
     1781/**
     1782 * Charger les informations contenues dans le YAML d'une noisette.
     1783 *
     1784 * @param string $noisette
     1785 * @param string $info
     1786 *
     1787 * @return array
     1788 */
     1789function noizetier_charger_infos_noisette_yaml($noisette, $info = '') {
     1790        include_spip('inc/yaml');
     1791        include_spip('inc/texte');
     1792
     1793        // on peut appeler avec le nom du squelette
     1794        $fichier = preg_replace(',[.]html$,i', '', $noisette).'.yaml';
     1795
     1796        $infos_noisette = array();
     1797        if ($infos_noisette = yaml_charger_inclusions(yaml_decode_file($fichier))) {
     1798                if (isset($infos_noisette['nom'])) {
     1799                        $infos_noisette['nom'] = _T_ou_typo($infos_noisette['nom']);
     1800                }
     1801                if (isset($infos_noisette['description'])) {
     1802                        $infos_noisette['description'] = _T_ou_typo($infos_noisette['description']);
     1803                }
     1804                if (isset($infos_noisette['icon'])) {
     1805                        $infos_noisette['icon'] = $infos_noisette['icon'];
     1806                }
     1807
     1808                if (!isset($infos_noisette['parametres'])) {
     1809                        $infos_noisette['parametres'] = array();
     1810                }
     1811
     1812                // necessite de plugins : toujours renvoyer un array
     1813                if (!isset($infos_noisette['necessite'])) {
     1814                        $infos_noisette['necessite'] = array();
     1815                }
     1816
     1817                if (is_string($infos_noisette['necessite'])) {
     1818                        $infos_noisette['necessite'] = array($infos_noisette['necessite']);
     1819                }
     1820
     1821                // contexte
     1822                if (!isset($infos_noisette['contexte'])) {
     1823                        $infos_noisette['contexte'] = array();
     1824                }
     1825
     1826                if (is_string($infos_noisette['contexte'])) {
     1827                        $infos_noisette['contexte'] = array($infos_noisette['contexte']);
     1828                }
     1829
     1830                // ajax
     1831                if (!isset($infos_noisette['ajax'])) {
     1832                        $infos_noisette['ajax'] = 'oui';
     1833                }
     1834
     1835                // inclusion
     1836                if (!isset($infos_noisette['inclusion'])) {
     1837                        $infos_noisette['inclusion'] = 'statique';
     1838                }
     1839        }
     1840
     1841        if (!$info) {
     1842                return $infos_noisette;
     1843        } else {
     1844                return isset($infos_noisette[$info]) ? $infos_noisette[$info] : '';
     1845        }
     1846}
     1847
     1848/**
     1849 * Retourne true ou false pour indiquer si la noisette doit être inclue en ajax.
     1850 *
     1851 * @param
     1852 *
     1853 * @return
     1854 **/
     1855function noizetier_ajaxifier_noisette($noisette) {
     1856        static $noisettes = false;
     1857
     1858        // seulement 1 fois par appel, on lit ou calcule tous les contextes
     1859        if ($noisettes === false) {
     1860                // lire le cache des contextes sauves
     1861                lire_fichier_securise(_CACHE_AJAX_NOISETTES, $noisettes);
     1862                $noisettes = @unserialize($noisettes);
     1863
     1864                // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
     1865                if (!$noisettes or (_request('var_mode') == 'recalcul')) {
     1866                        $infos = noizetier_lister_noisettes();
     1867                        $noisettes = array();
     1868                        foreach ($infos as $cle_noisette => $infos) {
     1869                                $noisettes[$cle_noisette] = ($infos['ajax'] == 'non') ? false : true;
     1870                        }
     1871                        ecrire_fichier_securise(_CACHE_AJAX_NOISETTES, serialize($noisettes));
     1872                }
     1873        }
     1874
     1875        if (isset($noisettes[$noisette])) {
     1876                return $noisettes[$noisette];
     1877        }
     1878
     1879        return true;
     1880}
     1881
    13261882
    13271883/**
     
    13691925                                        and (($page != 'z_apl') or (!defined('_DIR_PLUGIN_Z') and !defined('_DIR_PLUGIN_ZCORE')))
    13701926                                        and (!$est_composition or ($est_composition     and defined('_DIR_PLUGIN_COMPOSITIONS')))) {
    1371                                                 if ($configuration = noizetier_page_informer($page, '', $options)) {
     1927                                                if ($configuration = page_informer($page, '', $options)) {
    13721928                                                        // On n'inclue la page que si les plugins qu'elle nécessite explicitement dans son
    13731929                                                        // fichier de configuration sont bien tous activés.
     
    14011957                                if ($options['compositions']) {
    14021958                                        foreach ($options['compositions'] as $_composition => $_configuration) {
    1403                                                 if ($configuration = noizetier_page_informer($_composition, '', $options)) {
     1959                                                if ($configuration = page_informer($_composition, '', $options)) {
    14041960                                                                $pages[$_composition] = $configuration;
    14051961                                                }
     
    14642020 * @return array|string
    14652021 */
    1466 function noizetier_page_informer($page, $information = '', $options =array()) {
     2022function page_informer($page, $information = '', $options =array()) {
    14672023
    14682024        static $description_page = array();
     
    16262182
    16272183
    1628 /**
    1629  * Renvoie le type d'une page à partir de son identifiant.
    1630  *
    1631  * @package SPIP\NOIZETIER\API\PAGE
    1632  * @api
    1633  * @filtre
    1634  *
    1635  * @param string $page
    1636  *              L'identifiant de la page.
    1637  *
    1638  * @return string
    1639  *              Le type de la page choisie, c'est-à-dire:
    1640  *              - soit l'identifiant complet de la page,
    1641  *              - soit le mot précédent le tiret dans le cas d'une composition.
    1642  */
    1643 function noizetier_page_type($page) {
    1644         $type = explode('-', $page, 2);
    1645 
    1646         return $type[0];
    1647 }
    1648 
    1649 /**
    1650  * Détermine, à partir de son identifiant, la composition d'une page si elle existe.
    1651  *
    1652  * @package SPIP\NOIZETIER\API\PAGE
    1653  * @api
    1654  * @filtre
    1655  *
    1656  * @param string $page
    1657  *              L'identifiant de la page.
    1658  *
    1659  * @return string
    1660  *      La composition de la page choisie, à savoir, le mot suivant le tiret,
    1661  *              ou la chaine vide sinon.
    1662  */
    1663 function noizetier_page_composition($page) {
    1664         $composition = explode('-', $page, 2);
    1665         $composition = isset($composition[1]) ? $composition[1] : '';
    1666 
    1667         return $composition;
    1668 }
    1669 
    1670 /**
    1671  * Détermine, à partir de son identifiant, si la page est une composition.
    1672  *
    1673  * @package SPIP\NOIZETIER\API\PAGE
    1674  * @api
    1675  * @filtre
    1676  *
    1677  * @param string $page
    1678  *              L'identifiant de la page.
    1679  *
    1680  * @return boolean
    1681  *      `true` si la page est une composition, `false` sinon.
    1682  */
    1683 function noizetier_page_est_composition($page) {
    1684         $est_composition = false;
    1685         if (strpos($page, '-') !== false) {
    1686                 $est_composition = true;
    1687         }
    1688 
    1689         return $est_composition;
    1690 }
    1691 
    1692 
    1693 
    1694 /**
    1695  * Détermine si les compositions sont possibles sur un type de page.
    1696  *
    1697  * @package SPIP\NOIZETIER\API\OBJET
    1698  * @api
    1699  * @filtre
    1700  *
    1701  * @param string $type
    1702  *              Identifiant du type de page.
    1703  *
    1704  * @return boolean
    1705  *              True si les compositions sont autorisées, false sinon.
    1706  */
    1707 function noizetier_page_composition_activee($type) {
    1708 
    1709         $est_activee = false;
    1710 
    1711         if (defined('_DIR_PLUGIN_COMPOSITIONS')) {
    1712                 include_spip('compositions_fonctions');
    1713                 if (in_array($type, compositions_objets_actives())) {
    1714                         $est_activee = true;
    1715                 }
    1716         }
    1717 
    1718         return $est_activee;
    1719 }
    1720 
    1721 
    1722 /**
    1723  * Déterminer le répertoire dans lequel le NoiZetier peut lister les pages pouvant supporter
    1724  * l'insertion de noisettes.
    1725  *
    1726  * @package SPIP\NOIZETIER\API\PAGE
    1727  * @api
    1728  * @filtre
    1729  *
    1730  * @return string
    1731  *              Le répertoire des pages sous la forme dossier/.
    1732  */
    1733 function noizetier_page_obtenir_dossier() {
    1734 
    1735         if (defined('_NOIZETIER_REPERTOIRE_PAGES')) {
    1736                 $repertoire_pages = _NOIZETIER_REPERTOIRE_PAGES;
    1737         }
    1738         elseif (isset($GLOBALS['z_blocs'])) {
    1739                 $premier_bloc = reset($GLOBALS['z_blocs']);
    1740                 $repertoire_pages = "$premier_bloc/";
    1741         } else {
    1742                 $repertoire_pages = 'contenu/';
    1743         }
    1744 
    1745         return $repertoire_pages;
    1746 }
    1747 
    1748 
    1749 // --------------------------------------------------------------------
    1750 // ---------------------------- API OBJETS ----------------------------
    1751 // --------------------------------------------------------------------
    1752 
    1753 /**
    1754  * Lister les objets ayant des noisettes spéciquement configurées pour leur page.
    1755  *
    1756  * @package SPIP\NOIZETIER\API\OBJET
    1757  * @api
    1758  * @filtre
    1759  *
    1760  * @param string $objet
    1761  *              Type d'objet ou chaine vide.
    1762  * @param string $id_objet
    1763  *              Id de l'objet ou 0.
    1764  *
    1765  * @return array|string
    1766  *              Si le type et l'id de l'objet sont fournis, on renvoie la description de la page de cet objet.
    1767  *              Sinon, on renvoie le tableau de toutes les objets sous la forme [type_objet][id_objet].
    1768  */
    1769 function noizetier_objet_informer($type_objet = '', $id_objet = 0, $information = '') {
    1770         static $objets = null;
    1771         static $description_objet = array();
    1772 
    1773         if ((!$type_objet and !$id_objet and is_null($objets))
    1774         or ($type_objet and $id_objet and !isset($description_objet[$type_objet][$id_objet]))) {
    1775                 // On récupère le ou les objets ayant des noisettes dans la table spip_noisettes.
    1776                 $from = array('spip_noisettes');
    1777                 $select = array('objet', 'id_objet', "count(noisette) as 'noisettes'");
    1778                 $where = array('id_objet>0');
    1779                 if ($type_objet and $id_objet) {
    1780                         $where = array('objet=' . sql_quote($type_objet), 'id_objet=' . intval($id_objet));
    1781                 }
    1782                 $group = array('objet', 'id_objet');
    1783                 $objets_configures = sql_allfetsel($select, $from, $where, $group);
    1784                 if ($objets_configures) {
    1785                         include_spip('inc/quete');
    1786                         include_spip('base/objets');
    1787                         foreach ($objets_configures as $_objet) {
    1788                                 $description = array();
    1789                                 // On calcule le titre de l'objet à partir de la fonction idoine
    1790                                 $description['titre'] = generer_info_entite($_objet['id_objet'], $_objet['objet'], 'titre');
    1791                                 // On recherche le logo de l'objet si il existe sinon on stocke le logo du type d'objet
    1792                                 // (le chemin complet)
    1793                                 $description['logo'] = '';
    1794                                 if ($_objet['objet'] != 'document') {
    1795                                         $logo_infos = quete_logo(id_table_objet($_objet['objet']), 'on', $_objet['id_objet'], 0, false);
    1796                                         $description['logo'] = isset($logo_infos['src']) ? $logo_infos['src'] : '';
    1797                                 }
    1798                                 if (!$description['logo']) {
    1799                                         $description['logo'] = noizetier_icone_chemin("{$_objet['objet']}.png");
    1800                                 }
    1801                                 $description['noisettes'] = $_objet['noisettes'];
    1802 
    1803                                 // On rajoute les blocs du type de page dont l'objet est une instance et on sauvegarde
    1804                                 // la description complète.
    1805                                 if ($type_objet and $id_objet) {
    1806                                         $description['blocs'] = noizetier_page_informer($type_objet, 'blocs');
    1807                                         $description_objet[$type_objet][$id_objet] = $description;
    1808                                 } else {
    1809                                         $description['blocs'] = noizetier_page_informer($_objet['objet'], 'blocs');
    1810                                         $objets[$_objet['objet']][$_objet['id_objet']] = $description;
    1811                                 }
    1812                         }
    1813                 }
    1814         }
    1815 
    1816         if ($type_objet and $id_objet) {
    1817                 if (!$information) {
    1818                         return isset($description_objet[$type_objet][$id_objet])
    1819                                 ? $description_objet[$type_objet][$id_objet]
    1820                                 : array();
    1821                 } else {
    1822                         return isset($description_objet[$type_objet][$id_objet][$information])
    1823                                 ? $description_objet[$type_objet][$id_objet][$information]
    1824                                 : '';
    1825                 }
    1826         } else {
    1827                 // Filtrage des objets répertoriés:
    1828                 // - de façon systématique, on ne retient que les objets dont le type est activé dans la configuration du plugin.
    1829                 $objets_repertories = $objets;
    1830                 foreach ($objets_repertories as $_type_objet => $_objets) {
    1831                         if (!noizetier_objet_type_active($_type_objet)) {
    1832                                 unset($objets_repertories[$_type_objet]);
    1833                         }
    1834                 }
    1835                 return $objets_repertories;
    1836         }
    1837 }
    1838 
    1839 
    1840 /**
    1841  * Renvoie la liste des types d'objet ne pouvant pas être personnaliser car ne possédant pas de page
    1842  * détectable par le noiZetier.
    1843  *
    1844  * @package SPIP\NOIZETIER\API\OBJET
    1845  * @api
    1846  * @filtre
    1847  *
    1848  * @return array|null
    1849  */
    1850 function noizetier_objet_lister_exclusions() {
    1851 
    1852         static $exclusions = null;
    1853 
    1854         if (is_null($exclusions)) {
    1855                 $exclusions = array();
    1856                 include_spip('base/objets');
    1857 
    1858                 // On récupère les tables d'objets sous la forme spip_xxxx.
    1859                 $tables = lister_tables_objets_sql();
    1860                 $tables = array_keys($tables);
    1861 
    1862                 // On récupère la liste des pages disponibles et on transforme le type d'objet en table SQL.
    1863                 $filtres = array('est_composition' => false, 'est_page_objet' => 'oui');
    1864                 $pages = noizetier_page_repertorier($filtres);
    1865                 $pages = array_keys($pages);
    1866                 $pages = array_map('table_objet_sql', $pages);
    1867 
    1868                 // On exclut donc les tables qui ne sont pas dans la liste issues des pages.
    1869                 $exclusions = array_diff($tables, $pages);
    1870         }
    1871 
    1872         return $exclusions;
    1873 }
    1874 
    1875 
    1876 /**
    1877  * Détermine si un type d'objet est activé par configuration du noiZetier.
    1878  * Si oui, ses objets peuvent recevoir une configuration de noisettes.
    1879  *
    1880  * @package SPIP\NOIZETIER\API\OBJET
    1881  * @api
    1882  * @filtre
    1883  *
    1884  * @param string $type_objet
    1885  *              Type d'objet SPIP comme article, rubrique...
    1886  *
    1887  * @return boolean
    1888  *              True si le type d'objet est activé, false sinon.
    1889  */
    1890 function noizetier_objet_type_active($type_objet) {
    1891 
    1892         $est_active = false;
    1893 
    1894         include_spip('inc/config');
    1895         $tables_actives = lire_config('noizetier/objets_noisettes', array());
    1896         if ($tables_actives and in_array($type_objet, array_map('objet_type', $tables_actives))) {
    1897                 $est_active = true;
    1898         }
    1899 
    1900         return $est_active;
    1901 }
    1902 
    1903 
    1904 include_spip('public/noizetier_balises');
    1905 
    1906 
    1907 // -------------------------------------------------------------------
    1908 // API NOISETTES OBSOLETE : A VIRER A TERME
    1909 // -------------------------------------------------------------------
    1910 /**
    1911  * Lister les noisettes disponibles dans les dossiers noisettes/.
    1912  *
    1913  * @staticvar array $liste_noisettes
    1914  *
    1915  * @param string $type     renvoyer seulement un type de noisettes
    1916  * @param string $noisette renvoyer spécifiquement une noisette données
    1917  *
    1918  * @return array
    1919  */
    1920 function noizetier_lister_noisettes($type = 'tout') {
    1921         static $liste_noisettes = array();
    1922         if ($type == 'tout') {
    1923                 return noizetier_obtenir_infos_noisettes();
    1924         }
    1925         if (isset($liste_noisettes[$type])) {
    1926                 return $liste_noisettes[$type];
    1927         }
    1928 
    1929         $noisettes = noizetier_obtenir_infos_noisettes();
    1930         if ($type == '') {
    1931                 $match = '^[^-]*$';
    1932         } else {
    1933                 $match = $type.'-[^-]*$';
    1934         }
    1935 
    1936         foreach ($noisettes as $noisette => $description) {
    1937                 if (preg_match("/$match/", $noisette)) {
    1938                         $liste_noisettes[$type][$noisette] = $description;
    1939                 }
    1940         }
    1941 
    1942         return isset($liste_noisettes[$type]) ? $liste_noisettes[$type]: '';
    1943 }
    1944 
    1945 /**
    1946  * Renvoie les info d'une seule noisette.
    1947  *
    1948  * @param string $noisette renvoyer spécifiquement une noisette données
    1949  *
    1950  * @return array
    1951  */
    1952 function noizetier_info_noisette($noisette) {
    1953         $noisettes = noizetier_obtenir_infos_noisettes();
    1954         if (isset($noisettes[$noisette])) {
    1955                 $noisette = $noisettes[$noisette];
    1956         } else {
    1957                 $noisette = array('nom' => _T('noizetier:formulaire_erreur_noisette_introuvable', array('noisette' => $noisette)));
    1958         }
    1959 
    1960         return $noisette;
    1961 }
    1962 
    1963 /**
    1964  * Obtenir les infos de toutes les noisettes disponibles dans les dossiers noisettes/
    1965  * On utilise un cache php pour alleger le calcul.
    1966  *
    1967  * @param
    1968  *
    1969  * @return
    1970  **/
    1971 function noizetier_obtenir_infos_noisettes() {
    1972         static $noisettes = false;
    1973 
    1974         // seulement 1 fois par appel, on lit ou calcule tous les contextes
    1975         if ($noisettes === false) {
    1976                 // lire le cache des descriptions sauvees
    1977                 lire_fichier_securise(_CACHE_DESCRIPTIONS_NOISETTES, $noisettes);
    1978                 $noisettes = @unserialize($noisettes);
    1979                 // s'il en mode recalcul, on recalcule toutes les descriptions des noisettes trouvees.
    1980                 // ou si le cache est desactive
    1981                 if (!$noisettes or (_request('var_mode') == 'recalcul') or (defined('_NO_CACHE') and _NO_CACHE != 0)) {
    1982                         $noisettes = noizetier_obtenir_infos_noisettes_direct();
    1983                         ecrire_fichier_securise(_CACHE_DESCRIPTIONS_NOISETTES, serialize($noisettes));
    1984                 }
    1985         }
    1986 
    1987         return $noisettes;
    1988 }
    1989 
    1990 /**
    1991  * Obtenir les infos de toutes les noisettes disponibles dans les dossiers noisettes/
    1992  * C'est un GROS calcul lorsqu'il est a faire.
    1993  *
    1994  * @return array
    1995  */
    1996 function noizetier_obtenir_infos_noisettes_direct() {
    1997         $liste_noisettes = array();
    1998 
    1999         $match = '[^-]*[.]html$';
    2000         $liste = find_all_in_path('noisettes/', $match);
    2001 
    2002         if (count($liste)) {
    2003                 foreach ($liste as $squelette => $chemin) {
    2004                         $noisette = preg_replace(',[.]html$,i', '', $squelette);
    2005                         $dossier = str_replace($squelette, '', $chemin);
    2006                         // On ne garde que les squelettes ayant un fichier YAML de config
    2007                         if (file_exists("$dossier$noisette.yaml")
    2008                                 and ($infos_noisette = noizetier_charger_infos_noisette_yaml($dossier.$noisette))
    2009                         ) {
    2010                                 $liste_noisettes[$noisette] = $infos_noisette;
    2011                         }
    2012                 }
    2013         }
    2014 
    2015         // supprimer de la liste les noisettes necessitant un plugin qui n'est pas actif.
    2016         // On s'arrête au premier inactif.
    2017         foreach ($liste_noisettes as $noisette => $infos_noisette) {
    2018                 if (!empty($infos_noisette['necessite'])) {
    2019                         foreach ($infos_noisette['necessite'] as $plugin) {
    2020                                 if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
    2021                                         unset($liste_noisettes[$noisette]);
    2022                                         break;
    2023                                 }
    2024                         }
    2025                 }
    2026         }
    2027 
    2028         return $liste_noisettes;
    2029 }
    2030 
    2031 /**
    2032  * Charger les informations contenues dans le YAML d'une noisette.
    2033  *
    2034  * @param string $noisette
    2035  * @param string $info
    2036  *
    2037  * @return array
    2038  */
    2039 function noizetier_charger_infos_noisette_yaml($noisette, $info = '') {
    2040         include_spip('inc/yaml');
    2041         include_spip('inc/texte');
    2042 
    2043         // on peut appeler avec le nom du squelette
    2044         $fichier = preg_replace(',[.]html$,i', '', $noisette).'.yaml';
    2045 
    2046         $infos_noisette = array();
    2047         if ($infos_noisette = yaml_charger_inclusions(yaml_decode_file($fichier))) {
    2048                 if (isset($infos_noisette['nom'])) {
    2049                         $infos_noisette['nom'] = _T_ou_typo($infos_noisette['nom']);
    2050                 }
    2051                 if (isset($infos_noisette['description'])) {
    2052                         $infos_noisette['description'] = _T_ou_typo($infos_noisette['description']);
    2053                 }
    2054                 if (isset($infos_noisette['icon'])) {
    2055                         $infos_noisette['icon'] = $infos_noisette['icon'];
    2056                 }
    2057 
    2058                 if (!isset($infos_noisette['parametres'])) {
    2059                         $infos_noisette['parametres'] = array();
    2060                 }
    2061 
    2062                 // necessite de plugins : toujours renvoyer un array
    2063                 if (!isset($infos_noisette['necessite'])) {
    2064                         $infos_noisette['necessite'] = array();
    2065                 }
    2066 
    2067                 if (is_string($infos_noisette['necessite'])) {
    2068                         $infos_noisette['necessite'] = array($infos_noisette['necessite']);
    2069                 }
    2070 
    2071                 // contexte
    2072                 if (!isset($infos_noisette['contexte'])) {
    2073                         $infos_noisette['contexte'] = array();
    2074                 }
    2075 
    2076                 if (is_string($infos_noisette['contexte'])) {
    2077                         $infos_noisette['contexte'] = array($infos_noisette['contexte']);
    2078                 }
    2079 
    2080                 // ajax
    2081                 if (!isset($infos_noisette['ajax'])) {
    2082                         $infos_noisette['ajax'] = 'oui';
    2083                 }
    2084 
    2085                 // inclusion
    2086                 if (!isset($infos_noisette['inclusion'])) {
    2087                         $infos_noisette['inclusion'] = 'statique';
    2088                 }
    2089         }
    2090 
    2091         if (!$info) {
    2092                 return $infos_noisette;
    2093         } else {
    2094                 return isset($infos_noisette[$info]) ? $infos_noisette[$info] : '';
    2095         }
    2096 }
    2097 
    2098 /**
    2099  * Retourne true ou false pour indiquer si la noisette doit être inclue en ajax.
    2100  *
    2101  * @param
    2102  *
    2103  * @return
    2104  **/
    2105 function noizetier_ajaxifier_noisette($noisette) {
    2106         static $noisettes = false;
    2107 
    2108         // seulement 1 fois par appel, on lit ou calcule tous les contextes
    2109         if ($noisettes === false) {
    2110                 // lire le cache des contextes sauves
    2111                 lire_fichier_securise(_CACHE_AJAX_NOISETTES, $noisettes);
    2112                 $noisettes = @unserialize($noisettes);
    2113 
    2114                 // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
    2115                 if (!$noisettes or (_request('var_mode') == 'recalcul')) {
    2116                         $infos = noizetier_lister_noisettes();
    2117                         $noisettes = array();
    2118                         foreach ($infos as $cle_noisette => $infos) {
    2119                                 $noisettes[$cle_noisette] = ($infos['ajax'] == 'non') ? false : true;
    2120                         }
    2121                         ecrire_fichier_securise(_CACHE_AJAX_NOISETTES, serialize($noisettes));
    2122                 }
    2123         }
    2124 
    2125         if (isset($noisettes[$noisette])) {
    2126                 return $noisettes[$noisette];
    2127         }
    2128 
    2129         return true;
    2130 }
    2131 
    2132 function maj_noisettes_pages() {
    2133         include_spip('inc/config');
    2134         $compositions = lire_config('noizetier_compositions', array());
    2135         if ($compositions) {
    2136                 $compositions_060 = array();
    2137                 foreach ($compositions as $_page => $_composition) {
    2138                         $_composition['type'] = noizetier_page_type($_page);
    2139                         $_composition['composition'] = noizetier_page_composition($_page);
    2140                         if (empty($_composition['nom'])) {
    2141                                 $_description['nom'] = $_page;
    2142                         }
    2143                         if (empty($_composition['icon'])) {
    2144                                 $_composition['icon'] = 'composition-24.png';
    2145                         }
    2146                         $_composition['blocs_exclus'] = isset($_composition['blocs_exclus'])
    2147                                 ? serialize($_composition['blocs_exclus'])
    2148                                 : serialize(array());
    2149                         $_composition['necessite'] = isset($_composition['necessite'])
    2150                                 ? serialize($_composition['necessite'])
    2151                                 : serialize(array());
    2152                         $_composition['branche'] = isset($_composition['branche'])
    2153                                 ? serialize($_composition['branche'])
    2154                                 : serialize(array());
    2155                         include_spip('base/objets');
    2156                         $tables_objets = array_keys(lister_tables_objets_sql());
    2157                         $_composition['est_page_objet'] = in_array(table_objet_sql($_composition['type']), $tables_objets) ? 'oui' : 'non';
    2158                         $_composition['est_virtuelle'] = 'oui';
    2159                         $compositions_060[] = $_composition;
    2160                 }
    2161                 if ($compositions_060) {
    2162                         sql_insertq_multi('spip_noisettes_pages', $compositions_060);
    2163                 }
    2164         }
    2165 }
  • _plugins_/noizetier/trunk/noizetier_pipelines.php

    r104849 r104893  
    9393                                $page = isset($contexte['type']) ? $contexte['type'] : (isset($contexte['type-page']) ? $contexte['type-page'] : '');
    9494                                $page .= (isset($contexte['composition']) && $contexte['composition']) ? '-'.$contexte['composition'] : '';
    95                                 $info_page = noizetier_page_informer($page);
    96                                 if (isset($info_page['blocs'][$bloc])) {
     95                                $blocs = noizetier_page_lister_blocs($page);
     96                                if (isset($blocs[$bloc])) {
    9797                                        $complements = recuperer_fond('noizetier-generer-bloc-voir-noisettes', $contexte, array('raw' => true));
    9898                                        $flux['data']['texte'] .= $complements['texte'];
  • _plugins_/noizetier/trunk/prive/squelettes/contenu/noizetier_page.html

    r104887 r104893  
    3232        #BOITE_FERMER
    3333
    34 <div class="ajax">#FORMULAIRE_LISTER_NOISETTES_PAGE{#ENV{page,#ARRAY{objet,#OBJET,id_objet,#ID_OBJET}}, #ENV{bloc}}</div>
     34        <div class="ajax">#FORMULAIRE_LISTER_NOISETTES_PAGE{#ENV{page,#ARRAY{objet,#OBJET,id_objet,#ID_OBJET}}, #ENV{bloc}}</div>
    3535
    36 [(#REM) <!-- Liste des noisettes disponibles --> ]
    37 #SET{titre,#VAL{noizetier:noisettes_disponibles}|_T}
    38 #BOITE_OUVRIR{#GET{titre},'info noisettes_disponibles none'}
    39 <p><:noizetier:explication_glisser_deposer:></p>
    40 <INCLURE{fond=formulaires/inc-liste_noisettes_disponibles,
    41         page,
    42         objet,
    43         id_objet,
    44         ordre=oui} />
    45 #BOITE_FERMER
    46 <script type="text/javascript">/*<!\[CDATA\[*/
    47         jQuery('.noisettes_disponibles').show();
    48         jQuery('ul.liste-noisettes-disponibles li.noisette').draggable({
    49                 connectToSortable: "ul.bloc",
    50                 helper: "clone",
    51                 revert: "invalid",
    52                 cursor: 'move'
    53         });
    54 /*\]\]>*/</script>
     36        [(#REM) <!-- Liste des noisettes disponibles --> ]
     37        #SET{titre,#VAL{noizetier:noisettes_disponibles}|_T}
     38        #BOITE_OUVRIR{#GET{titre},'info noisettes_disponibles none'}
     39        <p><:noizetier:explication_glisser_deposer:></p>
     40        <INCLURE{fond=formulaires/inc-liste_noisettes_disponibles,
     41                page,
     42                objet,
     43                id_objet,
     44                ordre=oui} />
     45        #BOITE_FERMER
     46        <script type="text/javascript">/*<!\[CDATA\[*/
     47                jQuery('.noisettes_disponibles').show();
     48                jQuery('ul.liste-noisettes-disponibles li.noisette').draggable({
     49                        connectToSortable: "ul.bloc",
     50                        helper: "clone",
     51                        revert: "invalid",
     52                        cursor: 'move'
     53                });
     54        /*\]\]>*/</script>
    5555
    56 [(#EVAL{_AJAX}|oui)
    57         <script type="text/javascript">/*<!\[CDATA\[*/reloadExecPage('#ENV{exec}','#navigation,#chemin');/*\]\]>*/</script>
    58 ]
     56        [(#EVAL{_AJAX}|oui)
     57                <script type="text/javascript">/*<!\[CDATA\[*/reloadExecPage('#ENV{exec}','#navigation,#chemin');/*\]\]>*/</script>
     58        ]
    5959</BOUCLE_page_contenu>
    60 [(#ENV**{exec}|=={noisette_edit}|oui)#INCLURE{fond=prive/squelettes/contenu/noisette_edit,redirect='',env,retourajax=oui}]
    61 [(#ENV**{exec}|=={noisette_add}|oui)#INCLURE{fond=prive/squelettes/contenu/noisette_add,redirect='',env,retourajax=oui}]
    62 [(#ENV**{exec}|=={noizetier_page_edit}|oui)#INCLURE{fond=prive/squelettes/contenu/noizetier_page_edit,redirect='',env,retourajax=oui}]
    63 [(#ENV**{exec}|=={noisette_edit}|ou{#ENV**{exec}|=={noisette_add}}|ou{#ENV**{exec}|=={noizetier_page_edit}}|non)[(#REM|sinon_interdire_acces)]]
     60        [(#ENV**{exec}|=={noisette_edit}|oui)#INCLURE{fond=prive/squelettes/contenu/noisette_edit,redirect='',env,retourajax=oui}]
     61        [(#ENV**{exec}|=={noisette_add}|oui)#INCLURE{fond=prive/squelettes/contenu/noisette_add,redirect='',env,retourajax=oui}]
     62        [(#ENV**{exec}|=={noizetier_page_edit}|oui)#INCLURE{fond=prive/squelettes/contenu/noizetier_page_edit,redirect='',env,retourajax=oui}]
     63        [(#ENV**{exec}|=={noisette_edit}|ou{#ENV**{exec}|=={noisette_add}}|ou{#ENV**{exec}|=={noizetier_page_edit}}|non)[(#REM|sinon_interdire_acces)]]
    6464<//B_page_contenu>
  • _plugins_/noizetier/trunk/prive/squelettes/contenu/noizetier_page_edit.html

    r104670 r104893  
    55        |sinon_interdire_acces)]
    66
    7 #SET{description_page, #NOIZETIER_PAGE_INFOS{#ENV{page}|?{#ENV{page}, #ENV{source}}}}
     7#SET{page_concernee, #ENV{page}|?{#ENV{page}, #ENV{source}}}
     8#SET{description_page, #GET{page_concernee}|noizetier_page_informer}
    89[(#ENV{edition}|=={modifier}|oui)
    910        #SET{redirect, #URL_ECRIRE{noizetier_page}|parametre_url{page, #ENV{page}}}
  • _plugins_/noizetier/trunk/public/noizetier_balises.php

    r104773 r104893  
    1313                        $information = interprete_argument_balise(2, $p);
    1414                        $information = isset($information) ? str_replace('\'', '"', $information) : '""';
    15                         $p->code = "noizetier_page_informer($page, $information)";
     15                        $p->code = "page_informer($page, $information)";
    1616                } else {
    1717                        $filtres = str_replace('\'', '"', $argument);
Note: See TracChangeset for help on using the changeset viewer.