/trunk/services/tests/prepare.php |
---|
New file |
0,0 → 1,48 |
<?php |
/** |
* La méthode __autoload() charge dynamiquement les classes trouvées dans le code. |
* Cette fonction est appelée par php5 quand il trouve une instanciation de classe dans le code. |
* |
*@param string le nom de la classe appelée. |
*@return void le fichier contenant la classe doit être inclu par la fonction. |
*/ |
function chargerClasse($classe) { |
if (class_exists($classe)) { |
return null; |
} |
$chemins = array(realpath(__DIR__.'/../modules/0.1').'/'); |
foreach ($chemins as $chemin) { |
$chemin = $chemin.$classe.'.php'; |
if (file_exists($chemin)) { |
require_once $chemin; |
} |
} |
} |
spl_autoload_register('chargerClasse'); |
// Le fichier autoload.inc.php du Framework de Tela Botanica doit être appelée avant tout autre chose dans l'application. |
// Sinon, rien ne sera chargé. |
// Chemin du fichier chargeant le framework requis |
$framework = dirname(__FILE__).DIRECTORY_SEPARATOR.'..'.DIRECTORY_SEPARATOR.'framework.php'; |
if (!file_exists($framework)) { |
$e = "Veuillez paramétrer l'emplacement et la version du Framework dans le fichier $framework"; |
trigger_error($e, E_USER_ERROR); |
} else { |
// Inclusion du Framework |
require_once $framework; |
// Ajout d'information concernant cette application |
Framework::setCheminAppli(realpath($framework));// Obligatoire |
Framework::setInfoAppli(Config::get('info')); |
} |
/* |
* Local Variables: |
* mode: php |
* coding: utf-8 |
* tab-width: 4 |
* c-basic-offset: 4 |
* c-hanging-comment-ender-p: nil |
* indent-tabs-mode: nil |
* End: |
*/ |
?> |
/trunk/services/tests/BdtfxNomsTest.php |
---|
New file |
0,0 → 1,260 |
<?php |
class BdtfxNomsTest extends PHPUnit_Framework_TestCase { |
public function testVersionPrecise() { |
$ressources = array('v1.01'); |
$parametres = array(); |
$url = $this->creerUrl($ressources, $parametres); |
$retour = $this->consulterJson($ressources, $parametres); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url"); |
} |
public function testNomsIdVersionMultiple() { |
$ressources = array('*', '182'); |
$parametres = array(); |
$url = $this->creerUrl($ressources, $parametres); |
$retour = $this->consulterJson($ressources, $parametres); |
$this->assertArrayHasKey('bdtfx_v1_01', $retour, "Le json ne contient pas d'attribut : bdtfx_v1_01.\nVoir : $url"); |
$this->assertArrayHasKey('bdtfx_v1_02', $retour, "Le json ne contient pas d'attribut : bdtfx_v1_02.\nVoir : $url"); |
$this->assertEquals('182', $retour['bdtfx_v1_01']['id'], "'bdtfx_v1_01' doit contenir un attribut 'id' avec la valeur '182'"); |
$this->assertEquals('182', $retour['bdtfx_v1_02']['id'], "'bdtfx_v1_02' doit contenir un attribut 'id' avec la valeur '182'"); |
} |
public function testNomsVersionMultiple() { |
$ressources = array('*'); |
$parametres = array(); |
$url = $this->creerUrl($ressources, $parametres); |
$retour = $this->consulterBrut($ressources, $parametres); |
$attendu = "L'affichage de plusieurs versions ne fonctionne que pour les ressources de type /ressources/#id"; |
$message = "L'url :\n'$url'\n doit retourner un résultat de la forme :\n $attendu"; |
$this->assertEquals($attendu, $retour, $message); |
} |
public function testVersionInexistante() { |
$ressources = array('v99.00'); |
$parametres = array(); |
$url = $this->creerUrl($ressources, $parametres); |
$retour = $this->consulterBrut($ressources, $parametres); |
$attendu = 'La requête SQL formée comporte une erreur!'; |
$message = "L'url :\n'$url'\n doit retourner un résultat de la forme :\n $attendu"; |
$this->assertEquals($attendu, $retour, $message); |
} |
public function testRechercheStricte() { |
$ressources = array('v1.01'); |
$parametres = array( |
'recherche' => 'stricte', |
'masque' => 'Acer'); |
$url = $this->creerUrl($ressources, $parametres); |
$retour = $this->consulterJson($ressources, $parametres); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url"); |
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' de l'entête devrait valoir 1. Voir : $url"); |
$this->assertEquals(1, count($retour['resultat']), "Le résultat devrait contenir une seule donnée. Voir : $url"); |
} |
/* |
public function testResultatChamps() { |
$ressources = array('v1.01'); |
$parametres = array( |
'recherche' => 'stricte', |
'masque.nn' => '182'); |
$url = $this->creerUrl($ressources, $parametres); |
$noms = new Noms(array()); |
$retourJson = $noms->consulter($ressources, $parametres); |
$retour = json_decode($retourJson, true); |
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url"); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url"); |
$this->assertEquals(1, count($retour['resultat']), "Le résultat devrait contenir une seule donnée. Voir : $url"); |
$this->assertArrayHasKey('id', $retour['resultat']['182'], "Le tableau du résultat 182 doit contenir un champ 'id'. Voir : $url"); |
$this->assertEquals('182', $retour['resultat']['182']['id'], "Le tableau du résultat 182 doit contenir un champ 'id' avec pour valeur '182'. Voir : $url"); |
$this->assertArrayHasKey('retenu', $retour['resultat']['182'], "Le tableau du résultat 182 doit contenir un champ 'id'. Voir : $url"); |
$this->assertEquals('true', $retour['resultat']['182']['retenu'], "Le tableau du résultat 182 doit contenir un champ 'retenu' avec pour valeur 'true'. Voir : $url"); |
$this->assertArrayHasKey('nom_sci', $retour['resultat']['182'], "Le tableau du résultat 182 doit contenir un champ 'nom_sci'. Voir : $url"); |
$this->assertEquals('Acer monspessulanum', $retour['resultat']['182']['nom_sci'], "Le tableau du résultat 182 doit contenir un champ 'nom_sci' avec pour valeur 'Acer monspessulanum'. Voir : $url"); |
} |
public function testMasqueSg() { |
$ressources = array('v1.01'); |
$parametres = array( |
'recherche' => 'stricte', |
'masque.sg' => 'Asteraceae'); |
$url = $this->creerUrl($ressources, $parametres); |
$noms = new Noms(array()); |
$retourJson = $noms->consulter($ressources, $parametres); |
$retour = json_decode($retourJson, true); |
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url"); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$this->assertEquals('nom_supra_generique=Asteraceae', $retour['entete']['masque'], "L'attribut 'masque' de l'entête devrait valoir 'nom_supra_generique=Asteraceae'. Voir : $url"); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url"); |
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' de l'entête devrait valoir 1. Voir : $url"); |
$this->assertEquals(1, count($retour['resultat']), "Le résultat devrait contenir une seule donnée. Voir : $url"); |
} |
public function testMasqueGenSpSspAuAn() { |
$ressources = array('v1.01'); |
$parametres = array( |
'recherche' => 'stricte', |
'masque.gen' => 'Allium', |
'masque.sp' => 'carinatum', |
'masque.ssp' => 'consimile', |
'masque.au' => 'Gren.', |
'masque.an' => '1855'); |
$url = $this->creerUrl($ressources, $parametres); |
$noms = new Noms(array()); |
$retourJson = $noms->consulter($ressources, $parametres); |
$retour = json_decode($retourJson, true); |
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url"); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$masque = 'genre=Allium&epithete_sp=carinatum&epithete_infra_sp=consimile&auteur=Gren.&annee=1855'; |
$message = "L'attribut 'masque' de l'entête devrait valoir '$masque'. Voir : $url"; |
$this->assertEquals($masque, $retour['entete']['masque'], $message); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url"); |
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' de l'entête devrait valoir 1. Voir : $url"); |
$this->assertEquals(1, count($retour['resultat']), "Le résultat devrait contenir une seule donnée. Voir : $url"); |
} |
public function testMasqueNn() { |
$ressources = array('v1.01'); |
$parametres = array( |
'recherche' => 'stricte', |
'masque.nn' => '182'); |
$url = $this->creerUrl($ressources, $parametres); |
$noms = new Noms(array()); |
$retourJson = $noms->consulter($ressources, $parametres); |
$retour = json_decode($retourJson, true); |
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url"); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$masque = 'num_nom=182'; |
$message = "L'attribut 'masque' de l'entête devrait valoir '$masque'. Voir : $url"; |
$this->assertEquals($masque, $retour['entete']['masque'], $message); |
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' de l'entête devrait valoir 1. Voir : $url"); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url"); |
$this->assertEquals(1, count($retour['resultat']), "Le résultat devrait contenir une seule donnée. Voir : $url"); |
$this->assertArrayHasKey('id', $retour['resultat']['182'], "Le tableau du résultat 182 doit contenir un champ 'id'. Voir : $url"); |
$this->assertEquals('182', $retour['resultat']['182']['id'], "Le tableau du résultat 182 doit contenir un champ 'id' avec pour valeur '182'. Voir : $url"); |
} |
public function testMasqueRg() { |
$ressources = array('v1.01'); |
$parametres = array( |
'recherche' => 'stricte', |
'masque.rg' => '180'); |
$url = $this->creerUrl($ressources, $parametres); |
$noms = new Noms(array()); |
$retourJson = $noms->consulter($ressources, $parametres); |
$retour = json_decode($retourJson, true); |
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url"); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$masque = 'rang=180'; |
$message = "L'attribut 'masque' de l'entête devrait valoir '$masque'. Voir : $url"; |
$this->assertEquals($masque, $retour['entete']['masque'], $message); |
$this->assertEquals('210', $retour['entete']['total'], "L'attribut 'total' de l'entête devrait valoir 210. Voir : $url"); |
} |
public function testNsStructureTxt() { |
$ressources = array('v1.01'); |
$parametres = array( |
'recherche' => 'stricte', |
'masque.nn' => '182', |
'ns.format' => 'txt', |
'ns.structure' => 'au,an,bib,ad'); |
$url = $this->creerUrl($ressources, $parametres); |
$noms = new Noms(array()); |
$retourJson = $noms->consulter($ressources, $parametres); |
$retour = json_decode($retourJson, true); |
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url"); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$masque = 'num_nom=182'; |
$message = "L'attribut 'masque' de l'entête devrait valoir '$masque'. Voir : $url"; |
$this->assertEquals($masque, $retour['entete']['masque'], $message); |
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' de l'entête devrait valoir 1. Voir : $url"); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url"); |
$this->assertEquals('Acer monspessulanum L. [1753, Sp. Pl., éd. 1 : 1056]', $retour['resultat']['182']['nom_sci'], "Le tableau du résultat 182 doit contenir un champ 'nom_sci' avec pour valeur 'Acer monspessulanum'. Voir : $url"); |
} |
public function testNsStructureHtml() { |
$ressources = array('v1.01'); |
$parametres = array( |
'recherche' => 'stricte', |
'masque.nn' => '182', |
'ns.format' => 'htm', |
'ns.structure' => 'au,an,bib,ad'); |
$url = $this->creerUrl($ressources, $parametres); |
$noms = new Noms(array()); |
$retourJson = $noms->consulter($ressources, $parametres); |
$retour = json_decode($retourJson, true); |
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url"); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$masque = 'num_nom=182'; |
$message = "L'attribut 'masque' de l'entête devrait valoir '$masque'. Voir : $url"; |
$this->assertEquals($masque, $retour['entete']['masque'], $message); |
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' de l'entête devrait valoir 1. Voir : $url"); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat.\nVoir : $url"); |
$attendu = '<span class=sci><span class="gen">Acer</span> <span class="sp">monspessulanum</span></span> <span class="auteur">L.</span> [<span class="annee">1753</span>, <span class="biblio">Sp. Pl., éd. 1 : 1056</span>]'; |
$message = "Le tableau du résultat 182 doit contenir un champ 'nom_sci' avec pour valeur '$attendu'. Voir : $url"; |
$this->assertEquals($attendu, $retour['resultat']['182']['nom_sci'], $message); |
} |
*/ |
//+------------------------------------------------------------------------------------------------------+ |
// Refactorisation |
private function consulterJson($ressources, $parametres) { |
$retourJson = $this->consulterBrut($ressources, $parametres); |
$retour = json_decode($retourJson, true); |
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url"); |
return $retour; |
} |
private function consulterBrut($ressources, $parametres) { |
array_unshift($ressources, 'noms'); |
array_unshift($ressources, 'bdtfx'); |
$projets = new Projets(); |
$retourJson = $projets->consulter($ressources, $parametres); |
return $retourJson; |
} |
private function creerUrl($ressources, $parametres) { |
$version = ''; |
$ressourcesUrl = array(); |
foreach ($ressources as $ressource) { |
if (preg_match('/^(v[0-9]+\.[0-9]+|[*+])$/', $ressource)) { |
$version = $ressource.'/'; |
} else { |
$ressourcesUrl[] = $ressource; |
} |
} |
$ressourcesUrl = count($ressourcesUrl) > 0 ? '/'.implode('/', $ressourcesUrl) : ''; |
$parametresUrl = ''; |
if (count($parametres) > 0) { |
foreach ($parametres as $cle => $valeur) { |
$parametresUrl[] = $cle.'='.rawurlencode($valeur); |
} |
$parametresUrl = '?'.implode('&', $parametresUrl); |
} |
$url = Config::get('url_service').'/'.$version.'noms'.$ressourcesUrl.$parametresUrl; |
return $url; |
} |
} |
?> |
/trunk/services/tests/BdtfxTaxonsTest.php |
---|
New file |
0,0 → 1,140 |
<?php |
class BdtfxTaxonsTest extends PHPUnit_Framework_TestCase { |
public function testVersionPrecise() { |
$ressources = array('v1.01'); |
$parametres = array(); |
$url = $this->creerUrl($ressources, $parametres); |
$retour = $this->consulterJson($ressources, $parametres); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url"); |
} |
public function testNomsIdVersionMultiple() { |
$ressources = array('*', '182'); |
$parametres = array(); |
$url = $this->creerUrl($ressources, $parametres); |
$retour = $this->consulterJson($ressources, $parametres); |
$this->assertArrayHasKey('bdtfx_v1_01', $retour, "Le json ne contient pas d'attribut : bdtfx_v1_01.\nVoir : $url"); |
$this->assertArrayHasKey('bdtfx_v1_02', $retour, "Le json ne contient pas d'attribut : bdtfx_v1_02.\nVoir : $url"); |
$this->assertEquals('182', $retour['bdtfx_v1_01']['id'], "'bdtfx_v1_01' doit contenir un attribut 'id' avec la valeur '182'"); |
$this->assertEquals('182', $retour['bdtfx_v1_02']['id'], "'bdtfx_v1_02' doit contenir un attribut 'id' avec la valeur '182'"); |
} |
public function testNomsVersionMultiple() { |
$ressources = array('*'); |
$parametres = array(); |
$url = $this->creerUrl($ressources, $parametres); |
$retour = $this->consulterBrut($ressources, $parametres); |
$attendu = "L'affichage de plusieurs versions ne fonctionne que pour les ressources de type /ressources/#id"; |
$message = "L'url :\n'$url'\n doit retourner un résultat de la forme :\n $attendu"; |
$this->assertEquals($attendu, $retour, $message); |
} |
public function testVersionInexistante() { |
$ressources = array('v99.00'); |
$parametres = array(); |
$url = $this->creerUrl($ressources, $parametres); |
$retour = $this->consulterBrut($ressources, $parametres); |
$attendu = 'La requête SQL formée comporte une erreur!'; |
$message = "L'url :\n'$url'\n doit retourner un résultat de la forme :\n $attendu"; |
$this->assertEquals($attendu, $retour, $message); |
} |
public function testRechercheStricte() { |
$ressources = array('v1.01'); |
$parametres = array( |
'recherche' => 'stricte', |
'masque' => 'Acer'); |
$url = $this->creerUrl($ressources, $parametres); |
$retour = $this->consulterJson($ressources, $parametres); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url"); |
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' de l'entête devrait valoir 1. Voir : $url"); |
$this->assertEquals(1, count($retour['resultat']), "Le résultat devrait contenir une seule donnée. Voir : $url"); |
} |
/* |
public function testRechercheEtendue() { |
$url = Config::get('url_service').'/v1.01/taxons?recherche=etendue&masque=Acer'; |
$ressources = array('v1.01'); |
$parametres = array( |
'recherche' => 'etendue', |
'masque' => 'Acer'); |
$taxons = new Taxons(array()); |
$retourJson = $taxons->consulter($ressources, $parametres); |
$retour = json_decode($retourJson, true); |
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url"); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url"); |
$this->assertEquals('50', $retour['entete']['total'], "L'attribut total de l'entête devrait valoir 50. Voir : $url"); |
$this->assertEquals(50, count($retour['resultat']), "Le résultat devrait contenir 50 données. Voir : $url"); |
} |
public function testRechercheFloue() { |
$url = Config::get('url_service').'/v1.01/taxons?recherche=floue&masque=Acer'; |
$ressources = array('v1.01'); |
$parametres = array( |
'recherche' => 'floue', |
'masque' => 'Acer'); |
$taxons = new Taxons(array()); |
$retourJson = $taxons->consulter($ressources, $parametres); |
$retour = json_decode($retourJson, true); |
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url"); |
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url"); |
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url"); |
$this->assertEquals('4', $retour['entete']['total'], "L'attribut total de l'entête devrait valoir 4. Voir : $url"); |
$this->assertEquals(4, count($retour['resultat']), "Le résultat devrait contenir 4 données. Voir : $url"); |
} |
*/ |
//+------------------------------------------------------------------------------------------------------+ |
// Refactorisation |
private function consulterJson($ressources, $parametres) { |
$retourJson = $this->consulterBrut($ressources, $parametres); |
$retour = json_decode($retourJson, true); |
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url"); |
return $retour; |
} |
private function consulterBrut($ressources, $parametres) { |
array_unshift($ressources, 'taxons'); |
array_unshift($ressources, 'bdtfx'); |
$projets = new Projets(); |
$retourJson = $projets->consulter($ressources, $parametres); |
return $retourJson; |
} |
private function creerUrl($ressources, $parametres) { |
$version = ''; |
$ressourcesUrl = array(); |
foreach ($ressources as $ressource) { |
if (preg_match('/^(v[0-9]+\.[0-9]+|[*+])$/', $ressource)) { |
$version = $ressource.'/'; |
} else { |
$ressourcesUrl[] = $ressource; |
} |
} |
$ressourcesUrl = count($ressourcesUrl) > 0 ? '/'.implode('/', $ressourcesUrl) : ''; |
$parametresUrl = ''; |
if (count($parametres) > 0) { |
foreach ($parametres as $cle => $valeur) { |
$parametresUrl[] = $cle.'='.rawurlencode($valeur); |
} |
$parametresUrl = '?'.implode('&', $parametresUrl); |
} |
$url = Config::get('url_service').'/'.$version.'noms'.$ressourcesUrl.$parametresUrl; |
return $url; |
} |
} |
?> |
/trunk/services/modules/0.1/bdtfx/Noms.php |
---|
New file |
0,0 → 1,533 |
<?php |
// declare(encoding='UTF-8'); |
/** |
* Classe permettant de fournir des informations sur les noms scientifiques. |
* Si l'url finit par /noms on retourne une liste de noms latin et leurs identifiants (seulement les 100 premeiers noms par défaut). |
* L'url peut contenir des paramètres optionnels passés après le ? : /noms?param1=val1¶m2=val2&... |
* |
* Les paramètres de requête disponibles sont : masque, masque.gen (nom de genre), masque.sp (épithète d'espèce), masque.ssp (épithète infra-spécifique), |
* masque.au (auteur du nom), masque.an (année de publication du nom), masque.bib (réf biblio de la publi d'origine du nom), masque.ad (nomen addendum), |
* masque.nn (identifiant du nom), recherche, rang, distinct, retour.format, nl.format, nl.structure, navigation.depart et navigation.limite. |
* Les différentes requetes : |
* - noms | noms/relations/#projet/#id_projet | noms/#id | noms/#id/#champ+#champ |
* - noms/#id/relations | noms/#id/relations/synonymie | noms/#id/relations/homonymie | noms/#id/relations/flores |
* - noms/stats/rangs | noms/stats/annees | noms/stats/initiales |
* |
* @package bdtfx |
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org> |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version $Id$ |
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Noms |
*/ |
class Noms extends CommunNomsTaxons { |
protected $format_reponse = 'noms'; // Permet de stocker la requete formulée |
protected $service = 'noms'; |
protected $requete_champ = 'num_nom, nom_sci, num_nom_retenu'; |
protected $requete_condition = null; |
protected $requete_group_by = ''; |
/** Permet de stocker les limite de la requete SQL (par défaut seul les 100 premiers résultats seront retournés).*/ |
protected $limite_requete = array('depart' => 0, 'limite' => 100); |
protected $distinct = null; // Valeur du paramètre de requete distinct (=0|1) |
public function consulter($ressources, $parametres) { |
return parent::consulter($ressources, $parametres); |
} |
//+----------------FONCTION D'ANALYSE DES PARAMETRES---------------------------------------------------------+ |
public function traiterParametresSpecifiques() { |
foreach ($this->parametres as $param => $val) { |
switch ($param) { |
case 'masque' : |
$this->ajouterFiltreMasque('nom_sci', $val); |
break; |
case 'masque.sg' : |
$this->ajouterFiltreMasque('nom_supra_generique', $val); |
break; |
case 'masque.gen' : |
$this->ajouterFiltreMasque('genre', $val); |
break; |
case 'masque.sp' : |
$this->ajouterFiltreMasque('epithete_sp', $val); |
break; |
case 'masque.ssp' : |
$this->ajouterFiltreMasque('epithete_infra_sp',$val); |
break; |
case 'masque.au' : |
$this->ajouterFiltreMasque('auteur', $val); |
break; |
case 'masque.an' : |
$this->ajouterFiltreMasque('annee', $val); |
break; |
case 'masque.bib' : |
$this->ajouterFiltreMasque('biblio_origine',$val); |
break; |
case 'masque.ad' : |
$this->ajouterFiltreMasque('nom_addendum', $val); |
break; |
case 'masque.nn' : |
$this->requete_condition []= 'num_nom IN ('.$val.')'; |
$this->masque['num_nom'] = "num_nom=$val"; |
break; |
case 'masque.rg' : |
$this->ajouterFiltreMasque('rang', $val); |
break; |
case 'retour.champs' : |
$this->verifierParamChamps($param, $val); |
break; |
case 'distinct' : |
$this->distinct = $val; |
break; |
} |
$this->ajouterNomDistinct(); |
} |
} |
public function verifierParamChamps($param, $val) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
$champs_demandes = explode(',', $val); |
$champs_verifies = array(); |
$champs_api = array_flip($this->champs_api); |
foreach ($champs_demandes as $champ) { |
if (array_key_exists($champ, $champs_api)) { |
$champs_verifies[] = $champs_api[$champ]; |
} |
} |
if (count($champs_verifies) > 0) { |
$this->requete_champ .= ', '.implode(',', $champs_verifies); |
} |
} |
/** Permet de rajouter à la requete sql le parametre distinct. N'est utilisé qu'avec le format oss */ |
public function ajouterNomDistinct() { |
if (isset($this->distinct)) { |
if ($this->distinct == 1 && $this->parametres['retour.format'] == 'oss') { |
if ($this->compo_nom == '') { |
$this->requete_champ = ' DISTINCT nom_sci '; |
} else { |
$this->requete_champ = ' DISTINCT nom_sci, '.implode(', ',$this->compo_nom); |
} |
} elseif ($this->distinct == 1 && $this->parametres['retour.format'] != 'oss') { |
$e = 'Erreur dans votre requête </br> L\'utilisation du paramètre distinct ne se fait que sous |
le format oss'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
} |
//-----------------FONCTION D'ANALYSE DES RESSOURCES-------------------------------------------------------------------- |
public function traiterRessourcesIdentifiant() { |
//on initialise la condition de la requete sql et le format de réponse |
$this->requete_condition = array(); //on vide la table dans le cas de plusieurs version |
$this->requete_condition[] = 'num_nom = '.$this->getBdd()->proteger($this->ressources[0]); |
$this->format_reponse = $this->service.'/id'; |
if (isset($this->ressources[1]) && !empty($this->ressources[1])) { |
// requete de type noms/#id/#champ+#champ |
if (($this->ressources[1] != 'relations')) { |
$this->requete_champ = ' *, nom_sci '; |
$this->format_reponse .= '/champ'; |
// requete de type noms/#id/relations/#relations |
} elseif ($this->ressources[1] == 'relations') { |
$this->traiterRessourceIdRelations(); |
} else { |
$e = 'Erreur dans votre requête </br> Ressources disponibles : <br/> |
<li> noms/#id/relations </li> <li> noms/#id/#champ+#champ </li> |
<li> noms/#id/relations/synonymie </li> <li> noms/#id/relations/flores </li> |
<li> noms/#id/relations/homonymie </li>'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} else { // requete de type noms/#id : rajout du nom_sci pour récupérer le format html par la fct mettreAuFormat() |
$this->requete_champ = ' *, nom_sci '; |
} |
} |
public function traiterRessourceRelations() { |
$this->format_reponse .= '/relations'; |
$projet = $this->ressources[1]; |
$num_nom = $this->ressources[2]; |
if (strrpos($num_nom, 'nn.coste') !== false) { |
list($p, $nn) = explode('=', $num_nom); |
$num_nom = $nn; |
} |
$champ = "flore_$projet"."_num"; |
if (isset($this->ressources[3])) { |
$type = $this->ressources[3]; |
if (!in_array($type, array('homonymie', 'synonymie', 'flores'))) { |
$e = "Les types disponibles pour les noms sont homonymie, synonymie et flores"; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
$this->requete_champ = ' num_nom '; |
$this->requete_condition = array(); |
$this->requete_condition[] = "$champ = ".$this->getBdd()->proteger($num_nom); |
} |
public function traiterRessourceIdRelations() { |
$this->format_reponse .= '/relations'; |
if (isset($this->ressources[2]) && !empty($this->ressources[2])) { |
// requete de type noms/#id/relations/#relation |
switch ($this->ressources[2]) { |
case 'synonymie' : |
$this->traiterRessourceIdSynonymie(); |
break; |
case 'flores' : |
$this->traiterRessourceIdFlores(); |
break; |
case 'homonymie' : |
$this->traiterRessourceIdHomonymie(); |
break; |
default : |
$e = 'Erreur dans votre requête </br> Ressources disponibles : <br/> |
<li> noms/#id/relations </li> <li> noms/#id/relations/synonymie </li> |
<li> noms/#id/relations/flores </li> <li> noms/#id/relations/homonymie </li>'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
break; |
} |
} |
} |
public function traiterRessourceIdSynonymie() { |
// SELECT num_nom, nom_sci, num_nom_retenu, basionyme FROM bdtfx_v2_00 WHERE num_nom = X LIMIT 0,100; |
$this->format_reponse .= '/synonymie'; |
if (strrpos($this->requete_champ, ', basionyme') === false) { |
$this->requete_champ .= ', basionyme '; |
} |
$this->requete_condition[0] = 'num_nom_retenu = '. |
'(SELECT num_nom_retenu FROM '.$this->table.' WHERE '.$this->requete_condition[0].')'; |
} |
public function traiterRessourceIdHomonymie() { |
// SELECT num_nom, nom_sci, num_nom_retenu FROM bdtfx_v2_00 WHERE nom_sci = (SELECT nom_sci FROM bdtfx_v2_00 WHERE num_nom = X); |
$this->format_reponse .= '/homonymie'; |
$this->requete_condition[0] = 'nom_sci = (SELECT nom_sci FROM '.$this->table |
.' WHERE '.$this->requete_condition[0].')'; |
} |
public function traiterRessourceIdFlores() { |
$champ_flores = ''; |
foreach ($this->champs_table as $champ) { |
if (preg_match('/^flore_.*$/', $champ)) { |
$champ_flores .= ', '.$champ; |
} |
} |
$this->format_reponse .= '/flores'; |
$this->requete_champ = 'num_nom'.$champ_flores; |
} |
public function traiterRessourceStatsRangs() { |
// SELECT count(*) as nombre, rang FROM bdtfx_v2_00 [WHERE rang = 290] GROUP BY rang ORDER BY rang; |
$this->format_reponse .= '/rangs'; |
$this->requete_champ = 'count(*) as nombre, rang '; |
$this->requete_group_by = ' GROUP BY rang ORDER BY rang '; |
} |
public function traiterRessourceStatsAnnees() { |
// SELECT count(*) as nombre, annee FROM bdtfx_v2_00 GROUP BY annee ORDER BY annee; |
$this->format_reponse .= '/annees'; |
$this->requete_champ = 'count(*) as nombre, annee '; |
$this->requete_condition = null; |
$this->requete_group_by = ' GROUP BY annee ORDER BY annee '; |
} |
public function traiterRessourceStatsInitiales() { |
// SELECT count(left( nom_sci, 2 )) as nb, rang, left(nom_sci, 2) as lettre GROUP BY rang, left(nom_sci, 2); |
$this->format_reponse .= '/initiales'; |
$this->requete_champ = 'count(left( nom_sci, 2 )) as nb, rang, left(nom_sci, 2) as lettre '; |
$this->requete_group_by = ' GROUP BY rang, left(nom_sci, 2)'; |
} |
//-----------------------------FONCTIONS DASSEMBLAGE DE LA REQUETE----------------------------------------------------- |
public function assemblerLaRequete() { |
if ( strrpos($this->format_reponse, 'noms/stats/') === false ) { |
$this->mettreAuFormat(); //Ds CommunNomsTaxons.php |
} |
$requete = ' SELECT '.$this->requete_champ. |
' FROM '.$this->table |
.$this->retournerRequeteCondition() |
.$this->requete_group_by |
.$this->formerRequeteLimite(); |
return $requete; |
} |
public function formerRequeteLimite() { |
if ($this->format_reponse != 'noms' && $this->format_reponse != 'noms/id/relations/synonymie' |
&& $this->format_reponse != 'noms/id/relations/homonymie') { |
$this->requete_limite = ''; |
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) { |
$this->limite_requete['depart'] = |
(($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']); |
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
} else { |
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
} |
return $this->requete_limite; |
} |
public function retournerRequeteCondition() { |
$condition = ''; |
if ($this->requete_condition) { |
$condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
} |
return $condition; |
} |
/** Recupere le nombre total de résultat d'une requete lancée. */ |
public function recupererTotalResultat() { |
$total = null; |
$requete = 'SELECT count(*) as nombre FROM '.$this->table.$this->retournerRequeteCondition().$this->requete_group_by; |
$res = $this->getBdd()->recuperer($requete); |
if ($res) { |
$total = $res['nombre']; |
} else { |
$e = 'Fct recupererTotalResultat() : <br/>Données introuvables dans la base'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
} |
return $total; |
} |
//-------------------FONCTIONS POUR LE FORMATAGE EN JSON---------------------------------------------------------------- |
public function retournerResultatFormate($resultat, $version) { |
switch ($this->format_reponse) { |
case 'noms/relations' : |
$reponse = $this->formaterRelations($resultat[0]); |
break; |
case 'noms/id' : //ds CommunNomsTaxons |
$reponse = $this->formaterId($resultat[0]); |
break; |
case 'noms/id/champ' : //ds CommunNomsTaxons |
$reponse = $this->formaterIdChamp($resultat[0]); |
break; |
case 'noms/id/relations' : |
$reponse = $this->formaterIdRelations($resultat[0]); |
break; |
case 'noms/id/relations/synonymie' : |
$reponse = $this->formaterIdSynonymie($resultat); |
break; |
case 'noms/id/relations/homonymie' : |
$reponse = $this->formaterIdHomonymie($resultat); |
break; |
case 'noms/id/relations/flores' : //ds CommunsNomsTaxons |
$reponse = $this->formaterIdFlores($resultat[0]); |
break; |
case 'noms/stats/annees' : //ds CommunNomsTaxons |
$reponse = $this->formaterStatsAnnee($resultat); |
break; |
case 'noms/stats/rangs' : //ds CommunNomsTaxons |
$reponse = $this->formaterStatsRang($resultat); |
break; |
case 'noms/stats/initiales' : //ds CommunNomsTaxons |
$reponse = $this->formaterStatsInitiales($resultat); |
break; |
case 'noms' : |
$reponse = $this->formaterNoms($resultat); |
break; |
} |
return $reponse; |
} |
//+---------------------concerne les resultats pour des requetes de type noms/id-----------------------------+ |
public function formaterRelations($resultat) { |
$num_nom = $resultat['num_nom']; |
if (isset($this->ressources[3])) { |
$url = Config::get('url_service').$this->service."/$num_nom/relations"; |
} else { |
$type = $this->ressources[3]; |
$url = Config::get('url_service')."/$this->service/$num_nom/relations/$type"; |
} |
$res = $this->consulterHref($url); |
return $res; |
} |
public function formaterIdRelations($resultat) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
$this->resultat_req = $resultat; |
$retour_id_rel = array ('entete' => array()); //on initialise pr que l'entete apparaisse en premier lors de l'affichage |
//on recupère le resultat de chaque relation (appel du WS correspondant) |
$flores = $this->ajouterRelations('flores', $version); |
if (isset($flores)) $retour_id_rel['resultat']['flores'] = $flores; |
$homonymes = $this->ajouterRelations('homonymie', $version); |
if (isset($homonymes)) $retour_id_rel['resultat']['homonymes'] = $homonymes; |
$synonymes = $this->ajouterRelations('synonymie', $version); |
if (isset($synonymes)) $retour_id_rel['resultat']['synonymes'] = $synonymes; |
//on renvoit null si il n'existe aucune relations (on efface l'entete en premier lieu) |
if (!isset($retour_id_rel['resultat'])) { |
$retour_id_rel = null; |
} else { //on rajoute l'entete si des relations existent |
$this->afficherDonnees('num_nom', $this->ressources[0]); |
$retour_id_rel['entete'] = $this->table_retour; |
$this->table_retour = array(); |
} |
return $retour_id_rel; |
} |
/** |
* Recupere les relations (type de la relation passée en paramètres :[type_relation] = synonymie, homonymie ou |
* flores) par l'appel du web service [version]/noms/#id/relations/[type_relation] |
*/ |
public function ajouterRelations($relation, $version) { |
$version = str_replace(Config::get('bdd_table').'_', '', $version); |
$res = null; |
$parametres_url = ''; |
if ($this->parametres != array()) $parametres_url = '?'.http_build_query($this->parametres, '', '&'); |
$url = Config::get('url_service').'/'.$version.'/'.$this->service.'/' |
.$this->ressources[0].'/relations/' |
.$relation.$parametres_url; |
$relation = $this->consulterHref($url); |
$res = $relation->resultat; |
return $res; |
} |
public function formaterIdSynonymie($resultat) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
$retour_id_syn = array(); |
if ($resultat[0]['num_nom_retenu'] == '') { |
$retour_id_syn[] = 'nom_retenu N.D.'; |
} elseif (count($resultat) != 1) { |
//on remplit d'abord l'entete du resultat |
$this->table_retour['id'] = $this->ressources[0]; |
$this->afficherEnteteResultat('/'.$this->service.'/'.$this->ressources[0].'/relations/synonymie'); |
$retour_id_syn['entete'] = $this->table_retour; |
$this->table_retour = array(); |
foreach ($resultat as $tab) { |
//pour chaque basionyme, on recupère le résultat : num_nom, nom_sci, basionyme et num_nom_retenu : |
$this->resultat_req = $tab; |
$num = $tab['num_nom']; |
$this->afficherNomHrefRetenu($tab, $num); |
$this->afficherDonnees('basionyme', $tab['basionyme']); |
$retour_id_syn['resultat'][$num] = $this->table_retour; |
$this->table_retour = array(); |
} |
if (!isset($retour_id_syn['resultat']) && !in_array('nom_retenu N.D.', $retour_id_syn)) { |
$retour_id_syn = null; //on initialise le resultat à null |
} |
} |
return $retour_id_syn; |
} |
public function formaterIdHomonymie($resultat) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
if (count($res_version) != 1) { |
$this->table_retour['id'] = $this->ressources[0]; |
$this->afficherEnteteResultat($resultat, '/'.$this->service.'/'.$this->ressources[0].'/relations/homonymie'); |
$retour_id_hom['entete'] = $this->table_retour; |
$this->table_retour = array(); |
foreach ($resultat as $homonyme) { |
$this->resultat_req = $homonyme; |
$id = $homonyme['num_nom']; |
$this->afficherDonnees('num_nom', $id); |
if ($homonyme['num_nom_retenu'] != '') { |
$retenu = ($id == $homonyme['num_nom_retenu']) ? 'true' : 'false'; |
$this->table_retour['retenu'] = $retenu; |
} |
$retour_id_hom['resultat'][$id] = $this->table_retour; |
unset($retour_id_hom['resultat'][$id]['id']); |
$this->table_retour = array(); |
} |
} else { |
$retour_id_hom = null; |
} |
return $retour_id_hom; |
} |
public function formaterIdFlores($resultat) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp,noms_projets'); |
$this->resultat_req = $resultat; |
$id = array_shift($resultat); |
$reponse['entete']['id'] = $id; |
foreach ($resultat as $flores => $valeur) { |
if ($valeur != '' && $valeur != '0') { |
$this->afficherInfosFlore($res_version, $flores, $valeur); |
} |
} |
if ($this->table_retour != array()) { |
$reponse['resultat'] = $this->table_retour; |
$this->table_retour = array(); |
} else { |
$reponse = null; |
} |
return $reponse; |
} |
public function afficherInfosFlore(&$resultat, $flores, $valeur) { |
$flore = substr($flores,0,strrpos($flores, '_')); |
$projet = $this->noms_projets[$flore]; |
if (strrpos($flores, 'num') !== false) { |
if (preg_match('/^([0-9]+)(?:[.]syn[^a-z]*|(.*))?$/', $valeur, $match)) { |
$this->table_retour[$flore]['id'] = $match[1]; |
if ($projet == 'coste') { |
$this->table_retour[$flore]['href'] = $this->ajouterHrefAutreProjet('noms', 'nn_coste:', $match[1], $projet); |
} |
if (isset($match[2]) && $match[2] != '') $this->table_retour[$flore]['cle'] = $match[2]; |
} |
if (isset($resultat[$flore.'_rem']) && !empty($resultat[$flore.'_rem'])) { |
$this->table_retour[$flore]['remarque'] = $resultat[$flore.'_rem']; |
unset($resultat[$flore.'_rem']); |
} |
} elseif (strrpos($flores,'belge') !== false) { |
if (preg_match('/^([0-9]+) (R|S)?$/', $valeur, $match)) { |
if (isset($match[2])) $type = ($match[2] == 'R') ? 'taxons' : 'synonyme'; |
$this->table_retour[$flore]['page'] = $match[1]; |
$this->table_retour[$flore]['type'] = $type; |
} |
} |
} |
//+---------------------concerne les resultats pour des requetes de type /noms avec ou sans paramètres-------+ |
public function formaterNoms($resultat) { |
if ($this->parametres['retour.format'] == 'oss') { |
$reponse = $this->formaterEnOss($resultat); //Ds CommunNomsTaxons.php |
} else { |
$reponse = $this->formaterEnJsonMax($resultat); |
} |
return $reponse; |
} |
public function formaterEnJsonMax($resultat) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
$masque = $this->recupererMasquePrincipal(); |
if (isset($masque)) { |
$resultat = $this->trierRechercheFloue($this->parametres[$masque[0]], $resultat, $masque[1]); |
} |
if (isset($this->masque)) { |
$this->table_retour['masque'] = implode('&', $this->masque); |
} |
$this->afficherEnteteResultat('/'.$this->service); //communNomTaxons |
$table_retour_json['entete'] = $this->table_retour; |
//on remplit la table $table_retour_json['resultat'] |
$champs = null; |
if (array_key_exists('retour.champs', $this->parametres)) { |
$champs = explode(',', $this->parametres['retour.champs']); |
} |
$resultat_json = null; |
foreach ($resultat as $tab) { |
$this->table_retour = array(); |
$num = $tab['num_nom']; |
$this->afficherNomHrefRetenu($tab, $num); |
$reponse_id = $this->formaterId($tab); |
$this->ajouterChampsPersonnalises($champs, $reponse_id); |
$resultat_json[$num] = $this->table_retour; |
} |
$table_retour_json['resultat'] = $resultat_json; |
return $table_retour_json; |
} |
} |
?> |
/trunk/services/modules/0.1/bdtfx/Taxons.php |
---|
New file |
0,0 → 1,470 |
<?php |
// declare(encoding='UTF-8');// ou ISO-8859-15 |
/** |
* Description : |
* Classe Taxons.php permettant de fournir des informations sur les noms scientifiques retenu. |
* Si l'url finit par /taxons on retourne une liste de noms latin et leurs identifiants (seulement les 100 premeiers noms par défaut). |
* L'url peut contenir des paramètres optionnels passés après le ? : /taxons?param1=val1¶m2=val2&... |
* |
* Les paramètres de requête disponibles sont : masque, recherche, rang, distinct, retour.format, nl.format, |
* nl.structure, navigation.depart et navigation.limite. |
* |
* Encodage en entrée : utf8 |
* Encodage en sortie : utf8 |
* @package framework-v3 |
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org> |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 1.0 |
* @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org) |
*/ |
class Taxons extends CommunNomsTaxons { |
/** Permet de stocker la requete formulée taxons | taxons/#id | taxons/#id/#champ+#champ ...*/ |
protected $format_reponse = 'taxons'; |
protected $service = 'taxons'; |
protected $requete_champ = 'num_nom, nom_sci, num_nom_retenu, num_taxonomique '; |
protected $requete_condition = null; |
protected $requete_group_by = ' '; |
/** Permet de stocker les limite de la requete SQL (par défaut seul les 100 premiers résultats seront retournés).*/ |
protected $limite_requete = array('depart' => 0, 'limite' => 100); |
protected $num_nom_taxon; //Stocke le num_nom du nom retenu du num_nom recherché |
protected $presence_num_tax = true; |
public function consulter($ressources, $parametres) { |
return parent::consulter($ressources, $parametres); |
} |
public function traiterParametresSpecifiques() { |
$this->requete_condition[] = 'num_nom = num_nom_retenu'; |
foreach ($this->parametres as $param => $val) { |
switch ($param) { |
case 'masque' : |
$this->ajouterFiltreMasque('nom_sci', $val); |
break; |
case 'masque.nt' : |
$this->requete_condition[] = "num_taxonomique IN ($val)"; |
$this->masque[] = "num_tax=$val"; |
break; |
case 'masque.rg': |
$this->requete_condition[] = 'rang = '.$this->getBdd()->proteger($val); |
$this->masque[] = "rang=$val"; |
break; |
} |
} |
} |
//------------------------------------------Fonction ressources--------------------------------------------------------------------- |
public function gererNumTax() { |
if (!in_array('num_taxonomique', $this->champs_table)) { |
$this->presence_num_tax = false; |
$this->requete_champ = str_replace(', num_taxonomique ', '', $this->requete_champ); |
} else { |
$this->presence_num_tax = true; |
} |
} |
public function traiterRessourcesIdentifiant() { |
$this->format_reponse = 'taxons/id'; |
$this->traiterRessourceNtId(); |
$this->num_nom_taxon = $this->recupererNumNomTaxon(); //on recupere le taxon correspondant au num_nom recherché |
if ($this->entete_http == '') { |
$this->requete_condition[0] = 'num_nom = '.$this->getBdd()->proteger($this->num_nom_taxon); |
if (isset($this->ressources[1]) && !empty($this->ressources[1])) { |
//---------------- requete de type taxons/#id/#champ+#champ-------------------------------------- |
if ($this->ressources[1] != 'relations') { // SELECT *, nom_sci FROM bftfx_v2_00 WHERE num_nom = X; |
$this->requete_champ = ' *, nom_sci '; |
$this->format_reponse .= '/champ'; |
//---------------- requete de type taxons/#id/relations/#relation-------------------------------- |
} elseif ($this->ressources[1] == 'relations') { |
$this->traiterRessourceIdRelations(); |
} else { |
$e = 'Erreur dans votre requête </br> Ressources disponibles : <br/> |
<li> #id/relations </li> <li> #id/#champ+#champ </li> <li> #id/relations </li> |
<li> #id/relations/inferieurs </li> <li> #id/relations/superieurs </li>'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} else { //--------------- requete de type taxons/#id----------------------------------------------------- |
$this->requete_champ = ' *, nom_sci '; |
} |
} |
} |
public function traiterRessourceNtId() { |
if (strrpos($this->ressources[0], 'nt:') !== false) { |
if ($this->presence_num_tax) { |
// SELECT num_nom FROM bdtfx_v2_00 WHERE num_nom = num_nom_retenu AND num_taxonomique = X; |
$this->requete_condition[0] = 'num_nom = num_nom_retenu AND num_taxonomique = ' |
.str_replace('nt:', '', $this->ressources[0]).' '; |
} else { |
$e = 'Erreur dans votre requête : </br> Le numéro taxonomique n\'existe pas dans ce projet'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} else { |
// SELECT num_nom FROM bdtfx_v2_00 WHERE num_nom = (SELECT num_nom_retenu FROM bdtfx_v2_00 WHERE num_nom = X); |
$this->requete_condition[0] = 'num_nom = (SELECT num_nom_retenu FROM ' |
.$this->table.' WHERE num_nom = '.$this->ressources[0].')'; |
} |
} |
/** Permet de récupérer le num_nom du taxon recherché. Soit le numéro taxonomique est demandé (avec nt: ) |
* soit un num_nom dont on recherche le num_nom_retenu */ |
public function recupererNumNomTaxon() { |
$identifiant = ''; |
if ($this->entete_http == '') { |
//on récupere l'identifiant du taxon correspondant au num_nom ou num_taxonomique demandé pour pouvoir l'afficher |
$req_tax = 'SELECT num_nom FROM '.$this->table.' WHERE '.$this->requete_condition[0]; |
$res_tax = $this->getBdd()->recuperer($req_tax); |
//on recherche ensuite les identifiants des taxons supérieurs ou inférieurs |
if ($res_tax && $res_tax != '') { |
$identifiant = $res_tax['num_nom']; |
} else { |
$e = 'Le numéro de taxon ou l\'identifiant de nom correspondant au num_nom ' |
.$this->ressources[0].' n\'existe pas dans la base.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
Debug::printr($req_tax); |
} |
} |
return $identifiant; |
} |
public function traiterRessourceIdRelations() { |
//----------------- requete de type taxons/#id/relations------------------------------------------- |
// SELECT *, nom_sci FROM bftfx_v2_00 WHERE num_nom = X; |
$this->format_reponse .= '/relations'; |
if (isset($this->ressources[2]) && !empty($this->ressources[2])) { |
//------------- requete de type taxons/#id/relations/#relation-------------------------------- |
switch ($this->ressources[2]) { |
case 'superieurs' : |
$rel = 'recupererIdSup'; |
$this->format_reponse .= '/superieurs'; |
$this->traiterRessourceIdRelationInfSup($rel); |
break; |
case 'inferieurs' : |
$rel = 'recupererIdInf'; |
$this->format_reponse .= '/inferieurs'; |
$this->traiterRessourceIdRelationInfSup($rel); |
break; |
default : |
$e = 'Erreur dans votre requête </br> Ressources disponibles : <br/> |
<li> taxons/#id/relations </li><li> #id/relations/inferieurs </li> |
<li> #id/relations/superieurs </li>'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
break; |
} |
} |
} |
public function traiterRessourceIdRelationInfSup($rel) { |
//Appel de la fct récupérerIdSup ou recupererIdInf : retourne les num_nom des noms inferieurs ou superieurs |
$res_relation = $this->$rel(); |
//analyse du résultat retourné par la requete de recherche des identifiants correspondant aux taxons inf|sup : |
if ($res_relation == '') { //dans le cas ou la requete comporte des erreurs |
$e = 'Fct traiterRessourceIdHomonymie : La requête forme comporte une erreur!'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
} elseif ($res_relation) { |
//dans le cas ou une ou plusieurs relations est retournée, on récupère les identifiants ss la forme (id, id, id) |
foreach ($res_relation as $ligne) $res[] = $ligne['num_nom']; |
$res = implode(',',$res); |
$this->requete_condition[0] = "num_nom IN ($res)"; |
$this->requete_champ .= ', rang, num_tax_sup '; |
} else { //dans le cas ou aucune relation n'existe |
$res = array($this->num_nom_taxon => null); |
$this->corps_http = json_encode($res); |
$this->entete_http = RestServeur::HTTP_CODE_OK; |
} |
} |
public function recupererIdInf() { |
//SELECT num_nom FROM bfdtx_v2_00 WHERE num_tax_sup = (SELECT num_nom FROM bdtfx_v2_00 WHERE num_nom = X); |
$req_relation = 'SELECT num_nom FROM '.$this->table |
.' WHERE num_tax_sup = (SELECT num_nom FROM ' |
.$this->table |
.' WHERE '.implode(' AND ', $this->requete_condition).')'; |
$res_relation = $this->getBdd()->recupererTous($req_relation); |
return $res_relation; |
} |
public function recupererIdSup() { |
//SELECT num_nom FROM bfdtx_v2_00 WHERE num_nom = (SELECT num_tax_sup FROM bdtfx_v2_00 WHERE num_nom = X); |
$req_relation = 'SELECT num_nom FROM '.$this->table |
.' WHERE num_nom = (SELECT num_tax_sup FROM ' |
.$this->table |
.' WHERE '.implode(' AND ', $this->requete_condition).')'; |
$res_relation = $this->getBdd()->recupererTous($req_relation); |
return $res_relation; |
} |
public function traiterRessourceStatsInitiales() { |
// SELECT count(nom_sci) as nb, rang, left(nom_sci, 2) as lettre FROM bdtfx_v2_00 GROUP BY rang, left(nom_sci, 2); |
$this->format_reponse = 'taxons/stats/initiales'; |
$this->requete_champ = 'count(nom_sci) as nb, rang, left(nom_sci, 2) as lettre '; |
$this->requete_group_by = ' GROUP BY rang, left(nom_sci, 2) '; |
} |
public function traiterRessourceStatsRangs() { |
// SELECT count(*) as nombre, rang FROM bdtfx_v2_00 [WHERE rang = 290] GROUP BY rang ORDER BY rang; |
$this->format_reponse = 'taxons/stats/rangs'; |
$this->requete_champ = 'count(*) as nombre, rang '; |
$this->requete_group_by = ' GROUP BY rang ORDER BY rang '; |
} |
public function traiterRessourceStatsAnnees() { |
// SELECT count(*) as nombre, annee FROM bdtfx_v2_00 GROUP BY annee ORDER BY annee; |
$this->format_reponse = 'taxons/stats/annees'; |
$this->requete_champ = 'count(*) as nombre, annee '; |
$this->requete_group_by = ' GROUP BY annee ORDER BY annee '; |
} |
//-----------------------------FONCTIONS DASSEMBLAGE DE LA REQUETE----------------------------------------------------- |
public function assemblerLaRequete() { |
if ($this->format_reponse != 'taxons/stats/initiales') { |
$this->mettreAuFormat(); //on remplace les nom_sci par les nom_sci_html |
} |
$requete = ' SELECT '.$this->requete_champ. |
' FROM '.$this->table |
.$this->retournerRequeteCondition() |
.$this->requete_group_by |
.$this->formerRequeteLimite(); |
return $requete; |
} |
public function formerRequeteLimite() { |
if ($this->format_reponse != 'taxons' && $this->format_reponse != 'taxons/id/relations/homonymie') { |
$this->requete_limite = ''; |
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) { |
$this->limite_requete['depart'] = (($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']); |
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
} else { |
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
} |
return $this->requete_limite; |
} |
public function retournerRequeteCondition() { |
$condition = ''; |
if ($this->requete_condition) { |
$condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
} |
return $condition; |
} |
public function recupererTotalResultat() { |
$requete = 'SELECT count(*) as nombre FROM '.$this->table.$this->retournerRequeteCondition().$this->requete_group_by; |
$res = $this->getBdd()->recuperer($requete); |
if ($res) { |
$total = $res['nombre']; |
} |
return $total; |
} |
//-------------------------FONCTIONS DE FORMATION DU RESULTAT----------------------------------------------------------- |
/** Permet de récupérer le résultat à retourner propre à chaque requete et de l'encoder en json*/ |
public function retournerResultatFormate($resultat, $version) { |
switch ($this->format_reponse) { |
case 'taxons/id' ://ds CommunNomsTaxons |
$reponse = $this->formaterId($resultat[0]); |
break; |
case 'taxons/id/champ' ://ds CommunNomsTaxons |
$reponse = $this->formaterIdChamp($resultat[0]); |
break; |
case 'taxons/id/relations' : |
$reponse = $this->formaterIdRelations($resultat[0],$version); |
break; |
case 'taxons/id/relations/superieurs' : |
$reponse = $this->formaterIdSuperieur($resultat, $version); |
break; |
case 'taxons/id/relations/inferieurs' : |
$reponse = $this->formaterIdInferieur($resultat); |
break; |
case 'taxons/stats/annees' : //ds CommunNomsTaxons |
$reponse = $this->formaterStatsAnnee($resultat); |
break; |
case 'taxons/stats/rangs' ://ds CommunNomsTaxons |
$reponse = $this->formaterStatsRang($resultat); |
break; |
case 'taxons/stats/initiales' ://ds CommunNomsTaxons |
$reponse = $this->formaterStatsInitiales($resultat); |
break; |
case 'taxons' : |
$reponse = $this->formatertaxons($resultat); |
break; |
} |
return $reponse; |
} |
//----------------------concerne les resultats pour des requetes de type /noms avec ou sans paramètres-------------- |
public function formaterTaxons($resultat) { |
if ($this->parametres['retour.format'] == 'oss') { |
$reponse = $this->formaterEnOss($resultat); |
} else { |
$reponse = $this->formaterEnJsonMax($resultat); |
} |
return $reponse; |
} |
public function formaterEnJsonMax($resultat) { |
//print_r($resultat); |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
$masque = $this->recupererMasquePrincipal(); |
if (isset($masque)) $resultat = $this->trierRechercheFloue($this->parametres[$masque[0]], $resultat, $masque[1]); |
if (isset($this->masque)) $this->table_retour['masque'] = implode('&', $this->masque); |
$this->afficherEnteteResultat('/'.$this->service); |
$table_retour_json['entete'] = $this->table_retour; |
$this->table_retour = array(); |
//on remplit la table $table_retour_json['resultat'] |
$tab_tax_inf = $this->recupererListeTaxonInf($resultat); |
foreach ($resultat as $tab) { |
$num = $tab['num_nom']; |
if (isset($this->parametres['masque_nt'])) $this->afficherDonnees('num_taxonomique', $tab['num_taxonomique']); |
$this->afficherNomHrefRetenu($tab, $num); |
$this->afficherTaxonInfNb($num, $tab_tax_inf); |
$resultat_json[$num] = $this->table_retour; |
$this->table_retour = array(); //on vide le tableau table_retour |
} |
$table_retour_json['resultat'] = $resultat_json; |
return $table_retour_json; |
} |
//--------------------concerne les resultats pour des requetes de type noms/id---------------------------------------- |
public function formaterIdRelations($resultat, $version) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
$this->resultat_req = $resultat; |
$retour_id_rel = array ('entete' => array()); //on initialise pr que l'entete apparaisse en premier |
$superieurs = $this->ajouterRelations('superieurs'); //, $version); |
if (isset($superieurs)) $retour_id_rel['resultat']['superieurs'] = $superieurs; |
$inferieurs = $this->ajouterRelations('inferieurs', $version); |
if (isset($inferieurs)) $retour_id_rel['resultat']['inferieurs'] = $inferieurs; |
if (!isset($retour_id_rel['resultat'])) { //on renvoit un tableau null si il n'existe aucune relations |
$retour_id_rel = 'null'; |
} else { //on rajoute l'entete si des relations existent |
$this->afficherDonnees('num_nom', $this->num_nom_taxon); //$this->afficherEnteteResultat($resultat, '/'.$this->service.'/'.$this->ressources[0].'/relations/synonymie'); |
$retour_id_rel['entete'] = $this->table_retour; |
$this->table_retour = array(); |
} |
return $retour_id_rel; |
} |
public function ajouterRelations($relation, $version) { |
$version = str_replace(Config::get('bdd_table').'_', '', $version); |
$res = null; |
$taxon = $this->num_nom_taxon; |
$parametres_url = ''; |
if ($this->parametres != array()) $parametres_url = '?'.http_build_query($this->parametres, '', '&'); |
$url = Config::get('url_service').'/' |
.$this->service.'/'.$version.'/' |
.$this->ressources[0].'/relations/' |
.$relation.$parametres_url; |
$relation = $this->consulterHref($url); |
if (isset($relation->resultat)) { |
$res = $relation->resultat; |
} elseif (isset($relation->$taxon)) { //pour les relations inf et sup |
$res = $relation->$taxon; |
} |
return $res; |
} |
public function formaterIdSuperieur($resultat, $version) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
$tab_relation = null; //si il n'existe aucune relation |
if (($resultat) != '' ) { |
//on recupere d'abord les rangs supérieurs |
$sup = $resultat[0]; |
do { |
$sup = $this->recupererIdSuperieur($sup['num_tax_sup'], $version); |
if ($sup['rang'] == '0') $sup['rang'] = '10'; //erreur dans la base |
if (isset($sup)) $resultat[] = $sup; |
} while ($sup != null); |
krsort($resultat); |
//on les affiche ensuite |
foreach ($resultat as $tab) { |
$this->resultat_req = $tab; |
$num = $tab['num_nom']; |
$this->afficherNomHrefRetenu($tab, $num); |
$this->afficherDonnees('rang', $tab['rang']); |
$tab_inf[$num] = $this->table_retour; |
$this->table_retour = array(); |
} |
$tab_relation[$this->num_nom_taxon] = $tab_inf; |
} |
return $tab_relation; |
} |
public function recupererIdSuperieur($id, $version) { |
$req = 'SELECT num_nom, num_nom_retenu, num_tax_sup, rang FROM ' |
.$version.' WHERE num_nom = '.$this->getBdd()->proteger($id); |
$res = $this->getBdd()->recupererTous($req); |
if ($res) { |
$resultat = $res[0]; |
} else { |
$resultat = 'null'; //on return null si il n'y a pas de taxon superieur |
} |
return $resultat; |
} |
public function formaterIdInferieur($resultat) { |
$this->recupererTableSignification('champs_api,champs_comp,correspondance_champs'); |
$tab_tax_inf = $this->recupererListeTaxonInf($resultat); |
$tab_relation = null; |
//on commence le formatage |
if (($resultat) != '' ) { |
foreach ($resultat as $tab) { |
$this->resultat_req = $tab; |
$this->afficherNomHrefRetenu($tab, $num_nom); |
$tab_inf[$num] = $this->table_retour; |
$this->table_retour = array(); //on vide le tableau table_retour |
} |
$tab_relation[$this->num_nom_taxon] = $tab_inf; |
} |
return $tab_relation; |
} |
public function afficherTaxonInfNb($num, $tab_tax_inf) { |
foreach ($tab_tax_inf as $taxNb) { |
if ($taxNb['num_tax_sup'] == $num) { |
$this->table_retour['taxon_inferieur_nbre'] = $taxNb['nb']; |
} |
} |
if (!isset($this->table_retour['taxon_inferieur_nbre'])) { |
$this->table_retour['taxon_inferieur_nbre'] = '0'; |
} |
} |
public function recupererListeTaxonInf($resultat) { |
// SELECT num_tax_sup, count(*) as nb FROM bdtfx_v2_00 WHERE num_tax_sup IN (id, id, id) AND num_nom = num_nom_retenu GROUP BY num_tax_sup'; |
foreach ($resultat as $tab) { |
$tab_num[] = $tab['num_nom']; //on regroupe ici les id des taxons dont on cherche le nb de taxon inf |
} |
$req = 'SELECT num_tax_sup, count(*) as nb FROM '.$this->table |
.' WHERE num_tax_sup IN ('.implode(',',$tab_num) |
.') AND num_nom = num_nom_retenu GROUP BY num_tax_sup'; |
$res = $this->getBdd()->recupererTous($req); |
if ($res) { |
$resultat = $res; |
} else { |
$resultat = array(); //on return un tableau vide s'il n'y a pas de taxon inférieurs |
} |
return $resultat; |
} |
} |
?> |
/trunk/services/modules/0.1/bdtfx/CommunNomsTaxons.php |
---|
New file |
0,0 → 1,813 |
<?php |
// declare(encoding='UTF-8'); |
/** |
* Description : |
* Classe CommunNomsTaxons.php |
* Encodage en entrée : utf8 |
* Encodage en sortie : utf8 |
* @package framework-v3 |
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org> |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 1.0 |
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
*/ |
abstract class CommunNomsTaxons extends Commun { |
/** Tableau de correspondance entre les noms des champs et les codes de l'ontologie.*/ |
private $relationsChampsCodesOntologie = null; |
protected $table_retour; //Permet de stocker le tableau de résultat (non encodé en json) |
protected $resultat_req; // Permet de stocker le résultat de la requete principale. |
protected $compo_nom = null; //Stocke sous forme de tableau les composant du nom à ajouter au nom scientifique |
protected $table;// Nom de la table dans laquelle on récupèrera les données dans les requetes SQL |
protected $total_resultat = null; |
/** Stocke le service appelé correspondant. Est utilisé principalement lors de l'affichage du href d'un synonyme |
(ex id=12, basionyme num 25 est un synonyme) dans le service taxon */ |
protected $service_href = null; |
protected $erreursParametres = null; |
//+------------------------------- PARAMÈTRES ---------------------------------------------------------------+ |
public function traiterParametres() { |
$this->definirParametresParDefaut(); |
$this->verifierParametres(); |
if (isset($this->parametres) && count($this->parametres) > 0) { |
foreach ($this->parametres as $param => $val) { |
switch ($param) { |
case 'ns.structure' : |
$this->remplirTableCompositionNom($val); |
$this->requete_champ .= ' ,'.implode(', ',$this->compo_nom); |
break; |
case 'navigation.depart' : |
$this->limite_requete['depart'] = $val; |
break; |
case 'navigation.limite' : |
$this->limite_requete['limite'] = $val; |
break; |
} |
} |
$this->traiterParametresSpecifiques(); |
} |
} |
protected function definirParametresParDefaut() { |
if (empty($this->parametres['recherche'])) { |
$this->parametres['recherche'] = 'stricte'; |
} |
if (empty($this->parametres['ns.format'])) { |
$this->parametres['ns.format'] = 'txt'; |
} |
if (empty($this->parametres['retour.format'])) { |
$this->parametres['retour.format'] = 'max'; |
} |
} |
public function verifierParametres() { |
$this->verifierParametresAPI(); |
$this->verifierParametre('recherche', 'stricte|floue|etendue'); |
$this->verifierParametre('ns.format', 'htm|txt'); |
$this->verifierParametre('retour.format', 'min|max|oss|perso'); |
$this->verifierParametreAvecValeurMultipe('ns.structure', 'an|au|bib|ad'); |
if (count($this->erreursParametres) > 0) { |
$m = 'Erreur dans votre requête : '.implode('<br/>', $this->erreursParametres); |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $m); |
} |
} |
public function verifierParametresAPI() { |
$parametresApi = $this->recupererTableauConfig('parametresAPI'); |
while (!is_null($parametre = key($this->parametres))) { |
if (!in_array($parametre, $parametresApi)) { |
$this->erreursParametres[] = "Le paramètre '$parametre' n'est pas pris en compte par cette version de l'API."; |
} |
next($this->parametres); |
} |
} |
public function verifierParametre($parametre, $valeursPermises) { |
if (isset($this->parametres[$parametre]) && !empty($this->parametres[$parametre])) { |
$valeur = $this->parametres[$parametre]; |
$this->verifierValeursPermises($parametre, $valeur, $valeursPermises); |
} |
} |
public function verifierParametreAvecValeurMultipe($parametre, $valeursPermises) { |
if (isset($this->parametres[$parametre]) && !empty($this->parametres[$parametre])) { |
$valeursConcatenees = $this->parametres[$parametre]; |
$valeurs = explode(',', $valeursConcatenees); |
foreach ($valeurs as $valeur) { |
$this->verifierValeursPermises($parametre, $valeur, $valeursPermises); |
} |
} |
} |
private function verifierValeursPermises($parametre, $valeur, $valeursPermises) { |
if (!in_array($valeur, explode('|', $valeursPermises))) { |
$this->erreursParametres[] = "Le paramètre '$parametre' ne peut pas prendre la valeur '$valeur'. Valeurs permises : $valeursPermises"; |
} |
} |
public function traiterParametresCommuns() { |
} |
public function ajouterFiltreMasque($nom_champ, $valeur) { |
if ($nom_champ == 'annee' || $nom_champ == 'rang') { |
$this->requete_condition []= "$nom_champ = ".$this->getBdd()->proteger($valeur); |
} else { |
if ($this->parametres['recherche'] == 'etendue') { |
$valeur = $this->modifierValeur($valeur); |
$this->requete_condition[] = "$nom_champ LIKE ".$this->getBdd()->proteger($valeur); |
} elseif ($this->parametres['recherche'] == 'floue') { |
$valeur = $this->getBdd()->proteger($valeur); |
$this->requete_condition[] = "( SOUNDEX($nom_champ) = SOUNDEX($valeur))". |
" OR ( SOUNDEX(REVERSE($nom_champ)) = SOUNDEX(REVERSE($valeur)))"; |
} else { |
$this->requete_condition[] = "$nom_champ LIKE ".$this->getBdd()->proteger($valeur); |
} |
} |
$this->masque[$nom_champ] = "$nom_champ=$valeur"; |
} |
private function modifierValeur($valeur) { |
$valeur = $this->remplacerCaractereHybrideEtChimere($valeur); |
$valeur = $this->preparerChainePourRechercheEtendue($valeur); |
return $valeur; |
} |
private function remplacerCaractereHybrideEtChimere($valeur) { |
$caracteres = array('×', '%D7', '+', '%2B'); |
$remplacements = array('x ','x ', '+', '+'); |
$valeur = str_replace($caracteres, $remplacements, $valeur); |
return $valeur; |
} |
private function preparerChainePourRechercheEtendue($valeur) { |
$valeur = str_replace(' ', '%', trim($valeur)); |
$valeur = $valeur.'%'; |
return $valeur; |
} |
//+-------------------------------Fonctions d'analyse des ressources-----------------------------------------+ |
public function traiterVersionProjet() { |
if (isset($this->ressources) && count($this->ressources) > 0) { |
if (preg_match('/^(?:v[0-9]+[._][0-9]+|[*]|[+]|%2B| )$/', $this->ressources[0])) { |
$this->version_projet = array_shift($this->ressources); |
if (preg_match('/^(v[0-9]+[._][0-9]+)$/', $this->version_projet, $match)) { |
$this->version_projet = str_replace('.', '_', $match[1]); |
} else if (preg_match('/^(?:[+]|%2B| )$/', $this->version_projet)) { |
$this->version_projet = '+'; |
} else if (preg_match('/^(?:[*]|%2A)$/', $this->version_projet)) { |
$this->version_projet = '*'; |
} |
} else { |
$this->version_projet = '+'; |
} |
} |
//L'affichage de plusieurs versions ne fonctionne que pour les ressources de type /ressources/#id |
if ($this->version_projet == '*' && $this->etreRessourceId() == false ) { |
$message = "L'affichage de plusieurs versions ne fonctionne que pour les ressources de type /ressources/#id"; |
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
throw new Exception($message, $code); |
} |
$table_num_version = $this->recupererVersionDisponible(); |
$this->recupererListeNomTablePrChaqueVersion($table_num_version); |
} |
private function etreRessourceId() { |
$ok = false; |
if ($this->estUnIdentifiant() && count($this->ressources) == 1) { |
$ok = true; |
} |
return $ok; |
} |
public function traiterRessources() { |
if (isset($this->ressources) && count($this->ressources) > 0) { |
if ($this->ressources[0] == 'relations') { |
$this->traiterRessourceRelations(); |
} elseif ($this->estUnIdentifiant()) { //l'identifiant peut etre de type /#id ou /nt:#id |
$this->traiterRessourcesIdentifiant(); // dans le service noms ou taxons |
} elseif ($this->ressources[0] == 'stats') { //ressource = noms/stats |
$this->traiterRessourcesStats(); |
} else { |
$e = 'Erreur dans votre requete </br> Ressources disponibles : <br/> |
<li> /'.$this->service.'/#id (id : L\'identifiant du nom rechercher)</li> |
<li> /'.$this->service.'/nt:#id (id : Numero du taxon recherche)</li> |
<li> /'.$this->service.'/stats </li>'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
} |
public function traiterRessourcesStats() { |
$this->format_reponse = $this->service.'/stats'; |
$e = "Erreur dans votre requête </br> Ressources disponibles : $this->service/stats/[annees|rangs|initiales]"; |
if (isset($this->ressources[1]) && !empty($this->ressources[1])) { |
switch ($this->ressources[1]) { |
case 'annees' : |
$this->traiterRessourceStatsAnnees(); |
break; |
case 'rangs' : |
$this->traiterRessourceStatsRangs(); |
break; |
case 'initiales' : |
$this->traiterRessourceStatsInitiales(); |
break; |
default : |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
break; |
} |
} else { |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
/** Vérifie si la première valeur de la table de ressource est un identifiant : |
* un numerique ou un numéro taxonomique sous la forme nt:xx */ |
public function estUnIdentifiant() { |
return (is_numeric($this->ressources[0]) || (strrpos($this->ressources[0],'nt:') !== false |
&& is_numeric(str_replace('nt:','',$this->ressources[0])))); |
} |
//+--------------------------------------------Fonction d'analyse des parametres-----------------------------+ |
/** Permet de remplir le tableau compo_nom. Il comprendra en fct du paramètre ns.structure les éléments à rajouter |
* au nom_sci (annee, auteur, biblio ou addendum). */ |
public function remplirTableCompositionNom($valeur) { |
$structure_nom = explode(',', $valeur); |
foreach ($structure_nom as $structure) { |
$this->compo_nom[$structure] = str_replace(array('an', 'au', 'bib', 'ad'), |
array('annee', 'auteur', 'biblio_origine', 'nom_addendum'), $structure); |
} |
} |
public function mettreAuFormat() { |
if ($this->parametres['ns.format'] == 'htm') { |
if (strrpos($this->requete_champ, 'nom_sci_html as nom_sci') === false) { |
$this->requete_champ = str_replace('nom_sci', 'nom_sci_html as nom_sci', $this->requete_champ); |
} |
} |
} |
//+-------------------------------fonctions de formatage-----------------------------------------------------+ |
/** Fonction permettant de creer la table dont le nom est passé en paramètre (champs_api, champs_bdtfx, |
* correspondance_champs...). Les données de chaque table sont présentes dans le fichier de configuration config.ini |
* @param String $table : Peut contenir plusieurs nom de table dont on souhaite récupérer les données : table,table,table. */ |
public function recupererTableSignification($table) { |
$tables = explode(',', $table); |
foreach ($tables as $tab) { |
if ($tab == 'champs_comp') { |
$champ_bdnff_api = array_keys($this->champs_api); //on recupère le nom des champ ds la bdd |
$this->champs_comp = array_diff($this->champs_table, $champ_bdnff_api); |
} elseif ($tab == 'champs_api') { |
foreach ($this->correspondance_champs as $key => $val) { |
preg_match('/(hybride[.]parent_0[12](?:[.]notes)?|nom_sci[.][^.]+|[^.]+)(?:[.](id|code))?/', $val, $match); |
$val = $match[1]; |
$this->champs_api[$key] = $val; |
} |
} else { |
$this->$tab = $this->recupererTableauConfig($tab); |
} |
} |
} |
public function formaterEnOss($resultat) { |
$table_nom = array(); |
$oss = ''; |
foreach ($resultat as $tab) { |
if (isset($tab['nom_sci']) ) { |
if (!in_array($tab['nom_sci'], $table_nom)) { |
$table_nom[] = $tab['nom_sci']; |
$oss [] = $tab['nom_sci'].$this->ajouterCompositionNom($tab); |
} |
} |
} |
if (isset($this->masque)) $masque = implode('&', $this->masque); |
else $masque = 'Pas de masque'; |
$table_retour_oss = array($masque, $oss); |
return $table_retour_oss; |
} |
public function afficherEnteteResultat($url_service) { |
$this->table_retour['depart'] = $this->limite_requete['depart']; |
$this->table_retour['limite'] = $this->limite_requete['limite']; |
$this->table_retour['total'] = $this->total_resultat; |
$url = $this->formulerUrl($this->total_resultat, $url_service); |
if (isset($url['precedent']) && $url['precedent'] != '') { |
$this->table_retour['href.precedent'] = $url['precedent']; |
} |
if (isset($url['suivant']) && $url['suivant'] != '') { |
$this->table_retour['href.suivant'] = $url['suivant']; |
} |
} |
public function afficherNomHrefRetenu($tab, $num) { |
$this->resultat_req = $tab; |
$this->afficherDonnees('num_nom', $num); |
if ($this->parametres['retour.format'] == 'min') { // sinon est affiché ds afficherDonnees(num_nom, $val) ci-dessus |
$this->table_retour['nom_sci'] = $tab['nom_sci'].$this->ajouterCompositionNom($tab); |
} |
$this->table_retour['retenu'] = ($tab['num_nom_retenu'] == $num) ? 'true' : 'false'; |
unset($this->table_retour['id']); |
} |
//+---------------------------Fonction de formatage pour les services /#id/----------------------------------+ |
public function formaterId($resultat) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
$this->resultat_req = $resultat; |
foreach ($resultat as $cle => $valeur) { |
if ($valeur != '') { |
$this->afficherDonnees($cle, $valeur); |
} |
} |
unset($this->table_retour['href']); |
return $this->table_retour; |
} |
public function formaterIdChamp($resultat) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
$reponse_id = $this->formaterId($resultat); |
$this->table_retour = array(); |
$champs = explode(' ', $this->ressources[1]); |
$this->ajouterChampsPersonnalises($champs, $reponse_id); |
return $this->table_retour; |
} |
protected function ajouterChampsPersonnalises($champs, $reponse_id) { |
if (! is_null($champs) && is_array($champs) && count($champs) > 0) { |
foreach ($champs as $champ) { |
if ($this->verifierValiditeChamp($champ)) { |
if (strrpos($champ, '.*') !== false) { |
$this->afficherPointEtoile($champ, $reponse_id); |
} else { |
$champ = $this->trouverChampBddCorrespondant($champ); |
$this->table_retour[$champ] = (isset($reponse_id[$champ])) ? $reponse_id[$champ] : null; |
} |
} |
} |
} |
} |
public function afficherPointEtoile($champ, $reponse) { |
preg_match('/^([^.]+\.)\*$/', $champ, $match); |
if ($match[1] == 'nom_sci') { |
$this->afficherNomSciPointEpithete($this->resultat_req); |
} else { |
foreach ($reponse as $chp => $valeur) { |
if (strrpos($chp, $match[1]) !== false) { |
if ($valeur != '') { |
$this->table_retour[$chp] = $valeur; |
} else { |
$this->table_retour[$chp] = null; |
} |
} |
} |
} |
} |
public function decomposerNomChamp($champ) { |
$decomposition = false; |
if (preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match)) { |
$radical_champ = $match[1]; |
$suffixe = $match[2]; |
$decomposition = array($radical_champ, $suffixe); |
} |
return $decomposition; |
} |
public function verifierValiditeChamp($champ) { |
$decomposition = $this->decomposerNomChamp($champ); |
$validite_ressource = true; |
if ($decomposition) { |
list($radical, $suffixe) = $decomposition; |
// on verifie si le nom du champ existe bien |
if (!$this->estChampApi($radical) && !$this->estChampComplementaire($radical)) { |
$validite_ressource = false; |
$e = 'Le champ "'.$radical.'" n\'existe pas dans la base. <br/><br/>'; |
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} elseif ($this->estUnPoint($champ)) { |
$validite_ressource = $this->verifierValiditeSuffixe($suffixe, $radical); |
} |
} |
return $validite_ressource; |
} |
public function estChampApi($radical_champ) { |
$champ_api_ok = false; |
if (in_array($radical_champ, $this->champs_api) || in_array($radical_champ, $this->correspondance_champs)) { |
$champ_api_ok = true; |
} |
return $champ_api_ok; |
} |
public function estChampComplementaire($radical_champ) { |
$champ_complementaire_ok = in_array($radical_champ, $this->champs_comp) ? true : false; |
return $champ_complementaire_ok; |
} |
public function verifierValiditeSuffixe($suffixe, $radical_champ) { |
$validite_ressource = true; |
if ($this->correspondAUnId($radical_champ) || $radical_champ == 'id') { |
$this->verificationSuffixesIdentifiant($suffixe, $radical_champ, $validite_ressource); |
} elseif ($this->correspondAUnCode($radical_champ)) { |
$this->verificationSuffixesCodes($suffixe, $radical_champ, $validite_ressource); |
} elseif ($radical_champ == 'nom_sci') { |
if ($suffixe != '*') { |
$validite_ressource = false; |
$m = 'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'".<br/> |
Les suffixes possibles sont les suivants : <li> * </li>'; |
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $m); |
} |
} else { |
$validite_ressource = false; |
$m = 'Erreur : Le paramètre "'.$radical_champ.'" ne peut pas présenter de suffixe. <br/><br/>'; |
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $m); |
} |
return $validite_ressource; |
} |
public function verificationSuffixesCodes(&$suffixe, &$radical_champ, &$validite_ressource ) { |
if (!in_array($suffixe, array('*', 'code', 'href', 'details'))) { |
$validite_ressource = false; |
$e = 'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'.<br/> Les suffixes ' |
.'possibles sont les suivants : <li> .* </li><li> .code </li><li> .href </li><li> .details </li>'; |
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
public function verificationSuffixesIdentifiant(&$suffixe, &$radical_champ, &$validite_ressource) { |
if ((strrpos($radical_champ, 'parent') !== false && !in_array($suffixe, array('*', 'id', 'href', 'details', 'notes'))) |
|| !in_array($suffixe, array('*', 'id', 'href', 'details')) && strrpos($radical_champ, 'parent') === false) { |
$validite_ressource = false; |
$e = 'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'".<br/> Les suffixes ' |
.'possibles sont les suivants : <li> .* </li><li> .id </li><li> .href </li><li> .details </li>' |
.'<li> .notes (seulement pour les hybride.parent)'; |
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
//------------------------------fonction de formatage pour les services /stats/----------------------------------------- |
public function formaterStatsAnnee($resultat) { |
foreach ($resultat as $cle_annee) { |
$annee = ($cle_annee['annee'] != '') ? $cle_annee['annee'] : 'ND'; |
$nb = $cle_annee['nombre']; |
$retour_stats_annee[$annee] = $nb; |
} |
return $retour_stats_annee; |
} |
public function formaterStatsRang($resultat) { |
foreach ($resultat as $rangs) { |
if ($rangs['rang'] != 0) { |
$rang = $rangs['rang']; |
if ($this->parametres['retour.format'] == 'max') { |
$retour_rang[$rang]['rang'] = $this->ajouterSignificationCode('rang',$rang); |
} |
$nombre = $rangs['nombre']; |
$retour_rang[$rang]['nombre'] = $nombre; |
} |
} |
return $retour_rang; |
} |
public function formaterStatsInitiales($resultat) { |
$rang = null; |
$table_rang = array(); |
foreach ($resultat as $tuple) { |
if ($tuple['rang'] != 0) { |
$this->memoriserRang($table_rang, $tuple, $rang); |
if ($tuple['lettre'] == 'x ') { |
$this->ajouterHybrideChimere('hybride', $rang, $tuple); |
} elseif ($tuple['lettre'] == '+ ') { |
$this->ajouterHybrideChimere('chimere', $rang, $tuple); |
} else { |
$l = substr($tuple['lettre'], 0, 1); |
if (isset($this->table_retour[$rang][$l])) { |
$this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] += floatval($tuple['nb']); |
} else { |
$this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] = floatval($tuple['nb']); |
} |
} |
} |
} |
return $this->table_retour; |
} |
public function memoriserRang(&$table_rang, $tuple, &$rang) { |
if (is_array($table_rang)) { |
if (!in_array($tuple['rang'], $table_rang)) { |
$rang = $tuple['rang']; |
$table_rang[] = $rang; |
if ($this->parametres['retour.format'] == 'max') { |
$rang = $this->ajouterSignificationCode('rang', $rang); |
} |
} |
} |
} |
public function ajouterHybrideChimere($groupe, &$rang, &$tuple) { |
if (isset($this->table_retour[$rang][str_replace('hybride', 'hyb', $groupe)])) { |
$this->table_retour[$rang][$groupe] += floatval($tuple['nb']); |
} else { |
$this->table_retour[$rang][$groupe] = floatval($tuple['nb']); |
} |
} |
//-----------------------------Fonctions d'affichage utiliser dans les fonctions de formatage--------------------------- |
public function afficherDonnees($champApi, $valeur) { |
$champBdd = $this->trouverChampBddCorrespondant($champApi); |
if ($this->parametres['retour.format'] == 'min') { |
if ($cle == 'nom_sci') { |
$valeur = $valeur.$this->ajouterCompositionNom($this->resultat_req); |
} |
$this->table_retour[$champBdd] = $valeur; |
} else { |
$this->afficherToutesLesInfos($champBdd, $valeur); |
} |
} |
public function trouverChampBddCorrespondant($champApi) { |
if (array_key_exists($champApi, $this->champs_api)) { |
$champBdd = $this->correspondance_champs[$champApi]; |
} else { |
$champBdd = $champApi; |
} |
return $champBdd; |
} |
public function afficherToutesLesInfos($nom_champ_api, $valeur) { |
if ($this->presentePlusieursId($nom_champ_api, $valeur)) { |
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match); |
$this->afficherInfosPrecises($match[1], 'details', $valeur); |
$this->table_retour[$nom_champ_api] = $valeur; |
} elseif (strrpos($nom_champ_api, 'parent') !== false && strrpos($nom_champ_api, 'notes') !== false) { |
$this->table_retour[$nom_champ_api] = $valeur; |
} elseif (($this->correspondAUnId($nom_champ_api) || $nom_champ_api == 'id' && $valeur != '0')) { |
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match); |
$this->afficherInfosPrecises($match[1], 'id,signification,href', $valeur); |
} elseif ($this->correspondAUnCode($nom_champ_api)) { |
preg_match('/^([^.]+)(?:\.code)?$/', $nom_champ_api, $match); |
$this->afficherInfosPrecises($match[1], 'code,signification,href', $valeur); |
} elseif ($nom_champ_api != 'nom_sci') { |
$this->table_retour[$nom_champ_api] = $valeur; |
} |
} |
public function presentePlusieursId($ressource, $valeur = null) { |
if ($valeur) { |
$presente = strrpos($ressource, 'proparte') !== false && strrpos($valeur, ',') !== false; |
} else { //pour la vérification du champ, on ignore alors la valeur de la ressource |
$presente = strrpos($ressource, 'proparte') !== false; |
} |
return $presente; |
} |
public function afficherInfosPrecises($champ, $suffixe, $valeur) { |
$suffixes = explode(',', $suffixe); |
//on initialise au service appelé. Sera potentiellement modifié dans la fonction afficherSignification() |
$this->service_href = $this->service; |
foreach ($suffixes as $suffixe) { |
switch ($suffixe) { |
case 'id' : |
$this->table_retour[str_replace('id.id', 'id', $champ.'.id')] = $valeur; |
break; |
case 'details' : |
$this->afficherTableDetails($champ, $valeur); |
break; |
case 'signification' : |
$this->afficherSignification($champ, $valeur); |
break; |
case 'href' : |
$url = $this->creerUrl($champ, $valeur); |
$this->table_retour[str_replace('id.href', 'href', $champ.'.href')] = $url; |
break; |
case 'code' : |
$this->table_retour[$champ.'.code'] = $this->obtenirCode($champ, $valeur); |
break; |
case 'notes' : |
$this->table_retour[$champ.'.notes'] = $this->resultat_req[str_replace('.', '_', $champ).'_notes']; |
break; |
default : break; |
} |
} |
} |
public function afficherTableDetails($nom_champ_api, $valeur) { |
$tab_id = explode(',', $valeur); |
$tab_res = $this->table_retour; |
$this->table_retour = array(); |
foreach ($tab_id as $id) { |
$this->afficherInfosPrecises($nom_champ_api, 'id,signification,href', $id); |
$tab_res[$nom_champ_api.'.details'][] = $this->table_retour; |
$this->table_retour = array(); |
} |
$this->table_retour = $tab_res; |
} |
private function obtenirCode($champ, $valeur) { |
$code = $this->transformerChampEnCode($champ); |
return "bdnt.$code:$valeur"; |
} |
private function transformerChampEnCode($champ) { |
if (is_null($this->relationsChampsCodesOntologie)) { |
$this->relationsChampsCodesOntologie = Outils::recupererTableauConfig('ChampsCodesOntologie'); |
} |
$code = $champ; |
if (array_key_exists($champ, $this->relationsChampsCodesOntologie)) { |
$code = $this->relationsChampsCodesOntologie[$champ]; |
} |
return $code; |
} |
public function creerUrl($champ, $valeur) { |
if ($this->correspondAUnId($champ) || $champ == 'id') { |
$service = $this->service_href; |
$url = $this->ajouterHref($service, $valeur); |
} else { |
$code = $this->transformerChampEnCode($champ); |
$url = $this->ajouterHrefAutreProjet('ontologies', "$code:", $valeur, 'bdnt'); |
} |
return $url; |
} |
public function afficherSignification($champ, $valeur) { |
if ($champ == 'id' && isset($this->resultat_req['nom_sci']) && $this->resultat_req['num_nom'] == $valeur) { |
//si le nom_sci du num_nom que l'on veut afficher est déjà dans la table de résultat : |
$this->table_retour['nom_sci'] = $this->resultat_req['nom_sci']. |
$this->ajouterCompositionNom($this->resultat_req); |
} elseif ($this->correspondAUnId($champ) || $champ == 'id') { |
$nom = $this->recupererNomSci($valeur); |
if ($nom != array()) { |
$this->table_retour[$champ] = $nom['nom_sci']; |
$this->service_href = $nom['service']; |
} |
} elseif ($this->correspondAUnCode($champ)) { |
$this->table_retour[$champ] = $this->ajouterSignificationCode($champ, $valeur); |
} |
} |
/** Permet d'afficher les élements nomenclatural du nom_sci lors de l'appel dans le service noms/id/champ du champ^nom_sci.*/ |
public function afficherNomSciPointEpithete($resultat) { |
$tab_nom_sci = array('nom_supra_generique', 'genre', 'epithete_infra_generique', 'epithete_sp', |
'type_epithete', 'epithete_infra_sp', 'cultivar_groupe', 'cultivar', 'nom_commercial'); |
foreach ($tab_nom_sci as $compo_nom) { |
if (isset($resultat[$compo_nom]) && !empty($resultat[$compo_nom])) { |
$this->table_retour['nom_sci.'.$compo_nom] = $resultat[$compo_nom]; |
} |
} |
} |
public function ajouterSignificationCode($champ, $valeur) { |
$champ = ($champ == 'rang') ? 'rangTaxo' : rtrim($champ, '_Co,_Ga'); |
if (preg_match('/^([^_-]+)(?:_|-)([^_-]+)$/', $champ, $match)) { |
$champ = $match[1].ucfirst($match[2]); |
} |
$url = Config::get('url_ontologie').$champ.':'.$valeur.'/nom'; |
$res = $this->consulterHref($url); //dans commun.php |
$nom_code = $valeur; |
if (is_object($res)) { |
$nom_code = $res->nom; |
} |
return $nom_code; |
} |
public function recupererNomSci($id) { |
$nom = array(); |
if ($id != 0) { |
if ($this->compo_nom == null) { |
$req = 'SELECT nom_sci, num_nom_retenu FROM '.$this->table.' WHERE num_nom = '.$id; |
} else { //on ajoute à la requete sql, les champs de ns.structure |
//print_r($this->compo_nom); |
$req = 'SELECT nom_sci, num_nom_retenu, '.implode(', ', $this->compo_nom) |
.' FROM '.$this->table |
.' WHERE num_nom = '.$id; |
} |
if ($this->parametres['ns.format'] == 'htm') { |
$req = str_replace('nom_sci', 'nom_sci_html as nom_sci', $req); |
} |
$res = $this->getBdd()->recuperer($req); |
if ($res) { |
$nom['nom_sci'] = $res['nom_sci'].$this->ajouterCompositionNom($res); |
$nom['service'] = ($res['num_nom_retenu'] == $id && $this->service == 'taxons') ? 'taxons' : 'noms'; |
} |
} |
return $nom; |
} |
/** Permet de retourner une chaine de caractère composée des parametres du nom (ns.structure : annnée, auteur, |
* bibilio et addendum). A ajouter au nom scientifique */ |
public function ajouterCompositionNom($tab_res) { |
$nom = ''; |
if (isset($this->compo_nom)) { |
$compo_nom = null; |
$nom_complet = null; |
if ($this->parametres['ns.format'] == 'htm') { |
$format = array( |
'au' => '<span class="auteur">%s</span>', |
'an' => '[<span class="annee">%s</span>]', |
'an_bib' => '[<span class="annee">%s</span>, <span class="biblio">%s</span>]', |
'bib' => '[<span class="biblio">%s</span>]', |
'ad' => '[<span class="adendum">%s</span>]'); |
} else { |
$format = array( |
'au' => '%s', |
'an' => '[%s]', |
'an_bib' => '[%s, %s]', |
'bib' => '[%s]', |
'ad' => '[%s]'); |
} |
foreach ($this->compo_nom as $key => $champ) { |
if (isset($tab_res[$champ]) && !empty($tab_res[$champ])) { |
$compo_nom[$key] = $tab_res[$champ]; |
} |
} |
$this->formerNomComplet($compo_nom, $nom_complet, $format); |
$nom = ' '.implode(' ', $nom_complet); |
} |
return rtrim($nom, ' '); |
} |
public function formerNomComplet(&$compo_nom, &$nom_complet, $format) { |
extract($compo_nom); |
if (isset($au)) $nom_complet[] = sprintf($format['au'], $au); |
if (isset($an)) { |
if (isset($bib)) { |
$nom_complet[] = sprintf($format['an_bib'], $an, $bib); |
} else { |
$nom_complet[] = sprintf($format['an'], $an); |
} |
} elseif (isset($bib)) { |
$nom_complet[] = sprintf($format['bib'], $bib); |
} |
if (isset($ad)) $nom_complet[] = sprintf($format['ad'], $ad); |
return $nom_complet; |
} |
public function correspondAUnCode($key) { |
return (strrpos($key, '.code') !== false) || (in_array($key.'.code', $this->correspondance_champs)); |
} |
public function correspondAUnId($key) { |
return (strrpos($key, '.id') !== false) || (in_array($key.'.id', $this->correspondance_champs)); |
} |
public function estUnPoint($key) { |
if (strrpos($key, 'hybride.parent') !== false) { |
$key = str_replace('hybride.parent', 'hybride_parent', $key); |
} |
return (strrpos($key, '.') !== false); |
} |
public function recupererMasquePrincipal() { |
$masque = null; |
$tab_masque = array( |
'masque' => 'nom_sci', |
'masque_sg' => 'nom_supra_generique', |
'masque_gen' => 'genre', |
'masque_sp' => 'epithete_sp', |
'masque_ssp' => 'epithete_infra_sp', |
'masque_au' => 'auteur', |
'masque_an' => 'annee', |
'masque_bib' => 'biblio_origine', |
'masque_ad' => 'addendum', |
'masque_rg' => 'rang'); |
$liste_masque = array(); |
if (isset($this->masque['num_nom'])) { |
$liste_masque[] = $this->masque['num_nom']; |
} |
foreach ($tab_masque as $key => $filtre) { |
if (isset($this->masque[$filtre])) { |
if (!isset($masque) && !in_array($filtre, array('rang', 'annee'))) { |
$masque = array($key, $filtre); |
} |
$liste_masque[] = $this->masque[$filtre]; |
} |
} |
$this->masque = $liste_masque; |
return $masque; |
} |
} |
?> |
/trunk/services/modules/0.1/Projets.php |
---|
New file |
0,0 → 1,238 |
<?php |
/** |
* Description : |
* Classe principale de chargement des services d'eFlore. |
* |
* Encodage en entrée : utf8 |
* Encodage en sortie : utf8 |
* @package eflore-projets |
* @author Jennifer DHÉ <jennifer.dhe@tela-botanica.org> |
* @author Delphine CAUQUIL <delphine@tela-botanica.org> |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 0.1 |
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
*/ |
class Projets extends RestService { |
/** Contients les paramètres.*/ |
private $parametres = array(); |
/** Contients les ressources.*/ |
private $ressources = array(); |
/** Contients les erreurs HTTP levées par le service.*/ |
private $erreursHttp = array(); |
/** Nom du projet courrant. */ |
private $projetNom = array(); |
/** Nom du service demandé. */ |
private $serviceNom = array(); |
/** Chemin vers le dossier courrant. */ |
private $cheminCourrant = null; |
/** Indique si oui (true) ou non (false), on veut utiliser les paramètres brutes. */ |
protected $utilisationParametresBruts = true; |
public function __construct() { |
$this->cheminCourrant = dirname(__FILE__).DS; |
} |
public function consulter($ressources, $parametres) { |
$resultat = ''; |
try { |
$this->initialiserRessourcesEtParametres($ressources, $parametres); |
$resultat = $this->traiterRessources(); |
} catch (Exception $e) { |
$this->ajouterErreurHttp($e->getCode(), $e->getMessage()); |
} |
$corps = $this->genererReponseHttp($resultat); |
return $corps; |
} |
private function initialiserRessourcesEtParametres($ressources, $parametres) { |
$this->ressources = $ressources; |
$this->parametres = $parametres; |
} |
private function traiterRessources() { |
$retour = ''; |
if ($this->avoirRessources()) { |
if ($this->avoirRessourceProjet()) { |
$this->initialiserProjet(); |
if ($this->avoirRessourceService()) { |
$retour = $this->initialiserService(); |
} |
} |
} |
return $retour; |
} |
private function avoirRessources() { |
$presenceDeRessources = false; |
if (isset($this->ressources) && count($this->ressources) > 0) { |
$presenceDeRessources = true; |
} else { |
$message = "Aucune ressource n'a été indiquée.\n". |
"Veuillez indiquer au moins un code de projet et un type de service."; |
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
throw new Exception($message, $code); |
} |
return $presenceDeRessources; |
} |
private function avoirRessourceProjet() { |
$presenceRessourceProjet = false; |
$projet = $this->ressources[0]; |
$projetsDispo = Outils::recupererTableauConfig('projetsDispo'); |
if (in_array($projet, $projetsDispo)) { |
$presenceRessourceProjet = true; |
} else { |
$message = "La ressource '$projet' n'indique pas un projet existant.\n". |
"Les projets existant sont :\n".implode(', ', $projetsDispo); |
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
throw new Exception($message, $code); |
} |
return $presenceRessourceProjet; |
} |
private function initialiserProjet() { |
$this->chargerNomDuProjet(); |
$this->chargerConfigProjet(); |
// Enregistrement en première position des autoload de la méthode gérant les classes des services |
spl_autoload_register(array($this, 'chargerClasseProjet'), true , true); |
} |
private function chargerNomDuProjet() { |
$this->projetNom = $this->ressources[0]; |
} |
private function chargerConfigProjet() { |
$projet = $this->projetNom; |
$chemin = Config::get('chemin_configurations')."config_$projet.ini"; |
Config::charger($chemin); |
} |
private function chargerClasseProjet($classe) { |
if (class_exists($classe)) { |
return null; |
} |
$chemins = array(); |
$chemins[] = $this->cheminCourrant.$this->projetNom.DS; |
$chemins[] = $this->cheminCourrant.'commun'.DS; |
$chemins[] = Config::get('chemin_bibliotheque'); |
foreach ($chemins as $chemin) { |
$chemin = $chemin.$classe.'.php'; |
if (file_exists($chemin)) { |
require_once $chemin; |
} |
} |
} |
private function avoirRessourceService() { |
$presenceRessourceService = false; |
$servicesDispo = Outils::recupererTableauConfig('servicesDispo'); |
$service = $this->ressources[1]; |
if (in_array($service, $servicesDispo)) { |
$presenceRessourceService = true; |
} else { |
$message = "La service demandé '$service' n'est pas disponible pour le projet {$this->projetNom} !\n". |
"Les services disponibles sont : ".implode(', ', $servicesDispo); |
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
throw new Exception($message, $code); |
} |
return $presenceRessourceService; |
} |
private function initialiserService() { |
$this->chargerNomDuService(); |
$classe = $this->obtenirNomClasse($this->serviceNom); |
$chemins = array(); |
$chemins[] = $this->cheminCourrant.$this->projetNom.DS.$classe.'.php'; |
$chemins[] = $this->cheminCourrant.'commun'.DS.$classe.'.php'; |
$retour = ''; |
$service = null; |
foreach ($chemins as $chemin) { |
if (file_exists($chemin)) { |
$service = new $classe($this->getBdd()); |
$ressourcesPourService = $this->filtrerRessourcesPourService(); |
$retour = $service->consulter($ressourcesPourService, $this->parametres); |
} |
} |
if (is_null($service)) { |
$message = "La service demandé '{$this->serviceNom}' n'existe pas dans le projet {$this->projetNom} !"; |
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
throw new Exception($message, $code); |
} |
return $retour; |
} |
private function chargerNomDuService() { |
$this->serviceNom = $this->ressources[1]; |
} |
private function obtenirNomClasse($mot) { |
$classeNom = str_replace(' ', '', ucwords(strtolower(str_replace('-', ' ', $mot)))); |
return $classeNom; |
} |
private function filtrerRessourcesPourService() { |
$ressourcesPourService = array(); |
$nbreDeRessources = count($this->ressources); |
for ($i = 2; $i < $nbreDeRessources; $i++) { |
$ressourcesPourService[] = $this->ressources[$i]; |
} |
return $ressourcesPourService; |
} |
private function ajouterErreurHttp($entete, $message) { |
$this->erreursHttp[] = array('entete' => $entete, 'message' => $message); |
} |
private function etreEnErreurHttp() { |
$enErreur = false; |
if (count($this->erreursHttp) > 0) { |
$enErreur = true; |
} |
return $enErreur; |
} |
private function genererReponseHttp($resultat) { |
$this->genererEnteteHttp(); |
$corps = $this->genererCorpsHttp($resultat); |
return $corps; |
} |
private function genererEnteteHttp($mime = 'application/json', $encodage= 'utf-8') { |
// Si aucune erreur n'a été établie (donc un tableau de résultat a bien ete renvoyé...) |
if ($this->etreEnErreurHttp()) { |
$this->emettreEntete($this->erreursHttp[0]['entete'], 'text/html', $encodage); |
} else { |
$this->emettreEntete(RestServeur::HTTP_CODE_OK, $mime, $encodage); |
} |
} |
private function emettreEntete($entete, $mime, $encodage) { |
// Gestion du type de contenu |
if (!is_null($mime) && !is_null($encodage)) { |
header("Content-Type: $mime; charset=$encodage"); |
} else if (!is_null($mime) && is_null($encodage)) { |
header("Content-Type: $mime"); |
} |
// Envoie de l'entête |
RestServeur::envoyerEnteteStatutHttp($entete); |
} |
private function genererCorpsHttp($resultats) { |
$corps = ''; |
if ($this->etreEnErreurHttp()) { |
$corps = $this->erreursHttp[0]['message']; |
} else { |
$corps = json_encode($resultats); |
} |
return $corps; |
} |
} |
?> |
/trunk/services/modules/0.1/commun/Commun.php |
---|
New file |
0,0 → 1,417 |
<?php |
/** |
* Classe Commun.php est une classe abstraite qui contient les méthodes de base communes à tous les |
* sous-services des projets. |
* |
* Encodage en entrée : utf8 |
* Encodage en sortie : utf8 |
* @package eflore-projets |
* @author Jennifer DHÉ <jennifer.dhe@tela-botanica.org> |
* @author Delphine CAUQUIL <delphine@tela-botanica.org> |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 1.0 |
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
*/ |
abstract class Commun { |
/** Objet Bdd. */ |
private $Bdd = null; |
/** Objet Rest Client. */ |
private $RestClient = null; |
/** Contients les paramètres. Doit remplacer table_param. */ |
protected $parametres = array(); |
/** Contients les ressources. Doit remplacer table_ressources. */ |
protected $ressources = array(); |
/** Le nom du service courrant. */ |
protected $serviceNom = null; |
//Classe commune à tous les services web d'un projet. Contient par exemple les fonctions permettant de |
//renvoyer la réponse http... |
protected $entete_http; // Entete de la réponse correspondant au code de réponse de la requete http */ |
protected $corps_http; // Tableau de résultat à retourner au format json ou la description de l'erreur si elle existe */ |
protected $service; // Nom du service appelé |
/** Stocke la version du projet demandée dans la requete |
* - "*" : (/#projet/* /meta-donnees) Renvoi les meta-données de toutes les versions du projet |
* - "numero de la version" : (/#projet/2.00/meta-donnees) Renvoi les meta-données de la version 2.00 du projet */ |
protected $version_projet = '+'; |
protected $table_version; //Stocke les noms des tables de toutes les versions du projet disponibles |
/** tableau contenant tous les champs d'une table (est rempli par la fonction Commun::recupererNomChamp($table)) */ |
protected $champs_table = array(); |
private static $tri_multi_dimension = array(); |
private static $tri_type = ''; |
public function consulter($ressources, $parametres) { |
$this->ressources = $ressources; |
$this->parametres = $parametres; |
$this->chargerNomDuService(); |
$this->traiterParametres(); |
$this->traiterVersionProjet(); |
$resultats = ''; |
foreach ($this->table_version as $version) { |
$this->table = $version; //on stocke le nom de la table correspondant à la version du projet en cours |
$this->recupererNomChamp($this->table); //on récupère les noms des champs disponibles (Ds Commun.php) |
$this->traiterRessources(); //dans CommunNomsTaxons.php |
$requete = $this->assemblerLaRequete(); |
$resultat = $this->getBdd()->recupererTous($requete); |
$versionResultat = $this->traiterResultat($resultat, $version, $requete); |
if (count($this->table_version) > 1) { |
$resultats[$version] = $versionResultat; |
} else { |
$resultats = $versionResultat; |
} |
} |
return $resultats; |
} |
private function chargerNomDuService() { |
$this->serviceNom = get_class($this); |
} |
public function traiterResultat($resultat, $version, $requete) { |
$versionResultat = null; |
if ($resultat == '') { |
//cas ou la requete comporte des erreurs |
$message = 'La requête SQL formée comporte une erreur!'; |
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
throw new Exception($message, $code); |
} elseif ($resultat) { |
$versionResultat = $this->retournerResultatFormate($resultat, $version); |
} else { |
$message = 'Les données recherchées sont introuvables.'; |
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
throw new Exception($message, $code); |
} |
return $versionResultat; |
} |
//+------------------------------------------------------------------------------------------------------+ |
// Méthodes concernant les paramètres |
/** |
* Permet de récupérer une liste des noms des champs de la table passée en paramètre |
* @param $table : Nom de la table dont on souhaite connaitre les champs |
*/ |
public function recupererNomChamp($table) { |
$requete = 'SHOW FIELDS FROM '.$table; |
$resultat = $this->getBdd()->recupererTous($requete); |
if ($resultat == '') { |
$e = 'La requête SQL formée comporte une erreur!'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
} elseif ($resultat) { |
foreach ($resultat as $info) { |
$this->champs_table[] = $info['Field']; |
} |
} else { |
$m = "La table recherchée n'existe pas"; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $m); |
} |
} |
/** |
* Fonction permettant de creer la table dont le nom est passé en paramètre (champs_api, champs_bdtfx, |
* correspondance_champs...). Les données de chaque table sont présentes dans le fichier de configuration config.ini |
* @param String $table : Peut contenir plusieurs nom de table dont on souhaite récupérer les données : table,table,table. |
* Ex : recupererTableConfig('champs_api,champs_bdtfx') |
*/ |
public function recupererTableConfig($table) { |
$tables = explode(',', $table); |
foreach ($tables as $tab) { |
$tableau = explode(',', Config::get($tab)); |
$tableau = array_map('trim', $tableau); |
foreach ($tableau as $champ) { |
list($code, $rang) = explode('=', $champ); |
$tab_tampon[$code] = $rang; |
} |
$this->$tab = $tab_tampon; |
$tab_tampon = array(); |
} |
} |
public function renvoyerErreur($entete, $message) { |
throw new Exception($message, $entete); |
} |
/** |
* Permet de remplir la variable version_projet et de retirer cette donnée du tableau des ressources |
* @param $ressources |
*/ |
public function traiterVersionProjet() { |
if (isset($this->parametres['version'])) { |
if (preg_match('/(?:v[0-9]+(?:(?:_|[.])[0-9]+)?|[*])/', $this->parametres['version'])) { |
$this->version_projet = $this->parametres['version']; |
$this->version_projet = str_replace('.', '_', $this->version_projet); |
} else { |
$this->version_projet = '+'; |
} |
} |
//si la liste des noms est demandée pr toutes les versions, on affiche seulement la dernière version : |
if ($this->version_projet == '*' && $this->ressources == array()) { |
$this->version_projet = '+'; |
} |
//on recupère les versions du projet disponible dans la table des meta-donnees (utilisation service MetaDonnees) |
$table_num_version = $this->recupererVersionDisponible(); |
//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 |
$this->recupererListeNomTablePrChaqueVersion($table_num_version); |
} |
/** |
* Recupération des versions disponibles par appel du service metaDonnees |
* Verification de l'existance du service recherché dans la requete (si précisé : hors *) |
* @return array : tableau contenant le numéro de chaque version disponible |
*/ |
public function recupererVersionDisponible() { |
$versions_dispo = ''; |
$req_version = 'SELECT version FROM '.Config::get('bdd_table_meta'); |
$res_version = $this->getBdd()->recupererTous($req_version); |
if ($res_version == '') { //cas ou la requete comporte des erreurs |
$e = "La requête SQL de versionnage formée comporte une erreur : $req_version"; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
} elseif ($res_version) { |
foreach ($res_version as $version) { |
$versions_dispo[] = $version['version']; |
} |
} else { |
$m = 'Versions introuvables dans la table des méta-données'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $m); |
} |
return $versions_dispo; |
} |
public function recupererListeNomTablePrChaqueVersion($table_num_version) { |
switch ($this->serviceNom) { |
case 'Ontologies' : |
$prefixe_table = 'bdd_table_ontologies'; |
break; |
default: |
$prefixe_table = 'bdd_table'; |
} |
switch ($this->version_projet) { |
case '+' : |
$derniere_version = $table_num_version[count($table_num_version) - 1]; |
$this->table_version[] = Config::get($prefixe_table).'_v'.str_replace('.', '_', $derniere_version); |
break; |
case '*' : |
foreach ($table_num_version as $num_version) { |
$this->table_version[] = Config::get($prefixe_table).'_v'.str_replace('.', '_', $num_version); |
} |
break; |
default : |
$this->table_version[] = Config::get($prefixe_table).'_'.$this->version_projet; |
break; |
} |
} |
/** |
* Est appelée pour former l'url complete des resultats precedants ou suivants. |
* @param int : Permet de connaitre le nombre de noms obtenus par la requete |
* @return string Retourne l'url complete des resultats precedents ou suivant sous la forme d'un tableau |
*/ |
public function formulerUrl($nb_resultat, $id = null) { |
$url = array(); |
$debut_url = Config::get('url_service').$id.'?'; |
//on recré l'url sans les parametres de navigation qui seront rajouter ci-apres. On les enlève dc de la table des parametres |
foreach($this->parametres as $cle => $val) { |
$param_url[str_replace('_', '.', $cle)] = $val; |
} |
$this->recupererLesLimitesSuivantes($nb_resultat, $param_url); |
if (isset($param_url['navigation.depart']) && isset($param_url['navigation.limite'])) { |
$url['suivant'] = $debut_url.http_build_query($param_url); |
} |
$this->recupererLesLimitesPrecedentes($param_url); |
if (isset($param_url['navigation.depart']) && isset($param_url['navigation.limite'])) { |
$url['precedent'] = $debut_url.http_build_query($param_url); |
} |
return $url; |
} |
public function supprimerNavigation(&$param_url) { |
unset($param_url['navigation.depart']); |
unset($param_url['navigation.limite']); |
} |
/** |
* Description : |
* Permet de former les limites de la requete retournant les résultats suivants. |
* Cette url sera afficher dans l'entete de la reponse retournée en format JSON (retour.format=defaut). |
* @param int : $nb_resultat : Permet de connaitre le nombre de résultats obtenus par la requete |
* @return string : la fin de l'url decrivant les limites des resultats suivants. Si aucun résultats ne suient, |
* une chaine de caractère vide est retournée |
*/ |
public function recupererLesLimitesSuivantes($nb_resultat, &$param_url_suiv) { |
$this->supprimerNavigation($param_url); |
$depart = $this->limite_requete['depart']; |
$limite = $this->limite_requete['limite']; |
$depart_suivant = $depart + $limite; |
$limite_suivant = $limite; |
if ($nb_resultat > $depart_suivant) { |
$param_url_suiv['navigation.depart'] = $depart_suivant; |
$param_url_suiv['navigation.limite'] = $limite_suivant; |
} else { |
$param_url_suiv['navigation.depart'] = null; |
$param_url_suiv['navigation.limite'] = null; |
} |
} |
/** |
* Description : |
* Permet de former les limites de la requete retournant les résultats precedents. |
* Cette url sera afficher dans l'entete de la taxons/105reponse retournée en format JSON (retour.format=defaut) |
* @return string : la fin de l'url decrivant les limites des resultats precedents. |
* Si aucun résultats ne precedent, une chaine de caractère vide est retournée |
*/ |
public function recupererLesLimitesPrecedentes(&$param_url) { |
$this->supprimerNavigation($param_url); |
$depart = $this->limite_requete['depart']; |
$limite = $this->limite_requete['limite']; |
if ($depart == 0) { |
$url_precedente = ''; |
} else { |
if (($depart - $limite) < 0) { |
$depart_precedent = 0; |
} else { |
$depart_precedent = $depart - $limite; |
} |
$param_url['navigation.depart'] = $depart_precedent; |
$param_url['navigation.limite'] = $limite; |
} |
} |
public function ajouterHref($service, $val) { |
// http://tela-botanica.org/service:eflore:0.1/[projet]/[version_projet]/[service]/[ressource]:[valeur] |
if ($this->version_projet == '+') { |
$url = Config::get('url_service_base').Config::get('nom_projet').'/'.$service.'/'.$val; |
} else { |
$url = Config::get('url_service_base').Config::get('nom_projet').'/'.$this->version_projet.'/'.$service.'/'.$val; |
} |
return $url; |
} |
public function ajouterHrefAutreProjet($service, $ressource, $valeur, $projet = null, $param = null) { |
//on enleve les GA et Co, les meta ou les "_" |
$this->transliterer($service, $valeur); |
//on définit les nom des projets, des services et des ressources de l'url (dans les méta-donnees) |
$tab = array( |
'langue' => array('service' => 'langues', 'projet' => 'iso-639-1', 'ressource' => ''), |
'couverture_spatiale' => array('service' => 'zone-geo', 'projet' => 'iso-3166-1', 'ressource' => ''), |
'type' => array('service' => 'ontologies', 'projet' => 'commun', 'ressource' => 'contactType:'), |
'datum' => array('service' => 'ontologies', 'projet' => 'commun', 'ressource' => 'datum:') |
); |
if (array_key_exists($service, $tab)) { |
extract($tab[$service]); |
} else { |
if (strpos(Config::get('nom_projet'), 'bd') === 0 && $projet == null) { |
$projet = 'bdnt'; |
$service = 'ontologies'; |
$ressource = ''; |
} |
} |
$param = ($param) ? "?$param" : ""; |
$url = Config::get('url_service_base').$projet.'/'.$service.'/'.$ressource.$valeur.$param; |
return $url; |
} |
/**Permet de consulter une url et retourne le résultat ou une erreur |
* @param $url */ |
public function consulterHref($url) { |
$res = $this->getRestClient()->consulter($url); |
$entete = $this->getRestClient()->getReponseEntetes(); |
//Si le service meta-donnees fonctionne correctement, l'entete comprend la clé wrapper_data |
if (isset($entete['wrapper_data'])) { |
$res = json_decode($res); |
return $res; |
} else { |
$u = 'L\'url <a href="'.$url.'">'.$url.'</a> lancée via RestClient renvoie une erreur'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $u); |
} |
} |
public function transliterer(&$service, &$val) { |
if (preg_match('/^.+:(.+)$/', $val, $match)) { |
$val = $match[1]; |
} |
$service = str_replace(array('_Ga','_Co','_meta'), '', $service); |
if ($service == 'rang') { |
$ressource = 'rangTaxo'; |
} elseif (preg_match('/^(statut)(?:_|-)([^_-]+)$/', $service, $match)) { |
$service = $match[1].ucfirst($match[2]); |
} elseif (strrpos($service, 'datum') !== false) { |
$service = 'datum'; |
} |
} |
// prend en valeur la valeur de la recherche, les résultats approchés, le paramétre recherche |
// retourne le tableau trié en fonction de la ressemble entre le résultat approché et la valeur recherchée |
public function trierRechercheFloue($nom_demande, $tab_approchee, $nom) { |
$trie = ''; |
$resultat = array(); |
foreach ($tab_approchee as $id => $tab) { |
$nom_demande_ss = strtolower(Chaine::supprimerAccents($nom_demande)); |
$nom_flou_ss = strtolower(Chaine::supprimerAccents($tab[$nom])); |
$stat = array(); |
// Prime pour la ressemblance globale : |
$score = 500 - levenshtein($nom_flou_ss, $nom_demande_ss); |
// On affine |
$score = $score + (similar_text($nom_demande_ss, $nom_flou_ss) * 3); |
$stat['score'] = $score; |
foreach ($tab as $key => $valeur) { |
$stat[$key] = $valeur; |
} |
$resultat[] = $stat; |
} |
// Vérification que nous avons bien trouvé un nom approché |
if (count($resultat) > 0) { |
$trie = Tableau::trierMD($resultat, array('score' => SORT_DESC)); |
} |
return $trie; |
} |
protected function recupererTableauConfig($param) { |
$tableau = array(); |
$tableauPartiel = explode(',', Config::get($param)); |
$tableauPartiel = array_map('trim', $tableauPartiel); |
foreach ($tableauPartiel as $champ) { |
if (strpos($champ, '=') === false) { |
$tableau[] = $champ; |
} else { |
list($cle, $val) = explode('=', $champ); |
$tableau[$cle] = $val; |
} |
} |
return $tableau; |
} |
//+------------------------------------------------------------------------------------------------------+ |
// Méthodes d'accès aux objets du Framework |
/** |
* Méthode de connection à la base de données sur demande. |
* Tous les services web n'ont pas besoin de s'y connecter. |
*/ |
protected function getBdd() { |
if (! isset($this->Bdd)) { |
$this->Bdd = new Bdd(); |
} |
return $this->Bdd; |
} |
/** |
* Méthode permettant de faire appel à un client REST en fonction des besoins du service. |
*/ |
protected function getRestClient() { |
if (! isset($this->RestClient)) { |
$this->RestClient = new RestClient(); |
} |
return $this->RestClient; |
} |
} |
?> |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/trunk/services/modules/0.1/commun/Aide.php |
---|
New file |
0,0 → 1,233 |
<?php |
/** |
* Description : |
* Classe Aide.php fournit des informations sur les services des projets : leur état (up ou down), une description, |
* le lien vers le wikini |
* La ressource /projets donne la liste de tous les projets concernés par cette api. |
* |
* Encodage en entrée : utf8 |
* Encodage en sortie : utf8 |
* @package framework-v3 |
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org> |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 1.0 |
* @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org) |
*/ |
class Aide extends RestService { |
protected $retour_format = 'max'; |
protected $url_wikini = 'http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki='; |
protected $url_liste_projet = ''; |
protected $table_retour = array(); |
protected $corps_http = ''; |
protected $entete_http = ''; |
protected $projet = ''; |
public function consulter($ressources, $parametres) { |
$this->url_liste_projet = Config::get('url_service_base').'commun/aide/projets'; |
$this->projet = Config::get('nom_projet'); |
$this->traiterRessources($ressources); |
return $this->formerReponseHTTP(json_encode($this->table_retour)); |
} |
//-----------------------------------------traiter reponse http------------------------------------------------------------- |
public function formerReponseHTTP($resultat_formate, $mime = 'application/json', $encodage= 'utf-8') { |
// Si aucune erreur n'a été établie (donc un tableau de résultat a bien ete renvoyé...) |
if ($this->corps_http == '' && $this->entete_http == '') { |
$this->entete_http = RestServeur::HTTP_CODE_OK; |
$this->corps_http = $resultat_formate; |
} |
if ($this->entete_http != RestServeur::HTTP_CODE_OK) { |
$mime = 'text/html'; |
} |
// Gestion du type de contenu |
if (!is_null($mime) && !is_null($encodage)) { |
header("Content-Type: $mime; charset=$encodage"); |
} else if (!is_null($mime) && is_null($encodage)) { |
header("Content-Type: $mime"); |
} |
// Envoie de l'entête |
RestServeur::envoyerEnteteStatutHttp($this->entete_http); |
// Envoie du corps |
echo $this->corps_http; |
} |
public function renvoyerErreur($e, $c) { |
$this->entete_http = $e; |
$this->corps_http = $c; |
} |
//---------------------------------traiter Ressources------------------------------------------------------------------ |
public function traiterRessources($ressources) { |
if (isset($ressources) && !empty($ressources)) { |
//-----------------------service /aide/projets------------------------------------ |
if ($ressources[0] == 'projets') { |
$this->afficherInfosTousProjets(); |
} else { |
$r = 'Erreur dans votre requête </br> Ressources disponibles : |
<br/><li> /aide </li><li> /aide/projets </li>'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r); |
} |
} else { |
//-----------------------service /aide------------------------------------ |
$this->afficherInfosProjet(); |
$this->formaterAideListeProjetEtRessources(); |
} |
} |
public function afficherInfosTousProjets() { |
$req = 'show tables'; |
$tables = $this->getBdd()->recupererTous($req); |
foreach ($tables as $table) { |
if (preg_match('/^(.+)_meta$/', array_shift($table), $projet)) { |
if (isset($projet[1])) { |
$projets[] = $projet[1]; |
} else { |
$e = "erreur."; |
trigger_error($e, E_USER_ERROR); |
} |
} |
} |
foreach ($projets as $projet) { |
$this->table_retour[$projet] = $this->recupererInfoProjet($projet); |
} |
} |
public function recupererInfoProjet($projet) { |
$res_return = null; |
$projet = str_replace('_', '-', $projet); |
$url = Config::get('url_service_base').$projet.'/aide'; |
$intitule = 'PROJET '.strtoupper($projet); |
$res = $this->consulterHref($url); |
//$res = $this->rest_client->consulter($url); |
//$entete = $this->rest_client->getReponseEntetes(); |
if ($res) { |
$res_return = $res->$intitule; |
} |
/* if (isset($entete['wrapper_data']) && $res != '') { |
$res = json_decode($res); |
if (!is_object($res)) print_r($res); |
else $res_return = $res->$intitule; |
} else { |
$e = 'Le service aide du projet '.$projet.' ne fonctionne pas et renvoie comme entête : '.$entete.' et comme résultat : '.$res; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
}*/ |
return $res_return; |
} |
public function formaterAideListeProjetEtRessources() { |
$projets = 'LISTE DES PROJETS'; |
$services = 'Ressources'; |
$this->table_retour[$projets]['liste des projets en place']['href'] = $this->url_liste_projet; |
$this->table_retour[$projets]['liste de tous les projets']['wikini'] = $this->url_wikini.'EfloreIntegrationProjets'; |
} |
public function afficherInfosProjet() { |
$res = array(); |
$ressources = $this->recupererListeDesRessources(); |
if (isset($ressources['href']) && $ressources['href'] != '') { |
$this->table_retour['PROJET '.strtoupper($this->projet)]['projet.href'] = $ressources['href']; |
} |
$etats = $this->verifierEtatDesRessources($ressources['WS']); |
$this->table_retour['PROJET '.strtoupper($this->projet)]['projet.services'] = $etats['projet.services']; |
} |
public function recupererListeDesRessources() { |
$resultat = null; |
$req = 'SELECT url_projet, version, web_services FROM '.Config::get('bdd_table_meta').' ORDER BY CAST(version as DECIMAL)'; |
$res = $this->getBdd()->recuperer($req); |
if ($res == '') { |
$r = 'La requête SQL formée comporte une erreur !!'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r); |
Debug::printr($req); |
} elseif ($res) { |
$resultat['WS'] = $res['web_services']; |
$resultat['href'] = $res['url_projet']; |
} else { |
$d = 'Les données recherchées sont introuvables dans la version '.$res[0]['version'].'de la table de méta données'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $d); |
Debug::printr($req); |
} |
return $resultat; |
} |
public function verifierEtatDesRessources($ressources) { |
$ressources = explode(';', $ressources); |
$etats = array(); |
foreach ($ressources as $key => $ressApi) { |
list($ress, $api) = explode(':', $ressApi); |
$this->translitererRess($ress); |
$url = Config::get('url_service').'/'.$ress; |
$wikini = $this->url_wikini.'EfloreApi'.$api.$this->creerChaMot($ress); |
$url_service = Config::get('url_service').'/'.$ress; |
$etat = array( |
'service.nom' => $ress, |
'service.href' => $url_service, |
'service.wikini' => $wikini, |
'service.etat' => 'UP'); |
$res = $this->consulterHref($url); |
if (!$res) { |
$etat['service.etat'] = 'DOWN ('.$reponse[0].')'; |
} |
$etats['projet.services'][] = $etat; |
} |
return $etats; |
} |
/**Permet de consulter une url et retourne le résultat ou une erreur |
* @param $url */ |
public function consulterHref($url) { |
$res = $this->getRestClient()->consulter($url); |
$entete = $this->getRestClient()->getReponseEntetes(); |
//Si le service meta-donnees fonctionne correctement, l'entete comprend la clé wrapper_data |
if (isset($entete['wrapper_data'])) { |
$res = json_decode($res); |
return $res; |
} else { |
$u = 'L\'url <a href="'.$url.'">'.$url.'</a> lancée via RestClient renvoie une erreur'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $u); |
} |
} |
public function translitererRess(&$ress) { |
$ress = strtolower($ress); |
if ($ress == 'metadonnees') { |
$ress = 'meta-donnees'; |
} |
} |
public function creerChaMot($nom) { |
$chaine = new Chaine(); |
$nom = $chaine->supprimerAccents($nom); |
$nom_modif = ''; |
$nom_dec = preg_split('/-/', $nom); |
foreach ($nom_dec as $dec) { |
$nom_modif .= ucfirst($dec); |
} |
return trim($nom_modif); |
} |
} |
?> |
/trunk/services/modules/0.1/commun/MetaDonnees.php |
---|
New file |
0,0 → 1,507 |
<?php |
/** |
* Description : |
* Classe MetaDonnees.php fournit des informations sur le projet. |
* Le but étant de fournir un ensemble minimal d'information comprenant : |
* la version, la langue, le nom, le créateur et l'éditeur du projet. |
* Si l'url finit par /meta-donnees on retourne une liste de termes (seulement les 100 premières par défaut). |
* L'url peut contenir des paramètres optionnels passés après le ? : /meta-donnees?param1=val1¶m2=val2&... |
* |
* Les paramètres de requête disponibles sont : masque, , recherche, |
* distinct, retour.format, navigation.depart et navigation.limite. |
* |
* Encodage en entrée : utf8 |
* Encodage en sortie : utf8 |
* @package framework-v3 |
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org> |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 1.0 |
* @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org) |
*/ |
class MetaDonnees extends Commun { |
protected $requete_champ = '*'; |
protected $requete_condition = null; |
protected $retour_format = 'max'; |
protected $table_retour = array(); |
protected $format_reponse = 'metaDonnees'; |
protected $table_ressources; |
public function consulter($ressources, $parametres) { |
$this->service = 'meta-donnees'; |
$resultat_formate = ''; |
// on traite en premier la version dans le cas ou un langage est demandé pr une version |
$this->traiterRessourceVersion($ressources); |
$this->traiterParametres($parametres); |
$this->traiterRessources($ressources); |
if ($this->corps_http == '' && $this->entete_http == '') { |
$requete_meta = $this->assemblerLaRequete(); |
$resultat_meta = $this->getBdd()->recupererTous($requete_meta); |
$resultat_formate = $this->testerResultat($resultat_meta, $requete_meta); |
} |
return $this->formerReponseHTTP($resultat_formate); |
} |
public function testerResultat($resultat_meta, $requete_meta) { |
if ($resultat_meta == '') { |
$e = 'La requête formée comporte une erreur!'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,$e); |
Debug::printr($requete); |
} elseif ($resultat_meta) { |
$resultat_formate = $this->formaterResultat($resultat_meta); |
} else { |
$m = "Données introuvables dans la base $this->table"; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $m); |
Debug::printr($requete_meta); |
} |
return $resultat_formate; |
} |
//--------------------FONCTIONS TRAITEMENT DES PARAMETRES--------------------------------------------------------------- |
public function traiterParametres($parametres) { |
if (isset($parametres) && !empty($parametres)) { |
foreach ($parametres as $param => $val) { |
switch ($param) { |
case 'retour_langue' : $this->rechercherLangueDispo($val); break; |
case 'retour_format' : $this->retour_format = $val; break; |
default : |
$e = 'Erreur dans les paramètres de recherche de votre requête : </br> Le paramètre " ' |
.$param.' " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
break; |
} |
} |
} |
} |
//----------------------FONCTIONS TRAITEMENT DES RESSOURCES------------------------------------------------------------- |
public function traiterRessources($ressources) { |
// /meta-donnees (liste des meta-données. Toutes les info de la table sont affichées) ou /meta-donnees/#champ |
if (isset($ressources) && !empty($ressources)) { |
$this->table_ressources = $ressources; |
if (isset($ressources) && !empty($ressources)) { |
$this->format_reponse = 'metaDonnees/champ'; |
} |
} |
} |
/** Détermine quelles métadonnées doivent etre retournées : |
* - "*" : (/#projet/* /meta-donnees) Renvoi les meta-données de toutes les versions du projet |
* - "numero de la version" : (/#projet/2.00/meta-donnees) Renvoi les meta-données de la version 2.00 du projet |
* - non renseignée : (/#projet/meta-donnees) Renvoi les meta-données de la dernière version du projet |
* Cette info est stockée dans par la classe RestServeur dans la variable $ressources ($ressources[0]) |
*/ |
public function traiterRessourceVersion(&$ressources) { |
if (isset($ressources[0]) && !empty($ressources[0])) { |
if (preg_match('/(?:[0-9]+(?:_|[.])[0-9]+|[*]| )/', $ressources[0])) { |
$this->version_projet = array_shift($ressources); |
if ($this->version_projet == ' ') $this->version_projet = '+'; |
} |
switch ($this->version_projet) { |
case '+' : |
$this->requete_condition[] = 'version = (SELECT MAX(version) FROM '.Config::get('bdd_table_meta').')'; |
break; |
case '*' : |
break; |
default : |
if (is_numeric($this->version_projet)) { |
$res_version = $this->rechercherVersionsDispo($this->version_projet); |
} |
break; |
} |
} |
} |
/** |
* Vérifie que le numéro de la version passée en paramètre correspond à une version existante. |
* Si oui remplit la condition de la requete SQL |
*/ |
public function rechercherVersionsDispo($val) { |
$val = str_replace('_', '.', $val); |
$req_version = 'SELECT version FROM '.Config::get('bdd_table_meta'); |
$res_version = $this->getBdd()->recupererTous($req_version); |
foreach ($res_version as $version) { |
$versions_dispo[] = $version['version']; |
} |
if (in_array($val, $versions_dispo)) { |
$this->requete_condition[] = 'version = '.$this->getBdd()->proteger($val); |
} else { |
$e = 'La version demandée n\'existe pas actuellement. </br>Les versions disponibles sont : ' |
.implode($versions_dispo); |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
} |
return $res_version; |
} |
/** Vérifie que les meta-donnees existe dans la langue passée en paramètre, Si oui remplit la condition de la requete SQL */ |
public function rechercherLangueDispo($val) { |
//on recherche les langues_meta disponibles pour la version demandée : (d'ou ajout de la condition) |
$req_langue = 'SELECT langue_meta FROM ' |
.Config::get('bdd_table_meta') |
.' WHERE '.implode(' AND ', $this->requete_condition); |
$res_langue = $this->getBdd()->recupererTous($req_langue); |
foreach ($res_langue as $langue) { |
$langue_dispo[] = $langue['langue_meta']; |
} |
if (in_array($val, $langue_dispo)) { |
$this->requete_condition[] = 'langue_meta = '.$this->getBdd()->proteger($val); |
} else { |
$e = 'La langue demandée n\'existe pas actuellement. </br>Les langues disponibles sont : ' |
.implode($langue_dispo); |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
} |
} |
//------------------------------Fonction d'assemblage de la requete------------------------------------------------------ |
public function assemblerLaRequete() { |
$condition = ''; |
if (isset($this->requete_condition)) { |
$condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
} |
$req = 'SELECT '.$this->requete_champ.' FROM '.Config::get('bdd_table_meta').$condition; |
return $req; |
} |
//--------------------------------------Fonction de formatage des resultats --------------------------------------------- |
public function formaterResultat($resultat) { |
switch ($this->format_reponse) { |
case 'metaDonnees/champ' : $reponse = $this->formaterMetaDonneesChamp($resultat); break; |
case 'metaDonnees' : $reponse = $this->formaterMetaDonnees($resultat); break; |
default : break; |
} |
return json_encode($reponse); |
} |
//--------------------------------------Fonction de formatage des resultats de /metaDonnees/---------------------------- |
public function formaterMetaDonnees($resultat) { |
foreach ($resultat as $version) { |
foreach ($version as $key => $val) { |
if ($val != '') { |
$this->afficherDonnees($key, $val); |
} |
} |
if ($this->retour_format == 'max' && $this->version_projet == '*') { |
$this->table_retour['href'] = Config::get('url_service_base').Config::get('nom_projet') |
.'/'.$version['version'].'/'.$this->service; |
} |
$table[] = $this->table_retour; |
$this->table_retour = array(); |
} |
return $table; |
} |
public function afficherDonnees($key, $valeur) { |
if ($valeur != '') { |
$tab = array(); |
if ($this->retour_format == 'min') { |
if (in_array($key, array('editeur','createurs', 'contributeurs','couverture_spatiale','couverture_temporelle'))) { |
//Pour les données comprenant plusieurs infos (...=...,...=...;...) |
$tab = $this->recupererTableauResultat($valeur); |
$this->afficherConcatenationValeur($key, $tab); |
} else { |
$this->table_retour[$key] = trim($valeur); |
} |
} else { |
if (in_array($key, array('editeur','createurs', 'contributeurs','couverture_spatiale','couverture_temporelle','langue','langue_meta'))) { |
$tab = $this->recupererTableauResultat($valeur); |
$this->afficherConcatenationValeur($key, $tab); |
$this->afficherDonneesMax($key,$valeur,$tab); |
} else { |
$this->table_retour[$key] = trim($valeur); |
} |
} |
} |
} |
/** |
* Recupère à partir de la valeur du champ les différentes informations séparées par ';' (stocke ds un tableau) |
* pour éditeurs, créateurs, contributeurs,... |
* (ex : nom=Tela Botanica,guid=urn:lsid:tela-botanica.org,courriel=accueil@tela-botanica.org,... |
*/ |
public function recupererTableauResultat($val) { |
$tab = array(); |
$num_entite = 0; |
// découpe chaque participant |
$tab_entites = explode(';', $val); |
foreach ($tab_entites as $entite) { |
$tab[$num_entite] = array(); |
if ($entite != '') { // découpe les informations du participant |
$entite_detail = explode(',', $entite); |
foreach ($entite_detail as $detail) { |
if ($detail != '') { |
if (preg_match('/^([^=]+)=([^=]*)$/', $detail, $match)) { |
$tab[$num_entite][$match[1]] = $match[2]; |
} else { |
$tab[$num_entite][] = $detail; |
} |
} |
} |
} |
$num_entite++; |
} |
return $tab; |
} |
/** Retourne : |
* - le nom de l'editeur |
* - les coordonnées de l'éditeur sous la forme [latitude]N,[longitude]S [datum] |
* - la couverture temporelle sous la forme xxxx à xxxx |
* - la concaténation des noms pour les contributeurs et les créateurs (machin chouette, truc bidule...) |
* - la liste des liste des couvertures spatiales (le nom et pas le code) (France, allemagne..) */ |
public function afficherConcatenationValeur($champ, $tab) { |
if (strrpos($champ, '.coordonnees') !== false) { |
if (isset($tab[0]['latitude']) && isset($tab[0]['longitude']) && isset($tab[0]['datum'])) { |
$this->table_retour[$champ] = $tab[0]['latitude'].' N, '.$tab[0]['longitude'].' S ['.$tab[0]['datum'].']'; |
} |
} else { |
$concat = ''; |
foreach ($tab as $entite) { |
foreach ($entite as $key => $val) { |
if ($champ == 'couverture_spatiale') { |
$concat .= ', '.$this->ajouterSignification($champ, $val); |
} else { |
if (strrpos($key, '.prenom') !== false) { |
$concat .= ', '.$val; |
} elseif (strrpos($key, 'nom') !== false) { |
$concat .= ' '.$val; |
break; |
} |
} |
} |
} |
$res = trim($concat, ','); |
$res = trim($res); |
if ($champ == 'couverture_temporelle') $res = str_replace(' ', ' à ',$res); |
$this->table_retour[$champ] = $res; |
} |
} |
public function afficherDonneesMax($champ,$valeur,$tab) { |
switch ($champ) { |
case 'couverture_temporelle' : $this->afficherInfosPrecises($champ, 'start,end', $valeur, $tab); break; |
case 'langue' : $this->afficherInfosPrecises($champ,'signification,code,href', $valeur); break; |
case 'langue_meta' : $this->afficherInfosPrecises($champ,'signification,code,href', $valeur); break; |
case 'couverture_spatiale' : $this->afficherInfosPrecises($champ, 'details', $valeur, $tab); break; |
case 'createurs' : $this->afficherInfosPrecises($champ, 'details', $valeur, $tab); break; |
case 'contributeurs' : $this->afficherInfosPrecises($champ, 'details', $valeur, $tab); break; |
case 'editeur' : $this->afficherEditeur($champ, $tab); break; |
default : $this->table_retour[$champ] = $valeur; break; |
} |
} |
public function afficherEditeur($key, $tab) { |
// infos générales sur l'éditeur |
foreach ($tab[0] as $k => $val) { |
if ((strrpos($k, 'contact.') === false) && (strrpos($k, '.wgs84') === false)) { |
$this->table_retour[$key.'.'.$k] = $val; |
} |
} |
//on récupère dans un premier temps les tableaux des coordonnées. |
$table_coordonnees = $this->recupererTableCoordonnees($tab); |
//on affiche les informations sur les coordonnees : concaténation + détails |
if ($table_coordonnees[0] != array()) { |
$this->afficherConcatenationValeur($key.'.coordonnees', $table_coordonnees); |
if (isset($table_coordonnees[0]['datum'])) { |
$this->afficherInfosPrecises($key.'.coordonnees.datum', |
'signification,code,href',$table_coordonnees[0]['datum'], |
$table_coordonnees); |
} |
} |
$table_contact = $this->recupererTableContact($tab); |
//on affiche le premier contact en dehors de la table de détail: |
if ($table_contact[0] != array()) { |
$this->table_retour[$key.'.contact'] = ''; |
foreach ($table_contact as $info => $valeur) { |
$this->table_retour[$key.'.contact'] .= $valeur['contact.prenom']." ".$valeur['contact.nom']; |
} |
//on affiche les détails des autres contacts : |
$this->afficherTableDetails($key.'.contact', $table_contact); |
} |
} |
public function afficherInfosPrecises($champ, $pts, $val, $tab = null) { |
//permet d'afficher les informations précises telles que les .details, .start, .end... |
$pts = explode(',', $pts); |
foreach ($pts as $pt) { |
switch ($pt) { |
case 'start' : $this->table_retour[$champ.'.start'] = $tab['start']; break; |
case 'end' : $this->table_retour[$champ.'.end'] = $tab[' end']; break; |
case 'code' : $this->table_retour[$champ.'.code'] = $val; break; |
case 'href' : $this->table_retour[$champ.'.href'] = |
$this->ajouterHrefAutreProjet($champ, '', $val); break; |
case 'signification' : $this->table_retour[$champ] = $this->ajouterSignification($champ, $val); break; |
case 'details' : if ($champ == 'couverture_spatiale') { |
$this->afficherCouvertureSpatiale($champ, $tab); |
} else { |
$this->afficherTableDetails($champ, $tab); |
} break; |
default : $this->table_retour[$champ.'.'.$pt] = $tab[$pt]; break; |
} |
} |
} |
public function afficherCouvertureSpatiale($key, $tab) { |
$res = $this->table_retour; |
$this->table_retour = array(); |
foreach ($tab as $iso) { |
foreach ($iso as $val) { |
$this->afficherInfosPrecises($key, 'signification,code,href',$val); |
$res[$key.'.detail'][] = $this->table_retour; |
$this->table_retour = array(); |
} |
} |
$this->table_retour = $res; |
} |
public function afficherTableDetails($champ, $tab) { |
$res = $this->table_retour; |
$this->table_retour = array(); |
foreach ($tab as $num_entite => $entite) { // $t et $type valent p ou o |
$t = ''; |
$type = '.'; |
foreach ($entite as $key => $infos) { |
list($type, $info) = explode('.', trim($key)); |
if ($type == 'contact') $type = 'p'; |
if ($type != $t) { // cherche et ajoute la signification du type |
$this->afficherInfosPrecises('type', 'signification,code,href', trim($type)); |
foreach ($this->table_retour as $k => $val) { |
$res[$champ.'.details'][$num_entite][$type.'.'.$k] = $val; |
} |
$table_retour = array(); |
$this->table_retour = array(); // rempli par afficherInfosPrecises |
$t = $type; |
} |
$res[$champ.'.details'][$num_entite][$key] = $infos; |
} |
} |
$this->table_retour = $res; |
} |
public function ajouterSignification($champ, $val, $nom = 'nom') { |
$url = $this->ajouterHrefAutreProjet($champ, '', $val); |
if (in_array($champ, array('langue', 'langue_meta', 'couverture_spatiale'))) { |
$url .= '/'.$nom; |
} |
$signification = $this->consulterHref($url); |
if (isset($signification->$nom)) { |
$res = $signification->$nom; |
} else { |
$nom = 'nom.fr'; |
$res = $signification->$nom; |
} |
return $res ; |
} |
public function recupererTableContact(&$tab) { |
$res = array(); |
foreach ($tab[0] as $key => $val) { |
if (strrpos($key, 'contact.') !== false) { |
while (array_key_exists($key, $res)) { $key = ' '.$key; } |
$res[$key] = $val; |
unset($tab[0][$key]); //suppression des premiers contacts qui seront affichés après |
} |
} |
$resultat[0] = $res; |
return $resultat; |
} |
public function recupererTableCoordonnees(&$tab) { |
$res = array(); |
foreach ($tab[0] as $key => $val) { |
if (strrpos($key, 'latitude') !== false || strrpos($key, 'longitude') !== false) { |
list ($coord, $datum) = explode('.', $key); |
$res[$coord] = $val; |
$res['datum'] = $datum; |
} |
} |
$resultat[0] = $res; |
return $resultat; |
} |
//-------------------------------------Fonction de formatage des resultats de /metaDonnees/#champs+champs---------------- |
public function formaterMetaDonneesChamp($resultat) { |
$this->recupererNomChamp(Config::get('bdd_table_meta')); |
//On récupère dans un premier temps toutes les données existantes puis on pioche les champs recherchés |
$table_Meta = $this->formaterMetaDonnees($resultat); |
foreach ($table_Meta as $version) { |
//on affiche les informations par defaut : la version, la langue_meta et le guid : |
$this->afficherVersionLangueMetaGuid($version); |
$tab_ress = explode(' ', $this->table_ressources[0]); |
foreach ($tab_ress as $champ) {//on recupere le radical pour comparaison avec les nom des champs de la bdd : |
$this->afficherChampRecherche($champ, $version); |
} |
$table[] = $this->table_retour; |
$this->table_retour = array(); |
} |
return $table; |
} |
public function afficherChampRecherche(&$champ, &$version) { |
preg_match('/^([^.]+)(?:[.][^.]+)?$/', $champ, $match); |
if (preg_match('/(.+)[.][*]$/', $champ, $match_2)) { |
$this->afficherPointEtoile($match_2, $version, $champ); |
} elseif (array_key_exists($champ, $version)) { |
$this->table_retour[$champ] = $version[$champ]; |
} elseif (in_array($match[1], $this->champs_table)) { |
//si le champ est vide dans cette version on retourne null (comparaison avec les champs existants) |
$this->table_retour[$champ] = null; |
} else { |
$champs = implode('</li><li>', array_keys($version)); |
$e = 'Erreur dans votre requête : </br> Le champ "'.$champ.'" n\'existe pas'. |
'. Les champs disponibles sont : <li>'.$champs.'</li>'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
public function afficherPointEtoile($match, $version, $ressource) { |
$existe = false; |
foreach ($version as $key => $valeur) { |
if (strrpos($key, $match[1].'.') !== false) { |
$this->table_retour[$key] = $valeur; |
$existe = true; |
} |
} |
if (!$existe) { |
$champs = implode('</li><li>', array_keys($version)); |
$e = 'Erreur dans votre requête : </br> Le champ " '.$ressource.' " n\'existe pas dans la version ' |
.$version['version'].'. Les champs disponibles sont : <li>'.$champs.'</li>'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
public function afficherVersionLangueMetaGuid(&$version) { |
$this->table_retour['version'] = $version['version']; |
$this->table_retour['langue_meta'] = $version['langue_meta']; |
$this->table_retour['guid'] = $version['guid']; |
} |
} |
?> |
/trunk/services/modules/0.1/commun/Ontologies.php |
---|
New file |
0,0 → 1,347 |
<?php |
/** |
* Description : |
* Classe Ontologies.php fournit des informations sur ensemble structuré des termes et concepts représentant les éléments |
* d'un domaine de connaissances . |
* Le but étant de fournir un ensemble minimal d'information comprenant : |
* un identifiant (numérique ou alphanumérique sous forme de ChatMot si possible), un nom, une description et |
* éventuellement une relation hiérarchique avec un autre terme (=classe). |
* Si l'url finit par /ontologies on retourne une liste de termes (seulement les 100 premières par défaut). |
* L'url peut contenir des paramètres optionnels passés après le ? : /ontologies?param1=val1¶m2=val2&... |
* |
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.description , recherche, |
* distinct, retour.format, navigation.depart et navigation.limite. |
* |
* Encodage en entrée : utf8 |
* Encodage en sortie : utf8 |
* @package eflore-projets |
* @author Jennifer DHÉ <jennifer.dhe@tela-botanica.org> |
* @author Delphine CAUQUIL <delphine@tela-botanica.org> |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 0.1 |
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
*/ |
class Ontologies extends Commun { |
protected $requete_condition = null; //Représente la partie de la requete SQL ajoutant une condition (WHERE ...) |
/** Permet de stocker la requete formulée: /ontologies | /ontologies/#id | /ontologies/#id/champ | /ontologies/#id/relations */ |
protected $format_reponse = 'ontologies'; |
/** Permet de stocker les limite de la requete SQL (par défaut seul les 100 premiers résultats seront retournés). |
* Stocke également les valeurs des paramètres navigation.depart et navigation.limite passés dans la requete*/ |
protected $limite_requete = array( 'depart' => 0, 'limite' => 100); |
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */ |
protected $total_resultat; |
protected $retour_format = 'max'; |
public function traiterParametres() { |
if (isset($this->parametres) && !empty($this->parametres)) { |
foreach ($this->parametres as $param => $valeur) { |
switch ($param) { |
case 'masque' : $this->ajouterLeFiltreMasque('masque', $valeur); break; |
case 'masque_code' : $this->ajouterLeFiltreMasque('code', $valeur); break; |
case 'masque_nom' : $this->ajouterLeFiltreMasque('nom', $valeur); break; |
case 'masque_description' : $this->ajouterLeFiltreMasque('description', $valeur); break; |
case 'retour_format' : $this->retour_format = $valeur; break; |
case 'retour_champs' : break; |
case 'navigation_depart' : $this->limite_requete['depart'] = $valeur; break; |
case 'navigation_limite' : $this->limite_requete['limite'] = $valeur; break; |
case 'recherche' : break; |
default : |
$e = 'Erreur dans les parametres de recherche de votre requête : </br> Le paramètre " ' |
.$param.' " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break; |
} |
} |
} |
} |
public function ajouterLeFiltreMasque($nom_champ, $valeur) { |
if ($nom_champ == 'code') { |
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur); |
} else { |
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] == 'floue') { |
if ($nom_champ == 'masque') { |
$this->requete_condition[] = '( code = '.$this->getBdd()->proteger($valeur) |
.' OR ( SOUNDEX(nom) = SOUNDEX(\''.$valeur.'\')' |
.' OR SOUNDEX(REVERSE(nom)) = SOUNDEX(REVERSE(\''.$valeur.'\')) ' |
.') OR ( SOUNDEX(description) = SOUNDEX(\''.$valeur.'\')' |
.' OR SOUNDEX(REVERSE(description)) = SOUNDEX(REVERSE(\''.$valeur.'\')) ))'; |
} else { |
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')' |
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\')))'; |
} |
} else { |
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] == 'etendue') { |
$valeur = str_replace(' ','%', $valeur); |
$valeur .= '%'; |
} |
if ($nom_champ == 'masque') { |
$this->requete_condition[] = '(code = '.$this->getBdd()->proteger($valeur) |
.' OR nom LIKE '.$this->getBdd()->proteger($valeur) |
.' OR description LIKE '.$this->getBdd()->proteger($valeur).')'; |
} else { |
$this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur); |
} |
} |
} |
} |
public function traiterRessources() { |
if (isset($this->ressources) && !empty($this->ressources)) { |
if (isset($this->ressources[0]) && !empty($this->ressources[0])) { |
//requete = /ontologies/#id |
$this->traiterRessourceId(); |
if (isset($this->ressources[1]) && !empty($this->ressources[1])) { |
//requete = /ontologies/#id/relations |
$this->traiterRessourceRelations(); |
} |
} |
} |
} |
public function traiterRessourceId() { |
$this->requete_condition = array(); |
//requete : /ontologies/#id (ex : /ontologies/7) |
if (is_numeric($this->ressources[0])) { |
$this->requete_condition[] = ' id = '.$this->getBdd()->proteger($this->ressources[0]); |
$this->format_reponse .= '/id'; |
//requete : /ontologies/#classe:#code (ex : /ontologies/rangTaxo:290) |
} elseif (strrpos($this->ressources[0], ':') !== false) { |
$this->format_reponse .= '/id'; |
preg_match('/^([^:]+):([^:]+)$/', $this->ressources[0], $match); |
$this->requete_condition[] = |
' id = (SELECT id FROM '.$this->table.' WHERE code = '.$this->getBdd()->proteger($match[2]) |
.' AND classe_id = (SELECT id FROM '.$this->table.' WHERE code = '.$this->getBdd()->proteger($match[1]).'))'; |
} else { |
$e = 'Erreur dans les paramètres de recherche de votre requête : </br> Le paramètre " ' |
.$this->ressources[0].' " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
public function traiterRessourceRelations() { |
//requete = /ontologies/#id/relations : |
if ($this->ressources[1] == 'relations') { |
$this->format_reponse .= '/relations'; |
$this->requete_condition = array('classe_id = (SELECT classe_id FROM '.$this->table.' WHERE ' |
.implode(' AND ', $this->requete_condition).')'); |
} |
} |
//+--------------------------FONCTION ASSEMBLAGE DE LA REQUETE-------------------------------------------+ |
public function assemblerLaRequete() { |
$requete = ' SELECT '.$this->formerRequeteChamp(). |
' FROM '.$this->table |
.$this->retournerRequeteCondition() |
.$this->formerRequeteLimite(); //print_r($requete); |
return $requete; |
} |
public function formerRequeteChamp() { |
$champ[] = 'id'; |
if ($this->format_reponse == 'ontologies') { |
$champ[] = 'nom, code '; |
} |
if (isset($this->parametres['retour_champs']) || $this->format_reponse == 'ontologies/id/champs') { |
$champs_recherches = explode(',', $this->parametres['retour_champs']); |
$champs_possibles = $this->rechercherChampsPossibles(); |
foreach ($champs_recherches as $champ_recherche) { |
if ($this->verifierValiditeChamp($champ_recherche)) { |
$champ[] = (preg_match('/classe/', $champ_recherche)) ? 'classe_id' : $champ_recherche; |
} |
} |
} |
if (count($champ) == 1) { |
$champ = array(' * '); |
} |
return implode(', ', $champ); |
} |
public function rechercherChampsPossibles() { |
$this->recupererNomChamp($this->table); |
$champs_possibles = $this->champs_table; |
$champs_possibles[] = 'classe.id'; |
$champs_possibles[] = 'classe'; |
$champs_possibles[] = 'classe.href'; |
return $champs_possibles; |
} |
public function verifierValiditeChamp($champ, $champs_possibles) { |
$validite = false; |
preg_match('/^([^.]+)(:?\.([^.]+))?$/', $champ, $match); |
if (in_array($match[1], $champs_possibles)) { |
$validite = true; |
} else { |
$champs = implode('</li><li>', $champs_possibles); |
$e = 'Erreur dans votre requête : </br> Le champ "'.$champ |
.'" n\'existe pas. Les champs disponibles sont : <li>'.$champs.'</li>'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
return $validite; |
} |
public function retournerRequeteCondition() { |
$condition = ''; |
if ($this->requete_condition !== null) { |
$condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
} |
return $condition; |
} |
public function formerRequeteLimite() { |
$this->total_resultat = $this->recupererTotalResultat(); |
if (in_array($this->format_reponse , array('textes/id', 'textes/id/relations'))) { |
$this->requete_limite = ''; |
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat)) { |
$this->limite_requete['depart'] = |
(($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']); |
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
} else { |
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
} |
return $this->requete_limite; |
} |
public function recupererTotalResultat() { |
//on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /ontologies) |
$requete = 'SELECT count(*) as nombre FROM ' |
.$this->table |
.$this->retournerRequeteCondition(); |
$res = $this->getBdd()->recuperer($requete); |
if ($res) { |
$total = $res['nombre']; |
} else { |
$e = 'Données introuvables dans la base'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
Debug::printr($requete); |
} |
return $total; |
} |
//+------------------------------------------------------------------------------------------------------+ |
public function retournerResultatFormate($resultat) { |
// determine en fct du service appelé (/ontologies | /ontologies/#id | /ontologies/#id/champ | |
// /ontologies/#id/relations) le format du tableau à retourner. Encode en json |
switch ($this->format_reponse) { |
case 'ontologies' : $reponse = $this->formaterOntologies($resultat); break; |
case 'ontologies/id' : $reponse = $this->formaterOntologiesId($resultat[0]); break; |
case 'ontologies/id/relations' : $reponse = $this->formaterOntologiesIdRelations($resultat); break; |
default : break; |
} |
return $reponse; |
} |
public function formaterOntologies($resultat) { |
$this->ajouterEnteteResultat($resultat); |
$table_retour_json['entete'] = $this->ajouterEnteteResultat($resultat); |
if (isset($this->parametres['masque_code']) || isset($this->parametres['masque'])) { |
$resultat = $this->trierRechercheFloue($this->parametres['masque_code'], $resultat, 'code'); |
} elseif (isset($this->parametres['masque_nom'])) { |
$resultat = $this->trierRechercheFloue($this->parametres['masque_nom'], $resultat, 'nom'); |
} elseif (isset($this->parametres['masque_description'])) { |
$resultat = $this->trierRechercheFloue($this->parametres['masque_description'], $resultat, 'description'); |
} |
//on remplit la table $table_retour_json['resultat'] |
foreach ($resultat as $tab) { |
$num = $tab['id']; |
unset($tab['id']); |
foreach ($tab as $param => $valeur) { |
$resultat_json[$num][$param] = $valeur; |
} |
if ($this->retour_format == 'max') $resultat_json[$num]['href'] = $this->ajouterHref('ontologies', $num); |
} |
$table_retour_json['resultat'] = $resultat_json; |
return $table_retour_json; |
} |
public function ajouterEnteteResultat($resultat) { |
//on remplit la table $table_retour_json['entete'] |
$entete['depart'] = $this->limite_requete['depart']; |
$entete['limite'] = $this->limite_requete['limite']; |
$entete['total'] = $this->total_resultat; |
//formuler les urls |
$url = $this->formulerUrl($this->total_resultat, '/ontologies'); |
if (isset($url['precedent']) && $url['precedent'] != '') { $entete['href.precedent'] = $url['precedent']; } |
if (isset($url['suivant']) && $url['suivant'] != '') { $entete['href.suivant'] = $url['suivant']; } |
return $entete; |
} |
public function formaterOntologiesId($resultat) { |
$table_retour = array(); |
foreach ($resultat as $key => $valeur) { |
if ($valeur != '') { |
$table_retour = array_merge($table_retour, $this->afficherDonnees($key, $valeur)); |
} |
} |
return $table_retour; |
} |
public function afficherDonnees($champ, $valeur) { |
$retour[$champ] = $valeur; |
if ($this->retour_format == 'max') { |
if ($champ == 'classe_id') { |
unset($retour[$champ]); // remplacer par classe.id |
if ($valeur != "0") { // pas de parent |
if (isset($this->parametres['retour_champs'])) { |
switch ($this->parametres['retour_champs']) { |
case 'classe' : $retour['classe'] = $this->ajouterClasseCorrespondante($valeur); break; |
case 'classe.id' : $retour['classe.id'] = $valeur; break; |
case 'classe.href' : $retour['classe.href'] = $this->ajouterHref('ontologies', $valeur); break; |
case 'classe.*' : $retour['classe.id'] = $valeur; $retour['classe.href'] = $this->ajouterHref('ontologies', $valeur); break; |
} |
} else { |
$nom_classe = $this->ajouterClasseCorrespondante($valeur); |
if (isset($nom_classe)) $retour['classe'] = $nom_classe; |
$retour['classe.id'] = $valeur; |
$retour['classe.href'] = $this->ajouterHref('ontologies', $valeur); |
} |
} |
} |
} |
return $retour; |
} |
/** Recherche par interrogation de la base, le nom de la classe à partir de son identifiant (classe.id) */ |
public function ajouterClasseCorrespondante($classe_id) { |
$nom = null; |
if ($classe_id != 0) { |
$nom = ''; |
$req = 'SELECT nom FROM '.$this->table.' WHERE id = '.$this->getBdd()->proteger($classe_id); |
$res = $this->getBdd()->recuperer($req); |
if ($res) { |
$nom = $res['nom']; |
} else { |
$e = "Données introuvables dans la table $this->table"; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
Debug::printr($req); |
} |
} |
return $nom; |
} |
public function formaterOntologiesIdRelations($resultat) { |
$retour = null; |
if ($resultat != '') { |
$retour['entete'] = $this->ajouterEnteteResultat($resultat); |
//on remplit la table $table_retour_json['resultat'] |
foreach ($resultat as $tab) { |
$num = $tab['id']; |
$retour['resultat'][$num]['nom'] = $tab['nom']; |
if ($this->retour_format == 'max') { |
$retour['resultat'][$num]['href'] = $this->ajouterHref('ontologies', $num); |
} |
} |
} |
return $retour; |
} |
} |
?> |
/trunk/services/configurations/config.defaut.ini |
---|
New file |
0,0 → 1,72 |
; Encodage : UTF-8 |
; +------------------------------------------------------------------------------------------------------+ |
; URLs |
; Le séparateur utilisé par le framework lorsqu'il génère des URL pour séparer les arguments. |
; Pour remettre les valeurs par défaut, utitliser : "php:ini_get('arg_separator.output')" |
url_arg_separateur_sortie = "&" |
; +------------------------------------------------------------------------------------------------------+ |
; Info sur l'application |
info.nom = Services d'eFlore |
; Abréviation de l'application |
info.abr = eFlore-services |
; Version du Framework nécessaire au fonctionnement de cette application |
info.framework.version = 0.3 |
;Encodage de l'application |
encodage_appli = "UTF-8" |
; +------------------------------------------------------------------------------------------------------+ |
; Débogage |
; Indique si oui ou non on veut afficher le débogage. |
debogage = true |
; Indique sous quelle forme les méssages de débogage doivent s'afficher : |
; - "php:Debug::MODE_ECHO" : le message est affiché en utilisant echo |
; - "php:Debug::MODE_NOTICE" : le message est affiché en utilisant une erreur de type notice |
; - "php:Debug::MODE_ENTETE_HTTP" : les messages sont envoyés dans un entête HTTP "X_REST_DEBOGAGE". |
; - "Autre valeur" : les messages sont formatés puis retournés par la méthode de débogage utilisée. |
debogage_mode = "php:Debug::MODE_ECHO" |
; Indique si oui ou non on veut lancer le chronométrage |
chronometrage = false |
; +------------------------------------------------------------------------------------------------------+ |
; Paramètrage de la base de données. |
; Abstraction de la base de données. |
bdd_abstraction = pdo |
; Protocole de la base de données. |
bdd_protocole = mysql |
; Nom du serveur de bases de données. |
bdd_serveur = localhost |
; Nom de l'utilisateur de la base de données. |
bdd_utilisateur = "" |
; Mot de passe de l'utilisateur de la base de données. |
bdd_mot_de_passe = "" |
; Nom de la base de données principale. |
bdd_nom = "tb_eflore" |
; Encodage de la base de données principale au format base de données (ex. pour l'utf-8 ne pas mettre le tiret!). |
bdd_encodage = "utf8" |
; +------------------------------------------------------------------------------------------------------+ |
; Infos sur les services |
;chemin direct aux services |
serveur.baseURL = /eflore/eflore-projets/services/ |
;URL à rediriger |
serveur.baseAlternativeURL = /service:eflore:0.1/ |
; Version des service web du projet |
service_version = 0.1 |
; Standard utilisé pour les codes de langue |
langue_source = "ISO-639-1"; |
; Standard utilisé pour les codes de zones géographiques |
zone_geo_source = "ISO-3166-1"; |
; URL de base des services |
url_base="http://localhost/" |
; URL de base des services |
url_service_base='{ref:url_base}service:eflore:0.1/' |
; +------------------------------------------------------------------------------------------------------+ |
; Infos sur les projets |
; Liste des projets disponibles |
projetsDispo = "bdnt,bdtfx" |
/trunk/services/configurations/config_bdnt.ini |
---|
New file |
0,0 → 1,23 |
; Encodage : UTF-8 |
; Nom du projet |
nom_projet = "bdnt" |
; Nom de la table principalement utilisée. |
bdd_table_ontologies= "bdnt_ontologies" |
; Nom de la table métadonnées utilisée. |
bdd_table_meta = "bdnt_meta" |
; +------------------------------------------------------------------------------------------------------+ |
; URL de base de l'application. |
url_base = "http://localhost/" |
; URL de base des services de ce projet |
url_service="{ref:url_base}service:eflore:0.1/bdnt" |
; URL de l'ontologie des bdnt |
url_ontologie="{ref:url_base}service:eflore:0.1/bdnt/ontologies/" |
; +------------------------------------------------------------------------------------------------------+ |
; Config spécifique au projet |
; Noms des services disponibles pour ce projet |
servicesDispo = "meta-donnees,aide,ontologies" |
/trunk/services/configurations/config_bdtfx.ini |
---|
New file |
0,0 → 1,118 |
; Encodage : UTF-8 |
; Nom du projet |
nom_projet = "bdtfx" |
; Nom de la table principalement utilisée. |
bdd_table= "bdtfx" |
; Nom de la table métadonnées utilisée. |
bdd_table_meta = "bdtfx_meta" |
; +------------------------------------------------------------------------------------------------------+ |
; url_base : URL de base de l'application. Si vide : fonctionnement Stand-alone |
; Peut utiliser un objet Net_URL comme ceci : "php:$mon_objet_net_url->getUrl()" |
url_base = "http://localhost/" |
; URL de base des services du projet bdtfx |
url_service="{ref:url_base}service:eflore:0.1/bdtfx" |
; URL de l'ontologie des bdnt |
url_ontologie="{ref:url_base}service:eflore:0.1/bdnt/ontologies/" |
; +------------------------------------------------------------------------------------------------------+ |
; Config spécifique au projet |
; Noms des ressources disponible pour ce projet |
servicesDispo = "meta-donnees,aide,noms,taxons" |
; Paramètres de l'api |
parametresAPI = " |
recherche, |
navigation.depart, |
navigation.limite, |
distinct, |
ns.structure, |
ns.format, |
masque, |
masque.nn, |
masque.nt, |
masque.rg, |
masque.sg, |
masque.gen, |
masque.sp, |
masque.ssp, |
masque.au, |
masque.an, |
masque.bib, |
masque.ad, |
retour.format, |
retour.champs" |
;correspondance champs bdnt pour l'affichage lors du résultat renvoyé |
correspondance_champs = " |
num_nom=id, |
num_nom_retenu=nom_retenu.id, |
num_tax_sup=tax_sup.id, |
rang=rang.code, |
nom_sci=nom_sci, |
nom_supra_generique=nom_sci.supra_generique, |
genre=nom_sci.genre, |
epithete_infra_generique=nom_sci.infra_generique, |
epithete_sp=nom_sci.sp, |
type_epithete=nom_sci.type_epithete, |
epithete_infra_sp=nom_sci.infra_sp, |
cultivar_groupe=nom_sci.cultivar_groupe, |
cultivar=nom_sci.cultivar, |
nom_commercial=nom_sci.nom_commercial, |
auteur=auteur, |
annee=annee, |
biblio_origine=biblio_origine, |
notes=notes, |
nom_addendum=nom_addendum, |
homonyme=homonyme, |
basionyme=basionyme.id, |
synonyme_proparte=proparte.id, |
synonyme_douteux=douteux, |
synonyme_mal_applique=mal_applique, |
synonyme_orthographique=orthographe_correcte.id, |
hybride_parent_01=hybride.parent_01.id, |
hybride_parent_01_notes=hybride.parent_01.notes, |
hybride_parent_02=hybride.parent_02.id, |
hybride_parent_02_notes=hybride.parent_02.notes, |
nom_francais=nom_fr, |
presence=presence.code, |
statut_introduction=statut_introduction.code, |
statut_origine=statut_origine.code, |
statut_culture=statut_culture.code, |
presence_Ga=presence_Ga.code, |
presence_Co=presence_Co.code, |
num_taxonomique=num_taxonomique, |
num_meme_type=num_meme_type.id" |
;tableau contenant tous les noms des projet et la correspondance avec le nom des champs des flores de la bdnff |
noms_projets=" |
flore_bonnier=bonnier, |
flore_cnrs=cnrs, |
flore_fe=helvetica, |
flore_coste=coste, |
flore_fh=europaea, |
flore_fournier=fournier, |
flore_belge_ed5=flore_belge" |
; Correspondance entre les champs et les code l'ontologie |
ChampsCodesOntologie = " |
rang=rangTaxo, |
presence=presence, |
presence_Ga=presence, |
presence_Co=presence, |
statut_origine=statutOrigine, |
statut_culture=statutCulture, |
statut_introduction=statutIntroduction" |
; Correspondance entre les champs et les codes de la structure d'un nom |
nsStructure = " |
an=annee, |
au=auteur, |
bib=biblio_origine, |
ad=nom_addendum" |
/trunk/services/framework.defaut.php |
---|
New file |
0,0 → 1,6 |
<?php |
// Inclusion du Framework |
// Renomer ce fichier en "framework.php" |
// Indiquer ci-dessous le chemin absolu vers le fichier autoload.inc.php de la bonne version du Framework |
require_once '/home/delphine/web/framework-0.3/framework/Framework.php'; |
?> |
/trunk/services/.htaccess |
---|
New file |
0,0 → 1,9 |
<files *.ini> |
order deny,allow |
deny from all |
</files> |
RewriteEngine On |
RewriteCond %{REQUEST_FILENAME} !-d |
RewriteCond %{REQUEST_FILENAME} !-f |
RewriteRule ^.*$ index.php |
/trunk/services/bibliotheque/Outils.php |
---|
New file |
0,0 → 1,18 |
<?php |
class Outils { |
public static function recupererTableauConfig($param) { |
$tableau = array(); |
$tableauPartiel = explode(',', Config::get($param)); |
$tableauPartiel = array_map('trim', $tableauPartiel); |
foreach ($tableauPartiel as $champ) { |
if (strpos($champ, '=') === false) { |
$tableau[] = $champ; |
} else { |
list($cle, $val) = explode('=', $champ); |
$tableau[$cle] = $val; |
} |
} |
return $tableau; |
} |
} |
?> |
/trunk/services/index.php |
---|
New file |
0,0 → 1,43 |
<?php |
// Encodage : UTF-8 |
// Permet d'afficher le temps d'execution du service |
$temps_debut = (isset($_GET['chrono']) && $_GET['chrono'] == 1) ? microtime(true) : ''; |
// +-------------------------------------------------------------------------------------------------------------------+ |
/** |
* Serveur |
* |
* Description : initialise le chargement et l'exécution des services web. |
* |
//Auteur original : |
* @author auteur <aut@tela-botanica.org> |
* @copyright Tela-Botanica 1999-2008 |
* @licence GPL v3 & CeCILL v2 |
* @version $Id$ |
*/ |
// +-------------------------------------------------------------------------------------------------------------------+ |
// Le fichier autoload.inc.php du Framework de Tela Botanica doit être appelée avant tout autre chose dans l'application. |
// Sinon, rien ne sera chargé. |
// Chemin du fichier chargeant le framework requis |
$framework = dirname(__FILE__).DIRECTORY_SEPARATOR.'framework.php'; |
if (!file_exists($framework)) { |
$e = "Veuillez paramétrer l'emplacement et la version du Framework dans le fichier $framework"; |
trigger_error($e, E_USER_ERROR); |
} else { |
// Inclusion du Framework |
require_once $framework; |
// Ajout d'information concernant cette application |
Framework::setCheminAppli(__FILE__);// Obligatoire |
Framework::setInfoAppli(Config::get('info')); |
// Initialisation et lancement du serveur |
$Serveur = new RestServeur(); |
$Serveur->executer(); |
// Affiche le temps d'execution du service |
if (isset($_GET['chrono']) && $_GET['chrono'] == 1) { |
$temps_fin = microtime(true); |
echo 'Temps d\'execution : '.round($temps_fin - $temps_debut, 4); |
} |
} |
?> |