Subversion Repositories eFlore/Projets.eflore-projets

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
6 jpm 1 
<?php
2 
/**
3 
* Description :
4 
* Classe NomsVernaculaires.php fournit une liste de noms vernaculaires et leur liaison à la bdtfx
109 jpm 5 
* Le but étant de fournir un ensemble minimal d'information comprenant :
6 
* un identifiant (numérique ou alphanumérique sous forme de ChatMot si possible), un nom, une langue et
6 jpm 7 
* une relation avec un taxon de la bdtfx.
8 
* Si l'url finit par /noms-vernaculaires on retourne une liste de noms (seulement les 100 premières par défaut).
9 
* L'url peut contenir des paramètres optionnels passés après le ? : /observations?param1=val1&param2=val2&...
109 jpm 10 
*
11 
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche,
6 jpm 12 
* distinct, retour.format, navigation.depart et navigation.limite.
109 jpm 13 
*
6 jpm 14 
* Encodage en entrée : utf8
15 
* Encodage en sortie : utf8
16 
* @package framework-v3
109 jpm 17 
* @author Delphine Cauquil <delphine@tela-botanica.org>
6 jpm 18 
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org>
19 
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
20 
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
21 
* @version 1.0
22 
* @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org)
23 
*/
734 raphael 24 
 
25 
// Un caractère de concaténation entre le projet et le service.
26 
// Ce caractère ne doit pas faire partie d'aucun des noms de service ou projet
27 
define('RES_VAL_SEP', '@');
832 raphael 28 
define('SPE_INDEX_NVJFL', '_result_ontologies' . RES_VAL_SEP . 'nvjfl');
734 raphael 29 
 
6 jpm 30 
class NomsVernaculaires extends Commun {
832 raphael 31 
 
32 
	static $onto_multi_support = array('conseil_emploi', 'genre');
33 
	static $champ_infos = array(
729 raphael 34 
		'taxon' => array('service' => 'taxons', 'ressource' => 'nt:', 'projet' => 'bdtfx', 'nom' => 'nom_sci',
35 
						 // utilisés par ajouterChampsOntologieLigneResultat()
36 
						 'intitule' => 'taxon.code', // intitulé du champ tel qu'il sera renvoyé en JSON
37 
						 'bdd_champ' => 'num_taxon'), // intitulé du champ tel qu'il est présent dans l'enregistrement MySQL
38 
		'conseil_emploi' => array('service' => 'ontologies', 'ressource' => 'numStatut:', 'projet' => 'nvjfl', 'nom' => 'nom',
39 
								  'intitule' => 'conseil_emploi', 'bdd_champ' => 'num_statut'),
40 
		'genre' => array('service' => 'ontologies', 'ressource' => 'genreNombre:', 'projet' => 'nvjfl', 'nom' => 'nom',
41 
						 'intitule' => 'genre', 'bdd_champ' => 'num_genre'));
109 jpm 42 
 
6 jpm 43 
	protected $service = 'noms-vernaculaires';
109 jpm 44 
 
6 jpm 45 
	/**
46 
	 * Permet de stocker la requete formulée : /noms-vernaculaires | /noms-vernaculaires/#id |
47 
	 *  /noms-vernaculaires/#id/champ | /noms-vernaculaires/#id/relations
109 jpm 48 
	 * Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service.
6 jpm 49 
	 * Est utilisée principalement pr déterminer le format du tableau à retourner.	 */
109 jpm 50 
	protected $format_reponse = 'noms-vernaculaires';
51 
 
52 
	/** Variables constituant les parametres de la requete SQL (champ, condition, limit) remplie
6 jpm 53 
	 * selon ressources et paramètres */
54 
	protected $requete_champ = array(' * ');
55 
	protected $requete_condition = '';
56 
	protected $limite_requete = array(
109 jpm 57 
		'depart' => 0,
6 jpm 58 
		'limite' => 100
59 
	);
284 jpm 60 
 
61 
	protected $champ_tri = 'code_langue';
62 
	protected $direction_tri = 'asc';
286 aurelien 63 
 
64 
	/**
65 
	 * Indique les champs supplémentaires à retourner
66 
	 *  - conseil_emploi = conseil d'emploi du nom vernaculaire
67 
	 *  - genre = genre et nombre du nom
68 
	 *  - taxon = nom retenu associé à ce nom
69 
	 */
70 
	protected $champs_supp = array();
109 jpm 71 
 
6 jpm 72 
	/**
109 jpm 73 
	 * Precise la contenance plus ou moins précise du tableau à retourner :
74 
	 *  - min = les données présentes dans la table
6 jpm 75 
	 *  - max = les données de la table + les informations complémentaires (pour les identifiants et les codes)
76 
	 *  - oss = la liste des nom_sci (uniquement pour noms et taxons) */
77 
	protected $retour_format = 'max';
109 jpm 78 
	/** Valeur du paramètre de requete recherche :
79 
	 *  - stricte : le masque est passé tel quel à l'opérateur LIKE.
80 
	 *  - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE.
6 jpm 81 
	 *  - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */
82 
	protected $recherche;
284 jpm 83 
 
6 jpm 84 
	/** Permet de stocker le tableau de résultat (non encodé en json) */
85 
	protected $table_retour = array();
86 
	/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */
87 
	protected $total_resultat;
536 gduche 88 
 
89 
	private $config;
90 
 
563 aurelien 91 
	public function __construct($config) {
536 gduche 92 
		$this->config = is_null($config) ? Config::get('NomsVernaculaires') : $config;
93 
	}
109 jpm 94 
 
95 
	//+------------------------------------------------------------------------------------------------------+
6 jpm 96 
	// créer une condition en fonction du paramétre
109 jpm 97 
	public function traiterParametres() {
98 
		if (isset($this->parametres) && !empty($this->parametres)) {
99 
 
100 
			if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') {
101 
				$this->recherche = $this->parametres['recherche'];
6 jpm 102 
			}
109 jpm 103 
			foreach ($this->parametres as $param => $valeur) {
6 jpm 104 
				switch ($param) {
109 jpm 105 
					case 'masque' :
284 jpm 106 
						$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
109 jpm 107 
						break;
108 
					case 'masque.nt' :
284 jpm 109 
						$this->ajouterFiltreMasque('num_taxon', $valeur);
109 jpm 110 
						break;
111 
					case 'masque.nv' :
284 jpm 112 
						$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
109 jpm 113 
						break;
114 
					case 'masque.lg' :
284 jpm 115 
						$this->ajouterFiltreMasque('code_langue', $valeur);
109 jpm 116 
						break;
117 
					case 'masque.cce' :
284 jpm 118 
						$this->ajouterFiltreMasque('num_statut', $valeur);
109 jpm 119 
						break;
120 
					case 'retour.format' :
121 
						$this->retour_format = $valeur;
122 
						break;
123 
					case 'navigation.depart' :
124 
						$this->limite_requete['depart'] = $valeur;
125 
						break;
126 
					case 'navigation.limite' :
127 
						$this->limite_requete['limite'] = $valeur;
128 
						break;
286 aurelien 129 
					case 'retour.champs' :
130 
						$this->champs_supp = explode(',',$valeur);
131 
					break;
109 jpm 132 
					case 'recherche' :
133 
						break;
152 delphine 134 
					case 'version.projet' :
135 
						break;
109 jpm 136 
					default :
137 
						$p = 'Erreur dans les paramètres de recherche de votre requête : '.
138 
							'</br> Le paramètre " '.$param.' " n\'existe pas.';
139 
							$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $p);
6 jpm 140 
				}
141 
			}
142 
		}
143 
	}
109 jpm 144 
 
284 jpm 145 
	public function ajouterFiltreMasque($nom_champ, $valeur) {
6 jpm 146 
		if ($nom_champ == 'num_taxon') { // si il s'agit d'un chiffre
147 
			$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur);
148 
		} else {
149 
			if ($this->recherche == 'floue') {
150 
				$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
151 
					.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ';
152 
			} else {
153 
				if ($this->recherche == 'etendue') {
180 delphine 154 
					$valeur = '%'.str_replace(' ','% ', $valeur);
6 jpm 155 
					$valeur .= '%';
156 
				}
157 
				$this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur);
158 
			}
159 
		}
160 
	}
161 
 
109 jpm 162 
	//+------------------------------------------------------------------------------------------------------+
6 jpm 163 
	// en fonction de la présence des ressources modifie requete_champ et requete_condition
109 jpm 164 
	public function traiterRessources() {
165 
		if (isset($this->ressources) && !empty($this->ressources)) {
166 
			if (isset($this->ressources[0]) && !empty($this->ressources[0])) {
6 jpm 167 
				$this->traiterRessourceId(); // ajoute condition id=#valeur
109 jpm 168 
				if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
160 delphine 169 
					$this->traiterRessourceChamp(); //modifie requete_champ ou requete_condition
6 jpm 170 
				}
171 
			}
172 
		} else { //rajoute distinct pour ne pas avoir plusieurs fois le même nom
173 
			$this->requete_champ = array('distinct(id)', 'nom_vernaculaire ');
174 
		}
175 
	}
109 jpm 176 
 
6 jpm 177 
	//requete : /noms-vernaculaires/#id (ex : /noms-vernaculaires/7)
178 
	public function traiterRessourceId() {
109 jpm 179 
		if (is_numeric($this->ressources[0])) {
180 
			$this->requete_condition[] = ' id = '.$this->getBdd()->proteger($this->ressources[0]);
6 jpm 181 
			$this->format_reponse .= '/id';
160 delphine 182 
		} elseif ($this->ressources[0] == 'attributions') {
183 
			$this->format_reponse .= '/attributions';
6 jpm 184 
		} else {
109 jpm 185 
			$r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->ressources[0].
6 jpm 186 
				' " n\'existe pas.';
109 jpm 187 
			$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r);
6 jpm 188 
		}
189 
	}
109 jpm 190 
 
191 
 
160 delphine 192 
	public function traiterRessourceChamp() {
193 
		$this->format_reponse .= '/champ';
194 
		$this->analyserChamp();
6 jpm 195 
	}
109 jpm 196 
 
6 jpm 197 
	public function analyserChamp() {
198 
		$this->requete_champ = array();
199 
		$this->recupererTableConfig('champs_possibles');// s'il y a plusieurs champs correspondant au champ demandé ils sont séparé par des |
109 jpm 200 
		$champs = explode(' ', $this->ressources[1]);
6 jpm 201 
		foreach ($champs as $champ) {
202 
			preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match);
203 
			if (isset($this->champs_possibles[$match[1]])) {
204 
				$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[1]]);
205 
			} elseif (isset($this->champs_possibles[$match[0]])) {
206 
				$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[0]]);
207 
			} else {
208 
				$champs_possibles = implode('</li><li>', array_keys($this->champs_possibles));
209 
				$c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '.
210 
					'Les champs disponibles sont : <li>'.$champs_possibles.'</li> et leurs déclinaisons (ex. ".code").';
211 
				$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c);
212 
			}
213 
		}
214 
	}
109 jpm 215 
 
216 
	//+------------------------------------------------------------------------------------------------------+
6 jpm 217 
	public function assemblerLaRequete() {
218 
		$requete = ' SELECT '.$this->formerRequeteChamp().
659 delphine 219 
					', CASE num_statut WHEN "" THEN 1 ELSE 0 END AS is_null '.
6 jpm 220 
					' FROM '.$this->table
659 delphine 221 
					.$this->formerRequeteCondition().
222 
					' ORDER BY is_null ASC, num_statut ASC '
6 jpm 223 
					.$this->formerRequeteLimite();
224 
		return $requete;
225 
	}
109 jpm 226 
 
6 jpm 227 
	public  function formerRequeteChamp() {
228 
		if (in_array('*', $this->requete_champ)) {
229 
			$champ = ' * ';
230 
		} else {
231 
			$champ = implode(', ', $this->requete_champ);
232 
		}
233 
		return $champ;
234 
	}
109 jpm 235 
 
6 jpm 236 
	public  function formerRequeteCondition() {
237 
		$condition = '';
109 jpm 238 
		if ($this->requete_condition != null) {
6 jpm 239 
			$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
109 jpm 240 
		}
6 jpm 241 
		return $condition;
242 
	}
109 jpm 243 
 
244 
	//ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes
6 jpm 245 
	// suivantes : /noms-vernaculaires et /noms-vernaculaires/#id/relations)
246 
	public function formerRequeteLimite() {
247 
		if (in_array($this->format_reponse , array($this->service.'/id', $this->service.'/id/champs'))) {
109 jpm 248 
			$this->requete_limite = '';
6 jpm 249 
		} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) {
109 jpm 250 
			$this->limite_requete['depart'] =
6 jpm 251 
				(($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']);
109 jpm 252 
			$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
6 jpm 253 
		} else {
109 jpm 254 
			$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
6 jpm 255 
		}
256 
		return $this->requete_limite;
257 
	}
109 jpm 258 
 
6 jpm 259 
	//on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /noms-vernaculaires)
260 
	public function recupererTotalResultat() {
160 delphine 261 
		$distinct = ($this->format_reponse == 'noms-vernaculaires/attributions') ? 'id' : 'distinct(id)';
262 
		$requete = 'SELECT count('.$distinct.') as nombre FROM '
6 jpm 263 
			.$this->table
264 
			.$this->formerRequeteCondition();
265 
		$res = $this->getBdd()->recuperer($requete);
109 jpm 266 
 
6 jpm 267 
		if ($res) {
268 
			$total = $res['nombre'];
269 
		} else {
160 delphine 270 
			$t = 'Fonction recupererTotalResultat() : <br/>Données introuvables dans la base '.$requete;
6 jpm 271 
			$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $t);
272 
		}
273 
		return $total;
274 
	}
109 jpm 275 
 
276 
	//+------------------------------------------------------------------------------------------------------+
277 
	// determine en fct du service appelé (/noms-vernaculaires | /noms-vernaculaires/#id | /noms-vernaculaires/#id/champ |
6 jpm 278 
	// /noms-vernaculaires/#id/relations) le format du tableau à retourner.
279 
	public function retournerResultatFormate($resultat) {
280 
		$this->recupererTableConfig('correspondance_champs');
281 
		switch ($this->format_reponse) {
132 aurelien 282 
			case 'noms-vernaculaires'				:
283 
				$reponse = ($this->retour_format == 'oss') ? $this->formaterEnOss($resultat) : $this->formaterNomsVernaculaires($resultat);			break;
160 delphine 284 
			case 'noms-vernaculaires/attributions'	: $reponse = $this->formaterNomsVernaculairesAttributions($resultat);	break;
6 jpm 285 
			case 'noms-vernaculaires/id'			: $reponse = $this->formaterNomsVernaculairesId($resultat);			break;
286 
			case 'noms-vernaculaires/id/champ'		: $reponse = $this->formaterNomsVernaculairesIdChamp($resultat);	break;
287 
			default									:																	break;
288 
		}
289 
		return $reponse;
290 
	}
608 mathilde 291 
 
292 
	public function ajouterJsonEnTeteNV() {
293 
		$table_retour_json['masque'] = $this->recupererMasque();
294 
		$table_retour_json['depart'] = $this->limite_requete['depart'];
295 
		$table_retour_json['limite'] = $this->limite_requete['limite'];
296 
		$table_retour_json['total']  = $this->total_resultat;
6 jpm 297 
		$url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires');
608 mathilde 298 
		if (isset($url['precedent']) && $url['precedent'] != '') {
299 
			$table_retour_json['href.precedent'] = $url['precedent'];
6 jpm 300 
		}
608 mathilde 301 
		if (isset($url['suivant']) && $url['suivant']   != '') {
302 
			$table_retour_json['href.suivant']   = $url['suivant'];
152 delphine 303 
		}
608 mathilde 304 
		return $table_retour_json;
305 
	}
306 
 
307 
	public function ajouterJsonResultatNV($resultat) {
6 jpm 308 
		foreach ($resultat as $tab) {
309 
			foreach ($tab as $key => $valeur) {
310 
				if ($valeur != '') {
311 
					switch ($key) {
312 
						case 'id'				: $num = $valeur;								break;
313 
						case 'nom_vernaculaire'	: $this->table_retour['nom'] = $valeur;			break;
314 
						default					:												break;
315 
					}
316 
				}
317 
			}
608 mathilde 318 
		    if ($this->retour_format == 'max') $this->table_retour['href'] = $this->ajouterHref('noms-vernaculaires', $num);
6 jpm 319 
			$resultat_json[$num] = $this->table_retour;
320 
			$this->table_retour = array();
321 
		}
608 mathilde 322 
		return  $resultat_json;
323 
	}
109 jpm 324 
 
608 mathilde 325 
 
326 
	public function formaterNomsVernaculaires($resultat) {
327 
		$table_retour_json['entete'] = $this->ajouterJsonEnTeteNV();
328 
		$resultat = $this->hierarchiserResultat($resultat);
329 
		$table_retour_json['resultat'] = $this->ajouterJsonResultatNV($resultat);
6 jpm 330 
		return $table_retour_json;
331 
	}
132 aurelien 332 
 
608 mathilde 333 
	public function hierarchiserResultat($resultat) {
334 
		//tri recherche floue
335 
		if (isset($this->parametres['masque.nv'])) {
336 
			$resultat = $this->trierRechercheFloue($this->parametres['masque.nv'], $resultat, 'nom_vernaculaire');
337 
		}
338 
		if (isset($this->parametres['masque'])) {
339 
			$resultat = $this->trierRechercheFloue($this->parametres['masque'], $resultat, 'nom_vernaculaire');
340 
		}
341 
		return $resultat;
342 
	}
343 
 
160 delphine 344 
	public function recupererMasque() {
345 
		$tab_masque = array();
346 
		foreach ($this->parametres as $param=>$valeur) {
347 
			if (strstr($param, 'masque') != false) {
348 
				$tab_masque[] = $param.'='.$valeur;
349 
			}
350 
		}
351 
		$masque = implode('&', $tab_masque);
352 
		return $masque;
353 
	}
354 
 
132 aurelien 355 
	public function formaterEnOss($resultat) {
356 
		$table_nom = array();
357 
		$oss = '';
358 
		foreach ($resultat as $tab) {
359 
			if (isset($tab['nom_vernaculaire']) ) {
360 
				if (!in_array($tab['nom_vernaculaire'], $table_nom)) {
361 
					$table_nom[] = $tab['nom_vernaculaire'];
362 
					$oss [] = $tab['nom_vernaculaire'];
363 
				}
364 
			}
365 
		}
366 
		if (isset($this->masque)) $masque = implode('&', $this->masque);
367 
		else $masque = 'Pas de masque';
368 
		$table_retour_oss = array($masque, $oss);
369 
		return $table_retour_oss;
370 
	}
160 delphine 371 
 
372 
	public function formaterNomsVernaculairesAttributions($resultat) {
373 
		//on remplie la table $table_retour_json['entete']
374 
		$table_retour_json['entete']['masque'] = $this->recupererMasque();
375 
		$table_retour_json['entete']['depart'] = $this->limite_requete['depart'];
376 
		$table_retour_json['entete']['limite'] = $this->limite_requete['limite'];
377 
		$table_retour_json['entete']['total']  = $this->total_resultat;
378 
		$url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires/attributions');
729 raphael 379 
		if (!empty($url['precedent'])) {
160 delphine 380 
			$table_retour_json['entete']['href.precedent'] = $url['precedent'];
381 
		}
729 raphael 382 
		if (!empty($url['suivant'])) {
160 delphine 383 
			$table_retour_json['entete']['href.suivant']   = $url['suivant'];
384 
		}
890 raphael 385 
		foreach ($resultat as &$tab) {
730 raphael 386 
			$nnv = $tab['num_nom_vernaculaire'];
387 
			$resultat_json[$nnv]['id'] = $tab['id'];
388 
			$resultat_json[$nnv]['nom_vernaculaire'] = $tab['nom_vernaculaire'];
890 raphael 389 
			$resultat_json[$nnv]['langue.code'] = $resultat_json[$nnv]['code_langue'] = $tab['code_langue'];
730 raphael 390 
			$resultat_json[$nnv]['taxon.code'] = 'bdtfx.nt:'.$tab['num_taxon'];
160 delphine 391 
			if ($this->retour_format == 'max') {
284 jpm 392 
				$this->taxons[] = $tab['num_taxon']; // utilisé pour chercher les noms latins plus bas
729 raphael 393 
				if($this->champs_supp) {
730 raphael 394 
					//$resultat_json[$nnv] = $this->ajouterChampsOntologieLigneResultat($tab);
395 
					// simple initialisation par copie de la référence de l'original
396 
					$resultat_json[$nnv] = &$tab;
286 aurelien 397 
				}
729 raphael 398 
				else {
730 raphael 399 
					$resultat_json[$nnv]['num_taxon'] = $tab['num_taxon'];
400 
					$resultat_json[$nnv]['nom_retenu.code'] = $tab['num_taxon'];
401 
					$resultat_json[$nnv]['taxon'] = $tab['num_taxon'];
402 
					$resultat_json[$nnv]['href'] = $this->ajouterHref('noms-vernaculaires', $tab['id']);
729 raphael 403 
				}
160 delphine 404 
			}
280 aurelien 405 
		}
730 raphael 406 
 
407 
		// dans ce cas (particulier?) nous n'avons pour l'heure initialisé qu'une référence
408 
		// vers le tableau de valeurs original
409 
		if ($this->retour_format == 'max' && $this->champs_supp) {
410 
			// récupérons désormais les ontologies
411 
			$this->ajouterChampsOntologieLigneTousResultats($resultat_json);
412 
		}
413 
 
280 aurelien 414 
		if ($this->retour_format == 'max') {
284 jpm 415 
			// On est obligé de faire un deuxième boucle pour demander tous les taxons présents en une
416 
			// fois et les attribuer aux noms car c'est beaucoup plus rapide
417 
			$noms_sci = $this->recupererNomTaxons();
286 aurelien 418 
			foreach ($resultat_json as $num_nom => &$tab) {
419 
				$tab = $this->ajouterTaxonsAttributionsLigneResultat($tab, $noms_sci);
627 aurelien 420 
				if($tab == null) {
421 
					unset($resultat_json[$num_nom]);
422 
				}
284 jpm 423 
			}
160 delphine 424 
		}
280 aurelien 425 
 
160 delphine 426 
		$table_retour_json['resultat'] = $resultat_json;
427 
		return $table_retour_json;
428 
	}
429 
 
286 aurelien 430 
	/**
431 
	 * Ajoute les champs d'ontologie supplémentaires si necéssaire
832 raphael 432 
	 * en faisant appels aux web services associés.
433 
	 * Les appels peuvent être fait individuellement (pour un couple <ontologie:valeur>) ou bien
434 
	 * regroupés, **si le webservice correspondant le supporte**.
435 
	 *
436 
	 * Nous disposons à ce jour de 3 (trois) webservices d'ontologies correspondant aux noms vernaculaires (cf $champ_infos)
437 
	 * Mais 2 d'entre eux sont identiques, il s'agit de /nvjfl/ontologies/. Or ce webservice supporte le multi-critère.
438 
	 * Nous pouvons donc factorisé l'appel pour "conseil_emploi" et "genre", mais pas pour "taxon".
439 
	 *
730 raphael 440 
	 * @param array in/out $resultats: tous les résultats
441 
	 */
442 
	public function ajouterChampsOntologieLigneTousResultats(&$resultats) {
832 raphael 443 
		$champs_sup = array_intersect($this->champs_supp, array_keys(self::$champ_infos));
730 raphael 444 
 
832 raphael 445 
		// La regroupement des toutes les valeurs recherchées (pour tous les
446 
		// résultats), pour "les" onotologies supportant le multi-critère est effectué ci-dessous.
447 
		// Dans les faits ce n'est le cas que pour nvjfl.
448 
		$ontologieParamPending = self::NvjflOntologieIndex($resultats, $champs_sup);
449 
		$this->NvjflOntologieExpand($ontologieParamPending);
450 
		self::NvjflOntologieCombine($resultats);
730 raphael 451 
 
832 raphael 452 
		// pour les ontologies multi-critères, on vient de le régler ci-dessus
453 
		$champs_sup = array_diff($champs_sup, self::$onto_multi_support);
454 
 
455 
 
456 
		// ici, $champs_sup ne peut contenir, au plus, que "taxon".
457 
		// code historique:
458 
		foreach($champs_sup as $cle) {
459 
			$champs_supplementaires = self::$champ_infos[$cle];
730 raphael 460 
			// extrait, depuis un élément de $champ_infos:
461 
			// $service, $ressource, $projet, $nom, $intitule, $bdd_champ
462 
			extract($champs_supplementaires);
463 
 
464 
			foreach ($resultats as &$tab) {
465 
				$valeur_recherche = $tab[$bdd_champ];
466 
				if(!trim($valeur_recherche)) continue;
467 
 
468 
				$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur_recherche, $projet);
469 
				$tab[$intitule] = $this->chercherSignificationCode($url, $nom);
470 
			}
471 
		}
472 
	}
473 
 
731 raphael 474 
	/* Récupère les valeurs recherchées pour une liste de résultats, (plus ou moins)
475 
	   spécifiquement au service d'Ontologies de NVJFL.
476 
	   Aggrège les valeurs dans le tableau retourné.
477 
	   Une référence vers l'index du tableau (NULL pour l'instant) est laissée dans
478 
	   un élément du résultat. */
832 raphael 479 
	static function NvjflOntologieIndex(&$resultats, $champs_sup) {
480 
		// nous ne supportons le multi-critère que sur les ontologies nvjfl, et nous
481 
		// avons précisé celles qui sont concernées dans self::$onto_multi_support
482 
		$champs_sup = array_intersect($champs_sup, self::$onto_multi_support);
731 raphael 483 
		$ontologieParamPending = Array();
484 
		foreach($resultats as &$resultat) {
832 raphael 485 
			foreach($champs_sup as $v) {
486 
				// de cet extract() nous n'utilisons que $bdd_champ et $ressource
487 
				extract(self::$champ_infos[$v]);
488 
				if(!isset($resultat[$bdd_champ])) continue;
489 
 
490 
				$valeur_recherche = $resultat[$bdd_champ];
491 
				if(!trim($valeur_recherche)) continue;
492 
 
493 
				// XXX: $ressource contient déjà ':' comme suffixe
494 
				$critere = $ressource . $valeur_recherche;
495 
				$ontologieParamPending[$critere] = NULL;
496 
				// placeholder pour le résultat
497 
				$resultat[SPE_INDEX_NVJFL][$v][$critere] =
498 
					&$ontologieParamPending[$critere];
499 
			}
731 raphael 500 
		}
501 
		return $ontologieParamPending;
502 
	}
503 
 
504 
	// TODO: switch to static si il peut en être de même pour ajouterHrefAutreProjet()
505 
	/* À partir d'un aggrégat des critère de requêtes d'ontologies, spécifiques à NVJFL,
506 
	   créé une URL multi-critère.
507 
	   Celle-ci, dans ce cas précis, n'est que la concaténation, par des virgules,
832 raphael 508 
	   des couples <ressource:ValeurRecherchée>.
509 
	   L'URL est appelée et la valeur correspondante est remplacée dans $criteres_requete.
731 raphael 510 
 
511 
	   Note: dans le cadre du tryptique index/expand/combine pour lequel cette fonction existe,
832 raphael 512 
	   la valeur est référencée par un élément d'une ou plusieurs lignes de $resultat correspondantes.
731 raphael 513 
	   Celle(s)-ci sera[ont] donc changée(s) dans la foulée. */
514 
	public function NvjflOntologieExpand(&$criteres_requete) {
515 
		// équivalent spécifique de ajouterHrefAutreProjet()
516 
		$valeurs_requises = implode(',', array_keys($criteres_requete));
832 raphael 517 
		// en vérité, nous ne supportons ceci ici que pour nvjfl et non n'importe quel url_service
809 raphael 518 
		$url = Config::get('url_service').'/ontologies/'.$valeurs_requises;
731 raphael 519 
		$val = $this->consulterHref($url);
831 raphael 520 
 
521 
		// TODO, le webservice d'ontologies devrait être modifié pour retourner un tableau
522 
		// indexé par critère requesté à *CHAQUE* fois, y compris lorsque 1 seul critère est
523 
		// demandé.
524 
		if(array_key_exists('id', $val) && count($criteres_requete) == 1) {
525 
			$k = key($criteres_requete);
526 
			$criteres_requete[$k] = $val;
527 
			return;
528 
		}
529 
 
832 raphael 530 
		// subtilité, cette affectation modifie par conséquent les valeurs dans
531 
		// $resultats[X][SPE_INDEX_NVJFL]
731 raphael 532 
		// dont la référence pointe toujours sur $v
533 
		foreach($val as $k => $v) $criteres_requete[$k] = $val->$k;
534 
	}
535 
 
536 
	/* Fonction finale du tryptique: réordonne les valeurs obtenues auprès du web-service
832 raphael 537 
	   NVJFL en adéquation avec les champs attendus en sortie.
538 
	   Dès l'indexation des critères, nous avons associé une (ou plusieurs) référence(s) du
539 
	   tableau de résultats vers le tableau de retour des ontologies à l'aide d'un index
540 
	   particulier l'index SPE_INDEX_NVJFL qui contient comme élément(s)
541 
	   un ou plusieurs ontologies (les indexes de self::$champ_infos) qui elles-mêmes contiennent
542 
	   une ou plusieurs valeurs représentant les valeurs recherchées appartement à cette ontologies.
543 
	   Celui-ci est supprimé après avoir été correctement copié. */
544 
	/**
545 
	 * @param array in/out $resultats: tous les résultats
546 
	 * @param array in $critere: tableau des ontologies:valeur demandées, de la forme [ numStatut:1, genreNombre:11, ... ]
547 
	 */
848 raphael 548 
	static function NvjflOntologieCombine(&$resultats) {
731 raphael 549 
		foreach($resultats as &$resultat) {
832 raphael 550 
			if(!array_key_exists(SPE_INDEX_NVJFL, $resultat)) continue;
551 
 
552 
			/* Note: la complétude d'un résultat peut dépendre de plusieurs ontologies différentes,
553 
			   d'où cette boucle. Cependant une seule valeur sera demandé pour cette ontologie, c'est pourquoi
554 
			   $resultat[SPE_INDEX_NVJFL][$onto_name], s'il existe, ne contiendra toujours qu'un seul élément.
555 
			   Puisque par définition un résultat contenant des valeurs d'ontologie n'aura jamais qu'un seul et unique
556 
			   attribut num_genre (ou num_statut, ou autre) */
557 
			foreach(self::$onto_multi_support as $onto_name) {
848 raphael 558 
				if(!array_key_exists($onto_name, $resultat[SPE_INDEX_NVJFL])) continue;
559 
 
832 raphael 560 
				/* $onto_name est un nom d'ontologie (l'une des clefs, parmi conseil_emploi et genre,
561 
				   cf la boucle sur $champs_sup dans  NvjflOntologieIndex()
562 
				   de cet extract() nous n'utilisons que $intitule et $nom */
563 
				extract(self::$champ_infos[$onto_name]);
564 
 
565 
				// equivalent de l'affectation finale de chercherSignificationCode()
566 
				// (utilisé lors de recherches d'ontologies en mono-critère)
567 
				// XXX: PHP-5.3 pas de récupération d'attribut sur fonction
568 
				$r = current($resultat[SPE_INDEX_NVJFL][$onto_name]);
569 
				$resultat[$intitule] = $r->$nom;
570 
 
571 
				// XXX: certes nous pourrions nous contenter du unset() final
572 
				unset($resultat[SPE_INDEX_NVJFL][$onto_name]);
573 
			}
574 
			unset($resultat[SPE_INDEX_NVJFL]);
731 raphael 575 
		}
576 
	}
577 
 
730 raphael 578 
	/**
579 
	 * Ajoute les champs d'ontologie supplémentaires si necéssaire
580 
	 * en faisant appels aux web services associés
286 aurelien 581 
	 * @param array $ligne_resultat
582 
	 *
583 
	 * @return array la ligne modifiée
584 
	 */
284 jpm 585 
	public function ajouterChampsOntologieLigneResultat($ligne_resultat) {
832 raphael 586 
		foreach(self::$champ_infos as $cle => $champs_supplementaires) {
729 raphael 587 
			if(!in_array($cle, $this->champs_supp)) continue;
588 
			// extrait, depuis un élément de $champ_infos:
589 
			// $service, $ressource, $projet, $nom, $intitule, $bdd_champ
590 
			extract($champs_supplementaires);
591 
			$valeur_recherche = $ligne_resultat[$bdd_champ];
592 
			if(!trim($valeur_recherche)) continue;
593 
			$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur_recherche, $projet);
594 
			$ligne_resultat[$intitule] = $this->chercherSignificationCode($url, $nom);
277 aurelien 595 
		}
284 jpm 596 
		return $ligne_resultat;
277 aurelien 597 
	}
598 
 
284 jpm 599 
	/**
600 
	 * Fonction qui ajoute les attributions à une ligne de résultats
601 
	 *
602 
	 * @param array $ligne_tableau_resultat
603 
	 * @param array $nom_sci
604 
	 */
605 
	public function ajouterTaxonsAttributionsLigneResultat(&$ligne_tableau_resultat, &$noms_sci) {
285 aurelien 606 
		if (isset($noms_sci[$ligne_tableau_resultat['num_taxon']])) {
607 
			$ligne_tableau_resultat['nom_retenu.code'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['id'];
608 
			$ligne_tableau_resultat['taxon'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['nom_sci'];
627 aurelien 609 
		} else {
610 
			$ligne_tableau_resultat = null;
284 jpm 611 
		}
612 
		return $ligne_tableau_resultat;
613 
	}
614 
 
615 
	private function trierLigneTableau($a, $b) {
616 
		$retour = 0;
617 
 
618 
		if ($a[$this->champ_tri] == $b[$this->champ_tri]) {
619 
			$retour = 0;
620 
		}
621 
 
622 
		if($this->champ_tri == 'code_langue') {
623 
			if ($a[$this->champ_tri] == 'fra' && $b[$this->champ_tri] != 'fra') {
624 
				$retour = ($this->direction_tri == 'asc') ? -1 : 1;
625 
			} else if ($a[$this->champ_tri] != 'fra' && $b[$this->champ_tri] == 'fra') {
626 
				$retour = ($this->direction_tri == 'asc') ? 1 : -1;
627 
			} else {
628 
				$retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]);
629 
			}
630 
		} else {
631 
			$retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]);
632 
		}
633 
		return $retour;
634 
	}
635 
 
636 
	private function comparerChaineSelonDirectionTri($a, $b) {
637 
		if($this->direction_tri == 'asc') {
638 
			return ($a < $b) ? -1 : 1;
639 
		} else {
640 
			return ($a > $b) ? -1 : 1;
641 
		}
642 
	}
643 
 
6 jpm 644 
	// formatage de la reponse /id ss la forme
645 
	// id, nom_vernaculaire, attributions
646 
	// langue
647 
	// num_nom (correspond à un taxon bdtfx)
648 
	public function formaterNomsVernaculairesId($resultat) {
649 
		foreach ($resultat as $taxon) { // pour chaque attribution à un taxon bdtfx
650 
			// on crée les variables qui serviront de clés et on les enléves du tableau
651 
			$num_nom = $taxon['num_nom_vernaculaire']; // unique pour un trinôme id, langue, taxon
652 
			unset($taxon['num_nom_vernaculaire']);
653 
			$langue = $taxon['code_langue'];
654 
			unset($taxon['code_langue']);
109 jpm 655 
 
6 jpm 656 
			foreach ($this->correspondance_champs as $key => $correspondance) { // ordonne les infos pour affichage
657 
				if (isset($taxon[$key]) && $taxon[$key] != "") {
658 
					$this->afficherDonnees($correspondance, $taxon[$key], $langue, $num_nom);
659 
				}
660 
			}
661 
			foreach ($taxon as $key => $valeur) { // rajoute les champs non prévus dans l'api
662 
				if (!isset($this->correspondance_champs[$key]) && $valeur != "") {
663 
					$this->afficherDonnees($key, $valeur, $langue, $num_nom);
664 
				}
665 
			}
666 
			if ($this->retour_format == 'max') $this->chargerBiblio($num_nom, $langue);
667 
		}
668 
		if ($this->retour_format == 'max') $this->afficherTaxons(); // va chercher les noms de tous les taxons
669 
		unset($this->table_retour['href']);
670 
		return $this->table_retour;
671 
	}
109 jpm 672 
 
6 jpm 673 
	public function afficherDonnees($champ, $valeur, $langue = '', $num_nom = '') {
674 
		if ($champ == 'id' || $champ == 'nom_vernaculaire') {
675 
			$this->table_retour[$champ] = $valeur;
676 
		} elseif (preg_match('/^(.*)\.code$/', $champ, $match)) {
677 
				switch ($match[1]) {
678 
					case 'taxon'	: if ($this->retour_format == 'max') {$this->taxons[$num_nom] = $valeur;}
679 
						$this->afficherPointCode($match[1], $langue, $num_nom, $valeur);	break;
109 jpm 680 
					case 'langue'	: //$this->afficherPointCode($match[1], 'iso-639-3', 'langues', $valeur);
6 jpm 681 
						break;
682 
					case 'genre'	: $this->afficherPointCode($match[1], $langue, $num_nom, $valeur);	break;
683 
					case 'conseil_emploi'	: $this->afficherPointCode($match[1], $langue, $num_nom, $valeur);	break;
684 
					default : break;
685 
				}
109 jpm 686 
 
6 jpm 687 
		} elseif ($langue != '') {
688 
			$this->table_retour['attributions'][$langue][$num_nom][$champ] = $valeur;
689 
		} else {
690 
			$this->table_retour[$champ] = $valeur;
691 
		}
692 
	}
109 jpm 693 
 
6 jpm 694 
	public function afficherPointCode($nomChamp, $langue, $num_nom, $valeur) {
832 raphael 695 
		if (isset(self::$champ_infos[$nomChamp])) {
696 
			extract(self::$champ_infos[$nomChamp]);
6 jpm 697 
		}
109 jpm 698 
 
6 jpm 699 
		if ($this->retour_format == 'max') {
700 
			$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet);
701 
			if ($service == 'taxons') {
702 
				$code_valeur = '';
164 delphine 703 
				$this->table_retour['attributions'][$langue][$num_nom]['nom_retenu.code'] = $code_valeur;
109 jpm 704 
			} else {
6 jpm 705 
				$code_valeur = $this->chercherSignificationCode($url, $nom);
706 
			}
707 
			if ($projet != '') $projet .= '.';
708 
			$this->table_retour['attributions'][$langue][$num_nom][$nomChamp] = $code_valeur;
709 
			$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur;
710 
			$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.href'] = $url;
711 
		} else {
712 
			if ($projet != '') $projet .= '.';
713 
			$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur;
714 
		}
715 
	}
109 jpm 716 
 
6 jpm 717 
	public function chercherSignificationCode($url, $nom) {
718 
		if (isset($this->signification_code[$url])) {
719 
			$valeur = $this->signification_code[$url];
720 
		} else {
721 
			$res = $this->consulterHref($url);
722 
			$valeur = $res->$nom;
723 
			$this->signification_code[$url] = $valeur;
724 
		}
725 
		return $valeur;
726 
	}
109 jpm 727 
 
6 jpm 728 
	public function afficherTaxons() {
160 delphine 729 
		$resultat = $this->recupererNomTaxons();
6 jpm 730 
		foreach ($this->table_retour['attributions'] as $code_langue=>$langue) {
731 
			foreach ($langue as $num_nom=>$taxon) {
732 
				$num_tax = ltrim($taxon['taxon.code'], 'bdtfx.nt:');
733 
				if (isset($resultat[$num_tax])) {
164 delphine 734 
					$this->table_retour['attributions'][$code_langue][$num_nom]['nom_retenu.code'] = $resultat[$num_tax]['id'];
735 
					$this->table_retour['attributions'][$code_langue][$num_nom]['taxon'] = $resultat[$num_tax]['nom_sci'];
6 jpm 736 
				}
737 
			}
738 
		}
739 
	}
160 delphine 740 
 
741 
	public function recupererNomTaxons() {
627 aurelien 742 
		$taxons = array_unique($this->taxons);
743 
		$url = Config::get('url_service_base').'bdtfx/taxons?navigation.limite=500&ns.structure=au&masque.nt='.implode(',', $taxons);
160 delphine 744 
		$res = $this->consulterHref($url);
745 
		foreach ($res->resultat as $id=>$taxon) {
164 delphine 746 
			$resultat[$taxon->num_taxonomique]['id'] = 'bdtfx.nn:'.$id;
627 aurelien 747 
			$resultat[$taxon->num_taxonomique]['nom_sci'] = $taxon->nom_sci_complet;
160 delphine 748 
		}
749 
		return $resultat;
750 
	}
6 jpm 751 
 
752 
	public function formaterNomsVernaculairesIdChamp($resultat) {
109 jpm 753 
		$this->table_retour['id'] = $this->ressources[0];
754 
		$champs = explode(' ', $this->ressources[1]);
6 jpm 755 
		if (in_array('attributions', $champs) != false) {
756 
			$this->formaterNomsVernaculairesId($resultat);
757 
			unset($this->table_retour['nom_vernaculaire']);
160 delphine 758 
		} else {
6 jpm 759 
			$champ_attributions = array('num_taxon', 'zone_usage', 'num_statut', 'num_genre', 'notes');
760 
			foreach ($resultat as $taxon) {
761 
				foreach ($taxon as $key=>$valeur) {
762 
					if ($key == 'code_langue' && in_array('langue', $champs) != false) {
763 
						$this->table_retour['attributions']['langue'][] = $valeur;
764 
					} elseif (in_array($key, $champ_attributions) != false) {
765 
						$this->afficherPoint($this->correspondance_champs[$key] , $valeur, $taxon['code_langue'], $taxon['num_nom_vernaculaire']);
766 
					} elseif (in_array($key, $champs) != false) {
767 
						$this->table_retour[$key] = $valeur;
768 
					}
769 
				}
770 
				if (in_array('biblio', $champs) != false) $this->chargerBiblio($taxon['num_nom_vernaculaire'], $taxon['code_langue']);
771 
			}
772 
			if (in_array('biblio', $champs) != false && array_search('biblio.num_ref', $this->table_retour) != false) $this->table_retour['biblio'] = null;
773 
		}
774 
		return $this->table_retour;
775 
	}
109 jpm 776 
 
6 jpm 777 
	public function afficherPoint($champ, $valeur, $langue, $num_nom) {
778 
		preg_match('/^(.*)\.code$/', $champ, $match);
779 
		$champ = $match[1];
832 raphael 780 
		if (isset(self::$champ_infos[$champ])) {
781 
			extract(self::$champ_infos[$champ]);
6 jpm 782 
			$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet);
783 
			$projet .= '.';
784 
		}
109 jpm 785 
 
786 
		$champs = explode(' ', $this->ressources[1]);
6 jpm 787 
		if (in_array($champ.'.*', $champs) !== false && isset($projet)) {
788 
			$this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur;
789 
			$this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url;
109 jpm 790 
		}
6 jpm 791 
		if (in_array($champ.'.code', $champs) !== false && isset($projet)) {
792 
			$this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur;
109 jpm 793 
		}
6 jpm 794 
		if (in_array($champ.'.href', $champs) !== false && isset($projet)) {
795 
			$this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url;
109 jpm 796 
		}
6 jpm 797 
		if (in_array($champ, $champs) !== false) {
798 
			if (isset($url)) {
799 
				$this->table_retour['attributions'][$langue][$num_nom][$champ] = $this->chercherSignificationCode($url, $nom);
800 
			} else {
801 
				$this->table_retour['attributions'][$langue][$champ] = $valeur;
802 
			}
109 jpm 803 
		}
6 jpm 804 
	}
805 
 
806 
	public function afficherLangue($nomChamp, $projet, $service, $valeur, $ressource = '', $nom = 'nom') {
807 
		if ($this->retour_format == 'max') {
808 
				$this->table_retour['attributions'][$nomChamp] = $nom;
809 
				$this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur;
810 
				$this->table_retour['attributions'][$nomChamp.'.href'] = $url;
811 
		} else {
812 
			$this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur;
813 
		}
814 
	}
109 jpm 815 
 
6 jpm 816 
	public function chargerBiblio($num_nom, $langue) {
817 
		list($table, $version) = explode('_v',$this->table);
818 
		$requete = "SELECT b.*, lb.notes FROM nvjfl_lien_biblio_v$version lb, nvjfl_biblio_v$version b ".
819 
					"WHERE b.num_ref = lb.num_ref AND lb.num_nom = '$num_nom' ;";
284 jpm 820 
		$resultat = $this->getBdd()->recupererTous($requete);
109 jpm 821 
 
6 jpm 822 
		 if ($resultat == '') { //cas ou la requete comporte des erreurs
823 
		 	$r = 'La requête SQL formée comporte une erreur !!';
824 
			$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r);
825 
			Debug::printr($requete);
826 
		 } elseif ($resultat) {
827 
			foreach ($resultat as $res) {
828 
			   	foreach ($res as $cle => $valeur) {
829 
			   		if ($valeur !== "") {
830 
			   			$this->table_retour['attributions'][$langue][$num_nom]['biblio.'.$cle] = $valeur;
831 
			   		}
832 
			    }
833 
			}
834 
		}
835 
	}
109 jpm 836 
 
6 jpm 837 
}
838 
?>