Changeset 113944 in spip-zone


Ignore:
Timestamp:
Feb 16, 2019, 8:11:39 PM (12 months ago)
Author:
eric@…
Message:

On utilise les caches de Cache Factory et on en profite pour renvoyer le contenu et non plus le nom de la fonction de chargement ce qui simplifie pas mal le code des fonctions utilisatrices.
On supprime lz formulaire dédié de vidage et on se contente de créer juste l'inclusion utilisée par Cache Factory.
Un up de y.

Location:
_plugins_/rainette/trunk
Files:
4 added
2 deleted
8 edited
1 moved

Legend:

Unmodified
Added
Removed
  • _plugins_/rainette/trunk/inc/meteo_charger.php

    r108245 r113944  
    11<?php
    22/**
    3  * Ce fichier contient la fonction standard de chargement et fourniture du fichier cache des données météo.
     3 * Ce fichier contient la fonction standard de chargement et fourniture des données météo.
    44 * Elle s'applique à tous les services et à tous les types de données.
    55 *
     
    1212
    1313/**
    14  * Renvoyer le nom du fichier cache des données météos correspondant au lieu et au type de données choisis après l'avoir
    15  * éventuellement mis à jour.
     14 * Renvoyer le contenu du fichier cache des données météos correspondant au lieu et au type de données choisis
     15 * après l'avoir éventuellement mis à jour.
    1616 *
    1717 * Si le fichier cache est obsolète ou absent, on le crée après avoir chargé puis phrasé le flux XML ou JSON
     
    4545 *            - `owm` pour Open Weather Map
    4646 *            - `apixu` pour APIXU
    47  *
    48  * @return string
    49  *        Le nom du fichier cache correspondant à la demande.
     47 *            - `weatherbit` pour Weatherbit.io
     48 *
     49 * @return array
     50 *        Le contenu du fichier cache contenant les données à jour demandées.
    5051 */
    5152function inc_meteo_charger_dist($lieu, $mode = 'conditions', $periodicite = 0, $service = 'weather') {
     53
     54        // Initialisation du tableau de sortie.
     55        $tableau = array();
    5256
    5357        // Traitement des cas ou les arguments sont vides (ce qui est différent de non passés à l'appel)
     
    8690        }
    8791
    88         // Construire le nom du fichier cache
    89         $cache = cache_nommer($lieu, $mode, $periodicite, $configuration);
    90 
    91         // Déterminer le système d'unité utilisé dans le cache et celui requis par la configuration.
    92         // Si ces systèmes d'unité diffèrent il faut renouveler le cache sinon on affichera des données
    93         // fausses avec une unité correcte et ce jusqu'à la prochaine échéance du cache.
    94         $unite_configuree = '';
    95         $unite_cache = '';
    96         if (file_exists($cache) and ($mode != 'infos')) {
    97                 $unite_configuree = $configuration['unite']
    98                         ? $configuration['unite']
    99                         : $configuration['defauts']['unite'];
    100 
    101                 lire_fichier($cache, $contenu);
    102                 $tableau = unserialize($contenu);
    103                 $index = count($tableau) - 1;
    104                 $unite_cache = isset($tableau[$index]['config']['unite'])
    105                         ? $tableau[$index]['config']['unite']
    106                         : $configuration['defauts']['unite'];
    107         }
     92        // Construire le tableau identifiant le cache
     93        $cache = cache_normaliser($lieu, $mode, $periodicite, $configuration);
    10894
    10995        // Mise à jour du cache avec les nouvelles données météo si:
    11096        // - le fichier cache n'existe pas
    11197        // - la période de validité du cache est échue
    112         // - le système d'unités du cache n'est pas celui requis
    113         if (!file_exists($cache)
    114         or (!filemtime($cache) or (time() - filemtime($cache) > $configuration['periode_maj']))
    115         or (($mode != 'infos') and ($unite_configuree != $unite_cache))) {
     98        include_spip('inc/cache');
     99        if (!$fichier_cache = cache_est_valide('rainette', $cache)) {
    116100                // Construire l'url de la requête
    117101                $urler = "${service}_service2url";
     
    121105                // et traiter les cas d'erreurs du plugin ou du service.
    122106                include_spip('inc/rainette_requeter');
    123                 $tableau = array();
    124107                $erreur = array(
    125                         'type' => '',
    126                         'service' => array(
    127                                 'code' => '',
    128                                 'message' => ''
     108                        'type' => '', 'service' => array(
     109                                'code' => '', 'message' => ''
    129110                        )
    130111                );
     
    150131
    151132                                // On normalise le flux en utilisant le mode d'erreur pour vérifier si on obtient bien une erreur.
    152                                 $erreur_service = meteo_normaliser($configuration_erreur,'erreurs', $flux_erreur, -1);
     133                                $erreur_service = meteo_normaliser($configuration_erreur, 'erreurs', $flux_erreur, -1);
    153134                                $verifier = "${service}_erreur_verifier";
    154135                                if ($verifier($erreur_service)) {
     
    192173                                                        $periodes_horaires = array(-1);
    193174                                                        if ($periodicite) {
    194                                                                 for ($i = 0; $i <  (24 / $periodicite); $i++) {
     175                                                                for ($i = 0; $i < (24 / $periodicite); $i++) {
    195176                                                                        $periodes_horaires[] = $i;
    196177                                                                }
     
    200181                                                        // la majeure partie des cas
    201182                                                        $flux_heure = $_flux_jour;
    202                                                         if ((count($periodes_horaires) > 1)     and !empty($configuration['cle_heure'])) {
     183                                                        if ((count($periodes_horaires) > 1) and !empty($configuration['cle_heure'])) {
    203184                                                                $flux_heure = table_valeur($_flux_jour, implode('/', $configuration['cle_heure']), null);
    204185                                                        }
     
    210191                                                                //    Suivant la période il faut prendre le flux jour ou le flux heure. On calcule donc le flux heure
    211192                                                                //    quand c'est nécessaire.
    212                                                                 $flux_a_normaliser = $_periode == -1
    213                                                                         ? $_flux_jour
    214                                                                         : ($configuration['structure_heure'] ? $flux_heure[$_periode] : $flux_heure);
    215                                                                 $donnees = meteo_normaliser(
    216                                                                         $configuration,
    217                                                                         $mode,
    218                                                                         $flux_a_normaliser,
    219                                                                         $_periode);
     193                                                                $flux_a_normaliser = $_periode == -1 ? $_flux_jour : ($configuration['structure_heure'] ? $flux_heure[$_periode] : $flux_heure);
     194                                                                $donnees = meteo_normaliser($configuration, $mode, $flux_a_normaliser, $_periode);
    220195
    221196                                                                if ($donnees) {
     
    224199                                                                        $completer = "${service}_complement2${mode}";
    225200                                                                        if (function_exists($completer)) {
    226                                                                                 $donnees = $mode == 'previsions'
    227                                                                                         ? $completer($donnees, $configuration, $_periode)
    228                                                                                         : $completer($donnees, $configuration);
     201                                                                                $donnees = $mode == 'previsions' ? $completer($donnees, $configuration, $_periode) : $completer($donnees, $configuration);
    229202                                                                        }
    230203
     
    234207                                                                                // Calcul du risque uv à partir de l'indice uv si celui-ci est fourni
    235208                                                                                include_spip('inc/rainette_convertir');
    236                                                                                 $donnees['risque_uv'] = is_int($donnees['indice_uv'])
    237                                                                                         ? indice2risque_uv($donnees['indice_uv'])
    238                                                                                         : $donnees['indice_uv'];
     209                                                                                $donnees['risque_uv'] = is_int($donnees['indice_uv']) ? indice2risque_uv($donnees['indice_uv']) : $donnees['indice_uv'];
    239210                                                                        }
    240211
     
    256227                $extras = array();
    257228                $extras['credits'] = $configuration['credits'];
    258                 $extras['config'] = array_merge(
    259                         $configuration_utilisateur,
    260                         array('source' => configuration_donnees_normaliser($mode, $configuration['donnees'])),
    261                         array('nom_service' => $configuration['nom'])
    262                 );
     229                $extras['config'] = array_merge($configuration_utilisateur, array('source' => configuration_donnees_normaliser($mode, $configuration['donnees'])), array('nom_service' => $configuration['nom']));
    263230                $extras['lieu'] = $lieu;
    264231                $extras['mode'] = $mode;
     
    274241                        // Pour les prévisions l'index 0 à n désigne le jour, il faut donc le conserver
    275242                        $tableau = array(
    276                                 'donnees' => ($mode != 'previsions' ? array_shift($tableau) : $tableau),
    277                                 'extras' => $extras
     243                                'donnees' => ($mode != 'previsions' ? array_shift($tableau) : $tableau), 'extras' => $extras
    278244                        );
    279245                } else {
     
    281247                        // le bloc des données qui est mis à tableau vide dans ce cas à l'index 1.
    282248                        $tableau = array(
    283                                 'donnees' => array(),
    284                                 'extras'  => $extras
     249                                'donnees' => array(), 'extras' => $extras
    285250                        );
    286251                }
     
    289254                // -- pour effectuer des traitements annexes à partir des données météo (archivage, par exemple)
    290255                // -- pour ajouter ou modifier des données au tableau (la modification n'est pas conseillée cependant)
    291                 $tableau = pipeline('post_chargement_meteo',
    292                                                         array(
    293                                                                 'args' => array('lieu' => $lieu, 'mode' => $mode, 'service' => $service),
    294                                                                 'data' => $tableau
    295                                                         ));
    296 
    297                 // Création du nouveau cache
    298                 ecrire_fichier($cache, serialize($tableau));
    299         }
    300 
    301         return $cache;
     256                $tableau = pipeline(
     257                        'post_chargement_meteo',
     258                        array(
     259                                'args' => array('lieu' => $lieu, 'mode' => $mode, 'service' => $service),
     260                                'data' => $tableau
     261                        )
     262                );
     263
     264                // Mise à jour du cache
     265                cache_ecrire('rainette', $cache, $tableau);
     266        } else {
     267                // Lecture des données du fichier cache valide
     268                $tableau = cache_lire('rainette', $fichier_cache);
     269        }
     270
     271        return $tableau;
    302272}
  • _plugins_/rainette/trunk/inc/rainette_debusquer.php

    r108182 r113944  
    4040                        $periodicite = $configuration['periodicite_defaut'];
    4141                }
     42
    4243                // Chargement du cache
    4344                $charger = charger_fonction('meteo_charger', 'inc');
    44                 $nom_cache = $charger($lieu, $mode, $periodicite, $service);
    45                 if ($nom_cache) {
    46                         $contenu = '';
    47                         lire_fichier($nom_cache, $contenu);
    48                         $tableau = unserialize($contenu);
    49                         // Pour le mode prévisions, on supprime tous les jours postérieur au lendemain pour éviter d'avoir un
    50                         // affichage trop conséquent.
    51                         if ($mode == 'previsions') {
    52                                 // Récupérer les index de prévisions à afficher
    53                                 if (!$cles_previsions) {
    54                                         $cles_previsions = explode(',', _RAINETTE_DEBUG_CLES_PREVISIONS);
     45                $tableau = $charger($lieu, $mode, $periodicite, $service);
     46
     47                // Pour le mode prévisions, on supprime tous les jours postérieur au lendemain pour éviter d'avoir un
     48                // affichage trop conséquent.
     49                if ($mode == 'previsions') {
     50                        // Récupérer les index de prévisions à afficher
     51                        if (!$cles_previsions) {
     52                                $cles_previsions = explode(',', _RAINETTE_DEBUG_CLES_PREVISIONS);
     53                        }
     54                        foreach ($tableau['donnees'] as $_jour => $_valeurs) {
     55                                if (!in_array($_jour, $cles_previsions)) {
     56                                        unset($tableau['donnees'][$_jour]);
    5557                                }
    56                                 foreach ($tableau['donnees'] as $_jour => $_valeurs) {
    57                                         if (!in_array($_jour, $cles_previsions)) {
    58                                                 unset($tableau['donnees'][$_jour]);
    59                                         }
    60                                 }
    61                         }
    62                         $debug = bel_env(serialize($tableau), true);
    63                 }
     58                        }
     59                }
     60                $debug = bel_env(serialize($tableau), true);
    6461        }
    6562
     
    125122                        // Chargement des données
    126123                        $charger = charger_fonction('meteo_charger', 'inc');
    127                         $nom_cache = $charger($_lieu, $mode, $periodicite, $_service);
    128                         lire_fichier($nom_cache, $contenu_cache);
    129                         $tableau = unserialize($contenu_cache);
     124                        $tableau = $charger($_lieu, $mode, $periodicite, $_service);
    130125
    131126                        if (!$tableau['extras']['erreur']['type']) {
  • _plugins_/rainette/trunk/inc/rainette_normaliser.php

    r113779 r113944  
    654654
    655655/**
    656  * Construit le nom du cache en fonction du servide, du lieu, du type de données et de la langue utilisée par le site.
     656 * Construit le tableau du cache en fonction du service, du lieu, du type de données, de la langue utilisée par le site
     657 * et de l'unité des données.
    657658 *
    658659 * @param string $lieu
     
    665666 *        - `0`, pour les modes `conditions` et `infos`
    666667 * @param array  $configuration_service
    667  *        Configuration complète du service, statique et utilisateur.
    668  *
    669  * @return string
     668 *        Configuration complète du service, statique et utilisateur. Contient l'unité choisie pour les données.
     669 *
     670 * @return array
    670671 *        Chemin complet du fichier cache.
    671672 */
    672 function cache_nommer($lieu, $mode, $periodicite, $configuration_service) {
     673function cache_normaliser($lieu, $mode, $periodicite, $configuration_service) {
    673674
    674675        // Identification de la langue du resume.
     676        $cache = array();
     677
     678        // Le cache est stocké dans un sous-dossier au nom du service
     679        $cache['sous_dossier'] = $configuration_service['alias'];
     680
     681        // Composants obligatoires
     682        // -- Le nom du lieu normalisé (sans espace et dont tous les caractères non alphanumériques sont remplacés par un tiret)
     683        $lieu_normalise = lieu_normaliser($lieu);
     684        $cache['lieu'] = str_replace(array(' ', ',', '+', '.', '/'), '-', $lieu_normalise);
     685
     686        // -- Le nom du mode (infos, conditions ou previsions) accolé à la périodicité du cache pour les prévisions uniquement
     687        $cache['donnees'] = $mode . ($periodicite ? strval($periodicite) : '');
     688
     689        // -- Identification de la langue du resume.
    675690        $code_langue = langue_determiner($configuration_service);
    676 
    677         // Construction du chemin du fichier cache
    678         // Création et/ou détermination du dossier de destination du cache en fonction du service
    679         $dossier_cache = sous_repertoire(_DIR_VAR, trim(_RAINETTE_CACHE_NOMDIR, '/'));
    680         $dossier_cache = sous_repertoire($dossier_cache, $configuration_service['alias']);
    681 
    682         // Le nom du fichier cache est composé comme suit, chaque élément étant séparé par un underscore :
    683         // -- le nom du lieu normalisé (sans espace et dont tous les caractères non alphanumériques sont remplacés par un tiret
    684         // -- le nom du mode (infos, conditions ou previsions) accolé à la périodicité du cache pour les prévisions uniquement
    685         // -- la langue du résumé si il existe ou rien si aucune traduction n'est fournie par le service
    686         $lieu_normalise = lieu_normaliser($lieu);
    687         $fichier_cache = $dossier_cache
    688                                          . str_replace(array(' ', ',', '+', '.', '/'), '-', $lieu_normalise)
    689                                          . '_' . $mode
    690                                          . ($periodicite ? strval($periodicite) : '')
    691                                          . ($code_langue ? '_' . strtolower($code_langue) : '')
    692                                          . '.txt';
    693 
    694         return $fichier_cache;
    695 }
    696 
    697 
    698 /**
    699  * Construit le nom du cache en fonction du servide, du lieu, du type de données et de la langue utilisée par le site.
    700  *
    701  * @param string       $service
    702  *        Alias du service météorologique.
    703  * @param array|string $caches
    704  *        Liste des fichiers à supprimer ou vide si tous les fichiers cache doivent être supprimés.
    705  *        Il est possible de passer un seul fichier comme une chaine.
    706  *
    707  * @return boolean
    708  *        Toujours à `true`.
    709  */
    710 function cache_supprimer($service, $caches = array()) {
    711 
    712         include_spip('inc/flock');
    713 
    714         if ($caches) {
    715                 $fichiers_cache = is_string($caches) ? array($caches) : $caches;
    716         } else {
    717                 $fichiers_cache = glob(_RAINETTE_CACHE_DIR . $service . '/*.txt');
    718         }
    719 
    720         if ($fichiers_cache) {
    721                 foreach ($fichiers_cache as $_fichier) {
    722                         supprimer_fichier($_fichier);
    723                 }
    724         }
    725 
    726         return true;
    727 }
    728 
    729 
    730 /**
    731  * Répertorie les fichiers caches issu de l'utilisation de l'API d'un service donné.
    732  * La fonction renvoie une description de chaque fichier cache, à savoir, à minima, l'action lancée, le TSN
    733  * du taxon concerné et le nom du fichier cache.
    734  *
    735  * @package SPIP\TAXONOMIE\CACHE
    736  *
    737  * @param string $service
    738  *        Alias en minuscules du service pour lequel on veut lister les caches créés ou chaine vide si on souhaite
    739  *        tous les caches sans distinction de service.
    740  *
    741  * @return array
    742  *        Tableau des descriptions des fichiers cache créés par le ou les services.
    743  */
    744 function cache_repertorier($service = '') {
    745 
    746         // Initialisation de la liste des descriptions des caches du service
    747         $descriptions_cache = array();
    748 
    749         // On constitue la liste des services requis par l'appel
    750         include_spip('rainette_fonctions');
    751         $services = rainette_lister_services();
    752         if ($service) {
    753                 if (array_key_exists($service, $services)) {
    754                         $services = array($service => $services[$service]);
    755                 } else {
    756                         $services = array();
    757                 }
    758         }
    759 
    760         if ($services) {
    761                 foreach ($services as $_service => $_titre) {
    762                         // Récupération des fichiers cache du service.
    763                         $fichiers_cache = glob(_RAINETTE_CACHE_DIR . $_service . '/*.txt');
    764 
    765                         if ($fichiers_cache) {
    766                                 foreach ($fichiers_cache as $_fichier_cache) {
    767                                         // On raz la description pour éviter de garder des éléments du cache précédent et on initialise avec
    768                                         // le nom du fichier qui peut servir d'id, le chemin complet et le service.
    769                                         $description = array();
    770                                         $description['nom_cache'] = basename($_fichier_cache, '.txt');
    771                                         $description['fichier_cache'] = $_fichier_cache;
    772 
    773                                         // On extrait le service qui sert toujours d'index principal du tableau
    774                                         $description['service'] = $_service;
    775                                         $description['titre_service'] = $_titre;
    776 
    777                                         // On décompose le nom pour récupérer l'action et le TSN correspondant ainsi que la langue.
    778                                         // Le nom du fichier est composé d'éléments séparés par un underscore. La structure est toujours
    779                                         // composée dans l'ordre du service, de l'action et du TSN et peut être complétée par la langue.
    780                                         $elements = explode('_', $description['nom_cache']);
    781                                         $description['lieu'] = $elements[0];
    782                                         $description['modele'] = $elements[1];
    783                                         $description['langue'] = $elements[2];
    784 
    785                                         // On structure le tableau suivant que l'on demande un service ou tous.
    786                                         if ($service) {
    787                                                 $descriptions_cache['service'] = $_service;
    788                                                 $descriptions_cache['titre_service'] = $_titre;
    789                                                 $descriptions_cache['caches'][] = $description;
    790                                         } else {
    791                                                 $descriptions_cache[$_service]['titre_service'] = $_titre;
    792                                                 $descriptions_cache[$_service]['caches'][] = $description;
    793                                         }
    794                                 }
    795                         }
    796                 }
    797         }
    798 
    799         return $descriptions_cache;
     691        $cache['langage'] = strtolower($code_langue);
     692
     693        // Composants facultatifs
     694        // -- Unité des données si le mode n'est pas infos.
     695        if ($mode != 'infos') {
     696                $cache['unite'] = $configuration_service['unite'];
     697        }
     698
     699        // La durée de conservation par défaut est positionné pour le mode infos. Pour les autres modes il faut
     700        // la positionner spécifiquement car chaque service a sa propre récurrence.
     701        if ($mode != 'infos') {
     702                $cache['conservation'] = $configuration_service['periode_maj'];
     703        }
     704
     705        return $cache;
    800706}
    801707
  • _plugins_/rainette/trunk/lang/rainette_fr.php

    r113723 r113944  
    99        'bouton_cocher_aucun' => 'Tout décocher',
    1010        'bouton_cocher_tout' => 'Tout cocher',
     11        'bouton_vider_cache' => 'Vider les caches Rainette',
    1112
    1213        // C
  • _plugins_/rainette/trunk/paquet.xml

    r113808 r113944  
    22        prefix="rainette"
    33        categorie="divers"
    4         version="3.5.12"
     4        version="3.6.0"
    55        etat="stable"
    66        compatibilite="]3.1.3;3.2.*]"
     
    2525        <pipeline nom="post_chargement_meteo" action="" />
    2626
     27        <necessite nom="cache" compatibilite="[0.2.3;]" />
    2728        <necessite nom="saisies" compatibilite="[3.12.7;[" />
    2829        <necessite nom="php" compatibilite="[5.3.0;[" />
  • _plugins_/rainette/trunk/prive/squelettes/contenu/configurer_rainette.html

    r113723 r113944  
    77        (#FORMULAIRE_CONFIGURER_RAINETTE_SERVICE{#ENV{service, weather}})
    88</div>]
    9 
    10 [<div class='ajax'>
    11         (#FORMULAIRE_VIDER_CACHE_RAINETTE_SERVICE{#ENV{service, weather}})
    12 </div>]
  • _plugins_/rainette/trunk/prive/squelettes/navigation/configurer_rainette.html

    r111322 r113944  
    44#BOITE_FERMER
    55
    6 <INCLURE{fond=prive/squelettes/inclure/inc-navigation-rainette, env} />
     6[(#REM) <!-- Menu des services --> ]
     7<INCLURE{fond=prive/squelettes/inclure/inc-rainette_navigation, env} />
     8
     9[(#REM) <!-- Raccourci d'administration --> ]
     10<INCLURE{fond=prive/squelettes/inclure/inc-rainette_raccourcis_admin, env} />
  • _plugins_/rainette/trunk/rainette_fonctions.php

    r113211 r113944  
    5353                // Récupération des informations sur le lieu
    5454                $charger = charger_fonction('meteo_charger', 'inc');
    55                 $nom_cache = $charger($lieu, 'infos', 0, $service);
    56                 lire_fichier($nom_cache, $contenu_cache);
     55                $tableau = $charger($lieu, 'infos', 0, $service);
    5756                if (!isset($type) or !$type) {
    58                         $info = $contenu_cache;
     57                        $info = serialize($tableau);
    5958                } else {
    60                         $tableau = unserialize($contenu_cache);
    6159                        if (isset($tableau['donnees'][strtolower($type)])) {
    6260                                $info = $tableau['donnees'][strtolower($type)];
     
    488486                // Récupération du tableau des données météo
    489487                $charger = charger_fonction('meteo_charger', 'inc');
    490                 $nom_cache = $charger($lieu, $mode, $periodicite, $service);
    491                 lire_fichier($nom_cache, $contenu_cache);
    492                 $tableau = unserialize($contenu_cache);
     488                $tableau = $charger($lieu, $mode, $periodicite, $service);
    493489
    494490                // Séparation des données communes liées au service et au mode et des données météorologiques
Note: See TracChangeset for help on using the changeset viewer.