Subversion Repositories eFlore/Projets.eflore-projets

<?php
/**
*
*  fonctions et paramètres communs aux traitement des syntaxons
*   - traitement de l'ontologie
*   - fonction utiles pour les paramètres de configuration entre autres
*   - traitement des tables et de leur version
*   - traitement de la requête
*
* @package eflore-projets
* @author mathilde Salthun-Lassalle
* @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 SyntaxonsCommun  extends Commun {
        
        
        protected $table = "";
        protected $format_reponse = 'syntaxons';
        protected $serviceNom = 'syntaxons';
        protected $Bdd;
        protected $syn;
        protected $niv;
        protected $limite_requete = array('depart' => 0, 'limite' => 100);
        protected $requete_condition = '';
        protected $total_resultat;
        protected $champs_recherches = ' * ';
        protected $table_version;
        protected $version_projet = '+' ;
        protected $cache = array();     
        
        
        public function __construct(Conteneur $conteneur) {
                $this->Bdd = $conteneur->getBdd();
                $this->syn = $this->getParametreTableauSpe('synonymes');
                $this->niv = $this->getParametreTableauSpe('niveaux');
        }
        

        

        
        //+---------------------------------------------------outils------------------------------------------------//
        protected function getParametreTableauSpe($cle) {
                $tableau = array();
                $parametre = Config::get($cle);
                if (empty($parametre) === false) {
                        $tableauPartiel = explode(',', $parametre);
                        $tableauPartiel = array_map('trim', $tableauPartiel);
                        foreach ($tableauPartiel as $champ) {
                                $tableau[] = trim($champ,"'");// spécificité pour le = ? des synonymes
                        }
                }
                return $tableau;
        }
        
        //la fonction php array_filters ne marche pas sur le serveur
        protected function enleverValeursVides($tableau) {
                $tab = array();
                foreach ($tableau as $cle => $valeur) {
                        if ($valeur != '' && is_int($cle)) {
                                $tab[] = $valeur;
                        } elseif ($valeur != '' && is_string($cle)) {
                                $tab[$cle] = $valeur;
                        }
                }
                return $tab;
        }
        
        //+++------------------------------traitement des versions----------------------------------------++
        
        protected 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);
                }
        }
        
        protected function definirTables() {
                $table_num_version = $this->recupererVersionDisponible();
                $prefixe_table = config::get('bdd_table');
                if ( in_array($this->version_projet,$table_num_version) ) {
                        $this->table_version[] = $prefixe_table.'_v'.$this->version_projet;
                } elseif ($this->version_projet == '+') {
                        $derniere_version = $table_num_version[count($table_num_version) - 1];
                        $this->table_version[] = $prefixe_table.'_v'.str_replace('.', '_', $derniere_version);
                } elseif ($this->version_projet == '*') {
                        foreach ($table_num_version as $num_version) {
                                $this->table_version[] = $prefixe_table.'_v'.str_replace('.', '_', $num_version);
                        }
                } else {
                        $e = "Erreur : La version est inconnue.";
                        throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
                }
        }
        
        //+------------------------------------ontologies----------------------------------------------------+
        
        protected function recupererOntologiesNiveau($valeur, $code){
                $ontologie = array();
                $url = Config::get('url_service_base').Config::get('nom_projet').
                                                        '/ontologies/'.$code.':'.urlencode(urlencode($valeur));
                if(array_key_exists($url, $this->cache)) {
                        $val = $this->cache[$url];
                } else {
                        $val = $this->consulterHref($url);
                        $this->cache[$url] = $val;
                }
                $ontologie['niveau.code'] = $valeur;
                $ontologie['niveau.libelle'] = $val->nom;
                $ontologie['niveau.href'] = $url;
                return $ontologie;
        }
        
        protected  function recupererOntologiesNiveauSyn($niveau){
                $ontologie = array();
                $synonymes = explode(' ',$niveau[1]);
                $libelle = array();
                $detail = array();
                foreach ($synonymes as $syn) {
                        if ($syn == '=') {
                                $syn = 'equi';
                        } elseif ($syn == '= ?') {
                                $syn = 'prob';
                        }
                        if ($syn != '' && $syn != '?') {
                                $detail[] = $this->recupererOntologiesNiveau($syn, 'syn');
                                $dernier = end($detail);
                                $libelle[] = $dernier['niveau.libelle'].' ';
                        }
                }
                $ontologie['niveau.code'] = $niveau[0];
                $ontologie['niveau.libelle'] = 'synonyme '.implode(' - ',$libelle);
                if (isset($niveau[2])) {
                        $ontologie['niveau.libelle'] .= ' '.$niveau[2];
                }
                $ontologie['niveau.detail'] = $detail;
                return $ontologie;
        }
        
        protected function traiterOntologieNiveau($niveau) {
                $ontologie = array();
        
                if ( preg_match('/syn {0,1}(['.implode('',$this->syn).']*)( *\[.+\])*/',$niveau,$retour)) {
        
                        $ontologie = $this->recupererOntologiesNiveauSyn($retour);
        
                } else {
                        $ontologie = $this->recupererOntologiesNiveau($niveau, 'UP');
                }
                return $ontologie;
        }
        
        //+--------------------------FONCTIONS D'ASSEMBLAGE DE LA REQUETE-------------------------------------------+
        
        protected function assemblerLaRequete() {
                $requete =      ' SELECT '.$this->champs_recherches.' FROM '.$this->table.' '
                .$this->retournerRequeteCondition().' '.$this->delimiterResultatsRequete();
        
                return $requete;
        }
        
        protected function calculerTotalResultat() {
                $requete = 'SELECT count(*) as nombre FROM '.$this->table.' '.$this->retournerRequeteCondition();
        
                $res = $this->getBdd()->recuperer($requete);
                if ($res) {
                        $this->total_resultat = $res['nombre'];
                } else {
                        $this->total_resultat = 0;
                        $e = 'Données introuvables dans la base';
                        $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
                }
        }
        
        protected function delimiterResultatsRequete() {
                $this->calculerTotalResultat();
                $requete_limite = '';
                if (($this->limite_requete['depart'] <=  $this->total_resultat) ){
                        if (($this->limite_requete['limite'] + $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;
        }
        
        
        
        protected  function retournerRequeteCondition() {
                $condition = '';
                if (empty($this->requete_condition) == false) {
                        $condition = ' WHERE '.implode(' AND ', $this->requete_condition);
                }
        
                return $condition;
        }

}
?>