Subversion Repositories eFlore/Applications.del

Rev

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

Rev Author Line No. Line
700 gduche 1
<?php
2
/**
3
* Classe Commun.php est une classe abstraite qui contient les méthodes de base communes à tous les
4
* sous-services des projets.
5
*
6
* Encodage en entrée : utf8
7
* Encodage en sortie : utf8
8
* @package eflore-projets
9
* @author Jennifer DHÉ <jennifer.dhe@tela-botanica.org>
10
* @author Delphine CAUQUIL <delphine@tela-botanica.org>
11
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
12
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
13
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
14
* @version 1.0
15
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org)
16
*/
17
 
18
abstract class Commun {
19
 
20
	/** Objet Bdd. */
21
	private $Bdd = null;
22
	/** Objet Rest Client. */
23
	private $RestClient = null;
24
 
25
	/** Contients les paramètres. Doit remplacer table_param. */
26
	protected $parametres = array();
27
	/** Contients les ressources. Doit remplacer table_ressources. */
28
	protected $ressources = array();
29
	/** Le nom du service courrant. */
30
	protected $serviceNom = null;
31
 
32
	//Classe commune à tous les services web d'un projet. Contient par exemple les fonctions permettant de
33
	//renvoyer la réponse http...
34
	protected $entete_http; // Entete de la réponse correspondant au code de réponse de la requete http */
35
	protected $corps_http; // Tableau de résultat à retourner au format json ou la description de l'erreur si elle existe */
36
	protected $service; // Nom du service appelé
37
	/** Stocke la version du projet demandée dans la requete
38
	 *  - "*" : (/#projet/* /meta-donnees) Renvoi les meta-données de toutes les versions du projet
39
	 *  - "numero de la version" : (/#projet/2.00/meta-donnees) Renvoi les meta-données de la version 2.00 du projet */
40
	protected $version_projet = '+';
41
	protected $table_version; //Stocke les noms des tables de toutes les versions du projet disponibles
42
	/** tableau contenant tous les champs d'une table (est rempli par la fonction Commun::recupererNomChamp($table)) */
43
	protected $champs_table = array();
44
	private static $tri_multi_dimension = array();
45
	private static $tri_type = '';
46
 
47
	public function consulter($ressources, $parametres) {
48
		$this->ressources = $ressources;
49
		$this->parametres = $parametres;
50
		$this->chargerNomDuService();
51
 
52
		$this->traiterParametres();
53
		$this->traiterVersionProjet();
54
 
55
		$resultats = '';
56
		foreach ($this->table_version as $version) {
57
			$this->table = $version; //on stocke le nom de la table correspondant à la version du projet en cours
58
			$this->recupererNomChamp($this->table); //on récupère les noms des champs disponibles (Ds Commun.php)
59
			$this->traiterRessources(); //dans CommunNomsTaxons.php
60
			$requete = $this->assemblerLaRequete();
61
			$resultat = $this->getBdd()->recupererTous($requete);
62
			$versionResultat = $this->traiterResultat($resultat, $version, $requete);
63
			if (count($this->table_version) > 1) {
64
				$resultats[$version] = $versionResultat;
65
			} else {
66
				$resultats = $versionResultat;
67
			}
68
		}
69
 
70
		return $resultats;
71
	}
72
 
73
	private function chargerNomDuService() {
74
		$this->serviceNom = get_class($this);
75
	}
76
 
77
	public function traiterResultat($resultat, $version, $requete) {
78
		$versionResultat = null;
79
		if ($resultat == '') {
80
			//cas ou la requete comporte des erreurs
81
			$message = 'La requête SQL formée comporte une erreur!';
82
			$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
83
			throw new Exception($message, $code);
84
		} elseif ($resultat) {
85
			$versionResultat = $this->retournerResultatFormate($resultat, $version);
86
		} else {
87
			$message = 'Les données recherchées sont introuvables.';
88
			$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
89
			throw new Exception($message, $code);
90
		}
91
		return $versionResultat;
92
	}
93
 
94
	//+------------------------------------------------------------------------------------------------------+
95
	// Méthodes concernant les paramètres
96
	/**
97
	 *  Permet de récupérer une liste des noms des champs de la table passée en paramètre
98
	 *  @param $table : Nom de la table dont on souhaite connaitre les champs
99
	 */
100
	public function recupererNomChamp($table) {
101
		$requete = 'SHOW FIELDS FROM '.$table;
102
 
103
		$resultat = $this->getBdd()->recupererTous($requete);
104
		if ($resultat == '') {
105
			$e = 'La requête SQL formée comporte une erreur!';
106
			$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
107
		} elseif ($resultat) {
108
			foreach ($resultat as $info) {
109
				$this->champs_table[] = $info['Field'];
110
			}
111
		} else {
112
			$m = "La table recherchée n'existe pas";
113
			$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $m);
114
		}
115
	}
116
 
117
	/**
118
	 * Fonction permettant de creer la table dont le nom est passé en paramètre (champs_api, champs_bdtfx,
119
	 * correspondance_champs...). Les données de chaque table sont présentes dans le fichier de configuration config.ini
120
	 * @param String $table : Peut contenir plusieurs nom de table dont on souhaite récupérer les données : table,table,table.
121
	 * 	Ex : recupererTableConfig('champs_api,champs_bdtfx')
122
	 */
123
	public function recupererTableConfig($table) {
124
		$tables = explode(',', $table);
125
		foreach ($tables as $tab) {
126
			$tableau = explode(',', Config::get($tab));
127
			$tableau = array_map('trim', $tableau);
128
			foreach ($tableau as $champ) {
129
				list($code, $rang) = explode('=', $champ);
130
				$tab_tampon[$code] = $rang;
131
			}
132
			$this->$tab = $tab_tampon;
133
			$tab_tampon = array();
134
		}
135
	}
136
 
137
	public function renvoyerErreur($entete, $message) {
138
		throw new Exception($message, $entete);
139
	}
140
 
141
	/**
142
	 * Permet de remplir la variable version_projet et de retirer cette donnée du tableau des ressources
143
	 * @param $ressources
144
	 */
145
	public function traiterVersionProjet() {
146
		if (isset($this->parametres['version.projet'])) {
147
			if (preg_match('/^[0-9]+(?:[._][0-9]+|)$/', $this->parametres['version.projet'])) {
148
				$this->version_projet = $this->parametres['version.projet'];
149
				$this->version_projet = 'v'.str_replace('.', '_', $this->version_projet);
150
			} else  {
151
				$this->version_projet = $this->parametres['version.projet'];
152
			}
153
		}
154
		//si la liste des noms est demandée pr toutes les versions, on affiche seulement la dernière version :
155
		if ($this->version_projet == '*' && $this->ressources == array()) {
156
			$message = "L'affichage de plusieurs versions ne fonctionne que pour les ressources de type /ressources/#id";
157
			$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
158
			throw new Exception($message, $code);
159
		}
160
		//on recupère les versions du projet disponible dans la table des meta-donnees (utilisation service MetaDonnees)
161
		$table_num_version = $this->recupererVersionDisponible();
162
		//on recupere la liste des noms des tables de la bdd correspondant aux differentes versions du projet en fct de la ou les versions demandées
163
		$this->recupererListeNomTablePrChaqueVersion($table_num_version);
164
	}
165
 
166
	/**
167
	 * Recupération des versions disponibles par appel du service metaDonnees
168
	 * Verification de l'existance du service recherché dans la requete (si précisé : hors *)
169
	 * @return array  : tableau contenant le numéro de chaque version disponible
170
	 */
171
	public function recupererVersionDisponible() {
172
		$versions_dispo = '';
173
		$req_version = 'SELECT version FROM '.Config::get('bdd_table_meta');
174
		$res_version = $this->getBdd()->recupererTous($req_version);
175
		if ($res_version == '') { //cas ou la requete comporte des erreurs
176
			$e = "La requête SQL de versionnage formée comporte une erreur : $req_version";
177
			$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
178
		} elseif ($res_version) {
179
			foreach ($res_version as $version) {
180
				$versions_dispo[] = $version['version'];
181
			}
182
		} else {
183
			$m = 'Versions introuvables dans la table des méta-données';
184
			$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $m);
185
		}
186
		return $versions_dispo;
187
	}
188
 
189
	public function recupererListeNomTablePrChaqueVersion($table_num_version) {
190
		switch ($this->serviceNom) {
191
			case 'Ontologies' :
192
				$prefixe_table = 'bdd_table_ontologies';
193
				break;
194
			default:
195
				$prefixe_table = 'bdd_table';
196
		}
197
		switch ($this->version_projet) {
198
			case '+' :
199
				$derniere_version = $table_num_version[count($table_num_version) - 1];
200
				$this->table_version[] = Config::get($prefixe_table).'_v'.str_replace('.', '_', $derniere_version);
201
				break;
202
			case '*' :
203
				foreach ($table_num_version as $num_version) {
204
					$this->table_version[] = Config::get($prefixe_table).'_v'.str_replace('.', '_', $num_version);
205
				}
206
				break;
207
			default  :
208
				$this->table_version[] = Config::get($prefixe_table).'_'.$this->version_projet;
209
				break;
210
		}
211
	}
212
 
213
	/**
214
	 * Est appelée pour former l'url complete des resultats precedants ou suivants.
215
	 * @param int : Permet de connaitre le nombre de noms obtenus par la requete
216
	 * @return string Retourne l'url complete des resultats precedents ou suivant sous la forme d'un tableau
217
	 */
218
	public function formulerUrl($nb_resultat, $id = null) {
219
		$url = array();
220
		$debut_url = Config::get('url_service').$id.'?';
221
		//on recré l'url sans les parametres de navigation qui seront rajouter ci-apres. On les enlève dc de la table des parametres
222
		foreach($this->parametres as $cle => $val) {
223
			$param_url[str_replace('_', '.', $cle)] = $val;
224
		}
225
 
226
		$this->recupererLesLimitesSuivantes($nb_resultat, $param_url);
227
		if (isset($param_url['navigation.depart']) && isset($param_url['navigation.limite'])) {
228
			$url['suivant'] = $debut_url.http_build_query($param_url);
229
		}
230
 
231
		$this->recupererLesLimitesPrecedentes($param_url);
232
		if (isset($param_url['navigation.depart']) && isset($param_url['navigation.limite'])) {
233
			$url['precedent'] = $debut_url.http_build_query($param_url);
234
		}
235
		return $url;
236
	}
237
 
238
	public function supprimerNavigation(&$param_url) {
239
		unset($param_url['navigation.depart']);
240
		unset($param_url['navigation.limite']);
241
	}
242
 
243
	/**
244
	 * Description :
245
	 * Permet de former les limites de la requete retournant les résultats suivants.
246
	 * Cette url sera afficher dans l'entete de la reponse retournée en format JSON (retour.format=defaut).
247
	 * @param int : $nb_resultat : Permet de connaitre le nombre de résultats obtenus par la requete
248
	 * @return string : la fin de l'url decrivant les limites des resultats suivants. Si aucun résultats ne suient,
249
	 * une chaine de caractère vide est retournée
250
	 */
251
	public function recupererLesLimitesSuivantes($nb_resultat, &$param_url_suiv) {
252
		$this->supprimerNavigation($param_url);
253
		$depart = $this->limite_requete['depart'];
254
		$limite = $this->limite_requete['limite'];
255
		$depart_suivant = $depart + $limite;
256
		$limite_suivant = $limite;
257
		if ($nb_resultat > $depart_suivant) {
258
			$param_url_suiv['navigation.depart'] = $depart_suivant;
259
			$param_url_suiv['navigation.limite'] = $limite_suivant;
260
		} else {
261
			$param_url_suiv['navigation.depart'] = null;
262
			$param_url_suiv['navigation.limite'] = null;
263
		}
264
	}
265
 
266
	/**
267
	 * Description :
268
	 * Permet de former les limites de la requete retournant les résultats precedents.
269
	 * Cette url sera afficher dans l'entete de la taxons/105reponse retournée en format JSON (retour.format=defaut)
270
	 * @return string : la fin de l'url decrivant les limites des resultats precedents.
271
	 * Si aucun résultats ne precedent, une chaine de caractère vide est retournée
272
	 */
273
	public function recupererLesLimitesPrecedentes(&$param_url) {
274
		$this->supprimerNavigation($param_url);
275
		$depart = $this->limite_requete['depart'];
276
		$limite = $this->limite_requete['limite'];
277
		if ($depart == 0) {
278
			$url_precedente = '';
279
		} else {
280
			if (($depart - $limite) < 0) {
281
				$depart_precedent = 0;
282
			} else {
283
				$depart_precedent = $depart - $limite;
284
			}
285
			$param_url['navigation.depart'] = $depart_precedent;
286
			$param_url['navigation.limite'] = $limite;
287
		}
288
	}
289
 
290
	public function ajouterHref($service, $val) {
291
		// http://tela-botanica.org/service:eflore:0.1/[projet]/[version_projet]/[service]/[ressource]:[valeur]
292
		if ($this->version_projet == '+') {
293
			$url = Config::get('url_service_base').Config::get('nom_projet').'/'.$service.'/'.$val;
294
		} else {
295
			$url = Config::get('url_service_base').Config::get('nom_projet').'/'.$service.'/'.$val.'?version.projet='.ltrim($this->version_projet, 'v');
296
		}
297
		return $url;
298
	}
299
 
300
	public function ajouterHrefAutreProjet($service, $ressource, $valeur, $projet = null, $param = null) {
301
		//on enleve les GA et Co, les meta ou les "_"
302
		$this->transliterer($service, $valeur);
303
		//on définit les nom des projets, des services et des ressources de l'url (dans les méta-donnees)
304
		$tab = array(
305
			'langue' 			  => array('service' => 'langues', 'projet' => 'iso-639-1', 'ressource' => ''),
306
			'couverture_spatiale' => array('service' => 'zone-geo', 'projet' => 'iso-3166-1', 'ressource' => ''),
307
			'type' 				  => array('service' => 'ontologies', 'projet' => 'eflore', 'ressource' => 'contactType:'),
308
			'datum' 			  => array('service' => 'ontologies', 'projet' => 'eflore', 'ressource' => 'datum:')
309
		);
310
		if (array_key_exists($service, $tab)) {
311
			extract($tab[$service]);
312
		} else {
313
			if (strpos(Config::get('nom_projet'), 'bd') === 0 && $projet == null) {
314
				$projet 		= 'bdnt';
315
				$service 		= 'ontologies';
316
				$ressource 		= '';
317
			}
318
		}
319
		$param = ($param) ? "?".$param : "";
320
		$url = Config::get('url_service_base').$projet.'/'.$service.'/'.$ressource.$valeur.$param;
321
		return $url;
322
	}
323
 
324
	/**Permet de consulter une url et retourne le résultat ou une erreur
325
	 * @param $url	 */
326
	public function consulterHref($url) {
327
		$res = $this->getRestClient()->consulter($url);
328
		$entete = $this->getRestClient()->getReponseEntetes();
329
		//Si le service meta-donnees fonctionne correctement, l'entete comprend la clé wrapper_data
330
		if (isset($entete['wrapper_data'])) {
331
			$res = json_decode($res);
332
			return $res;
333
		} else {
334
			$u = 'L\'url <a href="'.$url.'">'.$url.'</a> lancée via RestClient renvoie une erreur';
335
			$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $u);
336
		}
337
	}
338
 
339
	public function transliterer(&$service, &$val) {
340
		if (preg_match('/^.+:(.+)$/', $val, $match)) {
341
			$val = $match[1];
342
		}
343
		$service = str_replace(array('_Ga','_Co','_meta'), '', $service);
344
		if ($service == 'rang') {
345
			$ressource = 'rangTaxo';
346
		} elseif (preg_match('/^(statut)(?:_|-)([^_-]+)$/', $service, $match)) {
347
			$service = $match[1].ucfirst($match[2]);
348
		} elseif (strrpos($service, 'datum') !== false) {
349
			$service = 'datum';
350
		}
351
	}
352
 
353
	// prend en valeur la valeur de la recherche, les résultats approchés, le paramétre recherche
354
	// retourne le tableau trié en fonction de la ressemble entre le résultat approché et la valeur recherchée
355
	public function trierRechercheFloue($nom_demande, $tab_approchee, $nom) {
356
		$trie = '';
357
		$resultat = array();
358
		foreach ($tab_approchee as $id => $tab) {
359
			$nom_demande_ss = strtolower(Chaine::supprimerAccents($nom_demande));
360
			$nom_flou_ss = strtolower(Chaine::supprimerAccents($tab[$nom]));
361
			$stat = array();
362
			// Prime pour la ressemblance globale :
363
			$score = 500 - levenshtein($nom_flou_ss, $nom_demande_ss);
364
			// On affine
365
			$score = $score + (similar_text($nom_demande_ss, $nom_flou_ss) * 3);
366
			$stat['score'] = $score;
367
			foreach ($tab as $key => $valeur) {
368
				$stat[$key] = $valeur;
369
			}
370
			$resultat[] = $stat;
371
		}
372
 
373
 
374
		// Vérification que nous avons bien trouvé un nom approché
375
		if (count($resultat) > 0) {
376
			$trie = Tableau::trierMD($resultat, array('score' => SORT_DESC));
377
		}
378
		return $trie;
379
	}
380
 
381
	protected function recupererTableauConfig($param) {
382
		$tableau = array();
383
		$tableauPartiel = explode(',', Config::get($param));
384
		$tableauPartiel = array_map('trim', $tableauPartiel);
385
		foreach ($tableauPartiel as $champ) {
386
			if (strpos($champ, '=') === false) {
387
				$tableau[] = $champ;
388
			} else {
389
				list($cle, $val) = explode('=', $champ);
390
				$tableau[$cle] = $val;
391
			}
392
		}
393
		return $tableau;
394
	}
395
 
396
	//+------------------------------------------------------------------------------------------------------+
397
	// Méthodes d'accès aux objets du Framework
398
	/**
399
	 * Méthode de connection à la base de données sur demande.
400
	 * Tous les services web n'ont pas besoin de s'y connecter.
401
	 */
402
	protected function getBdd() {
403
		if (! isset($this->Bdd)) {
404
			$this->Bdd = new Bdd();
405
		}
406
		return $this->Bdd;
407
	}
408
 
409
	/**
410
	 * Méthode permettant de faire appel à un client REST en fonction des besoins du service.
411
	 */
412
	protected function getRestClient() {
413
		if (! isset($this->RestClient)) {
414
			$this->RestClient = new RestClient();
415
		}
416
		return $this->RestClient;
417
	}
418
}
419
?>