Subversion Repositories eFlore/Projets.eflore-projets

Rev

Rev 1135 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
727 alex 1
<?php
2
 
747 alex 3
/**
4
 * Classe qui remplit un fond cartographique SVG a partir des observations en base de donnees
5
 * pour un taxon de plante. Elle verifie dans un premier temps la validite des parametres saisis,
6
 * puis charge le fond cartographique depuis le fichier, recupere dans la base de donnees
7
 * les observations sur la France metropolitaine pour le taxon donne et remplit la carte
8
 * en changeant le style CSS des mailles en fonction des coordonnees des points d'observation.
9
 * Le format et la taille de la carte renvoyee au client est parametrable.
10
 *
11
 * Parametres :
12
 *   - referentiel : le referentiel taxonomique a interroger pour verifier le taxon. Pour l'instant,
13
 *     seul bdtfx (Tracheophytes de France metropolirtaine) est utilise par le web service
14
 *   - num_taxon : le numero taxonomique de la plante dont on veut obtenir la carte de repartition.
15
 *     Le rang des taxons traites par le web service sont la famille, le genre, l'espece et la sous-espece.
16
 *     La recherche des observations s'etend en pus sur les sous taxons et les synonymes.
17
 *   - source : une ou plusieurs sources de donnees a interroger. Si le parametre n'est pas indique,
18
 *     le web service ira rechercher les observatipons dans toutes les sources de donnees.
19
 *   - format : la largeur de la carte, exprimee dans une valeur entiere en pixels.
20
 *     Le ratio largeur:hauteur est conserve lors du redimensionnement de la carte pour le retour
21
 *   - retour : le type MIME (ou format de fichier) de retour. Sont acceptes par le web service
22
 *     le PNG (image/png) et le XML (text/html) pour renvoyer le web service
23
 *
24
 * @package framework-0.4
25
 * @author Alexandre GALIBERT <alexandre.galibert@tela-botanica.org>
26
 * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
27
 * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
28
 * @version $Id$
29
 * @copyright 2013 Tela Botanica (accueil@tela-botanica.org)
30
 *
31
 */
32
 
811 raphael 33
class MoissonnageCartes {
727 alex 34
 
35
	const MIME_MAP = "text/html";
36
	const MIME_PNG = "image/png";
37
 
930 aurelien 38
	const METHODE_TELECHARGEMENT = "telecharger";
39
	const METHODE_AFFICHAGE = "afficher";
40
 
727 alex 41
	private $ressources;
42
	private $parametres;
43
 
44
	private $referentiel = '';
45
	private $taxon   = null;
46
	private $sources = array();
747 alex 47
	private $format  = 0;
727 alex 48
	private $retour  = self::MIME_MAP;
930 aurelien 49
	private $methode_livraison = self::METHODE_AFFICHAGE;
727 alex 50
	private $erreurs = array();
1134 mathias 51
 
727 alex 52
 
53
	public function consulter($ressources, $parametres) {
54
		$this->parametres = $parametres;
55
		$this->ressources = $ressources;
56
		$resultat = null;
57
		$this->chargerClassesSousDossier();
58
		if ($this->analyserRessources() == true) {
59
			$resultat = $this->formerLegende();
60
		} else {
61
			$this->traiterParametres();
1134 mathias 62
			$resultat = $this->obtenirCarte();
930 aurelien 63
			if($this->methode_livraison == self::METHODE_TELECHARGEMENT) {
64
				$this->telechargerCarte($resultat->corps);
65
			}
727 alex 66
		}
67
		return $resultat;
68
	}
69
 
70
	private function analyserRessources() {
71
		$ok = false;
72
		if (isset($this->ressources[0]) && $this->ressources[0] == 'legende') {
73
			$ok = true;
74
		}
75
		return $ok;
76
	}
77
 
78
	private function formerLegende() {
79
		$legende = new LegendeCartes();
80
		$resultat = $legende->obtenirLegende();
81
		return $resultat;
82
	}
83
 
84
	private function chargerClassesSousDossier() {
85
		$this->verifierExistenceDossier("cartes");
86
		$nomDossier = dirname(__FILE__).DS."cartes";
87
		$dossier = opendir($nomDossier);
88
		$fichiersAInclure = array();
89
		while ($fichier = readdir($dossier)) {
90
			if (filetype($nomDossier.DS.$fichier) == 'file') {
91
				$fichiersAInclure[] = $nomDossier.DS.$fichier;
92
			}
93
		}
94
		$fichiersAInclure = array_reverse($fichiersAInclure);
95
		foreach ($fichiersAInclure as $fichier) {
96
			include_once($fichier);
97
		}
98
	}
99
 
100
	private function verifierExistenceDossier($nomDossier) {
101
		$dossier = dirname(__FILE__).DS.$nomDossier;
102
		if (!file_exists($dossier) || !is_dir($dossier)) {
103
			$message = "Problème rencontré lors de la génération de la carte : des ressources ".
104
				"nécessaires au fonctionnement du service n'ont pas été localisées sur le serveur.\n";
105
			throw new Exception($message);
106
		}
107
	}
108
 
109
	private function verifierExistenceFichier($nomFichier) {
110
		if (!file_exists($nomFichier)) {
111
			$message = "Problème rencontré lors de la génération de la carte : des ressources ".
112
				"nécessaires au fonctionnement du service n'ont pas été localisées sur le serveur.\n";
113
			throw new Exception($message);
114
		}
115
	}
116
 
117
	private function traiterParametres() {
118
		$this->verifierReferentielEtTaxon();
119
		$this->verifierParametreSource();
120
		$this->verifierParametreFormat();
121
		$this->verifierParametreRetour();
930 aurelien 122
		$this->verifierParametreMethodeLivraison();
727 alex 123
		if (count($this->erreurs) > 0) {
124
			$this->renvoyerErreurs();
125
		}
126
	}
127
 
128
	private function verifierParametreFormat() {
129
		if (!isset($this->parametres['format'])) {
130
			$this->erreurs[] = "Le paramètre format (dimensions) de l'image n'a pas été indiqué dans l'URL du service.";
131
		} elseif (preg_match('/^[1-9]\d{2}$/', $this->parametres['format']) != 1) {
132
			$this->erreurs[] = "La valeur du paramètre format n'est pas acceptée par le service. ".
133
				"Une largeur valide doit être un nombre entier compris entre 100 et 999.";
134
		} else {
135
			$this->format = $this->parametres['format'];
136
		}
137
	}
138
 
139
	private function verifierParametreRetour() {
140
		$typesMime = array(self::MIME_MAP, self::MIME_PNG);
141
		if (!isset($this->parametres['retour'])) {
142
			$this->erreurs[] = "Le paramètre type de retour de l'image n'a pas été indiqué dans l'URL du service.";
143
		} elseif (!in_array($this->parametres['retour'], $typesMime)) {
144
			$this->erreurs[] = "Le format de retour ".$this->parametres['retour']." n'est pas acceptée par le service. ".
145
				" Seuls les types MIME suivants sont gérés : ".implode(',', $typesMime);
146
		} else {
147
			$this->retour = $this->parametres['retour'];
148
		}
149
	}
150
 
930 aurelien 151
	private function verifierParametreMethodeLivraison() {
152
		$typesMethodeLivraison = array(self::METHODE_AFFICHAGE, self::METHODE_TELECHARGEMENT);
153
		if (isset($this->parametres['methode']) && !in_array($this->parametres['methode'], $typesMethodeLivraison)) {
154
			$this->erreurs[] = "Le format de methode de livraison ".$this->parametres['methode']." n'est pas acceptée par le service. ".
155
						" Seuls les methodes suivantes sont gérés : ".implode(',', $typesMethodeLivraison);
938 aurelien 156
		} elseif(isset($this->parametres['methode']) && in_array($this->parametres['methode'], $typesMethodeLivraison)) {
930 aurelien 157
			$this->methode_livraison = $this->parametres['methode'];
158
		}
159
	}
160
 
727 alex 161
	private function verifierParametreSource() {
162
		$sourcesDisponibles = explode(',', trim(Config::get('sourcesDonnees')));
163
		if (isset($this->parametres['source'])) {
164
			$sourcesParametre = explode(',', trim($this->parametres['source']));
165
			foreach ($sourcesParametre as $source) {
166
				if (!in_array($source, $sourcesDisponibles)) {
167
					$this->erreurs[] = "La source de données $source n'est pas disponible pour ce service. ".
168
						"Les sources suivantes sont utilisables : ".implode(',', $sourcesDisponibles).".";
169
				} else {
170
					$this->sources[] = $source;
171
				}
172
			}
173
		} else {
174
			$this->sources = $sourcesDisponibles;
175
		}
176
	}
177
 
178
	private function verifierReferentielEtTaxon() {
179
		if (!$this->estReferentielDisponible()) {
180
			$this->erreurs[] = "Le référentiel ".$this->parametres['referentiel']." n'a pas été trouvé. ".
181
				"La liste des référentiels disponibles pour ce service sont : ".Config::get('referentielsDispo');
182
		} else {
183
			$this->referentiel = $this->parametres['referentiel'];
184
			$taxon = $this->recupererInformationsTaxon();
185
			if (is_null($taxon)) {
186
				$this->erreurs[] = "Le taxon d'espèce que vous avez demandé n'a pas été trouvé dans le référentiel.";
187
			} else {
188
				$this->taxon = $taxon;
189
			}
190
		}
191
	}
192
 
193
	private function renvoyerErreurs() {
194
		$message = "Les erreurs suivantes ont été rencontrées : \n".implode('\n', $this->erreurs);
195
		throw new Exception($message, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
196
	}
197
 
198
	private function estReferentielDisponible() {
199
		$referentielsDispo = explode(',', Config::get('referentielsDispo'));
200
		$estDisponible = (isset($this->parametres['referentiel'])
201
			&& in_array($this->parametres['referentiel'], $referentielsDispo));
202
		return $estDisponible;
203
	}
204
 
205
	private function recupererInformationsTaxon() {
206
		$taxon = null;
207
		if (isset($this->parametres['num_taxon'])) {
208
			$numTaxon = $this->parametres['num_taxon'];
209
			$nomTable = $this->recupererNomTableReferentiel();
210
			$bdd = new Bdd();
970 delphine 211
			$requete = "SELECT num_nom, num_nom_retenu, nom_sci, nom_complet, rang, num_taxonomique FROM {$nomTable} ".
727 alex 212
				"WHERE num_taxonomique={$numTaxon} ORDER BY If(num_nom=num_nom_retenu,0,1) LIMIT 0,1";
213
			$taxon = $bdd->recuperer($requete);
214
			if ($taxon === false) {
215
				$taxon = null;
216
			}
217
		}
218
		return $taxon;
219
	}
220
 
221
	private function recupererNomTableReferentiel() {
222
		$tablesReferentiel = explode(',', Config::get('bdd_table_referentiel'));
223
		$nomTable = '';
224
		foreach ($tablesReferentiel as $table) {
225
			if (strstr($table, $this->referentiel) !== false) {
226
				$nomTable = $table;
227
			}
228
		}
229
		return $nomTable;
230
	}
1134 mathias 231
 
232
	/**
233
	 * Va chercher la carte dans le cache si elle existe et n'a pas dépassé la durée
1135 mathias 234
	 * de vie $this->dureeCache; sinon, crée la carte et la met en cache.
235
	 * Avec le paramètre "recalculer=1", on force le vidage du cache et on recrée la carte
1134 mathias 236
	 */
237
	protected function obtenirCarte() {
238
		$carte = null;
239
		$cacheActif = Config::get('cache_miseEnCache');
240
		$cheminCache = Config::get('cache_stockageChemin');
1136 mathias 241
		$extension = "cache"; // par défaut; indique un problème de mimetype demandé par "retour="
242
		if ($this->retour == self::MIME_PNG) {
243
			$extension = "png";
244
		} elseif ($this->retour == self::MIME_MAP) {
245
			$extension = "svg";
246
		}
247
		$cheminCarteEnCache = $cheminCache . $this->referentiel . "-nt-" . $this->taxon['num_taxonomique'] . "." . $extension;
1134 mathias 248
 
1135 mathias 249
		// a-t-on demandé à régénérer la carte de force ?
250
		$recalculer = false;
251
		if (isset($this->parametres['recalculer'])) {
252
			$recalculer = ($this->parametres['recalculer'] === '1');
253
		}
1134 mathias 254
		// le cache est-il actif ?
255
		if ($cacheActif) {
256
			// le fichier existe-t-il en cache ?
257
			//echo "Chemin fichier: $cheminCarteEnCache<br/>";
258
			if (file_exists($cheminCarteEnCache)) {
259
				$limiteDuree = Config::get('cache_dureeDeVie'); // pour ne pas trop faire pipi
260
				$dateFichier = filectime($cheminCarteEnCache);
261
				$age = time() - $dateFichier;
1135 mathias 262
				// si le cache est trop vieux ou qu'on a demandé à recalculer
263
				if (($age > $limiteDuree) || $recalculer) {
264
					// détruire le fichier obsolète
265
					unlink($cheminCarteEnCache);
266
				} else {
1134 mathias 267
					// récupérer le fichier en cache
268
					$carte = file_get_contents($cheminCarteEnCache);
269
				}
270
			}
271
		}
272
		// si la carte n'a pas été trouvée en cache
273
		if ($carte === null) {
274
			// calculer la nouvelle carte
275
			$carte = $this->formerCarte();
276
			// mettre la nouvelle carte en cache
277
			if ($cacheActif) {
278
				file_put_contents($cheminCarteEnCache, $carte);
279
			}
280
		}
281
 
282
		// retour du service
283
		$resultat = new ResultatService();
284
		$resultat->mime = $this->retour;
285
		$resultat->corps = $carte;
286
 
287
		return $resultat;
288
	}
289
 
290
	/**
291
	 * Crée la carte - prend beaucoup de temps
292
	 * @return ResultatService
293
	 */
294
	protected function formerCarte() {
727 alex 295
		$suffixe = 'france_moissonnage';
1034 aurelien 296
 
297
		// le fichier png avec les départements est illisible en petit format
298
		// dans ce cas là un template plus simple est utilisé (sans les départements)
299
		if($this->format < 300 && $this->retour == self::MIME_PNG) {
300
			$suffixe = $suffixe."_sans_departements";
301
		}
302
 
727 alex 303
		$nomFichierSVG = Config::get('chemin')."{$suffixe}.svg";
304
		$this->verifierExistenceFichier($nomFichierSVG);
305
 
306
		$formateur = new FormateurSVG($nomFichierSVG, $this->sources, $this->retour, $this->format);
307
		$formateur->formaterCarte($this->taxon);
308
 
1134 mathias 309
		$resultat = $formateur->renvoyerCarte();
727 alex 310
		return $resultat;
311
	}
312
 
930 aurelien 313
	private function telechargerCarte($fichier) {
314
		if (function_exists('mb_strlen')) {
315
			$taille = mb_strlen($fichier, '8bit');
316
		} else {
317
			$taille = strlen($fichier);
318
		}
319
 
320
		$extension = ($this->retour == "text/html") ? 'html' : 'png';
321
 
322
		header('Content-Description: File Transfer');
323
		header('Content-Type: application/octet-stream');
324
		header('Content-Disposition: attachment; filename="carte.'.$extension.'"');
325
		header('Content-Transfer-Encoding: binary');
326
		header('Connection: Keep-Alive');
327
		header('Expires: 0');
328
		header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
329
		header('Pragma: public');
330
		header('Content-Length: '.$taille);
331
 
332
	}
333
 
727 alex 334
}
335
 
336
?>