Subversion Repositories eFlore/Applications.del

Rev

Rev 1366 | Blame | Last modification | View Log | RSS feed

<?php
// declare(encoding='UTF-8');
/**
        * Le web service image récupère toutes les données de la table del_obs_images
 * pour retourner une liste d'images associée à une observation
 *
 * @category    php 5.2
 * @package     del
 * @subpackage images
 * @author              Jean-Pascal MILCENT <jpm@tela-botanica.org>
 * @copyright   Copyright (c) 2012, Tela Botanica (accueil@tela-botanica.org)
 * @license     http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
 * @license     http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
 * @version     $Id: Bdd.php 403 2012-02-22 14:35:20Z gduche $
 * @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=ApiIdentiplante01Images
 */


/**
 * FONCTION TEMPORAIRE de debug pour afficher le contenu d'une variable en format lisible
 * @param $r la variable à afficher
 * */
function debug($r) {
        echo '<pre>'.print_r($r, true).'</pre>';
}


/**
 * Le service ListeImages récupère les données des tables observation et images
 * et les mets au format JSON pour identiplante / pictoflora 
 * */
class ListeImages {
        
        
        // Variables :
        // Configuration générale du service
        private $conteneur;
        private $navigation;
        private $bdd;
        private $gestionBdd;
        
        // Parametres
        private $ressources = array();
        private $parametres = array();
        private $masque;
        
        private $tri = 'date_transmission';
        private $directionTri = 'desc';
        private $formatRetour = 'XL';
        
        private $imageIds = array();
        
        
        /**
         * Constructeur de l'application 
         * Initialisation des variables générale de l'application
         * @param Conteneu $conteneur le conteneur de classes de l'application
         * */
        public function __construct(Conteneur $conteneur = null) {
                $this->conteneur = $conteneur == null ? new Conteneur() : $conteneur;
                $this->conteneur->chargerConfiguration('config_departements_bruts.ini');
                $this->conteneur->chargerConfiguration('config_mapping_votes.ini');
                $this->conteneur->chargerConfiguration('config_images.ini');
                $this->navigation = $conteneur->getNavigation();
                $this->masque = $conteneur->getMasque();
                $this->gestionBdd = $conteneur->getGestionBdd();
                $this->bdd = $this->gestionBdd->getBdd();       
        }
        
        
        /**
         * Méthode principale de la classe.
         * Lance la récupération des images dans la base et les place dans un objet ResultatService
         * pour l'afficher.
         * @param array $ressources les ressources situées après l'url de base (ex : http://url/ressource1/ressource2)
         * @param array $parametres les paramètres situés après le ? dans l'url
         * */
        public function consulter($ressources, $parametres) {
        
                $this->initialiserRessourcesEtParametres($ressources, $parametres);
                
                $this->configurer();
                $this->verifierConfiguration();
        
                $this->verifierParametresTri();
                $this->initialiserTri();
                
                $this->verifierParametreFormatRetour();
                $this->initialiserFormatRetour();
        
                $parametres = $this->nettoyerParametres($parametres);
        
                // En fonction des paramètres de recherche, on n'effectue
                // pas la même requête, pour optimiser les jointures et les
                // rapidités d'éxécution.
                $type = $this->getTypeRequete($parametres);
        
                switch ($type) {
                        case 'obs' :
                                $liaisons = $this->chargerLiaisonsObs();
                        break;
                        case 'images' :
                                $liaisons = $this->chargerLiaisonsImages();
                        break;
                        case 'obs-images' :
                                $liaisons = $this->chargerLiaisons();
                        break;
                        default : //case simple !
                        $liaisons = $this->chargerLiaisonsSimple();
                }
        

                // Partie commune à tous les cas : on complète les liaisons avec les informations des votes
                // et des images, puis on affiche sous forme de JSON
                $images = $this->chargerImage($liaisons);
                $images = $this->chargerVotes($images);
                
                $resultat = new ResultatService();
                $resultat->corps = array('entete' => $this->conteneur->getEntete(), 'resultats' => $images);
                
                return $resultat;
        }
        
        
        
        /**************************************************************************************
         *                                                              FONCTION LIEES AUX REQUETES                                               *
         **************************************************************************************/
        
        /**
         * Charger la clause WHERE en fonction des paramètres de masque
         * */
        private function chargerClauseWhere() {
        
                $where = array();
                $tableauMasque = $this->masque->getMasque();
                if (!empty($tableauMasque)) {
                        foreach($tableauMasque as $idMasque => $valeurMasque) {
                                //TODO: scinder ceci en fonctions réutilisables ?
                                // voir si c'est interessant par rapport à la recherche générale
                                $idMasque = str_replace('masque.', '', $idMasque);
                                switch ($idMasque) {
                                // nom du masque => nom BDD
                                        case 'auteur' :
                                                        $whereAuteur = ' '.$this->creerFiltreAuteur($this->masque->getMasque('auteur'));
                                                                        if($whereAuteur != '') {
                                                                                $where[] = $whereAuteur;
                                                                        }
                                                                        break;
                                        case 'date' :
                                        $whereDate = ' '.$this->creerFiltreDate($valeurMasque);
                                        if($whereDate != '') {
                                                $where[] = $whereDate;
                                        }
                                        break;
                                        case 'departement' :
                                                $where[] = ' '.$this->creerFiltreIdZoneGeo($valeurMasque);
                                                break;
                                        case 'genre' :
                                                $where[] = ' '.$this->mappingFiltre['ns'].' LIKE '.$this->proteger($valeurMasque.' %');
                                                break;
                                        case 'tag' :
                                                $where[] = ' '.$this->creerFiltreMotsCles($valeurMasque);
                                                break;
                                        case 'referentiel' :
                                                $where[] = ' referentiel_nom LIKE '.$this->proteger($valeurMasque.'%');
                                                break;
                                        case 'ns' :
                                                $where[] = ' nom_sel LIKE '.$this->proteger($valeurMasque.'%');
                                                break;
                                        case 'nn' :
                                                $where[] = ' (nom_sel_nn LIKE '.$this->proteger($valeurMasque.'%').' OR '.
                                                                   ' nom_ret_nn LIKE '.$this->proteger($valeurMasque.'%').') ';
                                                break;
                                        case 'commune' :
                                                $where[] = ' '.$this->mappingFiltre[$idMasque].' LIKE '.$this->proteger(str_replace(array('-',' '), '_', $valeurMasque).'%');
                                                break;
                                        case 'masque' :
                                                $where[] = ' '.$this->creerFiltreMasqueGeneral($valeurMasque);
                                                break;
                                        default:
                                                $where[] = ' '.$this->mappingFiltre[$idMasque].' = '.$this->proteger($valeurMasque);
                                                break;
                                }
                        }
                }
        
                if (!empty($where)) {
                        return ' WHERE '.implode('AND', $where);
                } else {
                        return;
                }
        }
        
        /**
         * Créer un masque général lorsque l'on souhaite utiliser le passe partout
         * @param la valeur du passe partout
         * */
        private function creerFiltreMasqueGeneral($valeurMasque) {
                //TODO: affecter d'aborder les variables, puis les tester pour les
                // ajouter à la chaine
                $whereAuteur = $this->creerFiltreAuteur($valeurMasque);
                $whereIdZoneGeo = $this->creerFiltreIdZoneGeo($valeurMasque);
        
                $masqueGeneral = '( '.
                                (($whereAuteur != '') ? $whereAuteur.' OR ' : '' ).
                                (($whereIdZoneGeo != '') ? $whereIdZoneGeo.' OR ' : '' ).
                                'zone_geo LIKE '.$this->proteger($this->remplacerParJokerCaractere($valeurMasque).'%').' OR '.
                                $this->creerFiltreMotsCles($valeurMasque).' OR '.
                                'nom_sel LIKE '.$this->proteger($valeurMasque.'%').' OR '.
                                'famille LIKE '.$this->proteger($valeurMasque.'%').' OR '.
                                'milieu LIKE '.$this->proteger($valeurMasque).' OR '.
                                $this->mappingFiltre['ns'].' LIKE '.$this->proteger('%'.$valeurMasque.'% %').' OR '.
                                $this->creerFiltreDate($valeurMasque).
                                ') ';
        
                return $masqueGeneral;
        }
        
        /**
         * Créer le filtre auteur en recherchant dans son nom, prénom, adresse email en fonction 
         * de la chaine donnée 
         * @param la valeur recherchée
         * */
        private function creerFiltreAuteur($valeurMasque) {
                $masque = '';
                $auteurId = $valeurMasque;
                if (is_numeric($auteurId)) {
                        $masque = ' ce_utilisateur = '.$auteurId;
                } else {
                        if (strpos($auteurId, '@') === false) {
                                $tableauNomPrenom = explode(' ',$auteurId, 2);
                                if(count($tableauNomPrenom) == 2) {
                                        // on teste potentiellement un nom prenom ou bien un prénom nom
                                        $masque = '('.
                                                        '(nom LIKE '.$this->proteger($tableauNomPrenom[0].'%').' AND '.
                                                        'prenom LIKE '.$this->proteger($tableauNomPrenom[1].'%').') OR '.
                                                        '(nom LIKE '.$this->proteger($tableauNomPrenom[1].'%').' AND '.
                                                        'prenom LIKE '.$this->proteger($tableauNomPrenom[0].'%').') OR '.
                                                        '(dob.nom_utilisateur LIKE '.$this->proteger($tableauNomPrenom[0].'%').' AND '.
                                                        'dob.prenom_utilisateur LIKE '.$this->proteger($tableauNomPrenom[1].'%').') OR '.
                                                        '(dob.nom_utilisateur LIKE '.$this->proteger($tableauNomPrenom[1].'%').' AND '.
                                                        'dob.prenom_utilisateur LIKE '.$this->proteger($tableauNomPrenom[0].'%').') OR '.
                                                        '(nom LIKE '.$this->proteger($valeurMasque.'%').') OR '.
                                                        '(prenom LIKE '.$this->proteger($valeurMasque.'%').') OR '.
                                                        '(dob.nom_utilisateur LIKE '.$this->proteger($valeurMasque.'%').') OR '.
                                                        '(dob.prenom_utilisateur LIKE '.$this->proteger($valeurMasque.'%').') '.
                                                        ')';
                                } else {
                                        $masque = '(
                                                            (nom LIKE '.$this->proteger($auteurId.'%').' OR '.
                                                                    'prenom LIKE '.$this->proteger($auteurId.'%').' OR '.
                                                                    'dob.nom_utilisateur LIKE '.$this->proteger($auteurId.'%').' OR '.
                                                                    'dob.prenom_utilisateur LIKE '.$this->proteger($auteurId.'%').')'.
                                                                    ')';
                                }
                        } else {
                                $masque = " ( courriel LIKE ".$this->proteger($valeurMasque.'%').
                                " OR dob.courriel_utilisateur LIKE ".$this->proteger($valeurMasque.'%').")  ";
                        }
                }
                return $masque;
        }
        
        
        /**
         * Obtenir une chaine de caractère concaténant nom et prénom séparé par une virgule
         * @param String $auteurId l'identifiant de l'auteur
         * @return String la chaine de concaténation
         * */
        private function getChaineNomPrenom($auteurId) {
                $nomPrenom = explode(' ', $auteurId);
                $nomPrenom = $this->proteger($nomPrenom);
                $chaineNomPrenom = implode(', ', $nomPrenom);
                return $chaineNomPrenom;
        }
        
        /**
         * Créer le filtre de recherche par zone géographique en fonction du masque
         * @param $valeurMasque le terme de la recherche
         * */
        private function creerFiltreIdZoneGeo($valeurMasque) {
                $masque = '';
                $dept = $valeurMasque;
                if (is_numeric($dept)) {
                        $dept = sprintf('%02s', $dept);
                        $dept = sprintf("%-'_5s", $dept);
                        $masque = " ce_zone_geo LIKE ".$this->proteger('INSEE-C:'.$dept);
                } else {
                        $deptId = $this->conteneur->getParametre($dept);
                        if ($deptId != null) {
                                $masque = " ce_zone_geo LIKE ".$this->proteger('INSEE-C:'.$deptId.'%');
                        } else {
                                $id = $this->obtenirIdDepartement($valeurMasque);
                                $masque = " ce_zone_geo LIKE ".$this->proteger('INSEE-C:'.$id.'%');
                        }
                }
                return $masque;
        }
        
        /**
         * Générer la chaine de recherche pour la date en  fonction du masque
         * @param $valeurMasque la date recherchée (AAAA ou JJ/MM/AAAA)
         * */
        private function creerFiltreDate($valeurMasque) {
                //TODO: définir dans le fichier de config un tableau contenant plusieurs format de date
                // autorisés pour la recherche, qui seraient ajoutés au OR
                $masque = '(';
                $masque .= (is_numeric($valeurMasque)) ? ' YEAR(date_observation) = '.$this->proteger($valeurMasque).' OR ' : '';
                $masque .= " DATE_FORMAT(date_observation, '%d/%m/%Y') = ".$this->proteger($valeurMasque).' '.
                                ')';
                return $masque;
        }
        
        /**
         * Générer la chaine de recherche dans les mots clés en fonction du masque
         * @param $valeurMasque le mot clé recherché
         * */
        private function creerFiltreMotsCles($valeurMasque) {
        
                $mots_cles = explode(' ', $valeurMasque);
                $requeteMotsClesImg = array();
                $requeteMotsClesObs = array();
                $requeteMotsClesImgPublic = array();
        
                foreach($mots_cles as $mot_cle) {
                        //TODO: rechercher sur les mots clés normalisés dans tous les cas ?
                        $requeteMotsCles = $this->proteger('%'.$mot_cle.'%');
                        $motsCleProtege = $this->proteger($this->normaliserMotCle('%'.$mot_cle.'%'));
                        $requeteMotsClesImgPublic[] = 'di.id_image IN (SELECT ce_image FROM del_image_tag WHERE tag_normalise LIKE '.$motsCleProtege.' AND actif = 1)';
                        $requeteMotsClesImg[] = 'di.mots_cles_texte LIKE '.$requeteMotsCles;
                        $requeteMotsClesObs[] = 'dob.mots_cles_texte LIKE '.$requeteMotsCles;
                }
        
                $requeteMotsClesImgPublic = implode(' AND ', $requeteMotsClesImgPublic);
                $requeteMotsClesImg = implode(' AND ', $requeteMotsClesImg);
                $requeteMotsClesObs = implode(' AND ', $requeteMotsClesObs);
        
                $masque = '('.
                                '('.$requeteMotsClesImgPublic.') OR '.
                                '('.$requeteMotsClesImg.') OR '.
                                '('.$requeteMotsClesObs.') '.
                                ')';
        
                return $masque;
        }
        
        // ??
        private function assemblercomptageOccurencesMotsClesCel() {
                $chaineMotsClesAffiches = $this->conteneur->getParametre('mots_cles_cel_affiches');
                $tabMotsClesAffiches = explode(',',$chaineMotsClesAffiches);
                $chaineSql = '';
        
                // Comptage du nombre de mots clés officiels présents dans la chaine mots clés texte
                foreach ($tabMotsClesAffiches as $motCle) {
                        if($chaineSql != '') {
                                $chaineSql .= ' + ';
                        }
                        $chaineSql .= 'IF(FIND_IN_SET('.$this->proteger($motCle).',di.mots_cles_texte) != 0, 1, 0)';
                }
        
                return '('.$chaineSql.')';
        }
        
        private function getTri() {
                $order = '';
                if($this->doitJoindreTableVotes()) {
                        $order = ' GROUP BY dvote.ce_image, dob.id_observation ORDER BY total_votes '.$this->directionTri.', date_transmission desc ';
                } else if($this->doitJoindreTableTags()) {
                        $order = ' GROUP BY doi.id_image ORDER BY total_tags '.$this->directionTri.', date_transmission desc ';
                } else {
                        $order = ' ORDER BY '.$this->tri.' '.$this->directionTri.' ';
                }
                return $order;
        }
        
        /**
         * Compter le nombre total d'images dans la base pour affichage dans entete.
         * */
        private function getFoundRows() {
                $requete = 'SELECT FOUND_ROWS() AS nbre ';
                $resultats = $this->bdd->recuperer($requete);
                return (int) $resultats['nbre'];
        }
        
        
        /**
         * En fonction des paramètres, générer les conditions de recherche 
         * des observations
         * */
        private function getConditionsObs() {
                $conditionsObs = array();
                $masques = $this->masque->getMasque();
                if (isset($masques['masque'])) {
                        $passe = $masques['masque'];
                                
                        // Si on a saisi le masque passe partout, alors on doit chercher dans tous les champs
                        // de la table observation (OR)
                        $conditionLibre = array();
                
                        if (!isset($masques['masque.ns'])) {
                                $conditionsLibre[] = "nom_sel LIKE '$passe%'";
                        }
                
                        if (!isset($masques['masque.famille'])) {
                                $conditionsLibre[] = "famille LIKE '$passe%'";
                        }
                
                        if (!isset($masques['masque.milieu'])) {
                                $conditionsLibre[] = "nom_sel LIKE '$passe%'";
                        }
                
                        if (!isset($masques['masque.date'])) {
                                $conditionsLibre[] = $this->creerFiltreDate($passe);
                        }
                
                        if (!isset($masques['masque.auteur'])) {
                                $conditionsLibre[] = $this->creerFiltreAuteur($passe);
                        }
                
                        /*
                         * FIXME : remplacer par motcle projet !
                        * if (!isset($masques['masque.tag'])) {
                        $conditionsLibre[] = "mots_cles_texte LIKE '%$passe%'";
                        }*/
                                
                        $conditionsObs[] = implode(' OR ', $conditionsLibre);
                }
                
                // referentiel
                if (isset($masques['masque.referentiel'])) {
                        $ref = $masques['masque.referentiel'];
                        $conditionsObs[] = "nom_referentiel LIKE '$ref%'";
                }
                
                // nom sel
                if (isset($masques['masque.ns'])) {
                        $nom_sel = $masques['masque.ns'];
                        $conditionsObs[] = "nom_sel LIKE '$nom_sel%'";
                }
                
                // nom sel
                if (isset($masques['masque.nn'])) {
                        $num_nom = $masques['masque.nn'];
                        $conditionsObs[] = "(nom_sel_nn = '$num_nom' OR nom_ret_nn = '$num_nom') ";
                }
                
                // famille
                if (isset($masques['masque.famille'])) {
                        $famille = $masques['masque.famille'];
                        $conditionsObs[] = "famille LIKE '$famille%'";
                }
                
                // genre
                if (isset($masques['masque.genre'])) {
                        $genre = $masques['masque.genre'];
                        $conditionsObs[] = "nom_sel LIKE '$genre%'";
                }
                        
                // milieu
                if (isset($masques['masque.milieu'])) {
                        $milieu = $masques['masque.milieu'];
                        $conditionsObs[] = "nom_sel LIKE '$milieu%'";
                }
                
                // date
                if (isset($masques['masque.date'])) {
                        $date = $masques['masque.date'];
                        $conditionsObs[] = $this->creerFiltreDate($date);
                }
                
                // utilisateur
                if (isset($masques['masque.auteur'])) {
                        $auteur = $masques['masque.auteur'];
                        $conditionsObs[] = $this->creerFiltreAuteur($auteur);
                }
                
                // commune
                if (isset($masques['masque.commune'])) {
                        $commune = $masques['masque.commune'];
                        $conditionsObs[] = " zone_geo LIKE ".$this->proteger(str_replace(array('-',' '), '_', $commune).'%');
                }
                
                // commune
                if (isset($masques['masque.departement'])) {
                        $dept = $masques['masque.departement'];
                        $conditionsObs[] = $this->creerFiltreIdZoneGeo($dept);
                }

                return $conditionsObs;
        }
        
        /**
         * Obtenir le tableu de chaines de condition de requete images en fonction des masques
         * */
        private function getConditionsImages() {
                $conditionsImg = array();
                $masques = $this->masque->getMasque();
                if (isset($masques['masque.tag'])) {
                        $tag = $masques['masque.tag'];
                        $conditionsImg[] = " dit.tag_normalise LIKE '$tag%' ";
                        $conditionsImg[] = " di.mots_cles_texte LIKE '%$tag%' ";
                }
                
                return $conditionsImg;
        }
        
        
        /*-------------------------------------------------------------------------------
         CHARGEMENT DES IMAGES
        --------------------------------------------------------------------------------*/
        /**
         * Chargement depuis la bdd de toutes les liaisons entre images et observations
         * Méthode appelée uniquement lorsque les paramètres sont vides
         * */
        private function chargerLiaisonsSimple() {
        
                // On récupère d'abord les N images de del_obs_image, éventuellement triées, 
                // Et on complète avec les informations des observations associées
                $requeteImages = ' SELECT *, di.mots_cles_texte as mots_cles_texte_image '.
                                                 ' FROM del_obs_image doi '.
                                                 ' INNER JOIN del_image di ON doi.id_image = di.id_image ';

                // Si le tri se fait par date d'observation, on récupère les identifiants de N observations triées
                if (isset($this->parametres['tri']) && $this->parametres['tri'] == 'date_observation') {
                        
                        $ordre = isset($this->parametres['ordre']) ? $this->parametres['ordre'] : 'DESC';
        
                        $requeteIdObs = ' SELECT doi.id_image  as id_image '.
                                                        ' FROM del_obs_image doi '.
                                                        ' INNER JOIN del_observation dob ON dob.id_observation = doi.id_observation '.
                                                        ' INNER JOIN del_image di ON doi.id_image = di.id_image '.
                                                        ' ORDER BY date_observation '.$ordre.', dob.id_observation '.$ordre;
                        $requeteIdObs .= $this->gestionBdd->getLimitSql();
                        
                        // Récupérer les N observations triées par date
                        $observations = $this->bdd->recupererTous($requeteIdObs);
                        
                        $idsImages = array();
                        foreach ($observations as $observation) {
                                $idsImages[] = $observation['id_image'];
                        }
                        
                        $chaineIdImages = implode(',', $idsImages);
                        $requeteImages .= ' WHERE doi.id_image IN ('.$chaineIdImages.') '.
                                                          ' GROUP BY doi.id_image, doi.id_observation '.
                                                          ' ORDER BY FIELD(doi.id_image,  '.$chaineIdImages.')'.
                                                          ' LIMIT '.$this->navigation->getLimite(); // On limite sur le nombre car les obs peuvent avoir plusieurs images
                        
                } else {
                        $requeteImages .= ' GROUP BY doi.id_image, doi.id_observation ';
                        $requeteImages .= ' ORDER BY doi.id_observation DESC';
                        $requeteImages .= $this->gestionBdd->getLimitSql();
                }
        
                $liaisons = $this->bdd->recupererTous($requeteImages);
                        
                // Ce n'est pas la peine de continuer s'il n'y a pas eu de résultats dans la table del_obs_images
                if (!empty($liaisons)) {
                        
                        $idsObservations = array();
                        foreach ($liaisons as $image) {
                                $idObs = $image['id_observation'];
                                $idsObservations[$idObs] = $idObs;
                        }
                        
                        $chaineIdObs = implode(',', $idsObservations);
                        
                        
                        // On récupère les observations qui complètent la requête précédente
                        $requeteObservations = ' SELECT * '.
                                                                   ' FROM del_observation dob '.
                                                                   ' LEFT JOIN del_utilisateur du ON dob.ce_utilisateur = du.id_utilisateur '.
                                                                   ' WHERE id_observation IN ('.$chaineIdObs.')';
                                                                                
                        $resultatsObservations = $this->bdd->recupererTous($requeteObservations);
                
                        // FIXME : Ca ne doit pas arriver, mais que se passe-t-il s'il n'y a pas d'observation pour l'image ?! 
                        
                        // On range les observations dans un tableau pour pouvoir les retrouver par leur id :
                        $observations = array();
                        foreach ($resultatsObservations as $id => $observation) {
                                $idObs = $observation['id_observation'];
                                $observations[$idObs] = $observation;
                        }
                
                        // Enfin, pour chaque image préalablement récupérées, on complète avec les informations de l'observation
                        // FIXME : peut-être peut-on utiliser un array_merge ici ? 
                        foreach ($liaisons as $id => $liaison) {
                                $idObs = $liaison['id_observation'];
                
                                $observation = $observations[$idObs];
                                foreach ($observation as $cle => $valeur) {
                                        $liaisons[$id][$cle] = $valeur;
                                }
                        }
                        
                        
                        // On compte à part les images issues de la jointure de del_obs_image et del_image car la fonction
                        // SQL_CALC_FOUND_ROWS dans la fonction requete image fait passer le temps d'éxécution de 0.0011 à 15s !
                        $requeteNbImages = 'SELECT SUM(t.nb) as nb FROM (SELECT count(DISTINCT doi.id_image) as nb '.
                                                           'FROM del_obs_image doi '.
                                                           'INNER JOIN del_image di '.
                                                           'ON di.id_image = doi.id_image '.
                                                           'GROUP BY doi.id_image, doi.id_observation) t ';
                        $resultatNbImages = $this->bdd->recupererTous($requeteNbImages);

                        $total = (int) $resultatNbImages[0]['nb'];
                        $this->navigation->setTotal($total);
                }

                return $liaisons;
        }
        
        
        /**
         * Chargement depuis la bdd de toutes les liaisons entre images et observations
         * Méthode appelée uniquement lorsque les paramètres concernent une observation
         * */
        private function chargerLiaisonsObs() {
        
                // Récupérer les liaisons
                $requeteObs = ' SELECT SQL_CALC_FOUND_ROWS dob.id_observation as id_observation, nom_referentiel, nom_sel, nom_sel_nn, nt, famille, ce_zone_geo, zone_geo, lieudit, station, milieu, '.
                                          ' date_observation, dob.mots_cles_texte as mots_cles_texte, dob.commentaire as commentaire, di.mots_cles_texte as mots_cles_texte_image , date_transmission, '.
                                          ' doi.id_image as id_image, di.ce_utilisateur as ce_utilisateur, prenom, nom, courriel, dob.prenom_utilisateur, dob.nom_utilisateur, dob.courriel_utilisateur, nom_original '.
                                          'FROM del_observation dob '.
                                          ' INNER JOIN del_obs_image doi ON dob.id_observation = doi.id_observation '.
                                          ' INNER JOIN del_image di ON doi.id_image = di.id_image '.
                                          ' LEFT JOIN del_utilisateur du ON dob.ce_utilisateur = du.id_utilisateur ';
        
                // Récupérer les conditions sous forme de tableau
                $conditionsObs = $this->getConditionsObs();
                
                if (!empty($conditionsObs)) {
                        $where = ' WHERE '.implode(' AND ', $conditionsObs);
                        $requeteObs .= $where;
                }
        
                // Gérer le tri (uniquement si c'est date_observation)
                if (isset($this->parametres['tri']) && $this->parametres['tri'] == 'date_observation') {
                        $ordre = isset($this->parametres['ordre']) ? $this->parametres['ordre'] : 'DESC';
                        $tri = ' ORDER BY '.$this->parametres['tri'].' '.$ordre.', doi.id_observation '.$ordre.' ';
                        $requeteObs .= $tri;
                }
                
                $requeteObs .= $this->gestionBdd->getLimitSql();
                $observations = $this->bdd->recupererTous($requeteObs);

                $total = $this->getFoundRows();
                $this->navigation->setTotal($total);

                return $observations;
        }
        
        /**
         * Chargement depuis la bdd de toutes les liaisons entre images et observations
         * Méthode appelée uniquement lorsque les paramètres concernent les images
         * */
        private function chargerLiaisonsImages() {
        
                // FIXME : si on faisait une requete à part pour compter, ca irait plus vite
                // Récupérer tous les ID d'image en fonction des paramètres de recherche
                $requeteImages = ' SELECT SQL_CALC_FOUND_ROWS '.
                                                 ' doi.id_image as id_image, dob.id_observation as id_observation, nom_sel, nom_sel_nn, nt, famille, ce_zone_geo, zone_geo, lieudit, station, milieu, '.
                                                 ' date_observation, dob.mots_cles_texte as mots_cles_texte, dob.commentaire as commentaire, di.mots_cles_texte as mots_cles_texte_image , date_transmission, '.
                                                 ' di.ce_utilisateur as ce_utilisateur, prenom, nom, courriel, dob.prenom_utilisateur, dob.nom_utilisateur, dob.courriel_utilisateur, nom_original '.
                                                 ' FROM del_obs_image doi '.
                                                 ' INNER JOIN del_image di ON doi.id_image = di.id_image '.
                                                 ' INNER JOIN del_observation dob ON dob.id_observation = doi.id_observation '.
                                                 ' LEFT JOIN del_image_tag dit ON dit.ce_image = di.id_image '.
                                                 ' LEFT JOIN del_utilisateur du ON du.id_utilisateur = di.ce_utilisateur ';

                $conditionsImg = $this->getConditionsImages();
        
                if (!empty($conditionsImg)) {
                        $where = ' WHERE ('.implode(' OR ', $conditionsImg).') ';
                        $where .= ' AND dit.actif = 1 ';
                        $requeteImages .= $where;
                }
        
                // Gérer le tri, sur les votes ou sur les tags
                if (isset($this->parametres['tri'])) {
                        
                        $chaineTri = '';
                        $chaineOrdre = '';
                        
                        if ($this->parametres['tri'] == 'votes') {
        
                                $protocole = isset($this->parametres['protocole']) ? $this->parametres['protocole'] : 1;
        
                                $requeteVotes = ' SELECT doi.id_image as id_image, IF(divo.ce_protocole = '.$protocole.', AVG(divo.valeur), 0) as total_votes '.
                                                                ' FROM del_obs_image doi '.
                                                                ' INNER JOIN del_image di ON doi.id_image = di.id_image '.
                                                                ' INNER JOIN del_observation dob ON dob.id_observation = doi.id_observation '.
                                                                ' LEFT JOIN del_image_vote divo ON doi.id_image = divo.ce_image '.
                                ' AND ce_protocole = '.$protocole.' ';
        
                                // Et si on a cherché par tag ?
                                if (isset($this->parametres['masque.tag'])) {
                                        $tag = $this->parametres['masque.tag'];
                                        $requeteVotes .= ' LEFT JOIN del_image_tag dit ON dit.ce_image = di.id_image ';
                                        $requeteVotes .= " WHERE (dit.tag_normalise LIKE '$tag%' OR  di.mots_cles_texte LIKE '%$tag%') AND dit.actif = 1 ";
                                }
        
                                $requeteVotes .= ' GROUP BY doi.id_image, doi.id_observation '.
                                                                 ' ORDER by total_votes '.$this->directionTri .', doi.id_observation '.$this->directionTri.' '.
                                                $this->gestionBdd->getLimitSql();
        

                                $resultatsVotes = $this->bdd->recupererTous($requeteVotes);
                                $tabVotes = array();
                                foreach ($resultatsVotes as $vote) {
                                        $tabVotes[] = $vote['id_image'];
                                }
        
                                $strVotes = empty($tabVotes) ? "''" : implode(',', $tabVotes);
        
                                // Et si on a cherché par tag ?
                                if (isset($this->parametres['masque.tag'])) {
                                        $chaineTri .= ' AND ';
                                } else {
                                        $chaineTri .= ' WHERE ';
                                }
                                
                                
                                $chaineTri .= '  doi.id_image IN ('.$strVotes.') ';
                                $chaineOrdre = ' ORDER BY FIELD(doi.id_image, '.$strVotes.')  ';
                        }
                        
                        if ($this->parametres['tri'] == 'tags') {
                                        
                                $requetetags = ' SELECT SQL_CALC_FOUND_ROWS doi.id_image, COUNT(id_tag) as total_tags '.
                                                ' FROM del_obs_image doi LEFT JOIN del_image_tag dit ON dit.ce_image = doi.id_image AND dit.actif = 1 '.
                                                 ' INNER JOIN del_image di ON doi.id_image = di.id_image '.
                                                 ' INNER JOIN del_observation dob ON dob.id_observation = doi.id_observation ';

                                if (isset($this->parametres['masque.tag'])) {
                                        // Et si on a cherché par tag ?
                                        $tag = $this->parametres['masque.tag'];
                                        $requetetags .= " WHERE (dit.tag_normalise LIKE '$tag%' OR  di.mots_cles_texte LIKE '%$tag%') ";
                                }
                                
                                $requetetags .= ' GROUP BY doi.id_image, doi.id_observation '.
                                                ' ORDER by total_tags '.$this->directionTri.', doi.id_observation '.$this->directionTri.
                                                $this->gestionBdd->getLimitSql();

                                $resultatstags = $this->bdd->recupererTous($requetetags);
                                $tabtags = array();
                                foreach ($resultatstags as $tag) {
                                        $tabtags[] = $tag['id_image'];
                                }
                                $strtags = empty($tabtags) ? "''" : implode(',', $tabtags);
                                
        
                                // Et si on a cherché par tag ?
                                if (isset($this->parametres['masque.tag'])) {
                                        $chaineTri .= ' AND ';
                                } else {
                                        $chaineTri .= ' WHERE ';
                                }
        
                                $chaineTri .= ' doi.id_image IN ('.$strtags.') ';
                                $chaineOrdre = ' ORDER BY FIELD(doi.id_image, '.$strtags.') ';
                        }
                                                
                        $requeteImages .= $chaineTri.' GROUP BY doi.id_image, doi.id_observation '.$chaineOrdre;
                } else {
                        $requeteImages .= ' GROUP BY doi.id_image, doi.id_observation'; // des fois, on a plusieurs observations pour la même image ...
                        $requeteImages .= $this->gestionBdd->getLimitSql();
                }

                $retour  = $this->bdd->recupererTous($requeteImages);
                $total = $this->getFoundRows();
                $this->navigation->setTotal($total);
                
                return $retour;
        }
        
        /**
         * Chargement depuis la bdd de toutes les liaisons entre images et observations
         * */
        private function chargerLiaisons() {
        
                $champs = array('dob.id_observation as id_observation', 'nom_sel', 'nom_sel_nn', 'nt', 'famille', 'ce_zone_geo', 'zone_geo',
                                'lieudit', 'station', 'milieu', 'date_observation', 'dob.mots_cles_texte as mots_cles_texte', 'dob.commentaire as commentaire',
                                'di.mots_cles_texte as mots_cles_texte_image ', 'date_transmission', 'di.id_image as id_image', 'di.ce_utilisateur as ce_utilisateur',
                                'prenom', 'nom', 'courriel', 'dob.prenom_utilisateur', 'dob.nom_utilisateur', 'dob.courriel_utilisateur', 'nom_original');
                // Attention le LEFT JOIN est indispensable pour ramener les images n'ayant pas de votes
                // en cas de tri par votes
                $requeteLiaisons = 'SELECT DISTINCT SQL_CALC_FOUND_ROWS '.implode(', ',$champs).' '.
                                ($this->doitJoindreTableVotes() ?
                                                ', IF(dvote.ce_protocole = '.$this->parametres['protocole'].', AVG(dvote.valeur), 0) as total_votes ' :
                                                ''
                                ).
                                ($this->doitJoindreTableTags() ?
                                                // attention le DISTINCT est indispensable !
                                                ', (COUNT(DISTINCT dtag.id_tag) + '.$this->assemblercomptageOccurencesMotsClesCel().') as total_tags ' :
                                                ''
                                ).
                                'FROM '.$this->gestionBdd->formaterTable('del_obs_image', 'doi').
                                'INNER JOIN del_image di '.
                                'ON doi.id_image = di.id_image '.
                                'INNER JOIN del_observation dob '.
                                'ON doi.id_observation = dob.id_observation '.
                                'LEFT JOIN del_utilisateur du '.
                                'ON du.id_utilisateur = di.ce_utilisateur '.
                                ($this->doitJoindreTableTags() ?
                                                'LEFT JOIN del_image_tag dtag '.
                                                'ON doi.id_image = dtag.ce_image AND dtag.actif = 1 ' :
                                                ''
                                                                ).
                                                                ($this->doitJoindreTableVotes() ?
                                                                'LEFT JOIN del_image_vote dvote '.
                                                                'ON doi.id_image = dvote.ce_image AND dvote.ce_protocole = '.$this->parametres['protocole'] :
                                                                ''
                                                                                );
                                $requeteLiaisons .= $this->chargerClauseWhere();
                                $requeteLiaisons .= $this->getTri();
                                $requeteLiaisons .= $this->gestionBdd->getLimitSql();

                                $retour = $this->bdd->recupererTous($requeteLiaisons);
                                $total = $this->getFoundRows();
                                $this->navigation->setTotal($total);
                                return $retour;
        }
        
        
        /**
         * Retourner un tableau d'images formaté en fonction des liaisons trouvées
         * @param $liaisons les liaisons de la table del_obs_images
         * */
        private function chargerImage($liaisons) {
        
                $images = array();
                foreach ($liaisons as $liaison) {
                        $idImage = $liaison['id_image'];
                                
                        if($liaison['ce_utilisateur'] == 0) {
                                $liaison['prenom'] = $liaison['prenom_utilisateur'];
                                $liaison['nom'] = $liaison['nom_utilisateur'];
                        }
                        // On enregistre l'ID de l'image pour n'effectuer qu'une seule requête par la suite
                        $this->imageIds[] = $idImage;
                        $index = $liaison['id_image'].'-'.$liaison['id_observation'];
                        $images[$index] = array('id_image' => $idImage, 'binaire.href' => $this->formaterLienImage($idImage),
                                        'protocoles_votes' => array(),
                                        'mots_cles_texte' => $liaison['mots_cles_texte_image'], 'observation' => $this->formaterObservation($liaison));
                }
                return $images;
        }
        
        /**
         * Charger les votes pour chaque image
         * */
        private function chargerVotes($images) {
                $requeteVotes = 'SELECT v.*, p.* FROM '.
                                $this->gestionBdd->formaterTable('del_image_vote', 'v').
                                ' INNER JOIN del_image_protocole p '.
                                'ON v.ce_protocole = p.id_protocole '.
                                $this->chargerClauseWhereVotes();
                $resultatsVotes = $this->bdd->recupererTous($requeteVotes);
                        
                        
                //TODO : faire une méthode formater vote
                $votes = $this->formaterVotes($resultatsVotes);
        
                foreach ($images as $id => $image) {
                        if (isset($votes[$image['id_image']])) {
                                $images[$id]['protocoles_votes'] = $votes[$image['id_image']];
                        }
                }
        
                return $images;
        }
        
        private function chargerClauseWhereVotes() {
                if (sizeof($this->imageIds) > 0) {
                        $chaineImageIds = implode(',', $this->imageIds);
                        $where[] = 'v.ce_image  IN ('.$chaineImageIds.')';
                }
                if (isset($this->parametres['protocole'])) {
                        $where[] = 'v.ce_protocole = '.$this->proteger($this->parametres['protocole']);
                }
        
                $where = (!empty($where)) ? 'WHERE '.implode(' AND ', $where) : '';
                return $where;
        }
        
        /**************************************************************************************
         *                                      FONCTION DE CONFIGURATION ET UTILITAIRES                                          *
        ***************************************************************************************/
        /**
         * Enregistrer dans les variables de classe les paramètres et ressources
         * @param $ressources
         * @param $parametres de recherche 
         * */
        private function initialiserRessourcesEtParametres($ressources, $parametres) {
                $this->ressources = $ressources;
                $this->parametres = $parametres;
        }
        
        /**
         * Configuration du service en fonction du fichier de config config_del.ini
         * */
        public function configurer() {
                $this->mappingFiltre = $this->conteneur->getParametre('mapping_masque');
                $this->mappingObservation = $this->conteneur->getParametre('mapping_observation');
                $this->mappingVotes = $this->conteneur->getParametre('mapping_votes');
        }
        
        /**
         * Vérifier que le service est bien configuré
         * */
        public function verifierConfiguration() {
        
                $erreurs = array();
                $tableauImages = $this->conteneur->getParametre('images');
                if (empty($tableauImages)) {
                        $erreurs[] = '- le fichier de configuration ne contient pas le tableau [images] ou celui-ci est vide ;';
                } else {
                        if ($this->conteneur->getParametre('url_service') == null) {
                                $erreurs[] = '- paramètre "url_service" manquant ;';
                        }
                                
                        if ($this->conteneur->getParametre('url_images') == null) {
                                $erreurs[] = '- paramètre "url_images" manquant ;';
                        }
                                
                }
        
                if (empty($this->mappingObservation)) {
                        $erreurs[] = '- le fichier de configuration ne contient pas le tableau [mapping_observation] ou celui-ci est vide ;';
                } else {
                        $champsMappingObs = array('id_observation', 'date_observation', 'date_transmission', 'famille', 'nom_sel', 'nom_sel_nn', 'nt',
                                        'ce_zone_geo', 'lieudit', 'station', 'milieu', 'ce_utilisateur', 'nom', 'prenom');
                        foreach ($champsMappingObs as $champ) {
                                if (!isset($this->mappingObservation[$champ])) {
                                        $erreurs[] = '- le mapping du champ "'.$champ.'" pour l\'observation est manquant ;';
                                }
                        }
                }
        
                if (empty($this->mappingFiltre)) {
                        $erreurs[] = '- le fichier de configuration ne contient pas le tableau [mapping_masque] ou celui-ci est vide ;';
                } else {
                        $champsMappingFiltre = array('famille', 'ns', 'nn', 'date', 'tag', 'commune');
                        foreach ($champsMappingFiltre as $champ) {
                                if (!isset($this->mappingFiltre[$champ])) {
                                        $erreurs[] = '- le mapping du champ "'.$champ.'" pour l\'observation est manquant ;';
                                }
                        }
                }
        
                $tris_possibles = $this->conteneur->getParametre('tris_possibles');
                if (empty($tris_possibles)) {
                        $erreurs[] = '- le fichier de configuration ne contient pas le parametre tris_possibles ou celui-ci est vide ;';
                }
        
                if (!empty($erreurs)) {
                        $e = 'Erreur lors de la configuration : '."\n";
                        $e .= implode("\n", $erreurs);
                        throw new Exception($e, RestServeur::HTTP_CODE_ERREUR);
                }
        }
        
        /** 
         * Verifier que les paramètres de tri sont bien autorisés et qu'ils sont au bon format.
         */
        private function verifierParametresTri() {
        
                $erreurs = array();
                $tris_possibles = $this->conteneur->getParametre('tris_possibles');
                $tris_possibles_tableau = explode(',', $tris_possibles);
                if(isset($this->parametres['tri']) && !in_array($this->parametres['tri'], $tris_possibles_tableau)) {
                        $erreurs[] = '- le type de tri demandé est incorrect, les valeurs possibles sont '.$tris_possibles.' ;';
                }
        
                if(isset($this->parametres['tri']) && $this->parametres['tri'] == "votes") {
                        if(!isset($this->parametres['protocole']) || !is_numeric($this->parametres['protocole'])) {
                                $erreurs[] = '- Le paramètre protocole est obligatoire en cas de tri par vote et doit être un entier ;';
                        }
                }
        
                $directions_tri = array('asc', 'desc');
                if(isset($this->parametres['ordre']) && !in_array($this->parametres['ordre'], $directions_tri)) {
                        $erreurs[] = '- la direction du tri demandé est incorrecte, les valeurs supportées sont asc ou desc ;';
                }
                        
                if (!empty($erreurs)) {
                        $e = 'Erreur lors de l\'analyse des parametres du tri : '."\n";
                        $e .= implode("\n", $erreurs);
                        throw new Exception($e, RestServeur::HTTP_CODE_ERREUR);
                }
        }
        
        private function verifierParametreFormatRetour() {
                $erreurs = array();
                $formats_possibles_str = $this->conteneur->getParametre('formats_possibles');
                $formats_possibles = explode(',',$formats_possibles_str);

                if(isset($this->parametres['format']) && !in_array($this->parametres['format'], $formats_possibles)) {
                        $erreurs[] = "- le format d'image demandé n'est pas supporté ; Les format supportés sont : ".$formats_possibles_str;
                }
                        
                if (!empty($erreurs)) {
                        $e = 'Erreur lors de l\'analyse du format de retour demandé : '."\n";
                        $e .= implode("\n", $erreurs);
                        throw new Exception($e, RestServeur::HTTP_CODE_ERREUR);
                }
        }
        
        private function initialiserFormatRetour() {
                $this->formatRetour = isset($this->parametres['format']) ? $this->parametres['format'] : $this->formatRetour;
        }

        /**
         * Initialiser les variables de tri depuis les paramètres  
         * */
        private function initialiserTri() {
                $this->tri = isset($this->parametres['tri']) ? $this->parametres['tri'] : $this->tri;
                $this->directionTri = isset($this->parametres['ordre']) ? $this->parametres['ordre'] : $this->directionTri;
        }
        
        /** Pour eviter les requêtes trop gourmandes, on supprime les caractères passe-partout
         * @param les paramètres de l'application
         * */
        public function nettoyerParametres($parametres) {
                $parametresRetour = array();
                foreach ($parametres as $cle => $valeur) {
                        $valSansPourcent = trim($valeur, "% ");
                        if ($valSansPourcent != '') {
                                $parametresRetour[$cle] = $valeur;
                        }
                }
                
                return $parametresRetour;
        }
        
        /**
         * Nettoyer les jokers
         * @param la valeur du masque
         * */
        private function remplacerParJokerCaractere($valeurMasque) {
                return str_replace(array('-',' '), '_', $valeurMasque);
        }

        //TODO: déplacer les fonctions ci dessus et dessous dans une classe
        // utilitaire
        
        /**
         * Supprimer les accents des chaines de caractères
         * */
        function supprimerAccents($str, $charset='utf-8')
        {
                $str = htmlentities($str, ENT_NOQUOTES, $charset);
        
                $str = preg_replace('#&([A-za-z])(?:acute|cedil|circ|grave|orn|ring|slash|th|tilde|uml);#', '\1', $str);
                $str = preg_replace('#&([A-za-z]{2})(?:lig);#', '\1', $str); // pour les ligatures e.g. '&oelig;'
                $str = preg_replace('#&[^;]+;#', '', $str); // supprime les autres caractères
        
                return $str;
        }
        
        /**
         * Normaliser en supprimant les accents et en mettant en minuscule
         * @param $mot_cle le mot recherché
         * */
        private function normaliserMotCle($mot_cle) {
                return mb_strtolower($this->supprimerAccents(trim($mot_cle)));
        }
        
        /**
         * Récupérer le numéro du département d'un fichier de configuration
         * */
        private function obtenirIdDepartement($nomDpt) {
        
                $nomDpt = $this->supprimerAccents($nomDpt);
                $nomDpt = strtolower(str_replace(' ','-',$nomDpt));
        
                $idDpt = $this->conteneur->getParametre($nomDpt);
                if($idDpt == null || $idDpt == ' ') {
                        $idDpt = ' ';
                }
                return $idDpt;
        }
        
        
        /**
         * Obtenir le type de requête à exécuter en fonction des paramètres de recherche
         * @param $parametres les paramètres de l'application
         * */
        private function getTypeRequete($parametres) {

                
                $typeRequete = 'simple';
                
                // Dans ce cas précis, les informations concernant le depart, la limite ou l'ordre ne 
                // rentre pas en compte dans le type de requête ; ce ne sont que des compléments.
                unset($parametres['navigation.depart']);
                unset($parametres['navigation.limite']);
                unset($parametres['ordre']);
                
                // En revanche, chaque masque est associé à un type de requête particulier.
                $masquesObservation = array('masque', 'masque.departement', 'masque.ns', 'masque.genre', 'masque.date', 'masque.commune', 'masque.famille', 'masque.auteur', 'masque.nn', 'masque.referentiel');
                $masquesImage = array('masque', 'masque.tag');
                
                // Le type de requête est défini par les tables qu'il doit inclure (observation, image, ou les deux) 
                $requeteSimple = false;
                $pourObservation = false;
                $pourImage = false;
                
                // S'il n'y a aucun paramètre, on lance une requête simple
                if (empty($parametres)) {
                        $requeteSimple = true;
                }
                
                // Si l'un des masques demandé concerne l'observation
                foreach ($masquesObservation as $masque) {
                        if (isset($parametres[$masque])) {
                                $pourObservation = true;
                                break;
                        }
                }
                
                // Si l'un des masques demandé concerne les images
                foreach ($masquesImage as $masque) {
                        if (isset($parametres[$masque])) {
                                $pourImage = true;
                                break;
                        }
                }
                
                // Selon les tri
                if (isset($parametres['tri'])) {
                        switch ($parametres['tri']) {
                                case 'votes' :
                                case 'tags' :
                                        $pourImage = true;
                                        break;
                                default : //case 'date_observation' :
                                        if (sizeof($parametres) > 1) {
                                                $pourObservation = true;
                                        }
                        }
                }
                
                // Vérifier la combinaison des booléens pour en déduire le type de requête
                if ($pourObservation && $pourImage) {
                        $typeRequete = 'obs-images';
                } else {
                        if ($pourImage) {
                                $typeRequete = 'images';
                        } else if ($pourObservation) {
                                $typeRequete = 'obs';
                        } else { // if ($requeteSimple)
                                $typeRequete = 'simple';
                        }
                }
                        
                return $typeRequete;
        }
        
        
        private function doitJoindreTableVotes() {
                return ($this->tri == 'votes');
        }
        
        private function doitJoindreTableTags() {
                return ($this->tri == 'tags');
        }

        /*-------------------------------------------------------------------------------
                                                                FORMATER ET METTRE EN FORME
        --------------------------------------------------------------------------------*/
        
        /**
        *  Formater une observation depuis une ligne liaison
        *  @param $liaison liaison issue de la recherche
        *  @return $observation l'observation mise en forme
        * */
        private function formaterObservation($liaison) {
                $observation = array();
                foreach ($this->mappingObservation as $nomOriginal => $nomFinal) {
                        $observation[$nomFinal] = $liaison[$nomOriginal];
                }

                return $observation;
        }
        
        /**
        *  Formater une observation depuis une ligne liaison
        *  @param $liaison liaison issue de la recherche
        *  @return $observation l'observation mise en forme
        * */
        private function formaterVotes($votes) {
                $retour = array();
                foreach ($votes as $vote) {
                        $retour_vote = array();
                        foreach ($vote as $param=>$valeur) {
                                if (strpos($this->mappingVotes[$param], 'protocole.') === 0) {
                                        $retour_protocole[$this->mappingVotes[$param]] = $valeur;
                                } else {
                                        $retour_vote[$this->mappingVotes[$param]] = $valeur;
                                }
                        }
                        if (!isset($retour[$vote['ce_image']][$vote['ce_protocole']])) {
                                $retour[$vote['ce_image']][$vote['ce_protocole']] = $retour_protocole;
                        }
                        $retour[$vote['ce_image']][$vote['ce_protocole']]['votes'][$vote['id_vote']] = $retour_vote;
                }
                
                return $retour;
        }
        
        /**
         * Formater le lien de l'image en fonction du fichier de config et de l'identifiant de l'image
         * */
        private function formaterLienImage($idImage) {
                $idImage = sprintf('%09s', $idImage);
                $url = $this->conteneur->getParametre('url_images');
                $urlImage = sprintf($url, $idImage, $this->formatRetour);
                return $urlImage;
        }
        
        private function proteger($valeur) {
                if (is_array($valeur)) {
                        return $this->bdd->protegerTableau($valeur);
                } else {
                        return $this->bdd->proteger($valeur);
                }
        }
}
?>