Subversion Repositories eFlore/Projets.eflore-projets

Compare Revisions

Ignore whitespace Rev 995 → Rev 996

/tags/v5.3-amandaie/services/tests/0.1/ServiceEflorePhpUnit.php
New file
0,0 → 1,168
<?php
// declare(encoding='UTF-8');
/**
* Classe contenant des méthodes :
* - d'intialisation des tests,
* - refactorisant le code des tests,
* - facilitant les tests.
*
* @category php 5.3
* @package Tests/Services
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2011, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
 
abstract class ServiceEflorePhpUnit extends PHPUnit_Framework_TestCase {
 
/** Définir la valeur de cet attribut dans le constructeur de la classe de test.*/
protected $projet = '';
/** Définir la valeur de cet attribut dans le constructeur de la classe de test.*/
protected $service = '';
 
//+------------------------------------------------------------------------------------------------------+
// Intialisation
 
public static function setUpBeforeClass() {
error_reporting(E_ALL);
 
self::chargerFramework();
 
// Enregistrement en première position des autoload de la méthode gérant les classes des services
spl_autoload_register(array(get_class(), 'chargerClasseAuto'));
}
 
public static function chargerClasseAuto($classe) {
if (class_exists($classe)) {
return null;
}
$cheminBase = realpath(__DIR__.'/../../modules/0.1').'/';
$cheminsTests = __DIR__.'/';
$chemins = array($cheminBase, $cheminsTests);
foreach ($chemins as $chemin) {
$chemin = $chemin.$classe.'.php';
if (file_exists($chemin)) {
require_once $chemin;
}
}
}
 
private static function chargerFramework() {
static $cheminRacine;
if(!$cheminRacine) {
$cheminRacine = realpath(dirname(__FILE__).'/../..').'/';
$framework = $cheminRacine.'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($cheminRacine);// Obligatoire
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
// Refactorisation
public function consulterJson($service, $projet, $ressources, $parametres = NULL) {
$retourJson = self::consulterBrut($service, $projet, $ressources, $parametres);
$retour = json_decode($retourJson, true);
$url = self::creerUrl($service, $ressources, $parametres);
$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url\n".print_r($retourJson, true));
return $retour;
}
 
static function consulterBrut($service, $projet, $ressources, $parametres = NULL) {
if(is_null($ressources)) $ressources = array();
array_unshift($ressources, $projet, $service);
$projets = new Projets();
$retourJson = $projets->consulter($ressources, $parametres);
return $retourJson;
}
 
static function creerUrl($service, $ressources, $parametres = NULL) {
// TODO ? $version
$ressourcesUrl = array();
if($ressources) foreach ($ressources as $ressource) $ressourcesUrl[] = $ressource;
$ressourcesUrl = count($ressourcesUrl) > 0 ? '/'.implode('/', $ressourcesUrl) : '';
 
$parametresUrl = '';
if ($parametres) {
foreach ($parametres as $cle => $valeur) {
$parametresUrl[] = $cle.'='.rawurlencode($valeur);
}
$parametresUrl = '?'.implode('&', $parametresUrl);
}
 
return Config::get('url_service') . '/' . $service . $ressourcesUrl . $parametresUrl;
}
 
//+------------------------------------------------------------------------------------------------------+
// Méthodes facilitant les tests
 
/**
* Récupère un bouchon de classe abstraite.
* Comment l'utiliser :
* $classeAstraite = $this->getClasseAbstraite('MaClasse', array('param1', 'param2'));
* $foo = $classeAstraite->methodeConcretePublique();
*
* @param String $classeNom Le nom de la classe
* @param Array $parametres Les paramètres à passer au constructeur.
* @return Object Le bouchon de la classe abstraite
*/
public function getClasseAbstraite($classeNom, Array $parametres) {
$efloreScript = $this->getMockForAbstractClass($classeNom, $parametres);
return $efloreScript;
}
 
/**
* Récupère une méthode privée d'une classe pour tester/documenter.
* Comment l'utiliser :
* MyClass->foo():
* $cls = new MyClass();
* $foo = self::getPrivateMethode($cls, 'foo');
* $foo->invoke($cls, $...);
*
* @param object $objet Une instance de votre classe
* @param string $methode Le nom de la méthode private
* @return ReflectionMethod La méthode demandée
*/
public static function getMethodePrivee($objet, $nomMethode) {
$classe = new ReflectionClass($objet);
$methode = $classe->getMethod($nomMethode);
$methode->setAccessible(true);
return $methode;
}
 
/**
* Récupère une méthode protégée d'une classe pour tester/documenter.
* Comment l'utiliser :
* MyClass->foo():
* $cls = new MyClass();
* $foo = self::getProtectedMethode($cls, 'foo');
* $foo->invoke($cls, $...);
* @param object $objet Une instance de votre classe
* @param string $methode Le nom de la méthode protected
* @return ReflectionMethod La méthode demandée
*/
public static function getMethodeProtegee($objet, $nomMethode) {
return self::getMethodePrivee($objet, $nomMethode);
}
 
public function assertArrayHasKeys(array $keys, array $array, $message = null) {
foreach ($keys as $key) {
$this->assertArrayHasKey($key, $array, $message);
}
}
}
 
/*
sed -i 's/$this->consulterBrut(/ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, /' $(grep -rl consulterBrut)
sed -i 's/$this->consulterJson(/$this->consulterJson($this->service, $this->projet, /' $(grep -rl consulterJson)
sed -i 's/$this->creerUrl(/ServiceEflorePhpUnit::creerUrl($this->service, /' $(grep -rl creerUrl)
*/
?>
/tags/v5.3-amandaie/services/tests/0.1/baseveg/SyntaxonsTest.php
New file
0,0 → 1,312
<?php
 
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class SyntaxonsTest extends ServiceEflorePhpUnit {
public function __construct() {
$this->projet = 'baseveg';
$this->service = 'syntaxons';
}
//++ ------------------------------------Test des ressources -----------------------------++
//la ressource demandée est t elle connue ?
public function testRessourceInconnue() {
$ressourcesList = array(
array('inconnue'),
array('code:07-2.0.1.0.1-08'),
array('relations'),
array('cle:bgwsd'),
array('cle:5','relations'),
array('cle:5','relations','synonymie'),
array('cle:5','relations','niveaux-sup'),
array('catminat:catminat'),
array('catminat:45'),
array('catminat:07-2.0.1.0.1-08','inconnu'),
array('catminat:07-2.0.1.0.1-08','inconnu','synonymie'),
array('catminat:07-2.0.1.0.1-08','relations','inconnu')
);
$parametres = array();
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur dans l'url de votre requête : </br> La ressource demandée n'existe pas.";
$this->assertEquals($messageAttendu, $retour, "Il faut indiquer si une ressource est eronnée.");
}
}
//++ ------------------------------------Test des parametres -----------------------------++
public function testParametreinconnu() {
$ressourcesList = array(
array('catminat:07-2.0.1.0.1-08'),
array('cle:10'),
array('catminat:07-2.0.1.0.1-08','relations','niveaux-sup'),
array(),
array('catminat:07-2.0.1.0.1-07','relations','synonymie'),
array('catminat:07-2.0.1.0.1-07','relations')
);
$parametres = array('paramatre' => 'ORD');
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur dans les parametres de votre requête :".
" </br> Le paramètre \" paramatre \" n'existe pas.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si le masque est erronné.");
}
}
public function testMasqueNiveauErronne() {
$ressourcesList = array(
array(),
array('catminat:07-2.0.1.0.1-08','relations','niveaux-sup'),
);
$parametres = array('masque.niveau' => 'syn');
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur : valeur inconnue pour masque.niveau. valeurs possibles : ALL|ORD|CLA|SUBCLA|SUBORD|SUBALL|ASS|SUBASS|BC|DC|GRPT";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si le masque est erronné.");
}
}
public function testParametresNavigationNonAutorisesSyntaxonsCode() {
$ressourcesList = array(
array('catminat:07-2.0.1.0.1-08'),
array('cle:6'),
array('catminat:07-2.0.1.0.1-08','relations'),
);
$parametres = array('navigation.depart' => '0');
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = $messageAttendu = "Erreur dans les parametres de votre requête :".
" </br> Le paramètre \" navigation.depart \" n'existe pas.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer que le parametre navigation.depart est interdit pour ce sous-service.");
}
$parametres = array('navigation.limite' => '10');
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = $messageAttendu = "Erreur dans les parametres de votre requête :".
" </br> Le paramètre \" navigation.limite \" n'existe pas.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer que le parametre navigation.limite est interdit pour ce sous-service.");
}
}
public function testParametresMasqueCatminatNonAutorise() {
$ressourcesList = array(
array('catminat:07-2.0.1.0.1-08'),
array('cle:6'),
array('catminat:07-2.0.1.0.1-08','relations'),
array('catminat:07-2.0.1.0.1-08','relations','synonymie')
);
$parametres = array('masque.catminat' => '07-2.0.1.0.1-08');
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = $messageAttendu = "Erreur dans les parametres de votre requête :".
" </br> Le paramètre \" masque.catminat \" n'existe pas.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer que le parametre masque.catminat est interdit pour ce sous-service.");
}
}
public function testParametresMasqueFixeNonAutorise() {
$ressourcesList = array(
array('catminat:07-2.0.1.0.1-08'),
array('cle:6'),
array('catminat:07-2.0.1.0.1-08','relations'),
);
$parametres = array('masque.fixe' => '2338');
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = $messageAttendu = "Erreur dans les parametres de votre requête :".
" </br> Le paramètre \" masque.fixe \" n'existe pas.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer que le parametre masque.fixe est interdit pour ce sous-service.");
}
}
public function testParametresMasqueNiveauNonAutorise() {
$ressourcesList = array(
array('catminat:07-2.0.1.0.1-08'),
array('cle:6'),
array('catminat:07-2.0.1.0.1-08','relations'),
array('catminat:07-2.0.1.0.1-08','relations','synonymie')
);
$parametres = array('masque.niveau' => 'ord');
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = $messageAttendu = "Erreur dans les parametres de votre requête :".
" </br> Le paramètre \" masque.niveau \" n'existe pas.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer que le parametre masque.niveau est interdit pour ce sous-service.");
}
}
public function testParametresMasqueRetenuNonAutorise() {
$ressourcesList = array(
array('catminat:07-2.0.1.0.1-08'),
array('cle:6'),
array('catminat:07-2.0.1.0.1-08','relations'),
array('catminat:07-2.0.1.0.1-08','relations','synonymie')
);
$parametres = array('masque.retenu' => 'true');
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur dans les parametres de votre requête :".
" </br> Le paramètre \" masque.retenu \" n'existe pas.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer que le parametre masque.catminat est interdit pour ce sous-service.");
}
}
//++ ------------------------------------Test du retour Json -----------------------------++
public function testJsonBienFormeListes() {
$ressourcesList = array(
array('catminat:07-2.0.1.0.1-08','relations','niveaux-sup'),
array(),
array('catminat:07-2.0.1.0.1-07','relations','synonymie'),
array('catminat:07-2.0.1.0.1-07','relations')
);
$parametres = array();
foreach ($ressourcesList as $ressources) {
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $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 testPasDeResultat() {
$ressourcesList = array(
array('catminat:18-5.2.1.6.0-8'),
array('catminat:18-5.2.1.6.0-8','relations')
);
$parametres = array();
foreach ($ressourcesList as $ressources) {
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$this->assertEquals("Données introuvables dans la base", $retour, "Il faut indiquer si les données recherchées sont introuvables. Voir : $url");
}
$ressourcesList = array(
array('catminat:18-5.2.1.6.0-8','relations','synonymie'),
array('catminat:18-5.2.1.6.0-8','relations','niveaux-sup'),
);
$parametres = array();
foreach ($ressourcesList as $ressources) {
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$this->assertEquals("Données introuvables dans la base", $retour, "Il faut indiquer si les données recherchées sont introuvables");
}
}
public function testChampsNiveau() {
$ressources = array();
$parametres = array('masque.retenu' => 'true');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
foreach ($retour['resultat'] as $cle => $valeurs) {
$this->assertArrayHasKey('niveau.code', $valeurs, "Le json ne contient pas d'attribut : niveau.code . Voir : $url");
$this->assertNotEmpty($valeurs['niveau.code']);
$this->assertArrayHasKey('niveau.libelle', $valeurs, "Le json ne contient pas d'attribut : niveau.libelle . Voir : $url");
$this->assertNotEmpty($valeurs['niveau.libelle']);
$this->assertArrayHasKey('niveau.href', $valeurs, "Le json ne contient pas d'attribut : niveau.href . Voir : $url");
$this->assertNotEmpty($valeurs['niveau.href']);
}
$parametres = array('masque.retenu' => 'false');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
foreach ($retour['resultat'] as $cle => $valeurs) {
$this->assertArrayHasKey('niveau.code', $valeurs, "Le json ne contient pas d'attribut : niveau.code . Voir : $url");
$this->assertNotEmpty($valeurs['niveau.code']);
$this->assertArrayHasKey('niveau.libelle', $valeurs, "Le json ne contient pas d'attribut : niveau.libelle . Voir : $url");
$this->assertNotEmpty($valeurs['niveau.libelle']);
$this->assertArrayHasKey('niveau.detail', $valeurs, "Le json ne contient pas d'attribut : niveau.detail . Voir : $url");
$this->assertNotEmpty($valeurs['niveau.detail']);
}
}
public function testMasqueNiveau() {
$parametres = array('masque.niveau' => 'ORD');
 
$url = ServiceEflorePhpUnit::creerUrl($this->service, [], $parametres);
$retour = $this->consulterJson($this->service, $this->projet, [], $parametres);
foreach ($retour['resultat'] as $cle => $valeurs) {
$this->assertEquals( $valeurs['niveau.code'], 'ORD','le masque.niveau ne fonctionne pas.');
}
 
$url = ServiceEflorePhpUnit::creerUrl($this->service, ['catminat:07-2.0.1.0.1-08','relations','niveaux-sup'], $parametres);
$retour = $this->consulterJson($this->service, $this->projet, ['catminat:07-2.0.1.0.1-08','relations','niveaux-sup'], $parametres);
foreach ($retour['resultat'] as $cle => $valeurs) {
$this->assertEquals( $valeurs['niveau.code'], 'ORD','le masque.niveau ne fonctionne pas.');
}
 
}
public function testMasqueRetenu() {
$ressourcesList = array();
$parametres = array('masque.retenu' => 'true');
foreach ($ressourcesList as $ressources) {
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
foreach ($retour['resultat'] as $cle => $valeurs) {
$this->assertStringStartsNotWith('syn',$valeurs['niveau.code'],'le masque.retenu ne fonctionne pas pour true.');
}
}
$parametres = array('masque.retenu' => 'false');
foreach ($ressourcesList as $ressources) {
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
foreach ($retour['resultat'] as $cle => $valeurs) {
$this->assertStringStartsWith('syn',$valeurs['niveau.code'],'le masque.retenu ne fonctionne pas pour false.');
}
}
}
public function testMasqueCatminat() {
$ressourcesList = array(
array(),
array('catminat:07-2.0.1.0.1-08','relations','niveaux-sup'),
);
$parametres = array('masque.catminat' => '07-2.');
foreach ($ressourcesList as $ressources) {
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
foreach ($retour['resultat'] as $cle => $valeurs) {
$this->assertEquals( $valeurs['code_catminat'], '07/2.','le masque.niveau ne fonctionne pas.');
}
}
}
public function testMasqueFixe() {
$ressourcesList = array(
array(),
array('catminat:07-2.0.1.0.1-08','relations','niveaux-sup'),
);
$parametres = array('masque.fixe' => '2322');
foreach ($ressourcesList as $ressources) {
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
foreach ($retour['resultat'] as $cle => $valeurs) {
$this->assertEquals( $valeurs['code_fixe_nom'], '2322','le masque.fixe ne fonctionne pas.');
}
}
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/eflore/EfloreCartesTest.php
New file
0,0 → 1,52
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class EfloreCartesTest extends ServiceEflorePhpUnit {
 
private $retour = '';
private $map = '';
 
public function __construct() {
$this->projet = 'eflore';
$this->service = 'cartes';
}
 
public function setUp() {
$this->retour = '';
$this->map = '';
}
 
public function testCarteGenerale() {
$ressources = array();//nn = 141; nt = 8522; nom = 'Acer campestre L.'; nom_ss_auteur = 'Acer campestre'
$parametres = array('projet' => 'general', 'masque.nn' => '141', 'masque.nt' => '8522',
'masque.ns' => 'Acer campestre', 'masque.au' => 'L.', 'retour' => 'text/html');
 
$this->retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($this->retour, $this->retour);
$this->assertContains('<img', $this->retour, 'doit contenir une balise image');
$this->assertContains('nt8522_france_utm_600x564.png', $this->retour, 'l\'adresse doit se terminer par nt8522_france_utm_600x564.png');
$this->assertContains('<map', $this->retour, 'doit contenir une balise map');
$this->assertContains('CEL', $this->retour, 'doit contenir une observation CEL');
$this->assertContains('SOPHY', $this->retour, 'doit contenir une observation SOPHY');
}
 
public function testCarteGeneriqueLegende() {
$ressources = array('legende');
$parametres = array();
 
$this->retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($this->retour);
$this->assertGreaterThanOrEqual(4, count($this->retour), 'doit contenir au - les légendes de cel, cen-lr, sophy et plusieurs'. print_r($this->retour, true));
$this->assertArrayHasKey('code', $this->retour[0], 'contient le code du projet');
$this->assertArrayHasKey('couleur', $this->retour[0], 'contient le code couleur correspondant');
$this->assertArrayHasKey('nom', $this->retour[0], 'contient le nom du projet');
$this->assertArrayHasKey('description', $this->retour[0], 'contient une desctiption du projet');
}
 
private function verifierPresenceMessage($messageAttendu) {
$this->assertEquals($messageAttendu, $this->retour);
}
 
}
?>
/tags/v5.3-amandaie/services/tests/0.1/eflore/EfloreOntologiesTest.php
New file
0,0 → 1,63
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class EfloreOntologiesTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'eflore';
$this->service = 'ontologies';
}
 
public function testRecherche() {
$ressources = array();
$parametres = array();
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'données absentes');
$this->assertArrayHasKey('total', $retour['entete'], "Le json ne contient pas d'attribut : total. Voir : $url");
// 23 au 20/08/2013
$this->assertGreaterThanOrEqual('23', $retour['entete']['total'], "L'attribut 'total' devrait avoir une valeur >= '23'. Voir : $url");
$this->assertArrayHasKey('10', $retour['resultat'], "Le json ne contient pas d'ontologie n°10. Voir : $url");
$this->assertArrayHasKey('nom', $retour['resultat'][10], "Le json ne contient pas d'attribut : nom. Voir : $url");
$this->assertEquals('legendeCarte', $retour['resultat'][10]['code'], "L'attribut 'code' devrait avoir la valeur 'legendeCarte'. Voir : $url");
$this->assertEquals('Légende carte eFlore observations', $retour['resultat'][10]['nom'], "L'attribut 'nom' devrait avoir la valeur 'Légende carte eFlore observations'. Voir : $url");
}
public function testMasqueCode() {
$ressources = array();
$parametres = array('masque.code' => 's');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'données absentes');
$this->assertArrayHasKey('total', $retour['entete'], "Le json ne contient pas d'attribut : total. Voir : $url");
$this->assertEquals('2', $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur '2'. Voir : $url");
$this->assertArrayHasKey('nom', $retour['resultat'][2], "Le json ne contient pas d'attribut : nom. Voir : $url");
$this->assertEquals('service', $retour['resultat'][2]['nom'], "L'attribut 'nom' devrait avoir la valeur 'service'. Voir : $url");
}
public function testMasqueNom() {
$ressources = array();
$parametres = array('masque.nom' => 'description');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'données absentes');
$this->assertArrayHasKey('total', $retour['entete'], "Le json ne contient pas d'attribut : total. Voir : $url");
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur '1'. Voir : $url");
$this->assertArrayHasKey('code', $retour['resultat'][6], "Le json ne contient pas d'attribut : code. Voir : $url");
$this->assertEquals('1', $retour['resultat'][6]['code'], "L'attribut 'code' devrait avoir la valeur '1'. Voir : $url");
}
 
public function disabledtestSeparateurToutesOntologies() {
$separateur = '|';
 
$db = new Bdd();
$tables = array_map(function($t) { return current($t); }, $db->recupererTous("SHOW TABLES LIKE '%_ontologies%'"));
$pattern = "SELECT count(1) AS c FROM %s WHERE complements LIKE '%%%s%%'";
foreach($tables as $t) {
echo $t."\n";
$c = $db->recuperer(sprintf($pattern, $t, $separateur))['c'];
$this->assertEquals(0, $c, "La colonne \"complements\" de la table d'ontologies \"$t\" contient le caractères \"$separateur\"");
}
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/baseflor/GraphiquesBaseflorTest.php
New file
0,0 → 1,267
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class GraphiquesBaseflorTest extends ServiceEflorePhpUnit {
private $svg;
public function __construct() {
$this->projet = 'baseflor';
$this->service = 'graphiques';
}
//++ ------------------------------------Test des ressources -----------------------------++
public function testRessourceTypeGraphiqueInexistante() {
$ressources = array('','bdtfx.nn:73256');
$parametres = array();
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur dans l'url de votre requête :".
"</br> precisez le graphique -> \"sol\" ou \"climat\".";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer l'absence de la ressource 'sol' ou 'climat'.");
}
public function testRessourceReferentielNnInexistante() {
$ressources = array('sol','');
$parametres = array();
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu =
"Erreur dans l'url de votre requête : précisez le référentiel et le numéro nomenclatural sous la forme {bdnt}.nn:{nn}.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer l'absence de la ressource {bdnt}.nn:{nn}.");
}
 
public function testRessourceReferentielTypeGraphiqueErronee() {
$ressources = array('humdite','bdtfx.nn:73256');
$parametres = array();
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur dans l'url de votre requête :".
"</br> precisez le graphique -> \"sol\" ou \"climat\".";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si la ressource type de graphique n'est ni sol' ni 'climat'.");
}
public function testRessourceReferentielNnEronne() {
$ressources = array('sol','gnnyh');
$parametres = array();
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu =
"Erreur dans l'url de votre requête : précisez le référentiel et le numéro nomenclatural sous la forme {bdnt}.nn:{nn}.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si la ressource {bdnt}.nn:{nn} est erronée.");
}
public function testRessourceReferentielInconnu() {
$ressources = array('climat','btdjv.nn:73256');
$parametres = array();
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Le référentiel btdjv n'existe pas.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si le référentiel est inconnu.");
}
public function testRessourceNNInconnu() {
$ressources = array('sol','bdtfx.nn:3');
$parametres = array();
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Les données recherchées sont introuvables.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si une requête ne renvoie pas de résultats.");
}
//++ ------------------------------------Test des paramètres -----------------------------++
public function testParametreInconnu() {
$ressources = array('sol','bdtfx.nn:73256');
$parametres = array('paramatre' => 'image/jpeg');
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur : Le paramètre paramatre est inconnu.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si un paramètre est inconnu.");
}
public function testParametreRetourInconnu() {
$ressources = array('sol','bdtfx.nn:73256');
$parametres = array('retour' => 'image/jpeg');
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu =
"Erreur : valeur inconnue. Choisissez le format de retour pour le paramètre retour : image/svg%2Bxml ou image/png.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si la valeur du paramètre retour est inconnue.");
}
public function testParametreRetourAbsent() {
$ressources = array('sol','bdtfx.nn:73256');
$parametres = array('retour' => '');
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu =
"Erreur : valeur inconnue. Choisissez le format de retour pour le paramètre retour : image/svg%2Bxml ou image/png.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si la valeur du paramètre retour est absente.");
}
public function testParametreRetourFormatAbsent() {
$ressources = array('sol','bdtfx.nn:73256');
$parametres = array('retour.format' => '');
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur : valeur inconnue. Entrez la largeur voulue (en pixels) pour le paramètre retour.format.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si la valeur du paramètre retour.format est absente.");
}
public function testParametreRetourFormatInconnu() {
$ressources = array('sol','bdtfx.nn:73256');
$parametres = array('retour.format' => 'dhgkg22');
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur : valeur inconnue. Entrez la largeur voulue (en pixels) pour le paramètre retour.format.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si la valeur du paramètre retour.format est inconnue.");
}
public function testParametreVersionProjetInconnu() {
$ressources = array('sol','bdtfx.nn:73256');
$parametres = array('version.projet' => 'dhgkg22');
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur : La version est inconnue.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si la valeur du paramètre version.projet est inconnue.");
}
public function testParametreVersionProjetAbsent() {
$ressources = array('sol','bdtfx.nn:73256');
$parametres = array('version.projet' => '');
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur : La version est inconnue.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si la valeur du paramètre version.projet est absente.");
}
//++------------------------------------------test des fichiers -------------------------++
public function testRetourEstUnSVG(){
$ressourcesListe = array(
array('sol','bdtfx.nn:73256'),
array('climat','bdtfx.nn:73256'),
array('climat','bdtfx.nn:101128'),
array('sol','bdtfx.nn:101128')
);
$parametresListe = array(
array('retour' => 'image/svg+xml'),
array()
);
foreach ($ressourcesListe as $ressources) {
foreach ($parametresListe as $parametres) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$this->chargerXml($retour);
$this->etreSvg($retour);
}
}
}
public function testSVGPresenceValeursEcolo_baseflor(){
$ressourcesListe = array(
array('sol','bdtfx.nn:73256'),
array('climat','bdtfx.nn:73256'),
);
$parametresListe = array();
foreach ($ressourcesListe as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametresListe);
$this->chargerXml($retour);
$this->etreSvg($retour);
$test = false;
$curseurs = $this->svg->getElementsByTagName('circle');
foreach ($curseurs as $curseur){
$classe = $curseur->getAttribute('class');
if ($classe == 'curseur') {
$test = true;
break;
}
}
}
$this->assertTrue($test,"Le graphique renvoyé par $retour est vide de données écologiques.");
}
public function testSVGPresenceValeursEcolo_rangSup(){
$ressourcesListe = array(
array('climat','bdtfx.nn:101128'),
array('sol','bdtfx.nn:101128')
);
$parametresListe = array();
foreach ($ressourcesListe as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametresListe);
$this->chargerXml($retour);
$this->etreSvg($retour);
$test = false;
$cases = $this->svg->getElementsByTagName('rect');
// ne fonctionne pas :
/*$dompath = new DOMXPath($this->svg);
$dompath->registerNamespace("svg", "http://www.w3.org/2000/svg");
$cases = $dompath->query('svg:rect[@fill and not(@id="fond" or @id="cache")]');*/
foreach ($cases as $case){
$classe = $case->getAttribute('class');
if ($classe != 'fond' and $classe != 'cache' and $case->getAttribute('fill') != 'none') {
$test = true;
break;
}
}
}
$this->assertTrue($test,"Le graphique renvoyé par $retour est vide de données écologiques.");
}
public function testExistenceDesSvgDeBase(){
$this->assertFileExists(config::get('chemin')."sol.svg","le svg de base sol.svg n'existe pas.");
$this->assertFileExists(config::get('chemin')."climat.svg","le svg de base climat.svg n'existe pas.");
$this->assertFileExists(config::get('chemin')."sol_min_max.svg","le svg de base sol_min_max.svg n'existe pas.");
$this->assertFileExists(config::get('chemin')."climat_min_max.svg","le svg de base climat_min_max.svg n'existe pas.");
 
}
public function testCreationSvgEtPngDansCache(){
$convertisseur = config::get('convertisseur');
if ($convertisseur == 'rsvg') {
$ressourcesListe = array(
array('sol','bdtfx.nn:73256'),
array('climat','bdtfx.nn:73256'),
array('climat','bdtfx.nn:101128'),
array('sol','bdtfx.nn:101128'));
$parametresListe = array('retour' => 'image/png');
foreach ($ressourcesListe as $ressources) {
ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametresListe);
$fichier = config::get('cache_stockageChemin') . $this->getFichier($ressources);
$this->assertFileExists($fichier.".svg"," {$fichier}.svg n'existe pas.");
$this->assertFileExists($fichier.".png"," {$fichier}.png n'existe pas.");
}
}
}
//++------------------------------------------fonctions utiles-------------------------++
private function chargerXml($retour) {
$this->svg = new DOMDocument();
$chargement = $this->svg->loadXML($retour);
$this->assertTrue($chargement,"le fichier ne s'est pas chargé.");
}
private function etreSvg($retour) {
$racineElement = $this->svg->documentElement;
$this->assertEquals('svg', $racineElement->tagName,"$retour ne renvoie pas un svg." );
}
private function getFichier($ressources) {
$idfichier = str_replace(".","-",$ressources[1]);
$idfichier = str_replace(':','-',$idfichier);
$idfichier .= "-".$ressources[0];
return $idfichier;
}
}
 
?>
/tags/v5.3-amandaie/services/tests/0.1/baseflor/InformationsBaseflorTest.php
New file
0,0 → 1,356
<?php
 
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class InformationsBaseflorTest extends ServiceEflorePhpUnit {
public function __construct() {
$this->projet = 'baseflor';
$this->service = 'informations';
}
//++ ------------------------------------Test des ressources -----------------------------++
public function testRessourceReferentielInconnu() {
$ressources = array('dgoju.nn:73256');
$parametres = array();
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$this->assertEquals("Données introuvables dans la base", $retour, "Il faut renvoyer \"données introuvables\" en cas de référentiel inconnu.");
}
public function testRessourceInconnue() {
$ressources = array('inconnue');
$parametres = array();
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu =
"Erreur dans l'url de votre requête : </br> La ressource demandée n'existe pas.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si une ressource est eronnée.");
}
public function testRessourceNNInconnu() {
$ressources = array('bdtfx.nn:3');
$parametres = array();
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$this->assertEquals("Données introuvables dans la base", $retour, "Il faut indiquer si une requête ne renvoie pas de résultats.");
}
//++ ------------------------------------Test des paramètres -----------------------------++
public function testParametreInconnu() {
$ressourcesList = array(
array('bdtfx.nn:73256'),
array('bdtfx.nn:101128'));
$parametres = array('paramatre' => 'image/jpeg');
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur dans les parametres de votre requête :".
" </br> Le paramètre \" paramatre \" n'existe pas.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si un paramètre est inconnu.");
}
}
public function testParametreCategorieInconnue() {
$ressourcesList = array(
array('bdtfx.nn:73256'),
array('bdtfx.nn:101128'));
$parametres = array('categorie' => 'inventé');
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Valeur de paramètre inconnue pour 'categorie'. Ce paramètre n'est pas autorisé";
$this->assertContains($messageAttendu, $retour,
"Il faut indiquer si la valeur du paramètre categorie est inconnue pour (" . implode(',', $ressources) . ").");
}
}
public function testParametreNavigationDepartSansLimite() {
$ressources = array();
$parametres = array('navigation.depart' => 10);
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "indiquez également la valeur pour le paramètre navigation.limite.";
$this->assertEquals($messageAttendu, $retour,
"Navigation.depart doit être accompagné de navigation.limite ensemble.");
 
}
public function testParametreDepartSuperieurTotalResultats() {
$ressources = array();
$parametres = array('navigation.depart' => 20000, 'navigation.limite' => 10 );
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu =
"Erreur : la valeur pour le paramètre navigation.départ est supérieure".
" au nombre total de résultats.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si la valeur de départ est supérieure au nombre de résultats.");
}
public function testParametreNavigationErrone() {
$ressources = array();
$parametresList = array(
array('navigation.depart' => -5, 'navigation.limite' => 10 ),
array('navigation.depart' => 0, 'navigation.limite' => 'abc' ));
$cles = array('navigation.depart','navigation.limite');
$i = 0 ;
foreach ($parametresList as $parametres) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur : valeur erronnée pour le paramètre {$cles[$i]}.";
$this->assertEquals($messageAttendu, $retour,
"il faut indiquer lorsque qu'un des paramètres de navigation a une valeur impossible.");
$i++;
}
}
public function testParametreRetourFormatErrone() {
$ressourcesList = array(
array('bdtfx.nn:73256'),
array('bdtfx.nn:101128'));
$parametres = array('retour.format' => 'pdf');
foreach ($ressourcesList as $ressources) {
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Valeur de paramètre inconnue pour 'retour.format'. Ce paramètre n'est pas autorisé";
$this->assertContains($messageAttendu, $retour,
"il faut indiquer lorsque que le paramètre retour.format a une valeur impossible.");
}
}
public function testParametreVersionProjetInconnu() {
$ressourcesList = array(
array('bdtfx.nn:73256'),
array('bdtfx.nn:101128'));
$parametres = array('version.projet' => 'dhgkg22');
foreach ($ressourcesList as $ressources){
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Erreur : La version est inconnue.";
$this->assertEquals($messageAttendu, $retour,
"Il faut indiquer si la valeur du paramètre version.projet est inconnue.");
}
}
//++ ------------------------------------Test du retour json correct -----------------------------++
//++ ---Informations ----++
public function testJsonBienFormeInformations() {
$ressources = array();
$parametres = array('navigation.depart' => 10, 'navigation.limite' => 15);
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url");
$this->assertArrayHasKey('resultats', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url");
$this->verifierJsonEnteteBienFormeInformations($retour, $ressources, $parametres);
}
private function verifierJsonEnteteBienFormeInformations($retour, $ressources, $parametres) {
//depart
$this->assertArrayHasKey('depart', $retour['entete'],
"L'en-tête ne contient pas d'attribut : depart ");
$this->assertEquals($retour['entete']['depart'], $parametres['navigation.depart'],
"La valeur de départ est incorrecte dans l'en-tête.");
//limite
$this->assertArrayHasKey('limite', $retour['entete'],
"L'en-tête ne contient pas d'attribut : limite");
$this->assertEquals($retour['entete']['limite'], $parametres['navigation.limite'],
"La valeur de limite est incorrecte dans l'en-tête.");
//total
$this->assertArrayHasKey('total', $retour['entete'],
"L'en-tête ne contient pas d'attribut : total ");
$this->assertNotEquals('', $retour['entete']['total'],
"La valeur de total est vide dans l'en-tête.");
//href
$this->assertArrayHasKey('href.suivant', $retour['entete'],
"L'en-tête ne contient pas d'attribut : href.suivant ");
$this->assertArrayHasKey('href.precedent', $retour['entete'],
"L'en-tête ne contient pas d'attribut : href.precedent ");
$parametres_url =
array('navigation.depart' => ($retour['entete']['limite']+$retour['entete']['depart']),
'navigation.limite' => $retour['entete']['limite'] );
$urlsuivant = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres_url);
$this->assertEquals($urlsuivant, $retour['entete']['href.suivant'],
"L' url $urlsuivant de l'entete est incorrecte.");
}
public function testJsonResultatsHrefInformations() {
$ressources = array();
$parametres = array('navigation.depart' => 370, 'navigation.limite' => 5);
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
foreach ($retour['resultats'] as $id => $valeurs) {
if (!$valeurs['num_nomen']) {
$this->assertArrayNotHasKey('href', $valeurs,
"Il ne doit pas avoir de lien s'il n'y a pas de numéro nomenclatural (=0). Voir $url ");
}
}
}
public function testJsonNombreLimiteDemande() {
$ressources = array();
$parametres = array();
$parametresList = array('navigation.depart' => 10, 'navigation.limite' => 15 );
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertLessThanOrEqual(15, count($retour),
"Le json renvoie un nombre de résultats trop important : entete. Voir : $url");
}
//++ ---Informations.nn ----++
public function testJsonInformationsNN_min() {
$ressourcesList = array(
array('bdtfx.nn:73256'),
array('bdtfx.nn:101128'));
$parametres = array('retour.format' => 'min' );
foreach ($ressourcesList as $ressources) {
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayNotHasKey('type_bio.code',$retour,
"Le champs 'type_bio.code' ne doit pas être présent si retour.format=min. ");
$this->assertArrayNotHasKey('type_bio.libelle',$retour,
"Le champs 'type_bio.libelle' ne doit pas être présent si retour.format=min.");
$this->assertArrayNotHasKey('type_bio.detail',$retour,
"Le champs 'type_bio.detail' ne doit pas être présent si retour.format=min.");
$champs = array_keys(Outils::recupererTableauConfig('Paramètres.champs_ontologiques'));
foreach ($champs as $chps) {
$this->assertArrayNotHasKey($chps.'.libelle', $retour,
"Le champs '{$chps}.libelle' ne doit pas être présent si retour.format=min.");
$this->assertArrayNotHasKey($chps.'.code', $retour,
"Le champs '{$chps}.code' ne doit pas être présent si retour.format=min.");
$this->assertArrayNotHasKey($chps.'.href', $retour,
"Le champs '{$chps}.href' ne doit pas être présent si retour.format=min.");
}
foreach ($champs as $chps) {
$this->assertArrayNotHasKey($chps.'_min.libelle', $retour,
"Le champs '{$chps}_min.libelle' ne doit pas être présent si retour.format=min.");
$this->assertArrayNotHasKey($chps.'_min.code', $retour,
"Le champs '{$chps}_min.code' ne doit pas être présent si retour.format=min.");
$this->assertArrayNotHasKey($chps.'_min.href', $retour,
"Le champs '{$chps}_min.href' ne doit pas être présent si retour.format=min.");
$this->assertArrayNotHasKey($chps.'_max.libelle', $retour,
"Le champs '{$chps}_max.libelle' ne doit pas être présent si retour.format=min.");
$this->assertArrayNotHasKey($chps.'_max.code', $retour,
"Le champs '{$chps}_max.code' ne doit pas être présent si retour.format=min.");
$this->assertArrayNotHasKey($chps.'_max.href', $retour,
"Le champs '{$chps}_max.href' ne doit pas être présent si retour.format=min.");
}
}
}
public function testJsonInformationsNNBasefor_max() {
$retour = $this->consulterJson($this->service, $this->projet, ['bdtfx.nn:73256'], ['retour.format' => 'max', 'categorie' => 'description']);
$this->verifierParametresDescription_max($retour);
 
$retour = $this->consulterJson($this->service, $this->projet, ['bdtfx.nn:73256'], ['retour.format' => 'max', 'categorie' => 'ecologie']);
$this->verifierParametresEcologie_max($retour, 'baseflor');
}
public function testJsonInformationsNNRangSup_max() {
$ressources = array('bdtfx.nn:101128');
$parametres = array('retour.format' => 'max' , 'categorie' => 'ecologie');
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
if ($parametres['categorie'] == 'description') {
$this->verifierParametresDescription_max();
} else {
$this->verifierParametresEcologie_max($retour, 'rangSup');
}
}
 
private function verifierParametresDescription_max($retour) {
$this->assertArrayHasKey('type_bio.code',$retour,
"Le champs 'type_bio.code' doit être présent si retour.format=max. ");
$this->assertArrayHasKey('type_bio.libelle',$retour,
"Le champs 'type_bio.libelle' doit être présent si retour.format=max.");
$this->assertArrayHasKey('type_bio.detail',$retour,
"Le champs 'type_bio.detail' doit être présent si retour.format=max.");
}
private function verifierParametresEcologie_max($retour,$type) {
$champs = array_keys(Outils::recupererTableauConfig('Paramètres.champs_ontologiques'));
if ($type == 'baseflor') {
foreach ($champs as $chps) {
$this->assertArrayHasKey($chps.'.libelle', $retour,
"Le champs '{$chps}.libelle' doit être présent si retour.format=max.");
$this->assertArrayHasKey($chps.'.code', $retour,
"Le champs '{$chps}.code' doit être présent si retour.format=max.");
$this->assertArrayHasKey($chps.'.href', $retour,
"Le champs '{$chps}.href' doit être présent si retour.format=max.");
}
} elseif ($type == 'rangSup') {
foreach ($champs as $chps) {
$this->assertArrayHasKey($chps.'_min.libelle', $retour,
"Le champs '{$chps}_min.libelle' doit être présent si retour.format=max.");
$this->assertArrayHasKey($chps.'_min.code', $retour,
"Le champs '{$chps}_min.code' doit être présent si retour.format=max.");
$this->assertArrayHasKey($chps.'_min.href', $retour,
"Le champs '{$chps}_min.href' doit être présent si retour.format=max.");
$this->assertArrayHasKey($chps.'_max.libelle', $retour,
"Le champs '{$chps}_max.libelle' doit être présent si retour.format=max.");
$this->assertArrayHasKey($chps.'_max.code', $retour,
"Le champs '{$chps}_max.code' doit être présent si retour.format=max.");
$this->assertArrayHasKey($chps.'_max.href', $retour,
"Le champs '{$chps}_max.href' doit être présent si retour.format=max.");
}
}
}
//++ ------------------------------------Test du champs type biologique -----------------------------++
//TEST sur différents cas typique de 'type_bio.libelle'
public function testJsonTypeBioOntologies() {
$ressourcesList = array(array("bdtfx.nn:73256"),array("bdtfx.nn:70441"),array("bdtfx.nn:62911"),array("bdtfx.nn:72496"),
array("bdtfx.nn:6446"),array("bdtfx.nn:8373"), array("bdafx.nn:35574"), array("bdtfx.nn:62443"),
array("bdtfx.nn:62442"));
$parametres = array();
$resultats_attendus = array ('Grhi-aqua' => 'Géophytes (>= 1m) à rhizome (plantes aquatiques) ' ,
'test-aqua-car' => 'Thérophytes (< 1m) estivaux (plantes aquatiques, carnivores) ',
'grhi' => 'Géophytes (< 1m) à rhizome ',
'hsto(test)' => 'Hémicryptophytes (< 1m) stolonifères , Thérophytes (< 1m) estivaux ',
'Hsto-lia(Grhi-lia)' => 'Hémicryptophytes (>= 1m) stolonifères (lianes) , Géophytes (>= 1m) à rhizome (lianes) ',
'Cfru(b-cad)' => 'Chaméphytes (>= 1m) frutescents , Nanophanérophytes (2 à 4m) (caducifoliées) ',
'test-aqua(heri)' => 'Thérophytes (< 1m) estivaux (plantes aquatiques) , Hémicryptophytes (< 1m) érigé ',
'hbis(hsto,test)-suc' => 'Hémicryptophytes (< 1m) bisannuels (succulentes) , Hémicryptophytes (< 1m) stolonifères, Thérophytes (< 1m) estivaux ',
'hbis(hsto)-suc' => 'Hémicryptophytes (< 1m) bisannuels (succulentes) , Hémicryptophytes (< 1m) stolonifères ');
foreach ($ressourcesList as $ressources) {
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$code = $retour['type_bio.code'];
$this->assertEquals($resultats_attendus[$code], $retour['type_bio.libelle'],
"le traitement de l'ontologie pour les types biologiques est erroné pour $ressources[0] . ");
}
}
 
public function testRelationsCatminat() {
$ressources = array('bdtfx.nn:5641', 'relations', 'catminat');
$parametres = array();
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
 
// valeurs standards
$this->assertArrayHasKey('cle',$retour, "Le champ 'cle' doit être présent.");
$this->assertEquals('1693',$retour['cle'], "Le champ 'cle' est erroné.");
 
$this->assertArrayHasKey('num_nomen',$retour, "Le champ 'num_nomen' doit être présent.");
$this->assertEquals('5641',$retour['num_nomen'], "Le champ 'num_nomen' est erroné.");
 
$this->assertArrayHasKey('bdnt',$retour, "Le champ 'bdnt' doit être présent.");
$this->assertEquals('bdtfx',$retour['bdnt'], "Le champ 'bdnt' est erroné.");
 
// valeurs écologiques, test libelle
$this->assertArrayHasKey('ve_texture_sol_min.libelle',$retour, "Le champ 've_texture_sol_min.libelle' doit être présent.");
$this->assertEquals('intermédiaire',$retour['ve_texture_sol_min.libelle'], "Le champ 've_texture_sol_min.libelle' est erroné.");
 
$this->assertArrayHasKey('ve_humidite_atmos_min.code',$retour, "Le champ 've_humidite_atmos_min.code' doit être présent.");
$this->assertEquals('8',$retour['ve_humidite_atmos_min.code'], "Le champ 've_texture_sol_min.libelle' est erroné.");
 
// climat
$this->assertArrayHasKey('graphique_climat',$retour, "Le champ 'graphique_climat' doit être présent.");
$this->assertArrayHasKey('libelle',$retour['graphique_climat'], "Le champ 'graphique_climat > libelle' doit être présent.");
$this->assertArrayHasKey('href',$retour['graphique_climat'], "Le champ 'graphique_climat > href' doit être présent.");
$this->assertEquals('climat',$retour['graphique_climat']['libelle'], "Le champ 'graphique_climat > href' doit être présent.");
}
 
// TODO = ajouter un test pour Informations/id/Relations/catminat?navigation.limite=500&navigation.depart=0
}
?>
/tags/v5.3-amandaie/services/tests/0.1/baseflor/OntologiesBaseflorTest.php
New file
0,0 → 1,44
<?php
 
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class OntologiesBaseflorTest extends ServiceEflorePhpUnit {
public function __construct() {
$this->projet = 'baseflor';
$this->service = 'ontologies';
}
public function testRecherche() {
$ressources = array();
$parametres = array("navigation.depart" => 20, "navigation.limite" => 100);
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'données absentes');
//limite
$this->assertArrayHasKey('limite', $retour['entete'],
"L'en-tête ne contient pas d'attribut : limite");
$this->assertEquals($retour['entete']['limite'], $parametres['navigation.limite'],
"La valeur de limite est incorrecte dans l'en-tête.");
//total
$this->assertArrayHasKey('total', $retour['entete'],
"L'en-tête ne contient pas d'attribut : total ");
$this->assertEquals('156', $retour['entete']['total'],
"L'attribut 'total' devrait avoir la valeur '156. Voir : $url");
//href
$this->assertArrayHasKey('href.suivant', $retour['entete'],
"L'en-tête ne contient pas d'attribut : href.suivant ");
$this->assertArrayHasKey('href.precedent', $retour['entete'],
"L'en-tête ne contient pas d'attribut : href.precedent ");
$parametres_url =
array('navigation.depart' => ($retour['entete']['limite']+$retour['entete']['depart']),
'navigation.limite' => $retour['entete']['limite'] );
$urlsuivant = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres_url);
$this->assertEquals($urlsuivant, $retour['entete']['href.suivant'],
"L' url $urlsuivant de l'entete est incorrecte.");
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/coste/CosteNomsTest.php
New file
0,0 → 1,217
<?php
/*
* @copyright 2013 Tela Botanica (accueil@tela-botanica.org)
* @author Raphaël Droz <raphael@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>
*/
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class CosteNomsTest extends ServiceEflorePhpUnit {
 
static $P = "coste";
static $S = "textes";
 
// test d'obtention d'information sur num_nom connu
public function testRessource() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array(182));
$retour = $this->consulterJson(self::$S, self::$P, array(182));
$this->commonTestHeader($retour, $url);
$this->assertEquals(1, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 1. Voir : $url");
$this->commonTest($retour, $url, 182);
$this->assertEquals(182, $retour['resultats'][182]['coste:nn'], "error: ['resultats'][182]['coste:nn']. Voir : $url");
$this->assertEquals("Roemeria violacea", $retour['resultats'][182]['titre'], "error: ['resultats'][182]['titre']. Voir : $url");
// tag peut peut-être varier à travers les décennies ?
// testRechercheTag ?
$this->assertArrayHasKey('tag', $retour['resultats'][182], "Le json [182] ne contient pas d'élément tag. Voir : $url");
$this->assertContains("HYBRIDA", $retour['resultats'][182]['texte'], "error: ['resultats'][182]['texte']. Voir : $url");
$this->assertEquals(56272, $retour['resultats'][182]['bdtfx:nn'], "error: ['resultats'][182]['titre']. Voir : $url");
}
 
public function testBdtfxRessource() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array("bdtfx.nn:182"));
$retour = $this->consulterJson(self::$S, self::$P, array("bdtfx.nn:182"));
$this->commonTestHeader($retour, $url);
$this->assertEquals(1, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 1. Voir : $url");
$this->commonTest($retour, $url, 1027);
$this->assertEquals("Acer monspessulanum", $retour['resultats'][1027]['titre'], "error: ['resultats'][1027]['titre']. Voir : $url");
$this->assertArrayHasKey('tag', $retour['resultats'][1027], "Le json [1027] ne contient pas d'élément tag. Voir : $url");
$this->assertContains("Érable de Montpellier", $retour['resultats'][1027]['texte'], "error: ['resultats'][1027]['texte']. Voir : $url");
$this->assertEquals(1027, $retour['resultats'][1027]['coste:nn'], "error: ['resultats'][1027]['coste:nn']. Voir : $url");
$this->assertEquals(182, $retour['resultats'][1027]['bdtfx:nn'], "error: ['resultats'][1027]['coste:nn']. Voir : $url");
}
 
 
public function testRessources() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array("bdtfx.nn:182,abcd,666"));
$retour = $this->consulterJson(self::$S, self::$P, array("bdtfx.nn:182,abcd,666"));
$this->commonTestHeader($retour, $url);
$this->assertEquals(2, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 2. Voir : $url");
$this->commonTest($retour, $url, 1027);
$this->assertEquals("Acer monspessulanum", $retour['resultats'][1027]['titre'], "error: ['resultats'][1027]['titre']. Voir : $url");
$this->assertArrayHasKey('titre', $retour['resultats'][1027], "Le json [1027] ne contient pas d'élément titre. Voir : $url");
$this->assertArrayHasKey('titre', $retour['resultats'][666], "Le json [666] ne contient pas d'élément titre. Voir : $url");
$this->assertEquals("Acer monspessulanum", $retour['resultats'][1027]['titre'], "error: ['resultats'][1027]['titre']. Voir : $url");
$this->assertEquals("Silene reflexa", $retour['resultats'][666]['titre'], "error: ['resultats'][666]['titre']. Voir : $url");
 
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array("a,-1,99999"));
$retour = $this->consulterBrut(self::$S, self::$P, array("a,-1,99999"));
$this->assertEquals("not supported", $retour, "error, Voir : $url");
}
 
public function testNonExistantRessource() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array("-182"));
$retour = $this->consulterBrut(self::$S, self::$P, array("-182"));
$this->assertEquals("not supported", $retour, "error. Voir : $url");
}
 
// les critères se cumulent
public function testRessourceEtMasque() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array(182), array("masque.ns" => "ABC"));
$retour = $this->consulterJson(self::$S, self::$P, array(182), array("masque.ns" => "ABC"));
$this->commonTestHeader($retour, $url);
$this->assertEquals(0, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 0. Voir : $url");
}
 
public function testRessourceFormatHTML() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array(182), array('txt.format' => 'htm'));
$retour = $this->consulterJson(self::$S, self::$P, array(182), array('txt.format' => 'htm'));
$this->assertContains("span class", $retour['resultats'][182]['titre'], "error: ['resultats'][182]['titre']. Voir : $url");
}
 
public function testRessourceChamps() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array(182), array('retour.champs' => 'titre,tome,page,famille,bdtfx:nt'));
$retour = $this->consulterJson(self::$S, self::$P, array(182), array('retour.champs' => 'titre,tome,page,famille,bdtfx:nt'));
$this->assertCount(1, $retour['resultats'], "error: ['resultats'][182]. Voir : $url");
$this->assertArrayHasKey("coste:nn", $retour['resultats'][182], "error: ['resultats'][182], clef coste:nn. Voir : $url");
$this->assertArrayHasKey("titre", $retour['resultats'][182], "error: ['resultats'][182], clef titre. Voir : $url");
$this->assertArrayHasKey("tome", $retour['resultats'][182], "error: ['resultats'][182], clef tome. Voir : $url");
$this->assertArrayHasKey("page", $retour['resultats'][182], "error: ['resultats'][182], clef page. Voir : $url");
$this->assertArrayHasKey("famille", $retour['resultats'][182], "error: ['resultats'][182], clef famille. Voir : $url");
$this->assertArrayHasKey("bdtfx:nt", $retour['resultats'][182], "error: ['resultats'][182], clef bdtfx:nt. Voir : $url");
$this->assertEquals(1, $retour['resultats'][182]['tome'], "error: ['resultats'][182]['tome']. Voir : $url");
$this->assertEquals(62, $retour['resultats'][182]['page'], "error: ['resultats'][182]['page']. Voir : $url");
$this->assertEquals("Papaveraceae", $retour['resultats'][182]['famille'], "error: ['resultats'][182]['famille']. Voir : $url");
$this->assertEquals(4057, $retour['resultats'][182]['bdtfx:nt'], "error: ['resultats'][182]['bdtfx:nt']. Voir : $url");
}
 
 
public function testRechercheNS() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, NULL, array("masque.ns" => "Roemeria", "recherche" => "etendue"));
$retour = $this->consulterJson(self::$S, self::$P, NULL, array("masque.ns" => "Roemeria", "recherche" => "etendue"));
$this->commonTestHeader($retour, $url);
$this->assertEquals(3, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 3. Voir : $url");
$this->commonTest($retour, $url, 182);
$this->assertEquals("Roemeria violacea", $retour['resultats'][182]['titre'], "error: ['resultats'][182]['titre']. Voir : $url");
}
 
 
public function testRechercheTXT() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, NULL, array("masque.txt" => "Nancy"));
$retour = $this->consulterJson(self::$S, self::$P, NULL, array("masque.txt" => "Nancy"));
$this->assertEquals(2, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 2. Voir : $url");
$this->assertArrayHasKey("1774", $retour['resultats'], "error: ['resultats']['1774']. Voir : $url");
$this->assertArrayHasKey("1775", $retour['resultats'], "error: ['resultats']['1775']. Voir : $url");
 
$url = ServiceEflorePhpUnit::creerUrl(self::$S, NULL, array("masque.txt" => "Nancy", "recherche" => "floue"));
$retour = $this->consulterJson(self::$S, self::$P, NULL, array("masque.txt" => "Nancy", "recherche" => "floue"));
$this->assertEquals(2, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 2. Voir : $url");
$this->assertArrayHasKey("1774", $retour['resultats'], "error: ['resultats']['1774']. Voir : $url");
$this->assertArrayHasKey("1775", $retour['resultats'], "error: ['resultats']['1775']. Voir : $url");
 
$url = ServiceEflorePhpUnit::creerUrl(self::$S, NULL, array("masque.txt" => "Nancy", "masque.tome" => 2));
$retour = $this->consulterJson(self::$S, self::$P, NULL, array("masque.txt" => "Nancy", "masque.tome" => 2));
$this->assertEquals(1, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 1. Voir : $url");
$this->assertArrayHasKey("1774", $retour['resultats'], "error: ['resultats']['1774']. Voir : $url");
 
$url = ServiceEflorePhpUnit::creerUrl(self::$S, NULL, array("masque.txt" => "Nancy", "masque.page" => 0));
$retour = $this->consulterJson(self::$S, self::$P, NULL, array("masque.txt" => "Nancy", "masque.page" => 0));
$this->assertEquals(1, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 1. Voir : $url");
$this->assertArrayHasKey("1775", $retour['resultats'], "error: ['resultats']['1775']. Voir : $url");
}
 
 
// par compatibilité, "titre" signifie une recherche sur "tag" (le titre de la page wiki de la description
// ou des clefs de détermination)
public function testRechercheTag() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, NULL, array("masque.titre" => "Esp0131RoemeriaViolacea"));
$retour = $this->consulterJson(self::$S, self::$P, NULL, array("masque.titre" => "Esp0131RoemeriaViolacea"));
$this->commonTestHeader($retour, $url);
$this->assertEquals(2, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 2. Voir : $url");
$this->commonTest($retour, $url, 182);
$this->assertEquals("Roemeria violacea", $retour['resultats'][182]['titre'], "error: ['resultats'][182]['titre']. Voir : $url");
$this->assertArrayHasKey('tag', $retour['resultats'][182], "Le json [182] ne contient pas d'élément tag. Voir : $url");
$this->assertEquals("Esp0131RoemeriaViolacea", $retour['resultats'][182]['tag'], "error: ['resultats'][182]['tag']. Voir : $url");
}
 
public function testRechercheNT() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, NULL, array("masque.nt" => 8523));
$retour = $this->consulterJson(self::$S, self::$P, NULL, array("masque.nt" => 8523));
$this->commonTestHeader($retour, $url);
$this->assertEquals(1, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 1. Voir : $url");
$this->commonTest($retour, $url, 1027);
$this->assertEquals("Acer monspessulanum", $retour['resultats'][1027]['titre'], "error: ['resultats'][182]['titre']. Voir : $url");
}
 
public function testRechercheFamille() {
// unknown famille
$url = ServiceEflorePhpUnit::creerUrl(self::$S, NULL, array("masque.famille" => "ABC"));
$retour = $this->consulterJson(self::$S, self::$P, NULL, array("masque.famille" => "ABC"));
$this->assertEquals(0, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 0. Voir : $url");
 
// par famille, mais pas de recherche étendue pour ça
$url = ServiceEflorePhpUnit::creerUrl(self::$S, NULL, array("masque.famille" => "Sapind"));
$retour = $this->consulterJson(self::$S, self::$P, NULL, array("masque.famille" => "Sapind"));
$this->assertEquals(0, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 0. Voir : $url");
 
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array("bdtfx.nn:182"), array("masque.famille" => "Sapindaceae"));
$retour = $this->consulterJson(self::$S, self::$P, array("bdtfx.nn:182"), array("masque.famille" => "Sapindaceae"));
$this->assertEquals(1, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 1. Voir : $url");
 
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array("bdtfx.nn:182"), array("masque.famille" => "Sapind%"));
$retour = $this->consulterJson(self::$S, self::$P, array("bdtfx.nn:182"), array("masque.famille" => "Sapind%"));
$this->assertEquals(1, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 1. Voir : $url");
 
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array("bdtfx.nn:182"), array("masque.famille" => "S_pindaceae"));
$retour = $this->consulterJson(self::$S, self::$P, array("bdtfx.nn:182"), array("masque.famille" => "S_pindaceae"));
$this->assertEquals(1, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur 1. Voir : $url");
}
 
// le webservice permet de définir la clef d'index choisir: par num_nom de coste ou num_nom de bdtfx
public function testIndex() {
$url = ServiceEflorePhpUnit::creerUrl(self::$S, NULL, array("masque.famille" => "Sapindaceae"));
$retour = $this->consulterJson(self::$S, self::$P, NULL, array("masque.famille" => "Sapindaceae"));
$e = array(1030,1027,1026,1028,1036,1025);
$r = array_keys($retour['resultats']);
sort($r);sort($e);
$this->assertEquals($e, $r, "Erreur des l'index des résultats. Voir : $url");
 
$url = ServiceEflorePhpUnit::creerUrl(self::$S, NULL, array("masque.famille" => "Sapindaceae", "retour.indexBy" => "bdtfx"));
$retour = $this->consulterJson(self::$S, self::$P, NULL, array("masque.famille" => "Sapindaceae", "retour.indexBy" => "bdtfx"));
$e = array(182,1053,74934,210,141,199);
$r = array_keys($retour['resultats']);
sort($r);sort($e);
$this->assertEquals($e, $r, "Erreur des l'index des résultats. Voir : $url");
 
// le taxon coste:nn:183 ne correspond à ce jour (2013/09/04) à aucun taxon bdtfx
// l'indexation par bdtfx doit donc absolument échouer
$url = ServiceEflorePhpUnit::creerUrl(self::$S, array(183), array("retour.indexBy" => "bdtfx"));
$retour = $this->consulterBrut(self::$S, self::$P, array(183), array("retour.indexBy" => "bdtfx"));
$this->assertContains("error", $retour, "L'indexation par bdtfx doit retourner une erreur en cas de bdtfx.num_nom NULL. Voir : $url");
}
 
 
// commons
public function commonTestHeader($retour, $url) {
$this->assertNotEmpty($retour, 'données absentes');
$this->assertArrayHasKey('total', $retour['entete'], "Le json ne contient pas d'attribut : total. Voir : $url");
}
 
 
public function commonTest($retour, $url, $id) {
$this->assertArrayHasKey("$id", $retour['resultats'], "Le json ne contient pas d'élément $id. Voir : $url");
$this->assertArrayHasKey('titre', $retour['resultats'][$id], "Le json [$id] ne contient pas d'élément titre. Voir : $url");
$this->assertArrayHasKey('coste:nn', $retour['resultats'][$id], "Le json [$id] ne contient pas d'élément coste:nn. Voir : $url");
$this->assertArrayHasKey('bdtfx:nn', $retour['resultats'][$id], "Le json [$id] ne contient pas d'élément bdtfx:nn. Voir : $url");
}
}
/tags/v5.3-amandaie/services/tests/0.1/commun/CommunAideTest.php
New file
0,0 → 1,34
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class CommunAideTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'eflore';
$this->service = 'aide';
}
 
public function testAideSurCommun() {
$ressources = array();
$parametres = array();
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour['PROJET EFLORE'], 'données absentes');
$this->assertArrayHasKey('service.nom', $retour['PROJET EFLORE']['projet.services'][0], "Le json ne contient pas d'attribut : editeur. Voir : $url");
$this->assertEquals('ontologies', $retour['PROJET EFLORE']['projet.services'][0]['service.nom'], "L'attribut 'editeur' devrait avoir la valeur 'Tela Botanica'. Voir : $url");
}
public function testAideProjets() {
$ressources = array('projets');
$parametres = array();
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'données absentes');
$this->assertGreaterThanOrEqual(8, count($retour), $retour);
$this->assertNotEmpty($retour['eflore'], 'données absentes');
$this->assertArrayHasKey('service.nom', $retour['eflore']['projet.services'][0], "Le json ne contient pas d'attribut : editeur. Voir : $url");
$this->assertEquals('ontologies', $retour['eflore']['projet.services'][0]['service.nom'], "L'attribut 'editeur' devrait avoir la valeur 'Tela Botanica'. Voir : $url");
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/commun/CommunMetaDonneesTest.php
New file
0,0 → 1,22
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class CommunMetaDonneesTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'eflore';
$this->service = 'meta-donnees';
}
 
public function testValeurChampPrecis() {
$ressources = array('editeur');
$parametres = array();
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour[0], 'données absentes');
$this->assertArrayHasKey('editeur', $retour[0], "Le json ne contient pas d'attribut : editeur. Voir : $url");
$this->assertEquals('Tela Botanica', $retour[0]['editeur'], "L'attribut 'editeur' devrait avoir la valeur 'Tela Botanica'. Voir : $url");
$this->assertArrayNotHasKey('langue', $retour[0], "Le json contient un attribut : langue. Voir : $url");
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/commun/CommunOntologiesTest.php
New file
0,0 → 1,109
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class CommunOntologiesTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'eflore';
$this->service = 'ontologies';
}
 
public function testRecherche() {
$ressources = array();
$parametres = array();
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'données absentes');
$this->assertArrayHasKey('total', $retour['entete'], "Le json ne contient pas d'attribut : total. Voir : $url");
// au 20/08/2013, n°23 = Baznat
$this->assertEquals('23', $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur '23'. Voir : $url");
$this->assertArrayHasKey('nom', $retour['resultat'][1], "Le json ne contient pas d'attribut : nom. Voir : $url");
$this->assertEquals('contactType', $retour['resultat'][1]['nom'], "L'attribut 'nom' devrait avoir la valeur 'contactType'. Voir : $url");
}
public function testMasqueCode() {
$ressources = array();
$parametres = array('masque.code' => 'o');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'données absentes');
$this->assertArrayHasKey('total', $retour['entete'], "Le json ne contient pas d'attribut : total. Voir : $url");
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur '1'. Voir : $url");
$this->assertArrayHasKey('nom', $retour['resultat'][4], "Le json ne contient pas d'attribut : nom. Voir : $url");
$this->assertEquals('organisations', $retour['resultat'][4]['nom'], "L'attribut 'nom' devrait avoir la valeur 'organisations'. Voir : $url");
}
public function testMasqueDescription() {
$ressources = array();
$parametres = array('masque.description' => '%contact');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'données absentes');
$this->assertArrayHasKey('total', $retour['entete'], "Le json ne contient pas d'attribut : total. Voir : $url");
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur '1'. Voir : $url");
$this->assertArrayHasKey('nom', $retour['resultat'][1], "Le json ne contient pas d'attribut : nom. Voir : $url");
$this->assertEquals('contactType', $retour['resultat'][1]['nom'], "L'attribut 'nom' devrait avoir la valeur 'contactType'. Voir : $url");
}
 
// simple test ontologies bdnt
// ce qui signifie les ontologies communes aux référentiels (bdtfx, bdtxa, isfan)
public function testBdntSimpleNonExistante() {
$url = '/bdnt' . ServiceEflorePhpUnit::creerUrl('ontologies', [ 'rangTaxo:-1' ] );
$retour = $this->consulterBrut('ontologies', 'bdnt', [ 'rangTaxo:-1' ] );
$this->assertContains($retour, 'Les données recherchées sont introuvables.');
}
 
public function testBdntSimpleExistante() {
$url = '/bdnt' . ServiceEflorePhpUnit::creerUrl('ontologies', [ 'rangTaxo:70' ] );
$retour = $this->consulterJson('ontologies', 'bdnt', [ 'rangTaxo:70' ] );
$this->assertNotEmpty($retour, 'données absentes');
foreach(['id', 'nom', 'code', 'complements', 'classe.id', 'classe', 'classe.href'] as $v) {
$this->assertArrayHasKey($v, $retour, "Le json ne contient pas l'attribut \"$v\". Voir : $url");
}
$this->assertEquals('15', $retour['id'], "L'attribut 'id' devrait avoir la valeur '15'. Voir : $url");
$this->assertEquals('Cladus', $retour['nom'], "L'attribut 'nom' devrait avoir la valeur 'Cladus'. Voir : $url");
}
 
// Les ontologies supportent les requêtes multiples, eg: /bdnt/ontologies/rangTaxo:70,rangTaxo:-1
// Les ontologies sont alors indexées par élément de requête (pour faciliter le travail du client)
// Les résultats inexistants ne sont pas retournés
public function testBdntMultiplesNonExistante() {
$ressource = [ implode(',', [ 'rangTaxo:70', 'rangTaxo:-1' ]) ];
$url = '/bdnt' . ServiceEflorePhpUnit::creerUrl('ontologies', $ressource );
$retour = $this->consulterJson('ontologies', 'bdnt', $ressource );
$this->assertNotEmpty($retour, 'données absentes');
$this->assertCount(1, $retour, "Le retour ne devrait contenir que le seul élément valide. Voir : $url");
$this->assertArrayHasKey('rangTaxo:70', $retour, "Le json ne contient pas d'élément rangTaxo:70. Voir : $url");
foreach(['id', 'nom', 'code', 'complements', 'classe.id', 'classe', 'classe.href'] as $v) {
$this->assertArrayHasKey($v, $retour['rangTaxo:70'], "Le json ne contient pas l'attribut \"$v\". Voir : $url");
}
$this->assertEquals('15', $retour['rangTaxo:70']['id'], "L'attribut 'id' devrait avoir la valeur '15'. Voir : $url");
$this->assertEquals('Cladus', $retour['rangTaxo:70']['nom'], "L'attribut 'nom' devrait avoir la valeur 'Cladus'. Voir : $url");
}
 
// Les ontologies supportent les requêtes multiples sur des code différents
// eg: /bdnt/ontologies/rangTaxo:70,zoneGeo:YT
public function testBdntMultiplesExistantes() {
$ressource = [ implode(',', [ 'rangTaxo:70', 'zoneGeo:YT' ]) ];
$url = '/bdnt' . ServiceEflorePhpUnit::creerUrl('ontologies', $ressource );
$retour = $this->consulterJson('ontologies', 'bdnt', $ressource );
$this->assertNotEmpty($retour, 'données absentes');
$this->assertCount(2, $retour, "Le retour devrait contenir 2 éléments valides. Voir : $url");
$this->assertArrayHasKey('rangTaxo:70', $retour, "Le json ne contient pas d'élément 'rangTaxo:70'. Voir : $url");
$this->assertArrayHasKey('zoneGeo:YT', $retour, "Le json ne contient pas d'élément 'zoneGeo:YT'. Voir : $url");
 
foreach($retour as $k => $e) {
foreach(['id', 'nom', 'code', 'classe.id', 'classe', 'classe.href'] as $v) {
$this->assertArrayHasKey($v, $e, "Le json ne contient pas l'attribut \"$v\" pour l'élément \"$k\". Voir : $url");
}
}
// n'existe pas pour "zoneGeo", pourquoi ?
$this->assertArrayHasKey('complements', $retour['rangTaxo:70'], "Le json ne contient pas l'attribut \"$v\". Voir : $url");
 
 
$this->assertEquals('15', $retour['rangTaxo:70']['id'], "L'attribut 'id' devrait avoir la valeur '15'. Voir : $url");
$this->assertEquals('Cladus', $retour['rangTaxo:70']['nom'], "L'attribut 'nom' devrait avoir la valeur 'Cladus'. Voir : $url");
$this->assertEquals('180', $retour['zoneGeo:YT']['id'], "L'attribut 'id' devrait avoir la valeur '180'. Voir : $url");
$this->assertEquals('Mayotte', $retour['zoneGeo:YT']['nom'], "L'attribut 'nom' devrait avoir la valeur 'Mayotte'. Voir : $url");
}
}
/tags/v5.3-amandaie/services/tests/0.1/liste-rouge/ListeRougeCategorieTest.php
New file
0,0 → 1,60
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class ListeRougeCategorieTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'liste-rouge';
$this->service = 'categorie';
}
public function testParametreMasqueNnExistant() {
$ressources = array();
$parametres = array('masque.nn'=>'3242');
$retour = ServiceEflorePhpUnit::consulterJson($this->service, $this->projet, $ressources, $parametres);
$retour_bool = is_array($retour) && isset($retour[0]) && isset($retour[0]['num_categorie']) && $retour[0]['num_categorie'] == 0;
$this->assertEquals(true, $retour_bool,
"Le service doit renvoyer des informations pour un masque.nn existant");
}
public function testParametreMasqueNnInexistant() {
$ressources = array();
$parametres = array('masque.nn'=>'1111');
$retour = ServiceEflorePhpUnit::consulterJson($this->service, $this->projet, $ressources, $parametres);
$retour_bool = is_array($retour) && empty($retour);
$this->assertEquals(true, $retour_bool,
"Le service doit renvoyer un tableau vide pour un masque.nn n'existant pas dans la base");
}
 
public function testParametreMasqueNnVide() {
$ressources = array();
$parametres = array('masque.nn'=>'');
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "renseignez une valeur pour masque.nn<br />la valeur pour masque.nn doit être un entier";
$this->assertEquals($messageAttendu, $retour,
"Le service doit renvoyer un message pour un masque.nn vide");
}
public function testParametreMasqueNnNonPrecise() {
$ressources = array();
$parametres = array();
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "renseignez une valeur pour masque.nn<br />la valeur pour masque.nn doit être un entier";
$this->assertEquals($messageAttendu, $retour,
"Le service doit renvoyer un message pour un masque.nn non renseigné");
}
public function testParametreMasqueNnNonNumerique() {
$ressources = array();
$parametres = array('masque.nn'=>'Acer');
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "la valeur pour masque.nn doit être un entier";
$this->assertEquals($messageAttendu, $retour,
"Le service doit renvoyer un message pour un masque.nn non numérique");
}
}
/tags/v5.3-amandaie/services/tests/0.1/nvjfl/NvjflNomsVernaTest.php
New file
0,0 → 1,255
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class NvjflNomsVernaTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'nvjfl';
$this->service = 'noms-vernaculaires';
}
 
public function testVersionPrecise() {
$ressources = array();
$parametres = array('version.projet' => '2007');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $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 testVersionInexistante() {
$ressources = array();
$parametres = array('version.projet' => '2011');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
 
$attendu = "La table recherchée n'existe pas";
$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();
$parametres = array(
'version.projet' => '2007',
'recherche' => 'stricte',
'masque' => 'Abricotier');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$url_attendu = ServiceEflorePhpUnit::creerUrl($this->service, array('111'), array('version.projet' => '2007'));
 
$retour = $this->consulterJson($this->service, $this->projet, $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->assertCount(1, $retour['resultat'], "Le résultat devrait contenir une seule donnée. Voir : $url");
$this->assertArrayNotHasKey('id', $retour['resultat']['111'], "Le tableau du résultat 111 ne doit pas contenir un champ 'id'. Voir : $url");
$this->assertArrayHasKey('href', $retour['resultat']['111'], "Le tableau du résultat 111 doit contenir un champ 'href'. Voir : $url");
$this->assertEquals($url_attendu, $retour['resultat']['111']['href'], "Le tableau du résultat 111 doit contenir un champ 'href' avec pour valeur $url_attendu . Voir : $url");
$this->assertArrayHasKey('nom', $retour['resultat']['111'], "Le tableau du résultat 111 doit contenir un champ 'nom'. Voir : $url");
$this->assertEquals('Abricotier', $retour['resultat']['111']['nom'], "Le tableau du résultat 111 doit contenir un champ 'nom' avec pour valeur 'Abricotier'. Voir : $url");
}
 
public function testMasqueNt() {
$ressources = array();
$parametres = array(
'version.projet' => '2007',
'recherche' => 'stricte',
'masque.nt' => '379');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$url_attendu = ServiceEflorePhpUnit::creerUrl($this->service, array('502'), array('version.projet' => '2007'));
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
 
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url");
$this->assertCount(2, $retour['resultat'], "Le résultat devrait contenir une seule donnée. Voir : $url");
$this->assertArrayNotHasKey('id', $retour['resultat']['502'], "Le tableau du résultat 502 ne doit pas contenir un champ 'id'. Voir : $url");
$this->assertArrayHasKey('href', $retour['resultat']['502'], "Le tableau du résultat 502 doit contenir un champ 'href'. Voir : $url");
$this->assertEquals($url_attendu, $retour['resultat']['502']['href'], "Le tableau du résultat 502 doit contenir un champ 'href' avec pour valeur $url_attendu. Voir : $url");
$this->assertArrayHasKey('nom', $retour['resultat']['502'], "Le tableau du résultat 502 doit contenir un champ 'nom'. Voir : $url");
$this->assertEquals('Adénostyle de Briquet', $retour['resultat']['502']['nom'], "Le tableau du résultat 502 doit contenir un champ 'nom' avec pour valeur 'Adénostyle de Briquet'. Voir : $url");
}
 
public function testMasqueLg() {
$ressources = array();
$parametres = array(
'version.projet' => '2007',
'recherche' => 'stricte',
'masque.lg' => 'fra',
'navigation.limite' => '100');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url");
$this->assertEquals('masque.lg=fra', $retour['entete']['masque'], "L'attribut 'masque' de l'entête devrait valoir 'masque.lg=fra'. Voir : $url");
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url");
$this->assertEquals('16411', $retour['entete']['total'], "L'attribut 'total' de l'entête devrait valoir 16411. Voir : $url");
$this->assertCount(100, $retour['resultat'], "Le résultat devrait contenir 100 données. Voir : $url");
}
public function testRechercheFloue() {
$ressources = array();
$parametres = array(
'version.projet' => '2007',
'recherche' => 'floue',
'masque' => 'Abrict');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$url_attendu_pattern = ServiceEflorePhpUnit::creerUrl($this->service, ['%d'], array('version.projet' => '2007'));
$retour = $this->consulterJson($this->service, $this->projet, $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('5', $retour['entete']['total'], "L'attribut 'total' de l'entête devrait valoir 1. Voir : $url");
$this->assertCount(5, $retour['resultat'], "Le résultat devrait contenir une seule donnée. Voir : $url");
$resultat_attendu = array(
"2611" => array("nom" => "Apricot", "href" => sprintf($url_attendu_pattern, 2611)),
"15868" => array("nom" => "Eyebright", "href" => sprintf($url_attendu_pattern, 15868)),
"4857" => array("nom" => "Berg-Ziest", "href" => sprintf($url_attendu_pattern, 4857)),
"33750" => array("nom" => "Periquet", "href" => sprintf($url_attendu_pattern, 33750)),
"17614" => array("nom" => "Frare cugot", "href"=> sprintf($url_attendu_pattern, 17614)));
$this->assertEquals($resultat_attendu, $retour['resultat'], "Le tableau de résultats est inattendu. Voir : $url");
}
 
public function testRechercheAttributions() {
$ressources = array('attributions');
$parametres = array(
'version.projet' => '2007',
'recherche' => 'stricte',
'masque.nv' => 'Acacia',
'retour.format' => 'min');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $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('4', $retour['entete']['total'], "L'attribut 'total' de l'entête devrait valoir 4. Voir : $url");
$this->assertCount(4, $retour['resultat'], "Le résultat devrait contenir une seule donnée. Voir : $url");
$this->assertArrayHasKey('id', $retour['resultat']['-880871632'], "Le tableau du résultat -880871632 ne doit pas contenir un champ 'id'. Voir : $url");
$this->assertEquals('140', $retour['resultat']['-880871632']['id'], "Le tableau du résultat -880871632 doit contenir un champ 'id' avec pour valeur 140. Voir : $url");
$this->assertArrayNotHasKey('href', $retour['resultat']['-880871632'], "Le tableau du résultat -880871632 doit contenir un champ 'href'. Voir : $url");
$this->assertArrayHasKey('nom_vernaculaire', $retour['resultat']['-880871632'], "Le tableau du résultat -880871632 doit contenir un champ 'nom'. Voir : $url");
$this->assertEquals('Acacia', $retour['resultat']['-880871632']['nom_vernaculaire'], "Le tableau du résultat -880871632 doit contenir un champ 'nom' avec pour valeur 'Acacia'. Voir : $url");
$this->assertArrayHasKey('langue.code', $retour['resultat']['-880871632'], "Le tableau du résultat -880871632 doit contenir un champ 'langue.code'. Voir : $url");
$this->assertEquals('spa', $retour['resultat']['-880871632']['langue.code'], "Le tableau du résultat -880871632 doit contenir un champ 'langue.code' avec pour valeur 'spa'. Voir : $url");
$this->assertArrayHasKey('code_langue', $retour['resultat']['-880871632'], "Le tableau du résultat -880871632 doit contenir un champ 'code_langue'. Voir : $url");
$this->assertEquals('spa', $retour['resultat']['-880871632']['code_langue'], "Le tableau du résultat -880871632 doit contenir un champ 'code_langue' avec pour valeur 'spa'. Voir : $url");
$this->assertArrayHasKey('taxon.code', $retour['resultat']['-880871632'], "Le tableau du résultat -880871632 doit contenir un champ 'taxon.code'. Voir : $url");
$this->assertEquals('bdtfx.nt:30746', $retour['resultat']['-880871632']['taxon.code'], "Le tableau du résultat -880871632 doit contenir un champ 'taxon.code' avec pour valeur 'bdtfx.nt:30746'. Voir : $url");
}
 
public function testerIdAvecOntologies() {
$ressources = array('140');
$parametres = array('version.projet' => '2007');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayNotHasKey('entete', $retour, "Le json contient un attribut : entete. Voir : $url");
$this->assertArrayNotHasKey('resultat', $retour, "Le json contient un attribut : resultat. Voir : $url");
$this->assertArrayHasKey('id', $retour, "Le json doit contenir un attribut : 'id' . Voir : $url");
$this->assertEquals('140', $retour['id'], "Le json doit contenir un attribut 'id' avec pour valeur 140. Voir : $url");
$this->assertArrayHasKey('nom_vernaculaire', $retour, "Le json doit contenir un attribut 'nom'. Voir : $url");
$this->assertEquals('Acacia', $retour['nom_vernaculaire'], "Le json doit contenir un attribut 'nom' avec pour valeur 'Acacia'. Voir : $url");
$this->assertArrayHasKey('attributions', $retour, "Le json doit contenir un attribut 'attributions'. Voir : $url");
$this->assertCount(2, $retour['attributions'], "Le résultat devrait contenir deux langues d'attributions. Voir : $url");
$this->assertCount(1, $retour['attributions']['fra'], "Le résultat devrait contenir une attribution à un taxon en français. Voir : $url");
$this->assertArrayHasKey('taxon', $retour['attributions']['fra']['-1617415758'], "Le json doit contenir un attribut : 'taxon' . Voir : $url");
$this->assertEquals('Robinia pseudoacacia L.', $retour['attributions']['fra']['-1617415758']['taxon'], "Le json doit contenir un attribut 'taxon' avec pour valeur Robinia pseudoacacia. Voir : $url");
$this->assertArrayHasKey('genre', $retour['attributions']['fra']['-1617415758'], "Le json doit contenir un attribut : 'genre' . Voir : $url");
$this->assertEquals('Masculin singulier', $retour['attributions']['fra']['-1617415758']['genre'], "Le json doit contenir un attribut 'genre' avec pour valeur Masculin singulier. Voir : $url");
$this->assertArrayHasKey('conseil_emploi', $retour['attributions']['fra']['-1617415758'], "Le json doit contenir un attribut : 'conseil_emploi' . Voir : $url");
$this->assertEquals('Recommandé ou typique', $retour['attributions']['fra']['-1617415758']['conseil_emploi'], "Le json doit contenir un attribut 'conseil_emploi' avec pour valeur Recommandé ou typique. Voir : $url");
}
public function testerAttributionsAvecRechercheMasqueEtOntologies() {
$ressources = array('attributions');
$parametres = array(
'retour.format' => 'max',
'navigation.limite' => '50',
'masque.nt' => '8523');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url");
$this->assertArrayHasKey('resultat', $retour, "Le json contient pas d'attribut : resultat. Voir : $url");
$this->assertEquals('21', $retour['entete']['total'], "Le json ne contient pas le nombre de valeurs attendues. Voir : $url");
$this->assertArrayHasKey(2081013327, $retour['resultat'], "[resultat] ne contient pas l'élément 2081013327. Voir : $url");
$this->assertArrayHasKeys(['taxon', 'genre', 'conseil_emploi'], $retour['resultat'][2081013327], "[resultat][2081013327] ne contient pas tous les éléments. Voir : $url");
$this->assertEquals('Acer monspessulanum L.', $retour['resultat']['2081013327']['taxon'], "Le json ne contient pas le taxon attendu. Voir : $url");
$this->assertEquals('Masculin singulier', $retour['resultat']['2081013327']['genre'], "Le json ne contient pas le genre attendu pour ce taxon. Voir : $url");
$this->assertEquals('Recommandé ou typique', $retour['resultat']['2081013327']['conseil_emploi'], "Le json ne contient pas le conseil emploi attendu pour ce taxon. Voir : $url");
}
public function testerAvecLangueFrMasqueEtRetourOss() {
$ressources = array();
$parametres = array(
'recherche' => 'etendue',
'retour.format' => 'oss',
'navigation.limite' => '50',
'masque.lg' => 'fra',
'masque' => 'Abr');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
// Raphaël, le 28/08/2013: pourquoi double-requête ? dans le doute: commentée
// $retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayNotHasKey('entete', $retour, "Le json ne doit pas contenir d'attribut : entete. Voir : $url");
$this->assertEquals('Pas de masque', $retour['0'], "L'attribut 0 du retour devrait valoir 'Pas de masque'. Voir : $url");
$this->assertArrayNotHasKey('resultat', $retour, "Le json ne doit pas contenir d'attribut : resultat. Voir : $url");
$this->assertCount(50, $retour[1], "Le résultat devrait contenir 50 données. Voir : $url");
}
 
// L'utilisation de retour.champs=conseil_emploi sur l'Héliotrope commun induit un requêtage à
// de multiple ontologies. Celles-ci devraient être factorisées sous la forme d'une requête et le
// résultat renvoyé correct.
// nvjfl/noms-vernaculaires/attributions?masque.nt=1382&retour.champs=conseil_emploi
// masque.lg=fra (pour simplement réduire la lourdeur)
public function testAttributionsOntologiesMultiples() {
$parametres = [ 'masque.nt' => 1382, 'retour.champs' => 'conseil_emploi,genre', 'masque.lg' => 'fra' ];
$url = ServiceEflorePhpUnit::creerUrl('noms-vernaculaires', ['attributions'], $parametres);
$retour = $this->consulterJson('noms-vernaculaires', 'nvjfl', ['attributions'], $parametres);
 
// basique:
$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 1. Voir : $url");
$this->assertCount(4, $retour['resultat'], "Le résultat devrait contenir une seule donnée. Voir : $url");
 
// présence champs standards:
foreach($retour['resultat'] as $k => $e) {
foreach([ 'id', 'nom_vernaculaire', 'taxon', 'code_langue', /* 'langue.code', 'taxon.code', 'href', */ 'nom_retenu.code', 'num_taxon' ] as $v) {
$this->assertArrayHasKey($v, $e, "Le json ne contient pas l'attribut \"$v\" pour l'élément \"$k\". Voir : $url");
}
}
 
// présence champs additionnels:
foreach($retour['resultat'] as $k => $e) {
foreach([ 'is_null', 'zone_usage', 'num_genre', 'notes', 'num_statut', 'num_nom_vernaculaire' ] as $v) {
$this->assertArrayHasKey($v, $e, "Le json ne contient pas l'attribut \"$v\" pour l'élément \"$k\". Voir : $url");
}
}
 
// -1311256838
$this->assertArrayHasKey('-1311256838', $retour['resultat'], "Le json ne contient pas l'élément -1311256838. Voir : $url");
$this->assertEquals('Recommandé ou typique', $retour['resultat']['-1311256838']['conseil_emploi'], "L'élément '-1311256838' contient une valeur erronée pour l'attribut 'conseil_emploi'. Voir : $url");
$this->assertEquals('Héliotrope commun', $retour['resultat']['-1311256838']['nom_vernaculaire'], "L'élément '-1311256838' contient une valeur erronée pour l'attribut 'nom_vernaculaire'. Voir : $url");
$this->assertEquals('1', $retour['resultat']['-1311256838']['num_statut'], "L'élément '-1311256838' contient une valeur erronée pour l'attribut 'num_statut'. Voir : $url");
 
$this->assertEquals('Secondaire ou régional', $retour['resultat']['-516239805']['conseil_emploi'], "L'élément '-516239805' contient une valeur erronée pour l'attribut 'conseil_emploi'. Voir : $url");
$this->assertEquals('Girasol', $retour['resultat']['-516239805']['nom_vernaculaire'], "L'élément '-516239805' contient une valeur erronée pour l'attribut 'nom_vernaculaire'. Voir : $url");
$this->assertEquals('2', $retour['resultat']['-516239805']['num_statut'], "L'élément '-516239805' contient une valeur erronée pour l'attribut 'num_statut'. Voir : $url");
 
// TODO: num_taxon => taxon.code ?
// absence champs "pseudo"-inattendus
foreach($retour['resultat'] as $k => $e) {
foreach([ '_result_ontologies@nvjfl'] as $v) {
$this->assertArrayNotHasKey($v, $e, "Le json contient l'attribut \"$v\" pour l'élément \"$k\". Voir : $url");
}
}
}
}
/tags/v5.3-amandaie/services/tests/0.1/nvjfl/NvjflOntologiesTest.php
New file
0,0 → 1,50
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class NvjflOntologiesTest extends ServiceEflorePhpUnit {
 
// simple test ontologies nvjfl
// ce qui signifie les ontologies communes aux référentiels (bdtfx, bdtxa, isfan)
public function testOntoNVJFLSimpleNotExist() {
$url = '/nvjfl' . ServiceEflorePhpUnit::creerUrl('ontologies', [ 'numStatut:-1' ] );
$retour = $this->consulterBrut('ontologies', 'nvjfl', [ 'numStatut:-1' ] );
$this->assertContains($retour, 'Les données recherchées sont introuvables.');
}
 
public function testOntoNVJFLSimpleAttrNotExist() {
$url = '/nvjfl' . ServiceEflorePhpUnit::creerUrl('ontologies', [ 'blah:1' ] );
$retour = $this->consulterBrut('ontologies', 'nvjfl', [ 'blah:1' ] );
$this->assertContains($retour, 'Les données recherchées sont introuvables.');
}
 
public function testOntoNVJFLSimple() {
$ressource = [ 'numStatut:1' ];
$url = '/nvjfl' . ServiceEflorePhpUnit::creerUrl('ontologies', $ressource );
$retour = $this->consulterJson('ontologies', 'nvjfl', $ressource );
$this->assertNotEmpty($retour, 'données absentes');
foreach(['id', 'nom', 'code', 'complements', 'classe.id', 'classe', 'classe.href', 'description'] as $v) {
$this->assertArrayHasKey($v, $retour, "Le json ne contient pas l'attribut \"$v\". Voir : $url");
}
}
 
public function testOntoNVJFLMultiples() {
$ressource = [ implode(',', [ 'numStatut:1', 'numStatut:2', 'genreNombre:10', 'numStatut:-1', 'blah:1' ]) ];
$url = '/nvjfl' . ServiceEflorePhpUnit::creerUrl('ontologies', $ressource );
$retour = $this->consulterJson('ontologies', 'nvjfl', $ressource );
$this->assertNotEmpty($retour, 'données absentes');
$this->assertCount(3, $retour, "Le retour devrait contenir 3 éléments valides. Voir : $url");
foreach($retour as $k => $e) {
$this->assertArrayHasKey($k, $retour, "Le json ne contient pas d'élément '$k'. Voir : $url");
}
foreach($retour as $k => $e) {
foreach(['id', 'nom', 'code', 'classe.id', 'classe', 'classe.href'] as $v) {
$this->assertArrayHasKey($v, $e, "Le json ne contient pas l'attribut \"$v\" pour l'élément \"$k\". Voir : $url");
}
}
$this->assertEquals('Recommandé ou typique', $retour['numStatut:1']['nom'], "test attribut 'nom' pour numStatut:1. Voir : $url");
$this->assertEquals('Secondaire ou régional', $retour['numStatut:2']['nom'], "test attribut 'nom' pour numStatut:2. Voir : $url");
$this->assertEquals('Féminin singulier', $retour['genreNombre:10']['nom'], "test attribut 'nom' pour genreNombre:10. Voir : $url");
$this->assertEquals('N° Statut', $retour['numStatut:1']['classe'], "test attribut 'classe' pour numStatut:1. Voir : $url");
$this->assertEquals('N° Genre et nombre', $retour['genreNombre:10']['classe'], "test attribut 'nom' pour genreNombre:10. Voir : $url");
}
}
/tags/v5.3-amandaie/services/tests/0.1/cel/CelImagesTest.php
New file
0,0 → 1,188
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class CelImagesTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'cel';
$this->service = 'images';
}
 
public function testParametreMasqueNnInexistant() {
$ressources = array();
$parametres = array('retour'=>'image/jpeg', 'retour.format'=>'M');
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Le paramètre masque.nn est obligatoire.";
$this->assertEquals($messageAttendu, $retour,
"Le service doit renvoyer un message pour un masque non renseigné");
}
 
public function testParametreMasqueNnMultiple() {
$ressources = array();
$parametres = array('masque.nn' => 'bdftf:6218,182','retour'=>'image/jpeg');
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Le paramètre masque.nn peut contenir une seule valeur numérique pour l'instant pour le format de retour image/jpeg.";
$this->assertEquals($messageAttendu, $retour,
"Le service doit renvoyer un message car le paramètre masque.nn n'est pas complétement implémenté.");
}
 
public function testParametreRetourFormatInexistant() {
$ressources = array();
$parametres = array('masque.nn' => '62018', 'retour'=>'image/jpeg');
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$image = imagecreatefromstring($retour);
$largeur = imagesx($image);
$hauteur = imagesy($image);
$this->assertLessThanOrEqual(450, $largeur,
"Le service doit renvoyer une image de taille M (largeur < 450px) par défaut (h:$hauteur x l:$largeur)");
$this->assertLessThanOrEqual(450, $hauteur,
"Le service doit renvoyer une image de taille M (hauteur < 600px) par défaut (h:$hauteur x l:$largeur)");
if ($hauteur != 450) {
$this->assertSame(450, $largeur,
"Le service doit renvoyer une image de taille M : largeur == 450px pour une hauteur infèrieure à 600px (h:$hauteur x l:$largeur)");
}
if ($largeur != 450) {
$this->assertSame(450, $hauteur,
"Le service doit renvoyer une image de taille M : hauteur == 600px pour une largeur infèrieure à 450px (h:$hauteur x l:$largeur)");
}
}
 
public function testValeurParametreRetourFormatInexistante() {
$ressources = array();
$parametres = array('masque.nn' => '62018', 'retour'=>'image/jpeg', 'retour.format'=>'X53L');
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Le type de format 'X53L' n'est pas supporté";
$this->assertEquals($messageAttendu, $retour,
"Le service doit renvoyer un message pour un format de retour inexistant");
}
 
public function testValeurParametreRetourInexistante() {
$ressources = array();
$parametres = array('masque.nn' => '6218','retour'=>'image/jpog');
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Le type de retour 'image/jpog' n'est pas supporté";
$this->assertEquals($messageAttendu, $retour,
"Le service doit renvoyer un message d'erreur 400 sur une type de retour incorrect");
}
 
public function testTaxonSansImage() {
$ressources = array();
$parametres = array('masque.nn' => '6218','retour' => 'image/jpeg');
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$messageAttendu = "Aucune image ne correspond au numéro numenclatural bdtfx:'6218'";
$this->assertEquals($messageAttendu, $retour,
"Le service doit renvoyer un message pour un taxon ne possédant pas d'images");
}
 
public function testListeImagesJsonMasqueNnSimple() {
$ressources = array();
$parametres = array('masque.nn' => '182','retour' => 'application/json', 'retour.format' => 'CRX2S');
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
 
$this->verifierEnteteChampsObligatoires($retour);
$this->assertEquals('nn=182', $retour['entete']['masque'], 'Valeur entete > masque = "nn=182"');
$this->assertSame(0, $retour['entete']['depart'], 'Valeur entete > depart = 0');
$this->assertSame(100, $retour['entete']['limite'], 'Valeur entete > limite = 0');
$this->assertSame(62, $retour['entete']['total'], 'Valeur entete > total = 62');
$this->assertArrayNotHasKey('href.suivant', $retour['entete'], "Absence champ : entete > href.suivant");
$this->assertArrayNotHasKey('href.precedent', $retour['entete'], "Absence champ : entete > href.precedent");
 
$this->verifierResultatsChampsObligatoires($retour);
$this->verifierResultatsValeursGenerique($retour);
$this->assertCount(62, $retour['resultats'], 'Nbre resultats = 62');
foreach ($retour['resultats'] as $id => $resultat) {
$this->assertRegExp("/CRX2S/", $resultat['binaire.href']);
}
}
 
public function testListeImagesJsonMasqueNnMultiple() {
$ressources = array();
$parametres = array('masque.nn' => '62018,182,141','retour' => 'application/json');
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
 
$this->verifierEnteteChampsObligatoires($retour);
$this->assertEquals('nn=62018,182,141', $retour['entete']['masque'], 'Valeur entete > masque = "nn=62018,182,141"');
$this->assertSame(0, $retour['entete']['depart'], 'Valeur entete > depart = 0');
$this->assertSame(100, $retour['entete']['limite'], 'Valeur entete > limite = 0');
$this->assertSame(134, $retour['entete']['total'], 'Valeur entete > total = 134');
$this->assertArrayHasKey('href.suivant', $retour['entete'], "Présence champ : entete > href.suivant");
$urlHrefSuivantAttendue = 'http://localhost/service:eflore:0.1/cel/images?navigation.depart=100&navigation.limite=100&masque.nn=62018,182,141';
$this->assertEquals($urlHrefSuivantAttendue, $retour['entete']['href.suivant'], "Valeur entete > href.suivant = '$urlHrefSuivantAttendue'");
$this->assertArrayNotHasKey('href.precedent', $retour['entete'], "Abscence champ : entete > href.precedent");
 
$this->verifierResultatsChampsObligatoires($retour);
$this->verifierResultatsValeursGenerique($retour);
$this->assertCount(100, $retour['resultats'], 'Nbre resultats = 134');
$this->assertArrayHasKey('6114', $retour['resultats'], "Présence champ : resultats > 6114");
}
 
public function testListeImagesJsonNavigation() {
$ressources = array();
$parametres = array('masque.nn' => '62018,182,141', 'retour' => 'application/json',
'navigation.depart' => 100, 'navigation.limite' => 100);
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
 
$this->verifierEnteteChampsObligatoires($retour);
$this->assertEquals('nn=62018,182,141', $retour['entete']['masque'], 'Valeur entete > masque = "nn=62018,182,141"');
$this->assertSame((int)$parametres['navigation.depart'], $retour['entete']['depart'], "Valeur entete > depart = {$parametres['navigation.depart']}");
$this->assertSame((int)$parametres['navigation.limite'], $retour['entete']['limite'], "Valeur entete > limite = {$parametres['navigation.limite']}");
$this->assertSame(134, $retour['entete']['total'], 'Valeur entete > total = 134');
 
$this->assertArrayHasKey('href.precedent', $retour['entete'], "Présence champ : entete > href.precedent");
$urlHrefPrecedentAttendue = 'http://localhost/service:eflore:0.1/cel/images?navigation.depart=0&navigation.limite=100&masque.nn=62018,182,141';
$this->assertEquals($urlHrefPrecedentAttendue, $retour['entete']['href.precedent'], "Valeur entete > href.precedent = '$urlHrefPrecedentAttendue'");
$this->assertArrayNotHasKey('href.suivant', $retour['entete'], "Abscence champ : entete > href.suivant");
 
$this->verifierResultatsChampsObligatoires($retour);
$this->verifierResultatsValeursGenerique($retour);
}
 
private function verifierEnteteChampsObligatoires($retour) {
$this->assertArrayHasKey('entete', $retour, "Présence champ : entete");
$this->assertArrayHasKey('masque', $retour['entete'], "Présence champ : entete > masque");
$this->assertArrayHasKey('depart', $retour['entete'], "Présence champ : entete > depart");
$this->assertArrayHasKey('limite', $retour['entete'], "Présence champ : entete > limite");
$this->assertArrayHasKey('total', $retour['entete'], "Présence champ : entete > total");
}
 
private function verifierResultatsChampsObligatoires($retour) {
$this->assertArrayHasKey('resultats', $retour, "Présence champ : resultats");
foreach ($retour['resultats'] as $id => $resultat) {
$this->assertTrue(is_int($id), "id = nbre entier : $id");
$this->assertArrayHasKey('date', $resultat, "Présence champ : resultats > $id > date");
$this->assertArrayHasKey('mime', $resultat, "Présence champ : resultats > $id > mime");
$this->assertArrayHasKey('binaire.href', $resultat, "Présence champ : resultats > $id > binaire.href");
$this->assertArrayHasKey('determination', $resultat, "Présence champ : resultats > $id > determination");
$this->assertArrayHasKey('determination.nom_sci', $resultat, "Présence champ : resultats > $id > determination.nom_sci");
$this->assertArrayHasKey('determination.nom_sci.code', $resultat, "Présence champ : resultats > $id > determination.nom_sci.code");
$this->assertArrayHasKey('station', $resultat, "Présence champ : resultats > $id > station");
$this->assertArrayHasKey('auteur', $resultat, "Présence champ : resultats > $id > auteur");
}
}
 
private function verifierResultatsValeursGenerique($retour) {
foreach ($retour['resultats'] as $id => $resultat) {
$this->assertRegExp("/$id/", $resultat['binaire.href']);
}
}
 
public function testDateAnterieur1901() {
$ressources = array('41825');
$parametres = array('referentiel'=>'bdtfx');
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
 
$this->assertArrayHasKey('date', $retour, "Présence champ : date");
$this->assertEquals("1891-00-00 00:00:00", $retour['date'], 'Valeur date <> 1891');
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/chorodep/ChorodepObservationsTest.php
New file
0,0 → 1,48
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class ChorodepObservationsTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'chorodep';
$this->service = 'observations';
}
 
public function testRecherche() {
$ressources = array();
$parametres = array();
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, print_r($retour, true));
$this->assertNotEmpty($retour['entete'], print_r($retour['entete'], true));
$this->assertEquals(20, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur '20'. Voir : $url");
$this->assertCount(20, $retour['resultat'], "Il devrait y avoir '20' résultats. Voir : $url");
}
 
 
public function testObservation() {
$ressources = array("10:20");
$parametres = array();
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, print_r($retour, true));
$this->assertArrayHasKey('type', $retour, "Le json ne contient pas d'attribut : type. Voir : $url");
$this->assertEquals('chorologie', $retour['type'], "L'attribut 'type' devrait avoir la valeur 'chorologie'. Voir : $url");
}
 
public function testMasqueStation() {
$ressources = array();
$parametres = array('masque.station' => '34', 'retour.format' => 'min');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'pas de resultat'.print_r($retour, true));
$this->assertNotEmpty($retour['entete'], 'pas d\'entete'.print_r($retour['entete'], true));
$this->assertEquals(20, $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur '20'. Voir : $url");
$this->assertCount(20, $retour['resultat'], "L'attribut 'total' devrait avoir la valeur '20'. Voir : $url");
$this->assertNotEmpty($retour['resultat']['197:34'], 'resultat 197:34 absent', true);
/*$this->assertArrayHasKey('type', $retour['resultat']['74929:03'], "Le json ne contient pas d'attribut : type. Voir : $url");
$this->assertEquals('chorologie', $retour['resultat']['74929:03']['type'], "L'attribut 'type' devrait avoir la valeur 'chorologie'. Voir : $url");*/
// TODO: implémenter "chorodep/observations/10:25?masque.station=34&retour.format=min"
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/chorodep/ChorodepCartesTest.php
New file
0,0 → 1,134
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class ChorodepCartesTest extends ServiceEflorePhpUnit {
 
private $retour = '';
private $svg = '';
 
public function __construct() {
$this->projet = 'chorodep';
$this->service = 'cartes';
}
 
public function setUp() {
$this->retour = '';
$this->svg = '';
}
 
public function testCarteGenerique() {
$ressources = array();
$parametres = array('version.projet' => '2012.01');
 
$this->retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
 
$this->verifierPresenceMessage("A implémenter : carte proportionnelle ensemble des infos");
}
 
public function testCarteGeneriqueLegende() {
$ressources = array('legende');
$parametres = array('version.projet' => '2012.01');
 
$this->retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
 
$this->verifierPresenceMessage("A implémenter : légende carte proportionnelle ensemble des infos");
}
 
public function testErreurRessource1() {
$ressources = array('ressource1Erreur');
$parametres = array('version.projet' => '2012.01');
 
$this->retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
 
$this->verifierPresenceMessage("La ressource n°1 '{$ressources[0]} indiquée n'est pas valable.");
}
 
public function testCarteSvgIdentifiants() {
$ressourcesListe = array(
array('3237'),
array('nn:3237'),
array('bdtfx.nn:3237')
);
$parametres = array('version.projet' => '2012.01',
'retour' => 'image/svg+xml');
 
foreach ($ressourcesListe as $ressources) {
$this->retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
 
$this->chargerXml();
$this->etreSvg();
$this->verifierDepartementsPresence(array(63, 81));
}
}
 
public function testCarteSvgPlusieursLegendes() {
$ressources = array('bdtfx.nn:71574');
$parametres = array('version.projet' => '2012.01',
'retour' => 'image/svg+xml');
 
$this->retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
$this->chargerXml();
$this->etreSvg();
$this->verifierDepartementsPresence(array('02', '07', '57', '67', '88', '68', '90', '25', '21', '39', '01', '74', '73', '38', '46', '83'));
$this->verifierDepartementsPresenceAConfirmer(array('62', '71'));
$this->verifierDepartementsDisparu(array('70'));
$this->verifierDepartementsErreur(array('06'));
}
 
private function verifierPresenceMessage($messageAttendu) {
$this->assertEquals($messageAttendu, $this->retour);
}
 
private function chargerXml() {
$this->svg = new DOMDocument();
$chargement = $this->svg->loadXML($this->retour);
$this->assertTrue($chargement);
}
 
private function etreSvg() {
$racineElement = $this->svg->documentElement;
$this->assertEquals('svg', $racineElement->tagName);
}
private function verifierDepartementsPresence($departements) {
$this->verifierReglesCssCouleur('A0FF7D', $departements);
}
 
private function verifierDepartementsPresenceAConfirmer($departements) {
$this->verifierReglesCssCouleur('FFFF32', $departements);
}
 
private function verifierDepartementsDouteux($departements) {
$this->verifierReglesCssCouleur('FFCB30', $departements);
}
 
private function verifierDepartementsDisparu($departements) {
$this->verifierReglesCssCouleur('F88017', $departements);
}
 
private function verifierDepartementsErreur($departements) {
$this->verifierReglesCssCouleur('FF2850', $departements);
}
 
private function verifierDepartementsErreurAConfirmer($departements) {
$this->verifierReglesCssCouleur('9F0016', $departements);
}
 
private function verifierReglesCssCouleur($couleur, $departements) {
sort($departements);
$cssRegles = $this->getListeReglesCss($departements);
$cssAttendu = "$cssRegles{\nfill:#$couleur;\n}";
 
$cssPresent = $this->svg->getElementsByTagName('style')->item(0)->nodeValue;
 
$this->assertContains($cssAttendu, $cssPresent);
}
 
private function getListeReglesCss($departements) {
foreach ($departements as $id => $val) {
$departements[$id] = '.departement'.$val;
}
$cssRegle = implode(', ', $departements);
return $cssRegle;
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/chorodep/ChorodepOntologiesTest.php
New file
0,0 → 1,48
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class ChorodepOntologiesTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'chorodep';
$this->service = 'ontologies';
}
 
public function testRecherche() {
$ressources = array();
$parametres = array();
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'données absentes');
$this->assertArrayHasKey('total', $retour['entete'], "Le json ne contient pas d'attribut : total. Voir : $url");
$this->assertEquals('8', $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur '8'. Voir : $url");
$this->assertArrayHasKey('nom', $retour['resultat'][1], "Le json ne contient pas d'attribut : nom. Voir : $url");
$this->assertEquals('presenceChorologie', $retour['resultat'][1]['nom'], "L'attribut 'nom' devrait avoir la valeur 'presenceChorologie'. Voir : $url");
}
public function testMasqueCode() {
$ressources = array();
$parametres = array('masque.code' => '?');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'données absentes');
$this->assertArrayHasKey('total', $retour['entete'], "Le json ne contient pas d'attribut : total. Voir : $url");
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur '1'. Voir : $url");
$this->assertArrayHasKey('5', $retour['resultat'], "L'ontologie n°5 ne fait pas partie du résultat. Voir : $url");
$this->assertArrayHasKey('nom', $retour['resultat'][5], "Le json ne contient pas d'attribut : nom. Voir : $url");
$this->assertEquals('douteux', $retour['resultat'][5]['nom'], "L'attribut 'nom' devrait avoir la valeur 'douteux'. Voir : $url");
}
public function testMasqueNom() {
$ressources = array();
$parametres = array('masque.nom' => 'disparu');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertNotEmpty($retour, 'données absentes');
$this->assertArrayHasKey('total', $retour['entete'], "Le json ne contient pas d'attribut : total. Voir : $url");
$this->assertEquals('1', $retour['entete']['total'], "L'attribut 'total' devrait avoir la valeur '1'. Voir : $url");
$this->assertArrayHasKey('code', $retour['resultat'][6], "Le json ne contient pas d'attribut : code. Voir : $url");
$this->assertEquals('-|-', $retour['resultat'][6]['code'], "L'attribut 'code' devrait avoir la valeur '-|-'. Voir : $url");
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/bibliobota/PublicationsTest.php
New file
0,0 → 1,33
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class PublicationsTest extends ServiceEflorePhpUnit {
public function __construct() {
$this->projet = 'bibliobota';
$this->service = 'publications';
}
public function testObtenirPublicationSansMasqueTaxon() {
$ressources = array();
$parametres = array();
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertEquals('', $retour['entete']['masque'], 'Valeur entete > ""');
$this->assertSame(29689, $retour['entete']['total'], 'Valeur entete > total = 29689');
$this->assertArrayHasKey(463, $retour['resultats'], "Absence du résultat 463 attendu");
$this->assertArrayHasKey('href.suivant', $retour['entete'], "Absence de lien href suivant attendu");
}
public function testObtenirPublication() {
$ressources = array();
$parametres = array('masque.taxon' => 'Acer monspessulanum');
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertEquals('masque.taxon=Acer monspessulanum', $retour['entete']['masque'], 'Valeur entete > masque.taxon=Acer monspessulanum');
$this->assertSame(4, $retour['entete']['total'], 'Valeur entete > total = 4');
$this->assertArrayHasKey(21991, $retour['resultats'], "Absence du résultat 21991 attendu");
$this->assertArrayNotHasKey('href.suivant', $retour['entete'], "Le lien href suivant est présent alors qu'il ne devrait pas");
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/wikipedia/WikipediaTexteTest.php
New file
0,0 → 1,59
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class WikipediaTest extends ServiceEflorePhpUnit {
public function __construct() {
$this->projet = 'wikipedia';
$this->service = 'textes';
}
public function testPageComplete() {
$ressources = array('Viola_alba');
$parametres = array('txt.format'=> 'htm');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
 
$this->assertEquals("Violette blanche", $retour['titre'], "Le titre n'est pas celui attendu. Voir : $url");
$this->assertArrayHasKey('id', $retour, "Le json ne contient pas d'attribut : id. Voir : $url");
$this->assertArrayHasKey('titre', $retour, "Le json ne contient pas d'attribut : titre. Voir : $url");
$this->assertArrayHasKey('texte', $retour, "Le json ne contient pas d'attribut : texte. Voir : $url");
$this->assertContains("<a href=\"http://fr.wikipedia.org/wiki/Fichier:Viola_alba", $retour['texte'], "Le titre n'est pas celui attendu. Voir : $url");
 
$this->assertArrayHasKey('mime', $retour, "Le json ne contient pas d'attribut : mime. Voir : $url");
$this->assertArrayHasKey('href', $retour, "Le json ne contient pas d'attribut : href. Voir : $url");
}
public function testDescription() {
$ressources = array('Viola_alba');
$parametres = array('txt.format'=> 'htm',
'txt.section.titre' => 'Description');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('id', $retour, "Le json ne contient pas d'attribut : id. Voir : $url");
$this->assertArrayHasKey('titre', $retour, "Le json ne contient pas d'attribut : titre. Voir : $url");
$this->assertEquals("Violette blanche", $retour['titre'], "Le titre n'est pas celui attendu. Voir : $url");
$this->assertArrayHasKey('texte', $retour, "Le json ne contient pas d'attribut : texte. Voir : $url");
$this->assertEquals("<p>C'est une espèce ", substr($retour['texte'], 0, 21), "Le texte n'est pas celui attendu. Voir : $url");
}
public function testCaracteristiques() {
$ressources = array('Viola_alba');
$parametres = array('txt.format'=> 'htm',
'txt.section.titre' => 'Caractéristiques');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertEquals("Violette blanche", $retour['titre'], "Le titre n'est pas celui attendu. Voir : $url");
$this->assertArrayHasKey('texte', $retour, "Le json ne contient pas d'attribut : texte. Voir : $url");
$debut_chara = '<ul>
<li>organes repr';
$this->assertEquals($debut_chara, trim(substr($retour['texte'], 0, 21)), "Le texte n'est pas celui attendu. Voir : $url");
}
}
 
?>
/tags/v5.3-amandaie/services/tests/0.1/bdtfx/BdtfxNomsTest.php
New file
0,0 → 1,295
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class BdtfxNomsTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'bdtfx';
$this->service = 'noms';
}
 
public function testVersionPrecise() {
$ressources = array();
$parametres = array('version.projet' => '1.01');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $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('71711');
$parametres = array('version.projet' => '*');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $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->assertArrayHasKey('bdtfx_v2_00', $retour, "Le json ne contient pas d'attribut : bdtfx_v2_00.\nVoir : $url");
 
$this->assertEquals('71711', $retour['bdtfx_v1_01']['id'], "'bdtfx_v1_01' doit contenir un attribut 'id' avec la valeur '71711'");
// $this->assertEquals('71711', $retour['bdtfx_v1_02']['id'], "'bdtfx_v1_02' doit contenir un attribut 'id' avec la valeur '71711'");
$this->assertEquals('71711', $retour['bdtfx_v2_00']['id'], "'bdtfx_v2_00' doit contenir un attribut 'id' avec la valeur '71711'");
}
 
public function testNomsVersionMultiple() {
$ressources = array();
$parametres = array('version.projet' => '*');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $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();
$parametres = array('version.projet' => '99.00');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
 
$attendu = "La table recherchée n'existe pas";
$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();
$parametres = array(
'version.projet' => '1.01',
'recherche' => 'stricte',
'masque' => 'Acer');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $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->assertCount(1, $retour['resultat'], "Le résultat devrait contenir une seule donnée. Voir : $url");
}
 
public function testResultatChamps() {
$ressources = array();
$parametres = array(
'version.projet' => '1.01',
'recherche' => 'stricte',
'masque.nn' => '182');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
 
$this->assertArrayHasKey('resultat', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url");
$this->assertCount(1, $retour['resultat'], "Le résultat devrait contenir une seule donnée. Voir : $url");
$this->assertArrayNotHasKey('id', $retour['resultat']['182'], "Le tableau du résultat 182 ne doit pas contenir un champ 'id'. 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();
$parametres = array(
'version.projet' => '1.01',
'recherche' => 'stricte',
'masque.sg' => 'Asteraceae');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$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->assertCount(1, $retour['resultat'], "Le résultat devrait contenir une seule donnée. Voir : $url");
}
 
public function testMasqueGenSpSspAuAn() {
$ressources = array();
$parametres = array(
'version.projet' => '1.01',
'recherche' => 'stricte',
'masque.gen' => 'Allium',
'masque.sp' => 'carinatum',
'masque.ssp' => 'consimile',
'masque.au' => 'Gren.',
'masque.an' => '1855');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
 
$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->assertCount(1, $retour['resultat'], "Le résultat devrait contenir une seule donnée. Voir : $url");
}
 
public function testMasqueNn() {
$ressources = array();
$parametres = array(
'version.projet' => '1.01',
'recherche' => 'stricte',
'masque.nn' => '182');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$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->assertCount(1, $retour['resultat'], "Le résultat devrait contenir une seule donnée. Voir : $url");
$this->assertArrayNotHasKey('id', $retour['resultat']['182'], "Le tableau du résultat 182 doit contenir un champ 'id'. Voir : $url");
}
 
public function testMasqueRg() {
$ressources = array();
$parametres = array(
'version.projet' => '1.01',
'recherche' => 'stricte',
'masque.rg' => '180');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$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();
$parametres = array(
'version.projet' => '1.01',
'recherche' => 'stricte',
'masque.nn' => '182',
'ns.format' => 'txt',
'ns.structure' => 'au,an,bib,ad');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$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_complet'], "Le tableau du résultat 182 doit contenir un champ 'nom_sci' avec pour valeur 'Acer monspessulanum'. Voir : $url");
}
 
public function testNsStructureHtml() {
$ressources = array();
$parametres = array(
'version.projet' => '1.01',
'recherche' => 'stricte',
'masque.nn' => '182',
'ns.format' => 'htm',
'ns.structure' => 'au,an,bib,ad');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$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_complet'], $message);
}
 
public function testListeNomsAvecParametreRetourChamps() {
$ressources = array();
$parametres = array('version.projet' => '1.01',
'masque' => 'acer',
'retour.champs' => 'auteur,nom_retenu.*');
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('auteur', $retour['resultat']['83587']);
$this->assertArrayHasKey('nom_retenu.id', $retour['resultat']['83587']);
$this->assertArrayHasKey('nom_retenu.href', $retour['resultat']['83587']);
$this->assertArrayNotHasKey('nom_retenu', $retour['resultat']['83587']);
}
 
public function testNomsIdAvecParametreRetourChamps() {
$ressources = array(1);
$parametres = array('version.projet' => '1.01',
'retour.champs' => 'nom_retenu.*');
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('nom_retenu.id', $retour);
$this->assertArrayHasKey('nom_retenu.href', $retour);
$this->assertArrayNotHasKey('nom_retenu', $retour);
$this->assertArrayNotHasKey('auteur', $retour);
}
 
public function testListeNomAvecParametreNsStructureAuAnBibAd() {
$ressources = array();
$parametres = array('version.projet' => '1.01',
'masque.nn' => '39607',
'ns.structure' => 'au,an,bib,ad');
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('resultat', $retour);
$this->assertArrayHasKey('39607', $retour['resultat']);
$this->assertArrayHasKey('nom_sci', $retour['resultat']['39607']);
$nomSciTxt = 'Lolium annuum Gilib. [1792, Exercit. Phytol., 2 : 520] [nom. invalid.]';
$this->assertEquals($nomSciTxt, $retour['resultat']['39607']['nom_sci_complet']);
}
 
public function testListeNomAvecParametreNsStructureAuAnBibAdEtNsFormatHtm() {
$ressources = array();
$parametres = array('version.projet' => '1.01',
'masque.nn' => '39607',
'ns.structure' => 'au,an,bib,ad',
'ns.format' => 'htm');
 
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('entete', $retour);
$this->assertArrayHasKey('masque', $retour['entete']);
$this->assertEquals('num_nom=39607', $retour['entete']['masque']);
 
$this->assertArrayHasKey('resultat', $retour);
$this->assertArrayHasKey('39607', $retour['resultat']);
$this->assertArrayHasKey('nom_sci', $retour['resultat']['39607']);
$nomSciHtml = "<span class=\"sci\"><span class=\"gen\">Lolium</span> <span class=\"sp\">annuum</span></span> <span class=\"auteur\">Gilib.</span> [<span class=\"annee\">1792</span>, <span class=\"biblio\">Exercit. Phytol., 2 : 520</span>] [<span class=\"adendum\">nom. invalid.</span>]";
$this->assertEquals($nomSciHtml, $retour['resultat']['39607']['nom_sci_complet']);
}
public function testListeNomAvecParametreRetourChamps() {
$ressources = array();
$parametres = array('version.projet' => '1.01',
'masque.nn' => '39607',
'retour.champs' => 'rang,auteur');
 
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('entete', $retour);
$this->assertArrayHasKey('masque', $retour['entete']);
$this->assertEquals('num_nom=39607', $retour['entete']['masque']);
$this->assertArrayHasKey('resultat', $retour);
$this->assertArrayHasKey('39607', $retour['resultat']);
$this->assertArrayHasKey('rang.libelle', $retour['resultat']['39607']);
// peut advenir en cas d'échec de la requête (HTTP ou SQL) sur les ontologies
// vérifier la présence de la table ainsi que la valeur "bdd_table_ontologies" dans "config_bdtfx.ini"
$this->assertEquals('Espèce', $retour['resultat']['39607']['rang.libelle'], "Erreur champ 'Espèce': Voir $url");
$this->assertArrayHasKey('auteur', $retour['resultat']['39607']);
$this->assertEquals('Gilib.', $retour['resultat']['39607']['auteur']);
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/bdtfx/BdtfxTaxonsTest.php
New file
0,0 → 1,137
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class BdtfxTaxonsTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'bdtfx';
$this->service = 'taxons';
}
 
public function testVersionPrecise() {
$ressources = array();
$parametres = array('version.projet' => '1.01');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $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('version.projet' => '*');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $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->assertArrayHasKey('bdtfx_v2_00', $retour, "Le json ne contient pas d'attribut : bdtfx_v2_00.\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'");
$this->assertEquals('182', $retour['bdtfx_v2_00']['id'], "'bdtfx_v2_00' doit contenir un attribut 'id' avec la valeur '182'");
}
 
public function testNomsVersionMultiple() {
$ressources = array();
$parametres = array('version.projet' => '*');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $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();
$parametres = array('version.projet' => '99.00');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, $ressources, $parametres);
 
$attendu = "La table recherchée n'existe pas";
$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();
$parametres = array(
'version.projet' => '1.01',
'recherche' => 'stricte',
'masque' => 'Acer');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $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->assertCount(1, $retour['resultat'], "Le résultat devrait contenir une seule donnée. Voir : $url");
}
 
public function testRechercheEtendue() {
$ressources = array();
$parametres = array(
'version.projet' => '1.01',
'recherche' => 'etendue',
'masque' => 'Acer');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $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('50', $retour['entete']['total'], "L'attribut total de l'entête devrait valoir 50. Voir : $url");
$this->assertCount(50, $retour['resultat'], "Le résultat devrait contenir 50 données. Voir : $url");
}
 
public function testRechercheFloue() {
$ressources = array();
$parametres = array(
'version.projet' => '1.01',
'recherche' => 'floue',
'masque' => 'Acer');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
 
$retour = $this->consulterJson($this->service, $this->projet, $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('3', $retour['entete']['total'], "L'attribut total de l'entête devrait valoir 3. Voir : $url");
$this->assertCount(3, $retour['resultat'], "Le résultat devrait contenir 3 données. Voir : $url");
}
public function testTaxonsInf() {
$ressources = array('13609', 'relations', 'inferieurs');
$parametres = array();
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('13609', $retour, "Le json ne contient pas le num tax en indice. Voir : $url");
$this->assertCount(2, $retour['13609'], "Le json ne contient pas le nom de taxons inf attendu. Voir : $url");
$this->assertEquals("Carex cuprina var. cuprina", $retour['13609']['13610']['nom_sci'], "Le json ne contient pas les 1er taxon inf attendu. Voir : $url");
}
public function testTaxonsSup() {
$ressources = array('13609', 'relations', 'superieurs');
$parametres = array('version.projet' => '1.01');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('13609', $retour, "Le json ne contient pas le num tax en indice. Voir : $url");
$this->assertCount(14, $retour['13609'], "Le json ne contient pas le nom de taxons inf attendu. Voir : $url");
$this->assertEquals("Chlorobiontes", $retour['13609']['101140']['nom_sci'], "Le json ne contient pas les 1er taxon inf attendu. Voir : $url");
 
// passe à "Chlorophytes" en 2.00
$ressources = array('13609', 'relations', 'superieurs');
$parametres = array('version.projet' => '2.00');
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('13609', $retour, "Le json ne contient pas le num tax en indice. Voir : $url");
$this->assertCount(14, $retour['13609'], "Le json ne contient pas le nom de taxons inf attendu. Voir : $url");
$this->assertEquals("Chlorophytes", $retour['13609']['101140']['nom_sci'], "Le json ne contient pas les 1er taxon inf attendu. Voir : $url");
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/bdtfx/BdtfxLMetaTest.php
New file
0,0 → 1,44
<?php
require_once __DIR__.'/../ServiceEflorePhpUnit.php';
 
class BdtfxMetaTest extends ServiceEflorePhpUnit {
 
public function testVersions() {
 
// version fixe: version.projet=1.01
 
$url = ServiceEflorePhpUnit::creerUrl('meta-donnees', [], ['version.projet' => '1.01']);
$retour = $this->consulterJson('meta-donnees', 'bdtfx', [], ['version.projet' => '1.01']);
$this->assertArrayHasKey(00, $retour, "json error, pas d'élément 0, $url");
$retour = $retour[0];
 
$this->assertArrayHasKey('guid', $retour, "json error, $url");
$this->assertArrayHasKey('code', $retour, "json error, $url");
$this->assertArrayHasKey('version', $retour, "json error, $url");
$this->assertArrayHasKey('titre', $retour, "json error, $url");
$this->assertArrayHasKey('contributeurs', $retour, "json error, $url");
// TODO: autres
 
$this->assertArrayHasKey('contributeurs', $retour, "json error, $url");
$this->assertEquals('1.01', $retour['version'], "json attribute error \"version\", $url");
 
// dernière version: version.projet=+
 
$url = ServiceEflorePhpUnit::creerUrl('meta-donnees', [], ['version.projet' => '+']);
$retour = $this->consulterJson('meta-donnees', 'bdtfx', [], ['version.projet' => '+']);
$this->assertArrayHasKey(00, $retour, "json error, pas d'élément 0, $url");
$retour = $retour[0];
 
$this->assertArrayHasKey('guid', $retour, "json error, $url");
$this->assertArrayHasKey('code', $retour, "json error, $url");
$this->assertArrayHasKey('version', $retour, "json error, $url");
$this->assertArrayHasKey('titre', $retour, "json error, $url");
$this->assertArrayHasKey('contributeurs', $retour, "json error, $url");
// TODO: autres
 
$this->assertArrayHasKey('contributeurs', $retour, "json error, $url");
// 2013/09/23
$this->assertEquals('2.00', $retour['version'], "json attribute error \"version\", $url");
}
}
?>
/tags/v5.3-amandaie/services/tests/0.1/iso-639-1/Iso6391LanguesTest.php
New file
0,0 → 1,22
<?php
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 
class Iso6391LanguesTest extends ServiceEflorePhpUnit {
 
public function __construct() {
$this->projet = 'iso-639-1';
$this->service = 'langues';
}
 
public function testValeurChampPrecis() {
$ressources = array('fr', 'nom');
$parametres = array();
$url = ServiceEflorePhpUnit::creerUrl($this->service, $ressources, $parametres);
$retour = $this->consulterJson($this->service, $this->projet, $ressources, $parametres);
$this->assertArrayHasKey('id', $retour, "Le json ne contient pas d'attribut : id. Voir : $url");
$this->assertEquals('fr', $retour['id'], "L'attribut 'id' devrait avoir la valeur 'fr'. Voir : $url");
$this->assertArrayHasKey('nom.fr', $retour, "Le json ne contient pas d'attribut : nom.fr. Voir : $url");
$this->assertEquals('Français', $retour['nom.fr'], "L'attribut 'nom.fr' devrait avoir la valeur 'Français'. Voir : $url");
}
}
?>
/tags/v5.3-amandaie/services/modules/0.1/nvjfl/NomsVernaculaires.php
New file
0,0 → 1,840
<?php
/**
* Description :
* Classe NomsVernaculaires.php fournit une liste de noms vernaculaires et leur liaison à la bdtfx
* 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 langue et
* une relation avec un taxon de la bdtfx.
* Si l'url finit par /noms-vernaculaires on retourne une liste de noms (seulement les 100 premières par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /observations?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche,
* distinct, retour.format, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Delphine Cauquil <delphine@tela-botanica.org>
* @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)
*/
 
// Un caractère de concaténation entre le projet et le service.
// Ce caractère ne doit pas faire partie d'aucun des noms de service ou projet
define('RES_VAL_SEP', '@');
define('SPE_INDEX_NVJFL', '_result_ontologies' . RES_VAL_SEP . 'nvjfl');
 
class NomsVernaculaires extends Commun {
 
static $onto_multi_support = array('conseil_emploi', 'genre');
static $champ_infos = array(
'taxon' => array('service' => 'taxons', 'ressource' => 'nt:', 'projet' => 'bdtfx', 'nom' => 'nom_sci',
// utilisés par ajouterChampsOntologieLigneResultat()
'intitule' => 'taxon.code', // intitulé du champ tel qu'il sera renvoyé en JSON
'bdd_champ' => 'num_taxon'), // intitulé du champ tel qu'il est présent dans l'enregistrement MySQL
'conseil_emploi' => array('service' => 'ontologies', 'ressource' => 'numStatut:', 'projet' => 'nvjfl', 'nom' => 'nom',
'intitule' => 'conseil_emploi', 'bdd_champ' => 'num_statut'),
'genre' => array('service' => 'ontologies', 'ressource' => 'genreNombre:', 'projet' => 'nvjfl', 'nom' => 'nom',
'intitule' => 'genre', 'bdd_champ' => 'num_genre'));
 
protected $service = 'noms-vernaculaires';
 
/**
* Permet de stocker la requete formulée : /noms-vernaculaires | /noms-vernaculaires/#id |
* /noms-vernaculaires/#id/champ | /noms-vernaculaires/#id/relations
* Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service.
* Est utilisée principalement pr déterminer le format du tableau à retourner. */
protected $format_reponse = 'noms-vernaculaires';
 
/** Variables constituant les parametres de la requete SQL (champ, condition, limit) remplie
* selon ressources et paramètres */
protected $requete_champ = array(' * ');
protected $requete_condition = '';
protected $limite_requete = array(
'depart' => 0,
'limite' => 100
);
 
protected $champ_tri = 'code_langue';
protected $direction_tri = 'asc';
 
/**
* Indique les champs supplémentaires à retourner
* - conseil_emploi = conseil d'emploi du nom vernaculaire
* - genre = genre et nombre du nom
* - taxon = nom retenu associé à ce nom
*/
protected $champs_supp = array();
 
/**
* Precise la contenance plus ou moins précise du tableau à retourner :
* - min = les données présentes dans la table
* - max = les données de la table + les informations complémentaires (pour les identifiants et les codes)
* - oss = la liste des nom_sci (uniquement pour noms et taxons) */
protected $retour_format = 'max';
/** Valeur du paramètre de requete recherche :
* - stricte : le masque est passé tel quel à l'opérateur LIKE.
* - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE.
* - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */
protected $recherche;
 
/** Permet de stocker le tableau de résultat (non encodé en json) */
protected $table_retour = array();
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */
protected $total_resultat;
 
private $config;
 
public function __construct($config) {
$this->config = is_null($config) ? Config::get('NomsVernaculaires') : $config;
}
 
//+------------------------------------------------------------------------------------------------------+
// créer une condition en fonction du paramétre
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres)) {
 
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') {
$this->recherche = $this->parametres['recherche'];
}
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'masque' :
$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
break;
case 'masque.nt' :
$this->ajouterFiltreMasque('num_taxon', $valeur);
break;
case 'masque.nv' :
$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
break;
case 'masque.lg' :
$this->ajouterFiltreMasque('code_langue', $valeur);
break;
case 'masque.cce' :
$this->ajouterFiltreMasque('num_statut', $valeur);
break;
case 'retour.format' :
$this->retour_format = $valeur;
break;
case 'navigation.depart' :
$this->limite_requete['depart'] = $valeur;
break;
case 'navigation.limite' :
$this->limite_requete['limite'] = $valeur;
break;
case 'retour.champs' :
$this->champs_supp = explode(',',$valeur);
break;
case 'recherche' :
break;
case 'version.projet' :
break;
default :
$p = '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, $p);
}
}
}
}
 
public function ajouterFiltreMasque($nom_champ, $valeur) {
if ($nom_champ == 'num_taxon') { // si il s'agit d'un chiffre
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if ($this->recherche == 'floue') {
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ';
} else {
if ($this->recherche == 'etendue') {
$valeur = '%'.str_replace(' ','% ', $valeur);
$valeur .= '%';
}
$this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
// en fonction de la présence des ressources modifie requete_champ et requete_condition
public function traiterRessources() {
if (isset($this->ressources) && !empty($this->ressources)) {
if (isset($this->ressources[0]) && !empty($this->ressources[0])) {
$this->traiterRessourceId(); // ajoute condition id=#valeur
if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
$this->traiterRessourceChamp(); //modifie requete_champ ou requete_condition
}
}
} else { //rajoute distinct pour ne pas avoir plusieurs fois le même nom
$this->requete_champ = array('distinct(id)', 'nom_vernaculaire ');
}
}
 
//requete : /noms-vernaculaires/#id (ex : /noms-vernaculaires/7)
public function traiterRessourceId() {
if (is_numeric($this->ressources[0])) {
$this->requete_condition[] = ' id = '.$this->getBdd()->proteger($this->ressources[0]);
$this->format_reponse .= '/id';
} elseif ($this->ressources[0] == 'attributions') {
$this->format_reponse .= '/attributions';
} else {
$r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->ressources[0].
' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r);
}
}
 
 
public function traiterRessourceChamp() {
$this->format_reponse .= '/champ';
$this->analyserChamp();
}
 
public function analyserChamp() {
$this->requete_champ = array();
$this->recupererTableConfig('champs_possibles');// s'il y a plusieurs champs correspondant au champ demandé ils sont séparé par des |
$champs = explode(' ', $this->ressources[1]);
foreach ($champs as $champ) {
preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match);
if (isset($this->champs_possibles[$match[1]])) {
$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[1]]);
} elseif (isset($this->champs_possibles[$match[0]])) {
$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[0]]);
} else {
$champs_possibles = implode('</li><li>', array_keys($this->champs_possibles));
$c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '.
'Les champs disponibles sont : <li>'.$champs_possibles.'</li> et leurs déclinaisons (ex. ".code").';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
public function assemblerLaRequete() {
$nolimit = in_array(
$this->format_reponse,
array($this->service.'/id', $this->service.'/id/champs'));
if(!$nolimit) {
$count = $this->recupererTotalResultat();
$limiteClause = self::formerRequeteLimite( // LIMIT
$this->limite_requete['depart'],
$count,
$this->limite_requete['limite']);
}
return sprintf(
'SELECT %s, IF(num_statut="",1,0) AS is_null' .
' FROM %s WHERE %s ORDER BY is_null ASC, num_statut ASC %s -- %s:%d',
 
in_array('*', $this->requete_champ) ? ' * ' : implode(', ', $this->requete_champ),
$this->table,
$this->requete_condition ? implode(' AND ', $this->requete_condition) : 'TRUE',
$nolimit ? '' : $limiteClause,
__FILE__, __LINE__);
}
 
//ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes
// suivantes : /noms-vernaculaires et /noms-vernaculaires/#id/relations)
static function formerRequeteLimite(&$depart, $total, $limite) {
if ($depart > $total) {
$depart = $total - $limite < 0 ? 0 : ($total - $limite);
return ' LIMIT ' . $depart . ', ' . $limite;
}
return ' LIMIT ' . $depart . ', ' . $limite;
}
 
//on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /noms-vernaculaires)
public function recupererTotalResultat() {
$res = $this->getBdd()->recuperer(sprintf(
'SELECT COUNT(%s) AS nombre FROM %s WHERE %s -- %s:%d',
$this->format_reponse == 'noms-vernaculaires/attributions' ? 'id' : 'distinct(id)',
$this->table,
$this->requete_condition ? implode(' AND ', $this->requete_condition) : 'TRUE',
__FILE__, __LINE__));
 
if (! $res)
throw new Exception('Données introuvables', RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE);
if($res['nombre'] == 0) {
print json_encode(
array(
"entete" => array(
"depart" => $this->limite_requete['depart'],
"limite" => $this->limite_requete['limite'],
"masque" => $this->recupererMasque(),
"total" => 0
),
"resultat" => array()
));
die; // die() très dommage (pour phpunit), mais la stack d'imbrication ne nous permet pas de retourner proprement
}
 
$this->total_resultat = $res['nombre'];
return $res['nombre'];
}
 
//+------------------------------------------------------------------------------------------------------+
// determine en fct du service appelé (/noms-vernaculaires | /noms-vernaculaires/#id | /noms-vernaculaires/#id/champ |
// /noms-vernaculaires/#id/relations) le format du tableau à retourner.
public function retournerResultatFormate($resultat) {
$this->recupererTableConfig('correspondance_champs');
switch ($this->format_reponse) {
case 'noms-vernaculaires' :
$reponse = ($this->retour_format == 'oss') ? $this->formaterEnOss($resultat) : $this->formaterNomsVernaculaires($resultat); break;
case 'noms-vernaculaires/attributions' : $reponse = $this->formaterNomsVernaculairesAttributions($resultat); break;
case 'noms-vernaculaires/id' : $reponse = $this->formaterNomsVernaculairesId($resultat); break;
case 'noms-vernaculaires/id/champ' : $reponse = $this->formaterNomsVernaculairesIdChamp($resultat); break;
default : break;
}
return $reponse;
}
public function ajouterJsonEnTeteNV() {
$table_retour_json['masque'] = $this->recupererMasque();
$table_retour_json['depart'] = $this->limite_requete['depart'];
$table_retour_json['limite'] = $this->limite_requete['limite'];
$table_retour_json['total'] = $this->total_resultat;
$url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires');
if (isset($url['precedent']) && $url['precedent'] != '') {
$table_retour_json['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$table_retour_json['href.suivant'] = $url['suivant'];
}
return $table_retour_json;
}
public function ajouterJsonResultatNV($resultat) {
foreach ($resultat as $tab) {
foreach ($tab as $key => $valeur) {
if ($valeur != '') {
switch ($key) {
case 'id' : $num = $valeur; break;
case 'nom_vernaculaire' : $this->table_retour['nom'] = $valeur; break;
default : break;
}
}
}
if ($this->retour_format == 'max') $this->table_retour['href'] = $this->ajouterHref('noms-vernaculaires', $num);
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array();
}
return $resultat_json;
}
 
public function formaterNomsVernaculaires($resultat) {
$table_retour_json['entete'] = $this->ajouterJsonEnTeteNV();
$resultat = $this->hierarchiserResultat($resultat);
$table_retour_json['resultat'] = $this->ajouterJsonResultatNV($resultat);
return $table_retour_json;
}
public function hierarchiserResultat($resultat) {
//tri recherche floue
if (isset($this->parametres['masque.nv'])) {
return $this->trierRechercheFloue($this->parametres['masque.nv'], $resultat, 'nom_vernaculaire');
}
if (isset($this->parametres['masque'])) {
return $this->trierRechercheFloue($this->parametres['masque'], $resultat, 'nom_vernaculaire');
}
return $resultat;
}
public function recupererMasque() {
$tab_masque = array();
foreach ($this->parametres as $param=>$valeur) {
if (strstr($param, 'masque') != false) {
$tab_masque[] = $param.'='.$valeur;
}
}
return implode('&', $tab_masque);
}
public function formaterEnOss($resultat) {
$table_nom = array();
$oss = '';
foreach ($resultat as $tab) {
if (isset($tab['nom_vernaculaire']) ) {
if (!in_array($tab['nom_vernaculaire'], $table_nom)) {
$table_nom[] = $tab['nom_vernaculaire'];
$oss [] = $tab['nom_vernaculaire'];
}
}
}
if (isset($this->masque)) $masque = implode('&', $this->masque);
else $masque = 'Pas de masque';
return array($masque, $oss);
}
public function formaterNomsVernaculairesAttributions($resultat) {
//on remplie la table $table_retour_json['entete']
$table_retour_json['entete']['masque'] = $this->recupererMasque();
$table_retour_json['entete']['depart'] = $this->limite_requete['depart'];
$table_retour_json['entete']['limite'] = $this->limite_requete['limite'];
$table_retour_json['entete']['total'] = $this->total_resultat;
$url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires/attributions');
if (!empty($url['precedent'])) {
$table_retour_json['entete']['href.precedent'] = $url['precedent'];
}
if (!empty($url['suivant'])) {
$table_retour_json['entete']['href.suivant'] = $url['suivant'];
}
foreach ($resultat as &$tab) {
$nnv = $tab['num_nom_vernaculaire'];
$resultat_json[$nnv]['id'] = $tab['id'];
$resultat_json[$nnv]['nom_vernaculaire'] = $tab['nom_vernaculaire'];
$resultat_json[$nnv]['langue.code'] = $resultat_json[$nnv]['code_langue'] = $tab['code_langue'];
$resultat_json[$nnv]['taxon.code'] = 'bdtfx.nt:'.$tab['num_taxon'];
if ($this->retour_format == 'max') {
$this->taxons[] = $tab['num_taxon']; // utilisé pour chercher les noms latins plus bas
if($this->champs_supp) {
//$resultat_json[$nnv] = $this->ajouterChampsOntologieLigneResultat($tab);
// simple initialisation par copie de la référence de l'original
$resultat_json[$nnv] = &$tab;
}
else {
$resultat_json[$nnv]['num_taxon'] = $tab['num_taxon'];
$resultat_json[$nnv]['nom_retenu.code'] = $tab['num_taxon'];
$resultat_json[$nnv]['taxon'] = $tab['num_taxon'];
$resultat_json[$nnv]['href'] = $this->ajouterHref('noms-vernaculaires', $tab['id']);
}
}
}
 
// dans ce cas (particulier?) nous n'avons pour l'heure initialisé qu'une référence
// vers le tableau de valeurs original
if ($this->retour_format == 'max' && $this->champs_supp) {
// récupérons désormais les ontologies
$this->ajouterChampsOntologieLigneTousResultats($resultat_json);
}
 
if ($this->retour_format == 'max') {
// On est obligé de faire un deuxième boucle pour demander tous les taxons présents en une
// fois et les attribuer aux noms car c'est beaucoup plus rapide
$noms_sci = $this->recupererNomTaxons();
foreach ($resultat_json as $num_nom => &$tab) {
$tab = $this->ajouterTaxonsAttributionsLigneResultat($tab, $noms_sci);
if($tab == null) {
unset($resultat_json[$num_nom]);
}
}
}
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
/**
* Ajoute les champs d'ontologie supplémentaires si necéssaire
* en faisant appels aux web services associés.
* Les appels peuvent être fait individuellement (pour un couple <ontologie:valeur>) ou bien
* regroupés, **si le webservice correspondant le supporte**.
*
* Nous disposons à ce jour de 3 (trois) webservices d'ontologies correspondant aux noms vernaculaires (cf $champ_infos)
* Mais 2 d'entre eux sont identiques, il s'agit de /nvjfl/ontologies/. Or ce webservice supporte le multi-critère.
* Nous pouvons donc factorisé l'appel pour "conseil_emploi" et "genre", mais pas pour "taxon".
*
* @param array in/out $resultats: tous les résultats
*/
public function ajouterChampsOntologieLigneTousResultats(&$resultats) {
$champs_sup = array_intersect($this->champs_supp, array_keys(self::$champ_infos));
 
// La regroupement des toutes les valeurs recherchées (pour tous les
// résultats), pour "les" onotologies supportant le multi-critère est effectué ci-dessous.
// Dans les faits ce n'est le cas que pour nvjfl.
$ontologieParamPending = self::NvjflOntologieIndex($resultats, $champs_sup);
$this->NvjflOntologieExpand($ontologieParamPending);
self::NvjflOntologieCombine($resultats);
 
// pour les ontologies multi-critères, on vient de le régler ci-dessus
$champs_sup = array_diff($champs_sup, self::$onto_multi_support);
 
 
// ici, $champs_sup ne peut contenir, au plus, que "taxon".
// code historique:
foreach($champs_sup as $cle) {
$champs_supplementaires = self::$champ_infos[$cle];
// extrait, depuis un élément de $champ_infos:
// $service, $ressource, $projet, $nom, $intitule, $bdd_champ
extract($champs_supplementaires);
 
foreach ($resultats as &$tab) {
$valeur_recherche = $tab[$bdd_champ];
if(!trim($valeur_recherche)) continue;
 
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur_recherche, $projet);
$tab[$intitule] = $this->chercherSignificationCode($url, $nom);
}
}
}
 
/* Récupère les valeurs recherchées pour une liste de résultats, (plus ou moins)
spécifiquement au service d'Ontologies de NVJFL.
Aggrège les valeurs dans le tableau retourné.
Une référence vers l'index du tableau (NULL pour l'instant) est laissée dans
un élément du résultat. */
static function NvjflOntologieIndex(&$resultats, $champs_sup) {
// nous ne supportons le multi-critère que sur les ontologies nvjfl, et nous
// avons précisé celles qui sont concernées dans self::$onto_multi_support
$champs_sup = array_intersect($champs_sup, self::$onto_multi_support);
$ontologieParamPending = Array();
foreach($resultats as &$resultat) {
foreach($champs_sup as $v) {
// de cet extract() nous n'utilisons que $bdd_champ et $ressource
extract(self::$champ_infos[$v]);
if(!isset($resultat[$bdd_champ])) continue;
 
$valeur_recherche = $resultat[$bdd_champ];
if(!trim($valeur_recherche)) continue;
 
// XXX: $ressource contient déjà ':' comme suffixe
$critere = $ressource . $valeur_recherche;
$ontologieParamPending[$critere] = NULL;
// placeholder pour le résultat
$resultat[SPE_INDEX_NVJFL][$v][$critere] =
&$ontologieParamPending[$critere];
}
}
return $ontologieParamPending;
}
 
// TODO: switch to static si il peut en être de même pour ajouterHrefAutreProjet()
/* À partir d'un aggrégat des critère de requêtes d'ontologies, spécifiques à NVJFL,
créé une URL multi-critère.
Celle-ci, dans ce cas précis, n'est que la concaténation, par des virgules,
des couples <ressource:ValeurRecherchée>.
L'URL est appelée et la valeur correspondante est remplacée dans $criteres_requete.
 
Note: dans le cadre du tryptique index/expand/combine pour lequel cette fonction existe,
la valeur est référencée par un élément d'une ou plusieurs lignes de $resultat correspondantes.
Celle(s)-ci sera[ont] donc changée(s) dans la foulée. */
public function NvjflOntologieExpand(&$criteres_requete) {
// équivalent spécifique de ajouterHrefAutreProjet()
$valeurs_requises = implode(',', array_keys($criteres_requete));
// en vérité, nous ne supportons ceci ici que pour nvjfl et non n'importe quel url_service
$url = Config::get('url_service').'/ontologies/'.$valeurs_requises;
$val = $this->consulterHref($url);
 
// TODO, le webservice d'ontologies devrait être modifié pour retourner un tableau
// indexé par critère requesté à *CHAQUE* fois, y compris lorsque 1 seul critère est
// demandé.
if(array_key_exists('id', $val) && count($criteres_requete) == 1) {
$k = key($criteres_requete);
$criteres_requete[$k] = $val;
return;
}
 
// subtilité, cette affectation modifie par conséquent les valeurs dans
// $resultats[X][SPE_INDEX_NVJFL]
// dont la référence pointe toujours sur $v
foreach($val as $k => $v) $criteres_requete[$k] = $val->$k;
}
 
/* Fonction finale du tryptique: réordonne les valeurs obtenues auprès du web-service
NVJFL en adéquation avec les champs attendus en sortie.
Dès l'indexation des critères, nous avons associé une (ou plusieurs) référence(s) du
tableau de résultats vers le tableau de retour des ontologies à l'aide d'un index
particulier l'index SPE_INDEX_NVJFL qui contient comme élément(s)
un ou plusieurs ontologies (les indexes de self::$champ_infos) qui elles-mêmes contiennent
une ou plusieurs valeurs représentant les valeurs recherchées appartement à cette ontologies.
Celui-ci est supprimé après avoir été correctement copié. */
/**
* @param array in/out $resultats: tous les résultats
* @param array in $critere: tableau des ontologies:valeur demandées, de la forme [ numStatut:1, genreNombre:11, ... ]
*/
static function NvjflOntologieCombine(&$resultats) {
foreach($resultats as &$resultat) {
if(!array_key_exists(SPE_INDEX_NVJFL, $resultat)) continue;
 
/* Note: la complétude d'un résultat peut dépendre de plusieurs ontologies différentes,
d'où cette boucle. Cependant une seule valeur sera demandé pour cette ontologie, c'est pourquoi
$resultat[SPE_INDEX_NVJFL][$onto_name], s'il existe, ne contiendra toujours qu'un seul élément.
Puisque par définition un résultat contenant des valeurs d'ontologie n'aura jamais qu'un seul et unique
attribut num_genre (ou num_statut, ou autre) */
foreach(self::$onto_multi_support as $onto_name) {
if(!array_key_exists($onto_name, $resultat[SPE_INDEX_NVJFL])) continue;
 
/* $onto_name est un nom d'ontologie (l'une des clefs, parmi conseil_emploi et genre,
cf la boucle sur $champs_sup dans NvjflOntologieIndex()
de cet extract() nous n'utilisons que $intitule et $nom */
extract(self::$champ_infos[$onto_name]);
 
// equivalent de l'affectation finale de chercherSignificationCode()
// (utilisé lors de recherches d'ontologies en mono-critère)
// XXX: PHP-5.3 pas de récupération d'attribut sur fonction
$r = current($resultat[SPE_INDEX_NVJFL][$onto_name]);
$resultat[$intitule] = $r->$nom;
 
// XXX: certes nous pourrions nous contenter du unset() final
unset($resultat[SPE_INDEX_NVJFL][$onto_name]);
}
unset($resultat[SPE_INDEX_NVJFL]);
}
}
 
/**
* Ajoute les champs d'ontologie supplémentaires si necéssaire
* en faisant appels aux web services associés
* @param array $ligne_resultat
*
* @return array la ligne modifiée
*/
public function ajouterChampsOntologieLigneResultat($ligne_resultat) {
foreach(self::$champ_infos as $cle => $champs_supplementaires) {
if(!in_array($cle, $this->champs_supp)) continue;
// extrait, depuis un élément de $champ_infos:
// $service, $ressource, $projet, $nom, $intitule, $bdd_champ
extract($champs_supplementaires);
$valeur_recherche = $ligne_resultat[$bdd_champ];
if(!trim($valeur_recherche)) continue;
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur_recherche, $projet);
$ligne_resultat[$intitule] = $this->chercherSignificationCode($url, $nom);
}
return $ligne_resultat;
}
/**
* Fonction qui ajoute les attributions à une ligne de résultats
*
* @param array $ligne_tableau_resultat
* @param array $nom_sci
*/
public function ajouterTaxonsAttributionsLigneResultat(&$ligne_tableau_resultat, &$noms_sci) {
if (isset($noms_sci[$ligne_tableau_resultat['num_taxon']])) {
$ligne_tableau_resultat['nom_retenu.code'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['id'];
$ligne_tableau_resultat['taxon'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['nom_sci'];
} else {
$ligne_tableau_resultat = null;
}
return $ligne_tableau_resultat;
}
private function trierLigneTableau($a, $b) {
$retour = 0;
if ($a[$this->champ_tri] == $b[$this->champ_tri]) {
$retour = 0;
}
if($this->champ_tri == 'code_langue') {
if ($a[$this->champ_tri] == 'fra' && $b[$this->champ_tri] != 'fra') {
$retour = ($this->direction_tri == 'asc') ? -1 : 1;
} else if ($a[$this->champ_tri] != 'fra' && $b[$this->champ_tri] == 'fra') {
$retour = ($this->direction_tri == 'asc') ? 1 : -1;
} else {
$retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]);
}
} else {
$retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]);
}
return $retour;
}
private function comparerChaineSelonDirectionTri($a, $b) {
if($this->direction_tri == 'asc') {
return ($a < $b) ? -1 : 1;
} else {
return ($a > $b) ? -1 : 1;
}
}
// formatage de la reponse /id ss la forme
// id, nom_vernaculaire, attributions
// langue
// num_nom (correspond à un taxon bdtfx)
public function formaterNomsVernaculairesId($resultat) {
foreach ($resultat as $taxon) { // pour chaque attribution à un taxon bdtfx
// on crée les variables qui serviront de clés et on les enléves du tableau
$num_nom = $taxon['num_nom_vernaculaire']; // unique pour un trinôme id, langue, taxon
unset($taxon['num_nom_vernaculaire']);
$langue = $taxon['code_langue'];
unset($taxon['code_langue']);
 
foreach ($this->correspondance_champs as $key => $correspondance) { // ordonne les infos pour affichage
if (isset($taxon[$key]) && $taxon[$key] != "") {
$this->afficherDonnees($correspondance, $taxon[$key], $langue, $num_nom);
}
}
foreach ($taxon as $key => $valeur) { // rajoute les champs non prévus dans l'api
if (!isset($this->correspondance_champs[$key]) && $valeur != "") {
$this->afficherDonnees($key, $valeur, $langue, $num_nom);
}
}
if ($this->retour_format == 'max') $this->chargerBiblio($num_nom, $langue);
}
if ($this->retour_format == 'max') $this->afficherTaxons(); // va chercher les noms de tous les taxons
unset($this->table_retour['href']);
return $this->table_retour;
}
 
public function afficherDonnees($champ, $valeur, $langue = '', $num_nom = '') {
if ($champ == 'id' || $champ == 'nom_vernaculaire') {
$this->table_retour[$champ] = $valeur;
} elseif (preg_match('/^(.*)\.code$/', $champ, $match)) {
switch ($match[1]) {
case 'taxon' : if ($this->retour_format == 'max') {$this->taxons[$num_nom] = $valeur;}
$this->afficherPointCode($match[1], $langue, $num_nom, $valeur); break;
case 'langue' : //$this->afficherPointCode($match[1], 'iso-639-3', 'langues', $valeur);
break;
case 'genre' : $this->afficherPointCode($match[1], $langue, $num_nom, $valeur); break;
case 'conseil_emploi' : $this->afficherPointCode($match[1], $langue, $num_nom, $valeur); break;
default : break;
}
 
} elseif ($langue != '') {
$this->table_retour['attributions'][$langue][$num_nom][$champ] = $valeur;
} else {
$this->table_retour[$champ] = $valeur;
}
}
 
public function afficherPointCode($nomChamp, $langue, $num_nom, $valeur) {
if (isset(self::$champ_infos[$nomChamp])) {
extract(self::$champ_infos[$nomChamp]);
}
 
if ($this->retour_format == 'max') {
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet);
if ($service == 'taxons') {
$code_valeur = '';
$this->table_retour['attributions'][$langue][$num_nom]['nom_retenu.code'] = $code_valeur;
} else {
$code_valeur = $this->chercherSignificationCode($url, $nom);
}
if ($projet != '') $projet .= '.';
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp] = $code_valeur;
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.href'] = $url;
} else {
if ($projet != '') $projet .= '.';
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur;
}
}
 
public function chercherSignificationCode($url, $nom) {
if (isset($this->signification_code[$url])) {
$valeur = $this->signification_code[$url];
} else {
$res = $this->consulterHref($url);
$valeur = $res->$nom;
$this->signification_code[$url] = $valeur;
}
return $valeur;
}
 
public function afficherTaxons() {
$resultat = $this->recupererNomTaxons();
foreach ($this->table_retour['attributions'] as $code_langue=>$langue) {
foreach ($langue as $num_nom=>$taxon) {
$num_tax = ltrim($taxon['taxon.code'], 'bdtfx.nt:');
if (isset($resultat[$num_tax])) {
$this->table_retour['attributions'][$code_langue][$num_nom]['nom_retenu.code'] = $resultat[$num_tax]['id'];
$this->table_retour['attributions'][$code_langue][$num_nom]['taxon'] = $resultat[$num_tax]['nom_sci'];
}
}
}
}
public function recupererNomTaxons() {
$taxons = array_unique($this->taxons);
$url = Config::get('url_service_base').'bdtfx/taxons?navigation.limite=500&ns.structure=au&masque.nt='.implode(',', $taxons);
$res = $this->consulterHref($url);
foreach ($res->resultat as $id=>$taxon) {
$resultat[$taxon->num_taxonomique]['id'] = 'bdtfx.nn:'.$id;
$resultat[$taxon->num_taxonomique]['nom_sci'] = $taxon->nom_sci_complet;
}
return $resultat;
}
 
public function formaterNomsVernaculairesIdChamp($resultat) {
$this->table_retour['id'] = $this->ressources[0];
$champs = explode(' ', $this->ressources[1]);
if (in_array('attributions', $champs) != false) {
$this->formaterNomsVernaculairesId($resultat);
unset($this->table_retour['nom_vernaculaire']);
} else {
$champ_attributions = array('num_taxon', 'zone_usage', 'num_statut', 'num_genre', 'notes');
foreach ($resultat as $taxon) {
foreach ($taxon as $key=>$valeur) {
if ($key == 'code_langue' && in_array('langue', $champs) != false) {
$this->table_retour['attributions']['langue'][] = $valeur;
} elseif (in_array($key, $champ_attributions) != false) {
$this->afficherPoint($this->correspondance_champs[$key] , $valeur, $taxon['code_langue'], $taxon['num_nom_vernaculaire']);
} elseif (in_array($key, $champs) != false) {
$this->table_retour[$key] = $valeur;
}
}
if (in_array('biblio', $champs) != false) $this->chargerBiblio($taxon['num_nom_vernaculaire'], $taxon['code_langue']);
}
if (in_array('biblio', $champs) != false && array_search('biblio.num_ref', $this->table_retour) != false) $this->table_retour['biblio'] = null;
}
return $this->table_retour;
}
 
public function afficherPoint($champ, $valeur, $langue, $num_nom) {
preg_match('/^(.*)\.code$/', $champ, $match);
$champ = $match[1];
if (isset(self::$champ_infos[$champ])) {
extract(self::$champ_infos[$champ]);
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet);
$projet .= '.';
}
 
$champs = explode(' ', $this->ressources[1]);
if (in_array($champ.'.*', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url;
}
if (in_array($champ.'.code', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur;
}
if (in_array($champ.'.href', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url;
}
if (in_array($champ, $champs) !== false) {
if (isset($url)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ] = $this->chercherSignificationCode($url, $nom);
} else {
$this->table_retour['attributions'][$langue][$champ] = $valeur;
}
}
}
 
public function afficherLangue($nomChamp, $projet, $service, $valeur, $ressource = '', $nom = 'nom') {
if ($this->retour_format == 'max') {
$this->table_retour['attributions'][$nomChamp] = $nom;
$this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$nomChamp.'.href'] = $url;
} else {
$this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur;
}
}
 
public function chargerBiblio($num_nom, $langue) {
list($table, $version) = explode('_v',$this->table);
$requete = "SELECT b.*, lb.notes FROM nvjfl_lien_biblio_v$version lb, nvjfl_biblio_v$version b ".
"WHERE b.num_ref = lb.num_ref AND lb.num_nom = '$num_nom' ;";
$resultat = $this->getBdd()->recupererTous($requete);
 
if ($resultat == '') { //cas ou la requete comporte des erreurs
$r = 'La requête SQL formée comporte une erreur !!';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r);
Debug::printr($requete);
} elseif ($resultat) {
foreach ($resultat as $res) {
foreach ($res as $cle => $valeur) {
if ($valeur !== "") {
$this->table_retour['attributions'][$langue][$num_nom]['biblio.'.$cle] = $valeur;
}
}
}
}
}
 
}
?>
/tags/v5.3-amandaie/services/modules/0.1/lion1906/NomCommune.php
New file
0,0 → 1,143
<?php
// declare(encoding='UTF-8');
/**
* Classe permettant d'obtenir le nom et le code INSEE des communes les plus proches d'un point (latitude et longitude).
* La latitude et longitude doivent être exprimée par un nombre décimal.
* Ce service fonctionne uniquement sur les communes de France métropolitaine (Corse comprise) présentent
* dans les données Lion1906 téléchargeable à cette adrese : http://www.lion1906.com/Pages/francais/utile/telechargements.html.
* Source des données : Lion1906.com http://www.lion1906.com
* Paramètres du service :
* - lat : latitude
* - lon : longitude
* Exemple :
* http://localhost/lion1906/services/0.1/nom-commune?lat=44.71546&lon=3.84216
*
* @category php 5.2
* @package lion1906
* @author Mohcen BENMOUNAH <mohcen@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class NomCommune {
 
const PATTERN_LAT = '/^[0-9]+(?:[.][0-9]+|)$/';
const PATTERN_LON = '/^[-]?[0-9]+(?:[.][0-9]+|)$/';
const LAT_MAX = 51.071667;
const LAT_MIN = 41.316667;
const LON_MAX = 9.513333;
const LON_MIN = -5.140278;
const NBRE_COMMUNE_PAR_DEFAUT = 10;
const NBRE_COMMUNE_MAX = 100;
const MIME_JSON = 'application/json';
 
private $parametres = array();
private $ressources = array();
private $bdd = null;
 
public function __construct(Bdd $bdd) {
$this->bdd = $bdd;
}
 
public function consulter($ressources, $parametres) {
$this->parametres = $parametres;
$this->ressources = $ressources;
 
$this->definirParametresParDefaut();
$this->verifierParametres();
 
$nomINSEEs = $this->trouverCommunesProches();
$corps = $this->formaterResultats($nomINSEEs);
 
$resultat = new ResultatService();
$resultat->mime = self::MIME_JSON;
$resultat->corps = $corps;
return $resultat;
}
 
private function definirParametresParDefaut() {
if (array_key_exists('nbre', $this->parametres) === false) {
$this->parametres['nbre'] = self::NBRE_COMMUNE_PAR_DEFAUT;
}
}
 
private function verifierParametres() {
extract($this->parametres);
$messages = array();
if (! array_key_exists('lat', $this->parametres)) {
$messages[] = "Vous devez indiquer une latitude en degré décimal à l'aide du paramètres d'url : lat";
} else if (!preg_match(self::PATTERN_LAT, $lat)) {
$messages[] = "La valeur de latitude doit être un nombre décimal positif dont le séparateur décimal est un point. Ex. : 44 ou 43.03";
} else if ($lat > self::LAT_MAX) {
$messages[] = "La valeur de latitude indiquée est supérieure à {self::LAT_MAX} qui est le point le plus au Nord de la France métropolitaine.";
} else if ($lat < self::LAT_MIN) {
$messages[] = "La valeur de latitude indiquée est infèrieure à {self::LAT_MIN} qui est le point le plus au Sud de la France métropolitaine.";
}
if (! array_key_exists('lon', $this->parametres)) {
$messages[] = "Vous devez indiquer une longitude en degré décimal à l'aide du paramètres d'url : lon";
} else if (!preg_match(self::PATTERN_LON, $lon)) {
$messages[] = "La valeur de longitude doit être un nombre décimal dont le séparateur décimal est un point. Ex. : -4.03 ou 3.256";
} else if ($lon > self::LON_MAX) {
$messages[] = "La valeur de longitude indiquée est supérieure à {self::LON_MAX} qui est le point le plus à l'Est de la France métropolitaine.";
} else if ($lon < self::LON_MIN) {
$messages[] = "La valeur de longitude indiquée est infèrieure à {self::LON_MIN} qui est le point le plus à l'Ouest de la France métropolitaine.";
}
if (array_key_exists('nbre', $this->parametres)) {
if (!preg_match('/^[0-9]+$/', $nbre)) {
$messages[] = "Le nombre de commune le plus proche à retourner doit être un entier positif. Ex. : 10";
} else if ($nbre > self::NBRE_COMMUNE_MAX) {
$messages[] = "Le nombre de commune le plus proche à retourner doit être un entier positif inférieur à 100. Ex. : 10";
}
}
 
if (count($messages) != 0) {
$message = implode('<br />', $messages);
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
 
private function formaterResultats($nomINSEEs) {
$communes_trouvees = null;
if (isset($nomINSEEs) && !empty($nomINSEEs)) {
foreach ($nomINSEEs as $nomINSEE) {
$communes_trouvees[] = array('nom' => $nomINSEE['nom'], 'codeINSEE' => $nomINSEE['insee']);
}
if (!is_null($communes_trouvees)) {
if ($this->parametres['nbre'] == 1 && count($communes_trouvees) == 1) {
$communes_trouvees = $communes_trouvees[0];
}
} else {
$message = "Le service '".get_class($this)."' n'a trouvé aucune commune correspondant aux coordonnées : {$parametres['lat']}, {$parametres['lon']}.";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
} else {
$message = "Le service '".get_class($this)."' n'a trouvé aucune commune dont le centroïde correspond aux coordonnées : {$parametres['lat']}, {$parametres['lon']}.";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
return $communes_trouvees;
}
 
/**
* requête qui récupère les 20 communes les plus proches du point recherché
* La distance(AB = \sqrt{(x_B-x_A)^2 + (y_B-y_A)^2}) est calculée sans la racine
* (calcul en plus qui change pas le résultat).
*/
private function trouverCommunesProches() {
$lat = $this->parametres['lat'];
$lon = $this->parametres['lon'];
$requete = 'SELECT '.
" (({$lat} - X(centroide)) * ({$lat} - X(centroide)) + ({$lon} - Y(centroide)) * ({$lon} - Y(centroide))) AS distance, ".
"insee, nom ".
'FROM lion1906_communes_v2008 '.
'ORDER BY distance '.
"LIMIT {$this->parametres['nbre']} ";
$resultat = $this->bdd->recupererTous($requete);
return $resultat;
}
}
?>
/tags/v5.3-amandaie/services/modules/0.1/moissonnage/cartes/SourceDonnees.php
New file
0,0 → 1,186
<?php
 
class SourceDonnees {
private $bdd = null;
private $limitesCarte = '';
private $taxon = array();
private $nomRang = '';
private $taxons = array();
private $genres = array();
private $utilisateurs = null;
public function __construct($limitesCarte, $taxon) {
$this->limitesCarte = $limitesCarte;
foreach ($this->limitesCarte as $bord => $valeur) {
$this->limitesCarte[$bord] = str_replace(",", ".", round($valeur, 6));
}
$this->bdd = new Bdd();
$this->taxon = $taxon;
$this->nomRang = $this->obtenirNomRang();
if ($this->nomRang == 'espece' || $this->nomRang == 'sous_espece') {
$this->taxons = $this->recupererSynonymesEtSousEspeces();
} elseif ($this->nomRang == 'famille') {
$this->genres = $this->recupererGenres();
}
$this->utilisateurs = new Utilisateurs();
}
private function obtenirNomRang() {
$nomsRangs = array('famille', 'genre', 'espece', 'sous_espece');
$rangs = explode(',', Config::get('rangs'));
for ($index = 0; $index < count($nomsRangs) && $rangs[$index] != $this->taxon['rang']; $index ++);
$position = $index == count($nomsRangs) ? count($nomsRangs)-1 : $index;
return $nomsRangs[$position];
}
protected function recupererSynonymesEtSousEspeces() {
$requete =
"SELECT num_nom, nom_sci, nom_complet, num_taxonomique FROM ".Config::get('bdd_table_referentiel').
" WHERE hierarchie LIKE '%-{$this->taxon['num_nom']}-%' ".
"OR num_nom_retenu = {$this->taxon['num_nom_retenu']}";
return $this->bdd->recupererTous($requete);
}
protected function recupererGenres() {
$this->bdd->requeter("USE ".Config::get('bdd_nom'));
$requete =
"SELECT num_nom, nom_sci, num_taxonomique FROM ".Config::get('bdd_table_referentiel').
" WHERE rang=220 AND num_tax_sup={$this->taxon['num_nom']}";
return $this->bdd->recupererTous($requete);
}
public function recupererStationsFloradata() {
$this->bdd->requeter("USE ".Config::get('bdd_nom_floradata'));
$requete =
"SELECT DISTINCTROW zone_geo AS commune, Date(date_observation) AS date, Floor(wgs84_latitude*10)/10 AS lat, ".
"Floor(wgs84_longitude*10)/10 AS lng, courriel_utilisateur AS auteur ".
"FROM cel_obs LEFT JOIN cel_zones_geo cz ON ce_zone_geo=id_zone_geo ".
"WHERE ".$this->construireWhereTaxonFloradata()." AND transmission=1 AND nom_referentiel = '".Config::get('referentielsDispo')."' AND ".
"wgs84_longitude BETWEEN ".$this->limitesCarte['ouest']." AND ".$this->limitesCarte['est']." ".
"AND wgs84_latitude BETWEEN ".$this->limitesCarte['sud']." AND ".$this->limitesCarte['nord']." ".
"AND date_observation<>'0000-00-00 00-00-00' ORDER BY lat DESC, lng ASC, commune, date";
$stations = $this->bdd->recupererTous($requete);
$this->extraireIdentitesAuteurs($stations);
foreach($stations as &$station) {
$station['auteur'] = $this->utilisateurs->getIntitule($station['auteur']);
}
return $stations;
}
private function extraireIdentitesAuteurs($stations) {
$courriels = array();
foreach ($stations as &$station) {
$courriels[] = $station['auteur'];
}
$this->utilisateurs->setCourriels($courriels);
$this->utilisateurs->chargerIdentites();
}
private function construireWhereTaxonFloradata() {
$criteres = array();
$nomRang = $this->obtenirNomRang($this->taxon);
if ($this->nomRang == 'famille') {
$criteres[] = "famille=".$this->bdd->proteger($this->taxon['nom_sci']);
} elseif ($this->nomRang == 'genre') {
$criteres[] = "nom_sel LIKE ".$this->bdd->proteger($this->taxon['nom_sci'].'%');
} else {
$taxons = array($this->taxon['num_nom']);
foreach ($this->taxons as $sousTaxon) {
$taxons[] = $sousTaxon['num_nom'];
}
$criteres[] = "nom_sel_nn IN (".implode(',', array_unique($taxons)) .")";
}
return "(".implode(' OR ',array_unique($criteres)).")";
}
public function recupererStationsMoissonnage($source) {
$this->bdd->requeter("USE ".Config::get('bdd_nom'));
$requete =
"SELECT DISTINCTROW lieu_commune_code_insee, observation_date AS date, observateur_nom_complet AS auteur ".
"FROM {$source}_tapir WHERE ".$this->construireWhereTaxonMoissonnage($source)." ".
"AND lieu_station_longitude BETWEEN ".$this->limitesCarte['ouest']." AND ".$this->limitesCarte['est']." ".
"AND lieu_station_latitude BETWEEN ".$this->limitesCarte['sud']." AND ".$this->limitesCarte['nord']." ".
"AND Length(lieu_commune_code_insee)=5 ORDER BY lieu_commune_code_insee, date"." -- " . __FILE__ . ":" . __LINE__." ". @$_SERVER['REQUEST_URI'];
$stations = $this->bdd->recupererTous($requete);
$this->rechercherInfosCommune($stations);
return $stations;
}
private function construireWhereTaxonMoissonnage($source) {
$nomRang = $this->obtenirNomRang();
$criteres = array();
 
$nom = ($source == "baznat") ? implode('%',explode(' ',$this->taxon['nom_complet'] )) : $this->taxon['nom_sci'] ;
$criteres[] = "nom_scientifique_complet LIKE ".$this->bdd->proteger($nom);
if ($this->nomRang == 'espece' || $this->nomRang == 'sous_espece') {
foreach ($this->taxons as $sousTaxon) {
$nom = ($source == "baznat") ? implode('%',explode(' ',$sousTaxon['nom_complet'] )) : $sousTaxon['nom_sci'];
$criteres[] = "nom_scientifique_complet LIKE ".$this->bdd->proteger($nom);
}
} elseif ($this->nomRang == 'famille') {
foreach ($this->genres as $genre) {
$criteres[] = "nom_scientifique_complet LIKE ".$this->bdd->proteger($genre['nom_sci']."%");
}
}
return "(".implode(' OR ',array_unique($criteres)).")";
}
private function rechercherInfosCommune(& $stations) {
$codesInsee = array();
foreach ($stations as $station) {
$codeInsee = $station['lieu_commune_code_insee'];
if (substr($codeInsee, 0, 2) == '20') {
$codeInsee = '2A'.substr($codeInsee, 2);
$codeInsee2 = '2B'.substr($codeInsee, 2);
}
if (!in_array($codeInsee, $codesInsee)) {
if (substr($codeInsee, 0, 2) == '20') {
$codesInsee[] = "'$codeInsee2'";
}
$codesInsee[] = "'$codeInsee'";
}
}
$nomTableCommunes = Config::get('bdd_table_communes');
$communes = array();
if(count($codesInsee) > 0) {
$requete =
"SELECT insee, nom AS commune, Floor(latitude_degre*10)/10 AS lat, Floor(longitude_degre*10)/10 AS lng ".
"FROM $nomTableCommunes WHERE insee IN (".implode(',', array_unique($codesInsee)).") ORDER BY insee";
$communes = $this->bdd->recupererTous($requete);
}
$indexStation = 0;
foreach ($communes as $commune) {
$codeInsee = $commune['insee'];
if (substr($codeInsee, 0, 2) == '2A' || substr($codeInsee, 0, 2) == '2B') {
$codeInsee = '20'.substr($codeInsee, 2);
}
while ($stations[$indexStation]['lieu_commune_code_insee'] < $codeInsee) {
$indexStation ++;
}
if ($stations[$indexStation]['lieu_commune_code_insee'] == $codeInsee) {
$stations[$indexStation]['lat'] = $commune['lat'];
$stations[$indexStation]['lng'] = $commune['lng'];
$stations[$indexStation]['commune'] = $commune['commune'];
}
}
$lat = array();
$lng = array();
foreach ($stations as $index => $station) {
if (!isset($station['lat'])) {
$station['lat'] = -100;
$station['lng'] = -100;
}
$lat[$index] = $station['lat'];
$lng[$index] = $station['lng'];
}
array_multisort($lat, SORT_DESC, $lng, SORT_ASC, $stations);
}
}
 
?>
/tags/v5.3-amandaie/services/modules/0.1/moissonnage/cartes/FormateurSVG.php
New file
0,0 → 1,321
<?php
 
/**
* Classe qui genere la carte SVG pour les parametres de la requete qui a ete utilisee pour appeler
* le web service
*
* @package framework-0.4
* @author Alexandre GALIBERT <alexandre.galibert@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 2013 Tela Botanica (accueil@tela-botanica.org)
*
*/
 
 
class FormateurSVG {
private $documentXML;
private $coordonnees = array();
private $grille = null;
private $largeur = 0;
private $hauteur = 0;
private $typeMime = '';
private $format = 0;
private $sources = array();
private $image = null;
const ORIGINE = 20037508.342789244;
const MIME_MAP = 'text/html';
public function __construct($nomFichierSVG, $sources, $typeMime, $format) {
$this->chargerSVG($nomFichierSVG);
$this->chargerCoordonnees();
$this->construireParametresRetour($typeMime, $format);
$this->creerStyleSources();
$this->sources = $sources;
}
private function chargerSVG($nomFichierSVG) {
$this->documentXML = new DOMDocument("1.0", "UTF-8");
$this->documentXML->load($nomFichierSVG);
}
private function chargerCoordonnees() {
$viewbox = $this->recupererNoeuds('qgisviewbox');
$this->coordonnees = array(
'xMin' => $viewbox->attributes->getNamedItem('xMin')->value,
'xMax' => $viewbox->attributes->getNamedItem('xMax')->value,
'yMin' => $viewbox->attributes->getNamedItem('yMin')->value,
'yMax' => $viewbox->attributes->getNamedItem('yMax')->value
);
}
private function recupererNoeuds($nomCouche) {
$contenuSVG = $this->documentXML->documentElement->childNodes;
$noeudCouche = null;
$index = 0;
while ($index < $contenuSVG->length && is_null($noeudCouche)) {
$id = $contenuSVG->item($index)->attributes->getNamedItem('id');
if ($id->value == $nomCouche) {
$noeudCouche = $contenuSVG->item($index);
}
$index ++;
}
$noeuds = null;
if (!is_null($noeudCouche)) {
$noeuds = $noeudCouche->firstChild;
}
return $noeuds;
}
private function construireParametresRetour($typeMime, $format) {
$viewBox = $this->documentXML->documentElement->attributes->getNamedItem('viewBox');
$limitesPixels = explode(' ',$viewBox->value);
$this->largeur = intval($limitesPixels[2]);
$this->hauteur = intval($limitesPixels[3]);
$this->typeMime = $typeMime;
$this->format = intval($format);
}
private function creerStyleSources() {
$couleurs = $this->recupererCouleursSources();
$reglesCss = array();
foreach ($couleurs as $codeSource => $codeCouleur) {
$reglesCss[] = ".{$codeSource} {\nfill:{$codeCouleur}\n}\n";
}
$texteCss = $this->documentXML->createCDATASection(implode(' ', $reglesCss));
$noeudStyle = new DomElement('style', '');
$this->documentXML->documentElement->appendChild($noeudStyle);
$noeudStyle->appendChild($texteCss);
}
private function recupererCouleursSources() {
$sourcesDonnees = Config::get('sourcesDonnees');
$codesSources = str_replace('floradata', 'cel', $sourcesDonnees).',tout';
$codes = explode(',', $codesSources);
for ($index = 0; $index < count($codes); $index ++) {
$codes[$index] = "'".$codes[$index]."'";
}
$codesSources = implode(',', $codes);
$bdd = new Bdd();
$requete = "SELECT code, SUBSTR(complements,9) AS couleur FROM ".Config::get('bdd_table_ontologies')." WHERE code IN ({$codesSources})";
$couleurs = $bdd->recupererTous($requete);
$listeCouleurs = array();
foreach ($couleurs as $couleur) {
$couleur['code'] = $couleur['code'] == 'cel' ? 'floradata' : $couleur['code'];
$listeCouleurs[$couleur['code']] = $couleur['couleur'];
}
return $listeCouleurs;
}
 
public function formaterCarte($taxon) {
$limitesCarte = $this->renvoyerLimitesCarte();
$sourceDonnees = new SourceDonnees($limitesCarte, $taxon);
// modification temporaire pour lors de la selection d'un rang au dessus de famille on ne prenne que floradata
// (probleme de performance, qui sera réglé en reremplissant la table de moissonnage)
if($taxon['rang'] >= 180) {
foreach ($this->sources as $source) {
$nomMethode = "recupererStations".($source == 'floradata' ? 'Floradata' : 'Moissonnage');
$stations = $sourceDonnees->$nomMethode($source);
$this->ajouterStations($stations, $source);
}
} else {
$stations = $sourceDonnees->recupererStationsFloradata($source);
$this->ajouterStations($stations, $source);
}
$this->supprimerMaillesVides();
}
public function renvoyerLimitesCarte() {
$limites = array();
list($limites['ouest'], $limites['sud']) = $this->convertirMetresEnPixels(
$this->coordonnees['xMin'], $this->coordonnees['yMin']);
list($limites['est'], $limites['nord']) = $this->convertirMetresEnPixels(
$this->coordonnees['xMax'], $this->coordonnees['yMax']);
return $limites;
}
private function convertirMetresEnPixels($x, $y) {
$longitude = ($x / self::ORIGINE) * 180;
$latitude = ($y / self::ORIGINE) * 180;
$latitude = 180 / M_PI * (2 * atan(exp($latitude * M_PI / 180.0)) - M_PI / 2.0);
return array(round($longitude, 6), round($latitude, 6));
}
private function ajouterStations($stations, $source) {
$grille = $this->recupererNoeuds('grille')->childNodes;
$index = 0;
$maille = $grille->item($index);
foreach ($stations as $station) {
if (!isset($station['lat']) || !isset($station['lng']) || !isset($station['commune'])) {
continue;
}
$idMaille = $maille->attributes->getNamedItem('id')->value;
$bbox = explode('_', substr($idMaille, 5));
$bbox[0] = floatval($bbox[0]);
$bbox[1] = floatval($bbox[1]);
while ($index < $grille->length && (
$bbox[1] > $station['lat'] || ($bbox[1] == $station['lat'] && $bbox[0] < $station['lng'])
)) {
$maille = $grille->item($index ++);
$idMaille = $maille->attributes->getNamedItem('id')->value;
$bbox = explode('_', substr($idMaille, 5));
$bbox[0] = floatval($bbox[0]);
$bbox[1] = floatval($bbox[1]);
}
if ($bbox[1] == $station['lat'] && $bbox[0] == $station['lng']) {
$this->ajouterCommentaire($station, $source, $maille);
$this->appliquerStyleMaille($source, $maille);
}
if ($index == $grille->length) {
break;
}
}
}
private function supprimerMaillesVides() {
$grille = $this->recupererNoeuds('grille')->childNodes;
$index = 0;
while ($index < $grille->length) {
if (!$grille->item($index)->hasAttribute('title')) {
$grille->item($index)->parentNode->removeChild($grille->item($index));
} else {
$index ++;
}
}
}
private function appliquerStyleMaille($source, & $maille) {
if ($maille->hasAttribute('class') && $maille->attributes->getNamedItem('class')->value != $source) {
$maille->setAttribute('class', 'tout');
} elseif (!$maille->hasAttribute('class')) {
$maille->setAttribute('class', $source);
}
}
private function ajouterCommentaire($station, $source, & $maille) {
$commentaires = array();
if ($maille->hasAttribute('title')) {
$commentaires = explode("; ", $maille->attributes->getNamedItem('title')->value);
}
$commentaire = ucfirst($source)." : {$station['commune']}, ";
if (strlen($station['date']) == 4) {
$commentaire .= "en {$station['date']} par {$station['auteur']}";
} else {
$date = preg_replace("/(\d{4})-(\d{2})-(\d{2})/", "$3/$2/$1", $station['date']);
$commentaire .= "le {$date} par {$station['auteur']}";
}
$commentaires[] = trim($commentaire);
$maille->setAttribute('title', implode('; ', $commentaires));
}
public function renvoyerCarte() {
$this->documentXML->documentElement->setAttribute("width", $this->format);
$this->documentXML->documentElement->setAttribute("height", $this->hauteur * $this->format / $this->largeur);
$retour = '';
if ($this->typeMime == self::MIME_MAP) {
$retour = $this->documentXML->saveHTML();
} else {
$retour = $this->convertirEnPng();
}
return $retour;
}
private function convertirEnPng() {
$this->image = imagecreatetruecolor($this->format, $this->hauteur * $this->format / $this->largeur);
imagefill($this->image, 0, 0, imagecolorallocate($this->image, 255, 255, 255));
$this->transformerLignesEnPng('departements');
$this->transformerPolygonesEnPng('grille');
// stocker le contenu encode de l'image generee dans une chaine de caracteres
ob_start();
imagepng($this->image);
$png = ob_get_contents();
ob_end_clean();
return $png;
}
private function transformerLignesEnPng($nomCouche) {
$facteur = floatval($this->format) / floatval($this->largeur);
$noeudCouche = $this->recupererNoeuds($nomCouche);
$couleurContour = $noeudCouche->attributes->getNamedItem('stroke')->value;
for ($index = 0; $index < $noeudCouche->childNodes->length; $index ++) {
$noeudLigne = $noeudCouche->childNodes->item($index);
for ($indexPath = 0; $indexPath < $noeudLigne->childNodes->length; $indexPath ++) {
$coordonneesSvg = $noeudLigne->childNodes->item($indexPath)->attributes->getNamedItem('points')->value;
preg_match_all('/\d+.\d/', $coordonneesSvg, $coordonnees);
$coordonnees = current($coordonnees);
foreach ($coordonnees as $indexCoord => $valeur) {
$coordonnees[$indexCoord] = intval(floatval($valeur) * $facteur);
}
if ($couleurContour != 'none') {
for ($i = 0; $i < count($coordonnees) - 2; $i += 2) {
imageline($this->image, $coordonnees[$i], $coordonnees[$i+1], $coordonnees[$i+2],
$coordonnees[$i+3], $this->allouerCouleur($couleurContour));
}
}
}
}
}
private function transformerPolygonesEnPng($nomCouche) {
$couleurs = $this->recupererCouleursSources();
$facteur = floatval($this->format) / floatval($this->largeur);
$noeudCouche = $this->recupererNoeuds($nomCouche);
$couleurRemplissage = $noeudCouche->attributes->getNamedItem('fill')->value;
$couleurContour = $noeudCouche->attributes->getNamedItem('stroke')->value;
for ($index = 0; $index < $noeudCouche->childNodes->length; $index ++) {
$noeudPolygone = $noeudCouche->childNodes->item($index);
$couleurPolygone = 'none';
if ($noeudPolygone->hasAttribute('class')) {
$couleurPolygone = $couleurs[$noeudPolygone->attributes->getNamedItem('class')->value];
}
for ($indexPath = 0; $indexPath < $noeudPolygone->childNodes->length; $indexPath ++) {
$coordonneesSvg = $noeudPolygone->childNodes->item($indexPath)->attributes->getNamedItem('points')->value;
preg_match_all('/\d+.\d/', $coordonneesSvg, $coordonnees);
$coordonnees = current($coordonnees);
foreach ($coordonnees as $indexCoord => $valeur) {
$coordonnees[$indexCoord] = intval(floatval($valeur) * $facteur);
}
if ($couleurRemplissage != 'none') {
imagefilledpolygon($this->image, $coordonnees, count($coordonnees) / 2, $this->allouerCouleur($couleurRemplissage));
}
if ($couleurContour != 'none') {
imagepolygon($this->image, $coordonnees, count($coordonnees) / 2, $this->allouerCouleur($couleurContour));
}
if ($couleurPolygone != 'none') {
$contourGrille = "rgba(255,255,255,".($this->format >= 300 ? 0.4 : 0).")";
imagefilledrectangle($this->image, $coordonnees[0], $coordonnees[1], $coordonnees[4], $coordonnees[5],
$this->allouerCouleur($couleurPolygone));
imagerectangle($this->image, $coordonnees[0], $coordonnees[1], $coordonnees[4], $coordonnees[5],
$this->allouerCouleur($contourGrille));
}
}
}
}
private function allouerCouleur($couleurTexte) {
preg_match_all('/\d+/', $couleurTexte, $valeurs);
$rouge = $valeurs[0][0];
$vert = $valeurs[0][1];
$bleu = $valeurs[0][2];
$alpha = 0;
if (count($valeurs[0]) > 3) {
$valeurAlpha = floatval($valeurs[0][3].".".$valeurs[0][4]);
$alpha = intval((1.0 - $valeurAlpha) * 127.0);
}
return imagecolorallocatealpha($this->image, $rouge, $vert, $bleu, $alpha);
}
}
 
?>
/tags/v5.3-amandaie/services/modules/0.1/moissonnage/cartes/LegendeCartes.php
New file
0,0 → 1,76
<?php
 
/**
* Classe qui fournit une legende recuperee dans une table d'ontologies pour la renvoyer au client
*
* @package framework-0.4
* @author Alexandre GALIBERT <alexandre.galibert@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 2013 Tela Botanica (accueil@tela-botanica.org)
*
*/
 
class LegendeCartes {
const TYPE_MIME = 'application/json';
const ID_CLASSE = '10';
private $tableOntologies = '';
private $ontologies = array();
private $legende = array();
public function __construct() {
$this->tableOntologies = Config::get('bdd_table_ontologies');
}
public function obtenirLegende() {
$this->chargerOntologies();
$this->chargerLegende();
$resultat = new ResultatService();
$resultat->corps = $this->legende;
$resultat->mime = self::TYPE_MIME;
return $resultat;
}
private function chargerOntologies() {
$bdd = new Bdd();
$requete = "SELECT * FROM {$this->tableOntologies}";
$resultats = $bdd->recupererTous($requete);
if (!is_array($resultats) || count($resultats) <= 0) {
$message = "Les données d'ontologies n'ont pu être chargées pour la ressource demandée";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
foreach ($resultats as $ontologie) {
$this->ontologies[$ontologie['id']] = $this->extraireComplementsOntologies($ontologie);
}
}
private function extraireComplementsOntologies($ontologie) {
if (strlen(trim($ontologie['complements'])) > 0) {
list($cle, $valeur) = explode('=', trim($ontologie['complements']));
$ontologie[trim($cle)] = trim($valeur);
}
return $ontologie;
}
private function chargerLegende() {
foreach ($this->ontologies as $ontologie) {
if ($ontologie['classe_id'] == self::ID_CLASSE && isset($ontologie['legende'])) {
$this->legende[] = array(
'code' => $ontologie['code'],
'couleur' => $ontologie['legende'],
'nom' => $ontologie['nom'],
'description' => $ontologie['description']
);
}
}
}
}
 
?>
/tags/v5.3-amandaie/services/modules/0.1/moissonnage/Cartes.php
New file
0,0 → 1,271
<?php
 
/**
* Classe qui remplit un fond cartographique SVG a partir des observations en base de donnees
* pour un taxon de plante. Elle verifie dans un premier temps la validite des parametres saisis,
* puis charge le fond cartographique depuis le fichier, recupere dans la base de donnees
* les observations sur la France metropolitaine pour le taxon donne et remplit la carte
* en changeant le style CSS des mailles en fonction des coordonnees des points d'observation.
* Le format et la taille de la carte renvoyee au client est parametrable.
*
* Parametres :
* - referentiel : le referentiel taxonomique a interroger pour verifier le taxon. Pour l'instant,
* seul bdtfx (Tracheophytes de France metropolirtaine) est utilise par le web service
* - num_taxon : le numero taxonomique de la plante dont on veut obtenir la carte de repartition.
* Le rang des taxons traites par le web service sont la famille, le genre, l'espece et la sous-espece.
* La recherche des observations s'etend en pus sur les sous taxons et les synonymes.
* - source : une ou plusieurs sources de donnees a interroger. Si le parametre n'est pas indique,
* le web service ira rechercher les observatipons dans toutes les sources de donnees.
* - format : la largeur de la carte, exprimee dans une valeur entiere en pixels.
* Le ratio largeur:hauteur est conserve lors du redimensionnement de la carte pour le retour
* - retour : le type MIME (ou format de fichier) de retour. Sont acceptes par le web service
* le PNG (image/png) et le XML (text/html) pour renvoyer le web service
*
* @package framework-0.4
* @author Alexandre GALIBERT <alexandre.galibert@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 2013 Tela Botanica (accueil@tela-botanica.org)
*
*/
 
class MoissonnageCartes {
 
const MIME_MAP = "text/html";
const MIME_PNG = "image/png";
const METHODE_TELECHARGEMENT = "telecharger";
const METHODE_AFFICHAGE = "afficher";
private $ressources;
private $parametres;
private $referentiel = '';
private $taxon = null;
private $sources = array();
private $format = 0;
private $retour = self::MIME_MAP;
private $methode_livraison = self::METHODE_AFFICHAGE;
private $erreurs = array();
public function consulter($ressources, $parametres) {
$this->parametres = $parametres;
$this->ressources = $ressources;
$resultat = null;
$this->chargerClassesSousDossier();
if ($this->analyserRessources() == true) {
$resultat = $this->formerLegende();
} else {
$this->traiterParametres();
$resultat = $this->formerCarte();
if($this->methode_livraison == self::METHODE_TELECHARGEMENT) {
$this->telechargerCarte($resultat->corps);
}
}
return $resultat;
}
private function analyserRessources() {
$ok = false;
if (isset($this->ressources[0]) && $this->ressources[0] == 'legende') {
$ok = true;
}
return $ok;
}
private function formerLegende() {
$legende = new LegendeCartes();
$resultat = $legende->obtenirLegende();
return $resultat;
}
private function chargerClassesSousDossier() {
$this->verifierExistenceDossier("cartes");
$nomDossier = dirname(__FILE__).DS."cartes";
$dossier = opendir($nomDossier);
$fichiersAInclure = array();
while ($fichier = readdir($dossier)) {
if (filetype($nomDossier.DS.$fichier) == 'file') {
$fichiersAInclure[] = $nomDossier.DS.$fichier;
}
}
$fichiersAInclure = array_reverse($fichiersAInclure);
foreach ($fichiersAInclure as $fichier) {
include_once($fichier);
}
}
private function verifierExistenceDossier($nomDossier) {
$dossier = dirname(__FILE__).DS.$nomDossier;
if (!file_exists($dossier) || !is_dir($dossier)) {
$message = "Problème rencontré lors de la génération de la carte : des ressources ".
"nécessaires au fonctionnement du service n'ont pas été localisées sur le serveur.\n";
throw new Exception($message);
}
}
private function verifierExistenceFichier($nomFichier) {
if (!file_exists($nomFichier)) {
$message = "Problème rencontré lors de la génération de la carte : des ressources ".
"nécessaires au fonctionnement du service n'ont pas été localisées sur le serveur.\n";
throw new Exception($message);
}
}
private function traiterParametres() {
$this->verifierReferentielEtTaxon();
$this->verifierParametreSource();
$this->verifierParametreFormat();
$this->verifierParametreRetour();
$this->verifierParametreMethodeLivraison();
if (count($this->erreurs) > 0) {
$this->renvoyerErreurs();
}
}
private function verifierParametreFormat() {
if (!isset($this->parametres['format'])) {
$this->erreurs[] = "Le paramètre format (dimensions) de l'image n'a pas été indiqué dans l'URL du service.";
} elseif (preg_match('/^[1-9]\d{2}$/', $this->parametres['format']) != 1) {
$this->erreurs[] = "La valeur du paramètre format n'est pas acceptée par le service. ".
"Une largeur valide doit être un nombre entier compris entre 100 et 999.";
} else {
$this->format = $this->parametres['format'];
}
}
private function verifierParametreRetour() {
$typesMime = array(self::MIME_MAP, self::MIME_PNG);
if (!isset($this->parametres['retour'])) {
$this->erreurs[] = "Le paramètre type de retour de l'image n'a pas été indiqué dans l'URL du service.";
} elseif (!in_array($this->parametres['retour'], $typesMime)) {
$this->erreurs[] = "Le format de retour ".$this->parametres['retour']." n'est pas acceptée par le service. ".
" Seuls les types MIME suivants sont gérés : ".implode(',', $typesMime);
} else {
$this->retour = $this->parametres['retour'];
}
}
private function verifierParametreMethodeLivraison() {
$typesMethodeLivraison = array(self::METHODE_AFFICHAGE, self::METHODE_TELECHARGEMENT);
if (isset($this->parametres['methode']) && !in_array($this->parametres['methode'], $typesMethodeLivraison)) {
$this->erreurs[] = "Le format de methode de livraison ".$this->parametres['methode']." n'est pas acceptée par le service. ".
" Seuls les methodes suivantes sont gérés : ".implode(',', $typesMethodeLivraison);
} elseif(isset($this->parametres['methode']) && in_array($this->parametres['methode'], $typesMethodeLivraison)) {
$this->methode_livraison = $this->parametres['methode'];
}
}
private function verifierParametreSource() {
$sourcesDisponibles = explode(',', trim(Config::get('sourcesDonnees')));
if (isset($this->parametres['source'])) {
$sourcesParametre = explode(',', trim($this->parametres['source']));
foreach ($sourcesParametre as $source) {
if (!in_array($source, $sourcesDisponibles)) {
$this->erreurs[] = "La source de données $source n'est pas disponible pour ce service. ".
"Les sources suivantes sont utilisables : ".implode(',', $sourcesDisponibles).".";
} else {
$this->sources[] = $source;
}
}
} else {
$this->sources = $sourcesDisponibles;
}
}
private function verifierReferentielEtTaxon() {
if (!$this->estReferentielDisponible()) {
$this->erreurs[] = "Le référentiel ".$this->parametres['referentiel']." n'a pas été trouvé. ".
"La liste des référentiels disponibles pour ce service sont : ".Config::get('referentielsDispo');
} else {
$this->referentiel = $this->parametres['referentiel'];
$taxon = $this->recupererInformationsTaxon();
if (is_null($taxon)) {
$this->erreurs[] = "Le taxon d'espèce que vous avez demandé n'a pas été trouvé dans le référentiel.";
} else {
$this->taxon = $taxon;
}
}
}
private function renvoyerErreurs() {
$message = "Les erreurs suivantes ont été rencontrées : \n".implode('\n', $this->erreurs);
throw new Exception($message, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
private function estReferentielDisponible() {
$referentielsDispo = explode(',', Config::get('referentielsDispo'));
$estDisponible = (isset($this->parametres['referentiel'])
&& in_array($this->parametres['referentiel'], $referentielsDispo));
return $estDisponible;
}
private function recupererInformationsTaxon() {
$taxon = null;
if (isset($this->parametres['num_taxon'])) {
$numTaxon = $this->parametres['num_taxon'];
$nomTable = $this->recupererNomTableReferentiel();
$bdd = new Bdd();
$requete = "SELECT num_nom, num_nom_retenu, nom_sci, nom_complet, rang, num_taxonomique FROM {$nomTable} ".
"WHERE num_taxonomique={$numTaxon} ORDER BY If(num_nom=num_nom_retenu,0,1) LIMIT 0,1";
$taxon = $bdd->recuperer($requete);
if ($taxon === false) {
$taxon = null;
}
}
return $taxon;
}
private function recupererNomTableReferentiel() {
$tablesReferentiel = explode(',', Config::get('bdd_table_referentiel'));
$nomTable = '';
foreach ($tablesReferentiel as $table) {
if (strstr($table, $this->referentiel) !== false) {
$nomTable = $table;
}
}
return $nomTable;
}
private function formerCarte() {
$suffixe = 'france_moissonnage';
$nomFichierSVG = Config::get('chemin')."{$suffixe}.svg";
$this->verifierExistenceFichier($nomFichierSVG);
$formateur = new FormateurSVG($nomFichierSVG, $this->sources, $this->retour, $this->format);
$formateur->formaterCarte($this->taxon);
$resultat = new ResultatService();
$resultat->corps = $formateur->renvoyerCarte();
$resultat->mime = $this->retour;
//echo '<pre>'.print_r($resultat,true).'</pre>';exit;
 
return $resultat;
}
private function telechargerCarte($fichier) {
if (function_exists('mb_strlen')) {
$taille = mb_strlen($fichier, '8bit');
} else {
$taille = strlen($fichier);
}
$extension = ($this->retour == "text/html") ? 'html' : 'png';
header('Content-Description: File Transfer');
header('Content-Type: application/octet-stream');
header('Content-Disposition: attachment; filename="carte.'.$extension.'"');
header('Content-Transfer-Encoding: binary');
header('Connection: Keep-Alive');
header('Expires: 0');
header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
header('Pragma: public');
header('Content-Length: '.$taille);
}
}
 
?>
/tags/v5.3-amandaie/services/modules/0.1/moissonnage/Ontologies.php
New file
0,0 → 1,366
<?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&param2=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 MoissonnageOntologies 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 consulter($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
$this->service = 'ontologies';
$this->traiterParametres();
$resultats = '';
$this->table = 'eflore_ontologies'; //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, '', $requete);
$resultats = $versionResultat;
return $resultats;
}
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;
case 'version.projet' : 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;
}
}
?>
/tags/v5.3-amandaie/services/modules/0.1/insee-d/ZoneGeo.php
New file
0,0 → 1,405
<?php
/**
* Description :
* Classe ZoneGeo.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 region et
* éventuellement une relation hiérarchique avec un autre terme (=classe).
* Si l'url finit par /zone-geo 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 ? : /observations?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche,
* distinct, retour.format, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Delphine Cauquil <delphine@tela-botanica.org>
* @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 ZoneGeo extends Commun {
 
protected $service = 'zone-geo';
 
/**
* Permet de stocker la requete formulée : /zone-geo | /zone-geo/#id | /zone-geo/#id/champ | /zone-geo/#id/relations
* Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service.
* Est utilisée principalement pr déterminer le format du tableau à retourner. */
protected $format_reponse = 'zone-geo';
 
/** Variables constituant les parametres de la requete SQL (champ, condition, group by, limit) remplie
* selon ressources et paramètres */
protected $requete_champ = ' * ';
protected $requete_condition = '';
protected $limite_requete = array(
'depart' => 0,
'limite' => 100
);
 
/** Stockage des ressources et paramétres */
protected $table_ressources = array();
protected $table_param = array();
/**
* Precise la contenance plus ou moins précise du tableau à retourner :
* - min = les données présentes dans la table
* - max = les données de la table + les informations complémentaires (pour les identifiants et les codes)
* - oss = la liste des nom_sci (uniquement pour noms et taxons)
*/
protected $retour_format = 'max';
/** Valeur du paramètre de requete recherche :
* - stricte : le masque est passé tel quel à l'opérateur LIKE.
* - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE.
* - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */
protected $recherche;
 
/** Permet de stocker le tableau de résultat (non encodé en json) */
protected $table_retour = array();
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */
protected $total_resultat;
 
// +-----------------------------------------------------------------------------------------------------+
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres)) {
$this->table_param = $this->parametres;
 
// masque : filtre la liste en fonction d'un masque de recherche portant sur le code, le nom ou la region.
// masque.code : filtre uniquement sur le code. masque.nom : filtre uniquement sur le nom.
// masque.region : filtre uniquement sur la region.
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') {
$this->recherche = $this->parametres['recherche'];
}
 
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'masque' :
$this->ajouterLeFiltreMasque('masque', $valeur);
break;
case 'masque.code' :
$this->ajouterLeFiltreMasque('dep', $valeur);
break;
case 'masque.nom' :
$this->ajouterLeFiltreMasque('nccenr', $valeur);
break;
case 'masque.region' :
$this->ajouterLeFiltreMasque('region', $valeur);
break;
case 'retour.format' :
$this->retour_format = $valeur;
break;
case 'navigation.depart' :
$this->limite_requete['depart'] = $valeur;
break;
case 'navigation.limite' :
$this->limite_requete['limite'] = $valeur;
break;
case 'recherche' :
break;
default :
$p = '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, $p);
}
}
}
}
 
public function ajouterLeFiltreMasque($nom_champ, $valeur) {
if ($nom_champ == 'dep' || $nom_champ == 'region') {
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if ($this->recherche == 'floue') {
if ($nom_champ == 'masque') {
$this->requete_condition[] = '( dep = '.$this->getBdd()->proteger($valeur)
.' OR region = '.$this->getBdd()->proteger($valeur)
.' OR ( SOUNDEX(nccenr) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(nccenr)) = SOUNDEX(REVERSE(\''.$valeur.'\')) '
.')) ';
} else {
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ';
}
} else {
if ($this->recherche == 'etendue') {
$valeur = str_replace(' ','%', $valeur);
$valeur .= '%';
}
 
if ($nom_champ == 'masque') {
$this->requete_condition[] = ' (dep = '.$this->getBdd()->proteger($valeur)
.' OR nccenr LIKE '.$this->getBdd()->proteger($valeur)
.' OR region = '.$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)) {
$this->table_ressources = $this->ressources;
if (isset($this->table_ressources[0]) && !empty($this->table_ressources[0])) {
//requete = /zone-geo/#id
$this->traiterRessourceId();
if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) {
//dans le cas /zone-geo/#id/#champ ou /zone-geo/#id/relations
$this->traiterRessourceChampOuRelations();
}
}
}
}
 
//requete : /zone-geo/#id (ex : /zone-geo/7)
public function traiterRessourceId() {
if (is_numeric($this->table_ressources[0])) {
$this->requete_condition[] = ' dep = '.$this->getBdd()->proteger($this->table_ressources[0]);
$this->format_reponse .= '/id';
} else {
$r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->table_ressources[0].
' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r);
}
}
 
 
public function traiterRessourceChampOuRelations() {
//requete = /zone-geo/#id/relations :
if ($this->table_ressources[1] == 'relations') {
$this->format_reponse .= '/relations';
$this->requete_condition[] = 'region = (SELECT region FROM '.$this->table.' WHERE '
.implode(' AND ', $this->requete_condition).')';
//requete = /zone-geo/#id/#champ :
} else {
$this->format_reponse .= '/champ';
}
}
 
//+------------------------------------------------------------------------------------------------------+
public function assemblerLaRequete() {
//assemblage de la requete :
$requete = ' SELECT '.$this->requete_champ.
' FROM '.$this->table
.$this->formerRequeteCondition()
.$this->formerRequeteLimite();
return $requete;
}
 
public function formerRequeteCondition() {
$condition = '';
if ($this->requete_condition != null) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
 
//ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes
// suivantes : /zone-geo et /zone-geo/#id/relations)
public function formerRequeteLimite() {
if ($this->format_reponse != 'zone-geo' && $this->format_reponse != 'zone-geo/id/relations') {
$this->requete_limite = '';
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) {
//cas où la requete presente un navigation.depart supérieur au nb total de resultats.
$this->limite_requete['depart'] =
(($nb - $this->limite_requete['limite']) < 0) ? 0 : ($nb - $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 /zone-geo)
$requete = 'SELECT count(*) as nombre FROM '
.$this->table
.$this->formerRequeteCondition();
$res = $this->getBdd()->recuperer($requete);
 
if ($res) {
$total = $res['nombre'];
} else {
$t = 'Fonction recupererTotalResultat() : <br/>Données introuvables dans la base';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $t);
}
return $total;
}
 
//+------------------------------------------------------------------------------------------------------+
// determine en fct du service appelé (/zone-geo | /zone-geo/#id | /zone-geo/#id/champ |
// /zone-geo/#id/relations) le format du tableau à retourner.
public function retournerResultatFormate($resultat) {
$this->recupererTableConfig('correspondance_champs');
switch ($this->format_reponse) {
case 'zone-geo' : $reponse = $this->formaterZoneGeo($resultat); break;
case 'zone-geo/id' : $reponse = $this->formaterZoneGeoId($resultat[0]); break;
case 'zone-geo/id/champ' : $reponse = $this->formaterZoneGeoIdChamp($resultat[0]); break;
case 'zone-geo/id/relations' : $reponse = $this->formaterZoneGeoIdRelations($resultat); break;
default : break;
}
return $reponse;
}
 
public function formaterZoneGeo($resultat) {
//on remplit la table $table_retour_json['entete']
$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, '/zone-geo');
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']; }
$table_retour_json['entete'] = $this->table_retour;
 
//on remplit la table $table_retour_json['resultat']
$this->table_retour = array();
if (isset($this->table_param['masque_nom'])) $resultat = $this->trierRechercheFloue($this->table_param['masque_nom'], $resultat, 'nccenr');
foreach ($resultat as $tab) {
foreach ($tab as $key => $valeur) {
if ($valeur != '') {
switch ($key) {
case 'dep' : $num = $valeur; $this->table_retour['code'] = $valeur; break;
case 'nccenr' : $this->table_retour['nom'] = $valeur; break;
default : break;
}
}
}
if ($this->retour_format == 'max') {
$this->table_retour['href'] = $this->ajouterHref('zone-geo', $num);
}
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array();
}
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
 
public function formaterZoneGeoId($resultat) {
foreach ($resultat as $key => $valeur) {
if ($valeur != '') {
$this->afficherDonnees($key, $valeur);
}
}
unset($this->table_retour['href']);
return $this->table_retour;
}
 
public function formaterZoneGeoIdRelations($resultat) {
if ($resultat == '') {
$retour = null;
} else {
//on remplit la table $table_retour_json['entete']
$this->table_retour['depart'] = $this->limite_requete['depart'];
$this->table_retour['limite'] = $this->limite_requete['limite'];
$this->table_retour['total'] = $this->total_resultat;
//formuler les urls
$url = $this->formulerUrl(count($resultat), '/zone-geo');
if ($url['precedent'] != '') { $this->table_retour['href.precedent'] = $url['precedent']; }
if ($url['suivant'] != '') { $this->table_retour['href.suivant'] = $url['suivant']; }
$retour['entete'] = $this->table_retour;
$this->table_retour = array();
 
//on remplit la table $table_retour_json['resultat']
foreach ($resultat as $tab) {
foreach ($tab as $key => $valeur) {
switch ($key) {
case 'dep' : $num = $valeur; $this->table_retour['code'] = $valeur; break;
case 'nccenr' : $this->table_retour['nom'] = $valeur; break;
default : break;
}
}
if ($this->retour_format == 'max') $this->table_retour['href'] = $this->ajouterHref('zone-geo', $num);
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array();
}
$retour['resultat'] = $resultat_json;
}
return $retour;
}
 
public function formaterZoneGeoIdChamp($resultat) {
//on recupère tous les resultats possibles
$reponse = $this->formaterZoneGeoId($resultat);
$this->table_retour = array();
//on recupère les résultats demandés à partir du tableau de résultat complet
$this->table_retour['id'] = $reponse['code'];
$champs = explode(' ', $this->table_ressources[1]);
 
foreach ($champs as $champ) {
if ($this->verifierValiditeChamp($champ)) {
if (strrpos($champ, '.*') !== false) {
$this->afficherPointEtoile($champ, $reponse);
 
} else {
if (isset($reponse[$champ])) {
$this->table_retour[$champ] = $reponse[$champ];
} else {
$this->table_retour[$champ] = null;
}
}
}
}
return $this->table_retour;
}
 
public function verifierValiditeChamp($champ) {
preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match);
$champs_possibles = $this->correspondance_champs;
$champs_possibles[] = 'nom.*';
 
if (in_array($match[1], $champs_possibles)) {
$validite = true;
} elseif (in_array($match[0], $champs_possibles)) {
$validite = true;
} else {
$champs_possibles = implode('</li><li>', $champs_possibles);
$c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '.
'Les champs disponibles sont : <li>'.$champs_possibles.'</li>';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c);
}
return $validite;
}
 
public function afficherPointEtoile($champ, $reponse) {
preg_match('/^([^.]+\.)\*$/', $champ, $match);
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 afficherDonnees($champ, $valeur) {
if ($this->retour_format == 'max') {
if ($champ == 'region' || $champ == 'chef_lieu') {
$projet = 'insee-'.substr($champ, 0, 1);
$this->table_retour[$champ.'.code'] = $valeur;
$this->table_retour[$champ.'.href'] = $this->ajouterHrefAutreProjet('zone-geo', '', $valeur, $projet);
} elseif ($champ == 'tncc') {
$url = $this->ajouterHref('ontologies', $valeur);
$res = $this->consulterHref($url);
$this->table_retour['type_nom'] = $res->nom;
$this->table_retour['type_nom.code'] = $valeur;
$this->table_retour['type_nom.href'] = $url;
} else {
$this->table_retour[$this->correspondance_champs[$champ]] = $valeur;
}
} else {
$this->table_retour[$this->correspondance_champs[$champ]] = $valeur;
}
}
 
}
 
?>
/tags/v5.3-amandaie/services/modules/0.1/nva/NomsVernaculaires.php
New file
0,0 → 1,653
<?php
/**
* Description :
* Classe NomsVernaculaires.php fournit une liste de noms vernaculaires et leur liaison à la bdtxa
* 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 langue et
* une relation avec un taxon de la bdtxa.
* Si l'url finit par /noms-vernaculaires on retourne une liste de noms (seulement les 100 premières par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /observations?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche,
* distinct, retour.format, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Delphine Cauquil <delphine@tela-botanica.org>
* @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 NomsVernaculaires extends Commun {
protected $champ_infos = array(
'taxon' => array('service' => 'taxons', 'ressource' => 'nt:', 'projet' => 'bdtxa', 'nom' => 'nom_sci'));
 
protected $service = 'noms-vernaculaires';
 
/**
* Permet de stocker la requete formulée : /noms-vernaculaires | /noms-vernaculaires/#id |
* /noms-vernaculaires/#id/champ | /noms-vernaculaires/#id/relations
* Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service.
* Est utilisée principalement pr déterminer le format du tableau à retourner. */
protected $format_reponse = 'noms-vernaculaires';
 
/** Variables constituant les parametres de la requete SQL (champ, condition, limit) remplie
* selon ressources et paramètres */
protected $requete_champ = array(' * ');
protected $requete_condition = '';
protected $limite_requete = array(
'depart' => 0,
'limite' => 100
);
protected $champ_tri = 'code_langue';
protected $direction_tri = 'asc';
/**
* Indique les champs supplémentaires à retourner
* - conseil_emploi = conseil d'emploi du nom vernaculaire
* - genre = genre et nombre du nom
* - taxon = nom retenu associé à ce nom
*/
protected $champs_supp = array();
 
/**
* Precise la contenance plus ou moins précise du tableau à retourner :
* - min = les données présentes dans la table
* - max = les données de la table + les informations complémentaires (pour les identifiants et les codes)
* - oss = la liste des nom_sci (uniquement pour noms et taxons) */
protected $retour_format = 'max';
/** Valeur du paramètre de requete recherche :
* - stricte : le masque est passé tel quel à l'opérateur LIKE.
* - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE.
* - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */
protected $recherche;
/** Permet de stocker le tableau de résultat (non encodé en json) */
protected $table_retour = array();
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */
protected $total_resultat;
private $config;
public function __construct($config) {
$this->config = is_null($config) ? Config::get('NomsVernaculaires') : $config;
}
 
//+------------------------------------------------------------------------------------------------------+
// créer une condition en fonction du paramétre
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres)) {
 
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') {
$this->recherche = $this->parametres['recherche'];
}
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'masque' :
$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
break;
case 'masque.nt' :
$this->ajouterFiltreMasque('num_taxon', $valeur);
break;
case 'masque.nv' :
$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
break;
case 'masque.lg' :
$this->ajouterFiltreMasque('code_langue', $valeur);
break;
case 'retour.format' :
$this->retour_format = $valeur;
break;
case 'navigation.depart' :
$this->limite_requete['depart'] = $valeur;
break;
case 'navigation.limite' :
$this->limite_requete['limite'] = $valeur;
break;
case 'retour.champs' :
$this->champs_supp = explode(',',$valeur);
break;
case 'recherche' :
break;
case 'version.projet' :
break;
default :
$p = '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, $p);
}
}
}
}
 
public function ajouterFiltreMasque($nom_champ, $valeur) {
if ($nom_champ == 'num_taxon') { // si il s'agit d'un chiffre
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if ($this->recherche == 'floue') {
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ';
} else {
if ($this->recherche == 'etendue') {
$valeur = '%'.str_replace(' ','% ', $valeur);
$valeur .= '%';
}
$this->requete_condition[] = 'nva.'.$nom_champ.' LIKE '.$this->getBdd()->proteger($valeur);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
// en fonction de la présence des ressources modifie requete_champ et requete_condition
public function traiterRessources() {
if (isset($this->ressources) && !empty($this->ressources)) {
if (isset($this->ressources[0]) && !empty($this->ressources[0])) {
$this->traiterRessourceId(); // ajoute condition id=#valeur
if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
$this->traiterRessourceChamp(); //modifie requete_champ ou requete_condition
}
}
} else { //rajoute distinct pour ne pas avoir plusieurs fois le même nom
$this->requete_champ = array('distinct(nva.num_nom_vernaculaire)', 'nva.nom_vernaculaire ');
}
}
 
//requete : /noms-vernaculaires/#id (ex : /noms-vernaculaires/7)
public function traiterRessourceId() {
if (is_numeric($this->ressources[0])) {
$this->requete_condition[] = ' nva.num_nom_vernaculaire = '.$this->getBdd()->proteger($this->ressources[0]);
$this->format_reponse .= '/id';
} elseif ($this->ressources[0] == 'attributions') {
$this->format_reponse .= '/attributions';
} else {
$r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->ressources[0].
' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r);
}
}
 
 
public function traiterRessourceChamp() {
$this->format_reponse .= '/champ';
$this->analyserChamp();
}
 
public function analyserChamp() {
$this->requete_champ = array();
$this->recupererTableConfig('champs_possibles');// s'il y a plusieurs champs correspondant au champ demandé ils sont séparé par des |
$champs = explode(' ', $this->ressources[1]);
foreach ($champs as $champ) {
preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match);
if (isset($this->champs_possibles[$match[1]])) {
$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[1]]);
} elseif (isset($this->champs_possibles[$match[0]])) {
$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[0]]);
} else {
$champs_possibles = implode('</li><li>', array_keys($this->champs_possibles));
$c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '.
'Les champs disponibles sont : <li>'.$champs_possibles.'</li> et leurs déclinaisons (ex. ".code").';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
public function assemblerLaRequete() {
$requete = ' SELECT '.$this->formerRequeteChamp().
', CASE nva.code_langue WHEN "fra" THEN 1 ELSE 0 END AS tri '.
' FROM '.str_replace('nva', 'nva_index', $this->table).' inva'.
' LEFT JOIN '.$this->table.' nva ON nva.num_nom_vernaculaire = inva.num_nom_vernaculaire '
.$this->formerRequeteCondition().
' ORDER BY tri DESC, nva.nom_vernaculaire ASC '
.$this->formerRequeteLimite();
return $requete;
}
 
public function formerRequeteChamp() {
if (in_array('*', $this->requete_champ)) {
$champ = ' * ';
} else {
$champ = implode(', ', $this->requete_champ);
}
return $champ;
}
 
public function formerRequeteCondition() {
$condition = '';
if ($this->requete_condition != null) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
//ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes
// suivantes : /noms-vernaculaires et /noms-vernaculaires/#id/relations)
public function formerRequeteLimite() {
if (in_array($this->format_reponse , array($this->service.'/id', $this->service.'/id/champs'))) {
$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;
}
 
//on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /noms-vernaculaires)
public function recupererTotalResultat() {
$distinct = ($this->format_reponse == 'noms-vernaculaires/attributions') ? '*' : 'distinct nva.num_nom_vernaculaire';
$requete = 'SELECT count('.$distinct.') as nombre FROM '
.str_replace('nva', 'nva_index', $this->table).' inva '
.'INNER JOIN '.$this->table.' nva ON nva.num_nom_vernaculaire = '
.'inva.num_nom_vernaculaire '
.$this->formerRequeteCondition();
 
$res = $this->getBdd()->recuperer($requete);
 
if ($res) {
$total = $res['nombre'];
} else {
$t = 'Fonction recupererTotalResultat() : <br/>Données introuvables dans la base '.$requete;
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $t);
}
return $total;
}
 
//+------------------------------------------------------------------------------------------------------+
// determine en fct du service appelé (/noms-vernaculaires | /noms-vernaculaires/#id | /noms-vernaculaires/#id/champ |
// /noms-vernaculaires/#id/relations) le format du tableau à retourner.
public function retournerResultatFormate($resultat) {
$this->recupererTableConfig('correspondance_champs');
switch ($this->format_reponse) {
case 'noms-vernaculaires' :
$reponse = ($this->retour_format == 'oss') ? $this->formaterEnOss($resultat) : $this->formaterNomsVernaculaires($resultat); break;
case 'noms-vernaculaires/attributions' : $reponse = $this->formaterNomsVernaculairesAttributions($resultat); break;
case 'noms-vernaculaires/id' : $reponse = $this->formaterNomsVernaculairesId($resultat); break;
case 'noms-vernaculaires/id/champ' : $reponse = $this->formaterNomsVernaculairesIdChamp($resultat); break;
default : break;
}
return $reponse;
}
public function ajouterJsonEnTeteNV() {
$table_retour_json['masque'] = $this->recupererMasque();
$table_retour_json['depart'] = $this->limite_requete['depart'];
$table_retour_json['limite'] = $this->limite_requete['limite'];
$table_retour_json['total'] = $this->total_resultat;
$url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires');
if (isset($url['precedent']) && $url['precedent'] != '') {
$table_retour_json['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$table_retour_json['href.suivant'] = $url['suivant'];
}
return $table_retour_json;
}
public function ajouterJsonResultatNV($resultat) {
foreach ($resultat as $tab) {
foreach ($tab as $key => $valeur) {
if ($valeur != '') {
switch ($key) {
case 'num_nom_vernaculaire' : $num = $valeur; break;
case 'nom_vernaculaire' : $this->table_retour['nom'] = $valeur; break;
default : break;
}
}
}
if ($this->retour_format == 'max') $this->table_retour['href'] = $this->ajouterHref('noms-vernaculaires', $num);
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array();
}
return $resultat_json;
}
 
public function formaterNomsVernaculaires($resultat) {
$table_retour_json['entete'] = $this->ajouterJsonEnTeteNV();
$resultat = $this->hierarchiserResultat($resultat);
$table_retour_json['resultat'] = $this->ajouterJsonResultatNV($resultat);
return $table_retour_json;
}
public function hierarchiserResultat($resultat) {
//tri recherche floue
if (isset($this->parametres['masque.nv'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque.nv'], $resultat, 'nom_vernaculaire');
}
if (isset($this->parametres['masque'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque'], $resultat, 'nom_vernaculaire');
}
return $resultat;
}
public function recupererMasque() {
$tab_masque = array();
foreach ($this->parametres as $param=>$valeur) {
if (strstr($param, 'masque') != false) {
$tab_masque[] = $param.'='.$valeur;
}
}
$masque = implode('&', $tab_masque);
return $masque;
}
public function formaterEnOss($resultat) {
$table_nom = array();
$oss = '';
foreach ($resultat as $tab) {
if (isset($tab['nom_vernaculaire']) ) {
if (!in_array($tab['nom_vernaculaire'], $table_nom)) {
$table_nom[] = $tab['nom_vernaculaire'];
$oss [] = $tab['nom_vernaculaire'];
}
}
}
$masque = $this->recupererMasque();
if($masque == "") {
$masque = "Pas de masque";
}
$table_retour_oss = array($masque, $oss);
return $table_retour_oss;
}
public function formaterNomsVernaculairesAttributions($resultat) {
$table_retour_json['entete']['masque'] = $this->recupererMasque();
$table_retour_json['entete']['depart'] = $this->limite_requete['depart'];
$table_retour_json['entete']['limite'] = $this->limite_requete['limite'];
$table_retour_json['entete']['total'] = $this->total_resultat;
$url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires/attributions');
if (isset($url['precedent']) && $url['precedent'] != '') {
$table_retour_json['entete']['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$table_retour_json['entete']['href.suivant'] = $url['suivant'];
}
foreach ($resultat as &$tab) {
unset($tab['tri']);
$id_nom = $tab['num_nom_vernaculaire'];
$resultat_json[$id_nom]['id'] = $id_nom;
$resultat_json[$id_nom]['nom_vernaculaire'] = $tab['nom_vernaculaire'];
$resultat_json[$id_nom]['code_langue'] = $tab['code_langue'];
$resultat_json[$id_nom]['taxon.code'] = 'bdtxa.nt:'.$tab['num_taxon'];
if ($this->retour_format == 'max') {
$resultat_json[$id_nom]['num_taxon'] = $tab['num_taxon'];
$resultat_json[$id_nom]['nom_retenu.code'] = $tab['num_taxon'];
$resultat_json[$id_nom]['taxon'] = $tab['num_taxon'];
$this->taxons[] = $tab['num_taxon']; // utilisé pour chercher les noms latins plus bas
$resultat_json[$id_nom]['href'] = $this->ajouterHref('noms-vernaculaires', $id_nom);
if($this->champs_supp != array()) {
$resultat_json[$id_nom] = $this->ajouterChampsOntologieLigneResultat($tab);
}
}
}
if ($this->retour_format == 'max') {
// On est obligé de faire un deuxième boucle pour demander tous les taxons présents en une
// fois et les attribuer aux noms car c'est beaucoup plus rapide
$noms_sci = $this->recupererNomTaxons();
foreach ($resultat_json as $num_nom => &$tab) {
$tab = $this->ajouterTaxonsAttributionsLigneResultat($tab, $noms_sci);
if($tab == null) {
unset($resultat_json[$num_nom]);
}
}
}
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
/**
* Ajoute les champs d'ontologie supplémentaires si necéssaire
* en faisant appels aux web services associés
* @param array $ligne_resultat
*
* @return array la ligne modifiée
*/
public function ajouterChampsOntologieLigneResultat($ligne_resultat) {
$intitule = '';
foreach($this->champ_infos as $cle => $champs_supplementaires) {
if(in_array($cle, $this->champs_supp)) {
extract($champs_supplementaires);
$valeur_recherche = '';
switch($cle) {
case 'taxon':
$valeur_recherche = $ligne_resultat['num_taxon'];
$intitule = 'taxon.code';
break;
}
$code_valeur = '';
if(trim($valeur_recherche) != '') {
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur_recherche, $projet);
$code_valeur = $this->chercherSignificationCode($url, $nom);
}
$ligne_resultat[$intitule] = $code_valeur;
}
}
return $ligne_resultat;
}
/**
* Fonction qui ajoute les attributions à une ligne de résultats
*
* @param array $ligne_tableau_resultat
* @param array $nom_sci
*/
public function ajouterTaxonsAttributionsLigneResultat(&$ligne_tableau_resultat, &$noms_sci) {
if (isset($noms_sci[$ligne_tableau_resultat['num_taxon']])) {
$ligne_tableau_resultat['nom_retenu.code'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['id'];
$ligne_tableau_resultat['taxon'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['nom_sci'];
} else {
$ligne_tableau_resultat = null;
}
return $ligne_tableau_resultat;
}
private function trierLigneTableau($a, $b) {
$retour = 0;
if ($a[$this->champ_tri] == $b[$this->champ_tri]) {
$retour = 0;
}
if($this->champ_tri == 'code_langue') {
if ($a[$this->champ_tri] == 'fra' && $b[$this->champ_tri] != 'fra') {
$retour = ($this->direction_tri == 'asc') ? -1 : 1;
} else if ($a[$this->champ_tri] != 'fra' && $b[$this->champ_tri] == 'fra') {
$retour = ($this->direction_tri == 'asc') ? 1 : -1;
} else {
$retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]);
}
} else {
$retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]);
}
return $retour;
}
private function comparerChaineSelonDirectionTri($a, $b) {
if($this->direction_tri == 'asc') {
return ($a < $b) ? -1 : 1;
} else {
return ($a > $b) ? -1 : 1;
}
}
// formatage de la reponse /id ss la forme
// id, nom_vernaculaire, attributions
// langue
// num_nom (correspond à un taxon bdtxa)
public function formaterNomsVernaculairesId($resultat) {
foreach ($resultat as $taxon) { // pour chaque attribution à un taxon bdtxa
// on crée les variables qui serviront de clés et on les enléves du tableau
$num_nom = $taxon['num_nom_vernaculaire']; // unique pour un trinôme id, langue, taxon
unset($taxon['num_nom_vernaculaire']);
$langue = $taxon['code_langue'];
unset($taxon['code_langue']);
 
foreach ($this->correspondance_champs as $key => $correspondance) { // ordonne les infos pour affichage
if (isset($taxon[$key]) && $taxon[$key] != "") {
$this->afficherDonnees($correspondance, $taxon[$key], $langue, $num_nom);
}
}
foreach ($taxon as $key => $valeur) { // rajoute les champs non prévus dans l'api
if (!isset($this->correspondance_champs[$key]) && $valeur != "") {
$this->afficherDonnees($key, $valeur, $langue, $num_nom);
}
}
}
if ($this->retour_format == 'max') $this->afficherTaxons(); // va chercher les noms de tous les taxons
unset($this->table_retour['href']);
return $this->table_retour;
}
 
public function afficherDonnees($champ, $valeur, $langue = '', $num_nom = '') {
if ($champ == 'num_nom_vernaculaire' || $champ == 'nom_vernaculaire') {
$this->table_retour[$champ] = $valeur;
} elseif (preg_match('/^(.*)\.code$/', $champ, $match)) {
switch ($match[1]) {
case 'taxon' : if ($this->retour_format == 'max') {$this->taxons[$num_nom] = $valeur;}
$this->afficherPointCode($match[1], $langue, $num_nom, $valeur); break;
case 'langue' : //$this->afficherPointCode($match[1], 'iso-639-3', 'langues', $valeur);
break;
default : break;
}
 
} elseif ($langue != '') {
$this->table_retour['attributions'][$langue][$num_nom][$champ] = $valeur;
} else {
$this->table_retour[$champ] = $valeur;
}
}
 
public function afficherPointCode($nomChamp, $langue, $num_nom, $valeur) {
if (isset($this->champ_infos[$nomChamp])) {
extract($this->champ_infos[$nomChamp]);
}
 
if ($this->retour_format == 'max') {
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet);
if ($service == 'taxons') {
$code_valeur = '';
$this->table_retour['attributions'][$langue][$num_nom]['nom_retenu.code'] = $code_valeur;
} else {
$code_valeur = $this->chercherSignificationCode($url, $nom);
}
if ($projet != '') $projet .= '.';
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp] = $code_valeur;
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.href'] = $url;
} else {
if ($projet != '') $projet .= '.';
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur;
}
}
 
public function chercherSignificationCode($url, $nom) {
if (isset($this->signification_code[$url])) {
$valeur = $this->signification_code[$url];
} else {
$res = $this->consulterHref($url);
$valeur = $res->$nom;
$this->signification_code[$url] = $valeur;
}
return $valeur;
}
 
public function afficherTaxons() {
$resultat = $this->recupererNomTaxons();
foreach ($this->table_retour['attributions'] as $code_langue=>$langue) {
foreach ($langue as $num_nom=>$taxon) {
$num_tax = ltrim($taxon['taxon.code'], 'bdtxa.nt:');
if (isset($resultat[$num_tax])) {
$this->table_retour['attributions'][$code_langue][$num_nom]['nom_retenu.code'] = $resultat[$num_tax]['id'];
$this->table_retour['attributions'][$code_langue][$num_nom]['taxon'] = $resultat[$num_tax]['nom_sci'];
}
}
}
}
public function recupererNomTaxons() {
$taxons = array_unique($this->taxons);
$url = Config::get('url_service_base').'bdtxa/taxons?navigation.limite=500&ns.structure=au&masque.nt='.implode(',', $taxons);
$res = $this->consulterHref($url);
foreach ($res->resultat as $id=>$taxon) {
$resultat[$taxon->num_taxonomique]['id'] = 'bdtxa.nn:'.$id;
$resultat[$taxon->num_taxonomique]['nom_sci'] = $taxon->nom_sci_complet;
}
return $resultat;
}
 
public function formaterNomsVernaculairesIdChamp($resultat) {
$this->table_retour['id'] = $this->ressources[0];
$champs = explode(' ', $this->ressources[1]);
if (in_array('attributions', $champs) != false) {
$this->formaterNomsVernaculairesId($resultat);
unset($this->table_retour['nom_vernaculaire']);
} else {
$champ_attributions = array('num_taxon', 'zone_usage', 'num_statut', 'num_genre', 'notes');
foreach ($resultat as $taxon) {
foreach ($taxon as $key=>$valeur) {
if ($key == 'code_langue' && in_array('langue', $champs) != false) {
$this->table_retour['attributions']['langue'][] = $valeur;
} elseif (in_array($key, $champ_attributions) != false) {
$this->afficherPoint($this->correspondance_champs[$key] , $valeur, $taxon['code_langue'], $taxon['num_nom_vernaculaire']);
} elseif (in_array($key, $champs) != false) {
$this->table_retour[$key] = $valeur;
}
}
if (in_array('biblio', $champs) != false) $this->chargerBiblio($taxon['num_nom_vernaculaire'], $taxon['code_langue']);
}
if (in_array('biblio', $champs) != false && array_search('biblio.num_ref', $this->table_retour) != false) $this->table_retour['biblio'] = null;
}
return $this->table_retour;
}
 
public function afficherPoint($champ, $valeur, $langue, $num_nom) {
preg_match('/^(.*)\.code$/', $champ, $match);
$champ = $match[1];
if (isset($this->champ_infos[$champ])) {
extract($this->champ_infos[$champ]);
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet);
$projet .= '.';
}
 
$champs = explode(' ', $this->ressources[1]);
if (in_array($champ.'.*', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url;
}
if (in_array($champ.'.code', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur;
}
if (in_array($champ.'.href', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url;
}
if (in_array($champ, $champs) !== false) {
if (isset($url)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ] = $this->chercherSignificationCode($url, $nom);
} else {
$this->table_retour['attributions'][$langue][$champ] = $valeur;
}
}
}
 
public function afficherLangue($nomChamp, $projet, $service, $valeur, $ressource = '', $nom = 'nom') {
if ($this->retour_format == 'max') {
$this->table_retour['attributions'][$nomChamp] = $nom;
$this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$nomChamp.'.href'] = $url;
} else {
$this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur;
}
}
}
?>
/tags/v5.3-amandaie/services/modules/0.1/iso-3166-1/ZoneGeo.php
New file
0,0 → 1,401
<?php
/**
* Description :
* Classe ZoneGeo.php fournit des informations sur un ensemble de lieux à une échelle donnée.
* 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 region et
* éventuellement une relation hiérarchique avec un autre terme (=classe).
* Si l'url finit par /zone-geo on retourne une liste de zones (seulement les 100 premières par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /zone-geo?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche,
* distinct, retour.format, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Delphine Cauquil <delphine@tela-botanica.org>
* @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 ZoneGeo extends Commun {
 
protected $service = 'zone-geo';
 
/**
* Permet de stocker la requete formulée : /zone-geo | /zone-geo/#id | /zone-geo/#id/champ | /zone-geo/#id/relations
* Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service.
* Est utilisée principalement pr déterminer le format du tableau à retourner. */
protected $format_reponse = 'zone-geo';
 
/** Variables constituant les parametres de la requete SQL (champ, condition, group by, limit) remplie
* selon ressources et paramètres */
protected $requete_champ = ' * ';
protected $requete_condition = '';
protected $limite_requete = array(
'depart' => 0,
'limite' => 100
);
 
/** Stockage des ressources et paramétres */
protected $table_ressources = array();
protected $table_param = array();
/**
* Precise la contenance plus ou moins précise du tableau à retourner :
* - min = les données présentes dans la table
* - max = les données de la table + les informations complémentaires (pour les identifiants et les codes)
* - oss = la liste des nom_sci (uniquement pour noms et taxons)
*/
protected $retour_format = 'max';
/** Valeur du paramètre de requete recherche :
* - stricte : le masque est passé tel quel à l'opérateur LIKE.
* - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE.
* - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */
protected $recherche;
 
/** Permet de stocker le tableau de résultat (non encodé en json) */
protected $table_retour = array();
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */
protected $total_resultat;
 
// +-----------------------------------------------------------------------------------------------------+
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres)) {
$this->table_param = $this->parametres;
 
// masque : filtre la liste en fonction d'un masque de recherche portant sur le code, le nom ou la region.
// masque.code : filtre uniquement sur le code. masque.nom : filtre uniquement sur le nom.
// masque.region : filtre uniquement sur la region.
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') {
$this->recherche = $this->parametres['recherche'];
}
 
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'masque' :
$this->ajouterLeFiltreMasque('masque', $valeur);
break;
case 'masque.code' :
$this->ajouterLeFiltreMasque('codet', $valeur);
break;
case 'masque.nom' :
$this->ajouterLeFiltreMasque('nom', $valeur);
break;
case 'masque.statut' :
$this->ajouterLeFiltreMasque('codet_statut', $valeur);
break;
case 'retour.format' :
$this->retour_format = $valeur;
break;
case 'navigation.depart' :
$this->limite_requete['depart'] = $valeur;
break;
case 'navigation.limite' :
$this->limite_requete['limite'] = $valeur;
break;
case 'recherche' :
break;
default :
$p = '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, $p); break;
}
}
}
}
 
public function ajouterLeFiltreMasque($nom_champ, $valeur) {
if ($nom_champ == 'codet') {
$this->requete_condition[] .= $nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if ($this->recherche == 'floue') {
if ($nom_champ == 'masque') {
$this->requete_condition[] = ' ( codet = '.$this->getBdd()->proteger($valeur)
.' OR (SOUNDEX(nom_francais) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(nom_francais)) = SOUNDEX(REVERSE(\''.$valeur.'\')) OR '
.'SOUNDEX(nom_anglais) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(nom_anglais)) = SOUNDEX(REVERSE(\''.$valeur.'\'))) '
.' OR ( SOUNDEX(codet_statut) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(codet_statut)) = SOUNDEX(REVERSE(\''.$valeur.'\')) '
.')) ';
} elseif ($nom_champ == 'nom') {
$this->requete_condition[] = '(SOUNDEX(nom_francais) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(nom_francais)) = SOUNDEX(REVERSE(\''.$valeur.'\'))) OR
(SOUNDEX(nom_anglais) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(nom_anglais)) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ';
} else {
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ';
}
} else {
if ($this->recherche == 'etendue') {
$valeur = str_replace(' ','%', $valeur);
$valeur .= '%';
}
 
if ($nom_champ == 'masque') {
$this->requete_condition[] = '(codet = '.$this->getBdd()->proteger($valeur)
.' OR nom_francais LIKE '.$this->getBdd()->proteger($valeur)
.' OR nom_anglais LIKE '.$this->getBdd()->proteger($valeur)
.' OR codet_statut LIKE '.$this->getBdd()->proteger($valeur).')';
} elseif ($nom_champ == 'nom') {
$this->requete_condition[] = '(nom_francais LIKE '.$this->getBdd()->proteger($valeur).' OR '
.'nom_anglais 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)) {
$this->table_ressources = $this->ressources;
if (isset($this->table_ressources[0]) && !empty($this->table_ressources[0])) {
//requete = /zone-geo/#id
$this->traiterRessourceId();
if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) {
//requete = /zone-geo/#id/#champ ou /zone-geo/#id/relations
$this->traiterRessourceChampOuRelations();
}
}
}
}
 
public function traiterRessourceId() {
//requete : /zone-geo/#id (ex : /zone-geo/7)
if ($this->table_ressources[0]) {
$this->requete_condition[] = ' codet = '.$this->getBdd()->proteger($this->table_ressources[0]);
$this->format_reponse .= '/id';
} else {
$r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->table_ressources[0].
' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r);
}
}
 
 
public function traiterRessourceChampOuRelations() {
if ($this->table_ressources[1] == 'relations') {
$r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->table_ressources[1].
' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r);
} else {
$this->format_reponse .= '/champ';
}
}
 
// +-------------------------------------------------------------------------------------------------------------------+
public function assemblerLaRequete() {
//assemblage de la requete :
$requete = ' SELECT '.$this->requete_champ.
' FROM '.$this->table
.$this->formerRequeteCondition()
.$this->formerRequeteLimite();
return $requete;
}
 
//ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes
// suivantes : /zone-geo et /zone-geo/#id/relations)
public function formerRequeteLimite() {
if ($this->format_reponse != 'zone-geo') {
$this->requete_limite = '';
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) {
//cas ou la requete presente un navigation.depart supérieur au nb total de resultats.
$this->limite_requete['depart'] =
(($nb - $this->limite_requete['limite']) < 0) ? 0 : ($nb - $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 formerRequeteCondition() {
$condition = '';
if ($this->requete_condition != null) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
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 /zone-geo)
$requete = 'SELECT count(*) as nombre FROM '
.$this->table
.$this->formerRequeteCondition();
$res = $this->getBdd()->recuperer($requete);
 
if ($res) {
$total = $res['nombre'];
} else {
$t = 'Fonction recupererTotalResultat() : <br/>Données introuvables dans la base';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $t);
}
return $total;
}
 
// +-------------------------------------------------------------------------------------------------------------------+
// determine en fct du service appelé (/zone-geo | /zone-geo/#id | /zone-geo/#id/champ |
// /zone-geo/#id/relations) le format du tableau à retourner. Encode en json
public function retournerResultatFormate($resultat) {
$this->recupererTableConfig('correspondance_champs');
switch ($this->format_reponse) {
case 'zone-geo' : $reponse = $this->formaterZoneGeo($resultat); break;
case 'zone-geo/id' : $reponse = $this->formaterZoneGeoId($resultat[0]); break;
case 'zone-geo/id/champ' : $reponse = $this->formaterZoneGeoIdChamp($resultat[0]); break;
default : break;
}
return $reponse;
}
 
public function formaterZoneGeo($resultat) {
//on remplit la table $table_retour_json['entete']
$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, '/zone-geo');
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'];
}
$table_retour_json['entete'] = $this->table_retour;
 
//on remplit la table $table_retour_json['resultat']
$this->table_retour = array();
if (isset($this->table_param['masque_nom'])) $resultat = $this->trierRechercheFloue($this->table_param['masque_nom'], $resultat, 'nom_francais');
foreach ($resultat as $tab) {
foreach ($tab as $key => $valeur) {
$valeur = rtrim($valeur);
if ($valeur != '') {
switch ($key) {
case 'codet' : $num = $valeur; $this->table_retour['code'] = $valeur; break;
case 'nom_francais' : $this->table_retour['nom'] = $valeur; break;
case 'nom_anglais' : if ($tab['nom_francais'] == '') $this->table_retour['nom'] = $valeur; break;
case 'codet_statut' : $this->table_retour['statut'] = $valeur; break;
default : break;
}
}
}
if ($this->retour_format == 'max') {
$this->table_retour['href'] = $this->ajouterHref('zone-geo', $num);
}
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array();
}
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
 
public function formaterZoneGeoId($resultat) {
foreach ($resultat as $key => $valeur) {
if ($valeur != '') {
$this->afficherDonnees($key, $valeur);
}
}
unset($this->table_retour['href']);
return $this->table_retour;
}
 
public function formaterZoneGeoIdChamp($resultat) {
//on recupère tous les resultats possibles
$reponse = $this->formaterZoneGeoId($resultat);
$this->table_retour = array();
//on recupère les résultats demandés à partir du tableau de résultat complet
$this->table_retour['id'] = $reponse['code'];
 
$champs = explode(' ', $this->table_ressources[1]);
foreach ($champs as $champ) {
if ($champ == 'nom') $champ = 'nom.fr';
if ($this->verifierValiditeChamp($champ)) {
if (strrpos($champ, '.*') !== false) {
$this->afficherPointEtoile($champ, $reponse);
} else {
if (isset($reponse[$champ])) {
$this->table_retour[$champ] = $reponse[$champ];
} else {
$this->table_retour[$champ] = null;
}
}
}
}
return $this->table_retour;
}
 
public function verifierValiditeChamp($champ) {
preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match);
$champs_possibles = $this->correspondance_champs;
$champs_possibles[] = 'nom.*';
 
if (in_array($match[1], $champs_possibles)) {
$validite = true;
} elseif (in_array($match[0], $champs_possibles)) {
$validite = true;
} else {
$champs_possibles = implode('</li><li>', $champs_possibles);
$c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '.
'Les champs disponibles sont : <li>'.$champs_possibles.'</li>';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c);
}
return $validite;
}
 
public function afficherPointEtoile($champ, $reponse) {
preg_match('/^([^.]+\.)\*$/', $champ, $match);
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 afficherDonnees($champ, $valeur) {
if ($this->retour_format == 'max') {
if ($champ == 'codet_statut') {
$this->table_retour[$this->correspondance_champs[$champ]] = $valeur;
$this->table_retour[$this->correspondance_champs[$champ].'.href'] =
$this->ajouterHref('ontologies', 'masque.nom=Codet '.$valeur, '?');
} else {
$this->table_retour[$this->correspondance_champs[$champ]] = $valeur;
}
} else {
$this->table_retour[$this->correspondance_champs[$champ]] = $valeur;
}
}
 
// +-------------------------------------------------------------------------------------------------------------------+
/** Permet de retourner l'url http://tela-botanica.org/service:eflore:0.1/[projet]/[version_projet]/[service]/[ressource]:[valeur]
* @param $service : correspond au nom de la ressource à laquelle on souhaite acceder
* @param $val : correspond au paramètre de la ressource (ex :
* @param $projet : est remplit dans les cas suivants :
* - si le projet dans lequel se trouve l'information est différent de celui du service appelé
* - si on souhaite rappeler le meme projet avec la meme ressource mais un parametre de ressource différent
*/
public function ajouterHref($service, $val, $separation = '/') {
$val = $this->encoderUrl($val);
if ($this->version_projet == '+') {
$url = Config::get('url_service_base').Config::get('nom_projet').'/'.$service.$separation.$val;
} else {
$url = Config::get('url_service_base').Config::get('nom_projet').'/'.$this->version_projet.'/'.$service.$separation.$val;
}
return $url;
}
 
public function encoderUrl($url) {
$url = str_replace(' ', '%20', $url);
$url = str_replace('?', urlencode('?'), $url);
return $url;
}
}
?>
/tags/v5.3-amandaie/services/modules/0.1/nvps/NomsVernaculaires.php
New file
0,0 → 1,652
<?php
/**
* Description :
* Classe NomsVernaculaires.php fournit une liste de noms vernaculaires et leur liaison à la bdtfx
* 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 langue et
* une relation avec un taxon de la bdtfx.
* Si l'url finit par /noms-vernaculaires on retourne une liste de noms (seulement les 100 premières par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /observations?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche,
* distinct, retour.format, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Delphine Cauquil <delphine@tela-botanica.org>
* @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 NomsVernaculaires extends Commun {
protected $champ_infos = array(
'taxon' => array('service' => 'taxons', 'ressource' => 'nt:', 'projet' => 'bdtfx', 'nom' => 'nom_sci'));
 
protected $service = 'noms-vernaculaires';
 
/**
* Permet de stocker la requete formulée : /noms-vernaculaires | /noms-vernaculaires/#id |
* /noms-vernaculaires/#id/champ | /noms-vernaculaires/#id/relations
* Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service.
* Est utilisée principalement pr déterminer le format du tableau à retourner. */
protected $format_reponse = 'noms-vernaculaires';
 
/** Variables constituant les parametres de la requete SQL (champ, condition, limit) remplie
* selon ressources et paramètres */
protected $requete_champ = array(' * ');
protected $requete_condition = '';
protected $limite_requete = array(
'depart' => 0,
'limite' => 100
);
protected $champ_tri = 'code_langue';
protected $direction_tri = 'asc';
/**
* Indique les champs supplémentaires à retourner
* - conseil_emploi = conseil d'emploi du nom vernaculaire
* - genre = genre et nombre du nom
* - taxon = nom retenu associé à ce nom
*/
protected $champs_supp = array();
 
/**
* Precise la contenance plus ou moins précise du tableau à retourner :
* - min = les données présentes dans la table
* - max = les données de la table + les informations complémentaires (pour les identifiants et les codes)
* - oss = la liste des nom_sci (uniquement pour noms et taxons) */
protected $retour_format = 'max';
/** Valeur du paramètre de requete recherche :
* - stricte : le masque est passé tel quel à l'opérateur LIKE.
* - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE.
* - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */
protected $recherche;
/** Permet de stocker le tableau de résultat (non encodé en json) */
protected $table_retour = array();
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */
protected $total_resultat;
private $config;
public function __construct($config) {
$this->config = is_null($config) ? Config::get('NomsVernaculaires') : $config;
}
 
//+------------------------------------------------------------------------------------------------------+
// créer une condition en fonction du paramétre
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres)) {
 
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') {
$this->recherche = $this->parametres['recherche'];
}
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'masque' :
$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
break;
case 'masque.nt' :
$this->ajouterFiltreMasque('num_taxon', $valeur);
break;
case 'masque.nv' :
$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
break;
case 'masque.lg' :
$this->ajouterFiltreMasque('code_langue', $valeur);
break;
case 'masque.cce' :
$this->ajouterFiltreMasque('num_statut', $valeur);
break;
case 'retour.format' :
$this->retour_format = $valeur;
break;
case 'navigation.depart' :
$this->limite_requete['depart'] = $valeur;
break;
case 'navigation.limite' :
$this->limite_requete['limite'] = $valeur;
break;
case 'retour.champs' :
$this->champs_supp = explode(',',$valeur);
break;
case 'recherche' :
break;
case 'version.projet' :
break;
default :
$p = '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, $p);
}
}
}
}
 
public function ajouterFiltreMasque($nom_champ, $valeur) {
if ($nom_champ == 'num_taxon') { // si il s'agit d'un chiffre
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if ($this->recherche == 'floue') {
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ';
} else {
if ($this->recherche == 'etendue') {
$valeur = '%'.str_replace(' ','% ', $valeur);
$valeur .= '%';
}
$this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
// en fonction de la présence des ressources modifie requete_champ et requete_condition
public function traiterRessources() {
if (isset($this->ressources) && !empty($this->ressources)) {
if (isset($this->ressources[0]) && !empty($this->ressources[0])) {
$this->traiterRessourceId(); // ajoute condition id=#valeur
if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
$this->traiterRessourceChamp(); //modifie requete_champ ou requete_condition
}
}
} else { //rajoute distinct pour ne pas avoir plusieurs fois le même nom
$this->requete_champ = array('distinct(id)', 'nom_vernaculaire ');
}
}
 
//requete : /noms-vernaculaires/#id (ex : /noms-vernaculaires/7)
public function traiterRessourceId() {
if (is_numeric($this->ressources[0])) {
$this->requete_condition[] = ' id = '.$this->getBdd()->proteger($this->ressources[0]);
$this->format_reponse .= '/id';
} elseif ($this->ressources[0] == 'attributions') {
$this->format_reponse .= '/attributions';
} else {
$r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->ressources[0].
' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r);
}
}
 
 
public function traiterRessourceChamp() {
$this->format_reponse .= '/champ';
$this->analyserChamp();
}
 
public function analyserChamp() {
$this->requete_champ = array();
$this->recupererTableConfig('champs_possibles');// s'il y a plusieurs champs correspondant au champ demandé ils sont séparé par des |
$champs = explode(' ', $this->ressources[1]);
foreach ($champs as $champ) {
preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match);
if (isset($this->champs_possibles[$match[1]])) {
$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[1]]);
} elseif (isset($this->champs_possibles[$match[0]])) {
$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[0]]);
} else {
$champs_possibles = implode('</li><li>', array_keys($this->champs_possibles));
$c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '.
'Les champs disponibles sont : <li>'.$champs_possibles.'</li> et leurs déclinaisons (ex. ".code").';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
public function assemblerLaRequete() {
$requete = ' SELECT '.$this->formerRequeteChamp().
' FROM '.$this->table
.$this->formerRequeteCondition()
.$this->formerRequeteLimite();
return $requete;
}
 
public function formerRequeteChamp() {
if (in_array('*', $this->requete_champ)) {
$champ = ' * ';
} else {
$champ = implode(', ', $this->requete_champ);
}
return $champ;
}
 
public function formerRequeteCondition() {
$condition = '';
if ($this->requete_condition != null) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
//ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes
// suivantes : /noms-vernaculaires et /noms-vernaculaires/#id/relations)
public function formerRequeteLimite() {
if (in_array($this->format_reponse , array($this->service.'/id', $this->service.'/id/champs'))) {
$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;
}
 
//on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /noms-vernaculaires)
public function recupererTotalResultat() {
$distinct = ($this->format_reponse == 'noms-vernaculaires/attributions') ? 'id' : 'distinct(id)';
$requete = 'SELECT count('.$distinct.') as nombre FROM '
.$this->table
.$this->formerRequeteCondition();
$res = $this->getBdd()->recuperer($requete);
 
if ($res) {
$total = $res['nombre'];
} else {
$t = 'Fonction recupererTotalResultat() : <br/>Données introuvables dans la base '.$requete;
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $t);
}
return $total;
}
 
//+------------------------------------------------------------------------------------------------------+
// determine en fct du service appelé (/noms-vernaculaires | /noms-vernaculaires/#id | /noms-vernaculaires/#id/champ |
// /noms-vernaculaires/#id/relations) le format du tableau à retourner.
public function retournerResultatFormate($resultat) {
$this->recupererTableConfig('correspondance_champs');
switch ($this->format_reponse) {
case 'noms-vernaculaires' :
$reponse = ($this->retour_format == 'oss') ? $this->formaterEnOss($resultat) : $this->formaterNomsVernaculaires($resultat); break;
case 'noms-vernaculaires/attributions' : $reponse = $this->formaterNomsVernaculairesAttributions($resultat); break;
case 'noms-vernaculaires/id' : $reponse = $this->formaterNomsVernaculairesId($resultat); break;
case 'noms-vernaculaires/id/champ' : $reponse = $this->formaterNomsVernaculairesIdChamp($resultat); break;
default : break;
}
return $reponse;
}
public function ajouterJsonEnTeteNV() {
$table_retour_json['masque'] = $this->recupererMasque();
$table_retour_json['depart'] = $this->limite_requete['depart'];
$table_retour_json['limite'] = $this->limite_requete['limite'];
$table_retour_json['total'] = $this->total_resultat;
$url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires');
if (isset($url['precedent']) && $url['precedent'] != '') {
$table_retour_json['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$table_retour_json['href.suivant'] = $url['suivant'];
}
return $table_retour_json;
}
public function ajouterJsonResultatNV($resultat) {
foreach ($resultat as $tab) {
foreach ($tab as $key => $valeur) {
if ($valeur != '') {
switch ($key) {
case 'id' : $num = $valeur; break;
case 'nom_vernaculaire' : $this->table_retour['nom'] = $valeur; break;
default : break;
}
}
}
if ($this->retour_format == 'max') $this->table_retour['href'] = $this->ajouterHref('noms-vernaculaires', $num);
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array();
}
return $resultat_json;
}
 
public function formaterNomsVernaculaires($resultat) {
$table_retour_json['entete'] = $this->ajouterJsonEnTeteNV();
$resultat = $this->hierarchiserResultat($resultat);
$table_retour_json['resultat'] = $this->ajouterJsonResultatNV($resultat);
return $table_retour_json;
}
public function hierarchiserResultat($resultat) {
//tri recherche floue
if (isset($this->parametres['masque.nv'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque.nv'], $resultat, 'nom_vernaculaire');
}
if (isset($this->parametres['masque'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque'], $resultat, 'nom_vernaculaire');
}
return $resultat;
}
public function recupererMasque() {
$tab_masque = array();
foreach ($this->parametres as $param=>$valeur) {
if (strstr($param, 'masque') != false) {
$tab_masque[] = $param.'='.$valeur;
}
}
$masque = implode('&', $tab_masque);
return $masque;
}
public function formaterEnOss($resultat) {
$table_nom = array();
$oss = '';
foreach ($resultat as $tab) {
if (isset($tab['nom_vernaculaire']) ) {
if (!in_array($tab['nom_vernaculaire'], $table_nom)) {
$table_nom[] = $tab['nom_vernaculaire'];
$oss [] = $tab['nom_vernaculaire'];
}
}
}
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 formaterNomsVernaculairesAttributions($resultat) {
//on remplie la table $table_retour_json['entete']
$table_retour_json['entete']['masque'] = $this->recupererMasque();
$table_retour_json['entete']['depart'] = $this->limite_requete['depart'];
$table_retour_json['entete']['limite'] = $this->limite_requete['limite'];
$table_retour_json['entete']['total'] = $this->total_resultat;
$url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires/attributions');
if (isset($url['precedent']) && $url['precedent'] != '') {
$table_retour_json['entete']['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$table_retour_json['entete']['href.suivant'] = $url['suivant'];
}
foreach ($resultat as &$tab) {
$resultat_json[$tab['id']]['id'] = $tab['id'];
$resultat_json[$tab['id']]['nom_vernaculaire'] = $tab['nom_vernaculaire'];
$resultat_json[$tab['id']]['code_langue'] = $tab['code_langue'];
$resultat_json[$tab['id']]['taxon.code'] = 'bdtfx.nt:'.$tab['num_taxon'];
if ($this->retour_format == 'max') {
$resultat_json[$tab['id']]['num_taxon'] = $tab['num_taxon'];
$resultat_json[$tab['id']]['nom_retenu.code'] = $tab['num_taxon'];
$resultat_json[$tab['id']]['taxon'] = $tab['num_taxon'];
$this->taxons[] = $tab['num_taxon']; // utilisé pour chercher les noms latins plus bas
$resultat_json[$tab['id']]['href'] = $this->ajouterHref('noms-vernaculaires', $tab['id']);
if($this->champs_supp != array()) {
$resultat_json[$tab['id']] = $this->ajouterChampsOntologieLigneResultat($tab);
}
}
}
if ($this->retour_format == 'max') {
// On est obligé de faire un deuxième boucle pour demander tous les taxons présents en une
// fois et les attribuer aux noms car c'est beaucoup plus rapide
$noms_sci = $this->recupererNomTaxons();
foreach ($resultat_json as $num_nom => &$tab) {
$tab = $this->ajouterTaxonsAttributionsLigneResultat($tab, $noms_sci);
if($tab == null) {
unset($resultat_json[$num_nom]);
}
}
}
uasort($resultat_json, array($this,'trierLigneTableau'));
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
/**
* Ajoute les champs d'ontologie supplémentaires si necéssaire
* en faisant appels aux web services associés
* @param array $ligne_resultat
*
* @return array la ligne modifiée
*/
public function ajouterChampsOntologieLigneResultat($ligne_resultat) {
$intitule = '';
foreach($this->champ_infos as $cle => $champs_supplementaires) {
if(in_array($cle, $this->champs_supp)) {
extract($champs_supplementaires);
$valeur_recherche = '';
switch($cle) {
case 'taxon':
$valeur_recherche = $ligne_resultat['num_taxon'];
$intitule = 'taxon.code';
break;
}
$code_valeur = '';
if(trim($valeur_recherche) != '') {
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur_recherche, $projet);
$code_valeur = $this->chercherSignificationCode($url, $nom);
}
$ligne_resultat[$intitule] = $code_valeur;
}
}
return $ligne_resultat;
}
/**
* Fonction qui ajoute les attributions à une ligne de résultats
*
* @param array $ligne_tableau_resultat
* @param array $nom_sci
*/
public function ajouterTaxonsAttributionsLigneResultat(&$ligne_tableau_resultat, &$noms_sci) {
if (isset($noms_sci[$ligne_tableau_resultat['num_taxon']])) {
$ligne_tableau_resultat['nom_retenu.code'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['id'];
$ligne_tableau_resultat['taxon'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['nom_sci'];
} else {
$ligne_tableau_resultat = null;
}
return $ligne_tableau_resultat;
}
private function trierLigneTableau($a, $b) {
$retour = 0;
if ($a[$this->champ_tri] == $b[$this->champ_tri]) {
$retour = 0;
}
if($this->champ_tri == 'code_langue') {
if ($a[$this->champ_tri] == 'fra' && $b[$this->champ_tri] != 'fra') {
$retour = ($this->direction_tri == 'asc') ? -1 : 1;
} else if ($a[$this->champ_tri] != 'fra' && $b[$this->champ_tri] == 'fra') {
$retour = ($this->direction_tri == 'asc') ? 1 : -1;
} else {
$retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]);
}
} else {
$retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]);
}
return $retour;
}
private function comparerChaineSelonDirectionTri($a, $b) {
if($this->direction_tri == 'asc') {
return ($a < $b) ? -1 : 1;
} else {
return ($a > $b) ? -1 : 1;
}
}
// formatage de la reponse /id ss la forme
// id, nom_vernaculaire, attributions
// langue
// num_nom (correspond à un taxon bdtfx)
public function formaterNomsVernaculairesId($resultat) {
foreach ($resultat as $taxon) { // pour chaque attribution à un taxon bdtfx
// on crée les variables qui serviront de clés et on les enléves du tableau
$num_nom = $taxon['id']; // unique pour un trinôme id, langue, taxon
$langue = $taxon['code_langue'];
unset($taxon['code_langue']);
 
foreach ($this->correspondance_champs as $key => $correspondance) { // ordonne les infos pour affichage
if (isset($taxon[$key]) && $taxon[$key] != "") {
$this->afficherDonnees($correspondance, $taxon[$key], $langue, $num_nom);
}
}
foreach ($taxon as $key => $valeur) { // rajoute les champs non prévus dans l'api
if (!isset($this->correspondance_champs[$key]) && $valeur != "") {
$this->afficherDonnees($key, $valeur, $langue, $num_nom);
}
}
}
if ($this->retour_format == 'max') $this->afficherTaxons(); // va chercher les noms de tous les taxons
unset($this->table_retour['href']);
return $this->table_retour;
}
 
public function afficherDonnees($champ, $valeur, $langue = '', $num_nom = '') {
if ($champ == 'id' || $champ == 'nom_vernaculaire') {
$this->table_retour[$champ] = $valeur;
} elseif (preg_match('/^(.*)\.code$/', $champ, $match)) {
switch ($match[1]) {
case 'taxon' : if ($this->retour_format == 'max') {$this->taxons[$num_nom] = $valeur;}
$this->afficherPointCode($match[1], $langue, $num_nom, $valeur); break;
case 'langue' : //$this->afficherPointCode($match[1], 'iso-639-3', 'langues', $valeur);
break;
default : break;
}
 
} elseif ($langue != '') {
$this->table_retour['attributions'][$langue][$num_nom][$champ] = $valeur;
} else {
$this->table_retour[$champ] = $valeur;
}
}
 
public function afficherPointCode($nomChamp, $langue, $num_nom, $valeur) {
if (isset($this->champ_infos[$nomChamp])) {
extract($this->champ_infos[$nomChamp]);
}
 
if ($this->retour_format == 'max') {
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet);
if ($service == 'taxons') {
$code_valeur = '';
$this->table_retour['attributions'][$langue][$num_nom]['nom_retenu.code'] = $code_valeur;
} else {
$code_valeur = $this->chercherSignificationCode($url, $nom);
}
if ($projet != '') $projet .= '.';
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp] = $code_valeur;
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.href'] = $url;
} else {
if ($projet != '') $projet .= '.';
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur;
}
}
 
public function chercherSignificationCode($url, $nom) {
if (isset($this->signification_code[$url])) {
$valeur = $this->signification_code[$url];
} else {
$res = $this->consulterHref($url);
$valeur = $res->$nom;
$this->signification_code[$url] = $valeur;
}
return $valeur;
}
 
public function afficherTaxons() {
$resultat = $this->recupererNomTaxons();
foreach ($this->table_retour['attributions'] as $code_langue=>$langue) {
foreach ($langue as $num_nom=>$taxon) {
$num_tax = ltrim($taxon['taxon.code'], 'bdtfx.nt:');
if (isset($resultat[$num_tax])) {
$this->table_retour['attributions'][$code_langue][$num_nom]['nom_retenu.code'] = $resultat[$num_tax]['id'];
$this->table_retour['attributions'][$code_langue][$num_nom]['taxon'] = $resultat[$num_tax]['nom_sci'];
}
}
}
}
public function recupererNomTaxons() {
$taxons = array_unique($this->taxons);
$url = Config::get('url_service_base').'bdtfx/taxons?navigation.limite=500&ns.structure=au&masque.nt='.implode(',', $taxons);
$res = $this->consulterHref($url);
foreach ($res->resultat as $id=>$taxon) {
$resultat[$taxon->num_taxonomique]['id'] = 'bdtfx.nn:'.$id;
$resultat[$taxon->num_taxonomique]['nom_sci'] = $taxon->nom_sci_complet;
}
return $resultat;
}
 
public function formaterNomsVernaculairesIdChamp($resultat) {
$this->table_retour['id'] = $this->ressources[0];
$champs = explode(' ', $this->ressources[1]);
if (in_array('attributions', $champs) != false) {
$this->formaterNomsVernaculairesId($resultat);
unset($this->table_retour['nom_vernaculaire']);
} else {
$champ_attributions = array('num_taxon', 'genre', 'notes');
foreach ($resultat as $taxon) {
foreach ($taxon as $key=>$valeur) {
if ($key == 'code_langue' && in_array('langue', $champs) != false) {
$this->table_retour['attributions']['langue'][] = $valeur;
} elseif (in_array($key, $champ_attributions) != false) {
$this->afficherPoint($this->correspondance_champs[$key] , $valeur, $taxon['code_langue'], $taxon['id']);
} elseif (in_array($key, $champs) != false) {
$this->table_retour[$key] = $valeur;
}
}
}
}
return $this->table_retour;
}
 
public function afficherPoint($champ, $valeur, $langue, $num_nom) {
preg_match('/^(.*)\.code$/', $champ, $match);
$champ = $match[1];
if (isset($this->champ_infos[$champ])) {
extract($this->champ_infos[$champ]);
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet);
$projet .= '.';
}
 
$champs = explode(' ', $this->ressources[1]);
if (in_array($champ.'.*', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url;
}
if (in_array($champ.'.code', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur;
}
if (in_array($champ.'.href', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url;
}
if (in_array($champ, $champs) !== false) {
if (isset($url)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ] = $this->chercherSignificationCode($url, $nom);
} else {
$this->table_retour['attributions'][$langue][$champ] = $valeur;
}
}
}
 
public function afficherLangue($nomChamp, $projet, $service, $valeur, $ressource = '', $nom = 'nom') {
if ($this->retour_format == 'max') {
$this->table_retour['attributions'][$nomChamp] = $nom;
$this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$nomChamp.'.href'] = $url;
} else {
$this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur;
}
}
 
 
}
?>
/tags/v5.3-amandaie/services/modules/0.1/baseflor/Graphiques.php
New file
0,0 → 1,42
<?php
/**
* Classe Graphiques.php détermine le type de graphiques à afficher en fonction des données des tables
* baseflor et baseflor_rang_sup_ecologie
* fin d'url possibles :
* graphiques/#typegraphique/#bdnt.nn:#num_nomen --> renvoie une graphique avec les données connues
*
*
* @package eflore-projets
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @author Mathilde SALTHUN-LASSALLE <mathilde@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)
*/
 
class Graphiques extends Commun{
 
 
private $Graph_tables = array('GraphiquesBaseflor', 'GraphiquesTaxonsSup');
public function consulter($ressources, $parametres) {
$versionResultat = null;
foreach ($this->Graph_tables as $graph_tab) {
$Graph = new $graph_tab();
$versionResultat = $Graph->consulter($ressources, $parametres);
if($versionResultat != null) {break;}
}
if ($versionResultat == null) {
$message = 'Les données recherchées sont introuvables.';
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
return $versionResultat;
}
 
}
?>
/tags/v5.3-amandaie/services/modules/0.1/baseflor/Informations.php
New file
0,0 → 1,287
<?php
 
/**
* Classe Informations.php interroge la table Index
* et redirige vers une autre classe si besoin
* d'interroger une autre table (comme baseflor ou baseflor_rang_sup)
* elle traite également le retour du web service : /informations
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package eflore-projets
* @author Mathilde SALTHUN-LASSALLE <mathilde@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-2012 Tela Botanica (accueil@tela-botanica.org)
*
*
*/
 
class Informations extends Commun {
protected $limite_requete = array( 'depart' => 0, 'limite' => 10);
private $tables;
private $champs_recherches = '*';
private $requete_jointure = array();
private $requete_condition = array();
private $total_resultat;
protected $serviceNom = 'informations';
private $masque;
public function consulter($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
$versionResultat = null;
if (empty($this->ressources)){
$this->traiterParametres();
}
$this->definirTables(array ('index' => config::get('bdd_table_index'),
'baseflor' => config::get('bdd_table'),
'rangSup' => config::get('bdd_table_rang_sup')
)
);
$this->traiterRessources();
$requete = $this->assemblerLaRequete();
// exemple:
// SELECT * FROM baseflor_index_v2012_12_31 WHERE `bdnt.nn` = 'bdtfx.nn:XXXXX';
$resultat = $this->Bdd->recupererTous($requete . ' -- ' . __FILE__ . ':' .__LINE__);
$versionResultat = $this->renvoyerResultat($resultat);
if ($versionResultat === null) {
throw new Exception('Les données recherchées sont introuvables.', RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE);
}
return $versionResultat;
}
 
public function __construct() {
$Conteneur = new Conteneur();
$this->Bdd = $Conteneur ->getBdd();
}
public function renvoyerResultat($resultat) {
if (empty($this->ressources)) return $this->retournerResultatFormate($resultat);
if(empty($resultat[0]['baseflor'])) {
if(@$this->parametres['categorie'] == 'description') {
// non-supporté par InformationsTaxonsSup.php...
return array();
}
$info = new InformationsTaxonsSup(new Conteneur());
return $info->consulter($this->ressources, $this->parametres);
}
 
$info = new InformationsBaseflor(new Conteneur());
return $info->consulter($this->ressources, $this->parametres);
}
//+--------------------------traitement ressources ou paramètres -------------------------------------+
 
public function traiterRessources() {
if (empty($this->ressources)) {
$this->requete_jointure = array(
'LEFT JOIN '. $this->tables['baseflor'].' ON '
.$this->tables['baseflor'].".cle =".$this->tables['index'].".baseflor",
'LEFT JOIN '. $this->tables['rangSup'].' ON '
.$this->tables['rangSup'].".cle = ".$this->tables['index'].".RangSup");
$this->champs_recherches = " {$this->tables['baseflor']}.num_nomen as 'baseflor.nn',
{$this->tables['baseflor']}.BDNT as 'baseflor.bdnt',
{$this->tables['baseflor']}.catminat_code,
{$this->tables['baseflor']}.num_taxon ,
{$this->tables['baseflor']}.nom_sci ,
{$this->tables['rangSup']}.num_nomen as 'rangSup.nn',
{$this->tables['rangSup']}.bdnt as 'rangSup.bdnt',
{$this->tables['index']}.cle as 'index.cle' ";
} else {
if(preg_match('/^(.+)\.nn:([0-9]+)$/', $this->ressources[0], $retour)){
$this->champs_recherches = " baseflor, rangSup ";
$this->requete_condition[] = " `bdnt.nn` = '{$retour[0]}' ";
} else {
$e = 'Erreur dans l\'url de votre requête : </br> La ressource demandée n\'existe pas.';
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
break;
}
}
}
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres) ) {
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'navigation.depart' :
if(!isset($this->parametres['navigation.limite']))
throw new Exception("indiquez également la valeur pour le paramètre navigation.limite.",
RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
$this->definirNavigationDepart($valeur);
break;
case 'navigation.limite' :
if(!isset($this->parametres['navigation.depart']))
throw new Exception("indiquez également la valeur pour le paramètre navigation.depart.",
RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
$this->definirNavigationLimite($valeur);
break;
case 'version.projet' :
$this->traiterVersion($valeur);
break;
case 'masque.cat' :
$this->masque = 'catminat='.str_replace('-','/',$valeur);
$this->requete_condition[] = " catminat_code = '".str_replace('-','/',$valeur)."' ";
break;
default :
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " '
.$param.' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break;
}
}
}
}
//+++------------------------------traitement des versions----------------------------------------++
public function traiterVersion($valeur) {
if (preg_match('/^[0-9]+(?:[._][0-9]+)*$/', $valeur) || $valeur == '*' || $valeur == '+') {
$this->version_projet = $valeur;
} else {
$e = "Erreur : La version est inconnue.";
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
if ($this->version_projet == '*' && empty($this->ressources)) {
$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);
}
}
public function definirTables($prefixe_table) {
$table_num_version = $this->recupererVersionDisponible();
foreach ($prefixe_table as $nom => $prefixe ) {
if ( in_array($this->version_projet,$table_num_version) ) {
$tables[$nom] = $prefixe.'_v'.$this->version_projet;
} elseif ($this->version_projet == '+') {
$derniere_version = $table_num_version[count($table_num_version) - 1];
$tables[$nom] = $prefixe.'_v'.str_replace('.', '_', $derniere_version);
} else {
$e = "Erreur : La version est inconnue.";
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
}
$this->tables = $tables;
}
 
//+--------------------------formatages de resultats -------------------------------------------+
 
public function retournerResultatFormate($resultat) {
$resultat_json = array();
$resultat_json['entete'] = $this->ajouterEnteteResultat();
$resultat_json['resultats'] = array();
foreach ($resultat as $ligne => $tab) {
$num = $tab['index.cle'];
$resultat_json['resultats'][$num]['num_nomen'] =
(empty ($tab['baseflor.nn'])) ? $tab['rangSup.nn'] : $tab['baseflor.nn'];
$resultat_json['resultats'][$num]['bdnt'] =
(empty ($tab['baseflor.bdnt'])) ? $tab['rangSup.bdnt'] : $tab['baseflor.bdnt'];
$resultat_json['resultats'][$num]['catminat_code'] =
(empty ($tab['catminat_code'])) ? '' : $tab['catminat_code'];
$resultat_json['resultats'][$num]['nom_sci'] =
(empty ($tab['nom_sci'])) ? '' : $tab['nom_sci'];
$resultat_json['resultats'][$num]['num_taxon'] =
(empty ($tab['num_taxon'])) ? '' : $tab['num_taxon'];
if ($resultat_json['resultats'][$num]['num_nomen'] != 0) {
$bdnt = strtolower($resultat_json['resultats'][$num]['bdnt']);
$nn = $resultat_json['resultats'][$num]['num_nomen'];
$resultat_json['resultats'][$num]['href'] =
$this->ajouterHref('informations',$bdnt.".nn:".$nn);
}
}
return $resultat_json;
}
public function ajouterEnteteResultat() {
$entete['depart'] = $this->limite_requete['depart'];
$entete['limite'] = $this->limite_requete['limite'];
$entete['total'] = $this->total_resultat;
if ($this->masque) {
$entete['masque'] = $this->masque;
}
$entete['version'] = $this->version_projet;
$url = $this->formulerUrl($this->total_resultat, '/informations');
if (isset($url['precedent']) && $url['precedent'] != '') {
$entete['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$entete['href.suivant'] = $url['suivant'];
}
return $entete;
}
//+-------------------------------------assemblage de requête------------------------------------//
public function assemblerLaRequete() {
$requete = ' SELECT '.$this->champs_recherches.
' FROM '.$this->tables['index'].' '
.self::retournerRequeteJointure($this->requete_jointure).' '
.self::retournerRequeteCondition($this->requete_condition).' '
.$this->delimiterResultatsRequete();
return $requete;
}
 
static function retournerRequeteCondition($cond) {
return $cond ? (' WHERE '.implode(' AND ', $cond)) : '';
}
static function calculerTotalResultat($db, $table, Array $join, Array $cond) {
$requete = sprintf(
'SELECT count(*) as nombre FROM %s %s %s -- %s:%d',
$table,
$join ? implode(' ', $join) : '',
$cond ? (' WHERE '.implode(' AND ', $cond)) : '',
__FILE__,
__LINE__);
$res = $db->recuperer($requete);
if ($res && $res['nombre']) return $res['nombre'];
throw new Exception('Données introuvables dans la base', RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE);
}
public function delimiterResultatsRequete() {
$this->total_resultat = self::calculerTotalResultat(
$this->getBdd(),
$this->tables['index'],
$this->requete_jointure,
$this->requete_condition);
$requete_limite = '';
if (($this->limite_requete['depart'] <= $this->total_resultat) ){
if ( $this->limite_requete['depart'] < $this->total_resultat ){
$requete_limite = 'LIMIT '.$this->limite_requete['depart'].', '
.$this->limite_requete['limite'];
}
} else {
$e = "Erreur : la valeur pour le paramètre navigation.départ est supérieure".
" au nombre total de résultats.";
throw new Exception($e, RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE);
}
return $requete_limite;
}
static function retournerRequeteJointure($join) {
return $join ? implode(' ', $join) : '';
}
}
/tags/v5.3-amandaie/services/modules/0.1/baseflor/GraphiquesTaxonsSup.php
New file
0,0 → 1,146
<?php
/**
* Classe GraphiquesTaxonsSup.php transforme les données écologiques de la table baseflor_rang_sup_ecologie
* en graphique svg
* graphiques/#typegraphique/#bdnt.nn:#num_nomen --> renvoie un graphique avec les données connues
*
*
* @package eflore-projets
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @author Mathilde SALTHUN-LASSALLE <mathilde@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)
*/
 
class GraphiquesTaxonsSup extends CommunGraphiques{
 
 
public function definirTable($version){
$this->table = Config::get('bdd_table_rang_sup')."_v".$version;
}
//+---- ressources ----+
public function traiterReferentieletNum(){
if (!empty($this->ressources[1])) {
if(preg_match('/^(.+)\.nn:([0-9]+)$/', $this->ressources[1], $retour) == 1){
switch ($retour[1]) {
case 'bdtfx' : // pour le moment un seul referentiel disponible
$this->requete_condition[]= "num_nomen = ".$retour[2]." AND bdnt = 'bdtfx' ";
break;
default :
$e = "Le référentiel {$retour[1]} n'existe pas.";
throw new Exception( $e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
break;
}
}else {
$e = "Erreur dans l'url de votre requête :".
" précisez le référentiel et le numéro nomenclatural sous la forme {bdnt}.nn:{nn}.";
throw new Exception( $e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
} else {
throw new Exception( "Erreur dans l'url de votre requête :".
" précisez le référentiel et le numéro nomenclatural sous la forme {bdnt}.nn:{nn}.",
RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
}
public function traiterTypeGraphique(){
if (!empty($this->ressources[0])) {
switch ($this->ressources[0]) {
case 'climat' :
$this->requete_champs = ' ve_lumiere_min, ve_lumiere_max, ve_temperature_min,'.
' ve_temperature_max, ve_continentalite_min,'.
' ve_continentalite_max, ve_humidite_atmos_min,'.
' ve_humidite_atmos_max' ;
$this->nomGraphique= 'climat_min_max';
break;
case 'sol' :
$this->requete_champs = ' ve_humidite_edaph_min , ve_humidite_edaph_max,'.
' ve_reaction_sol_min, ve_reaction_sol_max, '.
' ve_nutriments_sol_min, ve_nutriments_sol_max,'.
' ve_salinite_min, ve_salinite_max,'.
' ve_texture_sol_min, ve_texture_sol_max,'.
've_mat_org_sol_min,ve_mat_org_sol_max ' ;
$this->nomGraphique = 'sol_min_max';
break;
default :
$e = "Erreur dans l'url de votre requête :".
"</br> précisez le graphique -> \"sol\" ou \"climat\".";
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
break;
}
}else {
throw new Exception("Erreur dans l'url de votre requête :".
"</br> precisez le graphique -> \"sol\" ou \"climat\".", RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
}
//+-------------------------- formatage du résultat -------------------------------------------+
public function changerValeursSVG(){
$this->ajouterValeursIntermediaires();
$Dompath = new DOMXPath($this->dom);
foreach ($this->valeurs_en_pourcentage as $cle => $val){
$val = preg_replace('/,/','.', $val);
$grad_id = array_search($val,$this->graduations_id);
$champs = preg_replace('/_min|_max|_[0-9]/','', $cle);
// dans le cas de mauvaises données, pour ne pas que tout le graphique
$case = $Dompath->query("//*[@id='".$grad_id."_".$champs."']")->item(0);
if($case != null) {
$case->setAttribute('fill','#EA6624');
$case->setAttribute('stroke','#EA6624');
$this->ajouterInfoAuSurvol($champs,$case);
}
$changement = true;
}
$this->ajusterFormatSVG();
}
public function ajouterValeursIntermediaires(){
$champs_ecolo = array_keys($this->champs_ontologiques);
foreach ($champs_ecolo as $chps ){
$min = !empty($this->valeurs_en_pourcentage[$chps.'_min']) ? $this->valeurs_en_pourcentage[$chps.'_min'] : -1;
$max = !empty($this->valeurs_en_pourcentage[$chps.'_max']) ? $this->valeurs_en_pourcentage[$chps.'_max'] : -1;
if ($min < ($max-0.1) ){
$i = $min + 0.1;
$num = 1;
for ($i ; $i < $max; $i += 0.1) {
$this->valeurs_en_pourcentage[$chps.'_'.$num] = $i;
$num++;
}
}
}
}
public function ajouterInfoAuSurvol($champs, $case){
$min = $this->valeurs_champs[$champs."_min"];
$max = $this->valeurs_champs[$champs."_max"];
if ($min != $max){
$valeurMin = $this->recupererOntologies($min, $champs );
$valeurMax = $this->recupererOntologies($max, $champs );
$valeurMin = $this->traiterIntermediaires($valeurMin->nom, $champs, $champs.'_min');
$valeurMax = $this->traiterIntermediaires($valeurMax->nom, $champs, $champs.'_max');
$case->setAttribute('title',"de $min: $valeurMin à $max: $valeurMax " );
} else {
$valeurMin = $this->recupererOntologies($min, $champs );
$valeurMin = $this->traiterIntermediaires($valeurMin->nom, $champs, $champs.'_min');
$case->setAttribute('title',"$min: $valeurMin" );
}
}
}
?>
/tags/v5.3-amandaie/services/modules/0.1/baseflor/InformationsTaxonsSup.php
New file
0,0 → 1,274
<?php
 
/**
* Classe InformationsTaxonsSup.php permet de faire des requetes pour les rangs superieurs de baseflor
* du référentiel BDTFX et avec un numéro nomenclatural ( différent de 0 ).
* fin d'url possibles :
*
* /informations/#bdnt.nn:#num_nomen?champs=ecologie --> retourne champs ecologiques pour un BDNT et un num_nomen
*
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package eflore-projets
* @author Mathilde SALTHUN-LASSALLE <mathilde@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)
*/
 
class InformationsTaxonsSup extends Commun{
protected $table = "";
private $champs_ontologiques = array();
private $format_reponse = 'informations';
protected $serviceNom = 'informations';
private $retour_format = 'max';
private $Bdd;
private $requete_condition = "";
private $champs_recherches = '*';
public function consulter($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
$this->traiterParametres();
$this->definirTables();
$this->traiterRessources();
$resultats = '';
foreach ($this->table_version as $version) {
$this->table = $version;
$requete = $this->assemblerLaRequete();
$resultat = $this->Bdd->recupererTous($requete);
$versionResultat = $this->analyserResultat($resultat);
if (count($this->table_version) > 1) {
$resultats[$version] = $versionResultat;
} else {
$resultats = $versionResultat;
}
}
return $resultats;
}
public function analyserResultat($resultat) {
$versionResultat = null;
if ($resultat == '') {
$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);
}
return $versionResultat;
}
public function __construct(Conteneur $Conteneur) {
$this->Bdd = $Conteneur->getBdd();
}
//+--------------------------traitement ressources ou paramètres -------------------------------------------+
public function traiterRessources() {
if(preg_match('/^(.+)\.nn:([0-9]+)$/', $this->ressources[0], $retour)==1){
switch ($retour[1]) {
case 'bdtfx' :
$this->requete_condition[] = "num_nomen = ".$retour[2]." AND bdnt = 'bdtfx' ";
break;
default :
$e = 'Erreur dans l\'url de votre requête : </br> Le référentiel " '
.$retour[1].' " n\'existe pas.';
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
break;
}
}
}
//+---- paramètres ----+
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres) ) {
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'categorie' :
if ($valeur == "ecologie"){
$this->champs_recherches = ' num_nomen, bdnt, ve_lumiere_min , ve_lumiere_max,'
.' ve_temperature_min, ve_temperature_max, ve_continentalite_min,'
.' ve_continentalite_max, ve_humidite_atmos_min, ve_humidite_atmos_max,'
.' ve_humidite_edaph_min, ve_humidite_edaph_max, ve_reaction_sol_min,'
.' ve_reaction_sol_max, ve_nutriments_sol_min, ve_nutriments_sol_max,'
.' ve_salinite_min, ve_salinite_max, ve_texture_sol_min,ve_texture_sol_max,'
.' ve_mat_org_sol_min, ve_mat_org_sol_max ';
} else {
$e = "Valeur de paramètre inconnue pour 'categorie'. Ce paramètre n'est pas autorisé pour informations/#id";
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
break;
case 'retour.format' :
if ($valeur == 'min' || $valeur == 'max') {
$this->retour_format = $valeur;
break;
} else {
$e = "Valeur de paramètre inconnue pour 'retour.format'. Ce paramètre n'est pas autorisé pour informations/#id";
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
case 'navigation.depart' :
$this->definirNavigationDepart($valeur);
break;
case 'navigation.limite' :
$this->definirNavigationLimite($valeur);
break;
case 'version.projet' :
$this->traiterVersion($valeur);
break;
default :
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " '
.$param.' " n\'existe pas.';
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); break;
}
}
}
}
 
//+++------------------------------traitement des versions----------------------------------------++
public function traiterVersion($valeur) {
if (preg_match('/^[0-9]+(?:[._][0-9]+)*$/', $valeur) || $valeur == '*' || $valeur == '+') {
$this->version_projet = $valeur;
} else {
$e = "Erreur : La version est inconnue.";
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
if ($this->version_projet == '*' && $this->ressources == array()) {
$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);
}
}
 
public function definirTables() {
$table_num_version = $this->recupererVersionDisponible();
$prefixe_table = config::get('bdd_table_rang_sup');
if ( in_array($this->version_projet,$table_num_version) ) {
$this->table_version[] = $prefixe_table.'_v'.$this->version_projet;
} elseif ($this->version_projet == '+') {
$derniere_version = $table_num_version[count($table_num_version) - 1];
$this->table_version[] = $prefixe_table.'_v'.str_replace('.', '_', $derniere_version);
} elseif ($this->version_projet == '*') {
foreach ($table_num_version as $num_version) {
$this->table_version[] = $prefixe_table.'_v'.str_replace('.', '_', $num_version);
}
} else {
$e = "Erreur : La version est inconnue.";
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
}
//+--------------------------formatages de resultats -------------------------------------------+
public function retournerResultatFormate($resultat) {
$this->resultat_json = $resultat[0];
if ($this->retour_format == 'max') {
$graphique_presence = $this->traiterEcologie() ;
if ($graphique_presence) {
$this->ajouterLiensGraphique($graphique_presence);
}
}
return $this->resultat_json ;
}
public function traiterEcologie() {
$donnees_presence = false;
$this->champs_ontologiques = Commun::s_recupererTableauConfig('Paramètres.champs_ontologiques');
foreach ($this->champs_ontologiques as $cle => $valeur){
/* Les deux tests commentés ci-dessous étaient présents dans eflore-test (uniquement) jusqu'à juin 2013.
La valeur 0 pose question.
cf baseflor_v2012_12_31
cf services/modules/0.1/baseflor/CommunGraphiques.php traiterValeursEcologiques() */
if ($this->resultat_json[$cle.'_min'] != "") { // && $this->resultat_json[$cle.'_min'] != 0) {
$donnees_presence[$this->getNomGraphique($valeur)] = true;
$tab_ontologie = $this->recupererOntologies($this->resultat_json[$cle.'_min'], $cle.'_min');
unset($this->resultat_json[$cle.'_min']);
}
if ($this->resultat_json[$cle.'_max'] != "") { // && $this->resultat_json[$cle.'_max'] != 0) {
$this->recupererOntologies($this->resultat_json[$cle.'_max'], $cle.'_max');
unset($this->resultat_json[$cle.'_max']);
}
}
return $donnees_presence;
}
//donne le nom du graphique correspondant à un champ écologique
public function getNomGraphique($code_ecolo) {
$graphique = null;
if (in_array($code_ecolo, explode(',',Config::get('Paramètres.climat')))) {
$graphique = 'climat';
} elseif (in_array($code_ecolo, explode(',', Config::get('Paramètres.sol')) )) {
$graphique = 'sol';
}
return $graphique;
}
public function ajouterLiensGraphique($graphique_presence) {
if ($graphique_presence['climat']) {
$this->resultat_json['graphique_climat']['libelle'] = 'climat';
$this->resultat_json['graphique_climat']['href'] = $this->ajouterHref('graphiques/climat',
strtolower($this->resultat_json['bdnt']).'.nn:'.$this->resultat_json['num_nomen']);
}
if ($graphique_presence['sol']) {
$this->resultat_json['graphique_sol']['libelle'] = 'sol';
$this->resultat_json['graphique_sol']['href'] = $this->ajouterHref('graphiques/sol',
strtolower($this->resultat_json['bdnt']).'.nn:'.$this->resultat_json['num_nomen']);
}
}
//+--------------------------traitement ontologies -------------------------------------------+
public function recupererOntologies($valeur, $champs){
$chps_sans = preg_replace("/_min|_max/", '', $champs);
$url = Config::get('url_service_base').Config::get('nom_projet').
'/ontologies/'.$this->champs_ontologiques[$chps_sans].':'.urlencode(urlencode($valeur));
try {
$val = $this->getBdd()->recuperer(sprintf(
"SELECT a.nom FROM baseflor_ontologies a LEFT JOIN baseflor_ontologies b ON a.id = b.id LEFT JOIN baseflor_ontologies c ON b.classe_id = c.id WHERE".
" b.code = BINARY '%s' AND c.code = BINARY '%s' LIMIT 0, 100",
$valeur,
$this->champs_ontologiques[$chps_sans]),
Bdd::MODE_OBJET);
$this->resultat_json[$champs.'.libelle'] = $val->nom;
$this->resultat_json[$champs.'.code'] = $valeur;
$this->resultat_json[$champs.'.href'] = $url;
} catch (Exception $e) {
$this->resultat_json[$champs.'.libelle'] = '';
$this->resultat_json[$champs.'.code'] = '';
$this->resultat_json[$champs.'.href'] = '';
}
}
//+--------------------------FONCTIONS D'ASSEMBLAGE DE LA REQUETE-------------------------------------------+
public function assemblerLaRequete() {
$requete = ' SELECT '.$this->champs_recherches.' FROM '.$this->table.' '
.$this->retournerRequeteCondition();
return $requete;
}
public function retournerRequeteCondition() {
$condition = '';
if (empty($this->requete_condition) == false) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
}
?>