Subversion Repositories eFlore/Projets.eflore-projets

<?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);
                
        }
        
}

?>