Changeset 122318 in spip-zone


Ignore:
Timestamp:
Feb 8, 2020, 6:53:44 PM (2 weeks ago)
Author:
Eric Lupinacci
Message:

Robustifier l'API en gérant les cas où le service est soit inconnu soit désactivé

Location:
_plugins_/rainette/trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/rainette/trunk

    • Property subgit:lock:38c195dd43592aedc545f120616cba40febed942 deleted
    • Property subgit:lock:77f25b13099576ec86760a3bc2888dc2645d6fbc set to 2020-02-08T21:00:38.393
  • _plugins_/rainette/trunk/inc/meteo_charger.php

    r113953 r122318  
    6666        }
    6767
    68         // En fonction du service, on inclut le fichier d'API.
    69         // Le principe est que chaque service propose la même liste de fonctions d'interface dans un fichier unique.
    70         include_spip("services/${service}");
    71 
    72         // Acquérir la configuration statique du service (periode, format, données...)
    73         $configurer = "${service}_service2configuration";
    74         $configuration = $configurer($mode);
    75 
    76         // Acquérir la configuration dynamique du service (celle modifiable par l'utilisateur via
    77         // le formulaire et stockée en BDD dans la table spip_meta) et la merger avec la configuration statique.
    78         // Cependant, celle-ci pouvant être incomplète on la complète par les valeurs par défaut quand
    79         // cela est nécessaire.
     68        // On vérifie d'abord si le service est connu et actif car sinon il est inutile de continuer.
     69        // -- on initialise le bloc d'erreur
     70        $erreur = array(
     71                'type' => '',
     72                'service' => array(
     73                        'code' => '',
     74                        'message' => ''
     75                )
     76        );
     77        // -- on vérifie le service qui renvoie un type d'erreur ou vide sinon.
    8078        include_spip('inc/rainette_normaliser');
    81         $configuration_utilisateur = parametrage_normaliser($service, $configuration['defauts']);
    82 
    83         // Concaténer l'ensemble des configurations.
    84         $configuration = array_merge($configuration, $configuration_utilisateur);
    85 
    86         // Si on a demandé le mode 'previsions' sans préciser la periodicité horaire des données, il faut prendre l'intervalle
    87         // par défaut configuré pour le service.
    88         if (($mode == 'previsions') and !$periodicite) {
    89                 $periodicite = $configuration['previsions']['periodicite_defaut'];
    90         }
    91 
    92         // Construire le tableau identifiant le cache
    93         $cache = cache_normaliser($lieu, $mode, $periodicite, $configuration);
    94 
    95         // Mise à jour du cache avec les nouvelles données météo si:
    96         // - le fichier cache n'existe pas
    97         // - la période de validité du cache est échue
    98         include_spip('inc/cache');
    99         if (!$fichier_cache = cache_est_valide('rainette', $cache)) {
    100                 // Construire l'url de la requête
    101                 $urler = "${service}_service2url";
    102                 $url = $urler($lieu, $mode, $periodicite, $configuration);
    103 
    104                 // Acquérir le flux XML ou JSON dans un tableau si les limites du service ne sont pas atteintes
    105                 // et traiter les cas d'erreurs du plugin ou du service.
    106                 include_spip('inc/rainette_requeter');
    107                 $erreur = array(
    108                         'type' => '',
    109                         'service' => array(
    110                                 'code' => '',
    111                                 'message' => ''
    112                         )
     79        if ($erreur['type'] = service_est_indisponible($service)) {
     80                // Service nok :
     81                // -----------
     82                // On construit le tableau directement sans passer par un cache.
     83                $tableau = array(
     84                        'donnees' => array(),
     85                        'extras' => erreur_normaliser_extras($erreur, $lieu, $mode, $periodicite, $service)
    11386                );
    114                 if (!requete_autorisee($configuration['offres']['limites'], $service)) {
    115                         // La requête n'est pas autorisée parce qu'elle excède les limitations d'utilisation du service.
    116                         // On renvoie une erreur pour prévenir les utilisateurs.
    117                         $erreur['type'] = 'limite_service';
    118                 } else {
    119                         $flux = requeter($url, $configuration, $service);
    120                         if (!empty($flux['erreur'])) {
    121                                 // Erreur lors du traitement de la requête due à l'URL ou à la conversion en XML ou JSON.
    122                                 // Cette erreur n'est pas retournée par le service.
    123                                 $erreur['type'] = $flux['erreur'];
     87        } else {
     88                // Service ok :
     89                // ----------
     90                // En fonction du service, on inclut le fichier d'API.
     91                // Le principe est que chaque service propose la même liste de fonctions d'interface dans un fichier unique.
     92                include_spip("services/${service}");
     93
     94                // Acquérir la configuration statique du service (periode, format, données...)
     95                $configurer = "${service}_service2configuration";
     96                $configuration = $configurer($mode);
     97
     98                // Acquérir la configuration dynamique du service (celle modifiable par l'utilisateur via
     99                // le formulaire et stockée en BDD dans la table spip_meta) et la merger avec la configuration statique.
     100                // Cependant, celle-ci pouvant être incomplète on la complète par les valeurs par défaut quand
     101                // cela est nécessaire.
     102                $configuration_utilisateur = parametrage_normaliser($service, $configuration['defauts']);
     103
     104                // Concaténer l'ensemble des configurations.
     105                $configuration = array_merge($configuration, $configuration_utilisateur);
     106
     107                // Si on a demandé le mode 'previsions' sans préciser la periodicité horaire des données, il faut prendre l'intervalle
     108                // par défaut configuré pour le service.
     109                if (($mode == 'previsions') and !$periodicite) {
     110                        $periodicite = $configuration['previsions']['periodicite_defaut'];
     111                }
     112
     113                // Construire le tableau identifiant le cache
     114                $cache = cache_normaliser($lieu, $mode, $periodicite, $configuration);
     115
     116                // Mise à jour du cache avec les nouvelles données météo si:
     117                // - le fichier cache n'existe pas
     118                // - la période de validité du cache est échue
     119                include_spip('inc/cache');
     120                if (!$fichier_cache = cache_est_valide('rainette', $cache)) {
     121                        // Construire l'url de la requête
     122                        $urler = "${service}_service2url";
     123                        $url = $urler($lieu, $mode, $periodicite, $configuration);
     124
     125                        // Acquérir le flux XML ou JSON dans un tableau si les limites du service ne sont pas atteintes
     126                        // et traiter les cas d'erreurs du plugin ou du service.
     127                        include_spip('inc/rainette_requeter');
     128                        if (!requete_autorisee($configuration['offres']['limites'], $service)) {
     129                                // La requête n'est pas autorisée parce qu'elle excède les limitations d'utilisation du service.
     130                                // On renvoie une erreur pour prévenir les utilisateurs.
     131                                $erreur['type'] = 'limite_service';
    124132                        } else {
    125                                 // On teste une erreur d'acquisition renvoyée par le service. Pour tous les services, une cle de base
    126                                 // est explicitement utilisée pour distinguer les erreurs; sa présence permet d'identifier un cas d'erreur.
    127                                 include_spip('inc/filtres');
    128                                 $configuration_erreur = $configurer('erreurs');
    129                                 $flux_erreur = $flux;
    130                                 if (!empty($configuration_erreur['cle_base'])) {
    131                                         $flux_erreur = table_valeur($flux, implode('/', $configuration_erreur['cle_base']), null);
    132                                 }
    133 
    134                                 // On normalise le flux en utilisant le mode d'erreur pour vérifier si on obtient bien une erreur.
    135                                 $erreur_service = meteo_normaliser($configuration_erreur, 'erreurs', $flux_erreur, -1);
    136                                 $verifier = "${service}_erreur_verifier";
    137                                 if ($verifier($erreur_service)) {
    138                                         // Une erreur est renvoyée par le service, on formate l'erreur correctement.
    139                                         $erreur['type'] = 'reponse_service';
    140                                         $erreur['service'] = array_merge($erreur['service'], $erreur_service);
     133                                $flux = requeter($url, $configuration, $service);
     134                                if (!empty($flux['erreur'])) {
     135                                        // Erreur lors du traitement de la requête due à l'URL ou à la conversion en XML ou JSON.
     136                                        // Cette erreur n'est pas retournée par le service.
     137                                        $erreur['type'] = $flux['erreur'];
    141138                                } else {
    142                                         // On se positionne sur le niveau de base du flux des données où commence le tableau des données météorologiques.
    143                                         if (!empty($configuration['cle_base'])) {
    144                                                 $flux = table_valeur($flux, implode('/', $configuration['cle_base']), null);
     139                                        // On teste une erreur d'acquisition renvoyée par le service. Pour tous les services, une cle de base
     140                                        // est explicitement utilisée pour distinguer les erreurs; sa présence permet d'identifier un cas d'erreur.
     141                                        include_spip('inc/filtres');
     142                                        $configuration_erreur = $configurer('erreurs');
     143                                        $flux_erreur = $flux;
     144                                        if (!empty($configuration_erreur['cle_base'])) {
     145                                                $flux_erreur = table_valeur($flux, implode('/', $configuration_erreur['cle_base']), null);
    145146                                        }
    146147
    147                                         if (empty($flux)) {
    148                                                 // Pas d'erreur retournée par le service mais aucune donnée fournie. Ce cas est peut-être impossible
    149                                                 // mais on le traite tout de même par sécurité avec un type particulier.
    150                                                 $erreur['type'] = 'aucune_donnee';
     148                                        // On normalise le flux en utilisant le mode d'erreur pour vérifier si on obtient bien une erreur.
     149                                        $erreur_service = meteo_normaliser($configuration_erreur, 'erreurs', $flux_erreur, -1);
     150                                        $verifier = "${service}_erreur_verifier";
     151                                        if ($verifier($erreur_service)) {
     152                                                // Une erreur est renvoyée par le service, on formate l'erreur correctement.
     153                                                $erreur['type'] = 'reponse_service';
     154                                                $erreur['service'] = array_merge($erreur['service'], $erreur_service);
    151155                                        } else {
    152                                                 // En mode prévisions, le niveau de base est un tableau de n éléments, chaque élément étant un tableau contenant
    153                                                 // les données météorologiques d'un jour à venir ([0] => jour0[], [1] => jour1[]...).
    154                                                 // En mode infos ou conditions, on a directement accès aux données météorologiques (jour[]).
    155                                                 // Pour réaliser un traitement standard, on transforme donc le jour[] en un tableau d'un seul élément ([0] => jour[])
    156                                                 // qui pourra être traité comme celui des prévisions.
    157                                                 if (($mode == 'conditions') or ($mode == 'infos')) {
    158                                                         $flux = array($flux);
     156                                                // On se positionne sur le niveau de base du flux des données où commence le tableau des données météorologiques.
     157                                                if (!empty($configuration['cle_base'])) {
     158                                                        $flux = table_valeur($flux, implode('/', $configuration['cle_base']), null);
    159159                                                }
    160160
    161                                                 // Convertir le flux en tableau standard pour la mise en cache. Ce traitement se déroule en
    162                                                 // 3 étapes :
    163                                                 // -1- initialisation du tableau standard à partir uniquement des données reçues du service
    164                                                 // -2- complément du tableau avec les données propres à chaque service
    165                                                 // -3- complément du tableau avec les données communes à tous les services
    166                                                 foreach ($flux as $_index_jour => $_flux_jour) {
    167                                                         // Pour les informations et les conditions les données récupérées concernent toute la même "période".
    168                                                         // Par contre, pour les prévisions on distingue 2 type de données :
    169                                                         // - celles du jour indépendamment de la période horaire
    170                                                         // - celles correspondant à une période horaire choisie (24, 12, 6, 3, 1)
    171                                                         //   Ces données sont stockées à un index horaire de 0 à n qui représente la période horaire.
    172                                                         // Pour avoir un traitement identique pour les deux types de données on considère que l'index horaire
    173                                                         // des données jour est égal à -1.
    174                                                         // On crée donc le tableau des index correspondant au mode choisi et on boucle dessus.
    175                                                         $periodes_horaires = array(-1);
    176                                                         if ($periodicite) {
    177                                                                 for ($i = 0; $i < (24 / $periodicite); $i++) {
    178                                                                         $periodes_horaires[] = $i;
     161                                                if (empty($flux)) {
     162                                                        // Pas d'erreur retournée par le service mais aucune donnée fournie. Ce cas est peut-être impossible
     163                                                        // mais on le traite tout de même par sécurité avec un type particulier.
     164                                                        $erreur['type'] = 'aucune_donnee';
     165                                                } else {
     166                                                        // En mode prévisions, le niveau de base est un tableau de n éléments, chaque élément étant un tableau contenant
     167                                                        // les données météorologiques d'un jour à venir ([0] => jour0[], [1] => jour1[]...).
     168                                                        // En mode infos ou conditions, on a directement accès aux données météorologiques (jour[]).
     169                                                        // Pour réaliser un traitement standard, on transforme donc le jour[] en un tableau d'un seul élément ([0] => jour[])
     170                                                        // qui pourra être traité comme celui des prévisions.
     171                                                        if (($mode == 'conditions') or ($mode == 'infos')) {
     172                                                                $flux = array($flux);
     173                                                        }
     174
     175                                                        // Convertir le flux en tableau standard pour la mise en cache. Ce traitement se déroule en
     176                                                        // 3 étapes :
     177                                                        // -1- initialisation du tableau standard à partir uniquement des données reçues du service
     178                                                        // -2- complément du tableau avec les données propres à chaque service
     179                                                        // -3- complément du tableau avec les données communes à tous les services
     180                                                        foreach ($flux as $_index_jour => $_flux_jour) {
     181                                                                // Pour les informations et les conditions les données récupérées concernent toute la même "période".
     182                                                                // Par contre, pour les prévisions on distingue 2 type de données :
     183                                                                // - celles du jour indépendamment de la période horaire
     184                                                                // - celles correspondant à une période horaire choisie (24, 12, 6, 3, 1)
     185                                                                //   Ces données sont stockées à un index horaire de 0 à n qui représente la période horaire.
     186                                                                // Pour avoir un traitement identique pour les deux types de données on considère que l'index horaire
     187                                                                // des données jour est égal à -1.
     188                                                                // On crée donc le tableau des index correspondant au mode choisi et on boucle dessus.
     189                                                                $periodes_horaires = array(-1);
     190                                                                if ($periodicite) {
     191                                                                        for ($i = 0; $i < (24 / $periodicite); $i++) {
     192                                                                                $periodes_horaires[] = $i;
     193                                                                        }
    179194                                                                }
    180                                                         }
    181 
    182                                                         // On détermine le flux heure en fonction du service. Ce flux heure coincide avec le flux jour dans
    183                                                         // la majeure partie des cas
    184                                                         $flux_heure = $_flux_jour;
    185                                                         if ((count($periodes_horaires) > 1) and !empty($configuration['cle_heure'])) {
    186                                                                 $flux_heure = table_valeur($_flux_jour, implode('/', $configuration['cle_heure']), null);
    187                                                         }
    188 
    189                                                         // On boucle sur chaque période horaire pour remplir le tableau complet.
    190                                                         foreach ($periodes_horaires as $_periode) {
    191                                                                 // 1- Initialiser le tableau normalisé des informations à partir des données brutes
    192                                                                 //    fournies par le service.
    193                                                                 //    Suivant la période il faut prendre le flux jour ou le flux heure. On calcule donc le flux heure
    194                                                                 //    quand c'est nécessaire.
    195                                                                 $flux_a_normaliser = $_periode == -1 ? $_flux_jour : ($configuration['structure_heure'] ? $flux_heure[$_periode] : $flux_heure);
    196                                                                 $donnees = meteo_normaliser($configuration, $mode, $flux_a_normaliser, $_periode);
    197 
    198                                                                 if ($donnees) {
    199                                                                         // 2- Compléments spécifiques au service et au mode.
    200                                                                         //    Si ces compléments sont inutiles, la fonction n'existe pas
    201                                                                         $completer = "${service}_complement2${mode}";
    202                                                                         if (function_exists($completer)) {
    203                                                                                 $donnees = $mode == 'previsions' ? $completer($donnees, $configuration, $_periode) : $completer($donnees, $configuration);
    204                                                                         }
    205 
    206                                                                         // 3- Compléments standard communs à tous les services mais fonction du mode
    207                                                                         if ($mode == 'conditions') {
    208                                                                                 // Vérifier que l'indice uv si celui-ci est fourni
    209                                                                                 // Calcul du risque uv à partir de l'indice uv si celui-ci est fourni
    210                                                                                 include_spip('inc/rainette_convertir');
    211                                                                                 $donnees['risque_uv'] = is_int($donnees['indice_uv']) ? indice2risque_uv($donnees['indice_uv']) : $donnees['indice_uv'];
    212                                                                         }
    213 
    214                                                                         // Ajout du bloc à l'index en cours
    215                                                                         if ($_periode == -1) {
    216                                                                                 $tableau[$_index_jour] = $donnees;
    217                                                                         } else {
    218                                                                                 $tableau[$_index_jour]['heure'][$_periode] = $donnees;
     195
     196                                                                // On détermine le flux heure en fonction du service. Ce flux heure coincide avec le flux jour dans
     197                                                                // la majeure partie des cas
     198                                                                $flux_heure = $_flux_jour;
     199                                                                if ((count($periodes_horaires) > 1) and !empty($configuration['cle_heure'])) {
     200                                                                        $flux_heure = table_valeur($_flux_jour, implode('/', $configuration['cle_heure']), null);
     201                                                                }
     202
     203                                                                // On boucle sur chaque période horaire pour remplir le tableau complet.
     204                                                                foreach ($periodes_horaires as $_periode) {
     205                                                                        // 1- Initialiser le tableau normalisé des informations à partir des données brutes
     206                                                                        //    fournies par le service.
     207                                                                        //    Suivant la période il faut prendre le flux jour ou le flux heure. On calcule donc le flux heure
     208                                                                        //    quand c'est nécessaire.
     209                                                                        $flux_a_normaliser = $_periode == -1 ? $_flux_jour : ($configuration['structure_heure'] ? $flux_heure[$_periode] : $flux_heure);
     210                                                                        $donnees = meteo_normaliser($configuration, $mode, $flux_a_normaliser, $_periode);
     211
     212                                                                        if ($donnees) {
     213                                                                                // 2- Compléments spécifiques au service et au mode.
     214                                                                                //    Si ces compléments sont inutiles, la fonction n'existe pas
     215                                                                                $completer = "${service}_complement2${mode}";
     216                                                                                if (function_exists($completer)) {
     217                                                                                        $donnees = $mode == 'previsions' ? $completer($donnees, $configuration, $_periode) : $completer($donnees, $configuration);
     218                                                                                }
     219
     220                                                                                // 3- Compléments standard communs à tous les services mais fonction du mode
     221                                                                                if ($mode == 'conditions') {
     222                                                                                        // Vérifier que l'indice uv si celui-ci est fourni
     223                                                                                        // Calcul du risque uv à partir de l'indice uv si celui-ci est fourni
     224                                                                                        include_spip('inc/rainette_convertir');
     225                                                                                        $donnees['risque_uv'] = is_int($donnees['indice_uv']) ? indice2risque_uv($donnees['indice_uv']) : $donnees['indice_uv'];
     226                                                                                }
     227
     228                                                                                // Ajout du bloc à l'index en cours
     229                                                                                if ($_periode == -1) {
     230                                                                                        $tableau[$_index_jour] = $donnees;
     231                                                                                } else {
     232                                                                                        $tableau[$_index_jour]['heure'][$_periode] = $donnees;
     233                                                                                }
    219234                                                                        }
    220235                                                                }
     
    224239                                }
    225240                        }
     241
     242                        // 4- Compléments standard à tous les services et tous les modes
     243                        $extras = erreur_normaliser_extras($erreur, $lieu, $mode, $periodicite, $service, $configuration);
     244
     245                        // On range les données et les extras dans un tableau associatif à deux entrées ('donnees', 'extras')
     246                        if ($tableau) {
     247                                // Pour les modes "conditions" et "infos" l'ensemble des données météo est accessible sous
     248                                // l'index 'donnees'. Il faut donc supprimer l'index 0 provenant du traitement commun avec
     249                                // les prévisions.
     250                                // Pour les prévisions l'index 0 à n désigne le jour, il faut donc le conserver
     251                                $tableau = array(
     252                                        'donnees' => ($mode != 'previsions' ? array_shift($tableau) : $tableau),
     253                                        'extras' => $extras
     254                                );
     255                        } else {
     256                                // Traitement des erreurs de flux. On positionne toujours les bloc extra contenant l'erreur,
     257                                // le bloc des données qui est mis à tableau vide dans ce cas à l'index 1.
     258                                $tableau = array(
     259                                        'donnees' => array(),
     260                                        'extras' => $extras
     261                                );
     262                        }
     263
     264                        // Pipeline de fin de chargement des données météo. Peut-être utilisé :
     265                        // -- pour effectuer des traitements annexes à partir des données météo (archivage, par exemple)
     266                        // -- pour ajouter ou modifier des données au tableau (la modification n'est pas conseillée cependant)
     267                        $tableau = pipeline(
     268                                'post_chargement_meteo',
     269                                array(
     270                                        'args' => array('lieu' => $lieu, 'mode' => $mode, 'service' => $service),
     271                                        'data' => $tableau
     272                                )
     273                        );
     274
     275                        // Mise à jour du cache
     276                        cache_ecrire('rainette', $cache, $tableau);
     277                } else {
     278                        // Lecture des données du fichier cache valide
     279                        $tableau = cache_lire('rainette', $fichier_cache);
    226280                }
    227 
    228                 // 4- Compléments standard à tous les services et tous les modes
    229                 $extras = array();
    230                 $extras['credits'] = $configuration['credits'];
    231                 $extras['config'] = array_merge($configuration_utilisateur, array('source' => configuration_donnees_normaliser($mode, $configuration['donnees'])), array('nom_service' => $configuration['nom']));
    232                 $extras['lieu'] = $lieu;
    233                 $extras['mode'] = $mode;
    234                 $extras['periodicite_cache'] = $periodicite;
    235                 $extras['service'] = $service;
    236                 $extras['erreur'] = $erreur;
    237 
    238                 // On range les données et les extras dans un tableau associatif à deux entrées ('donnees', 'extras')
    239                 if ($tableau) {
    240                         // Pour les modes "conditions" et "infos" l'ensemble des données météo est accessible sous
    241                         // l'index 'donnees'. Il faut donc supprimer l'index 0 provenant du traitement commun avec
    242                         // les prévisions.
    243                         // Pour les prévisions l'index 0 à n désigne le jour, il faut donc le conserver
    244                         $tableau = array(
    245                                 'donnees' => ($mode != 'previsions' ? array_shift($tableau) : $tableau), 'extras' => $extras
    246                         );
    247                 } else {
    248                         // Traitement des erreurs de flux. On positionne toujours les bloc extra contenant l'erreur,
    249                         // le bloc des données qui est mis à tableau vide dans ce cas à l'index 1.
    250                         $tableau = array(
    251                                 'donnees' => array(), 'extras' => $extras
    252                         );
    253                 }
    254 
    255                 // Pipeline de fin de chargement des données météo. Peut-être utilisé :
    256                 // -- pour effectuer des traitements annexes à partir des données météo (archivage, par exemple)
    257                 // -- pour ajouter ou modifier des données au tableau (la modification n'est pas conseillée cependant)
    258                 $tableau = pipeline(
    259                         'post_chargement_meteo',
    260                         array(
    261                                 'args' => array('lieu' => $lieu, 'mode' => $mode, 'service' => $service),
    262                                 'data' => $tableau
    263                         )
    264                 );
    265 
    266                 // Mise à jour du cache
    267                 cache_ecrire('rainette', $cache, $tableau);
    268         } else {
    269                 // Lecture des données du fichier cache valide
    270                 $tableau = cache_lire('rainette', $fichier_cache);
    271281        }
    272282
  • _plugins_/rainette/trunk/inc/rainette_debusquer.php

    r113944 r122318  
    3131
    3232        // Recuperation du tableau des conditions courantes
    33         if (_RAINETTE_DEBUG and function_exists('bel_env')) {
     33        include_spip('inc/rainette_normaliser');
     34        if (!service_est_indisponible($service) and _RAINETTE_DEBUG and function_exists('bel_env')) {
    3435                // Si on est en mode prévisions, on impose la périodicité à la valeur par défaut pour le service
    3536                $periodicite = 0;
     
    264265        include_spip('inc/lang_liste');
    265266        include_spip('inc/rainette_normaliser');
     267
     268        $texte = '';
    266269        foreach ($GLOBALS['codes_langues'] as $code => $langue) {
    267270                if (!array_key_exists($code, $GLOBALS['rainette_config']['langues_alternatives'])) {
    268                         echo "code manquant $code<br />";
    269                 }
    270         }
    271 }
     271                        $texte .= "code manquant $code<br />";
     272                }
     273        }
     274
     275        return $texte;
     276}
  • _plugins_/rainette/trunk/inc/rainette_normaliser.php

    r113944 r122318  
    544544 * @param $lieu
    545545 * @param $mode
     546 * @param $periodicite
     547 * @param $service
     548 * @param $configuration
     549 *
     550 * @return array
     551 */
     552function erreur_normaliser_extras($erreur, $lieu, $mode, $periodicite, $service, $configuration = array()) {
     553
     554        $extras = array(
     555                'credits'           => array(),
     556                'config'            => array(
     557                        'nom_service' => $service
     558                ),
     559                'lieu'              => $lieu,
     560                'mode'              => $mode,
     561                'periodicite_cache' => $periodicite,
     562                'service'           => $service,
     563                'erreur'            => $erreur
     564        );
     565
     566        // On complète les informations extras uniquement si le service est connu actif ou non.
     567        if ($erreur['type'] != 'service_inconnu') {
     568                if (!$configuration) {
     569                        // Acquérir la configuration statique du service (periode, format, données...)
     570                        include_spip("services/${service}");
     571                        $configurer = "${service}_service2configuration";
     572                        $configuration = $configurer($mode);
     573                }
     574
     575                // On prépare un contexte extras pour traiter les erreurs du modèle de façon standard comme celles
     576                // renvoyée par le chargement des données.
     577                $extras['credits'] = $configuration['credits'];
     578                $extras['config'] = array_merge(
     579                        parametrage_normaliser($service, $configuration['defauts']),
     580                        array('source' => configuration_donnees_normaliser($mode, $configuration['donnees'])),
     581                        array('nom_service' => $configuration['nom'])
     582                );
     583        }
     584
     585        return $extras;
     586}
     587
     588/**
     589 * @param $erreur
     590 * @param $lieu
     591 * @param $mode
    546592 * @param $modele
    547593 * @param $service
     594 * @param $nom_service
    548595 *
    549596 * @return array
     
    594641                        $texte['conseil'] .= _T('rainette:erreur_conseil_modele_expliciter');
    595642                        break;
     643                case 'service_inactif':
     644                        $texte['principal'] .= _T("rainette:erreur_${type_erreur}", array('service' => $nom_service));
     645                        $texte['conseil'] .= _T('rainette:erreur_conseil_service_changer');
     646                        break;
     647                case 'service_inconnu':
     648                        $texte['principal'] .= _T("rainette:erreur_${type_erreur}", array('service' => $service));
     649                        $texte['conseil'] .= _T('rainette:erreur_conseil_service_verifier');
     650                        break;
    596651        }
    597652
     
    883938        return $chemin;
    884939}
     940
     941
     942/**
     943 * @param string $service
     944 *
     945 * @return string
     946 */
     947function service_est_indisponible($service) {
     948
     949        $services = rainette_lister_services('tableau', false);
     950        if (!array_key_exists($service, $services)) {
     951                // L'identifiant du service est erroné.
     952                $erreur = 'service_inconnu';
     953        } elseif (!$services[$service]['actif']) {
     954                // Le service est inactivé.
     955                $erreur = 'service_inactif';
     956        } else {
     957                $erreur = '';
     958        }
     959
     960        return $erreur;
     961}
  • _plugins_/rainette/trunk/lang/rainette_fr.php

    r122315 r122318  
    4747        'erreur_conseil_periodicite' => 'Veuillez utiliser une autre périodicité ou un autre modèle.',
    4848        'erreur_conseil_service' => 'Veuillez consulter le message du service ci-dessous.',
     49        'erreur_conseil_service_changer' => 'Veuillez utiliser un autre service.',
     50        'erreur_conseil_service_verifier' => 'Veuillez consulter la documentation pour choisir un identifiant de service valide.',
    4951        'erreur_limite_service' => 'Le nombre de requêtes maximum autorisé par le service @service@ a été atteint. Il est temporairement impossible d\'afficher des données météorologiques.',
    5052        'erreur_modele_inutilisable' => 'Le nom du modèle @modele@ ne permet pas de déterminer une périodicité horaire par défaut.',
     
    5456        'erreur_reponse_service_infos' => 'Le service @service@ ne fournit actuellement aucune condition météorologique sur le lieu @lieu@.',
    5557        'erreur_reponse_service_previsions' => 'Le service @service@ ne fournit actuellement aucune prévision météorologique sur le lieu @lieu@.',
     58        'erreur_service_inconnu' => 'L\'identifiant de service @service@ est erroné.',
     59        'erreur_service_inactif' => 'Le service @service@ choisi a été désactivé car il ne fournit plus de données météorologiques.',
    5660        'erreur_url_indisponible' => 'L\'URL utilisée pour le service @service@ semble erronée.',
    5761        'explication_configurer_cle_aucune' => 'Ce service ne nécessite aucune clé d\'inscription pour être utilisé.',
  • _plugins_/rainette/trunk/rainette_fonctions.php

    r122313 r122318  
    293293/**
    294294 * @param string $mode
     295 * @param bool   $actif_uniquement
    295296 *
    296297 * @return array|string
    297298 */
    298 function rainette_lister_services($mode = 'tableau') {
     299function rainette_lister_services($mode = 'tableau', $actif_uniquement = true) {
    299300
    300301        static $services = array();
    301302
    302         if (!isset($service[$mode])) {
     303        if (!isset($service[$mode][$actif_uniquement])) {
    303304                // On lit les fichiers php dans répertoire services/ du plugin sachant ce répertoire
    304305                // contient exclusivement les api de chaque service dans un fichier unique appelé
     
    315316                                $configuration = $configurer('service');
    316317
    317                                 // Ajout du service dans la liste uniquement si celui-ci est encore actif.
    318                                 if ($configuration['actif']) {
    319                                         $liste[$service] = $configuration['nom'];
     318                                // Ajout du service dans la liste uniquement si celui-ci est encore actif ou si on demande tous
     319                                // les services actifs ou pas.
     320                                if (
     321                                        !$actif_uniquement
     322                                        or ($actif_uniquement
     323                                                and $configuration['actif']
     324                                        )
     325                                ) {
     326                                        if (
     327                                                ($mode == 'tableau')
     328                                                and !$actif_uniquement
     329                                        ) {
     330                                                $liste[$service] = array(
     331                                                        'nom'   => $configuration['nom'],
     332                                                        'actif' => $configuration['actif']
     333                                                );
     334                                        } else {
     335                                                $liste[$service] = $configuration['nom'];
     336                                        }
    320337                                }
    321338                        }
     
    324341                // Par défaut la liste est fournie comme un tableau.
    325342                // Si le mode demandé est 'liste' on renvoie une chaîne énumérée des alias de service séparée par des virgules.
    326                 $services[$mode] = ($mode == 'tableau') ? $liste : implode(',', array_keys($liste));
    327         }
    328 
    329         return $services[$mode];
     343                $services[$mode][$actif_uniquement] = ($mode == 'tableau')
     344                        ? $liste
     345                        : implode(',', array_keys($liste));
     346        }
     347
     348        return $services[$mode][$actif_uniquement];
    330349}
    331350
     
    423442function rainette_coasser($lieu, $mode = 'conditions', $modele = 'conditions_tempsreel', $service = 'weather', $options = array()) {
    424443
    425         // Initialisation du tableau des données météorologiques
    426         $tableau = array();
     444        // Vérification du service et de la cohérence entre le mode, le modèle et la périodicité.
    427445        include_spip('inc/rainette_normaliser');
    428 
    429         // Détermination de la périodicité en fonction du mode et du modèle demandés
    430446        $periodicite = 0;
    431         $erreur = '';
    432         if ($mode == 'previsions') {
    433                 // Identification de la périodicité à partir du nom du modèle. Cela évite une configuration compliquée.
    434                 if (preg_match(',_(1|12|24)h,is', $modele, $match)) {
    435                         $type_modele = intval($match[1]);
    436 
    437                         // On verifie que la périodicité demandée explicitement dans l'appel du modèle est ok
    438                         if (isset($options['periodicite'])) {
    439                                 $periodicite_explicite = intval($options['periodicite']);
    440                                 if (periodicite_est_compatible($type_modele, $periodicite_explicite)) {
    441                                         $periodicite = $periodicite_explicite;
     447        if (!$type_erreur = service_est_indisponible($service)) {
     448                // Détermination de la périodicité en fonction du mode et du modèle demandés
     449                if ($mode == 'previsions') {
     450                        // Identification de la périodicité à partir du nom du modèle. Cela évite une configuration compliquée.
     451                        if (preg_match(',_(1|12|24)h,is', $modele, $match)) {
     452                                $type_modele = intval($match[1]);
     453
     454                                // On verifie que la périodicité demandée explicitement dans l'appel du modèle est ok
     455                                if (isset($options['periodicite'])) {
     456                                        $periodicite_explicite = intval($options['periodicite']);
     457                                        if (periodicite_est_compatible($type_modele, $periodicite_explicite)) {
     458                                                $periodicite = $periodicite_explicite;
     459                                        } else {
     460                                                $type_erreur = 'modele_periodicite';
     461                                        }
    442462                                } else {
    443                                         $erreur = 'modele_periodicite';
     463                                        // Dans ce cas, il faut choisir une périodicité en fonction du type du modèle et du service.
     464                                        $periodicite = periodicite_determiner($type_modele, $service);
     465                                        if (!$periodicite) {
     466                                                $type_erreur = 'modele_service';
     467                                        }
    444468                                }
    445469                        } else {
    446                                 // Dans ce cas, il faut choisir une périodicité en fonction du type du modèle et du service.
    447                                 $periodicite = periodicite_determiner($type_modele, $service);
    448                                 if (!$periodicite) {
    449                                         $erreur = 'modele_service';
     470                                // On ne connait pas le type du modèle, donc sa compatibilité.
     471                                // Si la périodicité est passée en argument on l'utilise sans se poser de question.
     472                                // Sinon c'est une erreur car on ne sait pas quelle périodicité est requise
     473                                if (isset($options['periodicite'])) {
     474                                        $periodicite = intval($options['periodicite']);
     475                                } else {
     476                                        $type_erreur = 'modele_inutilisable';
    450477                                }
    451478                        }
    452                 } else {
    453                         // On ne connait pas le type du modèle, donc sa compatibilité.
    454                         // Si la périodicité est passée en argument on l'utilise sans se poser de question.
    455                         // Sinon c'est une erreur car on ne sait pas quelle périodicité est requise
    456                         if (isset($options['periodicite'])) {
    457                                 $periodicite = intval($options['periodicite']);
    458                         } else {
    459                                 $erreur = 'modele_inutilisable';
    460                         }
    461                 }
    462         }
    463 
    464         if ($erreur) {
    465                 // Acquérir la configuration statique du service (periode, format, données...)
    466                 include_spip("services/${service}");
    467                 $configurer = "${service}_service2configuration";
    468                 $configuration = $configurer($mode);
    469 
    470                 // On prépare un contexte extras pour traiter les erreurs du modèle de façon standard comme celles
    471                 // renvoyée par le chargement des données.
    472                 $extras['credits'] = $configuration['credits'];
    473                 $extras['config'] = array_merge(
    474                         parametrage_normaliser($service, $configuration['defauts']),
    475                         array('source' => configuration_donnees_normaliser($mode, $configuration['donnees'])),
    476                         array('nom_service' => $configuration['nom'])
    477                 );
    478                 $extras['lieu'] = $lieu;
    479                 $extras['mode'] = $mode;
    480                 $extras['periodicite_cache'] = $periodicite;
    481                 $extras['service'] = $service;
    482                 $extras['erreur'] = array(
    483                         'type' => $erreur,
     479                }
     480        }
     481
     482        if ($type_erreur) {
     483                // On construit le tableau directement sans appeler la fonction de calcul des données météo.
     484                $erreur = array(
     485                        'type' => $type_erreur,
    484486                        'service' => array(
    485487                                'code' => '',
     
    487489                        )
    488490                );
     491
     492                $tableau = array(
     493                        'donnees' => array(),
     494                        'extras' => erreur_normaliser_extras($erreur, $lieu, $mode, $periodicite, $service)
     495                );
    489496        } else {
    490497                // Récupération du tableau des données météo
     
    493500
    494501                // Séparation des données communes liées au service et au mode et des données météorologiques
    495                 $extras = $tableau['extras'];
    496                 $erreur = $extras['erreur']['type'];
    497 
    498                 if (!$erreur and ($mode == 'previsions')) {
     502                $type_erreur = $tableau['extras']['erreur']['type'];
     503
     504                if (!$type_erreur and ($mode == 'previsions')) {
    499505                        // Adaptation des données en fonction de la demande et de la périodicité modèle-cache
    500506                        $nb_index = count($tableau['donnees']);
     
    519525        }
    520526
    521         // Affichage du message d'erreur ou des données
    522         if ($erreur) {
    523                 $extras['erreur']['texte'] = erreur_formater_texte($extras['erreur'], $lieu, $mode, $modele, $service, $tableau['extras']['config']['nom_service']);
    524                 $texte = recuperer_fond('modeles/erreur_rainette', $extras);
     527        if ($type_erreur) {
     528                // Affichage du message d'erreur ou des données: seul l'index extras est utile
     529                $tableau['extras']['erreur']['texte'] = erreur_formater_texte(
     530                        $tableau['extras']['erreur'],
     531                        $lieu,
     532                        $mode,
     533                        $modele,
     534                        $service,
     535                        $tableau['extras']['config']['nom_service']
     536                );
     537                $texte = recuperer_fond('modeles/erreur_rainette', $tableau['extras']);
    525538        } else {
    526539                // Appel du modèle avec le contexte complet
Note: See TracChangeset for help on using the changeset viewer.