WebSVN – eFlore/Projets.eflore-projets – Diff – /trunk/services/modules/0.1/moissonnage/Cartes.php


<?php
 
/**
 * Classe qui remplit un fond cartographique SVG a partir des observations en base de donnees
 * pour un taxon de plante. Elle verifie dans un premier temps la validite des parametres saisis,
 * puis charge le fond cartographique depuis le fichier, recupere dans la base de donnees
 * les observations sur la France metropolitaine pour le taxon donne et remplit la carte
 * en changeant le style CSS des mailles en fonction des coordonnees des points d'observation.
 * Le format et la taille de la carte renvoyee au client est parametrable.
 * 
 * Parametres :
 *   - referentiel : le referentiel taxonomique a interroger pour verifier le taxon. Pour l'instant,
 *     seul bdtfx (Tracheophytes de France metropolirtaine) est utilise par le web service
 *   - num_taxon : le numero taxonomique de la plante dont on veut obtenir la carte de repartition.
 *     Le rang des taxons traites par le web service sont la famille, le genre, l'espece et la sous-espece.
 *     La recherche des observations s'etend en pus sur les sous taxons et les synonymes.
 *   - source : une ou plusieurs sources de donnees a interroger. Si le parametre n'est pas indique,
 *     le web service ira rechercher les observatipons dans toutes les sources de donnees.
 *   - format : la largeur de la carte, exprimee dans une valeur entiere en pixels.
 *     Le ratio largeur:hauteur est conserve lors du redimensionnement de la carte pour le retour
 *   - retour : le type MIME (ou format de fichier) de retour. Sont acceptes par le web service
 *     le PNG (image/png) et le XML (text/html) pour renvoyer le web service
 * 
 * @package framework-0.4
 * @author Alexandre GALIBERT <alexandre.galibert@tela-botanica.org>
 * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
 * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
 * @version $Id$
 * @copyright 2013 Tela Botanica (accueil@tela-botanica.org)
 *
 */
 
class MoissonnageCartes {
 
	const MIME_MAP = "text/html";
	const MIME_PNG = "image/png";
	
	const METHODE_TELECHARGEMENT = "telecharger";
	const METHODE_AFFICHAGE = "afficher";
	
	private $ressources;
	private $parametres;
	
	private $referentiel = '';
	private $taxon   = null;
	private $sources = array();
	private $format  = 0;
	private $retour  = self::MIME_MAP;
	private $methode_livraison = self::METHODE_AFFICHAGE;
	private $erreurs = array();
 
	
	public function consulter($ressources, $parametres) {
		$this->parametres = $parametres;
		$this->ressources = $ressources;
		$resultat = null;
		$this->chargerClassesSousDossier();
		if ($this->analyserRessources() == true) {
			$resultat = $this->formerLegende();
		} else {
			$this->traiterParametres();
			$resultat = $this->obtenirCarte();
			if($this->methode_livraison == self::METHODE_TELECHARGEMENT) {
				$this->telechargerCarte($resultat->corps);
			}
		}
		return $resultat;
	}
	
	private function analyserRessources() {
		$ok = false;
		if (isset($this->ressources[0]) && $this->ressources[0] == 'legende') {
			$ok = true;
		}
		return $ok;
	}
	
	private function formerLegende() {
		$legende = new LegendeCartes();
		$resultat = $legende->obtenirLegende();
		return $resultat;
	}
	
	private function chargerClassesSousDossier() {
		$this->verifierExistenceDossier("cartes");
		$nomDossier = dirname(__FILE__).DS."cartes";
		$dossier = opendir($nomDossier);
		$fichiersAInclure = array();
		while ($fichier = readdir($dossier)) {
			if (filetype($nomDossier.DS.$fichier) == 'file') {
				$fichiersAInclure[] = $nomDossier.DS.$fichier;
			}
		}
		$fichiersAInclure = array_reverse($fichiersAInclure);
		foreach ($fichiersAInclure as $fichier) {
			include_once($fichier);
		}
	}
	
	private function verifierExistenceDossier($nomDossier) {
		$dossier = dirname(__FILE__).DS.$nomDossier;
		if (!file_exists($dossier) || !is_dir($dossier)) {
			$message = "Problème rencontré lors de la génération de la carte : des ressources ".
				"nécessaires au fonctionnement du service n'ont pas été localisées sur le serveur.\n";
			throw new Exception($message);
		}
	}
	
	private function verifierExistenceFichier($nomFichier) {
		if (!file_exists($nomFichier)) {
			$message = "Problème rencontré lors de la génération de la carte : des ressources ".
				"nécessaires au fonctionnement du service n'ont pas été localisées sur le serveur.\n";
			throw new Exception($message);
		}
	}
	
	private function traiterParametres() {
		$this->verifierReferentielEtTaxon();
		$this->verifierParametreSource();
		$this->verifierParametreFormat();
		$this->verifierParametreRetour();
		$this->verifierParametreMethodeLivraison();
		if (count($this->erreurs) > 0) {
			$this->renvoyerErreurs();
		}
	}
	
	private function verifierParametreFormat() {
		if (!isset($this->parametres['format'])) {
			$this->erreurs[] = "Le paramètre format (dimensions) de l'image n'a pas été indiqué dans l'URL du service.";
		} elseif (preg_match('/^[1-9]\d{2}$/', $this->parametres['format']) != 1) {
			$this->erreurs[] = "La valeur du paramètre format n'est pas acceptée par le service. ".
				"Une largeur valide doit être un nombre entier compris entre 100 et 999.";
		} else {
			$this->format = $this->parametres['format'];
		}
	}
	
	private function verifierParametreRetour() {
		$typesMime = array(self::MIME_MAP, self::MIME_PNG);
		if (!isset($this->parametres['retour'])) {
			$this->erreurs[] = "Le paramètre type de retour de l'image n'a pas été indiqué dans l'URL du service.";
		} elseif (!in_array($this->parametres['retour'], $typesMime)) {
			$this->erreurs[] = "Le format de retour ".$this->parametres['retour']." n'est pas acceptée par le service. ".
				" Seuls les types MIME suivants sont gérés : ".implode(',', $typesMime);
		} else {
			$this->retour = $this->parametres['retour'];
		}
	}
	
	private function verifierParametreMethodeLivraison() {
		$typesMethodeLivraison = array(self::METHODE_AFFICHAGE, self::METHODE_TELECHARGEMENT);
		if (isset($this->parametres['methode']) && !in_array($this->parametres['methode'], $typesMethodeLivraison)) {
			$this->erreurs[] = "Le format de methode de livraison ".$this->parametres['methode']." n'est pas acceptée par le service. ".
						" Seuls les methodes suivantes sont gérés : ".implode(',', $typesMethodeLivraison);
		} elseif(isset($this->parametres['methode']) && in_array($this->parametres['methode'], $typesMethodeLivraison)) {
			$this->methode_livraison = $this->parametres['methode'];
		}
	}
	
	private function verifierParametreSource() {
		$sourcesDisponibles = explode(',', trim(Config::get('sourcesDonnees')));
		if (isset($this->parametres['source'])) {
			$sourcesParametre = explode(',', trim($this->parametres['source']));
			foreach ($sourcesParametre as $source) {
				if (!in_array($source, $sourcesDisponibles)) {
					$this->erreurs[] = "La source de données $source n'est pas disponible pour ce service. ".
						"Les sources suivantes sont utilisables : ".implode(',', $sourcesDisponibles).".";
				} else {
					$this->sources[] = $source;
				}
			}
		} else {
			$this->sources = $sourcesDisponibles;
		}
	}
	
	private function verifierReferentielEtTaxon() {
		if (!$this->estReferentielDisponible()) {
			$this->erreurs[] = "Le référentiel ".$this->parametres['referentiel']." n'a pas été trouvé. ".
				"La liste des référentiels disponibles pour ce service sont : ".Config::get('referentielsDispo');
		} else {
			$this->referentiel = $this->parametres['referentiel'];
			$taxon = $this->recupererInformationsTaxon();
			if (is_null($taxon)) {
				$this->erreurs[] = "Le taxon d'espèce que vous avez demandé n'a pas été trouvé dans le référentiel.";
			} else {
				$this->taxon = $taxon;
			}
		}
	}
	
	private function renvoyerErreurs() {
		$message = "Les erreurs suivantes ont été rencontrées : \n".implode('\n', $this->erreurs);
		throw new Exception($message, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
	}
	
	private function estReferentielDisponible() {
		$referentielsDispo = explode(',', Config::get('referentielsDispo'));
		$estDisponible = (isset($this->parametres['referentiel'])
			&& in_array($this->parametres['referentiel'], $referentielsDispo));
		return $estDisponible;
	}
	
	private function recupererInformationsTaxon() {
		$taxon = null;
		if (isset($this->parametres['num_taxon'])) {
			$numTaxon = $this->parametres['num_taxon'];
			$nomTable = $this->recupererNomTableReferentiel();
			$bdd = new Bdd();
			$requete = "SELECT num_nom, num_nom_retenu, nom_sci, nom_complet, rang, num_taxonomique FROM {$nomTable} ".
				"WHERE num_taxonomique={$numTaxon} ORDER BY If(num_nom=num_nom_retenu,0,1) LIMIT 0,1";
			$taxon = $bdd->recuperer($requete);
			if ($taxon === false) {
				$taxon = null;
			}
		}
		return $taxon;
	}
	
	private function recupererNomTableReferentiel() {
		$tablesReferentiel = explode(',', Config::get('bdd_table_referentiel'));
		$nomTable = '';
		foreach ($tablesReferentiel as $table) {
			if (strstr($table, $this->referentiel) !== false) {
				$nomTable = $table;
			}
		}
		return $nomTable;
	}
 
	/**
	 * Va chercher la carte dans le cache si elle existe et n'a pas dépassé la durée
	 * de vie $this->dureeCache; sinon, crée la carte et la met en cache.
	 * Avec le paramètre "recalculer=1", on force le vidage du cache et on recrée la carte
	 */
	protected function obtenirCarte() {
		$carte = null;
		$cacheActif = Config::get('cache_miseEnCache');
		$cheminCache = Config::get('cache_stockageChemin');
		$extension = "cache"; // par défaut; indique un problème de mimetype demandé par "retour="
		if ($this->retour == self::MIME_PNG) {
			$extension = "png";
		} elseif ($this->retour == self::MIME_MAP) {
			$extension = "svg";
		}
		$cheminCarteEnCacheSansExtension = $cheminCache . $this->referentiel . "-nt-" . $this->taxon['num_taxonomique'] . "-" . $this->format . ".";
		$cheminCarteEnCache = $cheminCarteEnCacheSansExtension . $extension;
 
		// a-t-on demandé à régénérer la carte de force ?
		$recalculer = false;
		if (isset($this->parametres['recalculer'])) {
			$recalculer = ($this->parametres['recalculer'] === '1');
		}
		// le cache est-il actif ?
		if ($cacheActif) {
			// le fichier existe-t-il en cache ?
			//echo "Chemin fichier: $cheminCarteEnCache<br/>";
			if (file_exists($cheminCarteEnCache)) {
				$limiteDuree = Config::get('cache_dureeDeVie'); // pour ne pas trop faire pipi
				$dateFichier = filectime($cheminCarteEnCache);
				$age = time() - $dateFichier;
				// si le cache est trop vieux ou qu'on a demandé à recalculer
				if (($age > $limiteDuree) || $recalculer) {
					// détruire le fichier obsolète
					unlink($cheminCarteEnCache);
					// en cas de rechargement forcé, détruire les fichiers cache de même dimension
					// et de formats différents, afin ne pas provoquer d'incohérences
					// @ACHTUNG système minimaliste - si on modifie les dimensions, ça va foirer
					if ($recalculer) {
						foreach (glob($cheminCarteEnCacheSansExtension . "*") as $fichierCacheDeMemeDimension) {
							unlink($fichierCacheDeMemeDimension);
						}
					}
				} else {
					// récupérer le fichier en cache
					$carte = file_get_contents($cheminCarteEnCache);
				}
			}
		}
		// si la carte n'a pas été trouvée en cache
		if ($carte === null) {
			// calculer la nouvelle carte
			$carte = $this->formerCarte();
			// mettre la nouvelle carte en cache
			if ($cacheActif) {
				file_put_contents($cheminCarteEnCache, $carte);
			}
		}
 
		// retour du service
		$resultat = new ResultatService();
		$resultat->mime = $this->retour;
		$resultat->corps = $carte;
 
		return $resultat;
	}
 
	/**
	 * Crée la carte - prend beaucoup de temps
	 * @return ResultatService
	 */
	protected function formerCarte() {
		$suffixe = 'france_moissonnage';
		
		// le fichier png avec les départements est illisible en petit format
		// dans ce cas là un template plus simple est utilisé (sans les départements)
		if($this->format < 300 && $this->retour == self::MIME_PNG) {
			$suffixe = $suffixe."_sans_departements";
		}
		
		$nomFichierSVG = Config::get('chemin')."{$suffixe}.svg";
		$this->verifierExistenceFichier($nomFichierSVG);
		
		$formateur = new FormateurSVG($nomFichierSVG, $this->sources, $this->retour, $this->format);
		$formateur->formaterCarte($this->taxon);
 
		$resultat = $formateur->renvoyerCarte();
		return $resultat;
	}
	
	private function telechargerCarte($fichier) {		
		if (function_exists('mb_strlen')) {
			$taille = mb_strlen($fichier, '8bit');
		} else {
			$taille = strlen($fichier);
		}
		
		$extension = ($this->retour == "text/html") ? 'html' : 'png';
		
		header('Content-Description: File Transfer');
		header('Content-Type: application/octet-stream');
		header('Content-Disposition: attachment; filename="carte.'.$extension.'"');
		header('Content-Transfer-Encoding: binary');
		header('Connection: Keep-Alive');
		header('Expires: 0');
		header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
		header('Pragma: public');
		header('Content-Length: '.$taille);
		
	}
	
}
 
?>

Subversion Repositories eFlore/Projets.eflore-projets

(root)/trunk/services/modules/0.1/moissonnage/Cartes.php – Rev 1136 → 1137

Rev 1136		Rev 1137
1	`<?php`	1	`<?php`
2		2
3	`/**`	3	`/**`
4	`* Classe qui remplit un fond cartographique SVG a partir des observations en base de donnees`	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,`	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`	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`	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.`	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.`	9	`* Le format et la taille de la carte renvoyee au client est parametrable.`
10	`*`	10	`*`
11	`* Parametres :`	11	`* Parametres :`
12	`* - referentiel : le referentiel taxonomique a interroger pour verifier le taxon. Pour l'instant,`	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`	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.`	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.`	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.`	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,`	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.`	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.`	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`	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`	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`	22	`* le PNG (image/png) et le XML (text/html) pour renvoyer le web service`
23	`*`	23	`*`
24	`* @package framework-0.4`	24	`* @package framework-0.4`
25	`* @author Alexandre GALIBERT <alexandre.galibert@tela-botanica.org>`	25	`* @author Alexandre GALIBERT <alexandre.galibert@tela-botanica.org>`
26	`* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>`	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>`	27	`* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>`
28	`* @version $Id$`	28	`* @version $Id$`
29	`* @copyright 2013 Tela Botanica (accueil@tela-botanica.org)`	29	`* @copyright 2013 Tela Botanica (accueil@tela-botanica.org)`
30	`*`	30	`*`
31	`*/`	31	`*/`
32		32
33	`class MoissonnageCartes {`	33	`class MoissonnageCartes {`
34		34
35	`const MIME_MAP = "text/html";`	35	`const MIME_MAP = "text/html";`
36	`const MIME_PNG = "image/png";`	36	`const MIME_PNG = "image/png";`
37		37
38	`const METHODE_TELECHARGEMENT = "telecharger";`	38	`const METHODE_TELECHARGEMENT = "telecharger";`
39	`const METHODE_AFFICHAGE = "afficher";`	39	`const METHODE_AFFICHAGE = "afficher";`
40		40