Subversion Repositories eFlore/Projets.eflore-projets

Rev

Rev 1109 | Details | Compare with Previous | Last modification | View Log | RSS feed

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