Subversion Repositories eFlore/Projets.eflore-projets

Rev

Blame | Last modification | View Log | RSS feed

<?php

abstract class CommunNomsTaxons extends Commun {
                
        protected $table_param = array(); /** Permet de stocker le tableau des parametres (= $parametres) */
        protected $table_ressources = array(); /** Permet de stocker le tableau des ressources (= $ressources) */
        protected $table_retour; /** Permet de stocker le tableau de résultat (non encodé en json)*/
        protected $resultat_req; /** Permet de stocker le résultat de la requete principale. */
        /** Permet de stocker sous forme de tableau les composant du nom à ajouter au nom scientifique (fonction du paramètre ns.structure) */
        protected $compo_nom;
        protected $ordre_masque = array('masque', 'masque_sg', 'masque_gen', 'masque_sp', 'masque_ssp', 'masque_au',
                'masque_an', 'masque_bib', 'masque_ad', 'masque_nn', 'masque_rg' );
        protected $tab_nom_sci   = array('nom_supra_generique', 'genre', 'epithete_infra_generique', 'epithete_sp', 
                'type_epithete', 'epithete_infra_sp', 'cultivar_groupe', 'cultivar', 'nom_commercial'); 
        protected $retour_format = 'max';
        protected $html                  = 'txt'; /** Valeur du paramètre de requete ns.format */
        protected $table_version; /** Stocke les noms des tables de toutes les versions du projet disponibles */
        /** Nom de la table dans laquelle on récupèrera les données (remplace Config::get('bdd_table') dans les requetes SQL */
        protected $table;
        protected $total_resultat = null;
         /** Stocke le service appelé correspondant. Est utilisé principalement lors de l'affichage du href d'un synonyme
          (ex id=12, basionyme num 25 est un synonyme) dans le service taxon */
        protected $service_href = null;
        
        
//----------------------------------Fonctions d'analyse des ressources--------------------------------------------------
                
        /** Permet de remplir la variable version_projet et de retirer cette donnée du tableau des ressources */
        public function traiterVersionProjet(&$ressources) {
                if (isset($ressources) && !empty($ressources)) {
                        if (preg_match('/(?:[0-9]+(?:_|[.])[0-9]+|[*])/', $ressources[0])) {
                                $this->version_projet = array_shift($ressources);
                                $this->version_projet = str_replace('_', '.', $this->version_projet);
                        } else {
                                if ($ressources[0] == ' ') array_shift($ressources); //si un + a été ajouté
                                $this->version_projet = '+';
                        }
                }
                //si la liste des noms est demandée pr toutes les versions, on affiche seulement la dernière version pour :
                // - la liste des noms et taxons: /noms et /taxons
                // - la liste des taxons inferieurs/supérieur : /taxons/relations/inferieurs et /taxons/relations/superieurs
                // - la liste des relations : /taxons/relations ou /noms/relations
                if ($this->version_projet == '*' && ($ressources == array() 
                        || (isset($ressources[1]) && $ressources[1] == 'relations' && isset($ressources[2]) && in_array($ressources[2], array('superieurs', 'inferieurs')))
                        || (isset($ressources[1]) && $ressources[1] == 'relations' && !isset($ressources[2])) )) {
                        $this->version_projet = '+'; 
                }
                //on recupère les versions du projet disponible dans la table des meta-donnees (utilisation service MetaDonnees)
                $table_num_version = $this->recupererVersionDisponible(); 
                //on recupere la liste des noms des tables de la bdd correspondant aux differentes versions du projet en fct de la ou les versions demandées
                $this->recupererListeNomTablePrChaqueVersion($table_num_version);
        }
        
        
        public function traiterRessources($ressources) { 
                $this->table_ressources = $ressources;
                if (isset($ressources) && !empty($ressources)) {
                        if ($this->estUnIdentifiant()) { //l'identifiant peut etre de type /#id ou /nt:#id
                                $this->traiterRessourcesIdentifiant(); // dans le service noms ou taxons
                        } elseif ($this->table_ressources[0] == 'stats') { //ressource = noms/stats
                                $this->traiterRessourcesStats();
                        } else {
                                $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
                                        'Erreur dans votre requete </br> Ressources disponibles : <br/>
                                        <li> /'.$this->service.'/#id (id : L\'identifiant du nom rechercher)</li>  
                                        <li> /'.$this->service.'/nt:#id (id : Numero du taxon recherche)</li>
                                        <li> /'.$this->service.'/stats </li>' );
                        }
                }
        }
        
        
        public function traiterRessourcesStats() {
                $this->format_reponse = $this->service.'/stats';
                if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) {
                        switch ($this->table_ressources[1]) {
                                case 'annees'    : 
                                        $this->traiterRessourceStatsAnnees();    
                                        break;
                                case 'rangs'     : 
                                        $this->traiterRessourceStatsRangs();     
                                        break;
                                case 'initiales' : 
                                        $this->traiterRessourceStatsInitiales(); 
                                        break;
                                default                  : 
                                        $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
                                                'Erreur dans votre requete </br> Ressources disponibles : <br/>
                                                <li> /'.$this->service.'/stats/annees </li>  
                                                <li> /'.$this->service.'/stats/rangs </li>
                                                <li> /'.$this->service.'/stats/initiales </li>' ); 
                                        break;
                        }
                } else {
                        $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
                                  'Erreur dans votre requete </br> Ressources disponibles : <br/>
                                 <li> /'.$this->service.'/stats/annees </li>  
                                 <li> /'.$this->service.'/stats/rangs </li>
                                 <li> /'.$this->service.'/stats/initiales </li>' );
                }
        }
        
        
        /** Vérifie si la première valeur de la table de ressource est un identifiant : un numerique ou un numéro 
         * taxonomique sous la forme nt:xx */
        public function estUnIdentifiant() {
                return (is_numeric($this->table_ressources[0]) || (strrpos($this->table_ressources[0],'nt:') !== false 
                                && is_numeric(str_replace('nt:','',$this->table_ressources[0]))));
        }
        
//---------------------------------------------Fonction d'analyse des parametres----------------------------------------
        
        /** Permet de remplir le tableau compo_nom. Il comprendra en fct du paramètre ns.structure les éléments à rajouter 
         * au nom_sci (annee, auteur, biblio ou addendum).*/
        public function remplirTableCompositionNom($valeur) {
                $structure_nom = explode(",",$valeur); 
                foreach ($structure_nom as $structure) {
                        switch ($structure) {
                                case 'au'       :       $this->compo_nom['au']  = 'auteur';                     break;
                                case 'an'       :       $this->compo_nom['an']  = 'annee';                              break;
                                case 'bib'      :       $this->compo_nom['bib'] = 'biblio_origine';             break;
                                case 'ad'       :       $this->compo_nom['ad']  = 'nom_addendum';               break;
                                default         :       $this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
                                                                        'Erreur : Le parametre "'.$structure.'" n\'existe pas. <br/><br/>
                                                                        Les parametres du nom possibles sont : <li> au (auteur)</li><li> an (annee)</li> 
                                                                        <li> bib (bibliographie)</li><li> ad (nom_addendum)</li>'); 
                                                                                                                                                                break;
                        }
                }
        }
        
        
        /** Permet de recupérer le nom scientigfique au format html. Le champ nom_sci de la requete sql est remplacé par 
         * le champ nom_sci_html */
        public function mettreAuFormat() {
                if ($this->html == 'htm') {
                        if (strrpos($this->requete_champ, 'nom_sci_html as nom_sci') === false) {
                                $this->requete_champ = str_replace('nom_sci', 'nom_sci_html as nom_sci', $this->requete_champ);
                        }
                } elseif ($this->html != 'txt') {
                        $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
                                'Erreur dans votre requete </br> ns.format = htm ou txt (par defaut)' );
                }
        }

//--------------------------------fonctions de formatage----------------------------------------------------------

        /** Fonction permettant de creer la table dont le nom est passé en paramètre (champs_api, champs_bdtfx,
         * correspondance_champs...). Les données de chaque table sont présentes dans le fichier de configuration config.ini
         * @param String $table : Peut contenir plusieurs nom de table dont on souhaite récupérer les données : table,table,table.
         *  Ex : recupererTableSignification('champs_api,champs_bdtfx') */
        public function recupererTableSignification($table) {
                $tables = explode(',', $table);
                foreach ($tables as $tab) {
                        if ($tab == 'champs_comp') {
                                $champ_bdnff_api = array_keys($this->champs_api); //on recupère le nom des champ ds la bdd
                                $this->champs_comp = array_diff($this->champs_table, $champ_bdnff_api);
                        } elseif ($tab == 'champs_api') {
                                foreach ($this->correspondance_champs as $key => $val) {
                                        preg_match('/(hybride[.]parent_0[12](?:[.]notes)?|nom_sci[.][^.]+|[^.]+)(?:[.](id|code))?/', $val, $match);
                                        $val = $match[1];
                                        $this->champs_api[$key] = $val;
                                }
                        } else {
                                $tableau = explode(',', Config::get($tab));
                                $tableau = array_map('trim', $tableau);
                                foreach ($tableau as $champ) {
                                        list($code, $rang) = explode('=', $champ);
                                        $tab_tampon[$code] = $rang;     
                                }
                                $this->$tab = $tab_tampon;
                                $tab_tampon = array();
                        }
                }
        }
        
        
        public function formaterEnOss($resultat) {
                $res = array();
                $table_nom = array(); 
                foreach ($resultat as $version => $res_version) {
                        $oss = ''; 
                        foreach ($res_version as $tab) {
                                
                                if (isset($tab['nom_sci']) ) {
                                        if (!in_array($tab['nom_sci'], $table_nom)) {
                                                $table_nom[] = $tab['nom_sci'];
                                                $oss [] = $tab['nom_sci'].$this->ajouterCompositionNom($tab);
                                        }
                                }
                        }
                        $masque = $this->ordonnerMasque();
                        if ($masque == '') $masque = 'Pas de masque';
                        $table_retour_oss = array($masque, $oss);
                        //Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
                        $res = $this->afficherVersionOuPas($version, $table_retour_oss, $res);
                }
                return $res;    
        }
        
        
        /** Permet de récupérer le masque de rang superieur parmi les parametres de la requete.
         * Sera affiche dans l'entete du fichier json (clé 'masque') et oss.
         * @return string le masque de rang supérieur ou '' si aucun masque n'a été mis en parametre de 
         * requete (la clé masque ne sera alors pas affichée dans l'entete).*/
        public function ordonnerMasque() {
                $masque = '';
                foreach ($this->ordre_masque as $key => $filtre) {                      
                        if (isset($this->table_param[$filtre])) {
                                $masque .= '&'.$filtre.'='.$this->table_param[$filtre]; 
                        }
                }
                $masque = ltrim($masque, '&'); //on enlève le & du début 
                $masque = str_replace('masque_','',$masque);
                return $masque;
        }
        
        
        /** Affiche l'entete du résultat pour le service /noms et /noms/relations. L'entete comprend le rang (s'il est un 
         * filtre), le départ, la limite, le total des résultats et les urls suivante et precedente. */
        public function afficherEnteteRangBorneTotalUrls($resultat, $url_service) {
                if (isset($this->table_param['masque_rg'])) $this->afficherDonnees('rang', $this->table_param['masque_rg']);
                $this->table_retour['depart'] = $this->limite_requete['depart'];
                $this->table_retour['limite'] = $this->limite_requete['limite'];
                $this->table_retour['total']  = $this->total_resultat;
                //formuler les urls precedentes et suivantes
                $url = $this->formulerUrl($this->total_resultat, $url_service);
                if ($url['precedent'] != '') { $this->table_retour['href.precedent'] = $url['precedent']; }
                if ($url['suivant']   != '') { $this->table_retour['href.suivant']   = $url['suivant']; }
        }
        
//----------------------------Fonction de formatage pour les services /#id/---------------------------------------------
        /** Ajout du numero de la version au tableau de résultat à retourner : 
         * 'bdtfx_v2_00' : {'infos' : 'toto' ...}, 'bdtfx_v3_00' : {'infos' : 'tata' ...}
         * @param string $num_version : numéro de version (sous la forme de l'intitulé du nom de la table bdd)
         * @param array $tab : tableau contenant le resultat à retourner pour une version donnée
         * @param array $res : tableau contenant le resultat à retourner pour toutes les versions disponibles */
        public function afficherVersionOuPas($version, &$tab, &$res) {
                if (count($this->table_version) > 1) {
                        $res[$version] = $tab;
                        $tab = array();
                } else {
                        $res = $tab;
                }
                return $res;
        }
        
        
        public function formaterId($resultat) { 
                $this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
                $res = array();
                foreach ($resultat as $version => $res_version) {
                        $res_version = $res_version[0];
                        $this->resultat_req = $res_version;
                        foreach ($res_version as $key => $valeur) {
                                if ($valeur != '') {
                                        $this->afficherDonnees($key, $valeur);
                                }
                        }
                        unset($this->table_retour['href']); 
                        //Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
                        $res = $this->afficherVersionOuPas($version, $this->table_retour, $res);
                }
                return $res;
        }
        
        
        public function formaterIdChamp($resultat) {
                $this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
                $res = array();
                foreach ($resultat as $version => $res_version) {
                        $res_version = $res_version[0];
                        $this->resultat_req = $res_version;     
                        $this->table_retour['id'] = $res_version['num_nom']; 
                        //on récupère les champs (le + est transformé en espace par le navigateur)
                        $tab_ress = explode(' ', $this->table_ressources[1]); 
                        foreach ($tab_ress as $nom_champ_api) { 
                                if ($this->verifierValiditeChamp($nom_champ_api)) {
                                        switch ($nom_champ_api) {
                                                case 'nom_sci'   : $this->afficherNomSci($res_version); break;
                                                case 'nom_sci.*' : $this->afficherNomSciPointEpithete($res_version); break;
                                                case 'hybride.*' : 
                                                        $this->afficherChamps('hybride.parent_01.*', $res_version['hybride_parent_01']);
                                                        $this->afficherChamps('hybride.parent_02.*', $res_version['hybride_parent_02']); break;
                                                default : 
                                                        $this->afficherChamps($nom_champ_api, 
                                                        $res_version[$this->trouverChampBddCorrespondant($nom_champ_api)]); break;
                                        }
                                }
                        }
                        //Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
                        $res = $this->afficherVersionOuPas($version, $this->table_retour, $res);
                }
                return $res;
        }       
        
        /** Les champs passés dans l'url lors de la requete /noms|taxons/#id/#champ+#champ son sous la forme de l'api.
         * Les noms de l'api ne st pas les meme que ceux des champs de la base de données. 
         * Cette fct permet de récupérer le nom du champs de la base de données */
        public function trouverChampBddCorrespondant($champ) {
                $radical_champ = $champ; 
                if ($this->estUnPoint($champ) && strrpos($champ, '.notes') === false) {
                        preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match);
                        $radical_champ = $match[1];
                }
                // - Soit un champ de l'api est recherché (pour les champs du référentiel : les noms des champs ont été modifiés),
                // - Soit un champ complementaire de la bdnff (les noms de ces champs complementaire sont les memes que ds la base)
                if ($this->estChampApi($radical_champ)) {
                        $champ_bdd = array_search($radical_champ, $this->champs_api);
                } elseif ($this->estDansBdnff($radical_champ)) {
                        $champ_bdd = $radical_champ; 
                } else {
                        $this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
                        'Fct trouverChampBddCorrespondant : Le parametre "'.$radical_champ.'" n\'existe pas. <br/><br/>'); 
                }
                return $champ_bdd;
        }
        
        
        /** Permet d'afficher des informations précisées des données liées. Utilisé par le service id/champ  
         * lors de l'appel d'un champ tel que : champ.id, champ.code, champ.*, champ.href. */
        public function afficherChamps($champ, $valeur) {
                $reponse = $this->table_retour; 
                $this->table_retour = array();
                if ($valeur == '') {
                        $this->table_retour[$champ] = null;
                } else {
                        preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match);
                        //si on a un point etoile
                        if (isset($match[2]) && $match[2] == '*') {
                                $this->afficherPointEtoile($match[1], $valeur);
                        //si le champ comprend plusieurs identifiants : pour le champ proparte (liste ou .details recherché, pas de .href)
                        } elseif ($this->presentePlusieursId($match[1], $valeur)) { 
                                if (isset($match[2]) && $match[2] != 'id') {
                                        $this->afficherInfosPrecises($match[1], $match[2], $valeur);
                                } else {
                                        $this->table_retour[str_replace('.id', '', $champ)] = $valeur;
                                }
                        //si on est en présence d'une donnée liée (la donnée représente un identifiant ou un code)
                        } elseif ($this->correspondAUnId($match[1]) || $champ == 'id' || $this->correspondAUnCode($match[1])) {
                                if (isset($match[2])) { //si un .id, un .code ou un .href est demandé : 
                                        $this->afficherInfosPrecises($match[1], $match[2], $valeur);
                                } else { 
                                        $this->afficherInfosPrecises($match[1], 'signification', $valeur);
                                }
                        //sinon on affiche tel quel
                        } else {
                                $this->table_retour[$champ] = $valeur;
                        }
                }
                $this->table_retour = array_merge($reponse, $this->table_retour);
        }

        
        /**Vérifie la validité d'un champ passé dans la requete /#id/#champ+#champ */
        public function verifierValiditeChamp($champ) {
                preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match);
                $radical_champ = $match[1]; 
                $validite_ressource = true;
                //on verifie si le nom du champ existe bien
                if (!$this->estChampApi($radical_champ) && !$this->estDansBdnff($radical_champ)) {
                        $validite_ressource = false;
                        $this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
                                'Fct verifierValiditeChamp : Le parametre "'.$radical_champ.'" n\'existe pas. <br/><br/>');
                } elseif ($this->estUnPoint($champ)) {
                        $suffixe = $match[2];
                        //On verifie les suffixes pour les identifiants
                        if ($this->correspondAUnId($radical_champ) || $radical_champ == 'id') {                         
                                $this->verificationSuffixesIdentifiant($suffixe, $radical_champ, $validite_ressource);
                        //On verifie les suffixes pour les codes
                        } elseif ($this->correspondAUnCode($radical_champ)) {
                                $this->verficationSuffixesCodes($suffixe, $radical_champ, $validite_ressource);
                        } elseif ($radical_champ == 'nom_sci' && $suffixe != '*') {
                                $this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
                                'Erreur : Le suffixe demand&eacute; n\'existe pas pour le champ "'.$radical_champ.'".<br/> 
                                Les suffixes possibles sont les suivants : <li> * </li>');
                        } else {
                                $validite_ressource = false;
                                $this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
                                        'Erreur : Le parametre "'.$radical_champ.'" ne peut pas pr&eacute;senter de suffixe. <br/><br/>');
                        }
                }
                return $validite_ressource;
        }       
        
        
        public function verficationSuffixesCodes(&$suffixe, &$radical_champ, &$validite_ressource ) {
                if (!in_array($suffixe, array('*', 'code', 'href', 'details'))) {
                        $validite_ressource = false;
                        $this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
                                'Erreur : Le suffixe demand&eacute; n\'existe pas pour le champ "'.$radical_champ.'.<br/> 
                                Les suffixes possibles sont les suivants : 
                                <li> .* </li><li> .code </li><li> .href </li><li> .details </li>');
                }
        }
        
        
        public function verificationSuffixesIdentifiant(&$suffixe, &$radical_champ, &$validite_ressource) {
                if ((strrpos($radical_champ, 'parent') !== false && !in_array($suffixe, array('*', 'id', 'href', 'details', 'notes')))
                        || !in_array($suffixe, array('*', 'id', 'href', 'details')) && strrpos($radical_champ, 'parent') === false) {
                        $validite_ressource = false;
                        $this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
                                'Erreur : Le suffixe demand&eacute; n\'existe pas pour le champ "'.$radical_champ.'".<br/> 
                                Les suffixes possibles sont les suivants : 
                                <li> .* </li><li> .id </li><li> .href </li><li> .details </li><li> .notes (seulement pour les hybride.parent)');
                }
        }
        
        
//------------------------------fonction de formatage pour les services /stats/-----------------------------------------
        
        public function formaterStatsAnnee($resultat) {
                $res = array();
                foreach ($resultat as $version => $res_version) {
                        foreach ($res_version as $cle_annee) {
                                foreach ($cle_annee as $key => $val) {
                                         switch($key) {
                                                case 'annee' : $annee = ($val != '') ? $val : 'N.D.';   break;
                                                case 'nombre': $nb = $val;                                                              break;
                                                default : break;
                                         }
                                }
                                $retour_stats_annee[$annee] = $nb;
                        }
                        //Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
                        $res = $this->afficherVersionOuPas($version, $retour_stats_annee, $res);
                }
                return $res;
        }
        
        
        public function formaterStatsRang($resultat) {  
                $res = array();
                foreach ($resultat as $version => $res_version) {
                        foreach ($res_version as $rangs) {      
                                if ($rangs['rang'] != 0) {
                                        foreach ($rangs as $key => $val) {
                                                switch ($key) {
                                                        case 'rang'     : $rang         = $val;         break;
                                                        case 'nombre'   : $nombre       = $val;         break;
                                                        default : break;
                                                }
                                        }
                                        $retour_rang[$rang] = array(
                                                'rang'   => $this->ajouterSignificationCode('rang', $rang),
                                                'nombre' => $nombre
                                        );
                                }
                        }
                        //Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
                        $res = $this->afficherVersionOuPas($version, $retour_rang, $res);
                }
                return $res;            
        }
        
        
        public function formaterStatsInitiales($resultat) {
                $res = array();
                $table_rang = array();
                foreach ($resultat as $version => $res_version) {
                        foreach ($res_version as $tuple) { 
                                if ($tuple['rang'] != 0) {
                                        if (!isset($table_rang[$tuple['rang']])) {
                                                $rang = $this->ajouterSignificationCode('rang', $tuple['rang']);
                                                $table_rang[$tuple['rang']] = $rang;
                                        } else {
                                                $rang = $table_rang[$tuple['rang']];
                                        }
                                        if ($tuple['lettre'] == 'x ') {
                                                if (isset($this->table_retour[$rang]['hyb'])) {
                                                        $this->table_retour[$rang]['hybride'] += floatval($tuple['nb']);
                                                } else {
                                                        $this->table_retour[$rang]['hybride'] = floatval($tuple['nb']);
                                                }
                                        } elseif ($tuple['lettre'] == '+ ') {
                                                if (isset($this->table_retour[$rang]['chimère'])) {
                                                        $this->table_retour[$rang]['chimère'] += floatval($tuple['nb']);
                                                } else {
                                                        $this->table_retour[$rang]['chimère'] = floatval($tuple['nb']);
                                                }
                                        } else {
                                                $l = substr($tuple['lettre'], 0, 1);
                                                if (isset($this->table_retour[$rang][$l])) {
                                                        $this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] += floatval($tuple['nb']);
                                                } else {
                                                        $this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] = floatval($tuple['nb']);
                                                }
                                        }
                                }
                        }
                        //Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
                        $res = $this->afficherVersionOuPas($version, $this->table_retour, $res);
                }
                return $res;
        }
        
        
        //-----------------------------Fonctions d'affichage utiliser dans les fonctions de formatage---------------------------
        
        /** Affiche les résultats en fonction du paramètre retour_format. */
        public function afficherDonnees($key, $valeur) {
                //on souhaite afficher le nom au format de l'api
                if ($this->retour_format == 'min') {
                        if ($this->correspondAChampApi($key)) { //on affiche l'intitulé selon decrit dans l'api
                                if ($key == 'nom_sci') $valeur = $valeur.$this->ajouterCompositionNom($this->resultat_req);
                                $this->table_retour[$this->correspondance_champs[$key]] = $valeur;
                        } else {
                                $this->table_retour[$key] = $valeur;
                        }
                } else {
                        if ($this->correspondAChampApi($key)) {
                                $nom_champ_api = $this->correspondance_champs[$key]; //on récupere le nom comme définit ds l'api
                                $this->afficherToutesLesInfos($nom_champ_api, $valeur);
                        } elseif ($this->estDansBdnff($key)) {
                                $this->table_retour[$key] = $valeur;
                        } 
                }
        }
                
        
        public function afficherToutesLesInfos($nom_champ_api, $valeur) {
                if ($this->presentePlusieursId($nom_champ_api, $valeur)) {
                        preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match);
                        $this->afficherInfosPrecises($match[1], 'details', $valeur);
                        $this->table_retour[$nom_champ_api] = $valeur;
                } elseif (strrpos($nom_champ_api, 'parent') !== false && strrpos($nom_champ_api, 'notes') !== false) {
                        $this->table_retour[$nom_champ_api] = $valeur;
                } elseif (($this->correspondAUnId($nom_champ_api) || $nom_champ_api == 'id') && $valeur != '0') {
                        preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match); 
                        $this->afficherInfosPrecises($match[1], 'id,signification,href', $valeur);
                } elseif ($this->correspondAUnCode($nom_champ_api)) {
                        preg_match('/^([^.]+)(?:\.code)?$/', $nom_champ_api, $match);
                        $this->afficherInfosPrecises($match[1], 'code,signification,href', $valeur);
                }
        }
        
        
        public function presentePlusieursId($ressource, $valeur = null) {
                if ($valeur) {
                        $presente = strrpos($ressource, 'proparte') !== false && strrpos($valeur, ',') !== false;
                } else { //pour la vérification du champ, on ignore alors la valeur de la ressource
                        $presente = strrpos($ressource, 'proparte') !== false;
                }
                return $presente;
        }
        
        
        public function afficherTableDetails($nom_champ_api, $valeur) {
                $tab_id = explode(',',$valeur);
                $tab_res = $this->table_retour;
                $this->table_retour = array();
                foreach ($tab_id as $id) {
                        $this->afficherInfosPrecises($nom_champ_api, 'id,signification,href', $id); 
                        $tab_res[$nom_champ_api.'.details'][] = $this->table_retour;
                        $this->table_retour = array();
                }
                $this->table_retour = $tab_res;
        }
        
        
        public function afficherPointEtoile($champ, $valeur) {
                if ($this->presentePlusieursId($champ, $valeur)) { 
                        $this->afficherInfosPrecises($champ, 'details', $valeur);
                        $this->table_retour[$champ] = $valeur;
                } elseif (strrpos($champ, 'parent') !== false) {
                        $this->afficherInfosPrecises($champ, 'id,href,notes', $valeur);
                } elseif ($this->correspondAUnId($champ) || $champ == 'id') {
                        $this->afficherInfosPrecises($champ, 'id,href', $valeur);
                } elseif ($this->correspondAUnCode($champ)) {
                        $this->afficherInfosPrecises($champ, 'code,href', $valeur);
                } 
        }
        
        
        public function afficherInfosPrecises($champ, $suffixe, $valeur) {
                $suffixes = explode(',', $suffixe);
                //on initialise au service appelé. Sera potentiellement modifié dans la fonction afficherSignification()
                $this->service_href = $this->service; 
                foreach ($suffixes  as $suff) {
                        switch ($suff) {
                                case 'id'                        : 
                                        $this->table_retour[str_replace('id.id', 'id', $champ.'.id')] = $valeur; 
                                        break;
                                case 'details'           : 
                                        $this->afficherTableDetails($champ, $valeur); 
                                        break;
                                case 'signification' : 
                                        $this->afficherSignification($champ, $valeur); 
                                        break;
                                case 'href'              : 
                                        if ($this->correspondAUnId($champ) || $champ == 'id') {
                                                $service = $this->service_href;
                                                $url = $this->ajouterHref($service, $valeur);
                                        } else {
                                                $service = 'ontologies';
                                                $champ_url = $champ;
                                                $url = $this->ajouterHrefAutreProjet($service, $val, $champ_url);
                                        }
                                        $this->table_retour[str_replace('id.href', 'href', $champ.'.href')] = $url; 
                                        break;
                                case 'code'              : 
                                        $val = ( $champ == 'rang' ) ? 'bdnt.rangTaxo:'.$valeur : 'bdnt.'.rtrim($champ, '_Ga,_Co').':'.$valeur;
                                        $this->table_retour[$champ.'.code'] = $val; 
                                        break;
                                case 'notes'             : 
                                        $this->table_retour[$champ.'.notes'] = $this->resultat_req[str_replace('.', '_', $champ).'_notes']; 
                                        break;
                                default                          : 
                                        break;
                        }
                }
        }
        
        
        public function afficherSignification($champ, $valeur) {
                if ($champ == 'id' && isset($this->resultat_req['nom_sci']) && $this->resultat_req['num_nom'] == $valeur) {
                        //si le nom_sci du num_nom que l'on veut afficher est déjà dans la table de résultat : 
                        $this->table_retour['nom_sci'] = $this->resultat_req['nom_sci'].$this->ajouterCompositionNom($this->resultat_req);
                } elseif ($this->correspondAUnId($champ) || $champ == 'id') {
                        $nom = $this->recupererNomSci($valeur);
                        $champ = ($champ == 'id') ? 'nom_sci' : $champ;
                        if ($nom != array()) {
                                $this->table_retour[$champ] = $nom['nom_sci'];
                                $this->service_href = $nom['service'];
                        }
                } elseif ($this->correspondAUnCode($champ)) {
                        $this->table_retour[$champ] = $this->ajouterSignificationCode($champ, $valeur);
                }
        }
        
        
        /** Permet d'afficher les élements nomenclatural du nom_sci lors de l'appel dans le service noms/id/champ du champ^nom_sci.*/
        public function afficherNomSciPointEpithete($resultat) {
                foreach ($this->tab_nom_sci as $compo_nom) {
                        if (isset($resultat[$compo_nom]) && !empty($resultat[$compo_nom])) {
                                $this->table_retour['nom_sci.'.$compo_nom] = $resultat[$compo_nom];
                        }
                }
        }
        
        /** utilisé dans le formatage de /noms/id et de /noms/id/champ seulement */
        public function afficherNomSci($resultat) {
                if ($this->html == 'htm') {
                        $this->table_retour['nom_sci'] = $resultat['nom_sci_html'].$this->ajouterCompositionNom($resultat);
                } else { 
                        $this->table_retour['nom_sci'] = $resultat['nom_sci'].$this->ajouterCompositionNom($resultat);
                }       
        }
        
        
        /** Permet d'afficher la signification d'un code pour le rang, la présence, et les differents statuts */
        public function ajouterSignificationCode($champ, $valeur) {
                $champ = ($champ == 'rang') ? 'rangTaxo' : rtrim($champ, '_Co,_Ga');
                if (preg_match('/^([^_-]+)(?:_|-)([^_-]+)$/', $champ, $match)) {
                        $champ = $match[1].ucfirst($match[2]);
                }
                $url = Config::get('url_ontologie').$champ.':'.$valeur.'/nom';
                $res = $this->consulterHref($url); //dans commun.php
                $nom_code = $res->nom;
                return $nom_code;
        }
        
        
        /** Recupere le nom_scientifique (formaté ou non en fonction du parametre ns.format) à partir du num_nom */
        public function recupererNomSci($id) {
                $nom = array();
                if ($id != 0) {
                        if ($this->compo_nom == null) {
                                $req = 'SELECT nom_sci, num_nom_retenu FROM '.$this->table.' WHERE num_nom = '.$id;
                        } else { //on ajoute à la requete sql, les champs de ns.structure
                                $req = 'SELECT nom_sci, num_nom_retenu, '.implode(', ', $this->compo_nom)
                                                .' FROM '.$this->table
                                                .' WHERE num_nom = '.$id;
                        }
                        if ($this->html == 'htm') {
                                $req = str_replace('nom_sci', 'nom_sci_html as nom_sci', $req);
                        } 
                        $res = $this->getBdd()->recuperer($req); 
                        if ($res) {
                                $nom['nom_sci'] = $res['nom_sci'].$this->ajouterCompositionNom($res);
                                $nom['service'] = ($res['num_nom_retenu'] == $id && $this->service == 'taxons') ? 'taxons' : 'noms';            
                        } else {
                                $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
                                        'Fct recupererNomSci() : Donnees introuvables dans la base pour l\'id '.$id);
                        }
                } 
                return $nom;
        }

        /** Permet de retourner une chaine de caractère composée des parametres du nom (ns.structure : annnée, auteur, 
         * bibilio et addendum). A ajouter au nom scientifique */
        public function ajouterCompositionNom($tab_res) {
                $nom_complet = ' '; 
                $this->ajouterAuteur($tab_res, $nom_complet);  
                $this->ajouterAnneeEtBiblio($tab_res, $nom_complet);    
                $this->ajouterAnneeSansBilio($tab_res, $nom_complet);
                $this->ajouterBiblioSansAnnee($tab_res, $nom_complet); 
                $this->ajouterAddendum($tab_res, $nom_complet);
                return rtrim($nom_complet);
        }
        
        
        public function ajouterAuteur($tab_res, &$nom_complet) {
                if (isset($this->compo_nom['au']) && isset($tab_res['auteur']) && $tab_res['auteur'] != '') {
                        if ($this->html == 'htm') {
                                $nom_complet .= '<span class="auteur">'.$tab_res['auteur'].'</span> ';
                        } else {
                                $nom_complet .= $tab_res['auteur'].' ';
                        }
                }
        }
        
        public function ajouterAnneeEtBiblio($tab_res, &$nom_complet) {
                if (isset($this->compo_nom['an']) && isset($this->compo_nom['bib']) 
                                                && isset($tab_res['annee']) && ($tab_res['annee'] != '') 
                                                && isset($tab_res['biblio_origine']) && ($tab_res['biblio_origine'] != '')) {
                        if ($this->html == 'htm') {
                                $nom_complet .= '[<span class="annee">'.$tab_res['annee'].'</span>, <span class="biblio">'
                                        .$tab_res['biblio_origine'].'</span>]';
                        } else {
                                $nom_complet .= '['.$tab_res['annee'].', '.$tab_res['biblio_origine'].']';
                        }
                }
        }

        public function ajouterAnneeSansBilio($tab_res, &$nom_complet) {
                if (isset($this->compo_nom['an']) && !isset($this->compo_nom['bib']) 
                                                && isset($tab_res['annee']) && ($tab_res['annee'] != '')) {
                        if ($this->html == 'htm') {
                                $nom_complet .= '[<span class="annee">'.$tab_res['annee'].'</span>]';
                        } else {
                                $nom_complet .= '['.$tab_res['annee'].']';
                        }               
                }
        }
        
        public function ajouterBiblioSansAnnee($tab_res, &$nom_complet) {
                if (!isset($this->compo_nom['an']) && isset($this->compo_nom['bib']) && ($tab_res['biblio_origine'] != '')) {
                        if ($this->html == 'htm') {
                                $nom_complet .= '[<span class="biblio">'.$tab_res['biblio_origine'].'</span>]';
                        } else {
                                $nom_complet .= '['.$tab_res['biblio_origine'].']';
                        }
                }
        }
        
        public function ajouterAddendum($tab_res, &$nom_complet) {
                if (isset($this->compo_nom['ad']) && ($tab_res['nom_addendum'] != '')) {
                        if ($this->html == 'htm') {
                                $nom_complet .= '[<span class="adendum">'.$tab_res['nom_addendum'].'</span>]';
                        } else {
                                $nom_complet .= '['.$tab_res['nom_addendum'].']';
                        }
                }
        }
        
        public function correspondAUnCode($key) {
                return (strrpos($key, '.code') !== false) || (in_array($key.'.code', $this->correspondance_champs));
        }
        
        public function correspondAUnId($key) {
                return (strrpos($key, '.id') !== false) || (in_array($key.'.id', $this->correspondance_champs));
        }
        
        public function estChampApi($champ) {
                return (in_array($champ, $this->champs_api) || in_array($champ, $this->correspondance_champs));
        }
        
        public function correspondAChampApi($champ_bdd) { 
                return (array_key_exists($champ_bdd, $this->champs_api) || array_key_exists($champ_bdd, $this->correspondance_champs));
        }
                
        public function estDansBdnff($champ) {
                return (in_array($champ, $this->champs_comp));
        }
        
        public function estUnPoint($key) {
                if (strrpos($key, 'hybride.parent') !== false) {
                        $key = str_replace('hybride.parent', 'hybride_parent', $key);
                }
                return (strrpos($key, '.') !== false);
        }
}

?>