Subversion Repositories eFlore/Applications.del

Compare Revisions

Ignore whitespace Rev 1513 → Rev 1514

/trunk/services/modules/0.1/images/ListeImages.old.php
New file
0,0 → 1,1349
<?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($ressources, $parametres);
switch ($type) {
case 'obs' :
$liaisons = $this->chargerLiaisonsObs();
break;
case 'images' :
$liaisons = $this->chargerLiaisonsImages();
break;
case 'obs-images' :
$liaisons = $this->chargerLiaisons();
break;
case 'id':
$liaisons = $this->chargerLiaisonsParId();
break;
default : //case simple !
$liaisons = $this->chargerLiaisonsSimple();
}
$images = array();
if($liaisons) {
// 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();
if ($type == 'id') {
$clefsImages =array_keys($images);
$resultat->corps = $images[$clefsImages[0]];
} else {
$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 'tag_cel' :
$where[] = ' '.$this->creerFiltreMotsClesCel($valeurMasque);
break;
case 'tag_pictoflora' :
$where[] = ' '.$this->creerFiltreMotsClesPictoflora($valeurMasque);
break;
case 'referentiel' :
$where[] = ' dob.nom_referentiel LIKE '.$this->proteger($valeurMasque.'%');
break;
case 'ns' :
$where[] = ' nom_sel LIKE '.$this->proteger($valeurMasque.'%');
break;
case 'nn' :
$num_noms = $valeurMasque;
$num_noms = explode(',', $num_noms);
$num_noms = array_map('intval', $num_noms);
$num_noms = array_filter($num_noms);
$num_noms = implode(',', $num_noms);
$where[] = "(nom_sel_nn IN ($num_noms) OR nom_ret_nn IN ($num_noms)) ";
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;
}
/**
* Générer la chaine de recherche dans les mots clés en fonction du masque
* @param $valeurMasque le mot clé recherché
* */
private function creerFiltreMotsClesPictoflora($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)';
}
$requeteMotsClesImgPublic = implode(' AND ', $requeteMotsClesImgPublic);
$masque = '('.$requeteMotsClesImgPublic.') ';
return $masque;
}
private function creerFiltreMotsClesCel($valeurMasque) {
$mots_cles = explode(' ', $valeurMasque);
$requeteMotsClesImg = array();
$requeteMotsClesObs = 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.'%'));
$requeteMotsClesImg[] = 'di.mots_cles_texte LIKE '.$requeteMotsCles;
$requeteMotsClesObs[] = 'dob.mots_cles_texte LIKE '.$requeteMotsCles;
}
$requeteMotsClesImg = implode(' AND ', $requeteMotsClesImg);
$requeteMotsClesObs = implode(' AND ', $requeteMotsClesObs);
$masque = '('.
'('.$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[] = "dob.nom_referentiel LIKE '$ref%'";
}
// nom sel
if (isset($masques['masque.ns'])) {
$nom_sel = $masques['masque.ns'];
$conditionsObs[] = "nom_sel LIKE '$nom_sel%'";
}
// num nom
if (isset($masques['masque.nn'])) {
$num_noms = $masques['masque.nn'];
$num_noms = explode(',', $num_noms);
$num_noms = array_map('intval', $num_noms);
$num_noms = array_filter($num_noms);
$num_noms = implode(',', $num_noms);
$conditionsObs[] = "(nom_sel_nn IN ($num_noms) OR nom_ret_nn IN ($num_noms)) ";
}
// num taxon
if (isset($masques['masque.nt'])) {
$num_taxon = $masques['masque.nt'];
$conditionsObs[] = 'nt = '.intval($num_taxon);
}
// 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);
}
if (isset($masques['masque.tag_cel'])) {
$motsCles = $masques['masque.tag_cel'];
$conditionsObs[] = $this->creerFiltreMotsClesCel($motsCles);
}
 
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_pictoflora'])) {
$tag = $masques['masque.tag_pictoflora'];
$conditionsImg[] = $this->creerFiltreMotsClesPictoflora($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 . ' -- ' . __FILE__ . ':' . __LINE__);
$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 . ' -- ' . __FILE__ . ':' . __LINE__);
// 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 . ' -- ' . __FILE__ . ':' . __LINE__);
// 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 . ' -- ' . __FILE__ . ':' . __LINE__);
 
$total = (int) $resultatNbImages[0]['nb'];
$this->navigation->setTotal($total);
}
 
return $liaisons;
}
 
/**
* Charge les liaisons pour une seule image dont l'id est spécifié dans l'URL
* Copie de chargerLiaisonsObs avec critère sur l'id_image uniquement
* Supporte seulement le masque sur referentiel
*/
private function chargerLiaisonsParId() {
 
$idImage = $this->ressources[0];
 
// Récupérer les liaisons
$requeteObs = ' SELECT SQL_CALC_FOUND_ROWS dob.id_observation as id_observation, dob.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 '.
' WHERE doi.id_image = '.intval($idImage);
 
if (isset($this->parametres['masque.referentiel'])) {
$requeteObs .= " AND dob.nom_referentiel LIKE '" . $this->parametres['masque.referentiel'] . "%'";
}
 
$observations = $this->bdd->recupererTous($requeteObs . ' -- ' . __FILE__ . ':' . __LINE__);
 
$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 une observation
* */
private function chargerLiaisonsObs() {
// Récupérer les liaisons
$requeteObs = ' SELECT SQL_CALC_FOUND_ROWS dob.id_observation as id_observation, dob.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 . ' -- ' . __FILE__ . ':' . __LINE__);
 
$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, dob.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, '.
' 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 . ' -- ' . __FILE__ . ':' . __LINE__);
$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_pictoflora'])) {
// Et si on a cherché par tag ?
$tag = $this->parametres['masque.tag_pictoflora'];
$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 . ' -- ' . __FILE__ . ':' . __LINE__);
$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_pictoflora'])) {
$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 . ' -- ' . __FILE__ . ':' . __LINE__);
$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', 'dob.nom_referentiel', '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 . ' -- ' . __FILE__ . ':' . __LINE__);
$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 . ' -- ' . __FILE__ . ':' . __LINE__);
//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($ressources, $parametres) {
 
// une image par id
if ((count($ressources) == 1) && is_numeric($ressources[0])) {
return 'id';
}
 
$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', 'masque.tag_cel');
$masquesImage = array('masque', 'masque.tag_pictoflora');
// 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);
}
}
}
?>