Subversion Repositories eFlore/Applications.del

Rev

Rev 1326 | Rev 1328 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
709 gduche 1 
<?php
2 
// declare(encoding='UTF-8');
3 
/**
4 
	* Le web service image récupère toutes les données de la table del_obs_images
5 
 * pour retourner une liste d'images associée à une observation
6 
 *
7 
 * @category	php 5.2
8 
 * @package	del
9 
 * @subpackage images
10 
 * @author		Jean-Pascal MILCENT <jpm@tela-botanica.org>
11 
 * @copyright	Copyright (c) 2012, Tela Botanica (accueil@tela-botanica.org)
12 
 * @license	http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
13 
 * @license	http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
14 
 * @version	$Id: Bdd.php 403 2012-02-22 14:35:20Z gduche $
15 
 * @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=ApiIdentiplante01Images
16 
 */
17 
 
1326 gduche 18 
 
19 
/**
20 
 * FONCTION TEMPORAIRE de debug pour afficher le contenu d'une variable en format lisible
21 
 * @param $r la variable à afficher
22 
 * */
23 
function debug($r) {
24 
	echo '<pre>'.print_r($r, true).'</pre>';
25 
}
26 
 
27 
 
28 
/**
29 
 * Le service ListeImages récupère les données des tables observation et images
30 
 * et les mets au format JSON pour identiplante / pictoflora
31 
 * */
751 delphine 32 
class ListeImages {
709 gduche 33 
 
1326 gduche 34 
 
35 
	// Variables :
36 
	// Configuration générale du service
719 gduche 37 
	private $conteneur;
725 gduche 38 
	private $navigation;
1326 gduche 39 
	private $bdd;
725 gduche 40 
	private $gestionBdd;
1326 gduche 41 
 
42 
	// Parametres
43 
	private $ressources = array();
759 delphine 44 
	private $parametres = array();
1326 gduche 45 
	private $masque;
46 
 
800 aurelien 47 
	private $tri = 'date_transmission';
48 
	private $directionTri = 'desc';
709 gduche 49 
 
1326 gduche 50 
	private $imageIds = array();
51 
 
52 
 
53 
	/**
54 
	 * Constructeur de l'application
55 
	 * Initialisation des variables générale de l'application
56 
	 * @param Conteneu $conteneur le conteneur de classes de l'application
57 
	 * */
719 gduche 58 
	public function __construct(Conteneur $conteneur = null) {
59 
		$this->conteneur = $conteneur == null ? new Conteneur() : $conteneur;
791 aurelien 60 
		$this->conteneur->chargerConfiguration('config_departements_bruts.ini');
798 aurelien 61 
		$this->conteneur->chargerConfiguration('config_mapping_votes.ini');
775 aurelien 62 
		$this->conteneur->chargerConfiguration('config_images.ini');
725 gduche 63 
		$this->navigation = $conteneur->getNavigation();
64 
		$this->masque = $conteneur->getMasque();
65 
		$this->gestionBdd = $conteneur->getGestionBdd();
775 aurelien 66 
		$this->bdd = $this->gestionBdd->getBdd();
719 gduche 67 
	}
68 
 
1326 gduche 69 
 
709 gduche 70 
	/**
71 
	 * Méthode principale de la classe.
1326 gduche 72 
	 * Lance la récupération des images dans la base et les place dans un objet ResultatService
709 gduche 73 
	 * pour l'afficher.
74 
	 * @param array $ressources les ressources situées après l'url de base (ex : http://url/ressource1/ressource2)
75 
	 * @param array $parametres les paramètres situés après le ? dans l'url
76 
	 * */
77 
	public function consulter($ressources, $parametres) {
1326 gduche 78 
 
759 delphine 79 
		$this->initialiserRessourcesEtParametres($ressources, $parametres);
709 gduche 80 
 
81 
		$this->configurer();
711 gduche 82 
		$this->verifierConfiguration();
1326 gduche 83 
 
800 aurelien 84 
		$this->verifierParametresTri();
85 
		$this->initialiserTri();
1326 gduche 86 
 
87 
		$parametres = $this->nettoyerParametres($parametres);
88 
 
89 
		// En fonction des paramètres de recherche, on n'effectue
90 
		// pas la même requête, pour optimiser les jointures et les
91 
		// rapidités d'éxécution.
92 
		$type = $this->getTypeRequete($parametres);
93 
 
94 
		switch ($type) {
95 
			case 'obs' :
96 
				$liaisons = $this->chargerLiaisonsObs();
97 
			break;
98 
			case 'images' :
99 
				$liaisons = $this->chargerLiaisonsImages();
100 
			break;
101 
			case 'obs-images' :
102 
				$liaisons = $this->chargerLiaisons();
103 
			break;
104 
			default : //case simple !
105 
			$liaisons = $this->chargerLiaisonsSimple();
106 
		}
107 
 
108 
 
109 
		// Partie commune à tous les cas : on complète les liaisons avec les informations des votes
110 
		// et des images, puis on affiche sous forme de JSON
1321 gduche 111 
		$images = $this->chargerImage($liaisons);
112 
		$images = $this->chargerVotes($images);
113 
 
114 
		$resultat = new ResultatService();
115 
		$resultat->corps = array('entete' => $this->conteneur->getEntete(), 'resultats' => $images);
1326 gduche 116 
 
1321 gduche 117 
		return $resultat;
709 gduche 118 
	}
119 
 
800 aurelien 120 
 
121 
 
1326 gduche 122 
	/**************************************************************************************
123 
	 *								FONCTION LIEES AUX REQUETES 						  *
124 
	 **************************************************************************************/
709 gduche 125 
 
126 
	/**
1326 gduche 127 
	 * Charger la clause WHERE en fonction des paramètres de masque
710 gduche 128 
	 * */
1326 gduche 129 
	private function chargerClauseWhere() {
728 gduche 130 
 
709 gduche 131 
		$where = array();
725 gduche 132 
		$tableauMasque = $this->masque->getMasque();
133 
		if (!empty($tableauMasque)) {
134 
			foreach($tableauMasque as $idMasque => $valeurMasque) {
1326 gduche 135 
				//TODO: scinder ceci en fonctions réutilisables ?
136 
				// voir si c'est interessant par rapport à la recherche générale
725 gduche 137 
				$idMasque = str_replace('masque.', '', $idMasque);
138 
				switch ($idMasque) {
1326 gduche 139 
				// nom du masque => nom BDD
725 gduche 140 
					case 'auteur' :
1326 gduche 141 
							$whereAuteur = ' '.$this->creerFiltreAuteur($this->masque->getMasque('auteur'));
142 
									if($whereAuteur != '') {
143 
										$where[] = $whereAuteur;
144 
									}
145 
									break;
791 aurelien 146 
					case 'date' :
1326 gduche 147 
					$whereDate = ' '.$this->creerFiltreDate($valeurMasque);
148 
					if($whereDate != '') {
149 
						$where[] = $whereDate;
150 
					}
151 
					break;
791 aurelien 152 
					case 'departement' :
153 
						$where[] = ' '.$this->creerFiltreIdZoneGeo($valeurMasque);
154 
						break;
725 gduche 155 
					case 'genre' :
719 gduche 156 
						$where[] = ' '.$this->mappingFiltre['ns'].' LIKE '.$this->proteger($valeurMasque.' %');
725 gduche 157 
						break;
158 
					case 'tag' :
791 aurelien 159 
						$where[] = ' '.$this->creerFiltreMotsCles($valeurMasque);
725 gduche 160 
						break;
775 aurelien 161 
					case 'ns' :
791 aurelien 162 
						$where[] = ' nom_sel LIKE '.$this->proteger($valeurMasque.'%');
1326 gduche 163 
						break;
791 aurelien 164 
					case 'commune' :
165 
						$where[] = ' '.$this->mappingFiltre[$idMasque].' LIKE '.$this->proteger(str_replace(array('-',' '), '_', $valeurMasque).'%');
1326 gduche 166 
						break;
791 aurelien 167 
					case 'masque' :
168 
						$where[] = ' '.$this->creerFiltreMasqueGeneral($valeurMasque);
775 aurelien 169 
						break;
725 gduche 170 
					default:
171 
						$where[] = ' '.$this->mappingFiltre[$idMasque].' = '.$this->proteger($valeurMasque);
1326 gduche 172 
						break;
725 gduche 173 
				}
1326 gduche 174 
			}
709 gduche 175 
		}
1326 gduche 176 
 
709 gduche 177 
		if (!empty($where)) {
178 
			return ' WHERE '.implode('AND', $where);
179 
		} else {
180 
			return;
181 
		}
182 
	}
183 
 
1326 gduche 184 
	/**
185 
	 * Créer un masque général lorsque l'on souhaite utiliser le passe partout
186 
	 * @param la valeur du passe partout
187 
	 * */
791 aurelien 188 
	private function creerFiltreMasqueGeneral($valeurMasque) {
1326 gduche 189 
		//TODO: affecter d'aborder les variables, puis les tester pour les
791 aurelien 190 
		// ajouter à la chaine
191 
		$whereAuteur = $this->creerFiltreAuteur($valeurMasque);
1326 gduche 192 
		$whereIdZoneGeo = $this->creerFiltreIdZoneGeo($valeurMasque);
193 
 
791 aurelien 194 
		$masqueGeneral = '( '.
1326 gduche 195 
				(($whereAuteur != '') ? $whereAuteur.' OR ' : '' ).
196 
				(($whereIdZoneGeo != '') ? $whereIdZoneGeo.' OR ' : '' ).
197 
				'zone_geo LIKE '.$this->proteger($this->remplacerParJokerCaractere($valeurMasque).'%').' OR '.
198 
				$this->creerFiltreMotsCles($valeurMasque).' OR '.
199 
				'nom_sel LIKE '.$this->proteger($valeurMasque.'%').' OR '.
200 
				'famille LIKE '.$this->proteger($valeurMasque.'%').' OR '.
201 
				'milieu LIKE '.$this->proteger($valeurMasque).' OR '.
202 
				$this->mappingFiltre['ns'].' LIKE '.$this->proteger('%'.$valeurMasque.'% %').' OR '.
203 
				$this->creerFiltreDate($valeurMasque).
204 
				') ';
791 aurelien 205 
 
206 
		return $masqueGeneral;
207 
	}
208 
 
1326 gduche 209 
	/**
210 
	 * Créer le filtre auteur en recherchant dans son nom, prénom, adresse email en fonction
211 
	 * de la chaine donnée
212 
	 * @param la valeur recherchée
213 
	 * */
791 aurelien 214 
	private function creerFiltreAuteur($valeurMasque) {
215 
		$masque = '';
216 
		$auteurId = $valeurMasque;
217 
		if (is_numeric($auteurId)) {
218 
			$masque = ' ce_utilisateur = '.$auteurId;
219 
		} else {
220 
			if (strpos($auteurId, '@') === false) {
221 
				$tableauNomPrenom = explode(' ',$auteurId, 2);
222 
				if(count($tableauNomPrenom) == 2) {
223 
					// on teste potentiellement un nom prenom ou bien un prénom nom
224 
					$masque = '('.
1326 gduche 225 
							'(nom LIKE '.$this->proteger($tableauNomPrenom[0].'%').' AND '.
226 
							'prenom LIKE '.$this->proteger($tableauNomPrenom[1].'%').') OR '.
227 
							'(nom LIKE '.$this->proteger($tableauNomPrenom[1].'%').' AND '.
228 
							'prenom LIKE '.$this->proteger($tableauNomPrenom[0].'%').') OR '.
229 
							'(dob.nom_utilisateur LIKE '.$this->proteger($tableauNomPrenom[0].'%').' AND '.
230 
							'dob.prenom_utilisateur LIKE '.$this->proteger($tableauNomPrenom[1].'%').') OR '.
231 
							'(dob.nom_utilisateur LIKE '.$this->proteger($tableauNomPrenom[1].'%').' AND '.
232 
							'dob.prenom_utilisateur LIKE '.$this->proteger($tableauNomPrenom[0].'%').') OR '.
233 
							'(nom LIKE '.$this->proteger($valeurMasque.'%').') OR '.
234 
							'(prenom LIKE '.$this->proteger($valeurMasque.'%').') OR '.
235 
							'(dob.nom_utilisateur LIKE '.$this->proteger($valeurMasque.'%').') OR '.
236 
							'(dob.prenom_utilisateur LIKE '.$this->proteger($valeurMasque.'%').') '.
237 
							')';
791 aurelien 238 
				} else {
239 
					$masque = '(
240 
						            (nom LIKE '.$this->proteger($auteurId.'%').' OR '.
1326 gduche 241 
							            'prenom LIKE '.$this->proteger($auteurId.'%').' OR '.
242 
							            'dob.nom_utilisateur LIKE '.$this->proteger($auteurId.'%').' OR '.
243 
							            'dob.prenom_utilisateur LIKE '.$this->proteger($auteurId.'%').')'.
244 
							            ')';
791 aurelien 245 
				}
246 
			} else {
1274 aurelien 247 
				$masque = " courriel LIKE ".$this->proteger($valeurMasque.'%').
1326 gduche 248 
				" OR dob.courriel_utilisateur LIKE ".$this->proteger($valeurMasque.'%')." ";
791 aurelien 249 
			}
250 
		}
251 
		return $masque;
252 
	}
253 
 
254 
 
1326 gduche 255 
	/**
256 
	 * Obtenir une chaine de caractère concaténant nom et prénom séparé par une virgule
257 
	 * @param String $auteurId l'identifiant de l'auteur
258 
	 * @return String la chaine de concaténation
259 
	 * */
260 
	private function getChaineNomPrenom($auteurId) {
261 
		$nomPrenom = explode(' ', $auteurId);
262 
		$nomPrenom = $this->proteger($nomPrenom);
263 
		$chaineNomPrenom = implode(', ', $nomPrenom);
264 
		return $chaineNomPrenom;
791 aurelien 265 
	}
266 
 
1326 gduche 267 
	/**
268 
	 * Créer le filtre de recherche par zone géographique en fonction du masque
269 
	 * @param $valeurMasque le terme de la recherche
270 
	 * */
791 aurelien 271 
	private function creerFiltreIdZoneGeo($valeurMasque) {
272 
		$masque = '';
273 
		$dept = $valeurMasque;
274 
		if (is_numeric($dept)) {
275 
			$dept = sprintf('%02s', $dept);
276 
			$dept = sprintf("%-'_5s", $dept);
277 
			$masque = " ce_zone_geo LIKE ".$this->proteger('INSEE-C:'.$dept);
278 
		} else {
279 
			$deptId = $this->conteneur->getParametre($dept);
280 
			if ($deptId != null) {
281 
				$masque = " ce_zone_geo LIKE ".$this->proteger('INSEE-C:'.$deptId.'%');
282 
			} else {
283 
				$id = $this->obtenirIdDepartement($valeurMasque);
284 
				$masque = " ce_zone_geo LIKE ".$this->proteger('INSEE-C:'.$id.'%');
285 
			}
286 
		}
287 
		return $masque;
288 
	}
289 
 
1326 gduche 290 
	/**
291 
	 * Générer la chaine de recherche pour la date en  fonction du masque
292 
	 * @param $valeurMasque la date recherchée (AAAA ou JJ/MM/AAAA)
293 
	 * */
791 aurelien 294 
	private function creerFiltreDate($valeurMasque) {
295 
		//TODO: définir dans le fichier de config un tableau contenant plusieurs format de date
296 
		// autorisés pour la recherche, qui seraient ajoutés au OR
297 
		$masque = '(';
298 
		$masque .= (is_numeric($valeurMasque)) ? ' YEAR(date_observation) = '.$this->proteger($valeurMasque).' OR ' : '';
299 
		$masque .= " DATE_FORMAT(date_observation, '%d/%m/%Y') = ".$this->proteger($valeurMasque).' '.
1326 gduche 300 
				')';
791 aurelien 301 
		return $masque;
302 
	}
801 aurelien 303 
 
1326 gduche 304 
	/**
305 
	 * Générer la chaine de recherche dans les mots clés en fonction du masque
306 
	 * @param $valeurMasque le mot clé recherché
307 
	 * */
791 aurelien 308 
	private function creerFiltreMotsCles($valeurMasque) {
1326 gduche 309 
 
800 aurelien 310 
		$mots_cles = explode(' ', $valeurMasque);
812 gduche 311 
		$requeteMotsClesImg = array();
312 
		$requeteMotsClesObs = array();
1180 aurelien 313 
		$requeteMotsClesImgPublic = array();
1326 gduche 314 
 
800 aurelien 315 
		foreach($mots_cles as $mot_cle) {
1180 aurelien 316 
			//TODO: rechercher sur les mots clés normalisés dans tous les cas ?
857 gduche 317 
			$requeteMotsCles = $this->proteger('%'.$mot_cle.'%');
1180 aurelien 318 
			$motsCleProtege = $this->proteger($this->normaliserMotCle('%'.$mot_cle.'%'));
1326 gduche 319 
			$requeteMotsClesImgPublic[] = 'di.id_image IN (SELECT ce_image FROM del_image_tag WHERE tag_normalise LIKE '.$motsCleProtege.' AND actif = 1)';
857 gduche 320 
			$requeteMotsClesImg[] = 'di.mots_cles_texte LIKE '.$requeteMotsCles;
321 
			$requeteMotsClesObs[] = 'dob.mots_cles_texte LIKE '.$requeteMotsCles;
800 aurelien 322 
		}
1326 gduche 323 
 
1180 aurelien 324 
		$requeteMotsClesImgPublic = implode(' AND ', $requeteMotsClesImgPublic);
857 gduche 325 
		$requeteMotsClesImg = implode(' AND ', $requeteMotsClesImg);
326 
		$requeteMotsClesObs = implode(' AND ', $requeteMotsClesObs);
1326 gduche 327 
 
800 aurelien 328 
		$masque = '('.
1326 gduche 329 
				'('.$requeteMotsClesImgPublic.') OR '.
330 
				'('.$requeteMotsClesImg.') OR '.
331 
				'('.$requeteMotsClesObs.') '.
332 
				')';
791 aurelien 333 
 
1326 gduche 334 
		return $masque;
709 gduche 335 
	}
336 
 
1326 gduche 337 
	// ??
1168 aurelien 338 
	private function assemblercomptageOccurencesMotsClesCel() {
339 
		$chaineMotsClesAffiches = $this->conteneur->getParametre('mots_cles_cel_affiches');
340 
		$tabMotsClesAffiches = explode(',',$chaineMotsClesAffiches);
341 
		$chaineSql = '';
1326 gduche 342 
 
1168 aurelien 343 
		// Comptage du nombre de mots clés officiels présents dans la chaine mots clés texte
344 
		foreach ($tabMotsClesAffiches as $motCle) {
345 
			if($chaineSql != '') {
346 
				$chaineSql .= ' + ';
347 
			}
348 
			$chaineSql .= 'IF(FIND_IN_SET('.$this->proteger($motCle).',di.mots_cles_texte) != 0, 1, 0)';
349 
		}
1326 gduche 350 
 
1168 aurelien 351 
		return '('.$chaineSql.')';
352 
	}
353 
 
1326 gduche 354 
	private function getTri() {
800 aurelien 355 
		$order = '';
951 aurelien 356 
		if($this->doitJoindreTableVotes()) {
357 
			$order = ' GROUP BY dvote.ce_image, dob.id_observation ORDER BY total_votes '.$this->directionTri.', date_transmission desc ';
1168 aurelien 358 
		} else if($this->doitJoindreTableTags()) {
359 
			$order = ' GROUP BY doi.id_image ORDER BY total_tags '.$this->directionTri.', date_transmission desc ';
951 aurelien 360 
		} else {
800 aurelien 361 
			$order = ' ORDER BY '.$this->tri.' '.$this->directionTri.' ';
362 
		}
363 
		return $order;
364 
	}
365 
 
709 gduche 366 
	/**
1326 gduche 367 
	 * Compter le nombre total d'images dans la base pour affichage dans entete.
368 
	 * */
369 
	private function getFoundRows() {
709 gduche 370 
		$requete = 'SELECT FOUND_ROWS() AS nbre ';
719 gduche 371 
		$resultats = $this->bdd->recuperer($requete);
709 gduche 372 
		return (int) $resultats['nbre'];
373 
	}
374 
 
1326 gduche 375 
 
709 gduche 376 
	/**
1326 gduche 377 
	 * En fonction des paramètres, générer les conditions de recherche
378 
	 * des observations
379 
	 * */
380 
	private function getConditionsObs() {
1327 gduche 381 
		$conditionsObs = array();
1326 gduche 382 
		$masques = $this->masque->getMasque();
383 
		if (isset($masques['masque'])) {
384 
			$passe = $masques['masque'];
385 
 
386 
			// Si on a saisi le masque passe partout, alors on doit chercher dans tous les champs
387 
			// de la table observation (OR)
388 
			$conditionLibre = array();
389 
 
390 
			if (!isset($masques['masque.ns'])) {
391 
				$conditionsLibre[] = "nom_sel LIKE '$passe%'";
392 
			}
393 
 
394 
			if (!isset($masques['masque.famille'])) {
395 
				$conditionsLibre[] = "famille LIKE '$passe%'";
396 
			}
397 
 
398 
			if (!isset($masques['masque.milieu'])) {
399 
				$conditionsLibre[] = "nom_sel LIKE '$passe%'";
400 
			}
401 
 
402 
			if (!isset($masques['masque.date'])) {
403 
				$conditionsLibre[] = $this->creerFiltreDate($passe);
404 
			}
405 
 
406 
			if (!isset($masques['masque.auteur'])) {
407 
				$conditionsLibre[] = $this->creerFiltreAuteur($passe);
408 
			}
409 
 
410 
			/*
411 
			 * FIXME : remplacer par motcle projet !
412 
			* if (!isset($masques['masque.tag'])) {
413 
			$conditionsLibre[] = "mots_cles_texte LIKE '%$passe%'";
414 
			}*/
415 
 
416 
			$conditionsObs[] = implode(' OR ', $conditionsLibre);
417 
		}
418 
 
419 
		// nom sel
420 
		if (isset($masques['masque.ns'])) {
421 
			$nom_sel = $masques['masque.ns'];
422 
			$conditionsObs[] = "nom_sel LIKE '$nom_sel%'";
423 
		}
424 
 
425 
		// famille
426 
		if (isset($masques['masque.famille'])) {
427 
			$famille = $masques['masque.famille'];
428 
			$conditionsObs[] = "famille LIKE '$famille%'";
429 
		}
430 
 
431 
		// genre
432 
		if (isset($masques['masque.genre'])) {
433 
			$genre = $masques['masque.genre'];
434 
			$conditionsObs[] = "nom_sel LIKE '$genre%'";
435 
		}
436 
 
437 
		// milieu
438 
		if (isset($masques['masque.milieu'])) {
439 
			$milieu = $masques['masque.milieu'];
440 
			$conditionsObs[] = "nom_sel LIKE '$milieu%'";
441 
		}
442 
 
443 
		// date
444 
		if (isset($masques['masque.date'])) {
445 
			$date = $masques['masque.date'];
446 
			$conditionsObs[] = $this->creerFiltreDate($date);
447 
		}
448 
 
449 
		// utilisateur
450 
		if (isset($masques['masque.auteur'])) {
451 
			$auteur = $masques['masque.auteur'];
452 
			$conditionsObs[] = $this->creerFiltreAuteur($auteur);
453 
		}
454 
 
455 
		// commune
456 
		if (isset($masques['masque.commune'])) {
457 
			$commune = $masques['masque.commune'];
458 
			$conditionsObs[] = " zone_geo LIKE ".$this->proteger(str_replace(array('-',' '), '_', $commune).'%');
459 
		}
460 
 
461 
		// commune
462 
		if (isset($masques['masque.departement'])) {
463 
			$dept = $masques['masque.departement'];
464 
			$conditionsObs[] = $this->creerFiltreIdZoneGeo($dept);
465 
		}
466 
 
467 
		return $conditionsObs;
468 
	}
469 
 
470 
	/**
471 
	 * Obtenir le tableu de chaines de condition de requete images en fonction des masques
472 
	 * */
473 
	private function getConditionsImages() {
474 
		$conditionsImg = array();
475 
		$masques = $this->masque->getMasque();
476 
		if (isset($masques['masque.tag'])) {
477 
			$tag = $masques['masque.tag'];
478 
			$conditionsImg[] = " dit.tag_normalise LIKE '$tag%' ";
479 
			$conditionsImg[] = " di.mots_cles_texte LIKE '%$tag%' ";
480 
		}
481 
 
482 
		return $conditionsImg;
483 
	}
484 
 
485 
 
486 
	/*-------------------------------------------------------------------------------
487 
	 CHARGEMENT DES IMAGES
488 
	--------------------------------------------------------------------------------*/
489 
	/**
490 
	 * Chargement depuis la bdd de toutes les liaisons entre images et observations
491 
	 * Méthode appelée uniquement lorsque les paramètres sont vides
492 
	 * */
493 
	private function chargerLiaisonsSimple() {
494 
 
495 
		// On récupère d'abord les N images de del_obs_image, éventuellement triées,
496 
		// Et on complète avec les informations des observations associées
497 
		$requeteImages = ' SELECT *, di.mots_cles_texte as mots_cles_texte_image '.
498 
						 ' FROM del_obs_image doi '.
499 
						 ' INNER JOIN del_image di ON doi.id_image = di.id_image ';
500 
 
501 
 
502 
		// Si le tri se fait par date d'observation, on récupère les identifiants de N observations triées
503 
		if (isset($this->parametres['tri']) && $this->parametres['tri'] == 'date_observation') {
504 
 
505 
			$ordre = isset($this->parametres['ordre']) ? $this->parametres['ordre'] : 'DESC';
506 
 
507 
			$requeteIdObs = ' SELECT doi.id_image  as id_image '.
508 
							' FROM del_obs_image doi '.
509 
							' INNER JOIN del_observation dob ON dob.id_observation = doi.id_observation '.
510 
							' INNER JOIN del_image di ON doi.id_image = di.id_image '.
511 
							' ORDER BY date_observation '.$ordre.', dob.id_observation '.$ordre;
512 
			$requeteIdObs .= $this->gestionBdd->getLimitSql();
513 
 
514 
			// Récupérer les N observations triées par date
515 
			$observations = $this->bdd->recupererTous($requeteIdObs);
516 
 
517 
			$idsImages = array();
518 
			foreach ($observations as $observation) {
519 
				$idsImages[] = $observation['id_image'];
520 
			}
521 
 
522 
			$chaineIdImages = implode(',', $idsImages);
523 
			$requeteImages .= ' WHERE doi.id_image IN ('.$chaineIdImages.') '.
524 
							  ' ORDER BY FIELD(doi.id_image,  '.$chaineIdImages.')'.
525 
							  ' LIMIT '.$this->navigation->getLimite(); // On limite sur le nombre car les obs peuvent avoir plusieurs images
526 
 
527 
		} else {
528 
			$requeteImages .= ' ORDER BY id_observation DESC';
529 
			$requeteImages .= $this->gestionBdd->getLimitSql();
530 
		}
531 
 
532 
 
533 
		/**
534 
		 * 88307
535 
		 * SELECT *, di.mots_cles_texte as mots_cles_texte_image  FROM del_obs_image doi
536 
		 * INNER JOIN del_image di ON doi.id_image = di.id_image
537 
		 * WHERE id_observation IN (783590,922353,922351,922349,921316,921315,921313,921312,783388,921310,921309,921308)
538 
		 * ORDER BY FIELD(id_observation,  783590,922353,922351,922349,921316,921315,921313,921312,783388,921310,921309,921308)
539 
		 * */
540 
		$liaisons = $this->bdd->recupererTous($requeteImages);
541 
 
542 
		// Ce n'est pas la peine de continuer s'il n'y a pas eu de résultats dans la table del_obs_images
543 
		if (!empty($liaisons)) {
544 
 
545 
			$idsObservations = array();
546 
			foreach ($liaisons as $image) {
547 
				$idObs = $image['id_observation'];
548 
				$idsObservations[$idObs] = $idObs;
549 
			}
550 
 
551 
			$chaineIdObs = implode(',', $idsObservations);
552 
 
553 
 
554 
			// On récupère les observations qui complètent la requête précédente
555 
			$requeteObservations = ' SELECT * '.
556 
								   ' FROM del_observation dob '.
557 
								   ' LEFT JOIN del_utilisateur du ON dob.ce_utilisateur = du.id_utilisateur '.
558 
								   ' WHERE id_observation IN ('.$chaineIdObs.')';
559 
 
560 
			$resultatsObservations = $this->bdd->recupererTous($requeteObservations);
561 
 
562 
			// FIXME : Ca ne doit pas arriver, mais que se passe-t-il s'il n'y a pas d'observation pour l'image ?!
563 
 
564 
			// On range les observations dans un tableau pour pouvoir les retrouver par leur id :
565 
			$observations = array();
566 
			foreach ($resultatsObservations as $id => $observation) {
567 
				$idObs = $observation['id_observation'];
568 
				$observations[$idObs] = $observation;
569 
			}
570 
 
571 
			// Enfin, pour chaque image préalablement récupérées, on complète avec les informations de l'observation
572 
			// FIXME : peut-être peut-on utiliser un array_merge ici ?
573 
			foreach ($liaisons as $id => $liaison) {
574 
				$idObs = $liaison['id_observation'];
575 
 
576 
				$observation = $observations[$idObs];
577 
				foreach ($observation as $cle => $valeur) {
578 
					$liaisons[$id][$cle] = $valeur;
579 
				}
580 
			}
581 
 
582 
 
583 
			// On compte à part les images issues de la jointure de del_obs_image et del_image car la fonction
584 
			// SQL_CALC_FOUND_ROWS dans la fonction requete image fait passer le temps d'éxécution de 0.0011 à 15s !
585 
			$requeteNbImages = 'SELECT count(doi.id_image) as nb FROM del_obs_image doi INNER JOIN del_image di ON di.id_image = doi.id_image';
586 
			$resultatNbImages = $this->bdd->recupererTous($requeteNbImages);
587 
			$total = (int) $resultatNbImages[0]['nb'];
588 
			$this->navigation->setTotal($total);
589 
		}
590 
 
591 
		return $liaisons;
592 
	}
593 
 
594 
 
595 
	/**
596 
	 * Chargement depuis la bdd de toutes les liaisons entre images et observations
597 
	 * Méthode appelée uniquement lorsque les paramètres concernent une observation
598 
	 * */
599 
	private function chargerLiaisonsObs() {
600 
 
601 
		// Récupérer les liaisons
602 
		$requeteObs = ' SELECT SQL_CALC_FOUND_ROWS dob.id_observation as id_observation, nom_sel, nom_sel_nn, nt, famille, ce_zone_geo, zone_geo, lieudit, station, milieu, '.
603 
				 	  ' 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, '.
604 
					  ' 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 '.
605 
					  'FROM del_observation dob '.
606 
					  ' INNER JOIN del_obs_image doi ON dob.id_observation = doi.id_observation '.
607 
					  ' INNER JOIN del_image di ON doi.id_image = di.id_image '.
608 
					  ' LEFT JOIN del_utilisateur du ON dob.ce_utilisateur = du.id_utilisateur ';
609 
 
610 
		// Récupérer les conditions sous forme de tableau
611 
		$conditionsObs = $this->getConditionsObs();
612 
 
613 
		if (!empty($conditionsObs)) {
614 
			$where = ' WHERE '.implode(' AND ', $conditionsObs);
615 
			$requeteObs .= $where;
616 
		}
617 
 
618 
		// Gérer le tri (uniquement si c'est date_observation)
619 
		if (isset($this->parametres['tri']) && $this->parametres['tri'] == 'date_observation') {
620 
			$ordre = isset($this->parametres['ordre']) ? $this->parametres['ordre'] : 'DESC';
621 
			$tri = ' ORDER BY '.$this->parametres['tri'].' '.$ordre.', doi.id_observation '.$ordre.' ';
622 
			$requeteObs .= $tri;
623 
		}
624 
 
625 
		$requeteObs .= $this->gestionBdd->getLimitSql();
626 
		$observations = $this->bdd->recupererTous($requeteObs);
627 
 
628 
		$total = $this->getFoundRows();
629 
		$this->navigation->setTotal($total);
630 
 
631 
		return $observations;
632 
	}
633 
 
634 
	/**
635 
	 * Chargement depuis la bdd de toutes les liaisons entre images et observations
636 
	 * Méthode appelée uniquement lorsque les paramètres concernent les images
637 
	 * */
638 
	private function chargerLiaisonsImages() {
639 
 
640 
		// FIXME : si on faisait une requete à part pour compter, ca irait plus vite
641 
		// Récupérer tous les ID d'image en fonction des paramètres de recherche
642 
		$requeteImages = ' SELECT SQL_CALC_FOUND_ROWS '.
643 
						 ' 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, '.
644 
						 ' 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, '.
645 
						 ' di.ce_utilisateur as ce_utilisateur, prenom, nom, courriel, dob.prenom_utilisateur, dob.nom_utilisateur, dob.courriel_utilisateur, nom_original '.
646 
						 ' FROM del_obs_image doi '.
647 
						 ' INNER JOIN del_image di ON doi.id_image = di.id_image '.
648 
						 ' INNER JOIN del_observation dob ON dob.id_observation = doi.id_observation '.
649 
						 ' LEFT JOIN del_image_tag dit ON dit.ce_image = di.id_image '.
650 
						 ' LEFT JOIN del_utilisateur du ON du.id_utilisateur = di.ce_utilisateur ';
651 
 
652 
		$conditionsImg = $this->getConditionsImages();
653 
 
654 
		if (!empty($conditionsImg)) {
655 
			$where = ' WHERE ('.implode(' OR ', $conditionsImg).') ';
656 
			$where .= ' AND dit.actif = 1 ';
657 
			$requeteImages .= $where;
658 
		}
659 
 
660 
		// Gérer le tri, sur les votes ou sur les tags
661 
		if (isset($this->parametres['tri'])) {
662 
 
663 
			$chaineTri = '';
664 
			$chaineOrdre = '';
665 
 
666 
			if ($this->parametres['tri'] == 'votes') {
667 
 
668 
				$protocole = isset($this->parametres['protocole']) ? $this->parametres['protocole'] : 1;
669 
 
670 
				$requeteVotes = ' SELECT doi.id_image as id_image, IF(divo.ce_protocole = '.$protocole.', AVG(divo.valeur), 0) as total_votes '.
671 
								' FROM del_obs_image doi INNER JOIN del_image di ON doi.id_image = di.id_image'.
672 
								' LEFT JOIN del_image_vote divo ON doi.id_image = divo.ce_image ';
673 
 
674 
				// Et si on a cherché par tag ?
675 
				if (isset($this->parametres['masque.tag'])) {
676 
					$tag = $this->parametres['masque.tag'];
677 
					$requeteVotes .= ' LEFT JOIN del_image_tag dit ON dit.ce_image = di.id_image ';
678 
					$requeteVotes .= " WHERE (dit.tag_normalise LIKE '$tag%' OR  di.mots_cles_texte LIKE '%$tag%') AND dit.actif = 1 ";
679 
				}
680 
 
681 
 
682 
				$requeteVotes .= ' GROUP BY doi.id_image, doi.id_observation '.
683 
								 ' ORDER by total_votes '.$this->directionTri .', id_observation '.$this->directionTri.' '.
684 
						$this->gestionBdd->getLimitSql();
685 
 
686 
 
687 
				$resultatsVotes = $this->bdd->recupererTous($requeteVotes);
688 
				$tabVotes = array();
689 
				foreach ($resultatsVotes as $vote) {
690 
					$tabVotes[] = $vote['id_image'];
691 
				}
692 
 
693 
				$strVotes = empty($tabVotes) ? "''" : implode(',', $tabVotes);
694 
 
695 
				// Et si on a cherché par tag ?
696 
				if (isset($this->parametres['masque.tag'])) {
697 
					$chaineTri .= ' AND ';
698 
				} else {
699 
					$chaineTri .= ' WHERE ';
700 
				}
701 
 
702 
 
703 
				$chaineTri .= '  doi.id_image IN ('.$strVotes.') ';
704 
				$chaineOrdre = ' ORDER BY FIELD(doi.id_image, '.$strVotes.')  ';
705 
			}
706 
 
707 
 
708 
			if ($this->parametres['tri'] == 'tags') {
709 
 
710 
				$requetetags = ' SELECT SQL_CALC_FOUND_ROWS distinct doi.id_image, COUNT(id_tag) as total_tags '.
711 
						' FROM del_obs_image doi LEFT JOIN del_image_tag dit ON dit.ce_image = doi.id_image ';
712 
 
713 
				if (isset($this->parametres['masque.tag'])) {
714 
					// Et si on a cherché par tag ?
715 
					$requetetags .= ' LEFT JOIN del_image di ON dit.ce_image = di.id_image ';
716 
					$tag = $this->parametres['masque.tag'];
717 
					$requetetags .= " WHERE (dit.tag_normalise LIKE '$tag%' OR  di.mots_cles_texte LIKE '%$tag%') AND dit.actif = 1 ";
718 
				} else {
719 
					$requetetags .= ' WHERE dit.actif = 1 ';
720 
				}
721 
 
722 
				$requetetags .= ' GROUP BY id_image, id_observation '.
723 
						' ORDER by total_tags '.$this->directionTri.', id_observation '.$this->directionTri.
724 
						$this->gestionBdd->getLimitSql();
725 
 
726 
				$resultatstags = $this->bdd->recupererTous($requetetags);
727 
				$tabtags = array();
728 
				foreach ($resultatstags as $tag) {
729 
					$tabtags[] = $tag['id_image'];
730 
				}
731 
 
732 
				$strtags = empty($tabtags) ? "''" : implode(',', $tabtags);
733 
 
734 
 
735 
				// Et si on a cherché par tag ?
736 
				if (isset($this->parametres['masque.tag'])) {
737 
					$chaineTri .= ' AND ';
738 
				} else {
739 
					$chaineTri .= ' WHERE ';
740 
				}
741 
 
742 
				$chaineTri .= ' doi.id_image IN ('.$strtags.') ';
743 
				$chaineOrdre = ' ORDER BY FIELD(doi.id_image, '.$strtags.') ';
744 
			}
745 
 
746 
 
747 
			$requeteImages .= $chaineTri.' GROUP BY doi.id_image, doi.id_observation '.$chaineOrdre;
748 
		} else {
749 
			$requeteImages .= ' GROUP BY doi.id_image, doi.id_observation'; // des fois, on a plusieurs observations pour la même image ...
750 
			$requeteImages .= $this->gestionBdd->getLimitSql();
751 
		}
752 
 
753 
		$retour  = $this->bdd->recupererTous($requeteImages);
754 
		$total = $this->getFoundRows();
755 
		$this->navigation->setTotal($total);
756 
 
757 
		return $retour;
758 
	}
759 
 
760 
	/**
761 
	 * Chargement depuis la bdd de toutes les liaisons entre images et observations
762 
	 * */
763 
	private function chargerLiaisons() {
764 
 
765 
		$champs = array('dob.id_observation as id_observation', 'nom_sel', 'nom_sel_nn', 'nt', 'famille', 'ce_zone_geo', 'zone_geo',
766 
				'lieudit', 'station', 'milieu', 'date_observation', 'dob.mots_cles_texte as mots_cles_texte', 'dob.commentaire as commentaire',
767 
				'di.mots_cles_texte as mots_cles_texte_image ', 'date_transmission', 'di.id_image as id_image', 'di.ce_utilisateur as ce_utilisateur',
768 
				'prenom', 'nom', 'courriel', 'dob.prenom_utilisateur', 'dob.nom_utilisateur', 'dob.courriel_utilisateur', 'nom_original');
769 
		// Attention le LEFT JOIN est indispensable pour ramener les images n'ayant pas de votes
770 
		// en cas de tri par votes
771 
		$requeteLiaisons = 'SELECT DISTINCT SQL_CALC_FOUND_ROWS '.implode(', ',$champs).' '.
772 
				($this->doitJoindreTableVotes() ?
773 
						', IF(dvote.ce_protocole = '.$this->parametres['protocole'].', AVG(dvote.valeur), 0) as total_votes ' :
774 
						''
775 
				).
776 
				($this->doitJoindreTableTags() ?
777 
						// attention le DISTINCT est indispensable !
778 
						', (COUNT(DISTINCT dtag.id_tag) + '.$this->assemblercomptageOccurencesMotsClesCel().') as total_tags ' :
779 
						''
780 
				).
781 
				'FROM '.$this->gestionBdd->formaterTable('del_obs_image', 'doi').
782 
				'INNER JOIN del_image di '.
783 
				'ON doi.id_image = di.id_image '.
784 
				'INNER JOIN del_observation dob '.
785 
				'ON doi.id_observation = dob.id_observation '.
786 
				'LEFT JOIN del_utilisateur du '.
787 
				'ON du.id_utilisateur = di.ce_utilisateur '.
788 
				($this->doitJoindreTableTags() ?
789 
						'LEFT JOIN del_image_tag dtag '.
790 
						'ON doi.id_image = dtag.ce_image AND dtag.actif = 1 ' :
791 
						''
792 
								).
793 
								($this->doitJoindreTableVotes() ?
794 
								'LEFT JOIN del_image_vote dvote '.
795 
								'ON doi.id_image = dvote.ce_image AND dvote.ce_protocole = '.$this->parametres['protocole'] :
796 
								''
797 
										);
798 
										$requeteLiaisons .= $this->chargerClauseWhere();
799 
										$requeteLiaisons .= $this->getTri();
800 
										$requeteLiaisons .= $this->gestionBdd->getLimitSql();
801 
										$retour = $this->bdd->recupererTous($requeteLiaisons);
802 
										$total = $this->getFoundRows();
803 
										$this->navigation->setTotal($total);
804 
										return $retour;
805 
	}
806 
 
807 
 
808 
	/**
809 
	 * Retourner un tableau d'images formaté en fonction des liaisons trouvées
810 
	 * @param $liaisons les liaisons de la table del_obs_images
811 
	 * */
709 gduche 812 
	private function chargerImage($liaisons) {
813 
 
814 
		$images = array();
815 
		foreach ($liaisons as $liaison) {
736 gduche 816 
			$idImage = $liaison['id_image'];
1326 gduche 817 
 
1274 aurelien 818 
			if($liaison['ce_utilisateur'] == 0) {
1326 gduche 819 
				$liaison['prenom'] = $liaison['prenom_utilisateur'];
1274 aurelien 820 
				$liaison['nom'] = $liaison['nom_utilisateur'];
821 
			}
709 gduche 822 
			// On enregistre l'ID de l'image pour n'effectuer qu'une seule requête par la suite
823 
			$this->imageIds[] = $idImage;
800 aurelien 824 
			$index = $liaison['id_image'].'-'.$liaison['id_observation'];
1025 aurelien 825 
			$images[$index] = array('id_image' => $idImage, 'binaire.href' => $this->formaterLienImage($idImage),
1326 gduche 826 
					'protocoles_votes' => array(),
827 
					'mots_cles_texte' => $liaison['mots_cles_texte_image'], 'observation' => $this->formaterObservation($liaison));
709 gduche 828 
		}
829 
		return $images;
830 
	}
831 
 
832 
	/**
1326 gduche 833 
	 * Charger les votes pour chaque image
834 
	 * */
709 gduche 835 
	private function chargerVotes($images) {
1326 gduche 836 
		$requeteVotes = 'SELECT v.*, p.* FROM '.
837 
				$this->gestionBdd->formaterTable('del_image_vote', 'v').
838 
				' INNER JOIN del_image_protocole p '.
839 
				'ON v.ce_protocole = p.id_protocole '.
840 
				$this->chargerClauseWhereVotes();
841 
		$resultatsVotes = $this->bdd->recupererTous($requeteVotes);
709 gduche 842 
 
857 gduche 843 
 
1326 gduche 844 
		//TODO : faire une méthode formater vote
845 
		$votes = $this->formaterVotes($resultatsVotes);
709 gduche 846 
 
1326 gduche 847 
		foreach ($images as $id => $image) {
848 
			if (isset($votes[$image['id_image']])) {
849 
				$images[$id]['protocoles_votes'] = $votes[$image['id_image']];
709 gduche 850 
			}
1326 gduche 851 
		}
852 
 
709 gduche 853 
		return $images;
854 
	}
855 
 
759 delphine 856 
	private function chargerClauseWhereVotes() {
857 
		if (sizeof($this->imageIds) > 0) {
858 
			$chaineImageIds = implode(',', $this->imageIds);
760 delphine 859 
			$where[] = 'v.ce_image  IN ('.$chaineImageIds.')';
759 delphine 860 
		}
861 
		if (isset($this->parametres['protocole'])) {
760 delphine 862 
			$where[] = 'v.ce_protocole = '.$this->proteger($this->parametres['protocole']);
759 delphine 863 
		}
1326 gduche 864 
 
775 aurelien 865 
		$where = (!empty($where)) ? 'WHERE '.implode(' AND ', $where) : '';
866 
		return $where;
759 delphine 867 
	}
868 
 
1326 gduche 869 
	/**************************************************************************************
870 
	 *		    			FONCTION DE CONFIGURATION ET UTILITAIRES					  *
871 
	***************************************************************************************/
872 
	/**
873 
	 * Enregistrer dans les variables de classe les paramètres et ressources
874 
	 * @param $ressources
875 
	 * @param $parametres de recherche
876 
	 * */
877 
	private function initialiserRessourcesEtParametres($ressources, $parametres) {
878 
		$this->ressources = $ressources;
879 
		$this->parametres = $parametres;
880 
	}
881 
 
882 
	/**
883 
	 * Configuration du service en fonction du fichier de config config_del.ini
884 
	 * */
885 
	public function configurer() {
886 
		$this->mappingFiltre = $this->conteneur->getParametre('mapping_masque');
887 
		$this->mappingObservation = $this->conteneur->getParametre('mapping_observation');
888 
		$this->mappingVotes = $this->conteneur->getParametre('mapping_votes');
889 
	}
890 
 
891 
	/**
892 
	 * Vérifier que le service est bien configuré
893 
	 * */
894 
	public function verifierConfiguration() {
895 
 
896 
		$erreurs = array();
897 
		$tableauImages = $this->conteneur->getParametre('images');
898 
		if (empty($tableauImages)) {
899 
			$erreurs[] = '- le fichier de configuration ne contient pas le tableau [images] ou celui-ci est vide ;';
900 
		} else {
901 
			if ($this->conteneur->getParametre('url_service') == null) {
902 
				$erreurs[] = '- paramètre "url_service" manquant ;';
903 
			}
904 
 
905 
			if ($this->conteneur->getParametre('url_images') == null) {
906 
				$erreurs[] = '- paramètre "url_images" manquant ;';
907 
			}
908 
 
909 
		}
910 
 
911 
		if (empty($this->mappingObservation)) {
912 
			$erreurs[] = '- le fichier de configuration ne contient pas le tableau [mapping_observation] ou celui-ci est vide ;';
913 
		} else {
914 
			$champsMappingObs = array('id_observation', 'date_observation', 'date_transmission', 'famille', 'nom_sel', 'nom_sel_nn', 'nt',
915 
					'ce_zone_geo', 'lieudit', 'station', 'milieu', 'ce_utilisateur', 'nom', 'prenom');
916 
			foreach ($champsMappingObs as $champ) {
917 
				if (!isset($this->mappingObservation[$champ])) {
918 
					$erreurs[] = '- le mapping du champ "'.$champ.'" pour l\'observation est manquant ;';
919 
				}
920 
			}
921 
		}
922 
 
923 
		if (empty($this->mappingFiltre)) {
924 
			$erreurs[] = '- le fichier de configuration ne contient pas le tableau [mapping_masque] ou celui-ci est vide ;';
925 
		} else {
926 
			$champsMappingFiltre = array('famille', 'ns', 'nn', 'date', 'tag', 'commune');
927 
			foreach ($champsMappingFiltre as $champ) {
928 
				if (!isset($this->mappingFiltre[$champ])) {
929 
					$erreurs[] = '- le mapping du champ "'.$champ.'" pour l\'observation est manquant ;';
930 
				}
931 
			}
932 
		}
933 
 
934 
		$tris_possibles = $this->conteneur->getParametre('tris_possibles');
935 
		if (empty($tris_possibles)) {
936 
			$erreurs[] = '- le fichier de configuration ne contient pas le parametre tris_possibles ou celui-ci est vide ;';
937 
		}
938 
 
939 
		if (!empty($erreurs)) {
940 
			$e = 'Erreur lors de la configuration : '."\n";
941 
			$e .= implode("\n", $erreurs);
942 
			throw new Exception($e, RestServeur::HTTP_CODE_ERREUR);
943 
		}
944 
	}
945 
 
946 
	/**
947 
	 * Verifier que les paramètres de tri sont bien autorisés et qu'ils sont au bon format.
948 
	 */
949 
	private function verifierParametresTri() {
950 
 
951 
		$erreurs = array();
952 
		$tris_possibles = $this->conteneur->getParametre('tris_possibles');
953 
		$tris_possibles_tableau = explode(',', $tris_possibles);
954 
		if(isset($this->parametres['tri']) && !in_array($this->parametres['tri'], $tris_possibles_tableau)) {
955 
			$erreurs[] = '- le type de tri demandé est incorrect, les valeurs possibles sont '.$tris_possibles.' ;';
956 
		}
957 
 
958 
		if(isset($this->parametres['tri']) && $this->parametres['tri'] == "votes") {
959 
			if(!isset($this->parametres['protocole']) || !is_numeric($this->parametres['protocole'])) {
960 
				$erreurs[] = '- Le paramètre protocole est obligatoire en cas de tri par vote et doit être un entier ;';
961 
			}
962 
		}
963 
 
964 
		$directions_tri = array('asc', 'desc');
965 
		if(isset($this->parametres['ordre']) && !in_array($this->parametres['ordre'], $directions_tri)) {
966 
			$erreurs[] = '- la direction du tri demandé est incorrecte, les valeurs supportées sont asc ou desc ;';
967 
		}
968 
 
969 
		if (!empty($erreurs)) {
970 
			$e = 'Erreur lors de l\'analyse des parametres du tri : '."\n";
971 
			$e .= implode("\n", $erreurs);
972 
			throw new Exception($e, RestServeur::HTTP_CODE_ERREUR);
973 
		}
974 
	}
975 
 
976 
	/**
977 
	 * Initialiser les variables de tri depuis les paramètres
978 
	 * */
979 
	private function initialiserTri() {
980 
		$this->tri = isset($this->parametres['tri']) ? $this->parametres['tri'] : $this->tri;
981 
		$this->directionTri = isset($this->parametres['ordre']) ? $this->parametres['ordre'] : $this->directionTri;
982 
	}
983 
 
984 
	/** Pour eviter les requêtes trop gourmandes, on supprime les caractères passe-partout
985 
	 * @param les paramètres de l'application
986 
	 * */
987 
	public function nettoyerParametres($parametres) {
988 
		$parametresRetour = array();
989 
		foreach ($parametres as $cle => $valeur) {
990 
			$valSansPourcent = trim($valeur, "% ");
991 
			if ($valSansPourcent != '') {
992 
				$parametresRetour[$cle] = $valeur;
993 
			}
994 
		}
995 
 
996 
		return $parametresRetour;
997 
	}
998 
 
999 
	/**
1000 
	 * Nettoyer les jokers
1001 
	 * @param la valeur du masque
1002 
	 * */
1003 
	private function remplacerParJokerCaractere($valeurMasque) {
1004 
		return str_replace(array('-',' '), '_', $valeurMasque);
1005 
	}
1006 
 
1007 
	//TODO: déplacer les fonctions ci dessus et dessous dans une classe
1008 
	// utilitaire
1009 
 
1010 
	/**
1011 
	 * Supprimer les accents des chaines de caractères
1012 
	 * */
1013 
	function supprimerAccents($str, $charset='utf-8')
1014 
	{
1015 
		$str = htmlentities($str, ENT_NOQUOTES, $charset);
1016 
 
1017 
		$str = preg_replace('#&([A-za-z])(?:acute|cedil|circ|grave|orn|ring|slash|th|tilde|uml);#', '\1', $str);
1018 
		$str = preg_replace('#&([A-za-z]{2})(?:lig);#', '\1', $str); // pour les ligatures e.g. '&oelig;'
1019 
		$str = preg_replace('#&[^;]+;#', '', $str); // supprime les autres caractères
1020 
 
1021 
		return $str;
1022 
	}
1023 
 
1024 
	/**
1025 
	 * Normaliser en supprimant les accents et en mettant en minuscule
1026 
	 * @param $mot_cle le mot recherché
1027 
	 * */
1028 
	private function normaliserMotCle($mot_cle) {
1029 
		return mb_strtolower($this->supprimerAccents(trim($mot_cle)));
1030 
	}
1031 
 
1032 
	/**
1033 
	 * Récupérer le numéro du département d'un fichier de configuration
1034 
	 * */
1035 
	private function obtenirIdDepartement($nomDpt) {
1036 
 
1037 
		$nomDpt = $this->supprimerAccents($nomDpt);
1038 
		$nomDpt = strtolower(str_replace(' ','-',$nomDpt));
1039 
 
1040 
		$idDpt = $this->conteneur->getParametre($nomDpt);
1041 
		if($idDpt == null || $idDpt == ' ') {
1042 
			$idDpt = ' ';
1043 
		}
1044 
		return $idDpt;
1045 
	}
1046 
 
1047 
 
1048 
	/**
1049 
	 * Obtenir le type de requête à exécuter en fonction des paramètres de recherche
1050 
	 * @param $parametres les paramètres de l'application
1051 
	 * */
1052 
	private function getTypeRequete($parametres) {
1053 
 
1054 
 
1055 
		$typeRequete = 'simple';
1056 
 
1057 
		// Dans ce cas précis, les informations concernant le depart, la limite ou l'ordre ne
1058 
		// rentre pas en compte dans le type de requête ; ce ne sont que des compléments.
1059 
		unset($parametres['navigation.depart']);
1060 
		unset($parametres['navigation.limite']);
1061 
		unset($parametres['ordre']);
1062 
 
1063 
		// En revanche, chaque masque est associé à un type de requête particulier.
1064 
		$masquesObservation = array('masque', 'masque.departement', 'masque.ns', 'masque.genre', 'masque.date', 'masque.commune', 'masque.famille', 'masque.auteur');
1065 
		$masquesImage = array('masque', 'masque.tag');
1066 
 
1067 
		// Le type de requête est défini par les tables qu'il doit inclure (observation, image, ou les deux)
1068 
		$requeteSimple = false;
1069 
		$pourObservation = false;
1070 
		$pourImage = false;
1071 
 
1072 
		// S'il n'y a aucun paramètre, on lance une requête simple
1073 
		if (empty($parametres)) {
1074 
			$requeteSimple = true;
1075 
		}
1076 
 
1077 
		// Si l'un des masques demandé concerne l'observation
1078 
		foreach ($masquesObservation as $masque) {
1079 
			if (isset($parametres[$masque])) {
1080 
				$pourObservation = true;
1081 
				break;
1082 
			}
1083 
		}
1084 
 
1085 
		// Si l'un des masques demandé concerne les images
1086 
		foreach ($masquesImage as $masque) {
1087 
			if (isset($parametres[$masque])) {
1088 
				$pourImage = true;
1089 
				break;
1090 
			}
1091 
		}
1092 
 
1093 
		// Selon les tri
1094 
		if (isset($parametres['tri'])) {
1095 
			switch ($parametres['tri']) {
1096 
				case 'votes' :
1097 
				case 'tags' :
1098 
					$pourImage = true;
1099 
					break;
1100 
				default : //case 'date_observation' :
1101 
					if (sizeof($parametres) > 1) {
1102 
						$pourObservation = true;
1103 
					}
1104 
			}
1105 
		}
1106 
 
1107 
		// Vérifier la combinaison des booléens pour en déduire le type de requête
1108 
		if ($pourObservation && $pourImage) {
1109 
			$typeRequete = 'obs-images';
1110 
		} else {
1111 
			if ($pourImage) {
1112 
				$typeRequete = 'images';
1113 
			} else if ($pourObservation) {
1114 
				$typeRequete = 'obs';
1115 
			} else { // if ($requeteSimple)
1116 
				$typeRequete = 'simple';
1117 
			}
1118 
		}
1119 
 
1120 
		return $typeRequete;
1121 
	}
1122 
 
1123 
 
1124 
	private function doitJoindreTableVotes() {
1125 
		return ($this->tri == 'votes');
1126 
	}
1127 
 
1128 
	private function doitJoindreTableTags() {
1129 
		return ($this->tri == 'tags');
1130 
	}
1131 
 
709 gduche 1132 
	/*-------------------------------------------------------------------------------
1133 
								FORMATER ET METTRE EN FORME
1134 
	--------------------------------------------------------------------------------*/
1135 
 
1136 
	/**
1137 
	*  Formater une observation depuis une ligne liaison
1138 
	*  @param $liaison liaison issue de la recherche
1139 
	*  @return $observation l'observation mise en forme
1140 
	* */
1141 
	private function formaterObservation($liaison) {
1142 
		$observation = array();
1143 
		foreach ($this->mappingObservation as $nomOriginal => $nomFinal) {
1144 
			$observation[$nomFinal] = $liaison[$nomOriginal];
1145 
		}
1146 
 
1147 
		return $observation;
1148 
	}
1149 
 
1150 
	/**
1151 
	*  Formater une observation depuis une ligne liaison
1152 
	*  @param $liaison liaison issue de la recherche
1153 
	*  @return $observation l'observation mise en forme
1154 
	* */
1155 
	private function formaterVotes($votes) {
1156 
		$retour = array();
1157 
		foreach ($votes as $vote) {
759 delphine 1158 
			$retour_vote = array();
1159 
			foreach ($vote as $param=>$valeur) {
760 delphine 1160 
				if (strpos($this->mappingVotes[$param], 'protocole.') === 0) {
1161 
					$retour_protocole[$this->mappingVotes[$param]] = $valeur;
1162 
				} else {
1163 
					$retour_vote[$this->mappingVotes[$param]] = $valeur;
1164 
				}
759 delphine 1165 
			}
760 delphine 1166 
			if (!isset($retour[$vote['ce_image']][$vote['ce_protocole']])) {
1167 
				$retour[$vote['ce_image']][$vote['ce_protocole']] = $retour_protocole;
1168 
			}
1169 
			$retour[$vote['ce_image']][$vote['ce_protocole']]['votes'][$vote['id_vote']] = $retour_vote;
709 gduche 1170 
		}
1171 
 
1172 
		return $retour;
1173 
	}
1174 
 
1175 
	/**
1176 
	 * Formater le lien de l'image en fonction du fichier de config et de l'identifiant de l'image
1177 
	 * */
1178 
	private function formaterLienImage($idImage) {
1179 
		$idImage = sprintf('%09s', $idImage);
719 gduche 1180 
		$url = $this->conteneur->getParametre('url_images');
709 gduche 1181 
		$urlImage = str_replace('%s', $idImage, $url);
1182 
		return $urlImage;
1183 
	}
719 gduche 1184 
 
1185 
	private function proteger($valeur) {
1186 
		if (is_array($valeur)) {
1187 
			return $this->bdd->protegerTableau($valeur);
1188 
		} else {
1189 
			return $this->bdd->proteger($valeur);
709 gduche 1190 
		}
1191 
	}
1192 
}
1193 
?>