Subversion Repositories eFlore/Projets.eflore-projets

<?php

/**
 * Classe Informations.php interroge la table Index      
 * et redirige vers une autre classe si besoin 
 * d'interroger une autre table (comme baseflor ou baseflor_rang_sup)
 * elle traite également le retour du web service : /informations
 *  
 * Encodage en entrée : utf8
 * Encodage en sortie : utf8
 * @package eflore-projets
 * @author Mathilde SALTHUN-LASSALLE <mathilde@tela-botanica.org>
 * @author Jean-Pascal MILCENT <jpm@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 1.0
 * @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org)
 * 
 * 
 */

class Informations extends Commun {
        
        protected $limite_requete = array( 'depart' => 0, 'limite' => 10);
        private $tables;
        private $champs_recherches = '*';
        private $requete_jointure = array();
        private $requete_condition = array();
        private $total_resultat;
        protected $serviceNom = 'informations';
        private $masque;
        
        public function consulter($ressources, $parametres) {
                $this->ressources = $ressources;
                $this->parametres =      $parametres;
                $versionResultat = null;
                if (empty($this->ressources)){
                        $this->traiterParametres();
                }
                $this->definirTables(array ('index' => config::get('bdd_table_index'),
                'baseflor' => config::get('bdd_table'),
                'rangSup' => config::get('bdd_table_rang_sup')
                )
                );
                $this->traiterRessources();             
                $requete = $this->assemblerLaRequete();
                // exemple:
                // SELECT * FROM baseflor_index_v2012_12_31 WHERE `bdnt.nn` = 'bdtfx.nn:XXXXX';
                $resultat = $this->Bdd->recupererTous($requete . ' -- ' . __FILE__ . ':' .__LINE__);
                $versionResultat = $this->renvoyerResultat($resultat);
                if ($versionResultat === null) {
                        throw new Exception('Les données recherchées sont introuvables.', RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE);
                }
                return $versionResultat;
        }

        public function __construct() {
                $Conteneur = new Conteneur();
                $this->Bdd = $Conteneur ->getBdd();
        }
        
        public function renvoyerResultat($resultat) {
                if (empty($this->ressources)) return $this->retournerResultatFormate($resultat);
                if(empty($resultat[0]['baseflor'])) {
                        if(@$this->parametres['categorie'] == 'description') {
                                // non-supporté par InformationsTaxonsSup.php...
                                return array();
                        }
                        $info = new InformationsTaxonsSup(new Conteneur());
                        return $info->consulter($this->ressources, $this->parametres);
                }

                $info = new InformationsBaseflor(new Conteneur());
                return $info->consulter($this->ressources, $this->parametres);
        }
        
        
        
        //+--------------------------traitement ressources ou paramètres  -------------------------------------+
        

        public function traiterRessources() {
                if (empty($this->ressources)) { 
                        $this->requete_jointure = array(
                                'LEFT JOIN '. $this->tables['baseflor'].' ON '
                                .$this->tables['baseflor'].".cle =".$this->tables['index'].".baseflor",
                                'LEFT JOIN '. $this->tables['rangSup'].' ON '
                                .$this->tables['rangSup'].".cle = ".$this->tables['index'].".RangSup");
                        
                        $this->champs_recherches = " {$this->tables['baseflor']}.num_nomen as 'baseflor.nn',
                                                {$this->tables['baseflor']}.BDNT as 'baseflor.bdnt', 
                                                {$this->tables['baseflor']}.catminat_code,
                                                {$this->tables['baseflor']}.num_taxon , 
                                                {$this->tables['baseflor']}.nom_sci , 
                                                {$this->tables['rangSup']}.num_nomen as 'rangSup.nn', 
                                                {$this->tables['rangSup']}.bdnt as 'rangSup.bdnt',
                                                {$this->tables['index']}.cle as 'index.cle' ";
                } else {
                        if(preg_match('/^(.+)\.nn:([0-9]+)$/', $this->ressources[0], $retour)){
                                $this->champs_recherches = " baseflor, rangSup ";
                                $this->requete_condition[] = " `bdnt.nn` = '{$retour[0]}'  ";
                        } else {
                                $e = 'Erreur dans l\'url de votre requête : </br> La ressource demandée n\'existe pas.';
                                throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
                                break;
                        }
                }               
        }
        
        
        
        public function traiterParametres() {
                if (isset($this->parametres) && !empty($this->parametres) ) {
                        foreach ($this->parametres as $param => $valeur) {
                                switch ($param) {
                case 'navigation.depart'  :
                    if(!isset($this->parametres['navigation.limite']))
                        throw new Exception("indiquez également la valeur pour le paramètre navigation.limite.",
                        RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
                    $this->definirNavigationDepart($valeur);
                    break;
                case 'navigation.limite'  :
                    if(!isset($this->parametres['navigation.depart']))
                        throw new Exception("indiquez également la valeur pour le paramètre navigation.depart.",
                        RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
                    $this->definirNavigationLimite($valeur);
                    break;
                case 'version.projet' : 
                    $this->traiterVersion($valeur);
                    break;
                case 'masque.cat' :
                    $this->masque = 'catminat='.str_replace('-','/',$valeur);
                    $this->requete_condition[] = " catminat_code = '".str_replace('-','/',$valeur)."' ";
                    break;
                default :
                    $e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " '
                        .$param.' " n\'existe pas.';
                                        $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);     break;
                                }
                        }
                }
        }
        
        
        
        //+++------------------------------traitement des versions----------------------------------------++
        
        public function traiterVersion($valeur) {
                if (preg_match('/^[0-9]+(?:[._][0-9]+)*$/', $valeur) || $valeur == '*' || $valeur == '+') {
                        $this->version_projet = $valeur;
                } else {
                        $e = "Erreur : La version est inconnue.";
                        throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
                }
                if ($this->version_projet == '*' && empty($this->ressources)) {
                        $message = "L'affichage de plusieurs versions ne fonctionne que pour les ressources de type /ressources/#id";
                        $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
                        throw new Exception($message, $code);
                }
        }
        
        public function definirTables($prefixe_table) {
                $table_num_version = $this->recupererVersionDisponible();
                foreach ($prefixe_table as $nom => $prefixe ) {
                        if ( in_array($this->version_projet,$table_num_version) ) {
                                $tables[$nom] = $prefixe.'_v'.$this->version_projet;
                        } elseif ($this->version_projet == '+') {
                                $derniere_version = $table_num_version[count($table_num_version) - 1];
                                $tables[$nom] = $prefixe.'_v'.str_replace('.', '_', $derniere_version);
                        } else {
                                $e = "Erreur : La version est inconnue.";
                                throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
                        }
                }
                $this->tables = $tables;
        }
        

        //+--------------------------formatages de resultats  -------------------------------------------+

        public function retournerResultatFormate($resultat) {
                $resultat_json = array();
                $resultat_json['entete'] = $this->ajouterEnteteResultat();
                $resultat_json['resultats'] = array();
                foreach ($resultat as $ligne => $tab) {
                        $num = $tab['index.cle'];
                        
                        $resultat_json['resultats'][$num]['num_nomen'] = 
                                (empty ($tab['baseflor.nn'])) ? $tab['rangSup.nn'] : $tab['baseflor.nn'];
                        
                        $resultat_json['resultats'][$num]['bdnt'] =
                                (empty ($tab['baseflor.bdnt'])) ? $tab['rangSup.bdnt'] : $tab['baseflor.bdnt'];
                        
                        $resultat_json['resultats'][$num]['catminat_code'] =
                                (empty ($tab['catminat_code'])) ? '' : $tab['catminat_code'];
                        
                        $resultat_json['resultats'][$num]['nom_sci'] =
                                (empty ($tab['nom_sci'])) ? '' : $tab['nom_sci'];
                        
                        $resultat_json['resultats'][$num]['num_taxon'] =
                                (empty ($tab['num_taxon'])) ? '' : $tab['num_taxon'];
                        
                        if ($resultat_json['resultats'][$num]['num_nomen'] != 0) {
                                $bdnt = strtolower($resultat_json['resultats'][$num]['bdnt']);
                                $nn = $resultat_json['resultats'][$num]['num_nomen'];
                                $resultat_json['resultats'][$num]['href'] =
                    $this->ajouterHref('informations',$bdnt.".nn:".$nn);
                        }
                }
                return $resultat_json;
        }
        
        
        public function ajouterEnteteResultat() {
                $entete['depart'] = $this->limite_requete['depart'];
                $entete['limite'] = $this->limite_requete['limite'];
                $entete['total']  =      $this->total_resultat;
                if ($this->masque) {
                        $entete['masque']  =  $this->masque;
                }
                $entete['version']      = $this->version_projet;
                $url = $this->formulerUrl($this->total_resultat, '/informations');
                if (isset($url['precedent']) && $url['precedent'] != '') {
                        $entete['href.precedent'] = $url['precedent'];
                }
                if (isset($url['suivant']) && $url['suivant'] != '') {
                        $entete['href.suivant']   = $url['suivant'];
                }
                return $entete;
        }
        
        
        //+-------------------------------------assemblage de requête------------------------------------//
        
        
        public function assemblerLaRequete() {
                $requete =      ' SELECT '.$this->champs_recherches.
                        ' FROM '.$this->tables['index'].' '
                        .self::retournerRequeteJointure($this->requete_jointure).' '
                        .self::retournerRequeteCondition($this->requete_condition).' '
                        .$this->delimiterResultatsRequete();
                return $requete;
        }

        static function retournerRequeteCondition($cond) {
                return $cond ? (' WHERE '.implode(' AND ', $cond)) : '';
        }
        
        
        static function calculerTotalResultat($db, $table, Array $join, Array $cond) {
                $requete = sprintf(
                        'SELECT count(*) as nombre FROM %s %s %s -- %s:%d',
                        $table,
                        $join ? implode(' ', $join) : '',
                        $cond ? (' WHERE '.implode(' AND ', $cond)) : '',
                        __FILE__,
                        __LINE__);
                $res = $db->recuperer($requete);
                if ($res && $res['nombre']) return $res['nombre'];
                throw new Exception('Données introuvables dans la base', RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE);
        }
        
        public function delimiterResultatsRequete() {
                $this->total_resultat = self::calculerTotalResultat(
                        $this->getBdd(),
                        $this->tables['index'],
                        $this->requete_jointure,
                        $this->requete_condition);
                $requete_limite = '';
        if (($this->limite_requete['depart'] <=  $this->total_resultat) ){
            if ( $this->limite_requete['depart'] < $this->total_resultat  ){
                $requete_limite = 'LIMIT '.$this->limite_requete['depart'].', '
                                        .$this->limite_requete['limite'];
            }
        } else {
            $e = "Erreur : la valeur pour le paramètre navigation.départ est supérieure".
                " au nombre total de résultats.";
            throw new Exception($e, RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE);
        }
                return $requete_limite;
        }
        
        static function retournerRequeteJointure($join) {
                return $join ? implode(' ', $join) : '';
        }
        
}