Changeset 104909 in spip-zone


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

Insertion des noisettes dans la table spip_noizetier_noisettes.
Passage des fonctions anciennes d'information en obsolètes.

Location:
_plugins_/noizetier/trunk
Files:
3 edited

Legend:

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

    r104894 r104909  
    1515
    1616//      noizetier_page_repertorier();
    17 //      noizetier_page_charger();
    18 
    19         include_spip('base/create');
    20         maj_tables(array('spip_noizetier_noisettes'));
     17        noizetier_noisette_charger();
    2118
    2219
  • _plugins_/noizetier/trunk/noizetier_fonctions.php

    r104894 r104909  
    1616// -------------------------------------------------------------------
    1717
    18 /**
    19  * @param array $filtres
    20  *
    21  * @return array|mixed|null
    22  */
    23 function noizetier_noisette_repertorier($filtres = array()) {
    24         static $noisettes = null;
    25 
    26         if (is_null($noisettes)) {
    27                 // On détermine l'existence et le contenu du cache.
    28                 $cache_noisettes = array();
    29                 if (lire_fichier_securise(_CACHE_DESCRIPTIONS_NOISETTES, $contenu)) {
    30                         $cache_noisettes = unserialize($contenu);
    31                 }
    32 
    33                 if (!$cache_noisettes
    34                 or (_request('var_mode') == 'recalcul')
    35                 or (defined('_NO_CACHE') and (_NO_CACHE != 0))) {
    36                         // On doit recalculer le cache
    37                         if ($fichiers = find_all_in_path('noisettes/', '.+[.]yaml$')) {
    38                                 foreach ($fichiers as $_fichier => $_chemin) {
    39                                         $noisette = basename($_fichier, '.yaml');
    40                                         $options = array('recharger' => true, 'yaml' => $_chemin);
    41                                         if ($configuration = noizetier_noisette_informer($noisette, '', $options)) {
    42                                                 // On n'inclue la noisette que si les plugins qu'elle nécessite explicitement dans son
    43                                                 // fichier de configuration sont bien tous activés.
    44                                                 // Rappel : si une noisette est incluse dans un plugin non actif elle ne sera pas détectée
    45                                                 //          lors du find_all_in_path() puisque le plugin n'est pas dans le path SPIP.
    46                                                 $noisette_a_garder = true;
    47                                                 if (isset($configuration['necessite'])) {
    48                                                         foreach ($configuration['necessite'] as $plugin) {
    49                                                                 if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
    50                                                                         $noisette_a_garder = false;
    51                                                                         break;
    52                                                                 }
     18function noizetier_noisette_charger($recharger = false) {
     19
     20        // Retour de la fonction
     21        $retour = false;
     22
     23        // Initialiser le contexte de rechargement
     24        // TODO : en attente de voir si on rajoute un var_mode ou autre
     25        $forcer_chargement = $recharger;
     26
     27        // Initaliser la table et le where des noisettes.
     28        $from ='spip_noizetier_noisettes';
     29
     30        // On recherche les noisettes directement par leur fichier YAML de configuration car il est
     31        // obligatoire contrairement à une page.
     32        if ($fichiers = find_all_in_path('noisettes/', '.+[.]yaml$')) {
     33                $noisettes_nouvelles = $noisettes_modifiees = $noisettes_obsoletes = array();
     34                // Récupération des signatures md5 des noisettes déjà enregistrées.
     35                // Si on force le rechargement il est inutile de gérer les signatures et les noisettes modifiées ou obsolètes.
     36                $signatures = array();
     37                if (!$forcer_chargement) {
     38                        $select = array('noisette', 'signature');
     39                        if ($signatures = sql_allfetsel($select, $from)) {
     40                                $signatures = array_column($signatures, 'signature', 'page');
     41                        }
     42                        // On initialise la liste des noisettes à supprimer avec l'ensemble des noisettes en base de données.
     43                        $noisettes_obsoletes = $signatures ? array_keys($signatures) : array();
     44                }
     45
     46                foreach ($fichiers as $_squelette => $_chemin) {
     47                        $noisette = basename($_squelette, '.yaml');
     48                        // On passe le md5 de la page si il existe sinon la chaine vide. Cela permet de déterminer
     49                        // si on doit ajouter la page ou la mettre à jour.
     50                        // Si le md5 est le même et qu'il n'est donc pas utile de recharger la page, la configuration
     51                        // retournée est vide.
     52                        $options['md5'] = isset($signatures[$noisette]) ? $signatures[$noisette] : '';
     53                        $options['recharger'] = $forcer_chargement;
     54                        $options['yaml'] = $_chemin;
     55                        if ($configuration = noizetier_noisette_phraser($noisette, $options)) {
     56                                if (empty($configuration['identique'])) {
     57                                        // La noisette a été chargée (nouvelle) ou rechargée (modifiée).
     58                                        // Néanmoins, on n'inclue cette noisette que si les plugins qu'elle nécessite explicitement dans son
     59                                        // fichier de configuration sont bien tous activés.
     60                                        // Rappel: si une noisette est incluse dans un plugin non actif elle ne sera pas détectée
     61                                        //         lors du find_all_in_path() puisque le plugin n'est pas dans le path SPIP.
     62                                        //         Ce n'est pas ce cas qui est traité ici.
     63                                        $noisette_a_garder = true;
     64                                        $necessite = unserialize($configuration['necessite']);
     65                                        if (!empty($necessite)) {
     66                                                foreach ($necessite as $plugin) {
     67                                                        if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
     68                                                                $noisette_a_garder = false;
     69                                                                break;
    5370                                                        }
    5471                                                }
    55 
    56                                                 if ($noisette_a_garder) {
    57                                                         $noisettes[$noisette] = $configuration;
     72                                        }
     73
     74                                        // Si la noisette est à garder on détermine si elle est nouvelle ou modifiée.
     75                                        // En mode rechargement forcé toute noisette est considérée comme nouvelle.
     76                                        // Sinon, la noisette doit être retirée de la base car un plugin qu'elle nécessite a été désactivée:
     77                                        // => il suffit pour cela de la laisser dans la liste des noisettes obsolètes.
     78                                        if ($noisette_a_garder) {
     79                                                if (!$options['md5'] or $forcer_chargement) {
     80                                                        // La noisette est soit nouvelle soit on est en mode rechargement forcé:
     81                                                        // => il faut la rajouter dans la table.
     82                                                        $noisettes_nouvelles[] = $configuration;
     83                                                } else {
     84                                                        // La configuration stockée dans la table a été modifiée et le mode ne force pas le rechargement:
     85                                                        // => il faut mettre à jour la noisette dans la table.
     86                                                        $noisettes_modifiees[] = $configuration;
     87                                                        // => il faut donc la supprimer de la liste des noisettes obsolètes
     88                                                        $noisettes_obsoletes = array_diff($noisettes_obsoletes, array($noisette));
    5889                                                }
    5990                                        }
    60                                 }
    61                                 // Mise à jour du cache des descriptions
    62                                 if ($noisettes) {
    63                                         ecrire_fichier_securise(_CACHE_DESCRIPTIONS_NOISETTES, serialize($noisettes));
    64                                 }
    65                         }
    66                 } else {
    67                         // On renvoie le cache des descriptions.
    68                         $noisettes = $cache_noisettes;
    69                 }
    70         }
    71 
    72         // Application des filtres éventuellement demandés en argument de la fonction
    73         $noisettes_repertoriees = $noisettes;
    74         if ($filtres) {
    75                 foreach ($noisettes_repertoriees as $_noisette => $_configuration) {
    76                         foreach ($filtres as $_critere => $_valeur) {
    77                                 if (isset($_configuration[$_critere]) and ($_configuration[$_critere] != $_valeur)) {
    78                                         unset($noisettes_repertoriees[$_noisette]);
    79                                         break;
    80                                 }
    81                         }
    82                 }
    83         }
    84 
    85         return $noisettes_repertoriees;
    86 }
    87 
    88 
    89 /**
    90  * @param        $noisette
    91  * @param string $information
    92  * @param array  $options
    93  *
    94  * @return mixed|string
    95  */
    96 function noizetier_noisette_informer($noisette, $information = '', $options = array()) {
    97 
    98         static $description_noisette = array();
    99 
    100         if (!isset($description_noisette[$noisette])) {
    101                 // On essaye d'abord de récupérer la description dans le cache sauf si l'option recharger est activée
    102                 if (empty($options['recharger'])) {
    103                         if (lire_fichier_securise(_CACHE_DESCRIPTIONS_NOISETTES, $contenu)) {
    104                                 $cache_noisettes = unserialize($contenu);
    105                                 if (isset($cache_noisettes[$noisette])) {
    106                                         $description_noisette[$noisette] = $cache_noisettes[$noisette];
    10791                                } else {
    108                                         // On a pas trouvé la noisette dans le cache, on essaye de la charger directement
    109                                         $options['recharger'] = true;
    110                                 }
    111                         }
    112                 }
    113 
    114                 if (!empty($options['recharger'])) {
    115                         // Initialisation de la description et d'une description par défaut
    116                         $description = array();
    117                         $defaut = array(
    118                                 'nom' => $noisette,
    119                                 'description' => '',
    120                                 'icon' => 'noisette-24.png',
    121                                 'parametres' => array(),
    122                                 'necessite' => array(),
    123                                 'contexte' => array(),
    124                                 'ajax' => 'defaut',
    125                                 'inclusion' => 'statique',
    126                         );
    127 
    128                         // Le fichier YAML de la noisette est soit passé en argument soit à déterminer à partir de
    129                         // l'identifiant de la noisette.
    130                         $fichier = isset($options['yaml']) ? $options['yaml'] : find_in_path("noisettes/${noisette}.yaml");
    131                         if ($fichier) {
    132                                 include_spip('inc/yaml');
    133                                 if ($description = yaml_charger_inclusions(yaml_decode_file($fichier))) {
    134                                         if (isset($description['nom'])) {
    135                                                 $description['nom'] = _T_ou_typo($description['nom']);
    136                                         }
    137                                         if (isset($description['description'])) {
    138                                                 $description['description'] = _T_ou_typo($description['description']);
    139                                         }
    140                                         if (!empty($description['necessite']) and is_string($description['necessite'])) {
    141                                                 $description['necessite'] = array($description['necessite']);
    142                                         }
    143                                         if (!empty($description['contexte']) and is_string($description['contexte'])) {
    144                                                 $description['contexte'] = array($description['contexte']);
    145                                         }
    146 
    147                                         // Merge pour obtenir une description complète
    148                                         $description = array_merge($defaut, $description);
    149                                 }
    150                         }
    151 
    152                         // Sauvegarde de la description de la noisette pour une consultation ultérieure dans le même hit.
    153                         if ($description) {
    154                                 // Ajout du type de noisette
    155                                 $identifiants = explode('-', $noisette, 2);
    156                                 $description['type'] = isset($identifiants[1]) ? $identifiants[0] : '';
    157                                 $description_noisette[$noisette] = $description;
     92                                        // La noisette n'a pas changée et n'a donc pas été réchargée:
     93                                        // => Il faut donc juste indiquer qu'elle n'est pas obsolète.
     94                                        $noisettes_obsoletes = array_diff($noisettes_obsoletes, array($noisette));
     95                                }
    15896                        } else {
    159                                 $description_noisette[$noisette] = array();
    160                         }
    161                 }
    162         }
    163 
    164         if (!$information) {
    165                 return $description_noisette[$noisette];
    166         } elseif (isset($description_noisette[$noisette][$information])) {
    167                 return $description_noisette[$noisette][$information];
    168         } else {
    169                 return '';
    170         }
     97                                // Il y a eu une erreur sur lors du rechargement de la noisette.
     98                                // => il faut donc ne rien faire pour laisser la noisette dans les obsolètes
     99                        }
     100                }
     101
     102                // Mise à jour de la table des pages
     103                // -- Suppression des pages obsolètes ou de toute les pages non virtuelles si on est en mode
     104                //    rechargement forcé.
     105                if (sql_preferer_transaction()) {
     106                        sql_demarrer_transaction();
     107                }
     108                if ($noisettes_obsoletes) {
     109                        sql_delete($from, sql_in('noisette', $noisettes_obsoletes));
     110                } elseif ($forcer_chargement) {
     111                        sql_delete($from);
     112                }
     113                // -- Update des pages modifiées
     114                if ($noisettes_modifiees) {
     115                        sql_replace_multi($from, $noisettes_modifiees);
     116                }
     117                // -- Insertion des nouvelles pages
     118                if ($noisettes_nouvelles) {
     119                        sql_insertq_multi($from, $noisettes_nouvelles);
     120                }
     121                if (sql_preferer_transaction()) {
     122                        sql_terminer_transaction();
     123                }
     124
     125                $retour = true;
     126        }
     127
     128        return $retour;
     129}
     130
     131
     132function noizetier_noisette_phraser($noisette, $options = array()) {
     133
     134        // Initialisation de la description
     135        $description = array();
     136
     137        // Initialiser le contexte de chargement
     138        if (!isset($options['recharger'])) {
     139                $options['recharger'] = false;
     140        }
     141        if (!isset($options['md5']) or $options['recharger']) {
     142                $options['md5'] = '';
     143        }
     144
     145        // Initialiser les composants de l'identifiant de la noisette:
     146        // - type-noisette si la noisette est dédiée uniquement à une page ou une composition
     147        // - noisette sinon
     148        $identifiants = explode('-', $noisette);
     149
     150        // Initialisation de la description par défaut de la page
     151        $description_defaut = array(
     152                'noisette'       => $noisette,
     153                'type'           => isset($identifiants[1]) ? $identifiants[0] : '',
     154                'nom'            => $noisette,
     155                'description'    => '',
     156                'icon'           => 'noisette-24.png',
     157                'necessite'      => array(),
     158                'contexte'       => array(),
     159                'ajax'           => 'defaut',
     160                'inclusion'      => 'statique',
     161                'parametres'     => array(),
     162                'signature'      => '',
     163        );
     164
     165        // Recherche des noisettes par leur fichier YAML uniquement.
     166        $md5 = '';
     167        $fichier = isset($options['yaml']) ? $options['yaml'] : find_in_path("noisettes/${noisette}.yaml");
     168        if ($fichier) {
     169                // il y a un fichier YAML de configuration, on vérifie le md5 avant de charger le contenu.
     170                $md5 = md5_file($fichier);
     171                if ($md5 != $options['md5']) {
     172                        include_spip('inc/yaml');
     173                        $description = yaml_charger_inclusions(yaml_decode_file($fichier));
     174                        // Traitements des champs pouvant être soit une chaine soit un tableau
     175                        if (!empty($description['necessite']) and is_string($description['necessite'])) {
     176                                $description['necessite'] = array($description['necessite']);
     177                        }
     178                        if (!empty($description['contexte']) and is_string($description['contexte'])) {
     179                                $description['contexte'] = array($description['contexte']);
     180                        }
     181                }
     182        }
     183
     184        // Si la description est remplie c'est que le chargement a correctement eu lieu.
     185        // Sinon, si la noisette n'a pas changée on renvoie une description limitée à un indicateur d'identité pour
     186        // distinguer ce cas avec une erreur de chargement qui renvoie une description vide.
     187        if ($description) {
     188                // Mise à jour du md5
     189                $description['signature'] = $md5;
     190                // Complétude de la description avec les valeurs par défaut
     191                $description = array_merge($description_defaut, $description);
     192                // Sérialisation des champs necessite, contexte et parametres qui sont des tableaux
     193                $description['necessite'] = serialize($description['necessite']);
     194                $description['contexte'] = serialize($description['contexte']);
     195                $description['parametres'] = serialize($description['parametres']);
     196        } elseif ($md5 == $options['md5']) {
     197                $description['identique'] = true;
     198        }
     199
     200        return $description;
    171201}
    172202
     
    191221                        // On repertorie toutes les noisettes disponibles et on compare
    192222                        // avec la valeur par défaut configurée pour le noiZetier.
    193                         $noisettes = noizetier_noisette_repertorier();
    194                         foreach ($noisettes as $_noisette => $_configuration) {
    195                                 $est_ajax[$_noisette] = ($_configuration['ajax'] == 'defaut')
    196                                         ? $defaut_ajax
    197                                         : ($_configuration['ajax'] == 'non' ? false : true);
     223                        if ($noisettes = sql_allfetsel('noisette, ajax', 'spip_noizetier_noisettes')) {
     224                                $noisettes = array_column($noisettes, 'ajax', 'noisette');
     225                                foreach ($noisettes as $_noisette => $_configuration) {
     226                                        $est_ajax[$_noisette] = ($_configuration['ajax'] == 'defaut')
     227                                                ? $defaut_ajax
     228                                                : ($_configuration['ajax'] == 'non' ? false : true);
     229                                }
    198230                        }
    199231
     
    213245
    214246        return $est_ajax[$noisette];
    215 }
    216 
    217 
    218 /**
    219  * Charger les informations des contexte pour une noisette.
    220  *
    221  * @param string $noisette
    222  *
    223  * @return array
    224  */
    225 function noizetier_charger_contexte_noisette($noisette) {
    226         static $contexte_noisettes = null;
    227 
    228         if (is_null($contexte_noisettes[$noisette])) {
    229                 $noisettes = noizetier_lister_noisettes();
    230                 $contexte_noisettes[$noisette] = $noisettes[$noisette]['contexte'];
    231         }
    232 
    233         return $contexte_noisettes[$noisette];
    234 }
    235 
    236 
    237 /**
    238  * Ajoute une noisette à un bloc d'une page
    239  *
    240  * @param string $noisette
    241  *              Nom de la noisette à ajouter
    242  * @param string|array $page
    243  *              Nom de la page-composition OU tableau contenant l'objet et l'id_objet
    244  * @param string $bloc
    245  *              Nom du bloc où ajouter la noisette
    246  *
    247  * @return int
    248  *              Retourne l'identifiant de la nouvelle noisette
    249  **/
    250 function noizetier_ajouter_noisette($noisette, $page, $bloc) {
    251         $objet = '';
    252         $id_objet = 0;
    253         if (is_array($page)) {
    254                 $objet = $page['objet'];
    255                 $id_objet = $page['id_objet'];
    256                 $page = null;
    257         }
    258        
    259         if (autoriser('configurer', 'noizetier') && $noisette) {
    260                 include_spip('inc/saisies');
    261                 $info_noisette = noizetier_info_noisette($noisette);
    262                 $parametres = saisies_lister_valeurs_defaut($info_noisette['parametres']);
    263                
    264                 // On construit le where pour savoir quelles noisettes chercher
    265                 $where = array();
    266                 if ($page) {
    267                         $where[] = 'type = '.sql_quote(noizetier_page_type($page));
    268                         $where[] = 'composition = '.sql_quote(noizetier_page_composition($page));
    269                 }
    270                 else {
    271                         $where[] = 'objet = '.sql_quote($objet);
    272                         $where[] = 'id_objet = '.intval($id_objet);
    273                 }
    274                 $where[] = 'bloc = '.sql_quote($bloc);
    275                
    276                 // On cherche le rang suivant
    277                 $rang = intval(sql_getfetsel(
    278                         'rang',
    279                         'spip_noisettes',
    280                         $where,
    281                         '',
    282                         'rang DESC',
    283                         '0,1'
    284                 )) + 1;
    285                
    286                 $id_noisette = sql_insertq(
    287                         'spip_noisettes',
    288                         array(
    289                                 'type' => noizetier_page_type($page),
    290                                 'composition' => noizetier_page_composition($page),
    291                                 'objet' => $objet,
    292                                 'id_objet' => $id_objet,
    293                                 'bloc' => $bloc,
    294                                 'noisette' => $noisette,
    295                                 'rang' => $rang,
    296                                 'parametres' => serialize($parametres),
    297                         )
    298                 );
    299 
    300                 if ($id_noisette) {
    301                         // On invalide le cache
    302                         include_spip('inc/invalideur');
    303                         suivre_invalideur("id='noisette/$id_noisette'");
    304 
    305                         return $id_noisette;
    306                 }
    307         }
    308        
    309         return 0;
    310 }
    311 
    312 /**
    313  * Tri les noisettes d'une page
    314  * Attention : parfois la page est transmise dans $ordre (et peu éventuellement changer en cours, cas de la page-dist de Zpip-vide).
    315  *
    316  * @param string  $page
    317  * @param array $ordre
    318  *
    319  * @return bool
    320  */
    321 function noizetier_trier_noisette($page, $ordre) {
    322         // Vérifications
    323         if (
    324                 !autoriser('configurer', 'noizetier')
    325                 or !is_array($ordre)
    326                 or substr($ordre[0], 0, 4) != 'bloc'
    327         ) {
    328                 return false;
    329         }
    330        
    331         $objet = '';
    332         $id_objet = 0;
    333         if (is_array($page)) {
    334                 $objet = $page['objet'];
    335                 $id_objet = $page['id_objet'];
    336                 $type = '';
    337                 $composition = '';
    338         }
    339         elseif ($page) {
    340                 $type = noizetier_page_type($page);
    341                 $composition = noizetier_page_composition($page);
    342         }
    343        
    344         $modifs = array();
    345         foreach ($ordre as $entree) {
    346                 $entree = explode('-', $entree, 2);
    347                
    348                 if ($entree[0] == 'bloc') {
    349                         $bloc = $entree[1];
    350                         $rang = 1;
    351                 }
    352                 if ($entree[0] == 'page') {
    353                         $page = $entree[1];
    354                         $type = noizetier_page_type($page);
    355                         $composition = noizetier_page_composition($page);
    356                 }
    357                 if ($entree[0] == 'objet') {
    358                         $objet = $entree[1];
    359                 }
    360                 if ($entree[0] == 'id_objet') {
    361                         $id_objet = intval($entree[1]);
    362                 }
    363                 if ($entree[0] == 'noisette') {
    364                         $modifs[$entree[1]] = array(
    365                                 'bloc' => $bloc,
    366                                 'type' => $type,
    367                                 'composition' => $composition,
    368                                 'objet' => $objet,
    369                                 'id_objet' => $id_objet,
    370                                 'rang' => $rang,
    371                         );
    372                         $rang += 1;
    373                 }
    374                 if ($entree[0] == 'ajouter') {
    375                         $id_noisette = noizetier_ajouter_noisette($entree[1], $page, $bloc);
    376                         $modifs[$id_noisette] = array(
    377                                 'bloc' => $bloc,
    378                                 'type' => $type,
    379                                 'composition' => $composition,
    380                                 'objet' => $objet,
    381                                 'id_objet' => $id_objet,
    382                                 'rang' => $rang,
    383                         );
    384                         $rang += 1;
    385                 }
    386         }
    387 
    388         foreach ($modifs as $id_noisette => $valeurs) {
    389                 sql_updateq('spip_noisettes', $valeurs, 'id_noisette='.intval($id_noisette));
    390         }
    391 
    392         return true;
    393 }
    394 
    395 /**
    396  * Déplace une noisette au sein d'un bloc.
    397  *
    398  * @param int $id_noisette
    399  * @param string $sens
    400  */
    401 function noizetier_deplacer_noisette($id_noisette, $sens) {
    402         $id_noisette = intval($id_noisette);
    403         if ($sens != 'bas') {
    404                 $sens = 'haut';
    405         }
    406        
    407         if (autoriser('configurer', 'noizetier') and $id_noisette) {
    408                 // On récupère des infos sur le placement actuel
    409                 $noisette = sql_fetsel(
    410                         'bloc, type, composition, objet, id_objet, rang',
    411                         'spip_noisettes',
    412                         'id_noisette = '.$id_noisette
    413                 );
    414                 $bloc = $noisette['bloc'];
    415                 $type = $noisette['type'];
    416                 $composition = $noisette['composition'];
    417                 $objet = $noisette['objet'];
    418                 $id_objet = intval($noisette['id_objet']);
    419                 $rang_actuel = intval($noisette['rang']);
    420 
    421                 // On teste si y a une noisette suivante
    422                 $dernier_rang = intval(sql_getfetsel(
    423                         'rang',
    424                         'spip_noisettes',
    425                         array(
    426                                 'bloc = '.sql_quote($bloc),
    427                                 'type = '.sql_quote($type),
    428                                 'composition = '.sql_quote($composition),
    429                                 'objet = '.sql_quote($objet),
    430                                 'id_objet = '.$id_objet,
    431                         ),
    432                         '',
    433                         'rang desc',
    434                         '0,1'
    435                 ));
    436 
    437                 // Tant qu'on ne veut pas faire de tour complet
    438                 if (!($sens == 'bas' and $rang_actuel == $dernier_rang) and !($sens == 'haut' and $rang_actuel == 1)) {
    439                         // Alors on ne fait qu'échanger deux noisettes
    440                         $rang_echange = ($sens == 'bas') ? ($rang_actuel + 1) : ($rang_actuel - 1);
    441                         $ok = sql_updateq(
    442                                 'spip_noisettes',
    443                                 array(
    444                                         'rang' => $rang_actuel,
    445                                 ),
    446                                 array(
    447                                         'bloc = '.sql_quote($bloc),
    448                                         'type = '.sql_quote($type),
    449                                         'composition = '.sql_quote($composition),
    450                                         'objet = '.sql_quote($objet),
    451                                         'id_objet = '.$id_objet,
    452                                         'rang = '.$rang_echange,
    453                                 )
    454                         );
    455                         if ($ok) {
    456                                 $ok = sql_updateq(
    457                                         'spip_noisettes',
    458                                         array(
    459                                                 'rang' => $rang_echange,
    460                                         ),
    461                                         'id_noisette = '.$id_noisette
    462                                 );
    463                         }
    464                 }
    465                 // Sinon on fait un tour complet en déplaçant tout
    466                 else {
    467                         if ($sens == 'bas') {
    468                                 // Tout le monde descend d'un rang
    469                                 $ok = sql_update(
    470                                         'spip_noisettes',
    471                                         array(
    472                                                 'rang' => 'rang + 1',
    473                                         ),
    474                                         array(
    475                                                 'bloc = '.sql_quote($bloc),
    476                                                 'type = '.sql_quote($type),
    477                                                 'composition = '.sql_quote($composition),
    478                                                 'objet = '.sql_quote($objet),
    479                                                 'id_objet = '.$id_objet,
    480                                         )
    481                                 );
    482                                 // La noisette passe tout en haut
    483                                 if ($ok) {
    484                                         $ok = sql_updateq(
    485                                                 'spip_noisettes',
    486                                                 array(
    487                                                         'rang' => 1,
    488                                                 ),
    489                                                 'id_noisette = '.$id_noisette
    490                                         );
    491                                 }
    492                         } else {
    493                                 // Tout le monde monte d'un rang
    494                                 $ok = sql_update(
    495                                         'spip_noisettes',
    496                                         array(
    497                                                 'rang' => 'rang - 1',
    498                                         ),
    499                                         array(
    500                                                 'bloc = '.sql_quote($bloc),
    501                                                 'type = '.sql_quote($type),
    502                                                 'composition = '.sql_quote($composition),
    503                                                 'objet = '.sql_quote($objet),
    504                                                 'id_objet = '.$id_objet,
    505                                         )
    506                                 );
    507                                 // La noisette passe tout en bas
    508                                 if ($ok) {
    509                                         $ok = sql_updateq(
    510                                                 'spip_noisettes',
    511                                                 array(
    512                                                         'rang' => $dernier_rang,
    513                                                 ),
    514                                                 'id_noisette = '.$id_noisette
    515                                         );
    516                                 }
    517                         }
    518                 }
    519                 // On invalide le cache
    520                 include_spip('inc/invalideur');
    521                 suivre_invalideur("id='noisette/$id_noisette'");
    522         }
    523 }
    524 
    525 
    526 /**
    527  * Liste les blocs pour lesquels il y a des noisettes a inserer.
    528  *
    529  * @staticvar array $liste_blocs
    530  *
    531  * @return array
    532  */
    533 function noizetier_lister_blocs_avec_noisettes() {
    534         static $liste_blocs = null;
    535 
    536         if (is_null($liste_blocs)) {
    537                 include_spip('base/abstract_sql');
    538                
    539                 $liste_blocs = array();
    540                 $resultats = sql_allfetsel(
    541                         array('bloc', 'type', 'composition'),
    542                         'spip_noisettes',
    543                         '1',
    544                         array('bloc', 'type', 'composition')
    545                 );
    546                 foreach ($resultats as $res) {
    547                         if ($res['composition']) {
    548                                 $liste_blocs[] = $res['bloc'].'/'.$res['type'].'-'.$res['composition'];
    549                         } else {
    550                                 $liste_blocs[] = $res['bloc'].'/'.$res['type'];
    551                         }
    552                 }
    553         }
    554 
    555         return $liste_blocs;
    556 }
    557 
    558 /**
    559  * Liste les blocs pour lesquels il y a des noisettes a inserer POUR UN OBJET
    560  *
    561  * @staticvar array $liste_blocs
    562  *
    563  * @return array
    564  */
    565 function noizetier_lister_blocs_avec_noisettes_objet($objet, $id_objet) {
    566         static $liste_blocs = null;
    567 
    568         if (is_null($liste_blocs[$objet][$id_objet])) {
    569                 include_spip('base/abstract_sql');
    570                
    571                 $liste_blocs[$objet][$id_objet] = array();
    572                 $resultats = sql_allfetsel(
    573                         array('bloc'),
    574                         'spip_noisettes',
    575                         array(
    576                                 'objet = '.sql_quote($objet),
    577                                 'id_objet = '.intval($id_objet),
    578                         ),
    579                         array('bloc')
    580                 );
    581                 foreach ($resultats as $res) {
    582                         $liste_blocs[$objet][$id_objet][] = $res['bloc'].'/'.$objet;
    583                 }
    584         }
    585 
    586         return $liste_blocs[$objet][$id_objet];
    587 }
    588 
    589 
    590 /**
    591  * Retourne les elements du contexte uniquement
    592  * utiles a la noisette demande.
    593  *
    594  * @param
    595  *
    596  * @return
    597  **/
    598 function noizetier_choisir_contexte($noisette, $contexte_entrant, $id_noisette) {
    599         $contexte_noisette = array_flip(noizetier_obtenir_contexte($noisette));
    600 
    601         // On transmet toujours l'id_noisette et les variables se terminant par _$id_noisette (utilisees par exemple par Aveline pour la pagination)
    602         $contexte_min = array('id_noisette' => $id_noisette);
    603 
    604         if (isset($contexte_noisette['env'])) {
    605                 return array_merge($contexte_entrant, $contexte_min);
    606         }
    607 
    608         $l = -1 * (strlen($id_noisette) + 1);
    609         foreach ($contexte_entrant as $variable => $valeur) {
    610                 if (substr($variable, $l) == '_'.$id_noisette) {
    611                         $contexte_min[$variable] = $valeur;
    612                 }
    613         }
    614 
    615         if (isset($contexte_noisette['aucun'])) {
    616                 return $contexte_min;
    617         }
    618         if ($contexte_noisette) {
    619                 return array_merge(array_intersect_key($contexte_entrant, $contexte_noisette), $contexte_min);
    620         }
    621 
    622         return $contexte_entrant;
    623 }
    624 
    625 /**
    626  * Retourne la liste des contextes donc peut avoir besoin une noisette.
    627  *
    628  * @param
    629  *
    630  * @return
    631  **/
    632 function noizetier_obtenir_contexte($noisette) {
    633         static $noisettes = false;
    634 
    635         // seulement 1 fois par appel, on lit ou calcule tous les contextes
    636         if ($noisettes === false) {
    637                 // lire le cache des contextes sauves
    638                 lire_fichier_securise(_CACHE_CONTEXTE_NOISETTES, $noisettes);
    639                 $noisettes = @unserialize($noisettes);
    640 
    641                 // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
    642                 if (!$noisettes or (_request('var_mode') == 'recalcul')) {
    643                         $infos = noizetier_lister_noisettes();
    644                         $noisettes = array();
    645                         foreach ($infos as $cle_noisette => $infos) {
    646                                 $noisettes[$cle_noisette] = ($infos['contexte'] ? $infos['contexte'] : array());
    647                         }
    648                         ecrire_fichier_securise(_CACHE_CONTEXTE_NOISETTES, serialize($noisettes));
    649                 }
    650         }
    651 
    652         if (isset($noisettes[$noisette])) {
    653                 return $noisettes[$noisette];
    654         }
    655 
    656         return array();
    657 }
    658 
    659 
    660 /**
    661  * Retourne true ou false pour indiquer si la noisette doit être inclue dynamiquement.
    662  *
    663  * @param
    664  *
    665  * @return
    666  **/
    667 function noizetier_inclusion_dynamique($noisette) {
    668         static $noisettes = false;
    669 
    670         // seulement 1 fois par appel, on lit ou calcule tous les contextes
    671         if ($noisettes === false) {
    672                 // lire le cache des contextes sauves
    673                 lire_fichier_securise(_CACHE_INCLUSIONS_NOISETTES, $noisettes);
    674                 $noisettes = @unserialize($noisettes);
    675 
    676                 // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
    677                 if (!$noisettes or (_request('var_mode') == 'recalcul')) {
    678                         $infos = noizetier_lister_noisettes();
    679                         $noisettes = array();
    680                         foreach ($infos as $cle_noisette => $infos) {
    681                                 $noisettes[$cle_noisette] = ($infos['inclusion'] == 'dynamique') ? true : false;
    682                         }
    683                         ecrire_fichier_securise(_CACHE_INCLUSIONS_NOISETTES, serialize($noisettes));
    684                 }
    685         }
    686 
    687         if (isset($noisettes[$noisette])) {
    688                 return $noisettes[$noisette];
    689         }
    690 
    691         return false;
    692 }
    693 
    694 /**
    695  * Retourne le tableau des noisettes et des compositions du noizetier pour les exports.
    696  *
    697  * @return
    698  **/
    699 function noizetier_tableau_export() {
    700         $data = array();
    701 
    702         // On calcule le tableau des noisettes
    703         $data['noisettes'] = sql_allfetsel(
    704                 'type, composition, bloc, noisette, parametres, css',
    705                 'spip_noisettes',
    706                 '1',
    707                 '',
    708                 'type, composition, bloc, rang'
    709         );
    710 
    711         // On remet au propre les parametres
    712         foreach ($data['noisettes'] as $cle => $noisette) {
    713                 $data['noisettes'][$cle]['parametres'] = unserialize($noisette['parametres']);
    714         }
    715 
    716         // On recupere les compositions du noizetier
    717         $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
    718         if (is_array($noizetier_compositions) and count($noizetier_compositions) > 0) {
    719                 $data['noizetier_compositions'] = $noizetier_compositions;
    720         }
    721 
    722         $data = pipeline('noizetier_config_export', $data);
    723 
    724         return $data;
    725 }
    726 
    727 /**
    728  * Importe une configuration de noisettes et de compositions.
    729  *
    730  * @param string  $type_import
    731  * @param string  $import_compos
    732  * @param array $config
    733  *
    734  * @return bool
    735  */
    736 function noizetier_importer_configuration($type_import, $import_compos, $config) {
    737         if ($type_import != 'remplacer') {
    738                 $type_import = 'fusion';
    739         }
    740         if ($import_compos != 'oui') {
    741                 $import_compos = 'non';
    742         }
    743 
    744         $config = pipeline('noizetier_config_import', $config);
    745 
    746         // On s'occupe deja des noisettes
    747         $noisettes = $config['noisettes'];
    748         include_spip('base/abstract_sql');
    749         if (is_array($noisettes) and count($noisettes) > 0) {
    750                 $noisettes_insert = array();
    751                 $rang = 1;
    752                 $page = '';
    753                
    754                 if ($type_import == 'remplacer') {
    755                         sql_delete('spip_noisettes', '1');
    756                 }
    757                
    758                 foreach ($noisettes as $noisette) {
    759                         $type = $noisette['type'];
    760                         $composition = $noisette['composition'];
    761                         if ($type.'-'.$composition != $page) {
    762                                 $page = $type.'-'.$composition;
    763                                 $rang = 1;
    764                                 if ($type_import == 'fusion') {
    765                                         $rang = sql_getfetsel('rang', 'spip_noisettes', 'type='.sql_quote($type).' AND composition='.sql_quote($composition), '', 'rang DESC') + 1;
    766                                 }
    767                         } else {
    768                                 $rang = $rang + 1;
    769                         }
    770                         $noisette['rang'] = $rang;
    771                         $noisette['parametres'] = serialize($noisette['parametres']);
    772                         $noisettes_insert[] = $noisette;
    773                 }
    774                
    775                 $ok = sql_insertq_multi('spip_noisettes', $noisettes_insert);
    776         }
    777 
    778         // On s'occupe des compositions du noizetier
    779         if ($import_compos == 'oui') {
    780                 include_spip('inc/meta');
    781                 $compos_importees = $config['noizetier_compositions'];
    782                 if (is_array($compos_importees) and count($compos_importees) > 0) {
    783                         if ($type_import == 'remplacer') {
    784                                 effacer_meta('noizetier_compositions');
    785                         } else {
    786                                 $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
    787                         }
    788 
    789                         if (!is_array($noizetier_compositions)) {
    790                                 $noizetier_compositions = array();
    791                         }
    792 
    793                         foreach ($compos_importees as $type => $compos_type) {
    794                                 foreach ($compos_type as $composition => $info_compo) {
    795                                         $noizetier_compositions[$type][$composition] = $info_compo;
    796                                 }
    797                         }
    798 
    799                         ecrire_meta('noizetier_compositions', serialize($noizetier_compositions));
    800                         ecrire_metas();
    801                 }
    802         }
    803 
    804         // On invalide le cache
    805         include_spip('inc/invalideur');
    806         suivre_invalideur('noizetier-import-config');
    807 
    808         return $ok;
    809247}
    810248
  • _plugins_/noizetier/trunk/noizetier_vieilles_fonctions.php

    r104894 r104909  
    1111// -------------------------------------------------------------------
    1212
     13
     14// API à traiter
     15// -------------
     16/**
     17 * Charger les informations des contexte pour une noisette.
     18 *
     19 * @param string $noisette
     20 *
     21 * @return array
     22 */
     23function noizetier_charger_contexte_noisette($noisette) {
     24        static $contexte_noisettes = null;
     25
     26        if (is_null($contexte_noisettes[$noisette])) {
     27                $noisettes = noizetier_lister_noisettes();
     28                $contexte_noisettes[$noisette] = $noisettes[$noisette]['contexte'];
     29        }
     30
     31        return $contexte_noisettes[$noisette];
     32}
     33
     34
     35/**
     36 * Ajoute une noisette à un bloc d'une page
     37 *
     38 * @param string $noisette
     39 *              Nom de la noisette à ajouter
     40 * @param string|array $page
     41 *              Nom de la page-composition OU tableau contenant l'objet et l'id_objet
     42 * @param string $bloc
     43 *              Nom du bloc où ajouter la noisette
     44 *
     45 * @return int
     46 *              Retourne l'identifiant de la nouvelle noisette
     47 **/
     48function noizetier_ajouter_noisette($noisette, $page, $bloc) {
     49        $objet = '';
     50        $id_objet = 0;
     51        if (is_array($page)) {
     52                $objet = $page['objet'];
     53                $id_objet = $page['id_objet'];
     54                $page = null;
     55        }
     56
     57        if (autoriser('configurer', 'noizetier') && $noisette) {
     58                include_spip('inc/saisies');
     59                $info_noisette = noizetier_info_noisette($noisette);
     60                $parametres = saisies_lister_valeurs_defaut($info_noisette['parametres']);
     61
     62                // On construit le where pour savoir quelles noisettes chercher
     63                $where = array();
     64                if ($page) {
     65                        $where[] = 'type = '.sql_quote(noizetier_page_type($page));
     66                        $where[] = 'composition = '.sql_quote(noizetier_page_composition($page));
     67                }
     68                else {
     69                        $where[] = 'objet = '.sql_quote($objet);
     70                        $where[] = 'id_objet = '.intval($id_objet);
     71                }
     72                $where[] = 'bloc = '.sql_quote($bloc);
     73
     74                // On cherche le rang suivant
     75                $rang = intval(sql_getfetsel(
     76                        'rang',
     77                        'spip_noisettes',
     78                        $where,
     79                        '',
     80                        'rang DESC',
     81                        '0,1'
     82                )) + 1;
     83
     84                $id_noisette = sql_insertq(
     85                        'spip_noisettes',
     86                        array(
     87                                'type' => noizetier_page_type($page),
     88                                'composition' => noizetier_page_composition($page),
     89                                'objet' => $objet,
     90                                'id_objet' => $id_objet,
     91                                'bloc' => $bloc,
     92                                'noisette' => $noisette,
     93                                'rang' => $rang,
     94                                'parametres' => serialize($parametres),
     95                        )
     96                );
     97
     98                if ($id_noisette) {
     99                        // On invalide le cache
     100                        include_spip('inc/invalideur');
     101                        suivre_invalideur("id='noisette/$id_noisette'");
     102
     103                        return $id_noisette;
     104                }
     105        }
     106
     107        return 0;
     108}
     109
     110/**
     111 * Tri les noisettes d'une page
     112 * Attention : parfois la page est transmise dans $ordre (et peu éventuellement changer en cours, cas de la page-dist de Zpip-vide).
     113 *
     114 * @param string  $page
     115 * @param array $ordre
     116 *
     117 * @return bool
     118 */
     119function noizetier_trier_noisette($page, $ordre) {
     120        // Vérifications
     121        if (
     122                !autoriser('configurer', 'noizetier')
     123                or !is_array($ordre)
     124                or substr($ordre[0], 0, 4) != 'bloc'
     125        ) {
     126                return false;
     127        }
     128
     129        $objet = '';
     130        $id_objet = 0;
     131        if (is_array($page)) {
     132                $objet = $page['objet'];
     133                $id_objet = $page['id_objet'];
     134                $type = '';
     135                $composition = '';
     136        }
     137        elseif ($page) {
     138                $type = noizetier_page_type($page);
     139                $composition = noizetier_page_composition($page);
     140        }
     141
     142        $modifs = array();
     143        foreach ($ordre as $entree) {
     144                $entree = explode('-', $entree, 2);
     145
     146                if ($entree[0] == 'bloc') {
     147                        $bloc = $entree[1];
     148                        $rang = 1;
     149                }
     150                if ($entree[0] == 'page') {
     151                        $page = $entree[1];
     152                        $type = noizetier_page_type($page);
     153                        $composition = noizetier_page_composition($page);
     154                }
     155                if ($entree[0] == 'objet') {
     156                        $objet = $entree[1];
     157                }
     158                if ($entree[0] == 'id_objet') {
     159                        $id_objet = intval($entree[1]);
     160                }
     161                if ($entree[0] == 'noisette') {
     162                        $modifs[$entree[1]] = array(
     163                                'bloc' => $bloc,
     164                                'type' => $type,
     165                                'composition' => $composition,
     166                                'objet' => $objet,
     167                                'id_objet' => $id_objet,
     168                                'rang' => $rang,
     169                        );
     170                        $rang += 1;
     171                }
     172                if ($entree[0] == 'ajouter') {
     173                        $id_noisette = noizetier_ajouter_noisette($entree[1], $page, $bloc);
     174                        $modifs[$id_noisette] = array(
     175                                'bloc' => $bloc,
     176                                'type' => $type,
     177                                'composition' => $composition,
     178                                'objet' => $objet,
     179                                'id_objet' => $id_objet,
     180                                'rang' => $rang,
     181                        );
     182                        $rang += 1;
     183                }
     184        }
     185
     186        foreach ($modifs as $id_noisette => $valeurs) {
     187                sql_updateq('spip_noisettes', $valeurs, 'id_noisette='.intval($id_noisette));
     188        }
     189
     190        return true;
     191}
     192
     193/**
     194 * Déplace une noisette au sein d'un bloc.
     195 *
     196 * @param int $id_noisette
     197 * @param string $sens
     198 */
     199function noizetier_deplacer_noisette($id_noisette, $sens) {
     200        $id_noisette = intval($id_noisette);
     201        if ($sens != 'bas') {
     202                $sens = 'haut';
     203        }
     204
     205        if (autoriser('configurer', 'noizetier') and $id_noisette) {
     206                // On récupère des infos sur le placement actuel
     207                $noisette = sql_fetsel(
     208                        'bloc, type, composition, objet, id_objet, rang',
     209                        'spip_noisettes',
     210                        'id_noisette = '.$id_noisette
     211                );
     212                $bloc = $noisette['bloc'];
     213                $type = $noisette['type'];
     214                $composition = $noisette['composition'];
     215                $objet = $noisette['objet'];
     216                $id_objet = intval($noisette['id_objet']);
     217                $rang_actuel = intval($noisette['rang']);
     218
     219                // On teste si y a une noisette suivante
     220                $dernier_rang = intval(sql_getfetsel(
     221                        'rang',
     222                        'spip_noisettes',
     223                        array(
     224                                'bloc = '.sql_quote($bloc),
     225                                'type = '.sql_quote($type),
     226                                'composition = '.sql_quote($composition),
     227                                'objet = '.sql_quote($objet),
     228                                'id_objet = '.$id_objet,
     229                        ),
     230                        '',
     231                        'rang desc',
     232                        '0,1'
     233                ));
     234
     235                // Tant qu'on ne veut pas faire de tour complet
     236                if (!($sens == 'bas' and $rang_actuel == $dernier_rang) and !($sens == 'haut' and $rang_actuel == 1)) {
     237                        // Alors on ne fait qu'échanger deux noisettes
     238                        $rang_echange = ($sens == 'bas') ? ($rang_actuel + 1) : ($rang_actuel - 1);
     239                        $ok = sql_updateq(
     240                                'spip_noisettes',
     241                                array(
     242                                        'rang' => $rang_actuel,
     243                                ),
     244                                array(
     245                                        'bloc = '.sql_quote($bloc),
     246                                        'type = '.sql_quote($type),
     247                                        'composition = '.sql_quote($composition),
     248                                        'objet = '.sql_quote($objet),
     249                                        'id_objet = '.$id_objet,
     250                                        'rang = '.$rang_echange,
     251                                )
     252                        );
     253                        if ($ok) {
     254                                $ok = sql_updateq(
     255                                        'spip_noisettes',
     256                                        array(
     257                                                'rang' => $rang_echange,
     258                                        ),
     259                                        'id_noisette = '.$id_noisette
     260                                );
     261                        }
     262                }
     263                // Sinon on fait un tour complet en déplaçant tout
     264                else {
     265                        if ($sens == 'bas') {
     266                                // Tout le monde descend d'un rang
     267                                $ok = sql_update(
     268                                        'spip_noisettes',
     269                                        array(
     270                                                'rang' => 'rang + 1',
     271                                        ),
     272                                        array(
     273                                                'bloc = '.sql_quote($bloc),
     274                                                'type = '.sql_quote($type),
     275                                                'composition = '.sql_quote($composition),
     276                                                'objet = '.sql_quote($objet),
     277                                                'id_objet = '.$id_objet,
     278                                        )
     279                                );
     280                                // La noisette passe tout en haut
     281                                if ($ok) {
     282                                        $ok = sql_updateq(
     283                                                'spip_noisettes',
     284                                                array(
     285                                                        'rang' => 1,
     286                                                ),
     287                                                'id_noisette = '.$id_noisette
     288                                        );
     289                                }
     290                        } else {
     291                                // Tout le monde monte d'un rang
     292                                $ok = sql_update(
     293                                        'spip_noisettes',
     294                                        array(
     295                                                'rang' => 'rang - 1',
     296                                        ),
     297                                        array(
     298                                                'bloc = '.sql_quote($bloc),
     299                                                'type = '.sql_quote($type),
     300                                                'composition = '.sql_quote($composition),
     301                                                'objet = '.sql_quote($objet),
     302                                                'id_objet = '.$id_objet,
     303                                        )
     304                                );
     305                                // La noisette passe tout en bas
     306                                if ($ok) {
     307                                        $ok = sql_updateq(
     308                                                'spip_noisettes',
     309                                                array(
     310                                                        'rang' => $dernier_rang,
     311                                                ),
     312                                                'id_noisette = '.$id_noisette
     313                                        );
     314                                }
     315                        }
     316                }
     317                // On invalide le cache
     318                include_spip('inc/invalideur');
     319                suivre_invalideur("id='noisette/$id_noisette'");
     320        }
     321}
     322
     323
     324/**
     325 * Liste les blocs pour lesquels il y a des noisettes a inserer.
     326 *
     327 * @staticvar array $liste_blocs
     328 *
     329 * @return array
     330 */
     331function noizetier_lister_blocs_avec_noisettes() {
     332        static $liste_blocs = null;
     333
     334        if (is_null($liste_blocs)) {
     335                include_spip('base/abstract_sql');
     336
     337                $liste_blocs = array();
     338                $resultats = sql_allfetsel(
     339                        array('bloc', 'type', 'composition'),
     340                        'spip_noisettes',
     341                        '1',
     342                        array('bloc', 'type', 'composition')
     343                );
     344                foreach ($resultats as $res) {
     345                        if ($res['composition']) {
     346                                $liste_blocs[] = $res['bloc'].'/'.$res['type'].'-'.$res['composition'];
     347                        } else {
     348                                $liste_blocs[] = $res['bloc'].'/'.$res['type'];
     349                        }
     350                }
     351        }
     352
     353        return $liste_blocs;
     354}
     355
     356/**
     357 * Liste les blocs pour lesquels il y a des noisettes a inserer POUR UN OBJET
     358 *
     359 * @staticvar array $liste_blocs
     360 *
     361 * @return array
     362 */
     363function noizetier_lister_blocs_avec_noisettes_objet($objet, $id_objet) {
     364        static $liste_blocs = null;
     365
     366        if (is_null($liste_blocs[$objet][$id_objet])) {
     367                include_spip('base/abstract_sql');
     368
     369                $liste_blocs[$objet][$id_objet] = array();
     370                $resultats = sql_allfetsel(
     371                        array('bloc'),
     372                        'spip_noisettes',
     373                        array(
     374                                'objet = '.sql_quote($objet),
     375                                'id_objet = '.intval($id_objet),
     376                        ),
     377                        array('bloc')
     378                );
     379                foreach ($resultats as $res) {
     380                        $liste_blocs[$objet][$id_objet][] = $res['bloc'].'/'.$objet;
     381                }
     382        }
     383
     384        return $liste_blocs[$objet][$id_objet];
     385}
     386
     387
     388/**
     389 * Retourne les elements du contexte uniquement
     390 * utiles a la noisette demande.
     391 *
     392 * @param
     393 *
     394 * @return
     395 **/
     396function noizetier_choisir_contexte($noisette, $contexte_entrant, $id_noisette) {
     397        $contexte_noisette = array_flip(noizetier_obtenir_contexte($noisette));
     398
     399        // On transmet toujours l'id_noisette et les variables se terminant par _$id_noisette (utilisees par exemple par Aveline pour la pagination)
     400        $contexte_min = array('id_noisette' => $id_noisette);
     401
     402        if (isset($contexte_noisette['env'])) {
     403                return array_merge($contexte_entrant, $contexte_min);
     404        }
     405
     406        $l = -1 * (strlen($id_noisette) + 1);
     407        foreach ($contexte_entrant as $variable => $valeur) {
     408                if (substr($variable, $l) == '_'.$id_noisette) {
     409                        $contexte_min[$variable] = $valeur;
     410                }
     411        }
     412
     413        if (isset($contexte_noisette['aucun'])) {
     414                return $contexte_min;
     415        }
     416        if ($contexte_noisette) {
     417                return array_merge(array_intersect_key($contexte_entrant, $contexte_noisette), $contexte_min);
     418        }
     419
     420        return $contexte_entrant;
     421}
     422
     423/**
     424 * Retourne la liste des contextes donc peut avoir besoin une noisette.
     425 *
     426 * @param
     427 *
     428 * @return
     429 **/
     430function noizetier_obtenir_contexte($noisette) {
     431        static $noisettes = false;
     432
     433        // seulement 1 fois par appel, on lit ou calcule tous les contextes
     434        if ($noisettes === false) {
     435                // lire le cache des contextes sauves
     436                lire_fichier_securise(_CACHE_CONTEXTE_NOISETTES, $noisettes);
     437                $noisettes = @unserialize($noisettes);
     438
     439                // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
     440                if (!$noisettes or (_request('var_mode') == 'recalcul')) {
     441                        $infos = noizetier_lister_noisettes();
     442                        $noisettes = array();
     443                        foreach ($infos as $cle_noisette => $infos) {
     444                                $noisettes[$cle_noisette] = ($infos['contexte'] ? $infos['contexte'] : array());
     445                        }
     446                        ecrire_fichier_securise(_CACHE_CONTEXTE_NOISETTES, serialize($noisettes));
     447                }
     448        }
     449
     450        if (isset($noisettes[$noisette])) {
     451                return $noisettes[$noisette];
     452        }
     453
     454        return array();
     455}
     456
     457
     458/**
     459 * Retourne true ou false pour indiquer si la noisette doit être inclue dynamiquement.
     460 *
     461 * @param
     462 *
     463 * @return
     464 **/
     465function noizetier_inclusion_dynamique($noisette) {
     466        static $noisettes = false;
     467
     468        // seulement 1 fois par appel, on lit ou calcule tous les contextes
     469        if ($noisettes === false) {
     470                // lire le cache des contextes sauves
     471                lire_fichier_securise(_CACHE_INCLUSIONS_NOISETTES, $noisettes);
     472                $noisettes = @unserialize($noisettes);
     473
     474                // s'il en mode recalcul, on recalcule tous les contextes des noisettes trouvees.
     475                if (!$noisettes or (_request('var_mode') == 'recalcul')) {
     476                        $infos = noizetier_lister_noisettes();
     477                        $noisettes = array();
     478                        foreach ($infos as $cle_noisette => $infos) {
     479                                $noisettes[$cle_noisette] = ($infos['inclusion'] == 'dynamique') ? true : false;
     480                        }
     481                        ecrire_fichier_securise(_CACHE_INCLUSIONS_NOISETTES, serialize($noisettes));
     482                }
     483        }
     484
     485        if (isset($noisettes[$noisette])) {
     486                return $noisettes[$noisette];
     487        }
     488
     489        return false;
     490}
     491
     492/**
     493 * Retourne le tableau des noisettes et des compositions du noizetier pour les exports.
     494 *
     495 * @return
     496 **/
     497function noizetier_tableau_export() {
     498        $data = array();
     499
     500        // On calcule le tableau des noisettes
     501        $data['noisettes'] = sql_allfetsel(
     502                'type, composition, bloc, noisette, parametres, css',
     503                'spip_noisettes',
     504                '1',
     505                '',
     506                'type, composition, bloc, rang'
     507        );
     508
     509        // On remet au propre les parametres
     510        foreach ($data['noisettes'] as $cle => $noisette) {
     511                $data['noisettes'][$cle]['parametres'] = unserialize($noisette['parametres']);
     512        }
     513
     514        // On recupere les compositions du noizetier
     515        $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
     516        if (is_array($noizetier_compositions) and count($noizetier_compositions) > 0) {
     517                $data['noizetier_compositions'] = $noizetier_compositions;
     518        }
     519
     520        $data = pipeline('noizetier_config_export', $data);
     521
     522        return $data;
     523}
     524
     525/**
     526 * Importe une configuration de noisettes et de compositions.
     527 *
     528 * @param string  $type_import
     529 * @param string  $import_compos
     530 * @param array $config
     531 *
     532 * @return bool
     533 */
     534function noizetier_importer_configuration($type_import, $import_compos, $config) {
     535        if ($type_import != 'remplacer') {
     536                $type_import = 'fusion';
     537        }
     538        if ($import_compos != 'oui') {
     539                $import_compos = 'non';
     540        }
     541
     542        $config = pipeline('noizetier_config_import', $config);
     543
     544        // On s'occupe deja des noisettes
     545        $noisettes = $config['noisettes'];
     546        include_spip('base/abstract_sql');
     547        if (is_array($noisettes) and count($noisettes) > 0) {
     548                $noisettes_insert = array();
     549                $rang = 1;
     550                $page = '';
     551
     552                if ($type_import == 'remplacer') {
     553                        sql_delete('spip_noisettes', '1');
     554                }
     555
     556                foreach ($noisettes as $noisette) {
     557                        $type = $noisette['type'];
     558                        $composition = $noisette['composition'];
     559                        if ($type.'-'.$composition != $page) {
     560                                $page = $type.'-'.$composition;
     561                                $rang = 1;
     562                                if ($type_import == 'fusion') {
     563                                        $rang = sql_getfetsel('rang', 'spip_noisettes', 'type='.sql_quote($type).' AND composition='.sql_quote($composition), '', 'rang DESC') + 1;
     564                                }
     565                        } else {
     566                                $rang = $rang + 1;
     567                        }
     568                        $noisette['rang'] = $rang;
     569                        $noisette['parametres'] = serialize($noisette['parametres']);
     570                        $noisettes_insert[] = $noisette;
     571                }
     572
     573                $ok = sql_insertq_multi('spip_noisettes', $noisettes_insert);
     574        }
     575
     576        // On s'occupe des compositions du noizetier
     577        if ($import_compos == 'oui') {
     578                include_spip('inc/meta');
     579                $compos_importees = $config['noizetier_compositions'];
     580                if (is_array($compos_importees) and count($compos_importees) > 0) {
     581                        if ($type_import == 'remplacer') {
     582                                effacer_meta('noizetier_compositions');
     583                        } else {
     584                                $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
     585                        }
     586
     587                        if (!is_array($noizetier_compositions)) {
     588                                $noizetier_compositions = array();
     589                        }
     590
     591                        foreach ($compos_importees as $type => $compos_type) {
     592                                foreach ($compos_type as $composition => $info_compo) {
     593                                        $noizetier_compositions[$type][$composition] = $info_compo;
     594                                }
     595                        }
     596
     597                        ecrire_meta('noizetier_compositions', serialize($noizetier_compositions));
     598                        ecrire_metas();
     599                }
     600        }
     601
     602        // On invalide le cache
     603        include_spip('inc/invalideur');
     604        suivre_invalideur('noizetier-import-config');
     605
     606        return $ok;
     607}
     608
     609// API en cours de traitement
     610// --------------------------
     611/**
     612 * @param array $filtres
     613 *
     614 * @return array|mixed|null
     615 */
     616function noizetier_noisette_repertorier($filtres = array()) {
     617        static $noisettes = null;
     618
     619        if (is_null($noisettes)) {
     620                // On détermine l'existence et le contenu du cache.
     621                $cache_noisettes = array();
     622                if (lire_fichier_securise(_CACHE_DESCRIPTIONS_NOISETTES, $contenu)) {
     623                        $cache_noisettes = unserialize($contenu);
     624                }
     625
     626                if (!$cache_noisettes
     627                or (_request('var_mode') == 'recalcul')
     628                or (defined('_NO_CACHE') and (_NO_CACHE != 0))) {
     629                        // On doit recalculer le cache
     630                        if ($fichiers = find_all_in_path('noisettes/', '.+[.]yaml$')) {
     631                                foreach ($fichiers as $_fichier => $_chemin) {
     632                                        $noisette = basename($_fichier, '.yaml');
     633                                        $options = array('recharger' => true, 'yaml' => $_chemin);
     634                                        if ($configuration = noizetier_noisette_informer($noisette, '', $options)) {
     635                                                // On n'inclue la noisette que si les plugins qu'elle nécessite explicitement dans son
     636                                                // fichier de configuration sont bien tous activés.
     637                                                // Rappel : si une noisette est incluse dans un plugin non actif elle ne sera pas détectée
     638                                                //          lors du find_all_in_path() puisque le plugin n'est pas dans le path SPIP.
     639                                                $noisette_a_garder = true;
     640                                                if (isset($configuration['necessite'])) {
     641                                                        foreach ($configuration['necessite'] as $plugin) {
     642                                                                if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
     643                                                                        $noisette_a_garder = false;
     644                                                                        break;
     645                                                                }
     646                                                        }
     647                                                }
     648
     649                                                if ($noisette_a_garder) {
     650                                                        $noisettes[$noisette] = $configuration;
     651                                                }
     652                                        }
     653                                }
     654                                // Mise à jour du cache des descriptions
     655                                if ($noisettes) {
     656                                        ecrire_fichier_securise(_CACHE_DESCRIPTIONS_NOISETTES, serialize($noisettes));
     657                                }
     658                        }
     659                } else {
     660                        // On renvoie le cache des descriptions.
     661                        $noisettes = $cache_noisettes;
     662                }
     663        }
     664
     665        // Application des filtres éventuellement demandés en argument de la fonction
     666        $noisettes_repertoriees = $noisettes;
     667        if ($filtres) {
     668                foreach ($noisettes_repertoriees as $_noisette => $_configuration) {
     669                        foreach ($filtres as $_critere => $_valeur) {
     670                                if (isset($_configuration[$_critere]) and ($_configuration[$_critere] != $_valeur)) {
     671                                        unset($noisettes_repertoriees[$_noisette]);
     672                                        break;
     673                                }
     674                        }
     675                }
     676        }
     677
     678        return $noisettes_repertoriees;
     679}
     680
     681
     682
     683/**
     684 * @param        $noisette
     685 * @param string $information
     686 * @param array  $options
     687 *
     688 * @return mixed|string
     689 */
     690function noizetier_noisette_informer($noisette, $information = '', $options = array()) {
     691
     692        static $description_noisette = array();
     693
     694        if (!isset($description_noisette[$noisette])) {
     695                // On essaye d'abord de récupérer la description dans le cache sauf si l'option recharger est activée
     696                if (empty($options['recharger'])) {
     697                        if (lire_fichier_securise(_CACHE_DESCRIPTIONS_NOISETTES, $contenu)) {
     698                                $cache_noisettes = unserialize($contenu);
     699                                if (isset($cache_noisettes[$noisette])) {
     700                                        $description_noisette[$noisette] = $cache_noisettes[$noisette];
     701                                } else {
     702                                        // On a pas trouvé la noisette dans le cache, on essaye de la charger directement
     703                                        $options['recharger'] = true;
     704                                }
     705                        }
     706                }
     707
     708                if (!empty($options['recharger'])) {
     709                        // Initialisation de la description et d'une description par défaut
     710                        $description = array();
     711                        $defaut = array(
     712                                'nom' => $noisette,
     713                                'description' => '',
     714                                'icon' => 'noisette-24.png',
     715                                'parametres' => array(),
     716                                'necessite' => array(),
     717                                'contexte' => array(),
     718                                'ajax' => 'defaut',
     719                                'inclusion' => 'statique',
     720                        );
     721
     722                        // Le fichier YAML de la noisette est soit passé en argument soit à déterminer à partir de
     723                        // l'identifiant de la noisette.
     724                        $fichier = isset($options['yaml']) ? $options['yaml'] : find_in_path("noisettes/${noisette}.yaml");
     725                        if ($fichier) {
     726                                include_spip('inc/yaml');
     727                                if ($description = yaml_charger_inclusions(yaml_decode_file($fichier))) {
     728                                        if (isset($description['nom'])) {
     729                                                $description['nom'] = _T_ou_typo($description['nom']);
     730                                        }
     731                                        if (isset($description['description'])) {
     732                                                $description['description'] = _T_ou_typo($description['description']);
     733                                        }
     734                                        if (!empty($description['necessite']) and is_string($description['necessite'])) {
     735                                                $description['necessite'] = array($description['necessite']);
     736                                        }
     737                                        if (!empty($description['contexte']) and is_string($description['contexte'])) {
     738                                                $description['contexte'] = array($description['contexte']);
     739                                        }
     740
     741                                        // Merge pour obtenir une description complète
     742                                        $description = array_merge($defaut, $description);
     743                                }
     744                        }
     745
     746                        // Sauvegarde de la description de la noisette pour une consultation ultérieure dans le même hit.
     747                        if ($description) {
     748                                // Ajout du type de noisette
     749                                $identifiants = explode('-', $noisette, 2);
     750                                $description['type'] = isset($identifiants[1]) ? $identifiants[0] : '';
     751                                $description_noisette[$noisette] = $description;
     752                        } else {
     753                                $description_noisette[$noisette] = array();
     754                        }
     755                }
     756        }
     757
     758        if (!$information) {
     759                return $description_noisette[$noisette];
     760        } elseif (isset($description_noisette[$noisette][$information])) {
     761                return $description_noisette[$noisette][$information];
     762        } else {
     763                return '';
     764        }
     765}
     766
     767// API traitées
     768// ------------
    13769/**
    14770 * Lister les noisettes disponibles dans les dossiers noisettes/.
Note: See TracChangeset for help on using the changeset viewer.