Changeset 107848 in spip-zone


Ignore:
Timestamp:
Dec 3, 2017, 8:38:39 PM (16 months ago)
Author:
eric@…
Message:

Mise en place d'une gestion complète des erreurs tenant compte aussi des erreurs remontées par chaque service.
Pour ce faire, ajout d'une configuration pour chaque service et d'une fonction de service permettant de savoir si une erreur a été remontée.
Correction du service OWM et passage de tous ses modes en JSON.
Début de renommage de certaines fonctions internes.

Location:
_plugins_/rainette/trunk
Files:
2 added
1 deleted
11 edited

Legend:

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

    r107753 r107848  
    7575        // Cependant, celle-ci pouvant être incomplète on la complète par les valeurs par défaut quand
    7676        // cela est nécessaire.
    77         include_spip('inc/config');
    78         $configuration_utilisateur = lire_config("rainette/${service}");
    79         foreach ($configuration['defauts'] as $_cle => $_valeur) {
    80                 if (!isset($configuration_utilisateur[$_cle])) {
    81                         $configuration_utilisateur[$_cle] = $_valeur;
    82                 }
    83         }
     77        $configuration_utilisateur = normaliser_configuration_utilisateur($service, $configuration['defauts']);
     78
     79        // Concaténer l'ensemble des configurations.
    8480        $configuration = array_merge($configuration, $configuration_utilisateur);
    8581
     
    123119                $url = $urler($lieu, $mode, $periodicite, $configuration);
    124120
    125                 // Acquérir le flux XML ou JSON dans un tableau
    126                 include_spip('inc/rainette_phraser');
    127                 $acquerir = "url2flux_{$configuration['format_flux']}";
    128                 $flux = $acquerir($url);
    129 
    130                 // On se positionne sur le niveau de base du flux où commence le tableau des données météorologiques.
    131                 include_spip('inc/filtres');
     121                // Acquérir le flux XML ou JSON dans un tableau et traiter les cas d'erreurs du plugin ou du service.
     122                include_spip('inc/rainette_requeter');
     123                $flux = requeter($url, $configuration['format_flux'], $service);
    132124                $tableau = array();
    133                 if (!empty($configuration['cle_base'])) {
    134                         $flux = table_valeur($flux, implode('/', $configuration['cle_base']), null);
    135                 }
    136 
    137                 if ($flux) {
    138                         // En mode prévisions, le niveau de base est un tableau de n éléments, chaque élément étant un tableau contenant
    139                         // les données météorologiques d'un jour à venir ([0] => jour0[], [1] => jour1[]...).
    140                         // En mode infos ou conditions, on a directement accès aux données météorologiques (jour[]).
    141                         // Pour réaliser un traitement standard, on transforme donc le jour[] en un tableau d'un seul élément ([0] => jour[])
    142                         // qui pourra être traité comme celui des prévisions.
    143                         if (($mode == 'conditions') or ($mode == 'infos')) {
    144                                 $flux = array($flux);
     125                $erreur = array(
     126                        'type' => '',
     127                        'service' => array(
     128                                'code' => '',
     129                                'message' => ''
     130                        )
     131                );
     132                if (!empty($flux['erreur'])) {
     133                        // Erreur lors du traitement de la requête due à l'URL ou à la conversion en XML ou JSON.
     134                        // Cette erreur n'est pas retournée par le service.
     135                        $erreur['type'] = $flux['erreur'];
     136                } else {
     137                        // On teste une erreur d'acquisition renvoyée par le service. Pour tous les services, une cle de base
     138                        // est explicitement utilisée pour distinguer les erreurs; sa présence permet d'identifier un cas d'erreur.
     139                        include_spip('inc/filtres');
     140                        $configuration_erreur = $configurer('erreurs');
     141                        $flux_erreur = $flux;
     142                        if (!empty($configuration_erreur['cle_base'])) {
     143                                $flux_erreur = table_valeur($flux, implode('/', $configuration_erreur['cle_base']), null);
    145144                        }
    146145
    147                         // Convertir le flux en tableau standard pour la mise en cache. Ce traitement se déroule en
    148                         // 3 étapes :
    149                         // -1- initialisation du tableau standard à partir uniquement des données reçues du service
    150                         // -2- complément du tableau avec les données propres à chaque service
    151                         // -3- complément du tableau avec les données communes à tous les services
    152                         foreach ($flux as $_index_jour => $_flux_jour) {
    153                                 // Pour les informations et les conditions les données récupérées concernent toute la même "période".
    154                                 // Par contre, pour les prévisions on distingue 2 type de données :
    155                                 // - celles du jour indépendamment de la période horaire
    156                                 // - celles correspondant à une période horaire choisie (24, 12, 6, 3, 1)
    157                                 //   Ces donnnées sont stockées à un index horaire de 0 à n qui représente la période horaire.
    158                                 // Pour avoir un traitement identique pour les deux types de données on considère que l'index horaire
    159                                 // des données jour est égal à -1.
    160                                 // On crée donc le tableau des index correspondant au mode choisi et on boucle dessus.
    161                                 $periodes_horaires = array(-1);
    162                                 if ($periodicite) {
    163                                         for ($i = 0; $i <  (24 / $periodicite); $i++) {
    164                                                 $periodes_horaires[] = $i;
     146                        // On normalise le flux en utilisant le mode d'erreur pour vérifier si on obtient bien une erreur.
     147                        $erreur_service = service2donnees($configuration_erreur,'erreurs', $flux_erreur, -1);
     148                        $verifier = "${service}_erreur_verifier";
     149                        if ($verifier($erreur_service)) {
     150                                // Une erreur est renvoyée par le service, on formate l'erreur correctement.
     151                                $erreur['type'] = 'reponse_service';
     152                                $erreur['service'] = array_merge($erreur['service'], $erreur_service);
     153                        } else {
     154                                // On se positionne sur le niveau de base du flux des données où commence le tableau des données météorologiques.
     155                                if (!empty($configuration['cle_base'])) {
     156                                        $flux = table_valeur($flux, implode('/', $configuration['cle_base']), null);
     157                                }
     158
     159                                if (empty($flux)) {
     160                                        // Pas d'erreur retournée par le service mais aucune donnée fournie. Ce cas est peut-être impossible
     161                                        // mais on le traite tout de même par sécurité avec un type particulier.
     162                                        $erreur['type'] = 'aucune_donnee';
     163                                } else {
     164                                        // En mode prévisions, le niveau de base est un tableau de n éléments, chaque élément étant un tableau contenant
     165                                        // les données météorologiques d'un jour à venir ([0] => jour0[], [1] => jour1[]...).
     166                                        // En mode infos ou conditions, on a directement accès aux données météorologiques (jour[]).
     167                                        // Pour réaliser un traitement standard, on transforme donc le jour[] en un tableau d'un seul élément ([0] => jour[])
     168                                        // qui pourra être traité comme celui des prévisions.
     169                                        if (($mode == 'conditions') or ($mode == 'infos')) {
     170                                                $flux = array($flux);
    165171                                        }
    166                                 }
    167 
    168                                 // On détermine le flux heure en fonction du service. Ce flux heure coincide avec le flux jour dans
    169                                 // la majeure partie des cas
    170                                 $flux_heure = $_flux_jour;
    171                                 if ((count($periodes_horaires) > 1)     and !empty($configuration['cle_heure'])) {
    172                                         $flux_heure = table_valeur($_flux_jour, implode('/', $configuration['cle_heure']), null);
    173                                 }
    174 
    175                                 // On boucle sur chaque periode horaire pour remplir le tableau complet.
    176                                 foreach ($periodes_horaires as $_periode) {
    177                                         // 1- Initialiser le tableau normalisé des informations à partir des données brutes
    178                                         //    fournies par le service.
    179                                         //    Suivant la période il faut prendre le flux jour ou le flux heure. On calcule donc le flux heure
    180                                         //    quand c'est nécessaire.
    181                                         $flux_a_normaliser = $_periode == -1
    182                                                 ? $_flux_jour
    183                                                 : ($configuration['structure_heure'] ? $flux_heure[$_periode] : $flux_heure);
    184                                         $donnees = service2donnees(
    185                                                 $configuration,
    186                                                 $mode,
    187                                                 $flux_a_normaliser,
    188                                                 $_periode);
    189 
    190                                         if ($donnees) {
    191                                                 // 2- Compléments spécifiques au service et au mode.
    192                                                 //    Si ces compléments sont inutiles, la fonction n'existe pas
    193                                                 $completer = "${service}_complement2${mode}";
    194                                                 if (function_exists($completer)) {
    195                                                         $donnees = $mode == 'previsions'
    196                                                                 ? $completer($donnees, $configuration, $_periode)
    197                                                                 : $completer($donnees, $configuration);
     172
     173                                        // Convertir le flux en tableau standard pour la mise en cache. Ce traitement se déroule en
     174                                        // 3 étapes :
     175                                        // -1- initialisation du tableau standard à partir uniquement des données reçues du service
     176                                        // -2- complément du tableau avec les données propres à chaque service
     177                                        // -3- complément du tableau avec les données communes à tous les services
     178                                        foreach ($flux as $_index_jour => $_flux_jour) {
     179                                                // Pour les informations et les conditions les données récupérées concernent toute la même "période".
     180                                                // Par contre, pour les prévisions on distingue 2 type de données :
     181                                                // - celles du jour indépendamment de la période horaire
     182                                                // - celles correspondant à une période horaire choisie (24, 12, 6, 3, 1)
     183                                                //   Ces donnnées sont stockées à un index horaire de 0 à n qui représente la période horaire.
     184                                                // Pour avoir un traitement identique pour les deux types de données on considère que l'index horaire
     185                                                // des données jour est égal à -1.
     186                                                // On crée donc le tableau des index correspondant au mode choisi et on boucle dessus.
     187                                                $periodes_horaires = array(-1);
     188                                                if ($periodicite) {
     189                                                        for ($i = 0; $i <  (24 / $periodicite); $i++) {
     190                                                                $periodes_horaires[] = $i;
     191                                                        }
    198192                                                }
    199193
    200                                                 // 3- Compléments standard communs à tous les services mais fonction du mode
    201                                                 if ($mode == 'conditions') {
    202                                                         // Vérifier que l'indice uv si celui-ci est fourni
    203                                                         // Calcul du risque uv à partir de l'indice uv si celui-ci est fourni
    204                                                         include_spip('inc/rainette_convertir');
    205                                                         $donnees['risque_uv'] = is_int($donnees['indice_uv'])
    206                                                                 ? indice2risque_uv($donnees['indice_uv'])
    207                                                                 : $donnees['indice_uv'];
     194                                                // On détermine le flux heure en fonction du service. Ce flux heure coincide avec le flux jour dans
     195                                                // la majeure partie des cas
     196                                                $flux_heure = $_flux_jour;
     197                                                if ((count($periodes_horaires) > 1)     and !empty($configuration['cle_heure'])) {
     198                                                        $flux_heure = table_valeur($_flux_jour, implode('/', $configuration['cle_heure']), null);
    208199                                                }
    209200
    210                                                 // Ajout du bloc à l'index en cours
    211                                                 if ($_periode == -1) {
    212                                                         $tableau[$_index_jour] = $donnees;
    213                                                 } else {
    214                                                         $tableau[$_index_jour]['heure'][$_periode] = $donnees;
     201                                                // On boucle sur chaque periode horaire pour remplir le tableau complet.
     202                                                foreach ($periodes_horaires as $_periode) {
     203                                                        // 1- Initialiser le tableau normalisé des informations à partir des données brutes
     204                                                        //    fournies par le service.
     205                                                        //    Suivant la période il faut prendre le flux jour ou le flux heure. On calcule donc le flux heure
     206                                                        //    quand c'est nécessaire.
     207                                                        $flux_a_normaliser = $_periode == -1
     208                                                                ? $_flux_jour
     209                                                                : ($configuration['structure_heure'] ? $flux_heure[$_periode] : $flux_heure);
     210                                                        $donnees = service2donnees(
     211                                                                $configuration,
     212                                                                $mode,
     213                                                                $flux_a_normaliser,
     214                                                                $_periode);
     215
     216                                                        if ($donnees) {
     217                                                                // 2- Compléments spécifiques au service et au mode.
     218                                                                //    Si ces compléments sont inutiles, la fonction n'existe pas
     219                                                                $completer = "${service}_complement2${mode}";
     220                                                                if (function_exists($completer)) {
     221                                                                        $donnees = $mode == 'previsions'
     222                                                                                ? $completer($donnees, $configuration, $_periode)
     223                                                                                : $completer($donnees, $configuration);
     224                                                                }
     225
     226                                                                // 3- Compléments standard communs à tous les services mais fonction du mode
     227                                                                if ($mode == 'conditions') {
     228                                                                        // Vérifier que l'indice uv si celui-ci est fourni
     229                                                                        // Calcul du risque uv à partir de l'indice uv si celui-ci est fourni
     230                                                                        include_spip('inc/rainette_convertir');
     231                                                                        $donnees['risque_uv'] = is_int($donnees['indice_uv'])
     232                                                                                ? indice2risque_uv($donnees['indice_uv'])
     233                                                                                : $donnees['indice_uv'];
     234                                                                }
     235
     236                                                                // Ajout du bloc à l'index en cours
     237                                                                if ($_periode == -1) {
     238                                                                        $tableau[$_index_jour] = $donnees;
     239                                                                } else {
     240                                                                        $tableau[$_index_jour]['heure'][$_periode] = $donnees;
     241                                                                }
     242                                                        }
    215243                                                }
    216244                                        }
     
    224252                $extras['config'] = array_merge(
    225253                        $configuration_utilisateur,
    226                         array('source' => normaliser_config_donnees($mode, $configuration))
     254                        array('source' => normaliser_configuration_donnees($mode, $configuration['donnees']))
    227255                );
    228                 $extras['erreur'] = '';
    229256                $extras['lieu'] = $lieu;
    230257                $extras['mode'] = $mode;
    231258                $extras['periodicite_cache'] = $periodicite;
    232259                $extras['service'] = $service;
     260                $extras['erreur'] = $erreur;
    233261
    234262                // On range les données et les extras dans un tableau associatif à deux entrées ('donnees', 'extras')
     
    243271                        );
    244272                } else {
    245                         // Traitement des erreurs de flux. On positionne toujours les bloc extra contenant l'erreur à l'index 0,
     273                        // Traitement des erreurs de flux. On positionne toujours les bloc extra contenant l'erreur,
    246274                        // le bloc des données qui est mis à tableau vide dans ce cas à l'index 1.
    247                         $extras['erreur'] = 'chargement';
    248275                        $tableau = array(
    249276                                'donnees' => array(),
  • _plugins_/rainette/trunk/inc/rainette_convertir.php

    r97957 r107848  
    153153        return $ressenti;
    154154}
     155
     156/**
     157 * Conversion en kilomètres d'une valeur en mètres.
     158 *
     159 * @param  int $metre
     160 *        La valeur entière en mètres
     161 *
     162 * @return float
     163 *        La valeur correspondante convertie en kilomètres.
     164 */
     165function metre2kilometre($metre) {
     166        return $metre / 1000;
     167}
  • _plugins_/rainette/trunk/inc/rainette_normaliser.php

    r107778 r107848  
    2323        define('_RAINETTE_REGEXP_LIEU_WEATHER_ID', '#[a-zA-Z]{4}\d{4}#i');
    2424}
     25
     26$GLOBALS['rainette_config']['erreurs'] = array(
     27        'code'    => array('origine' => 'service', 'type_php' => 'string', 'type_unite' => '', 'groupe' => 'donnees_erreur'),
     28        'message' => array('origine' => 'service', 'type_php' => 'string', 'type_unite' => '', 'groupe' => 'donnees_erreur'),
     29);
    2530
    2631$GLOBALS['rainette_config']['infos'] = array(
     
    367372                                        } else {
    368373                                                // La donnée météo n'est jamais fournie par le service. On la positionne à null pour
    369                                                 // la distinguer avec une donnée vide car indisponible temporairement.
     374                                                // la distinguer avec une donnée vide qui indinque une indisponibilité temporaire.
    370375                                                $donnee = null;
    371376                                        }
     
    663668
    664669
    665 function normaliser_config_donnees($mode, $config_service) {
    666 
    667         $config_donnees = array();
    668 
    669         foreach ($GLOBALS['rainette_config'][$mode] as $_donnee => $_config) {
    670                 if ($_config['origine'] == 'service') {
    671                         $config_donnees[$_donnee] = !empty($config_service['donnees'][$_donnee]['cle']) ? true : false;
     670function normaliser_configuration_donnees($mode, $configuration_donnees) {
     671
     672        $configuration_normalisee = array();
     673
     674        foreach ($GLOBALS['rainette_config'][$mode] as $_donnee => $_configuration) {
     675                if ($_configuration['origine'] == 'service') {
     676                        $configuration_normalisee[$_donnee] = !empty($configuration_donnees[$_donnee]['cle']) ? true : false;
    672677                }
    673678        }
    674679
    675         return $config_donnees;
    676 }
     680        return $configuration_normalisee;
     681}
     682
     683function normaliser_configuration_utilisateur($service, $configuration_defaut) {
     684
     685        // On récupère la configuration utilisateur
     686        include_spip('inc/config');
     687        $configuration_utilisateur = lire_config("rainette/${service}", array());
     688
     689        // On complète la configuration avec des valeurs par défaut si nécessaire.
     690        foreach ($configuration_defaut as $_cle => $_valeur) {
     691                if (!isset($configuration_utilisateur[$_cle])) {
     692                        $configuration_utilisateur[$_cle] = $_valeur;
     693                }
     694        }
     695
     696        return $configuration_utilisateur;
     697}
     698
     699function normaliser_texte_erreur($erreur, $lieu, $mode, $modele, $service) {
     700
     701        $texte = array('principal' => '', 'conseil' => '', 'service' => '');
     702        $titre_service = _T("rainette:titre_service_${service}");
     703
     704        $type_erreur = $erreur['type'];
     705        switch ($type_erreur) {
     706                // Cas d'erreur lors du traitement de la requête par le plugin
     707                case 'url_indisponible':
     708                case 'analyse_xml':
     709                case 'analyse_json':
     710                // Cas d'erreur où le service renvoie aucune donnée sans pour autant monter une erreur.
     711                case 'aucune_donnee':
     712                        $texte['principal'] .= _T("rainette:erreur_${type_erreur}", array('service' => $titre_service));
     713                        $texte['conseil'] .= _T('rainette:erreur_conseil_equipe');
     714                        break;
     715                // Cas d'erreur renvoyé par le service lui-même
     716                case 'reponse_service':
     717                        if (!empty($erreur['service']['code'])) {
     718                                $texte['service'] .= $erreur['service']['code'];
     719                        }
     720                        if (!empty($erreur['service']['message'])) {
     721                                $texte['service'] .= ($texte['service'] ? ' - ' : '') . $erreur['service']['message'];
     722                        }
     723                        $texte['principal'] .= _T("rainette:erreur_${type_erreur}_${mode}", array('service' => $titre_service, 'lieu' => $lieu));
     724                        $texte['conseil'] .= _T('rainette:erreur_conseil_service');
     725                        break;
     726                // Cas d'erreur du à une mauvause utilisation des modèles
     727                case 'modele_periodicite':
     728                        $texte['principal'] .= _T("rainette:erreur_${type_erreur}", array('modele' => $modele));
     729                        $texte['conseil'] .= _T('rainette:erreur_conseil_periodicite');
     730                        break;
     731                case 'modele_service':
     732                        $texte['principal'] .= _T("rainette:erreur_${type_erreur}", array('modele' => $modele, 'service' => $titre_service));
     733                        $texte['conseil'] .= _T('rainette:erreur_conseil_modele_changer');
     734                        break;
     735                case 'modele_inutilisable':
     736                        $texte['principal'] .= _T("rainette:erreur_${type_erreur}", array('modele' => $modele));
     737                        $texte['conseil'] .= _T('rainette:erreur_conseil_modele_expliciter');
     738                        break;
     739        }
     740
     741
     742        return $texte;
     743}
  • _plugins_/rainette/trunk/lang/rainette_fr.php

    r107753 r107848  
    3232
    3333        // E
    34         'erreur_affichage_modele' => 'Le modèle @modele@ n\'est pas compatible avec le service @service@.',
    35         'erreur_affichage_conseil' => 'Veuillez utiliser un autre modèle.',
    36         'erreur_chargement_conditions' => 'Le service @service@ ne fournit actuellement aucune information géographique sur le lieu @lieu@.',
    37         'erreur_chargement_infos' => 'Le service @service@ ne fournit actuellement aucune condition météorologique sur le lieu @lieu@.',
    38         'erreur_chargement_previsions' => 'Le service @service@ ne fournit actuellement aucune prévision météorologique sur le lieu @lieu@.',
    39         'erreur_chargement_conseil' => 'Veuillez vérifier le nom du lieu ou la disponibilité du service.',
    40         'erreur_jour_previsions' => 'Le service @service@ ne fournit pas de prévision météorologique pour le @date@.',
    41         'erreur_jour_conseil' => 'Ce service ne fournit que @max@ jours de prévisions.',
     34        'erreur_analyse_json' => 'L\'analyse du flux JSON renvoyé par le @service@ a échoué.',
     35        'erreur_analyse_xml' => 'L\'analyse du flux XML renvoyé par le @service@ a échoué.',
     36        'erreur_aucune_donnee' => 'Aucune donnée n\'a été renvoyée par le service @service@ mais le service n\'a pas monté d\'erreur.',
     37        'erreur_conseil_modele_changer' => 'Veuillez utiliser un autre modèle.',
     38        'erreur_conseil_modele_expliciter' => 'Veuillez préciser explicitement la périodicité horaire ou renommer le modèle correctement.',
     39        'erreur_conseil_equipe' => 'Veuillez contacter l\'équipe de développement du plugin.',
     40        'erreur_conseil_periodicite' => 'Veuillez utiliser une autre périodicité ou un autre modèle.',
     41        'erreur_conseil_service' => 'Veuillez consulter le message du service ci-dessous.',
     42        'erreur_modele_inutilisable' => 'Le nom du modèle @modele@ ne permet pas de déterminer une périodicité horaire par défaut.',
     43        'erreur_modele_periodicite' => 'Le modèle @modele@ n\'est pas compatible avec la périodicité horaire demandée.',
     44        'erreur_modele_service' => 'Le service @service@ ne fournit pas de prévisions avec une périodicité horaire compatible avec le modèle @modele@.',
     45        'erreur_reponse_service_conditions' => 'Le service @service@ a renvoyé une erreur lors de l\'acquisition des conditions météorologiques du lieu @lieu@.',
     46        'erreur_reponse_service_infos' => 'Le service @service@ ne fournit actuellement aucune condition météorologique sur le lieu @lieu@.',
     47        'erreur_reponse_service_previsions' => 'Le service @service@ ne fournit actuellement aucune prévision météorologique sur le lieu @lieu@.',
     48        'erreur_url_indisponible' => 'L\'URL utilisée pour le @service@ semble erronée.',
    4249
    4350        // G
  • _plugins_/rainette/trunk/modeles/erreur.html

    r94404 r107848  
    33 -->
    44]
    5 #SET{nom_service, #VAL{rainette:titre_service_}|concat{#ENV{service}}_T}
    6 
    75<div class="notice">
    8         [(#VAL{rainette:erreur_}|concat{#ENV{erreur}}|concat{_}|concat{#ENV{mode}}|_T{#ARRAY{service, #GET{nom_service}, lieu, #ENV{lieu}, date, #ENV{date_erreur}, modele, #ENV{modele}}})]
    9         <br />
    10         [(#VAL{rainette:erreur_}|concat{#ENV{erreur}}|concat{_conseil}|_T{#ARRAY{max, #ENV{max_previsions}}})]
     6        [(#ENV{erreur/texte/principal})]
     7        [<br />(#ENV{erreur/texte/conseil})]
     8        [<br /><i>\((#ENV{erreur/texte/service})\)</i>]
    119</div>
  • _plugins_/rainette/trunk/rainette_fonctions.php

    r107753 r107848  
    380380        // Initialisation du tableau des données météorologiques
    381381        $tableau = array();
     382        include_spip('inc/rainette_normaliser');
    382383
    383384        // Détermination de la périodicité en fonction du mode et du modèle demandés
     
    390391
    391392                        // On verifie que la périodicité demandée explicitement dans l'appel du modèle est ok
    392                         include_spip('inc/rainette_normaliser');
    393393                        if (isset($options['periodicite'])) {
    394394                                $periodicite_explicite = intval($options['periodicite']);
     
    418418
    419419        if ($erreur) {
    420                 // On prépare un contexte extras minimal pour traiter les erreurs du modèle de façon standard
    421                 $extras['erreur'] = $erreur;
     420                // Acquérir la configuration statique du service (periode, format, données...)
     421                $configurer = "${service}_service2configuration";
     422                $configuration = $configurer($mode);
     423
     424                // On prépare un contexte extras pour traiter les erreurs du modèle de façon standard comme celles
     425                // renvoyée par le chargement des données.
     426                $extras['credits'] = $configuration['credits'];
     427                $extras['config'] = array_merge(
     428                        normaliser_configuration_utilisateur($service, $configuration['defaut']),
     429                        array('source' => normaliser_configuration_donnees($mode, $configuration['donnees']))
     430                );
    422431                $extras['lieu'] = $lieu;
    423432                $extras['mode'] = $mode;
    424433                $extras['periodicite_cache'] = $periodicite;
    425434                $extras['service'] = $service;
     435                $extras['erreur'] = array(
     436                        'type' => $erreur,
     437                        'service' => array(
     438                                'code' => '',
     439                                'message' => ''
     440                        )
     441                );
    426442        } else {
    427443                // Récupération du tableau des données météo
     
    433449                // Séparation des données communes liées au service et au mode et des données météorologiques
    434450                $extras = $tableau['extras'];
    435                 $erreur = $extras['erreur'];
     451                $erreur = $extras['erreur']['type'];
    436452
    437453                if (!$erreur and ($mode == 'previsions')) {
     
    460476        // Affichage du message d'erreur ou des données
    461477        if ($erreur) {
     478                $extras['erreur']['texte'] = normaliser_texte_erreur($extras['erreur'], $lieu, $mode, $modele, $service);
    462479                $texte = recuperer_fond('modeles/erreur', $extras);
    463480        } else {
  • _plugins_/rainette/trunk/services/apixu.php

    r107753 r107848  
    7272                ),
    7373                'defaut'      => 'en'
     74        ),
     75        'requetes' => array(
     76                'mois'        => 5000
    7477        )
    7578);
     
    174177);
    175178
     179// Configuration des données fournies par le service APIXU en cas d'erreur.
     180// -- Seules les données non calculées sont configurées.
     181$GLOBALS['rainette_apixu_config']['erreurs'] = array(
     182        'cle_base'    => array('error'),
     183        'donnees'     => array(
     184                // Erreur
     185                'code'     => array('cle' => array('code')),
     186                'message'  => array('cle' => array('message')),
     187        ),
     188);
     189
    176190
    177191// ------------------------------------------------------------------------------------------------
     
    250264
    251265        return $url;
     266}
     267
     268
     269/**
     270 * @param array $erreur
     271 *
     272 * @return bool
     273 */
     274function apixu_erreur_verifier($erreur) {
     275
     276        // Initialisation
     277        $est_erreur = false;
     278
     279        // Une erreur est toujours décrite par un code et un message.
     280        if (!empty($erreur['code']) and !empty($erreur['message'])) {
     281                $est_erreur = true;
     282        }
     283
     284        return $est_erreur;
    252285}
    253286
  • _plugins_/rainette/trunk/services/owm.php

    r107753 r107848  
    22/**
    33 * Ce fichier contient l'ensemble des constantes et fonctions implémentant le service Open Weather Map (owm).
    4  * Ce service fournit des données au format XML ou JSON.
     4 * Ce service fournit des données au format XML ou JSON mais Rainette utilise uniquement le JSON.
    55 *
    66 * @package SPIP\RAINETTE\SERVICES\OWM
     
    5656                ),
    5757                'defaut'      => 'en'
     58        ),
     59        'requetes' => array(
     60                'minute'     => 60
    5861        )
    5962);
    6063
    61 // Configuration des données fournies par le service wunderground pour le mode 'infos'.
     64// Configuration des données fournies par le service owm pour le mode 'infos'.
    6265// -- Seules les données non calculées sont configurées.
    6366$GLOBALS['rainette_owm_config']['infos'] = array(
    64         'periode_maj' => 86400,
     67        'periode_maj' => 3600*24*30,
    6568        'format_flux' => 'json',
    6669        'cle_base'    => array(),
     
    8083// Configuration des données fournies par le service owm pour le mode 'conditions'.
    8184// -- Seules les données non calculées sont configurées.
    82 // -- On utilise le mode XML et non JSON car la date de dernière mise à jour n'est pas disponible en JSON
    8385$GLOBALS['rainette_owm_config']['conditions'] = array(
    84         'periode_maj' => 7200,
    85         'format_flux' => 'xml',
    86         'cle_base'    => array('children'),
     86        'periode_maj' => 3600*2,
     87        'format_flux' => 'json',
     88        'cle_base'    => array(),
    8789        'donnees'     => array(
    8890                // Données d'observation
    89                 'derniere_maj'          => array('cle' => array('lastupdate', 0, 'attributes', 'value')),
     91                'derniere_maj'          => array('cle' => array('dt')),
    9092                'station'               => array('cle' => array()),
    9193                // Températures
    92                 'temperature_reelle'    => array('cle' => array('temperature', 0, 'attributes', 'value')),
     94                'temperature_reelle'    => array('cle' => array('main', 'temp')),
    9395                'temperature_ressentie' => array('cle' => array()),
    9496                // Données anémométriques
    95                 'vitesse_vent'          => array('cle' => array('wind', 0, 'children', 'speed', 0, 'attributes', 'value')),
    96                 'angle_vent'            => array('cle' => array('wind', 0, 'children', 'direction', 0, 'attributes', 'value')),
    97                 'direction_vent'        => array('cle' => array('wind', 0, 'children', 'direction', 0, 'attributes', 'code')),
     97                'vitesse_vent'          => array('cle' => array('wind', 'speed')),
     98                'angle_vent'            => array('cle' => array('wind', 'deg')),
     99                'direction_vent'        => array('cle' => array()),
    98100                // Données atmosphériques : risque_uv est calculé
    99101                'precipitation'         => array('cle' => array()),
    100                 'humidite'              => array('cle' => array('humidity', 0, 'attributes', 'value')),
     102                'humidite'              => array('cle' => array('main', 'humidity')),
    101103                'point_rosee'           => array('cle' => array()),
    102                 'pression'              => array('cle' => array('pressure', 0, 'attributes', 'value')),
     104                'pression'              => array('cle' => array('main', 'pressure')),
    103105                'tendance_pression'     => array('cle' => array()),
    104                 'visibilite'            => array('cle' => array('visibility', 0, 'attributes', 'value')),
     106                'visibilite'            => array('cle' => array('visibility')),
    105107                'indice_uv'             => array('cle' => array()),
    106108                // Etats météorologiques natifs
    107                 'code_meteo'            => array('cle' => array('weather', 0, 'attributes', 'number')),
    108                 'icon_meteo'            => array('cle' => array('weather', 0, 'attributes', 'icon')),
    109                 'desc_meteo'            => array('cle' => array('weather', 0, 'attributes', 'value')),
     109                'code_meteo'            => array('cle' => array('weather', 0, 'id')),
     110                'icon_meteo'            => array('cle' => array('weather', 0, 'icon')),
     111                'desc_meteo'            => array('cle' => array('weather', 0, 'description')),
    110112                'trad_meteo'            => array('cle' => array()),
    111113                // Etats météorologiques calculés : icone, resume, periode sont calculés
     
    115117// Configuration des données fournies par le service owm pour le mode 'conditions'.
    116118// -- Seules les données non calculées sont configurées.
    117 // -- On utilise le mode XML et non JSON car la date de dernière mise à jour et la précipitation ne sont
    118 //    pas disponibles en JSON
    119119$GLOBALS['rainette_owm_config']['previsions'] = array(
    120120        'periodicites'       => array(
     
    123123        ),
    124124        'periodicite_defaut' => 24,
    125         'periode_maj'        => 7200,
    126         'format_flux'        => 'xml',
    127         'cle_base'           => array('children', 'forecast', 0, 'children', 'time'),
     125        'periode_maj'        => 3600*2,
     126        'format_flux'        => 'json',
     127        'cle_base'           => array('list'),
    128128        'cle_heure'          => array(),
    129129        'structure_heure'    => false,
    130130        'donnees'            => array(
    131131                // Données d'observation
    132                 'date'                 => array('cle' => array('attributes', 'day')),
     132                'date'                 => array('cle' => array('dt')),
    133133                'heure'                => array('cle' => array()),
    134134                // Données astronomiques
     
    137137                // Températures
    138138                'temperature'          => array('cle' => array()),
    139                 'temperature_max'      => array('cle' => array('children', 'temperature', 0, 'attributes', 'max')),
    140                 'temperature_min'      => array('cle' => array('children', 'temperature', 0, 'attributes', 'min')),
     139                'temperature_max'      => array('cle' => array('temp', 'max')),
     140                'temperature_min'      => array('cle' => array('temp', 'min')),
    141141                // Données anémométriques
    142                 'vitesse_vent'         => array('cle' => array('children', 'windspeed', 0, 'attributes', 'mps')),
    143                 'angle_vent'           => array('cle' => array('children', 'winddirection', 0, 'attributes', 'deg')),
    144                 'direction_vent'       => array('cle' => array('children', 'winddirection', 0, 'attributes', 'code')),
     142                'vitesse_vent'         => array('cle' => array('speed')),
     143                'angle_vent'           => array('cle' => array('deg')),
     144                'direction_vent'       => array('cle' => array()),
    145145                // Données atmosphériques : risque_uv est calculé
    146146                'risque_precipitation' => array('cle' => array()),
    147                 'precipitation'        => array('cle' => array('children', 'precipitation', 0, 'attributes', 'value')),
    148                 'humidite'             => array('cle' => array('children', 'humidity', 0, 'attributes', 'value')),
     147                'precipitation'        => array('cle' => array('rain')),
     148                'humidite'             => array('cle' => array('humidity')),
    149149                'point_rosee'          => array('cle' => array()),
    150                 'pression'             => array('cle' => array('children', 'pressure', 0, 'attributes', 'value')),
     150                'pression'             => array('cle' => array('pressure')),
    151151                'visibilite'           => array('cle' => array()),
    152152                'indice_uv'            => array('cle' => array()),
    153153                // Etats météorologiques natifs
    154                 'code_meteo'           => array('cle' => array('children', 'symbol', 0, 'attributes', 'number')),
    155                 'icon_meteo'           => array('cle' => array('children', 'symbol', 0, 'attributes', 'var')),
    156                 'desc_meteo'           => array('cle' => array('children', 'symbol', 0, 'attributes', 'name')),
     154                'code_meteo'           => array('cle' => array('weather', 0, 'id')),
     155                'icon_meteo'           => array('cle' => array('weather', 0, 'icon')),
     156                'desc_meteo'           => array('cle' => array('weather', 0, 'description')),
    157157                'trad_meteo'           => array('cle' => array()),
    158158                // Etats météorologiques calculés : icone, resume, periode sont calculés
    159159        ),
    160160);
     161
     162// Configuration des données fournies par le service owm en cas d'erreur.
     163// -- Seules les données non calculées sont configurées.
     164$GLOBALS['rainette_owm_config']['erreurs'] = array(
     165        'cle_base'    => array(),
     166        'donnees'     => array(
     167                // Erreur
     168                'code'     => array('cle' => array('cod')),
     169                'message'  => array('cle' => array('message')),
     170        ),
     171);
     172
    161173
    162174/**
     
    231243
    232244/**
     245 * @param array $erreur
     246 *
     247 * @return bool
     248 */
     249function owm_erreur_verifier($erreur) {
     250
     251        // Initialisation
     252        $est_erreur = false;
     253
     254        // Pour OWM une erreur possède deux attributs, le code et le message.
     255        // Néanmoins, le code 200 est aussi renvoyé pour dire ok sans message.
     256        // => il faut donc écarter ce cas d'une erreur.
     257        if (!empty($erreur['code']) and !empty($erreur['message']) and ($erreur['code'] != '200')) {
     258                $est_erreur = true;
     259        }
     260
     261        return $est_erreur;
     262}
     263
     264
     265/**
    233266 * @param array $tableau
    234267 * @param       $configuration
     
    267300                $tableau['temperature_ressentie'] = temperature2ressenti($tableau['temperature_reelle'], $tableau['vitesse_vent']);
    268301                $tableau['direction_vent'] = angle2direction($tableau['angle_vent']);
     302                // On convertit aussi la visibilité en km car elle est fournie en mètres.
     303                $tableau['visibilite'] = metre2kilometre($tableau['visibilite']);
    269304
    270305                // Compléter le tableau standard avec les états météorologiques calculés
     
    297332
    298333        if (($tableau) and ($index_periode > -1)) {
     334                // Vérifier les précipitations. Pour les prévisions, OWM renvoie le champ rain uniquement si il est
     335                // différent de zéro. Il faut donc rétablir la valeur zéro dans ce cas pour éviter d'avoir N/D lors de
     336                // l'affichage.
     337                if ($tableau['precipitation'] === '') {
     338                        $tableau['precipitation'] = 0;
     339                }
    299340
    300341                // Compléter le tableau standard avec les états météorologiques calculés
  • _plugins_/rainette/trunk/services/weather.php

    r100714 r107848  
    3333                'disponibles' => array(),
    3434                'defaut'      => 'en'
    35         )
     35        ),
     36        'requetes' => array()
    3637);
    3738
     
    133134);
    134135
     136// Configuration des données fournies par le service weather en cas d'erreur.
     137// -- Seules les données non calculées sont configurées.
     138$GLOBALS['rainette_weather_config']['erreurs'] = array(
     139        'cle_base'    => array('children', 'err', 0,),
     140        'donnees'     => array(
     141                // Erreur
     142                'code'     => array('cle' => array()),
     143                'message'  => array('cle' => array('text')),
     144        ),
     145);
     146
    135147
    136148/**
     
    178190
    179191        return $url;
     192}
     193
     194
     195/**
     196 * @param array $erreur
     197 *
     198 * @return bool
     199 */
     200function weather_erreur_verifier($erreur) {
     201
     202        // Initialisation
     203        $est_erreur = false;
     204
     205        // Une erreur est uniquement décrite par un texte (message).
     206        if (!empty($erreur['message'])) {
     207                $est_erreur = true;
     208        }
     209
     210        return $est_erreur;
    180211}
    181212
  • _plugins_/rainette/trunk/services/wunderground.php

    r107753 r107848  
    117117                ),
    118118                'defaut'      => 'EN'
     119        ),
     120        'requetes' => array(
     121                'jour'        => 500,
     122                '1minute'     => 10
    119123        )
    120124);
     
    218222);
    219223
     224// Configuration des données fournies par le service Wunderground en cas d'erreur.
     225// -- Seules les données non calculées sont configurées.
     226$GLOBALS['rainette_wunderground_config']['erreurs'] = array(
     227        'cle_base'    => array('response', 'error'),
     228        'donnees'     => array(
     229                // Erreur
     230                'code'     => array('cle' => array('type')),
     231                'message'  => array('cle' => array('description')),
     232        ),
     233);
     234
    220235
    221236/**
     
    309324
    310325        return $url;
     326}
     327
     328
     329/**
     330 * @param array $erreur
     331 *
     332 * @return bool
     333 */
     334function wunderground_erreur_verifier($erreur) {
     335
     336        // Initialisation
     337        $est_erreur = false;
     338
     339        // Une erreur est toujours décrite par un type (code) et un message.
     340        if (!empty($erreur['code']) and !empty($erreur['message'])) {
     341                $est_erreur = true;
     342        }
     343
     344        return $est_erreur;
    311345}
    312346
  • _plugins_/rainette/trunk/services/wwo.php

    r107753 r107848  
    7272                ),
    7373                'defaut'      => 'en'
     74        ),
     75        'requetes' => array(
     76                'jour'        => 500
    7477        )
    7578);
     
    177180);
    178181
     182// Configuration des données fournies par le service WWO en cas d'erreur.
     183// -- Seules les données non calculées sont configurées.
     184$GLOBALS['rainette_wwo_config']['erreurs'] = array(
     185        'cle_base'    => array('data', 'error', 0),
     186        'donnees'     => array(
     187                // Erreur
     188                'code'     => array('cle' => array()),
     189                'message'  => array('cle' => array('msg')),
     190        ),
     191);
     192
    179193
    180194// ------------------------------------------------------------------------------------------------
     
    254268
    255269        return $url;
     270}
     271
     272
     273/**
     274 * @param array $erreur
     275 *
     276 * @return bool
     277 */
     278function wwo_erreur_verifier($erreur) {
     279
     280        // Initialisation
     281        $est_erreur = false;
     282
     283        // Une erreur est uniquement décrite par un message.
     284        if (!empty($erreur['message'])) {
     285                $est_erreur = true;
     286        }
     287
     288        return $est_erreur;
    256289}
    257290
Note: See TracChangeset for help on using the changeset viewer.