Changeset 107974 in spip-zone


Ignore:
Timestamp:
Dec 10, 2017, 8:39:22 PM (20 months ago)
Author:
eric@…
Message:

Ajout d'une fonction d'autorisation de requête basée sur les seuils d'utilisation de chaque service. Ces seuils sont pour l'instant configurés sur la base des plans gratuits proposés par les services.
Dans une future version il sera possible de les modifier.

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

Legend:

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

    r107753 r107974  
    1111#SET{service, #ENV{service, weather}}
    1212#SET{mode, #ENV{mode, conditions}}
    13 #SET{jeu, #ARRAY{
    14                         'weather', 'FRXX0076',
    15                         'owm', 'Paris,Fr',
    16                         'wwo', 'Paris,France',
    17                         'apixu', 'Paris,France',
    18                         'wunderground', 'FRXX0076'}}
     13#SET{jeu, #VAL|rainette_dbg_jeu_defaut}
    1914#SET{lieu, #ENV{ville, #GET{jeu/#GET{service}}}}
    2015
     
    10398                        <div class="clearfix">
    10499                                <br />
    105                                 #SET{donnees, #GET{mode}|rainette_dbg_comparer_services{#GET{jeu}, 0}}
     100                                #SET{donnees, #GET{mode}|rainette_dbg_comparer_services{#GET{jeu}}}
    106101                                #INCLURE{fond=demo/inc-comparer_services,
    107102                                        jeu=#GET{jeu},
    108103                                        donnees=#GET{donnees},
    109104                                        mode=#GET{mode}}
     105                        </div>
     106
     107
     108                        <h2 class="h2">3 - ETAT D'EXECUTION DES SERVICES</h2>
     109                        <a name="execution" href="#"></a>
     110                        <div class="clearfix">
     111                                #SET{execution, #VAL|rainette_dbg_afficher_execution}
     112                                #INCLURE{fond=demo/inc-afficher_execution, execution=#GET{execution}}
     113                                [<div class="clearfix"><br />(#VAL|rainette_dbg_afficher_config)</div>]
     114                        </div>
     115
     116
     117                        <h2 class="h2">4. - LANGUES SPIP NON INTEGREES</h2>
     118                        <a name="langues" href="#"></a>
     119                        <div class="clearfix">
     120                                [(#VAL|rainette_dbg_verifier_langue_manquante|sinon{'Aucune langue SPIP manque'})]
    110121                        </div>
    111122                </div>
  • _plugins_/rainette/trunk/inc/charger_meteo.php

    r107858 r107974  
    119119                $url = $urler($lieu, $mode, $periodicite, $configuration);
    120120
    121                 // Acquérir le flux XML ou JSON dans un tableau et traiter les cas d'erreurs du plugin ou du service.
     121                // Acquérir le flux XML ou JSON dans un tableau si les limites du service ne sont pas atteintes
     122                // et traiter les cas d'erreurs du plugin ou du service.
    122123                include_spip('inc/rainette_requeter');
    123                 $flux = requeter($url, $configuration['format_flux'], $service);
    124124                $tableau = array();
    125125                $erreur = array(
     
    130130                        )
    131131                );
    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'];
     132                if (!requete_autorisee($configuration['limites'], $service)) {
     133                        // La requête n'est pas autorisée parce qu'elle excède les limitations d'utilisation du service.
     134                        // On renvoie une erreur pour prévenir les utilisateurs.
     135                        $erreur['type'] = 'limite_service';
    136136                } 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);
    144                         }
    145 
    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);
     137                        $flux = requeter($url, $configuration, $service);
     138                        if (!empty($flux['erreur'])) {
     139                                // Erreur lors du traitement de la requête due à l'URL ou à la conversion en XML ou JSON.
     140                                // Cette erreur n'est pas retournée par le service.
     141                                $erreur['type'] = $flux['erreur'];
    153142                        } 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);
     143                                // On teste une erreur d'acquisition renvoyée par le service. Pour tous les services, une cle de base
     144                                // est explicitement utilisée pour distinguer les erreurs; sa présence permet d'identifier un cas d'erreur.
     145                                include_spip('inc/filtres');
     146                                $configuration_erreur = $configurer('erreurs');
     147                                $flux_erreur = $flux;
     148                                if (!empty($configuration_erreur['cle_base'])) {
     149                                        $flux_erreur = table_valeur($flux, implode('/', $configuration_erreur['cle_base']), null);
    157150                                }
    158151
    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';
     152                                // On normalise le flux en utilisant le mode d'erreur pour vérifier si on obtient bien une erreur.
     153                                $erreur_service = service2donnees($configuration_erreur,'erreurs', $flux_erreur, -1);
     154                                $verifier = "${service}_erreur_verifier";
     155                                if ($verifier($erreur_service)) {
     156                                        // Une erreur est renvoyée par le service, on formate l'erreur correctement.
     157                                        $erreur['type'] = 'reponse_service';
     158                                        $erreur['service'] = array_merge($erreur['service'], $erreur_service);
    163159                                } 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);
     160                                        // On se positionne sur le niveau de base du flux des données où commence le tableau des données météorologiques.
     161                                        if (!empty($configuration['cle_base'])) {
     162                                                $flux = table_valeur($flux, implode('/', $configuration['cle_base']), null);
    171163                                        }
    172164
    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;
     165                                        if (empty($flux)) {
     166                                                // Pas d'erreur retournée par le service mais aucune donnée fournie. Ce cas est peut-être impossible
     167                                                // mais on le traite tout de même par sécurité avec un type particulier.
     168                                                $erreur['type'] = 'aucune_donnee';
     169                                        } else {
     170                                                // En mode prévisions, le niveau de base est un tableau de n éléments, chaque élément étant un tableau contenant
     171                                                // les données météorologiques d'un jour à venir ([0] => jour0[], [1] => jour1[]...).
     172                                                // En mode infos ou conditions, on a directement accès aux données météorologiques (jour[]).
     173                                                // Pour réaliser un traitement standard, on transforme donc le jour[] en un tableau d'un seul élément ([0] => jour[])
     174                                                // qui pourra être traité comme celui des prévisions.
     175                                                if (($mode == 'conditions') or ($mode == 'infos')) {
     176                                                        $flux = array($flux);
     177                                                }
     178
     179                                                // Convertir le flux en tableau standard pour la mise en cache. Ce traitement se déroule en
     180                                                // 3 étapes :
     181                                                // -1- initialisation du tableau standard à partir uniquement des données reçues du service
     182                                                // -2- complément du tableau avec les données propres à chaque service
     183                                                // -3- complément du tableau avec les données communes à tous les services
     184                                                foreach ($flux as $_index_jour => $_flux_jour) {
     185                                                        // Pour les informations et les conditions les données récupérées concernent toute la même "période".
     186                                                        // Par contre, pour les prévisions on distingue 2 type de données :
     187                                                        // - celles du jour indépendamment de la période horaire
     188                                                        // - celles correspondant à une période horaire choisie (24, 12, 6, 3, 1)
     189                                                        //   Ces donnnées sont stockées à un index horaire de 0 à n qui représente la période horaire.
     190                                                        // Pour avoir un traitement identique pour les deux types de données on considère que l'index horaire
     191                                                        // des données jour est égal à -1.
     192                                                        // On crée donc le tableau des index correspondant au mode choisi et on boucle dessus.
     193                                                        $periodes_horaires = array(-1);
     194                                                        if ($periodicite) {
     195                                                                for ($i = 0; $i <  (24 / $periodicite); $i++) {
     196                                                                        $periodes_horaires[] = $i;
     197                                                                }
    191198                                                        }
    192                                                 }
    193 
    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);
    199                                                 }
    200 
    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;
     199
     200                                                        // On détermine le flux heure en fonction du service. Ce flux heure coincide avec le flux jour dans
     201                                                        // la majeure partie des cas
     202                                                        $flux_heure = $_flux_jour;
     203                                                        if ((count($periodes_horaires) > 1)     and !empty($configuration['cle_heure'])) {
     204                                                                $flux_heure = table_valeur($_flux_jour, implode('/', $configuration['cle_heure']), null);
     205                                                        }
     206
     207                                                        // On boucle sur chaque periode horaire pour remplir le tableau complet.
     208                                                        foreach ($periodes_horaires as $_periode) {
     209                                                                // 1- Initialiser le tableau normalisé des informations à partir des données brutes
     210                                                                //    fournies par le service.
     211                                                                //    Suivant la période il faut prendre le flux jour ou le flux heure. On calcule donc le flux heure
     212                                                                //    quand c'est nécessaire.
     213                                                                $flux_a_normaliser = $_periode == -1
     214                                                                        ? $_flux_jour
     215                                                                        : ($configuration['structure_heure'] ? $flux_heure[$_periode] : $flux_heure);
     216                                                                $donnees = service2donnees(
     217                                                                        $configuration,
     218                                                                        $mode,
     219                                                                        $flux_a_normaliser,
     220                                                                        $_periode);
     221
     222                                                                if ($donnees) {
     223                                                                        // 2- Compléments spécifiques au service et au mode.
     224                                                                        //    Si ces compléments sont inutiles, la fonction n'existe pas
     225                                                                        $completer = "${service}_complement2${mode}";
     226                                                                        if (function_exists($completer)) {
     227                                                                                $donnees = $mode == 'previsions'
     228                                                                                        ? $completer($donnees, $configuration, $_periode)
     229                                                                                        : $completer($donnees, $configuration);
     230                                                                        }
     231
     232                                                                        // 3- Compléments standard communs à tous les services mais fonction du mode
     233                                                                        if ($mode == 'conditions') {
     234                                                                                // Vérifier que l'indice uv si celui-ci est fourni
     235                                                                                // Calcul du risque uv à partir de l'indice uv si celui-ci est fourni
     236                                                                                include_spip('inc/rainette_convertir');
     237                                                                                $donnees['risque_uv'] = is_int($donnees['indice_uv'])
     238                                                                                        ? indice2risque_uv($donnees['indice_uv'])
     239                                                                                        : $donnees['indice_uv'];
     240                                                                        }
     241
     242                                                                        // Ajout du bloc à l'index en cours
     243                                                                        if ($_periode == -1) {
     244                                                                                $tableau[$_index_jour] = $donnees;
     245                                                                        } else {
     246                                                                                $tableau[$_index_jour]['heure'][$_periode] = $donnees;
     247                                                                        }
    241248                                                                }
    242249                                                        }
  • _plugins_/rainette/trunk/inc/rainette_debusquer.php

    r100689 r107974  
    66
    77if (!defined('_RAINETTE_DEBUG')) {
     8        /**
     9         * Activation ou désactivation des traces de debug.
     10         */
    811        define('_RAINETTE_DEBUG', false);
    912}
    1013if (!defined('_RAINETTE_DEBUG_CLES_PREVISIONS')) {
     14        /**
     15         * Clé jour par défaut utiliser pour afficher les prévisions : jour suivant.
     16         */
    1117        define('_RAINETTE_DEBUG_CLES_PREVISIONS', '1');
    1218}
     
    1622 * @param string $lieu
    1723 * @param string $mode
    18  * @param int    $periodicite
    1924 * @param string $service
    2025 *
     
    6469
    6570/**
     71 * @param string $lieu
     72 * @param string $mode
     73 * @param string $service
     74 *
     75 * @return string
     76 */
     77function rainette_dbg_afficher_config() {
     78        $debug = '';
     79
     80        // Recuperation du tableau des conditions courantes
     81        if (_RAINETTE_DEBUG and function_exists('bel_env')) {
     82                include_spip('inc/config');
     83                $execution = lire_config('rainette_execution', array());
     84                $debug = bel_env(serialize($execution), true);
     85        }
     86
     87        return $debug;
     88}
     89
     90
     91/**
    6692 * @param string $mode
    6793 * @param array  $jeu
     
    82108        if ($config_donnees) {
    83109                if (!$jeu) {
    84                         $jeu = array(
    85                                 'weather'      => 'FRXX0076',
    86                                 'owm'          => 'Paris,Fr',
    87                                 'wwo'          => 'Paris,France',
    88                                 'wunderground' => 'Paris,France'
    89                         );
     110                        $jeu = rainette_dbg_jeu_defaut();
    90111                }
    91112
     
    108129                        $tableau = unserialize($contenu_cache);
    109130
    110                         if (!$tableau['extras']['erreur']) {
     131                        if (!$tableau['extras']['erreur']['type']) {
    111132                                // Suivant le mode on extrait les données à afficher. Pour le mode prévisions, on choisit le
    112133                                // jour suivant le jour courant et pour les données heures l'index 0 qui existe toujours.
     
    183204}
    184205
    185 
    186 function trouver_langue_manquante() {
     206/**
     207 * @return array
     208 */
     209function rainette_dbg_jeu_defaut() {
     210
     211        $jeu = array();
     212
     213        include_spip('rainette_fonctions');
     214        $services = rainette_lister_services();
     215        if ($services) {
     216                foreach ($services as $_service) {
     217                        if (($_service == 'weather') or ($_service == 'wunderground')) {
     218                                $jeu[$_service] = 'FRXX0076';
     219                        } else {
     220                                $jeu[$_service] = 'Paris,France';
     221                        }
     222                }
     223        }
     224
     225        return $jeu;
     226}
     227
     228/**
     229 * @return array
     230 */
     231function rainette_dbg_afficher_execution() {
     232
     233        $debug = array();
     234
     235        $services = rainette_lister_services();
     236        if ($services) {
     237                include_spip('inc/config');
     238                $execution = lire_config('rainette_execution', array());
     239
     240                foreach ($services as $_service) {
     241                        include_spip("services/${_service}");
     242                        $configurer = "${_service}_service2configuration";
     243                        $configuration = $configurer('infos');
     244
     245                        $debug[$_service]['dernier_appel'] = isset($execution[$_service]['dernier_appel'])
     246                                ? $execution[$_service]['dernier_appel']
     247                                : '--';
     248                        foreach (array('year', 'month', 'day', 'hour', 'minute') as $_periode) {
     249                                if (isset($configuration['limites'][$_periode])) {
     250                                        $compteur = isset($execution[$_service]['compteurs'][$_periode])
     251                                                ? $execution[$_service]['compteurs'][$_periode]
     252                                                : '--';
     253                                        $debug[$_service][$_periode] = "${compteur} / {$configuration['limites'][$_periode]}";
     254                                } else {
     255                                        $debug[$_service][$_periode] = '';
     256                                }
     257                        }
     258                }
     259        }
     260
     261        return $debug;
     262}
     263
     264/**
     265 * Fonction permettant de vérifier si la liste des langues de SPIP a changé et qu'il faut modifier la config rainette.
     266 *
     267 */
     268function rainette_dbg_verifier_langue_manquante() {
    187269        include_spip('inc/lang_liste');
    188270        include_spip('inc/rainette_normaliser');
  • _plugins_/rainette/trunk/inc/rainette_normaliser.php

    r107848 r107974  
    710710                // Cas d'erreur où le service renvoie aucune donnée sans pour autant monter une erreur.
    711711                case 'aucune_donnee':
     712                // Cas d'erreur où le nombre de requêtes maximal a été atteint.
    712713                        $texte['principal'] .= _T("rainette:erreur_${type_erreur}", array('service' => $titre_service));
    713714                        $texte['conseil'] .= _T('rainette:erreur_conseil_equipe');
     
    724725                        $texte['conseil'] .= _T('rainette:erreur_conseil_service');
    725726                        break;
     727                // Cas d'erreur où le nombre de requêtes maximal a été atteint.
     728                case 'limite_service':
     729                        $texte['principal'] .= _T("rainette:erreur_${type_erreur}", array('service' => $titre_service));
     730                        $texte['conseil'] .= _T('rainette:erreur_conseil_limite');
     731                        break;
    726732                // Cas d'erreur du à une mauvause utilisation des modèles
    727733                case 'modele_periodicite':
  • _plugins_/rainette/trunk/inc/rainette_requeter.php

    r107848 r107974  
    99 *
    1010 * @param string $url
    11  * @param string $format_reponse
     11 * @param array  $configuration
    1212 * @param string $service
    1313 *
    1414 * @return array
    1515 */
    16 function requeter($url, $format_reponse, $service) {
     16function requeter($url, $configuration, $service) {
    1717
    1818        // Acquisition des données spécifiées par l'url
     
    2020        $flux = recuperer_url($url, array('transcoder' => true));
    2121
    22         // On loge l'appel et on incrémente les compteurs de requêtes du service.
     22        // On loge la date de l'appel et on incrémente les compteurs de requêtes du service.
     23        include_spip('inc/config');
     24        $execution = lire_config('rainette_execution', array());
     25        $execution[$service]['dernier_appel'] = date('Y-m-d H:i:s');
     26        if (!isset($execution[$service]['compteurs'])) {
     27                // On initialise les compteurs de requêtes.
     28                $execution[$service]['compteurs'] = array();
     29        }
     30        // On met à jour tous les compteurs
     31        if ($configuration['limites']) {
     32                foreach ($configuration['limites'] as $_periode => $_seuil) {
     33                        $execution[$service]['compteurs'][$_periode] = isset($execution[$service]['compteurs'][$_periode])
     34                                ? $execution[$service]['compteurs'][$_periode] + 1
     35                                : 1;
     36                }
     37        }
     38        ecrire_config('rainette_execution', $execution);
    2339
    2440        // Initialisation de la réponse et du bloc d'erreur normalisé.
     
    2945        } else {
    3046                // Tranformation de la chaine xml reçue en tableau associatif
    31                 if ($format_reponse == 'xml') {
     47                if ($configuration['format_flux'] == 'xml') {
    3248                        $convertir = charger_fonction('simplexml_to_array', 'inc');
    3349
     
    6581
    6682
    67 function requete_autorisee($service) {
     83/**
     84 * @param array  $limites
     85 * @param string $service
     86 *
     87 * @return bool
     88 */
     89function requete_autorisee($limites, $service) {
    6890
    6991        $autorisee = true;
    7092
     93        // On loge la date de l'appel et on incrémente le compteur de requêtes du service.
     94        include_spip('inc/config');
     95        $execution = lire_config('rainette_execution', array());
     96        if (isset($execution[$service])) {
     97                // Si aucune information d'exécution n'a été logée on considère que c'est la mise en route du service
     98                // et donc que la requête est forcément autorisée.
     99                $dernier_appel = date_parse($execution[$service]['dernier_appel']);
     100                $date_courante = date_parse(date('Y-m-d H:i:s'));
     101
     102                if ($limites) {
     103                        $periode_a_change = false;
     104                        foreach ($limites as $_periode => $_max) {
     105                                // La date courante est un tableau indexé par la période de l'année (year) à la minute (minute) et plus.
     106                                // La stratégie est de vérifier - de l'année à la période configurée pour le service - si un élément a changé
     107                                // ou pas : si un élément a changé alors on est forcément ok, sinon on vérifie le nombre d'appels comparé
     108                                // à la valeur max configurée.
     109                                if ($periode_a_change) {
     110                                        // Toutes les autres périodes inférieures ont donc changé aussi, on remet donc leur compteur
     111                                        // à zéro.
     112                                        $execution[$service]['compteurs'][$_periode] = 0;
     113                                        ecrire_config('rainette_execution', $execution);
     114                                } else {
     115                                        foreach ($date_courante as $_cle => $_valeur) {
     116                                                if ($_valeur != $dernier_appel[$_cle]) {
     117                                                        // Période de temps supérieure ou égale à celle configurée pour le service a changé.
     118                                                        // On est donc forcément dans la limite d'utilisation.
     119                                                        // Il faut remettre le compteur de la période à zéro.
     120                                                        $execution[$service]['compteurs'][$_periode] = 0;
     121                                                        ecrire_config('rainette_execution', $execution);
     122                                                        $periode_a_change = true;
     123                                                        break;
     124                                                } elseif ($_cle == $_periode) {
     125                                                        // On est arrivé à la période configurée pour le service et la valeur est la même :
     126                                                        // il faut donc vérifier si on a atteint ou pas la limite autorisée du nombre de requête pour cette
     127                                                        // période de temps.
     128                                                        if ($execution[$service]['compteurs'][$_periode] == $_max) {
     129                                                                $autorisee = false;
     130                                                        }
     131                                                        // On est arrivé à la période de la date courante au delà duquel il n'y a plus besoin de continuer.
     132                                                        break;
     133                                                }
     134                                        }
     135                                }
     136                        }
     137                }
     138        }
     139
    71140        return $autorisee;
    72141}
  • _plugins_/rainette/trunk/lang/rainette_fr.php

    r107848 r107974  
    4040        'erreur_conseil_periodicite' => 'Veuillez utiliser une autre périodicité ou un autre modèle.',
    4141        'erreur_conseil_service' => 'Veuillez consulter le message du service ci-dessous.',
     42        'erreur_conseil_limite' => 'Veuillez attendre que la période soit échue. Alternativement, vous pouvez mettre à jour votre enregistrement vers une option payante autorisant plus de requêtes par unité de temps voire changer de service.',
     43        '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.',
    4244        'erreur_modele_inutilisable' => 'Le nom du modèle @modele@ ne permet pas de déterminer une périodicité horaire par défaut.',
    4345        'erreur_modele_periodicite' => 'Le modèle @modele@ n\'est pas compatible avec la périodicité horaire demandée.',
  • _plugins_/rainette/trunk/services/apixu.php

    r107848 r107974  
    7373                'defaut'      => 'en'
    7474        ),
    75         'requetes' => array(
    76                 'mois'        => 5000
     75        'limites' => array(
     76                'month'       => 5000
    7777        )
    7878);
  • _plugins_/rainette/trunk/services/owm.php

    r107848 r107974  
    5757                'defaut'      => 'en'
    5858        ),
    59         'requetes' => array(
    60                 'minute'     => 60
     59        'limites' => array(
     60                'minute'      => 60
    6161        )
    6262);
  • _plugins_/rainette/trunk/services/weather.php

    r107848 r107974  
    3434                'defaut'      => 'en'
    3535        ),
    36         'requetes' => array()
     36        'limites' => array()
    3737);
    3838
  • _plugins_/rainette/trunk/services/wunderground.php

    r107848 r107974  
    118118                'defaut'      => 'EN'
    119119        ),
    120         'requetes' => array(
    121                 'jour'        => 500,
    122                 '1minute'     => 10
     120        'limites' => array(
     121                'day'         => 500,
     122                'minute'      => 10
    123123        )
    124124);
  • _plugins_/rainette/trunk/services/wwo.php

    r107848 r107974  
    7373                'defaut'      => 'en'
    7474        ),
    75         'requetes' => array(
    76                 'jour'        => 500
     75        'limites' => array(
     76                'day'         => 500
    7777        )
    7878);
Note: See TracChangeset for help on using the changeset viewer.