Subversion Repositories eFlore/Applications.del

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
720 gduche 1
<?php
2
// declare(encoding='UTF-8');
3
/**
737 gduche 4
	* Le web service observations récupère toutes les observations et, pour chacune d'elle, les
5
	* images qui lui sont associées.
720 gduche 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 $
737 gduche 15
 * @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=ApiIdentiplante01Observations
720 gduche 16
 */
17
 
755 gduche 18
class ListeObservations {
720 gduche 19
 
755 gduche 20
 
720 gduche 21
	private $conteneur;
726 gduche 22
	private $navigation;
23
	private $masque;
737 gduche 24
	private $gestionBdd;
25
	private $bdd;
797 aurelien 26
	private $parametres = array();
27
	private $ressources = array();
800 aurelien 28
	private $tri = 'date_transmission';
29
	private $directionTri = 'desc';
720 gduche 30
 
31
	public function __construct(Conteneur $conteneur = null) {
32
		$this->conteneur = $conteneur == null ? new Conteneur() : $conteneur;
790 aurelien 33
		$this->conteneur->chargerConfiguration('config_departements_bruts.ini');
776 aurelien 34
		$this->conteneur->chargerConfiguration('config_observations.ini');
797 aurelien 35
		$this->conteneur->chargerConfiguration('config_mapping_votes.ini');
726 gduche 36
		$this->navigation = $conteneur->getNavigation();
37
		$this->masque = $conteneur->getMasque();
737 gduche 38
		$this->gestionBdd = $conteneur->getGestionBdd();
39
		$this->bdd = $this->gestionBdd->getBdd();
720 gduche 40
	}
41
 
42
	/**
43
	 * Méthode principale de la classe.
44
	 * Lance la récupération des images dans la base et les place dans un objet ResultatService
45
	 * pour l'afficher.
46
	 * @param array $ressources les ressources situées après l'url de base (ex : http://url/ressource1/ressource2)
47
	 * @param array $parametres les paramètres situés après le ? dans l'url
48
	 * */
49
	public function consulter($ressources, $parametres) {
797 aurelien 50
		$this->initialiserRessourcesEtParametres($ressources, $parametres);
720 gduche 51
 
52
		// Gestion des configuration du script
53
		$this->configurer();
54
		$this->verifierConfiguration();
55
 
800 aurelien 56
		$this->verifierParametresTri();
57
		$this->initialiserTri();
58
 
720 gduche 59
		// Lancement du service
60
		$liaisons = $this->chargerLiaisons();
737 gduche 61
		$total = $this->compterObservations();
726 gduche 62
		$this->navigation->setTotal($total);
755 gduche 63
		$observations = $this->chargerObservations($liaisons);
64
		$observations = $this->chargerImages($observations);
65
		$observations = $this->chargerDeterminations($observations);
720 gduche 66
 
67
		// Mettre en forme le résultat et l'envoyer pour affichage
68
		$resultat = new ResultatService();
755 gduche 69
		$resultat->corps = array('entete' => $this->conteneur->getEntete(), 'resultats' => $observations);
720 gduche 70
		return $resultat;
71
	}
72
 
797 aurelien 73
	private function initialiserRessourcesEtParametres($ressources, $parametres) {
74
		$this->ressources = $ressources;
75
		$this->parametres = $parametres;
76
	}
800 aurelien 77
 
78
	private function verifierParametresTri() {
79
 
80
		$erreurs = array();
81
		$tris_possibles = $this->conteneur->getParametre('tris_possibles');
82
		$tris_possibles_tableau = explode(',', $tris_possibles);
83
		if(isset($this->parametres['tri']) && !in_array($this->parametres['tri'], $tris_possibles_tableau)) {
84
			$erreurs[] = '- le type de tri demandé est incorrect, les valeurs possibles sont '.$tris_possibles.' ;';
85
		}
86
 
87
		$directions_tri = array('asc', 'desc');
88
		if(isset($this->parametres['ordre']) && !in_array($this->parametres['ordre'], $directions_tri)) {
89
			$erreurs[] = '- la direction du tri demandé est incorrecte, les valeurs supportées sont asc ou desc ;';
90
		}
91
 
92
		if (!empty($erreurs)) {
93
			$e = 'Erreur lors de l\'analyse des parametres du tri : '."\n";
94
			$e .= implode("\n", $erreurs);
95
			throw new Exception($e, RestServeur::HTTP_CODE_ERREUR);
96
		}
97
	}
98
 
99
	private function initialiserTri() {
100
		$this->tri = isset($this->parametres['tri']) ? $this->parametres['tri'] : $this->tri;
101
		$this->directionTri = isset($this->parametres['ordre']) ? $this->parametres['ordre'] : $this->directionTri;
102
	}
720 gduche 103
	/*-------------------------------------------------------------------------------
104
	 							CONFIGURATION DU SERVICE
105
	 --------------------------------------------------------------------------------*/
106
	/**
107
	 * Configuration du service en fonction du fichier de config config_del.ini
108
	 * */
755 gduche 109
	private function configurer() {
720 gduche 110
		$this->mappingFiltre = $this->conteneur->getParametre('mapping_masque');
111
		$this->mappingObservation = $this->conteneur->getParametre('mapping_observation');
787 delphine 112
		$this->mappingVotes = $this->conteneur->getParametre('mapping_votes');
720 gduche 113
	}
114
 
115
	/**
116
	 * Vérifier que le service est bien configuré
117
	 * */
755 gduche 118
	private function verifierConfiguration() {
737 gduche 119
 
720 gduche 120
		$erreurs = array();
755 gduche 121
		$tableauObservations = $this->conteneur->getParametre('observations');
122
		if (empty($tableauObservations)) {
720 gduche 123
			$erreurs[] = '- le fichier de configuration ne contient pas le tableau [images] ou celui-ci est vide ;';
124
		} else {
737 gduche 125
			if ($this->conteneur->getParametre('url_service') == null) {
720 gduche 126
				$erreurs[] = '- paramètre "url_service" manquant ;';
127
			}
128
 
737 gduche 129
			if ($this->conteneur->getParametre('url_images') == null) {
720 gduche 130
				$erreurs[] = '- paramètre "url_images" manquant ;';
131
			}
132
 
133
		}
134
 
135
		if (empty($this->mappingObservation)) {
136
			$erreurs[] = '- le fichier de configuration ne contient pas le tableau [mapping_observation] ou celui-ci est vide ;';
137
		} else {
138
			$champsMappingObs = array('id_observation', 'date_observation', 'date_transmission', 'famille', 'nom_sel', 'nom_sel_nn', 'nt',
737 gduche 139
								'ce_zone_geo', 'zone_geo', 'lieudit', 'station', 'courriel', 'ce_utilisateur', 'nom', 'prenom');
140
 
720 gduche 141
			foreach ($champsMappingObs as $champ) {
142
				if (!isset($this->mappingObservation[$champ])) {
143
					$erreurs[] = '- le mapping du champ "'.$champ.'" pour l\'observation est manquant ;';
144
				}
145
			}
146
		}
147
 
148
		if (empty($this->mappingFiltre)) {
149
			$erreurs[] = '- le fichier de configuration ne contient pas le tableau [mapping_masque] ou celui-ci est vide ;';
150
		} else {
151
			$champsMappingFiltre = array('famille', 'ns', 'nn', 'date', 'tag', 'commune');
152
			foreach ($champsMappingFiltre as $champ) {
153
				if (!isset($this->mappingFiltre[$champ])) {
154
					$erreurs[] = '- le mapping du champ "'.$champ.'" pour l\'observation est manquant ;';
155
				}
156
			}
157
		}
158
 
159
		if (!empty($erreurs)) {
160
			$e = 'Erreur lors de la configuration : '."\n";
161
			$e .= implode("\n", $erreurs);
162
			throw new Exception($e, RestServeur::HTTP_CODE_ERREUR);
737 gduche 163
		}
720 gduche 164
	}
165
 
166
 
167
 
168
	/**
169
	 * Obtenir une chaine de caractère concaténant nom et prénom séparé par une virgule
170
	 * @param String $auteurId l'identifiant de l'auteur
171
	 * @return String la chaine de concaténation
172
	 * */
173
	private function getChaineNomPrenom($auteurId) {
174
		$nomPrenom = explode(' ', $auteurId);
175
		$nomPrenom = $this->proteger($nomPrenom);
176
		$chaineNomPrenom = implode(', ', $nomPrenom);
177
		return $chaineNomPrenom;
178
	}
179
 
180
	/**
181
	* Charger la clause WHERE en fonction des paramètres de masque
182
	* */
183
	private function chargerClauseWhere() {
184
		$where = array();
737 gduche 185
		$tableauMasque = $this->masque->getMasque();
186
		if (!empty($tableauMasque)) {
187
			foreach($tableauMasque as $idMasque => $valeurMasque) {
188
 
189
				$idMasque = str_replace('masque.', '', $idMasque);
190
				switch ($idMasque) {
191
					// nom du masque => nom BDD
192
					case 'auteur' :
797 aurelien 193
						$whereAuteur = ' '.$this->creerFiltreAuteur($this->masque->getMasque('auteur'));
194
						if($whereAuteur != '') {
195
							$where[] = $whereAuteur;
196
						}
737 gduche 197
						break;
790 aurelien 198
					case 'date' :
797 aurelien 199
						$whereDate = ' '.$this->creerFiltreDate($valeurMasque);
200
						if($whereDate != '') {
201
							$where[] = $whereDate;
202
						}
790 aurelien 203
						break;
737 gduche 204
					case 'departement' :
797 aurelien 205
						$where[] = ' '.$this->creerFiltreIdZoneGeo($valeurMasque);
737 gduche 206
						break;
207
					case 'genre' :
744 gduche 208
						$where[] = ' '.$this->mappingFiltre['ns'].' LIKE '.$this->proteger('%'.$valeurMasque.'% %');
737 gduche 209
						break;
210
					case 'tag' :
797 aurelien 211
						$where[] = ' '.$this->creerFiltreMotsCles($valeurMasque);
737 gduche 212
						break;
776 aurelien 213
					case 'ns' :
797 aurelien 214
						$where[] = ' nom_sel LIKE '.$this->proteger($valeurMasque.'%');
215
						break;
790 aurelien 216
					case 'commune' :
797 aurelien 217
						$where[] = ' '.$this->mappingFiltre[$idMasque].' LIKE '.$this->proteger(str_replace(array('-',' '), '_', $valeurMasque).'%');
790 aurelien 218
					break;
219
					case 'masque' :
797 aurelien 220
						$where[] = ' '.$this->creerFiltreMasqueGeneral($valeurMasque);
790 aurelien 221
						break;
737 gduche 222
					default:
797 aurelien 223
						$where[] = ' '.$this->mappingFiltre[$idMasque].' = '.$this->proteger($valeurMasque);
224
					break;
737 gduche 225
				}
226
			}
720 gduche 227
		}
228
 
229
		if (!empty($where)) {
230
			return ' WHERE '.implode('AND', $where);
231
		} else {
232
			return;
233
		}
234
	}
235
 
790 aurelien 236
	private function creerFiltreMasqueGeneral($valeurMasque) {
797 aurelien 237
		//TODO: affecter d'aborder les variables, puis les tester pour les
238
		// ajouter à la chaine
790 aurelien 239
		$whereAuteur = $this->creerFiltreAuteur($valeurMasque);
797 aurelien 240
		$whereIdZoneGeo = $this->creerFiltreIdZoneGeo($valeurMasque);
241
 
790 aurelien 242
		$masqueGeneral = '( '.
800 aurelien 243
						(($whereAuteur != '') ? $whereAuteur.' OR ' : '' ).
244
						(($whereIdZoneGeo != '') ? $whereIdZoneGeo.' OR ' : '' ).
797 aurelien 245
						'zone_geo LIKE '.$this->proteger($this->remplacerParJokerCaractere($valeurMasque).'%').' OR '.
800 aurelien 246
						$this->creerFiltreMotsCles($valeurMasque).' OR '.
797 aurelien 247
						'nom_sel LIKE '.$this->proteger($valeurMasque.'%').' OR '.
248
						'famille LIKE '.$this->proteger($valeurMasque.'%').' OR '.
249
						'milieu LIKE '.$this->proteger($valeurMasque).' OR '.
800 aurelien 250
						$this->mappingFiltre['ns'].' LIKE '.$this->proteger('%'.$valeurMasque.'% %').' OR '.
251
						$this->creerFiltreDate($valeurMasque).
797 aurelien 252
						') ';
790 aurelien 253
 
254
		return $masqueGeneral;
255
	}
256
 
257
	private function creerFiltreAuteur($valeurMasque) {
258
		$masque = '';
259
		$auteurId = $valeurMasque;
260
		if (is_numeric($auteurId)) {
261
			$masque = ' ce_utilisateur = '.$auteurId;
262
		} else {
263
			if (strpos($auteurId, '@') === false) {
264
				$tableauNomPrenom = explode(' ',$auteurId, 2);
265
				if(count($tableauNomPrenom) == 2) {
266
					// on teste potentiellement un nom prenom ou bien un prénom nom
267
					$masque = '('.
797 aurelien 268
							          	'(nom LIKE '.$this->proteger($tableauNomPrenom[0].'%').' AND '.
269
									  	'prenom LIKE '.$this->proteger($tableauNomPrenom[1].'%').') OR '.
270
									 	'(nom LIKE '.$this->proteger($tableauNomPrenom[1].'%').' AND '.
271
									  	'prenom LIKE '.$this->proteger($tableauNomPrenom[0].'%').')'.
272
									  ')';
790 aurelien 273
				} else {
274
					$masque = '(
797 aurelien 275
							            (nom LIKE '.$this->proteger($auteurId.'%').' OR '.
276
										'prenom LIKE '.$this->proteger($auteurId.'%').')'.
277
									  ')';
790 aurelien 278
				}
279
			} else {
280
				$masque = " courriel LIKE ".$this->proteger($valeurMasque.'%')." ";
281
			}
282
		}
283
		return $masque;
284
	}
285
 
286
	private function remplacerParJokerCaractere($valeurMasque) {
287
		return str_replace(array('-',' '), '_', $valeurMasque);
288
	}
797 aurelien 289
	//TODO: déplacer les fonctions ci dessus et dessous dans une classe
790 aurelien 290
	// utilitaire
291
	function supprimerAccents($str, $charset='utf-8')
292
	{
293
		$str = htmlentities($str, ENT_NOQUOTES, $charset);
294
 
295
		$str = preg_replace('#&([A-za-z])(?:acute|cedil|circ|grave|orn|ring|slash|th|tilde|uml);#', '\1', $str);
296
		$str = preg_replace('#&([A-za-z]{2})(?:lig);#', '\1', $str); // pour les ligatures e.g. '&oelig;'
297
		$str = preg_replace('#&[^;]+;#', '', $str); // supprime les autres caractères
298
 
299
		return $str;
300
	}
301
 
302
	private function obtenirIdDepartement($nomDpt) {
797 aurelien 303
 
790 aurelien 304
		$nomDpt = $this->supprimerAccents($nomDpt);
305
		$nomDpt = strtolower(str_replace(' ','-',$nomDpt));
797 aurelien 306
 
790 aurelien 307
		$idDpt = $this->conteneur->getParametre($nomDpt);
308
		if($idDpt == null || $idDpt == ' ') {
309
			$idDpt = ' ';
310
		}
311
		return $idDpt;
312
	}
313
 
314
	private function creerFiltreIdZoneGeo($valeurMasque) {
315
		$masque = '';
316
		$dept = $valeurMasque;
317
		if (is_numeric($dept)) {
318
			$dept = sprintf('%02s', $dept);
319
			$dept = sprintf("%-'_5s", $dept);
320
			$masque = " ce_zone_geo LIKE ".$this->proteger('INSEE-C:'.$dept);
321
		} else {
322
			$deptId = $this->conteneur->getParametre($dept);
323
			if ($deptId != null) {
324
				$masque = " ce_zone_geo LIKE ".$this->proteger('INSEE-C:'.$deptId.'%');
325
			} else {
326
				$id = $this->obtenirIdDepartement($valeurMasque);
327
				$masque = " ce_zone_geo LIKE ".$this->proteger('INSEE-C:'.$id.'%');
328
			}
329
		}
330
		return $masque;
331
	}
332
 
333
	private function creerFiltreDate($valeurMasque) {
334
		//TODO: définir dans le fichier de config un tableau contenant plusieurs format de date
335
		// autorisés pour la recherche, qui seraient ajoutés au OR
336
		$masque = '(';
337
		$masque .= (is_numeric($valeurMasque)) ? ' YEAR(date_observation) = '.$this->proteger($valeurMasque).' OR ' : '';
338
		$masque .= " DATE_FORMAT(date_observation, '%d/%m/%Y') = ".$this->proteger($valeurMasque).' '.
797 aurelien 339
			           ')';
790 aurelien 340
		return $masque;
341
	}
342
 
343
	private function creerFiltreMotsCles($valeurMasque) {
800 aurelien 344
		$mots_cles = explode(' ', $valeurMasque);
345
		$requeteMotsClesImg = '';
346
		$requeteMotsClesObs = '';
347
		//TODO voir s'il existe un moyen plus simple que le foreach + rtrim
806 aurelien 348
		// comme avec implode (attention au fait que l'on concatène des % au début et à la fin)
800 aurelien 349
		foreach($mots_cles as $mot_cle) {
350
			$requeteMotsCles = $this->proteger('%'.$mot_cle.'%');
351
			$requeteMotsClesImg .= 'di.mots_cles_texte LIKE '.$requeteMotsCles.' AND ';
352
			$requeteMotsClesObs .= 'dob.mots_cles_texte LIKE '.$requeteMotsCles.' AND ';
353
		}
354
		$requeteMotsClesImg = rtrim($requeteMotsClesImg, ' AND ');
355
		$requeteMotsClesObs = rtrim($requeteMotsClesObs, ' AND ');
356
 
357
		$masque = '('.
358
		          	'('.$requeteMotsClesImg.') OR '.
359
		          	'('.$requeteMotsClesObs.') '.
360
				  ') ';
361
 
362
		return $masque;
790 aurelien 363
	}
364
 
720 gduche 365
	/*-------------------------------------------------------------------------------
745 gduche 366
								CHARGEMENT DES OBSERVATIONS
720 gduche 367
	--------------------------------------------------------------------------------*/
368
	/**
369
	* Chargement depuis la bdd de toutes les liaisons entre images et observations
370
	* */
371
	private function chargerLiaisons() {
797 aurelien 372
 
800 aurelien 373
		$requeteLiaisons = 'SELECT SQL_CALC_FOUND_ROWS *, di.mots_cles_texte '.
737 gduche 374
						   'FROM '.$this->gestionBdd->formaterTable('del_observation', 'dob').
766 aurelien 375
						   'INNER JOIN '.$this->gestionBdd->formaterTable('del_obs_image', 'doi').
737 gduche 376
						   'ON doi.id_observation = dob.id_observation '.
720 gduche 377
						   'INNER JOIN del_utilisateur du '.
819 gduche 378
						   'ON du.id_utilisateur = dob.ce_utilisateur '.
800 aurelien 379
						   'INNER JOIN del_image di '.
380
						   'ON di.id_image = doi.id_image ';
720 gduche 381
		$requeteLiaisons .= $this->chargerClauseWhere();
800 aurelien 382
		$requeteLiaisons .= ' GROUP BY doi.id_observation';
383
		$requeteLiaisons .= ' ORDER BY '.$this->tri.' '.$this->directionTri.' ';
737 gduche 384
		$requeteLiaisons .= $this->gestionBdd->getLimitSql();
797 aurelien 385
 
720 gduche 386
		return $this->bdd->recupererTous($requeteLiaisons);
387
	}
388
 
389
	/**
390
	* Compter le nombre total d'images dans la base pour affichage dans entete.
391
	* */
737 gduche 392
	private function compterObservations() {
720 gduche 393
		$requete = 'SELECT FOUND_ROWS() AS nbre ';
394
		$resultats = $this->bdd->recuperer($requete);
766 aurelien 395
		return (int) $resultats['nbre'];
720 gduche 396
	}
397
 
398
	/**
399
	* Retourner un tableau d'images formaté en fonction des liaisons trouvées
400
	* @param $liaisons les liaisons de la table del_obs_images
401
	* */
737 gduche 402
	private function chargerObservations($liaisons) {
720 gduche 403
 
737 gduche 404
		$observations = array();
720 gduche 405
		foreach ($liaisons as $liaison) {
737 gduche 406
			$idObs = $liaison[$this->mappingObservation['id_observation']];
720 gduche 407
 
745 gduche 408
			$observation = $this->formaterObservation($liaison);
737 gduche 409
			$observations[$idObs] = $observation;
720 gduche 410
		}
737 gduche 411
		return $observations;
720 gduche 412
	}
413
 
414
	/**
737 gduche 415
	 * Sélectionner toutes les images de chaque observation
416
	 * @param array $observations la liste des observations
417
	 * */
755 gduche 418
	private function chargerImages($observations) {
720 gduche 419
 
737 gduche 420
		foreach ($observations as $id => $observation) {
720 gduche 421
 
766 aurelien 422
			$requeteImages = 'SELECT * FROM '. $this->gestionBdd->formaterTable('del_obs_image', 'doi').
737 gduche 423
							 'INNER JOIN '.$this->gestionBdd->formaterTable('del_image', 'di').
424
							 'ON doi.id_image = di.id_image '.
425
							 'WHERE doi.id_observation = '.$observation['id_observation'];
720 gduche 426
 
737 gduche 427
			$images = $this->bdd->recupererTous($requeteImages);
428
			$images = $this->formaterImages($images);
429
			$observations[$id]['images'] = $images;
720 gduche 430
		}
431
 
737 gduche 432
		return $observations;
720 gduche 433
	}
434
 
755 gduche 435
	/**
436
	* Récupérer toutes les déterminations et le nombre de commentaire au total
437
	* @param array $observations la liste des observations à mettre à jour
438
	* */
439
	private function chargerDeterminations($observations) {
440
		foreach ($observations as $id => $observation) {
441
			$requetePropositions = 'SELECT * FROM '.$this->gestionBdd->formaterTable('del_commentaire', 'dc').
442
									   'WHERE dc.nom_sel IS NOT NULL AND ce_observation = '.$observation['id_observation'];
443
			$propositions = $this->bdd->recupererTous($requetePropositions);
781 delphine 444
			$observations[$id]['propositions'] = $this->formaterDeterminations($propositions);
755 gduche 445
		}
446
		return $observations;
447
	}
737 gduche 448
 
781 delphine 449
	private function formaterDeterminations($propositions) {
450
		$propositions_format = array();
451
		if ($propositions != array()) {
452
			foreach ($propositions as $id => $proposition) {
453
				$propositions_format[$proposition['id_commentaire']] = $proposition;
454
				$ids_proposition[] = $proposition['id_commentaire'];
455
			}
456
			$propositions_format = $this->chargerVotes($ids_proposition, $propositions_format);
457
			$propositions_format = $this->chargerNombreCommentaire($ids_proposition, $propositions_format);
458
		}
459
		return $propositions_format;
460
	}
755 gduche 461
	/**
781 delphine 462
	 * Charger les votes sur les déterminations
797 aurelien 463
	 * @param Array $observations le tableau des observations à mettre à jour
781 delphine 464
	* */
465
	private function chargerVotes($ids_proposition, $propositions) {
466
		$requeteVotes = 'SELECT * FROM '.
467
			$this->gestionBdd->formaterTable('del_commentaire_vote').
468
			'WHERE ce_proposition IN ('.implode(', ', $ids_proposition).')';
469
 
470
		$resultatsVotes = $this->bdd->recupererTous($requeteVotes);
471
		foreach ($resultatsVotes as $vote) {
787 delphine 472
			$propositions[$vote['ce_proposition']]['votes'][] = $this->formaterVotes($vote);
781 delphine 473
		}
474
		return $propositions;
475
	}
476
 
477
	/**
755 gduche 478
	 * Charger le nombre de commentaires (sans détermination) associé à l'observation
479
	 * @param Array $observations le tableau des observatins à mettre à jour
480
	 * */
781 delphine 481
	private function chargerNombreCommentaire($ids_proposition, $propositions) {
482
		$requeteNbCommentaires = 'SELECT ce_proposition, COUNT('.$this->proteger('id_commentaire').') as nb '.
483
									'FROM '.$this->gestionBdd->formaterTable('del_commentaire').
484
									'WHERE ce_proposition IN ('.implode(', ', $ids_proposition).')';
485
		$nbCommentaires = $this->bdd->recuperer($requeteNbCommentaires);
486
		foreach ($nbCommentaires as $vote) {
487
			$propositions[$vote['ce_proposition']]['commentaires']= $vote;
755 gduche 488
		}
781 delphine 489
		return $propositions;
755 gduche 490
	}
737 gduche 491
 
720 gduche 492
	/*-------------------------------------------------------------------------------
493
								FORMATER ET METTRE EN FORME
494
	--------------------------------------------------------------------------------*/
495
 
496
	/**
737 gduche 497
	 * Formater les images d'une observation
498
	 * @param array $images les images de l'observation
499
	 * */
500
	private function formaterImages($images) {
501
		$imagesRetour = array();
502
		foreach ($images as $image) {
503
			$imageCourante = array();
504
			$imageCourante['id_image'] = $image['id_image'];
505
			$imageCourante['date'] = $image['date_prise_de_vue'];
506
			$imageCourante['binaire.href'] = $this->formaterLienImage($image['id_image']);
507
			$imageCourante['hauteur'] = $image['hauteur'];
508
			$imageRetour['largeur'] = $image['largeur'];
509
 
510
			$imagesRetour[] = $imageCourante;
511
		}
512
 
513
		return $imagesRetour;
514
	}
515
 
516
	/**
720 gduche 517
	*  Formater une observation depuis une ligne liaison
518
	*  @param $liaison liaison issue de la recherche
519
	*  @return $observation l'observation mise en forme
520
	* */
521
	private function formaterObservation($liaison) {
522
		$observation = array();
523
 
524
		foreach ($this->mappingObservation as $nomOriginal => $nomFinal) {
525
			$observation[$nomFinal] = $liaison[$nomOriginal];
526
		}
745 gduche 527
 
528
		$observation['images'] = array();
720 gduche 529
 
530
		return $observation;
531
	}
532
 
533
 
534
	/**
535
	 * Formater le lien de l'image en fonction du fichier de config et de l'identifiant de l'image
536
	 * */
537
	private function formaterLienImage($idImage) {
538
		$idImage = sprintf('%09s', $idImage);
539
		$url = $this->conteneur->getParametre('url_images');
540
		$urlImage = str_replace('%s', $idImage, $url);
541
		return $urlImage;
542
	}
543
 
787 delphine 544
	/**
545
	*  Formater un vote en fonction du fichier de configuration config_votes.ini
546
	*  @param $votes array()
547
	* */
548
	private function formaterVotes($vote) {
549
		$retour = array();
550
		foreach ($vote as $param=>$valeur) {
551
			$retour[$vote['id_vote']][$this->mappingVotes[$param]] = $valeur;
552
		}
553
		return $retour;
554
	}
555
 
720 gduche 556
	private function proteger($valeur) {
557
		if (is_array($valeur)) {
558
			return $this->bdd->protegerTableau($valeur);
559
		} else {
560
			return $this->bdd->proteger($valeur);
561
		}
562
	}
563
}
564
?>