source: spip-zone/_plugins_/rainette/trunk/rainette_fonctions.php @ 94839

Last change on this file since 94839 was 94839, checked in by eric@…, 4 years ago

Réorganisation d'une partie de la configuration des services.
Reformatage des fichiers service.

File size: 11.8 KB
Line 
1<?php
2
3if (!defined('_ECRIRE_INC_VERSION')) {
4        return;
5}
6
7if (!defined('_RAINETTE_ICONES_PATH')) {
8        define('_RAINETTE_ICONES_PATH', 'rainette/');
9}
10if (!defined('_RAINETTE_ICONES_GRANDE_TAILLE')) {
11        define('_RAINETTE_ICONES_GRANDE_TAILLE', 110);
12}
13if (!defined('_RAINETTE_ICONES_PETITE_TAILLE')) {
14        define('_RAINETTE_ICONES_PETITE_TAILLE', 28);
15}
16
17// Balises du plugin utilisables dans les squelettes et modeles
18/**
19 * @param $p
20 *
21 * @return mixed
22 */
23function balise_RAINETTE_INFOS($p) {
24
25        $code_meteo = interprete_argument_balise(1, $p);
26        $code_meteo = isset($code_meteo) ? str_replace('\'', '"', $code_meteo) : '""';
27        $type_info = interprete_argument_balise(2, $p);
28        $type_info = isset($type_info) ? str_replace('\'', '"', $type_info) : '""';
29        $service = interprete_argument_balise(3, $p);
30        $service = isset($service) ? str_replace('\'', '"', $service) : '"weather"';
31
32        $p->code = 'calculer_infos(' . $code_meteo . ', ' . $type_info . ', ' . $service . ')';
33        $p->interdire_scripts = false;
34
35        return $p;
36}
37
38/**
39 * @param $lieu
40 * @param $type
41 * @param $service
42 *
43 * @return mixed|string
44 */
45function calculer_infos($lieu, $type, $service) {
46
47        // Initialisation du retour
48        $info = '';
49
50        // Traitement des cas ou les arguments sont vides
51        if ($lieu) {
52                if (!$service) {
53                        $service = 'weather';
54                }
55
56                // Récupération des informations sur le lieu
57                $charger = charger_fonction('charger_meteo', 'inc');
58                $nom_cache = $charger($lieu, 'infos', 0, $service);
59                lire_fichier($nom_cache, $contenu_cache);
60                if (!isset($type) or !$type) {
61                        $info = $contenu_cache;
62                } else {
63                        $tableau = unserialize($contenu_cache);
64                        $info = $tableau['donnees'][strtolower($type)];
65                }
66        }
67
68        return $info;
69}
70
71// Filtres du plugin utilisables dans les squelettes et modeles
72/**
73 * @param        $meteo
74 * @param string $taille
75 * @param string $chemin
76 * @param string $extension
77 *
78 * @return string
79 */
80function rainette_afficher_icone($meteo, $taille = 'petit', $chemin = '', $extension = 'png') {
81        $taille_defaut = ($taille == 'petit') ? _RAINETTE_ICONES_PETITE_TAILLE : _RAINETTE_ICONES_GRANDE_TAILLE;
82
83        if (is_array($meteo)) {
84                // Utilisation des icones natifs des services autres que weather.com
85                $resume = attribut_html(rainette_afficher_resume($meteo['code']));
86                $source = $meteo['url'];
87        } else {
88                // Utilisation des icones weather.com
89                $resume = rainette_afficher_resume($meteo);
90
91                $meteo = ($meteo and (($meteo >= 0) and ($meteo < 48))) ? strval($meteo) : 'na';
92                $chemin = (!$chemin) ? _RAINETTE_ICONES_PATH . $taille . '/' : rtrim($chemin, '/') . '/';
93                $fichier = $meteo . '.' . $extension;
94                // Le dossier personnalise ou le dossier passe en argument
95                // a-t-il bien l'icone requise ?
96                $source = find_in_path($fichier, $chemin);
97                if (!$source) {
98                        // Non, il faut donc prendre l'icone par defaut dans le repertoire img_meteo qui existe toujours
99                        $source = find_in_path($fichier, "img_meteo/$taille/");
100                }
101        }
102
103        // On retaille si nécessaire l'image pour qu'elle soit toujours de la même taille (grande ou petite)
104        list($largeur, $hauteur) = @getimagesize($source);
105        include_spip('filtres/images_transforme');
106        if (($largeur < $taille_defaut)
107                or ($hauteur < $taille_defaut)
108        ) {
109                // Image plus petite que celle par défaut :
110                // --> Il faut insérer et recadrer l'image dans une image plus grande à la taille par défaut
111                $source = extraire_attribut(image_recadre($source, $taille_defaut, $taille_defaut, 'center', 'transparent'), 'src');
112        } elseif (($largeur > $taille_defaut)
113                          or ($hauteur > $taille_defaut)
114        ) {
115                // Image plus grande que celle par défaut :
116                // --> Il faut reduire l'image à la taille par défaut
117                $source = extraire_attribut(image_reduire($source, $taille_defaut), 'src');
118        }
119
120        // On construit la balise img
121        $texte = attribut_html($resume);
122        $balise_img = "<img src=\"${source}\" alt=\"${texte}\" title=\"${texte}\" width=\"${taille_defaut}\" height=\"${taille_defaut}\" />";
123
124        return $balise_img;
125}
126
127/**
128 * @param $meteo
129 *
130 * @return string
131 */
132function rainette_afficher_resume($meteo) {
133
134        if (is_numeric($meteo)) {
135                // On utilise l'option de _T permettant de savoir si un item existe ou pas
136                $resume = _T('rainette:meteo_' . $meteo, array(), array('force' => false));
137                if (!$resume) {
138                        $resume = _T('rainette:meteo_na') . " ($meteo)";
139                }
140        } else {
141                $resume = $meteo ? $meteo : _T('rainette:meteo_na');
142        }
143
144        return ucfirst($resume);
145}
146
147/**
148 * Conversion une indication de direction en une chaine traduite pour
149 * l'affichage dans les modèles.
150 *
151 * @param    mixed $direction
152 *        La direction soit sous forme d'une valeur numérique entre 0 et 360, soit sous forme
153 *        d'une chaine. Certains services utilisent la chaine "V" pour indiquer une direction
154 *        variable.
155 *
156 * @return    string
157 *        La chaine traduite indiquant la direction du vent.
158 */
159function rainette_afficher_direction($direction) {
160
161        include_spip('inc/convertir');
162        $direction = angle2direction($direction);
163
164        if ($direction) {
165                return _T("rainette:direction_$direction");
166        } else {
167                return _T('rainette:valeur_indeterminee');
168        }
169}
170
171/**
172 * @param        $tendance_en
173 * @param string $methode
174 * @param string $chemin
175 * @param string $extension
176 *
177 * @return string
178 */
179function rainette_afficher_tendance($tendance_en, $methode = 'texte', $chemin = '', $extension = 'png') {
180
181        $tendance = '';
182
183        if (($tendance_en)
184                and ($texte = _T("rainette:tendance_texte_$tendance_en", array(), array('force' => false)))
185        ) {
186                if ($methode == 'texte') {
187                        $tendance = $texte;
188                } elseif ($methode == 'symbole') {
189                        $tendance = _T("rainette:tendance_symbole_$tendance_en");
190                } elseif ($methode == 'icone') {
191                        $chemin = (!$chemin) ? _RAINETTE_ICONES_PATH : rtrim($chemin, '/') . '/';
192                        $fichier = $tendance_en . '.' . $extension;
193                        // Le dossier personnalise ou le dossier passe en argument
194                        // a-t-il bien l'icone requise ?
195                        $source = find_in_path($fichier, $chemin);
196                        if (!$source) {
197                                // Non, il faut donc prendre l'icone par defaut dans le repertoire img_meteo qui existe toujours
198                                $source = find_in_path($fichier, 'img_meteo/');
199                        }
200
201                        list($largeur, $hauteur) = @getimagesize($source);
202                        $tendance = "<img src=\"$source\" alt=\"$texte\" title=\"$texte\" width=\"$largeur\" height=\"$hauteur\" />";
203                }
204        }
205
206        return $tendance;
207}
208
209/**
210 * Affiche toute donnée météorologique au format numérique avec son unité.
211 *
212 *
213 * @package    RAINETTE/AFFICHAGE
214 * @api
215 *
216 * @param        int /float    $valeur            La valeur à afficher
217 * @param string $type_valeur Type de données à afficher parmi 'temperature', 'pourcentage', 'angle', 'pression',
218 *                                    'distance', 'vitesse', 'population', 'precipitation'
219 * @param int    $precision Nombre de décimales à afficher pour les réels uniquement ou -1 pour utiliser le défaut
220 * @param string $service
221 *
222 * @return string    La chaine calculée ou le texte désignant une valeur indéterminée
223 */
224function rainette_afficher_unite($valeur, $type_valeur = '', $precision = -1, $service = 'weather') {
225
226        static $precision_defaut = array(
227                'temperature'   => 0,
228                'pression'      => 1,
229                'distance'      => 1,
230                'angle'         => 0,
231                'pourcentage'   => 0,
232                'population'    => 0,
233                'precipitation' => 1,
234                'vitesse'       => 0,
235                'indice'        => 0
236        );
237
238        if (!$service) {
239                $service = 'weather';
240        }
241        include_spip('inc/config');
242        $unite = lire_config("rainette/${service}/unite", 'm');
243
244        // On distingue la valeur NULL qui indique que la donnée météo n'est pas fournie par le service avec
245        // la valeur '' qui indique que la valeur n'est pas disponible temporairement
246        // Dans le cas NULL on n'affiche pas la valeur, dans le cas '' on affiche la non disponibilité
247        if ($valeur === null) {
248                $valeur_affichee = '';
249        } else {
250                $valeur_affichee = _T('rainette:valeur_indeterminee');
251                if ($valeur !== '') {
252                        // Détermination de l'arrondi si la donnée est stockée sous format réel
253                        if (array_key_exists($type_valeur, $precision_defaut)) {
254                                $precision = ($precision < 0) ? $precision_defaut[$type_valeur] : $precision;
255                                $valeur = round($valeur, $precision);
256                        }
257
258                        // Construction de la valeur affichée en fonction de son type. Un indice ne possède pas d'unité.
259                        $valeur_affichee = strval($valeur);
260                        if ($type_valeur != 'indice') {
261                                $suffixe = ($type_valeur == 'population')
262                                        ? ''
263                                        : (($unite == 'm') ? 'metrique' : 'standard');
264                                $espace = in_array($type_valeur, array('temperature', 'pourcentage', 'angle')) ? '' : '&nbsp;';
265                                $item = 'rainette:unite_' . $type_valeur . ($suffixe ? '_' . $suffixe : '');
266                                $valeur_affichee .= $espace . _T($item);
267                        }
268                }
269        }
270
271        return $valeur_affichee;
272}
273
274
275/**
276 * @param string $lieu
277 * @param string $mode
278 * @param string $modele
279 * @param string $service
280 * @param array  $options
281 *
282 * @return array|string
283 */
284function rainette_coasser($lieu, $mode = 'conditions', $modele = 'conditions_tempsreel', $service = 'weather', $options = array()) {
285
286        // Initialisation du retour
287        $tableau = array();
288
289        // Détermination de la périodicité en fonction du mode et du modèle demandés
290        $periodicite = 0;
291        $erreur = '';
292        if ($mode == 'previsions') {
293                // Identification de la périodicité à partir du nom du modèle. Cela évite une configuration compliquée.
294                if (preg_match(',_(1|12|24)h,is', $modele, $match)) {
295                        $type_modele = intval($match[1]);
296
297                        // On verifie que la périodicité demandée explicitement dans l'appel du modèle est ok
298                        include_spip('inc/normaliser');
299                        if (isset($options['periodicite'])) {
300                                $periodicite_explicite = intval($options['periodicite']);
301                                if (periodicite_compatible($type_modele, $periodicite_explicite)) {
302                                        $periodicite = $periodicite_explicite;
303                                } else {
304                                        $erreur = 'modele_periodicite';
305                                }
306                        } else {
307                                // Dans ce cas, il faut choisir une périodicité en fonction du type du modèle et du service.
308                                $periodicite = trouver_periodicite($type_modele, $service);
309                                if (!$periodicite) {
310                                        $erreur = 'modele_service';
311                                }
312                        }
313                } else {
314                        // On ne connait pas le type du modèle, donc sa compatibilité.
315                        // Si la périodicité est passée en argument on l'utilise sans se poser de question.
316                        // Sinon c'est une erreur car on ne sait pas quelle périodicité est requise
317                        if (isset($options['periodicite'])) {
318                                $periodicite = intval($options['periodicite']);
319                        } else {
320                                $erreur = 'modele_inutilisable';
321                        }
322                }
323        }
324
325        if ($erreur) {
326                // On prépare un contexte extras minimal pour traiter les erreurs du modèle de façon standard
327                $extras['erreur'] = $erreur;
328                $extras['lieu'] = $lieu;
329                $extras['mode'] = $mode;
330                $extras['periodicite'] = $periodicite;
331                $extras['service'] = $service;
332        } else {
333                // Récupération du tableau des données météo
334                $charger = charger_fonction('charger_meteo', 'inc');
335                $nom_cache = $charger($lieu, $mode, $periodicite, $service);
336                lire_fichier($nom_cache, $contenu_cache);
337                $tableau = unserialize($contenu_cache);
338
339                // Séparation des données communes liées au service et au mode et des données météorologiques
340                $extras = $tableau['extras'];
341                $erreur = $extras['erreur'];
342
343                if (!$erreur and ($mode == 'previsions')) {
344                        // Adaptation des données en fonction de la demande et de la périodicité modèle-cache
345                        $nb_index = count($tableau['donnees']);
346
347                        $jour1 = 0;
348                        if (isset($options['premier_jour'])) {
349                                $jour1 = intval($options['premier_jour']) < $nb_index
350                                        ? intval($options['premier_jour'])
351                                        : $nb_index -1;
352                        }
353
354                        $nb_jours = $nb_index - $jour1;
355                        if (isset($options['nombre_jours'])) {
356                                $nb_jours = ($jour1 + intval($options['nombre_jours']) <= $nb_index)
357                                        ? intval($options['nombre_jours'])
358                                        : $nb_index - $jour1;
359                        }
360
361                        $tableau['premier_jour'] = $jour1;
362                        $tableau['nombre_jours'] = $nb_jours;
363                }
364        }
365
366        // Affichage du message d'erreur ou des données
367        if ($erreur) {
368                $texte = recuperer_fond('modeles/erreur', $extras);
369        } else {
370                // Appel du modèle avec le contexte complet
371                $texte = recuperer_fond("modeles/$modele", $tableau);
372        }
373
374        return $texte;
375}
376
377include_spip('inc/debusquer');
Note: See TracBrowser for help on using the repository browser.