Changeset 108066 in spip-zone


Ignore:
Timestamp:
Dec 16, 2017, 3:45:50 PM (18 months ago)
Author:
eric@…
Message:

Renommage en masse des fonctions internes pour plus de cohérence.

Location:
_plugins_/rainette/trunk
Files:
9 edited
1 moved

Legend:

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

    r108065 r108066  
    1919 * périodicité est compatible avec le service; cette fonction ne retourne donc que des erreurs de chargement.
    2020 *
    21  * @uses service2cache()
    22  * @uses service2donnees()
     21 * @uses cache_nommer()
     22 * @uses meteo_normaliser()
    2323 * @uses indice2risque_uv()
    2424 *
     
    5050 *        Le nom du fichier cache correspondant à la demande.
    5151 */
    52 function inc_charger_meteo_dist($lieu, $mode = 'conditions', $periodicite = 0, $service = 'weather') {
     52function inc_meteo_charger_dist($lieu, $mode = 'conditions', $periodicite = 0, $service = 'weather') {
    5353
    5454        // Traitement des cas ou les arguments sont vides (ce qui est différent de non passés à l'appel)
     
    8888
    8989        // Construire le nom du fichier cache
    90         $cache = service2cache($lieu, $mode, $periodicite, $configuration);
     90        $cache = cache_nommer($lieu, $mode, $periodicite, $configuration);
    9191
    9292        // Déterminer le système d'unité utilisé dans le cache et celui requis par la configuration.
     
    151151
    152152                                // 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);
     153                                $erreur_service = meteo_normaliser($configuration_erreur,'erreurs', $flux_erreur, -1);
    154154                                $verifier = "${service}_erreur_verifier";
    155155                                if ($verifier($erreur_service)) {
     
    214214                                                                        ? $_flux_jour
    215215                                                                        : ($configuration['structure_heure'] ? $flux_heure[$_periode] : $flux_heure);
    216                                                                 $donnees = service2donnees(
     216                                                                $donnees = meteo_normaliser(
    217217                                                                        $configuration,
    218218                                                                        $mode,
  • _plugins_/rainette/trunk/inc/rainette_debusquer.php

    r107974 r108066  
    4141                }
    4242                // Chargement du cache
    43                 $charger = charger_fonction('charger_meteo', 'inc');
     43                $charger = charger_fonction('meteo_charger', 'inc');
    4444                $nom_cache = $charger($lieu, $mode, $periodicite, $service);
    4545                if ($nom_cache) {
     
    124124
    125125                        // Chargement des données
    126                         $charger = charger_fonction('charger_meteo', 'inc');
     126                        $charger = charger_fonction('meteo_charger', 'inc');
    127127                        $nom_cache = $charger($_lieu, $mode, $periodicite, $_service);
    128128                        lire_fichier($nom_cache, $contenu_cache);
  • _plugins_/rainette/trunk/inc/rainette_normaliser.php

    r107974 r108066  
    313313
    314314/**
    315  * @param $config_service
     315 * @param $configuration_service
    316316 * @param $mode
    317317 * @param $flux
     
    320320 * @return array
    321321 */
    322 function service2donnees($config_service, $mode, $flux, $periode) {
     322function meteo_normaliser($configuration_service, $mode, $flux, $periode) {
    323323        $tableau = array();
    324324
     
    339339                                        // La donnée est fournie par le service. Elle n'est jamais calculée par le plugin
    340340                                        // Néanmoins, elle peut-être indisponible temporairement
    341                                         if ($cle_service = $config_service['donnees'][$_donnee]['cle']) {
     341                                        if ($cle_service = $configuration_service['donnees'][$_donnee]['cle']) {
    342342                                                // La donnée est normalement fournie par le service car elle possède une configuration de clé
    343343                                                // On traite le cas où le nom de la clé varie suivant le système d'unité choisi ou la langue.
    344344                                                // La clé de base peut être vide, le suffixe contenant dès lors toute la clé.
    345                                                 if (!empty($config_service['donnees'][$_donnee]['suffixe_unite'])) {
    346                                                         $systeme_unite = $config_service['unite'];
    347                                                         $id_suffixee = $config_service['donnees'][$_donnee]['suffixe_unite']['id_cle'];
    348                                                         $cle_service[$id_suffixee] .= $config_service['donnees'][$_donnee]['suffixe_unite'][$systeme_unite];
    349                                                 } elseif (!empty($config_service['donnees'][$_donnee]['suffixe_langue'])) {
    350                                                         $langue = trouver_langue_service($config_service);
    351                                                         $id_suffixee = $config_service['donnees'][$_donnee]['suffixe_langue']['id_cle'];
     345                                                if (!empty($configuration_service['donnees'][$_donnee]['suffixe_unite'])) {
     346                                                        $systeme_unite = $configuration_service['unite'];
     347                                                        $id_suffixee = $configuration_service['donnees'][$_donnee]['suffixe_unite']['id_cle'];
     348                                                        $cle_service[$id_suffixee] .= $configuration_service['donnees'][$_donnee]['suffixe_unite'][$systeme_unite];
     349                                                } elseif (!empty($configuration_service['donnees'][$_donnee]['suffixe_langue'])) {
     350                                                        $langue = langue_determiner($configuration_service);
     351                                                        $id_suffixee = $configuration_service['donnees'][$_donnee]['suffixe_langue']['id_cle'];
    352352                                                        $cle_service[$id_suffixee] .= $langue;
    353353                                                }
     
    361361                                                        : table_valeur($flux, implode('/', $cle_service), '');
    362362                                                if ($valeur_service !== '') {
    363                                                         $typer = donnee2typage($mode, $_donnee);
     363                                                        $typer = donnee_typer($mode, $_donnee);
    364364                                                        $valeur_typee = $typer($valeur_service);
    365365
    366366                                                        // Vérification de la donnée en cours de traitement si une fonction idoine existe
    367                                                         $verifier = "verifier_${_donnee}";
     367                                                        $verifier = "donnee_verifier_${_donnee}";
    368368                                                        if (!function_exists($verifier) or (function_exists($verifier) and $verifier($valeur_typee))) {
    369369                                                                $donnee = $valeur_typee;
     
    372372                                        } else {
    373373                                                // La donnée météo n'est jamais fournie par le service. On la positionne à null pour
    374                                                 // la distinguer avec une donnée vide qui indinque une indisponibilité temporaire.
     374                                                // la distinguer avec une donnée vide qui indique une indisponibilité temporaire.
    375375                                                $donnee = null;
    376376                                        }
     
    396396 * @return string
    397397 */
    398 function donnee2typage($mode, $donnee) {
     398function donnee_typer($mode, $donnee) {
    399399        $fonction = '';
    400400
     
    414414                                break;
    415415                        case 'date':
    416                                 $fonction = 'donnee2date';
     416                                $fonction = 'donnee_formater_date';
    417417                                break;
    418418                        case 'heure':
    419                                 $fonction = 'donnee2heure';
     419                                $fonction = 'donnee_formater_heure';
    420420                                break;
    421421                        default:
     
    433433 * @return string
    434434 */
    435 function donnee2date($donnee) {
     435function donnee_formater_date($donnee) {
    436436        if (is_numeric($donnee)) {
    437437                $date = date('Y-m-d H:i:s', $donnee);
     
    455455 * @return string
    456456 */
    457 function donnee2heure($donnee) {
     457function donnee_formater_heure($donnee) {
    458458        if (is_numeric($donnee)) {
    459459                $taille = strlen($donnee);
     
    475475}
    476476
    477 function verifier_indice_uv($valeur) {
     477/**
     478 * @param $valeur
     479 *
     480 * @return bool
     481 */
     482function donnee_verifier_indice_uv($valeur) {
    478483
    479484        $est_valide = true;
     
    486491
    487492/**
    488  * @param $type_modele
    489  * @param $service
    490  *
    491  * @return int
    492  */
    493 function trouver_periodicite($type_modele, $service) {
    494 
    495         // Périodicité initialisée à "non trouvée"
    496         $periodicite = 0;
    497 
    498         if (isset($GLOBALS['rainette_config']['periodicite'][$type_modele])) {
    499                 // Acquérir la configuration statique du service pour connaitre les périodicités horaires supportées
    500                 // pour le mode prévisions
    501                 include_spip("services/${service}");
    502                 $configurer = "${service}_service2configuration";
    503                 $configuration = $configurer('previsions');
    504                 $periodicites_service = array_keys($configuration['periodicites']);
    505 
    506                 $periodicites_modele = $GLOBALS['rainette_config']['periodicite'][$type_modele];
    507                 foreach ($periodicites_modele as $_periodicite_modele) {
    508                         if (in_array($_periodicite_modele, $periodicites_service)) {
    509                                 $periodicite = $_periodicite_modele;
    510                                 break;
    511                         }
    512                 }
    513         }
    514 
    515         return $periodicite;
    516 }
    517 
    518 
    519 /**
    520  * @param $type_modele
    521  * @param $periodicite
    522  *
    523  * @return bool
    524  */
    525 function periodicite_compatible($type_modele, $periodicite) {
    526 
    527         // Périodicité initialisée à "non trouvée"
    528         $compatible = false;
    529 
    530         if (isset($GLOBALS['rainette_config']['periodicite'][$type_modele])
    531                 and in_array($periodicite, $GLOBALS['rainette_config']['periodicite'][$type_modele])
    532         ) {
    533                 $compatible = true;
    534         }
    535 
    536         return $compatible;
    537 }
    538 
    539 
    540 /**
    541  * Construit le nom du cache en fonction du servide, du lieu, du type de données et de la langue utilisée par le site.
    542  *
    543  * @param string $lieu
    544  *        Lieu pour lequel on requiert le nom du cache.
    545  * @param string $mode
    546  *        Type de données météorologiques. Les valeurs possibles sont `infos`, `conditions` ou `previsions`.
    547  * @param int    $periodicite
    548  *        La périodicité horaire des prévisions :
    549  *        - `24`, `12`, `6`, `3` ou `1`, pour le mode `previsions`
    550  *        - `0`, pour les modes `conditions` et `infos`
    551  * @param array  $config_service
    552  *        Configuration complète du service, statique et utilisateur.
    553  *
    554  * @return string
    555  *        Chemin complet du fichier cache.
    556  */
    557 function service2cache($lieu, $mode, $periodicite, $config_service) {
    558 
    559         // Identification de la langue du resume.
    560         $code_langue = trouver_langue_service($config_service);
    561 
    562         // Construction du chemin du fichier cache
    563         $fichier_cache = normaliser_cache($config_service['alias'], $lieu, $mode, $periodicite, $code_langue);
    564 
    565         return $fichier_cache;
    566 }
    567 
    568 
    569 /**
    570  * @param $config_service
    571  *
    572  * @return mixed
    573  */
    574 function trouver_langue_service($config_service) {
    575 
    576         if ($config_service['condition'] == $config_service['alias']) {
    577                 // Langue SPIP : soit celle de la page soit celle en cours pour l'affichage
    578                 // TODO : cela a-t-il du sens ?
    579                 $langue_spip = $GLOBALS['lang'] ? $GLOBALS['lang'] : $GLOBALS['spip_lang'];
    580 
    581                 // On cherche si le service fournit la langue utilisée par le site.
    582                 // -- Pour cela on utilise la configuration du service qui fournit un tableau des langues disponibles
    583                 //    sous le format [code de langue du service] = code de langue spip.
    584                 $langue_service = array_search($langue_spip, $config_service['langues']['disponibles']);
    585                 if ($langue_service === false) {
    586                         // La langue utilisée par SPIP n'est pas supportée par le service.
    587                         // -- On cherche si il existe une langue SPIP utilisable meilleure que la langue par défaut du service.
    588                         // -- Pour ce faire on a défini pour chaque code de langue spip, un ou deux codes de langue SPIP à utiliser
    589                         //    en cas d'absence de la langue concernée dans un ordre de priorité (index 0, puis index 1).
    590                         $langue_service = $config_service['langues']['defaut'];
    591                         if ($GLOBALS['rainette_config']['langues_alternatives'][$langue_spip]) {
    592                                 foreach ($GLOBALS['rainette_config']['langues_alternatives'][$langue_spip] as $_langue_alternative) {
    593                                         $langue_service = array_search($_langue_alternative, $config_service['langues']['disponibles']);
    594                                         if ($langue_service !== false) {
    595                                                 break;
    596                                         }
    597                                 }
    598                         }
    599                 }
    600         } else {
    601                 $langue_service = $config_service['langues']['defaut'];
    602         }
    603 
    604         return $langue_service;
    605 }
    606 
    607 
    608 /**
    609  * @param $service
     493 * @param $erreur
    610494 * @param $lieu
    611495 * @param $mode
    612  * @param $periodicite
    613  * @param $code_langue
    614  *
    615  * @return string
    616  */
    617 function normaliser_cache($service, $lieu, $mode, $periodicite, $code_langue) {
    618 
    619         // Création et/ou détermination du dossier de destination du cache en fonction du service
    620         $dossier_cache = sous_repertoire(_DIR_VAR, 'cache-rainette');
    621         $dossier_cache = sous_repertoire($dossier_cache, $service);
    622 
    623         // Le nom du fichier cache est composé comme suit, chaque élement étant séparé par un underscore :
    624         // -- le nom du lieu normalisé (sans espace et dont tous les caractères non alphanumériques sont remplacés par un tiret
    625         // -- le nom du mode (infos, conditions ou previsions) accolé à la périodicité du cache pour les prévisions uniquement
    626         // -- la langue du résumé si il existe ou rien si aucune traduction n'est fournie par le service
    627         list($lieu_normalise,) = normaliser_lieu($lieu);
    628         $fichier_cache = $dossier_cache
    629                                          . str_replace(array(' ', ',', '+', '.', '/'), '-', $lieu_normalise)
    630                                          . '_' . $mode
    631                                          . ($periodicite ? strval($periodicite) : '')
    632                                          . ($code_langue ? '_' . strtolower($code_langue) : '')
    633                                          . '.txt';
    634 
    635         return $fichier_cache;
    636 }
    637 
    638 
    639 /**
    640  * @param $lieu
     496 * @param $modele
     497 * @param $service
    641498 *
    642499 * @return array
    643500 */
    644 function normaliser_lieu($lieu) {
    645 
    646         $lieu_normalise = trim($lieu);
    647 
    648         if (preg_match(_RAINETTE_REGEXP_LIEU_WEATHER_ID, $lieu_normalise, $match)) {
    649                 $format_lieu = 'weather_id';
    650                 $lieu_normalise = $match[0];
    651         } elseif (preg_match(_RAINETTE_REGEXP_LIEU_COORDONNEES, $lieu_normalise, $match)) {
    652                 $format_lieu = 'latitude_longitude';
    653                 $lieu_normalise = "{$match[1]},{$match[2]}";
    654         } elseif (preg_match(_RAINETTE_REGEXP_LIEU_IP, $lieu_normalise, $match)) {
    655                 $format_lieu = 'adresse_ip';
    656                 $lieu_normalise = $match[0];
    657         } else {
    658                 $format_lieu = 'ville_pays';
    659                 // On détermine la ville et éventuellement le pays (ville[,pays])
    660                 // et on élimine les espaces par un seul +
    661                 $elements = explode(',', $lieu_normalise);
    662                 $lieu_normalise = trim($elements[0]) . (!empty($elements[1]) ? ',' . trim($elements[1]) : '');
    663                 $lieu_normalise = preg_replace('#\s{1,}#', '+', $lieu_normalise);
    664         }
    665 
    666         return array($lieu_normalise, $format_lieu);
    667 }
    668 
    669 
    670 function normaliser_configuration_donnees($mode, $configuration_donnees) {
    671 
    672         $configuration_normalisee = array();
    673 
    674         foreach ($GLOBALS['rainette_config'][$mode] as $_donnee => $_configuration) {
    675                 if ($_configuration['origine'] == 'service') {
    676                         $configuration_normalisee[$_donnee] = !empty($configuration_donnees[$_donnee]['cle']) ? true : false;
    677                 }
    678         }
    679 
    680         return $configuration_normalisee;
    681 }
    682 
    683 function normaliser_configuration_utilisateur($service, $configuration_defaut) {
    684 
    685         // On récupère la configuration utilisateur
    686         include_spip('inc/config');
    687         $configuration_utilisateur = lire_config("rainette/${service}", array());
    688 
    689         // On complète la configuration avec des valeurs par défaut si nécessaire.
    690         foreach ($configuration_defaut as $_cle => $_valeur) {
    691                 if (!isset($configuration_utilisateur[$_cle])) {
    692                         $configuration_utilisateur[$_cle] = $_valeur;
    693                 }
    694         }
    695 
    696         return $configuration_utilisateur;
    697 }
    698 
    699 function normaliser_texte_erreur($erreur, $lieu, $mode, $modele, $service) {
     501function erreur_formater_texte($erreur, $lieu, $mode, $modele, $service) {
    700502
    701503        $texte = array('principal' => '', 'conseil' => '', 'service' => '');
     
    748550        return $texte;
    749551}
     552
     553/**
     554 * @param $type_modele
     555 * @param $service
     556 *
     557 * @return int
     558 */
     559function periodicite_determiner($type_modele, $service) {
     560
     561        // Périodicité initialisée à "non trouvée"
     562        $periodicite = 0;
     563
     564        if (isset($GLOBALS['rainette_config']['periodicite'][$type_modele])) {
     565                // Acquérir la configuration statique du service pour connaitre les périodicités horaires supportées
     566                // pour le mode prévisions
     567                include_spip("services/${service}");
     568                $configurer = "${service}_service2configuration";
     569                $configuration = $configurer('previsions');
     570                $periodicites_service = array_keys($configuration['periodicites']);
     571
     572                $periodicites_modele = $GLOBALS['rainette_config']['periodicite'][$type_modele];
     573                foreach ($periodicites_modele as $_periodicite_modele) {
     574                        if (in_array($_periodicite_modele, $periodicites_service)) {
     575                                $periodicite = $_periodicite_modele;
     576                                break;
     577                        }
     578                }
     579        }
     580
     581        return $periodicite;
     582}
     583
     584
     585/**
     586 * @param $type_modele
     587 * @param $periodicite
     588 *
     589 * @return bool
     590 */
     591function periodicite_est_compatible($type_modele, $periodicite) {
     592
     593        // Périodicité initialisée à "non trouvée"
     594        $compatible = false;
     595
     596        if (isset($GLOBALS['rainette_config']['periodicite'][$type_modele])
     597                and in_array($periodicite, $GLOBALS['rainette_config']['periodicite'][$type_modele])
     598        ) {
     599                $compatible = true;
     600        }
     601
     602        return $compatible;
     603}
     604
     605
     606/**
     607 * Construit le nom du cache en fonction du servide, du lieu, du type de données et de la langue utilisée par le site.
     608 *
     609 * @param string $lieu
     610 *        Lieu pour lequel on requiert le nom du cache.
     611 * @param string $mode
     612 *        Type de données météorologiques. Les valeurs possibles sont `infos`, `conditions` ou `previsions`.
     613 * @param int    $periodicite
     614 *        La périodicité horaire des prévisions :
     615 *        - `24`, `12`, `6`, `3` ou `1`, pour le mode `previsions`
     616 *        - `0`, pour les modes `conditions` et `infos`
     617 * @param array  $configuration_service
     618 *        Configuration complète du service, statique et utilisateur.
     619 *
     620 * @return string
     621 *        Chemin complet du fichier cache.
     622 */
     623function cache_nommer($lieu, $mode, $periodicite, $configuration_service) {
     624
     625        // Identification de la langue du resume.
     626        $code_langue = langue_determiner($configuration_service);
     627
     628        // Construction du chemin du fichier cache
     629        // Création et/ou détermination du dossier de destination du cache en fonction du service
     630        $dossier_cache = sous_repertoire(_DIR_VAR, 'cache-rainette');
     631        $dossier_cache = sous_repertoire($dossier_cache, $configuration_service['alias']);
     632
     633        // Le nom du fichier cache est composé comme suit, chaque élement étant séparé par un underscore :
     634        // -- le nom du lieu normalisé (sans espace et dont tous les caractères non alphanumériques sont remplacés par un tiret
     635        // -- le nom du mode (infos, conditions ou previsions) accolé à la périodicité du cache pour les prévisions uniquement
     636        // -- la langue du résumé si il existe ou rien si aucune traduction n'est fournie par le service
     637        list($lieu_normalise,) = lieu_normaliser($lieu);
     638        $fichier_cache = $dossier_cache
     639                                         . str_replace(array(' ', ',', '+', '.', '/'), '-', $lieu_normalise)
     640                                         . '_' . $mode
     641                                         . ($periodicite ? strval($periodicite) : '')
     642                                         . ($code_langue ? '_' . strtolower($code_langue) : '')
     643                                         . '.txt';
     644
     645        return $fichier_cache;
     646}
     647
     648
     649/**
     650 * @param $lieu
     651 *
     652 * @return array
     653 */
     654function lieu_normaliser($lieu) {
     655
     656        $lieu_normalise = trim($lieu);
     657
     658        if (preg_match(_RAINETTE_REGEXP_LIEU_WEATHER_ID, $lieu_normalise, $match)) {
     659                $format_lieu = 'weather_id';
     660                $lieu_normalise = $match[0];
     661        } elseif (preg_match(_RAINETTE_REGEXP_LIEU_COORDONNEES, $lieu_normalise, $match)) {
     662                $format_lieu = 'latitude_longitude';
     663                $lieu_normalise = "{$match[1]},{$match[2]}";
     664        } elseif (preg_match(_RAINETTE_REGEXP_LIEU_IP, $lieu_normalise, $match)) {
     665                $format_lieu = 'adresse_ip';
     666                $lieu_normalise = $match[0];
     667        } else {
     668                $format_lieu = 'ville_pays';
     669                // On détermine la ville et éventuellement le pays (ville[,pays])
     670                // et on élimine les espaces par un seul +
     671                $elements = explode(',', $lieu_normalise);
     672                $lieu_normalise = trim($elements[0]) . (!empty($elements[1]) ? ',' . trim($elements[1]) : '');
     673                $lieu_normalise = preg_replace('#\s{1,}#', '+', $lieu_normalise);
     674        }
     675
     676        return array($lieu_normalise, $format_lieu);
     677}
     678
     679
     680/**
     681 * @param $configuration_service
     682 *
     683 * @return mixed
     684 */
     685function langue_determiner($configuration_service) {
     686
     687        if ($configuration_service['condition'] == $configuration_service['alias']) {
     688                // Rainette est configurée pour utiliser le résumé renvoyé par le service pour l'affichage :
     689                // il est donc nécessaire de demander ce résumé dans la bonne langue si elle existe.
     690
     691                // On détermine la "bonne langue" : on choisit soit celle de la page en cours
     692                // soit celle en cours pour l'affichage.
     693                $langue_spip = $GLOBALS['lang'] ? $GLOBALS['lang'] : $GLOBALS['spip_lang'];
     694
     695                // On cherche si le service fournit la langue utilisée par le site.
     696                // -- Pour cela on utilise la configuration du service qui fournit un tableau des langues disponibles
     697                //    sous le format [code de langue du service] = code de langue spip.
     698                $langue_service = array_search($langue_spip, $configuration_service['langues']['disponibles']);
     699                if ($langue_service === false) {
     700                        // La langue utilisée par SPIP n'est pas supportée par le service.
     701                        // -- On cherche si il existe une langue SPIP utilisable meilleure que la langue par défaut du service.
     702                        // -- Pour ce faire on a défini pour chaque code de langue spip, un ou deux codes de langue SPIP à utiliser
     703                        //    en cas d'absence de la langue concernée dans un ordre de priorité (index 0, puis index 1).
     704                        $langue_service = $configuration_service['langues']['defaut'];
     705                        if ($GLOBALS['rainette_config']['langues_alternatives'][$langue_spip]) {
     706                                foreach ($GLOBALS['rainette_config']['langues_alternatives'][$langue_spip] as $_langue_alternative) {
     707                                        $langue_service = array_search($_langue_alternative, $configuration_service['langues']['disponibles']);
     708                                        if ($langue_service !== false) {
     709                                                break;
     710                                        }
     711                                }
     712                        }
     713                }
     714        } else {
     715                // Rainette est configurée pour afficher le résumé Weather.com après transcodage. La langue de la requête
     716                // importe peu, on choisit donc la langue configurée par défaut.
     717                $langue_service = $configuration_service['langues']['defaut'];
     718        }
     719
     720        return $langue_service;
     721}
     722
     723
     724/**
     725 * @param $mode
     726 * @param $configuration
     727 *
     728 * @return array
     729 */
     730function normaliser_configuration_donnees($mode, $configuration) {
     731
     732        $configuration_normalisee = array();
     733
     734        foreach ($GLOBALS['rainette_config'][$mode] as $_donnee => $_configuration) {
     735                if ($_configuration['origine'] == 'service') {
     736                        $configuration_normalisee[$_donnee] = !empty($configuration[$_donnee]['cle']) ? true : false;
     737                }
     738        }
     739
     740        return $configuration_normalisee;
     741}
     742
     743/**
     744 * @param $service
     745 * @param $configuration_defaut
     746 *
     747 * @return mixed
     748 */
     749function normaliser_configuration_utilisateur($service, $configuration_defaut) {
     750
     751        // On récupère la configuration utilisateur
     752        include_spip('inc/config');
     753        $configuration_utilisateur = lire_config("rainette/${service}", array());
     754
     755        // On complète la configuration avec des valeurs par défaut si nécessaire.
     756        foreach ($configuration_defaut as $_cle => $_valeur) {
     757                if (!isset($configuration_utilisateur[$_cle])) {
     758                        $configuration_utilisateur[$_cle] = $_valeur;
     759                }
     760        }
     761
     762        return $configuration_utilisateur;
     763}
  • _plugins_/rainette/trunk/inc/rainette_requeter.php

    r107974 r108066  
    77
    88/**
     9 * Fait appel au service spécifié en utilisant l'URL fournie et retourne le flux brut JSON ou XML transcodé dans un tableau.
     10 * Chaque appel est comptabilisé et logé dans une meta.
    911 *
    1012 * @param string $url
     13 *              URL complète de la requête formatée en fonction de la demande et du service.
    1114 * @param array  $configuration
     15 *              Configuration statique et utilisateur du service nécessaire pour identifier les seuils de requêtes
     16 *      par période propres au service et le format du flux pour le transcodage.
    1217 * @param string $service
     18 *      Alias du service.
    1319 *
    1420 * @return array
     21 *      Tableau des données météorologiques retournées par le service ou tableau limité à l'index `erreur` en cas
     22 *      d'erreur de transcodage.
    1523 */
    1624function requeter($url, $configuration, $service) {
     
    5159                        // http://stackoverflow.com/questions/17009045/how-do-i-handle-warning-simplexmlelement-construct/17012247#17012247
    5260                        set_error_handler(
    53                                 function($erreur_id, $erreur_message, $erreur_fichier, $erreur_ligne) {
     61                                function ($erreur_id, $erreur_message, $erreur_fichier, $erreur_ligne) {
    5462                                        throw new Exception($erreur_message, $erreur_id);
    5563                                }
     
    8290
    8391/**
     92 * Vérifie si la requête prévue peut être adressée au service sans excéder les limites d'utilisation fixées dans
     93 * les conditions d'utilisation du service.
     94 * Si une période est échue, la fonction remet à zéro le compteur associé.
     95 *
    8496 * @param array  $limites
     97 *      Tableau des seuils de requêtes par période (année, mois,..., minute).
    8598 * @param string $service
     99 *      Alias du service.
    86100 *
    87101 * @return bool
     102 *      `true` si la requête est autorisée, `false`sinon.
    88103 */
    89104function requete_autorisee($limites, $service) {
     
    101116
    102117                if ($limites) {
    103                         $periode_a_change = false;
     118                        $nouvelle_periode = false;
    104119                        foreach ($limites as $_periode => $_max) {
    105120                                // La date courante est un tableau indexé par la période de l'année (year) à la minute (minute) et plus.
     
    107122                                // ou pas : si un élément a changé alors on est forcément ok, sinon on vérifie le nombre d'appels comparé
    108123                                // à la valeur max configurée.
    109                                 if ($periode_a_change) {
     124                                if ($nouvelle_periode) {
    110125                                        // Toutes les autres périodes inférieures ont donc changé aussi, on remet donc leur compteur
    111126                                        // à zéro.
     
    120135                                                        $execution[$service]['compteurs'][$_periode] = 0;
    121136                                                        ecrire_config('rainette_execution', $execution);
    122                                                         $periode_a_change = true;
     137                                                        $nouvelle_periode = true;
    123138                                                        break;
    124139                                                } elseif ($_cle == $_periode) {
  • _plugins_/rainette/trunk/rainette_fonctions.php

    r107857 r108066  
    5555
    5656                // Récupération des informations sur le lieu
    57                 $charger = charger_fonction('charger_meteo', 'inc');
     57                $charger = charger_fonction('meteo_charger', 'inc');
    5858                $nom_cache = $charger($lieu, 'infos', 0, $service);
    5959                lire_fichier($nom_cache, $contenu_cache);
     
    393393                        if (isset($options['periodicite'])) {
    394394                                $periodicite_explicite = intval($options['periodicite']);
    395                                 if (periodicite_compatible($type_modele, $periodicite_explicite)) {
     395                                if (periodicite_est_compatible($type_modele, $periodicite_explicite)) {
    396396                                        $periodicite = $periodicite_explicite;
    397397                                } else {
     
    400400                        } else {
    401401                                // Dans ce cas, il faut choisir une périodicité en fonction du type du modèle et du service.
    402                                 $periodicite = trouver_periodicite($type_modele, $service);
     402                                $periodicite = periodicite_determiner($type_modele, $service);
    403403                                if (!$periodicite) {
    404404                                        $erreur = 'modele_service';
     
    443443        } else {
    444444                // Récupération du tableau des données météo
    445                 $charger = charger_fonction('charger_meteo', 'inc');
     445                $charger = charger_fonction('meteo_charger', 'inc');
    446446                $nom_cache = $charger($lieu, $mode, $periodicite, $service);
    447447                lire_fichier($nom_cache, $contenu_cache);
     
    477477        // Affichage du message d'erreur ou des données
    478478        if ($erreur) {
    479                 $extras['erreur']['texte'] = normaliser_texte_erreur($extras['erreur'], $lieu, $mode, $modele, $service);
     479                $extras['erreur']['texte'] = erreur_formater_texte($extras['erreur'], $lieu, $mode, $modele, $service);
    480480                $texte = recuperer_fond('modeles/erreur', $extras);
    481481        } else {
  • _plugins_/rainette/trunk/services/apixu.php

    r107974 r108066  
    191191// ------------------------------------------------------------------------------------------------
    192192// Les fonctions qui suivent définissent l'API standard du service et sont appelées par la fonction
    193 // unique de chargement des données météorologiques `charger_meteo()`.
     193// unique de chargement des données météorologiques `meteo_charger()`.
    194194// ------------------------------------------------------------------------------------------------
    195195
     
    240240        // Identification de la langue du resume.
    241241        include_spip('inc/rainette_normaliser');
    242         $code_langue = trouver_langue_service($configuration);
     242        $code_langue = langue_determiner($configuration);
    243243
    244244        // On normalise le lieu et on récupère son format.
    245245        // Le service accepte la format ville,pays, le format latitude,longitude et le format adresse IP.
    246246        // Néanmoins, la query a toujours la même forme; il n'est donc pas nécessaire de gérer le format.
    247         list($lieu_normalise,) = normaliser_lieu($lieu);
     247        list($lieu_normalise,) = lieu_normaliser($lieu);
    248248
    249249        $url = _RAINETTE_APIXU_URL_BASE;
  • _plugins_/rainette/trunk/services/owm.php

    r107974 r108066  
    175175 * ------------------------------------------------------------------------------------------------
    176176 * Les fonctions qui suivent définissent l'API standard du service et sont appelées par la fonction
    177  * unique de chargement des données météorologiques `charger_meteo()`.
     177 * unique de chargement des données météorologiques `meteo_charger()`.
    178178 * PACKAGE SPIP\RAINETTE\OWM\API
    179179 * ------------------------------------------------------------------------------------------------
     
    214214        // on ne la precise pas et on laisse l'API renvoyer la langue par defaut
    215215        include_spip('inc/rainette_normaliser');
    216         $code_langue = trouver_langue_service($configuration);
     216        $code_langue = langue_determiner($configuration);
    217217
    218218        // On normalise le lieu et on récupère son format.
    219219        // Le service accepte la format ville,pays et le format latitude,longitude
    220         list($lieu_normalise, $format_lieu) = normaliser_lieu($lieu);
     220        list($lieu_normalise, $format_lieu) = lieu_normaliser($lieu);
    221221        if ($format_lieu == 'latitude_longitude') {
    222222                list($latitude, $longitude) = explode(',', $lieu_normalise);
  • _plugins_/rainette/trunk/services/weather.php

    r107974 r108066  
    176176        // Néanmoins, la query a toujours la même forme; il n'est donc pas nécessaire de gérer le format.
    177177        include_spip('inc/rainette_normaliser');
    178         list($lieu_normalise,) = normaliser_lieu($lieu);
     178        list($lieu_normalise,) = lieu_normaliser($lieu);
    179179
    180180        $url = _RAINETTE_WEATHER_URL_BASE
  • _plugins_/rainette/trunk/services/wunderground.php

    r107974 r108066  
    237237 * ------------------------------------------------------------------------------------------------
    238238 * Les fonctions qui suivent définissent l'API standard du service et sont appelées par la fonction
    239  * unique de chargement des données météorologiques `charger_meteo()`.
     239 * unique de chargement des données météorologiques `meteo_charger()`.
    240240 * PACKAGE SPIP\RAINETTE\WUNDERGROUND\API
    241241 * ------------------------------------------------------------------------------------------------
     
    295295        // et le format weather ID (comme FRXX0076 pour Paris).
    296296        include_spip('inc/rainette_normaliser');
    297         list($lieu_normalise, $format_lieu) = normaliser_lieu($lieu);
     297        list($lieu_normalise, $format_lieu) = lieu_normaliser($lieu);
    298298        if ($format_lieu == 'weather_id') {
    299299                $query = "locid:${lieu_normalise}";
     
    314314        // Le choix de la langue n'a d'interet que si on utilise le resume natif du service. Si ce n'est pas
    315315        // le cas on demande à l'API de renvoyer la langue par defaut
    316         $code_langue = trouver_langue_service($configuration);
     316        $code_langue = langue_determiner($configuration);
    317317
    318318        $url = _RAINETTE_WUNDERGROUND_URL_BASE_REQUETE
  • _plugins_/rainette/trunk/services/wwo.php

    r107974 r108066  
    194194// ------------------------------------------------------------------------------------------------
    195195// Les fonctions qui suivent définissent l'API standard du service et sont appelées par la fonction
    196 // unique de chargement des données météorologiques `charger_meteo()`.
     196// unique de chargement des données météorologiques `meteo_charger()`.
    197197// ------------------------------------------------------------------------------------------------
    198198
     
    243243        // Identification de la langue du resume.
    244244        include_spip('inc/rainette_normaliser');
    245         $code_langue = trouver_langue_service($configuration);
     245        $code_langue = langue_determiner($configuration);
    246246
    247247        // On normalise le lieu et on récupère son format.
    248248        // Le service accepte la format ville,pays, le format latitude,longitude et le format adresse IP.
    249249        // Néanmoins, la query a toujours la même forme; il n'est donc pas nécessaire de gérer le format.
    250         list($lieu_normalise,) = normaliser_lieu($lieu);
     250        list($lieu_normalise,) = lieu_normaliser($lieu);
    251251
    252252        $url = _RAINETTE_WWO_URL_BASE
Note: See TracChangeset for help on using the changeset viewer.