Subversion Repositories eFlore/Projets.eflore-projets

Compare Revisions

No changes between revisions

Ignore whitespace Rev 1041 → Rev 1042

/tags/v5.6-arganeraie/services/modules/0.1/nasa-srtm/Altitude.php
New file
0,0 → 1,151
<?php
 
/**
* Classe unique du web service nasa-srtm qui détermine l'altitude d'un point à partir de ses coordonnees
* Les coordonnees sont definies dans des fichiers au format HGT dans un dossier specifique
* (dont le chemin est defini dans le fichier de configuration propre au web service).
* Les ressources utilisees sont les donnees issues du programme SRTM-3 de la NASA qui couvre
* l'ensemble terrestre du monde. La precision des points dont on renvoie l'altitude est de 90 metres.
* Chaque fichier couvre un secteur de 1 degre sur 1 degre et contient un tableau de 1201 lignes
* (axe des latitudes) sur 1201 colonnes (axe des longitudes) contenant l'altitude en metres
* correspondant a des point precis. L'ecart entre chaque entree des tableaux est constant, ce qui
* permet de calculer la latitude et la longitude de chaque point. L'altitude du point le plus proche
* de celui passe en parametres sera renvoyee au client.
*
* Parametres du web service :
* - latitude : latitude du point dont on recherche les coordonnees
* - longitude : longitude du point dont on recherche les coordonnees
*
* @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 Altitude {
private $parametres = array();
private $ressources = array();
private $coordonnees = null;
private $fichierSrtm = '';
const LONGUEUR_COTE = 1201;
const OFFSET = 2;
public function consulter($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
$retour = null;
try {
$this->traiterCoordonnees();
$this->rechercherFichierSrtm();
$this->recupererAltitude();
$retour = $this->coordonnees;
} catch (Exception $erreur) {
$retour = $erreur->getMessage();
}
return $retour;
}
private function traiterCoordonnees() {
if ($this->estParametreExistant('lat') && $this->estParametreExistant('lon')) {
$longitude = $this->parametres['lon'];
$latitude = $this->parametres['lat'];
if ($this->estUnFloat($longitude) && $this->estUnFloat($latitude)) {
$this->verifierValiditeCoordonnees($longitude, $latitude);
} else {
$message = "La valeur des coordonnées longitude ou latitude n'est pas correcte. ".
" Elle doit être pour les deux paramètres une valeur décimale.";
throw new Exception($message, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
} else {
$message = "Tous les paramètres passés dans l'URL ne correspondent pas à ceux attendus. ".
"Le web service nécessite de lui fournir une longitude et une latitude pour son bon fonctionnement.";
throw new Exception($message, RestServeur::HTTP_CODE_CONTENU_REQUIS);
}
}
private function estParametreExistant($nomParametre) {
return in_array($nomParametre, array_keys($this->parametres));
}
private function estUnFloat($variable) {
return (preg_match("/^(-)?\d+(\.\d+)?$/", $variable) == 1);
}
private function verifierValiditeCoordonnees($longitude, $latitude) {
$longitude = floatval($longitude);
$latitude = floatval($latitude);
$longitudeMax = Config::get("limite_longitude");
$latitudeMax = Config::get("limite_latitude");
if (abs($longitude) > $longitudeMax || abs($latitude) > $latitudeMax) {
$message = "Les coordonnées passées en paramètres désignent un point qui se trouve ".
"en dehors des limites du monde. Elles doivent être comprises entre -{$longitudeMax} ".
"et $longitudeMax sur l'axe des longitudes, et entre -{$latitudeMax} et {$latitudeMax} ".
"sur l'axe des latitudes.";
throw new Exception($message, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
} else {
$this->coordonnees = new StdClass();
$this->coordonnees->longitude = $longitude;
$this->coordonnees->latitude = $latitude;
}
}
private function rechercherFichierSrtm() {
$nomFichierSrtm = $this->construireNomFichierSrtm();
if (!file_exists($nomFichierSrtm)) {
$message = "Erreur interne : certaines ressources demandées n'ont pas pu être trouvées sur le serveur.";
throw new Exception($message, restServeur::HTTP_CODE_ERREUR);
} else {
$this->fichierSrtm = $nomFichierSrtm;
}
}
private function construireNomFichierSrtm() {
$latitudeEntier = abs(floor($this->coordonnees->latitude));
if ($latitudeEntier < 10) {
$latitudeEntier = "0".$latitudeEntier;
}
$suffixeLatitude = $this->coordonnees->latitude < 0 ? "S" : "N";
$longitudeEntier = abs(floor($this->coordonnees->longitude));
if ($longitudeEntier < 10) {
$longitudeEntier = "00".$longitudeEntier;
} elseif ($longitudeEntier < 100) {
$longitudeEntier = "0".$longitudeEntier;
}
$suffixeLongitude = $this->coordonnees->longitude < 0 ? "W" : "E";
$dossierSrtm = Config::get('dossier_srtm').DS;
$nomFichierSrtm = $dossierSrtm.$suffixeLatitude.$latitudeEntier.$suffixeLongitude.$longitudeEntier.".hgt.zip";
return $nomFichierSrtm;
}
private function recupererAltitude() {
$zip = zip_open($this->fichierSrtm);
$fichier = zip_read($zip);
$donnees = zip_entry_read($fichier, zip_entry_filesize($fichier));
zip_close($zip);
$xDepart = floor($this->coordonnees->longitude);
$yDepart = floor($this->coordonnees->latitude);
$longitude = $this->coordonnees->longitude;
$latitude = $this->coordonnees->latitude;
$positionX = (self::LONGUEUR_COTE-1) * ($longitude - $xDepart);
$positionY = (self::LONGUEUR_COTE-1) * (1 - $latitude + $yDepart);
$positionX = ($positionX + 0.5 > ceil($positionX)) ? ceil($positionX) : floor($positionX);
$positionY = ($positionY + 0.5 > ceil($positionY)) ? ceil($positionY) : floor($positionY);
$binaire = substr($donnees, ($positionY * self::LONGUEUR_COTE + $positionX) * self::OFFSET, self::OFFSET);
$this->coordonnees->altitude = current(unpack("n*", $binaire));
if (!$this->coordonnees->altitude) {
$this->coordonnees->altitude = 0;
}
}
}
 
?>
/tags/v5.6-arganeraie/services/modules/0.1/bibliobota/Publications.php
New file
0,0 → 1,330
<?php
// declare(encoding='UTF-8');
/**
* Classe implémentant l'API d'eFlore Publications pour le projet Biblio bota.
*
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Publications
*
* @package eFlore/services
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @author Aurélien PERONNET <aurelien@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)
*/
// TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests...
class Publications extends Commun{
 
protected $parametres;
protected $ressources;
private $Bdd;
private $config;
private $nbrePublications;
private $masque_taxon;
protected $service = 'publications';
public function __construct(Bdd $bdd = null, Array $config = null, Utilisateurs $utilisateurs = null, Url $url = null) {
$this->Bdd = is_null($bdd) ? new Bdd() : $bdd;
$this->UrlNavigation = is_null($url) ? new Url($this->config['url_service']) : $url;
}
 
public function consulter($ressources, $parametres) {
$resultat = new ResultatService();
$this->parametres = $parametres;
$this->ressources = $ressources;
 
$this->definirValeurParDefautDesParametres();
$this->verifierParametres();
$this->recupererParametresMasque();
$this->chargerNbrePublicationsTotal();
$publications = $this->getPublications($this->masque_taxon);
$resultat->corps = $this->formaterPublications($publications);
 
return $resultat;
}
 
public function getPublications($cherche) {
$depart = $this->parametres['navigation.depart'];
$limite = $this->parametres['navigation.limite'];
$tab_mots = preg_split('~ ~', $cherche, -1, PREG_SPLIT_NO_EMPTY);
$sql = 'SELECT DISTINCT B_C_CRAI, B_C_NOMCOMPLET, B_C_ABREGE, ' .
' B_F_NUMERO, B_F_TITRE, B_F_DATE, B_F_CRAICOLL, '.
' B_SER_SOUSTITRE, '.
' B_A_PAGEDEBUT, B_A_PAGEFIN, B_A_CRAIFASC, B_A_CRAISERIE, ' .
' B_D_ID, B_D_LABEL, ' .
' B_S_IDSTR, B_S_NOM, ' .
' B_AS_LIBELLE, '.
' biblio_serie.*, biblio_item.*, biblio_item_typlog.*, biblio_item_typphy.* '.
'FROM biblio_item '.
' LEFT JOIN biblio_aut_saisie ON (b_i_auteursaisie = b_as_id) '.
' LEFT JOIN biblio_article ON (b_i_iditem = b_a_idart) '.
' LEFT JOIN biblio_fasc ON '.
' (B_F_CRAICOLL = B_A_CRAICOLL '.
' AND B_F_CRAISERIE = B_A_CRAISERIE '.
' AND B_F_NUMERO = B_A_CRAIFASC)' .
' LEFT JOIN biblio_serie ON ' .
' (b_f_craicoll = b_ser_craicoll ' .
' AND b_f_craiserie = b_ser_idserie) '.
' LEFT JOIN biblio_collection ON (b_ser_craicoll = b_c_crai) '.
' LEFT JOIN biblio_str ON (B_C_LKSTR = B_S_IDSTR) '.
' LEFT JOIN biblio_domaine_lier ON (b_i_iditem = b_dl_iditem) ' .
' LEFT JOIN biblio_domaine ON (b_dl_iddom = b_d_id) ' .
' LEFT JOIN biblio_item_typphy ON (b_i_typphy = b_ip_id) ' .
' LEFT JOIN biblio_item_typlog ON (b_i_typlog = b_il_id) ' .
' WHERE B_I_TYPLOG = 1 AND B_I_TYPPHY = 2 AND B_I_CACHER = 0 '.
' AND B_D_ID = 1 ';
foreach ($tab_mots as $mot) {
$sql .= " AND (B_I_TITRE LIKE '%$mot%' ".
" OR B_I_RESUMCLE LIKE '%$mot%' ".
" OR B_I_COMMENT LIKE '%$mot%') ";
}
$sql .= 'ORDER BY B_I_AUTEURS LIMIT '.$depart.', '.$limite;
 
$publications = $this->Bdd->recupererTous($sql);
return $publications;
}
function formaterPublications($publications) {
$resultats = array();
foreach($publications as $publication) {
$id_a = $publication['B_I_IDITEM'];
$titre = $publication['B_I_TITRE'];
$auteurs = $publication['B_I_AUTEURS'];
$geo = $publication['B_I_GEO'];
$langue = $publication['B_I_LANGUE'];
$resum = $publication['B_I_RESUMCLE'];
$image = $publication['B_I_IMAGE'];
$comment = $publication['B_I_COMMENT'];
// Table Auteur Saisie
$saisie = $publication['B_AS_LIBELLE'];
// Table Domaine
$domaine_id = $publication['B_D_ID'];
$domaine_nom = $publication['B_D_LABEL'];
// Table Collection
$coll_nom = $publication['B_C_NOMCOMPLET'];
$coll_abreviation = $publication['B_C_ABREGE'];
// Table S�rie
$serie_titre = $publication['B_SER_SOUSTITRE'];
// Table Fascicule
$craicoll = $publication['B_F_CRAICOLL'];
$date = $publication['B_F_DATE'];
$fascicule_titre = $publication['B_F_TITRE'];
// Table Article
$craifasc = $publication['B_A_CRAIFASC'];
$craiserie = $publication['B_A_CRAISERIE'];
$page_debut = $publication['B_A_PAGEDEBUT'];
$page_fin = $publication['B_A_PAGEFIN'];
// Table Structure
$nomstr = $publication['B_S_NOM'];
// Formatage de la chaine de publication
$chainePublication = "";
if (isset($domaine_nom)) {
$chainePublication .= '<span class="texte_inactif">['.$domaine_nom.']</span>';
}
if (isset($auteurs)) {
$chainePublication .= $auteurs;
}
if (isset($titre)) {
$chainePublication .= " - <strong>$titre</strong>";
}
if (isset($date)) {
$chainePublication .= " - $date";
}
 
if (isset($mots_cles)) {
$chainePublication .= " - <em>$mots_cles</em>";
}
if (isset($page_debut)) {
$chainePublication .= ", p. $page_debut";
if (isset($page_fin)) {
$chainePublication .= "- $page_fin";
}
}
if (isset($geo)) {
$chainePublication .= " - Départ./Région : <em>$geo</em>";
}
if (isset($structure)) {
$chainePublication .= " - $structure";
}
if (isset($coll_nom)) {
$chainePublication .= ", $coll_nom";
}
if (isset($craiserie)) {
$chainePublication .= ", $craiserie";
}
if (isset($lien)) {
$chainePublication .= ", <a class=\"lien_ext\" href=\"$lien_url\">$fascicule_titre</a>";
} else {
$chainePublication .= ", $fascicule_titre";
}
if (isset($saisie_auteur)) {
$chainePublication .= " - <span class=\"texte_inactif\">Saisie : $saisie_auteur - Art. n°$article_id</span>";
}
$resultats[$id_a]['reference_html'] = $chainePublication;
}
$retour = array('entete' => $this->construireEntete(), 'resultats' => $resultats);
return $retour;
}
private function definirValeurParDefautDesParametres() {
if (isset($this->parametres['navigation.depart']) == false) {
$this->parametres['navigation.depart'] = 0;
}
if (isset($this->parametres['navigation.limite']) == false) {
$this->parametres['navigation.limite'] = 10;
}
}
 
private function verifierParametres() {
$erreurs = array();
if ($this->verifierValeurParametreNavigationDepart() == false) {
$erreurs[] = "Le paramètre 'navigation.depart' doit possèder un valeur numérique.";
}
if ($this->verifierValeurParametreNavigationLimite() == false) {
$erreurs[] = "Le paramètre 'navigation.limite' doit possèder un valeur numérique supérieure à 0.";
}
 
if (count($erreurs) > 0) {
$message = implode('<br />', $erreurs);
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
 
private function verifierValeurParametreNavigationDepart() {
$depart = $this->parametres['navigation.depart'];
$ok = is_numeric($depart) ? true : false;
return $ok;
}
 
private function verifierValeurParametreNavigationLimite() {
$limite = $this->parametres['navigation.limite'];
$ok = (is_numeric($limite) && $limite != 0) ? true : false;
return $ok;
}
 
private function recupererParametresMasque() {
if (isset($this->parametres['masque.taxon'])) {
$this->masque_taxon = $this->parametres['masque.taxon'];
} else {
$this->masque_taxon = "";
}
}
 
private function chargerNbrePublicationsTotal() {
$tab_mots = preg_split('~ ~', $this->masque_taxon, -1, PREG_SPLIT_NO_EMPTY);
$requete = 'SELECT COUNT(B_I_IDITEM) AS nbre '.
'FROM biblio_item '.
' LEFT JOIN biblio_aut_saisie ON (b_i_auteursaisie = b_as_id) '.
' LEFT JOIN biblio_article ON (b_i_iditem = b_a_idart) '.
' LEFT JOIN biblio_fasc ON '.
' (B_F_CRAICOLL = B_A_CRAICOLL '.
' AND B_F_CRAISERIE = B_A_CRAISERIE '.
' AND B_F_NUMERO = B_A_CRAIFASC)' .
' LEFT JOIN biblio_serie ON ' .
' (b_f_craicoll = b_ser_craicoll ' .
' AND b_f_craiserie = b_ser_idserie) '.
' LEFT JOIN biblio_collection ON (b_ser_craicoll = b_c_crai) '.
' LEFT JOIN biblio_str ON (B_C_LKSTR = B_S_IDSTR) '.
' LEFT JOIN biblio_domaine_lier ON (b_i_iditem = b_dl_iditem) ' .
' LEFT JOIN biblio_domaine ON (b_dl_iddom = b_d_id) ' .
' LEFT JOIN biblio_item_typphy ON (b_i_typphy = b_ip_id) ' .
' LEFT JOIN biblio_item_typlog ON (b_i_typlog = b_il_id) ' .
' WHERE B_I_TYPLOG = 1 AND B_I_TYPPHY = 2 AND B_I_CACHER = 0 '.
' AND B_D_ID = 1 ';
foreach ($tab_mots as $mot) {
$requete .= " AND (B_I_TITRE LIKE '%$mot%' ".
" OR B_I_RESUMCLE LIKE '%$mot%' ".
" OR B_I_COMMENT LIKE '%$mot%') ";
}
$resultats = $this->Bdd->recuperer($requete);
$this->nbrePublications = (int) $resultats['nbre'];
}
 
private function construireEntete() {
$entete = array('masque' => '', 'depart' => 0, 'limite' => 10, 'total' => 0);
 
$entete['masque'] = $this->recupererMasque();
$entete['depart'] = (int) $this->parametres['navigation.depart'];
$entete['limite'] = (int) $this->parametres['navigation.limite'];
$entete['total'] = $this->nbrePublications;
if ($hrefPrecedent = $this->recupererHrefPrecedent()) {
$entete['href.precedent'] = $hrefPrecedent;
}
if ($hrefSuivant = $this->recupererHrefSuivant()) {
$entete['href.suivant'] = $hrefSuivant;
}
return $entete;
}
 
private function recupererMasque() {
$masqueEntete = '';
if ($this->masque_taxon) {
$masqueEntete = "masque.taxon=$this->masque_taxon";
}
return $masqueEntete;
}
private function recupererHrefPrecedent() {
$departActuel = $this->parametres['navigation.depart'];
$limite = $this->parametres['navigation.limite'];
$departPrecedent = $departActuel - $limite;
$url = null;
if ($departPrecedent >= 0) {
$url = $this->obtenirUrlNavigation($departPrecedent, $limite, array('masque.taxon' => $this->masque_taxon));
}
return $url;
}
 
private function recupererHrefSuivant() {
$departActuel = $this->parametres['navigation.depart'];
$limite = $this->parametres['navigation.limite'];
$departSuivant = $departActuel + $limite;
$url = null;
if ($departSuivant < $this->nbrePublications) {
$url = $this->obtenirUrlNavigation($departSuivant, $limite, array('masque.taxon' => $this->masque_taxon));
}
return $url;
}
 
private function obtenirUrlNavigation($depart, $limite, $parametresAdditionnels) {
$parametres = array(
'navigation.depart' => $depart,
'navigation.limite' => $limite);
if ($parametresAdditionnels != null) {
$parametres = array_merge($parametres, $parametresAdditionnels);
}
$this->UrlNavigation->setRequete($parametres);
$url = $this->UrlNavigation->getURL();
return $url;
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/wikipedia/textes/PageTextes.php
New file
0,0 → 1,132
<?php
class PageTextes {
 
private $parametres = array();
private $ressources = array();
 
const MIME_JSON = 'application/json';
const PRESENCE_CHOROLOGIE = '1';
 
private $retourFormatsSupportes = array(self::MIME_JSON);
private $txtFormatsSupportes = array('txt', 'htm');
private $serviceUrl = null;
private $idPage = null;
private $wpBot = null;
private $infosPage = null;
 
public function __construct($ressources, $parametres, Conteneur $conteneur) {
$this->parametres = $parametres;
$this->ressources = $ressources;
 
$this->wpBot = $conteneur->getWikipediaBot();
$url = $conteneur->getParametre('url_service').DS.$this->ressources[0];
$this->serviceUrl = $conteneur->getUrl($url);
}
 
public function consulter() {
$this->idPage = $this->ressources[0];
 
$this->definirValeurParDefautDesParametres();
$this->verifierParametres();
 
$resultat = $this->obtenirResultat();
 
return $resultat;
}
 
private function definirValeurParDefautDesParametres() {
if (isset($this->parametres['retour']) == false) {
$this->parametres['retour'] = self::MIME_JSON;
}
if (isset($this->parametres['txt.format']) == false) {
$this->parametres['txt.format'] = 'txt';
}
}
 
private function verifierParametres() {
$erreurs = array();
 
if (isset($this->parametres['retour']) == false) {
$erreurs[] = "Le paramètre type de retour 'retour' est obligatoire.";
}
if ($this->verifierValeurParametreTxtFormat() == false) {
$erreurs[] = "Le format du texte '{$this->parametres['txt.format']}' n'est pas supporté.";
}
 
if (count($erreurs) > 0) {
$message = implode('<br />', $erreurs);
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
 
private function verifierValeurParametreRetour() {
return in_array($this->parametres['retour'], $this->retourFormatsSupportes);
}
 
private function verifierValeurParametreTxtFormat() {
return in_array($this->parametres['txt.format'], $this->txtFormatsSupportes);
}
 
private function obtenirResultat() {
$this->chargerPageWp();
 
$resultat = new ResultatService();
$resultat->corps = $this->infosPage;
$resultat->mime = $this->parametres['retour'];
 
return $resultat;
}
 
private function chargerPageWp() {
$options = array('langue' => 'fr');
$this->wpBot = new WikipediaBot($options);
$this->wpBot->chargerPage($this->idPage);
 
$this->infosPage['id'] = $this->idPage;
$this->infosPage['titre'] = $this->wpBot->getPageTitre();
$this->infosPage['texte'] = $this->getTxt();
 
$this->infosPage['mime'] = $this->getTypeMime();
$this->infosPage['href'] = $this->getHref();
}
 
private function getTxt() {
$txt = '';
if (isset($this->parametres['txt.section.position'])) {
$positionSection = $this->parametres['txt.section.position'];
$txt = $this->wpBot->getSectionParNumero($positionSection);
} else if (isset($this->parametres['txt.section.titre'])) {
$titreSection = $this->parametres['txt.section.titre'];
if ($titreSection == 'taxobox') {
$txt = $this->wpBot->extraireTaxobox();
} else {
$txt = $this->wpBot->getSectionParTitre($titreSection);
}
} else {
$txt = $this->wpBot->getPageTxt();
}
if ($this->parametres['txt.format'] == 'htm') {
$txt = $this->wpBot->rendre($txt);
}
return $txt;
}
 
private function getTypeMime() {
$mime = '';
if ($this->parametres['txt.format'] == 'htm') {
$mime = 'txt/html';
} else if ($this->parametres['txt.format'] == 'txt') {
$mime = 'text/plain';
}
return $mime;
}
 
private function getHref() {
$href = '';
$this->serviceUrl->setRequete($this->parametres);
$href = $this->serviceUrl->getUrl();
return $href;
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/wikipedia/Textes.php
New file
0,0 → 1,80
<?php
// declare(encoding='UTF-8');
/**
* Classe implémentant l'API d'eFlore Textes pour le projet WIKIPEDIA.
*
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Textes
*
* @package eFlore/services
* @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 Textes extends Commun{
 
protected $parametres = array();
protected $ressources = array();
protected $service = 'textes';
 
public function consulter($ressources, $parametres) {
$this->parametres = $parametres;
$this->ressources = $ressources;
 
$this->analyserRessources();
$resultat = $this->executerSousService();
 
return $resultat;
}
 
private function analyserRessources() {
$nbreRessources = count($this->ressources);
if ($nbreRessources == 0) {
$message = "A implémenter : listes des pages trouvées";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
} else if ($nbreRessources == 1) {
if ($this->etreRessourceIdentifiants(0)) {
$this->sousService = 'Page';
} else {
$message = "La ressource n°1 '{$this->ressources[0]} indiquée n'est pas valable.";
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
} else if ($nbreRessources > 1) {
$message = "Les ressources indiquées ne sont pas valables.";
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
 
private function etreRessourceIdentifiants($position) {
$ok = true;
if (isset($this->ressources[$position])) {
$ids = $this->ressources[$position];
$supraSpPattern = "[A-Z][a-z]+";
$spPattern = "{$supraSpPattern}_[a-z]+";
$pagePattern = "/^(?:$supraSpPattern|$spPattern)$/i";
$ok = preg_match($pagePattern, $ids) ? true : false;
}
return $ok;
}
 
private function executerSousService() {
if (isset($this->sousService)) {
$classe = $this->sousService.'Textes';
require_once dirname(__FILE__).DS.'textes'.DS.$classe.'.php';
$sousService = new $classe($this->ressources, $this->parametres, new Conteneur());
$resultat = $sousService->consulter();
} else {
$message = "L'analyse des ressources n'a pu aboutir à déterminer le sous service à exécuter.";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
return $resultat;
}
 
 
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/wikipedia/NomCommune.php
New file
0,0 → 1,127
<?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 des DROM-COM présentent
* sur Wikipedia FR à cette adrese : http://fr.wikipedia.org/
* Source des données : Wikipedia http://fr.wikipedia.org/
* Paramètres du service :
* - lat : latitude
* - lon : longitude
* Exemple :
* http://localhost/service:eflore:0.1/wikipedia/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 NBRE_COMMUNE_PAR_DEFAUT = 10;
const NBRE_COMMUNE_MAX = 100;
const MIME_JSON = 'application/json';
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 dont le séparateur décimal est un point. Ex. : 44 ou 43.03";
}
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";
}
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 à {self::NBRE_COMMUNE_MAX}. 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['code_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, ".
"code_insee, nom ".
'FROM wikipedia_communes_v2011 '.
'ORDER BY distance '.
"LIMIT {$this->parametres['nbre']} ";
$resultat = $this->bdd->recupererTous($requete);
return $resultat;
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/iso-639-1/Langues.php
New file
0,0 → 1,388
<?php
/**
* Description :
* Classe Langues.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 /langues 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 Langues extends Commun {
 
protected $service = 'langues';
 
/**
* Permet de stocker la requete formulée : /langues | /langues/#id | /langues/#id/champ | /langues/#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 = 'langues';
 
/** 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';
protected $retour_langue = 'fr';
/** 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($parametres['recherche']) && $parametres['recherche'] != '') {
$this->recherche = $parametres['recherche'];
}
 
foreach ($parametres as $param => $valeur) {
switch ($param) {
case 'masque' :
$this->ajouterLeFiltreMasque('masque', $valeur);
break;
case 'masque.code' :
$this->ajouterLeFiltreMasque('id', $valeur);
break;
case 'masque.nom' :
$this->ajouterLeFiltreMasque('nom', $valeur);
break;
case 'retour.langue' :
$this->retour_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 '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 == 'id') {
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if ($this->recherche == 'floue') {
if ($nom_champ == 'masque') {
$this->requete_condition[] = '( id = '.$this->getBdd()->proteger($valeur)
.' OR ( SOUNDEX(nom) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(nom)) = 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 = /langues/#id
$this->traiterRessourceId();
if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) {
//requete = /langues/#id/#champ ou /langues/#id/relations
$this->traiterRessourceChampOuRelations();
}
}
}
}
 
public function traiterRessourceId() {
//requete : /langues/#id (ex : /langues/7)
if (preg_match('/^[a-z]{2}$/', $this->table_ressources[0])) {
$this->requete_condition[] = ' id = '.$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 = /langues/#id/relations :
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);
//requete = /langues/#id/#champ :
} else {
$this->format_reponse .= '/champ';
}
}
 
// +-------------------------------------------------------------------------------------------------------------------+
public function assemblerLaRequete() {
$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 : /langues et /langues/#id/relations)
public function formerRequeteLimite() {
if (($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 recupererTotalResultat() {
//on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /langues)
$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é (/langues | /langues/#id | /langues/#id/champ |
// /langues/#id/relations) le format du tableau à retourner. Encode en json
public function retournerResultatFormate($resultat) {
$this->recupererTableConfig('correspondance_champs');
switch ($this->format_reponse) {
case 'langues' :
$reponse = $this->formaterLangues($resultat);
break;
case 'langues/id' :
$reponse = $this->formaterLanguesId($resultat[0]);
break;
case 'langues/id/champ' :
$reponse = $this->formaterLanguesIdChamp($resultat[0]);
break;
}
return $reponse;
}
 
public function formaterLangues($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;
//formuler les urls precedentes et suivantes affichées dans l'entete du resultat
$url = $this->formulerUrl($this->total_resultat, '/langues');
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;
$this->table_retour = array();
if ($this->retour_langue == 'fr') {$nom = 'nom'; } else {$nom = 'nom_'.$this->retour_langue;}
if (isset($this->table_param['masque_nom'])) $resultat = $this->trierRechercheFloue($this->table_param['masque_nom'], $resultat, $nom);
//on remplit la table $table_retour_json['resultat']
foreach ($resultat as $tab) {
foreach ($tab as $key => $valeur) {
if ($valeur != '') {
//TODO : vérifier d'où venez $id
if ($key == 'id') {// ATTENTION : au départ valait $id!
$num = $valeur;
$this->table_retour['code'] = $valeur;
break;
} elseif ($key == 'nom_'.$this->retour_langue || ($this->retour_langue == 'fr' && $key == 'nom')) {
$this->table_retour['nom'] = $valeur;
break;
} else {
switch ($key) {
case 'id' :
$num = $valeur; $this->table_retour['code'] = $valeur;
break;
case 'nom' :
$this->table_retour['nom'] = $valeur;
break;
}
}
}
}
if ($this->retour_format == 'max') {
$this->table_retour['href'] = $this->ajouterHref('langues', $num);
}
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array();
}
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
 
public function formaterLanguesId($resultat) {
foreach ($resultat as $key => $valeur) {
if ($valeur != '') {
$this->afficherDonnees($key, $valeur);
}
}
unset($this->table_retour['href']);
return $this->table_retour;
}
 
 
public function formaterLanguesIdChamp($resultat) {
//on recupère tous les resultats possibles
$reponse = $this->formaterLanguesId($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';
$champs_possibles[] = 'iso-639-2';
$champs_possibles[] = 'iso-639-3';
 
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 (strpos($champ, 'iso_639_') !== false) {
$projet = substr(str_replace('_', '-', $champ),5);
$this->table_retour[$projet.'.code'] = $valeur;
$this->table_retour[$projet.'.href'] = $this->ajouterHrefAutreProjet('langues', '', $valeur, $projet);
} else {
$this->table_retour[$this->correspondance_champs[$champ]] = $valeur;
}
} else {
$this->table_retour[$this->correspondance_champs[$champ]] = $valeur;
}
}
 
}
 
?>
/tags/v5.6-arganeraie/services/modules/0.1/bdtfx/CommunNomsTaxons.php
New file
0,0 → 1,948
<?php
// declare(encoding='UTF-8');
/**
* Description :
* Classe CommunNomsTaxons.php
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 1.0
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org)
*/
 
 
abstract class CommunNomsTaxons extends Commun {
 
/** Tableau de correspondance entre les noms des champs et les codes de l'ontologie.*/
private $relationsChampsCodesOntologie = null;
protected $table_retour; //Permet de stocker le tableau de résultat (non encodé en json)
protected $resultat_req; // Permet de stocker le résultat de la requete principale.
protected $compo_nom = null; //Stocke sous forme de tableau les composant du nom à ajouter au nom scientifique
protected $table;// Nom de la table dans laquelle on récupèrera les données dans les requetes SQL
protected $total_resultat = null;
/** Stocke le service appelé correspondant. Est utilisé principalement lors de l'affichage du href d'un synonyme
(ex id=12, basionyme num 25 est un synonyme) dans le service taxon */
protected $service_href = null;
protected $erreursParametres = null;
protected $sans_nom_sci = array('gen','sp','ssp','fam','au_ss','bib_ss');
private $bib_traitees = array();
private $ontologie = array();
 
//+------------------------------- PARAMÈTRES ---------------------------------------------------------------+
 
public function traiterParametres() {
$this->definirParametresParDefaut();
$this->verifierParametres();
 
if (isset($this->parametres) && count($this->parametres) > 0) {
foreach ($this->parametres as $param => $val) {
switch ($param) {
case 'ns.structure' :
$this->remplirTableCompositionNom($val);
if (in_array($val,$this->sans_nom_sci)){
$this->requete_champ = implode(', ',$this->compo_nom);
}else {
$this->requete_champ .= ' ,'.implode(', ',$this->compo_nom);
}
break;
case 'navigation.depart' :
$this->limite_requete['depart'] = $val;
break;
case 'navigation.limite' :
$this->limite_requete['limite'] = $val;
break;
}
}
$this->traiterParametresSpecifiques();
}
}
 
protected function definirParametresParDefaut() {
if (empty($this->parametres['recherche'])) {
$this->parametres['recherche'] = 'stricte';
}
if (empty($this->parametres['ns.format'])) {
$this->parametres['ns.format'] = 'txt';
}
if (empty($this->parametres['retour.format'])) {
$this->parametres['retour.format'] = 'max';
}
if (empty($this->parametres['ns.structure']) &&
$this->parametres['retour.format'] != 'oss') {
$this->parametres['ns.structure'] = 'au,an,bib';
}
}
 
 
public function verifierParametres() {
//$this->verifierParametresAPI();
 
$this->verifierParametre('recherche', 'stricte|floue|etendue|complete');
$this->verifierParametre('ns.format', 'htm|txt');
$this->verifierParametre('retour.format', 'min|max|oss|perso');
$this->verifierParametreAvecValeurMultipe('ns.structure', 'an|au|bib|ad|gen|sp|ssp|fam|au_ss|bib_ss');
 
/*if (count($this->erreursParametres) > 0) {
$m = 'Erreur dans votre requête : '.implode('<br/>', $this->erreursParametres);
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $m);
}*/
}
 
public function verifierParametresAPI() {
$parametresApi = $this->recupererTableauConfig('parametresAPI');
while (!is_null($parametre = key($this->parametres))) {
if (!in_array($parametre, $parametresApi)) {
$this->erreursParametres[] = "Le paramètre '$parametre' n'est pas pris en compte par cette version de l'API.";
}
next($this->parametres);
}
}
 
public function verifierParametre($parametre, $valeursPermises) {
if (isset($this->parametres[$parametre]) && !empty($this->parametres[$parametre])) {
$valeur = $this->parametres[$parametre];
$this->verifierValeursPermises($parametre, $valeur, $valeursPermises);
}
}
 
public function verifierParametreAvecValeurMultipe($parametre, $valeursPermises) {
if (isset($this->parametres[$parametre]) && !empty($this->parametres[$parametre])) {
$valeursConcatenees = $this->parametres[$parametre];
$valeurs = explode(',', $valeursConcatenees);
foreach ($valeurs as $valeur) {
$this->verifierValeursPermises($parametre, $valeur, $valeursPermises);
}
}
}
 
private function verifierValeursPermises($parametre, $valeur, $valeursPermises) {
if (!in_array($valeur, explode('|', $valeursPermises))) {
$this->erreursParametres[] = "Le paramètre '$parametre' ne peut pas prendre la valeur '$valeur'. Valeurs permises : $valeursPermises";
}
}
 
public function traiterParametresCommuns() {
 
}
 
public function ajouterFiltreMasque($nom_champ, $valeur) {
$orig_val = $valeur;
$valeur = explode(',',$valeur);
$conditions = array();
if ($nom_champ == 'annee' || $nom_champ == 'rang') {
foreach ($valeur as $val) {
$conditions[] = "$nom_champ = ".$this->getBdd()->proteger($val);
}
} else {
if ($this->parametres['recherche'] == 'etendue') {
foreach ($valeur as $val) {
$val = $this->modifierValeur($val);
$conditions[] = "$nom_champ LIKE ".$this->getBdd()->proteger($val);
}
 
} elseif ($this->parametres['recherche'] == 'floue') {
foreach ($valeur as $val) {
$val = $this->getBdd()->proteger($val);
$conditions[] = "( SOUNDEX($nom_champ) = SOUNDEX($val))".
" OR ( SOUNDEX(REVERSE($nom_champ)) = SOUNDEX(REVERSE($val)))";
}
// utile pour la détermination à partir d'un nom retenu (concat(nom_sci,auteur)) lors
// d'un import depuis le CEL
} elseif ($this->parametres['recherche'] == 'concat' && $nom_champ == 'nom_sci') {
$conditions[] = "CONCAT(nom_sci, ' ', auteur) = " . $this->getBdd()->proteger($orig_val);
 
} else {
foreach ($valeur as $val) {
$conditions[] = "$nom_champ LIKE ".$this->getBdd()->proteger($val);
}
}
}
$this->requete_condition[]= '('.implode(' OR ', $conditions ).')';
$this->masque[$nom_champ] = $nom_champ.'='.implode(',',$valeur);
}
 
private function modifierValeur($valeur) {
$valeur = $this->remplacerCaractereHybrideEtChimere($valeur);
$valeur = $this->preparerChainePourRechercheEtendue($valeur);
return $valeur;
}
 
private function remplacerCaractereHybrideEtChimere($valeur) {
$caracteres = array('×', '%D7', '+', '%2B');
$remplacements = array('x ','x ', '+', '+');
$valeur = str_replace($caracteres, $remplacements, $valeur);
return $valeur;
}
 
private function preparerChainePourRechercheEtendue($valeur) {
$valeur = str_replace(' ', '% ', trim($valeur));
$valeur = $valeur.'%';
return $valeur;
}
 
//+-------------------------------Fonctions d'analyse des ressources-------------------------------------+
 
private function etreRessourceId() {
$ok = false;
if ($this->estUnIdentifiant() && count($this->ressources) == 1) {
$ok = true;
}
return $ok;
}
 
public function traiterRessources() {
if (isset($this->ressources) && count($this->ressources) > 0) {
if ($this->ressources[0] == 'relations') {
$this->traiterRessourceIdRelations();
} elseif ($this->estUnIdentifiant()) { //l'identifiant peut etre de type /#id ou /nt:#id
$this->traiterRessourcesIdentifiant(); // dans le service noms ou taxons
} elseif ($this->ressources[0] == 'stats') { //ressource = noms/stats
$this->traiterRessourcesStats();
} else {
$e = 'Erreur dans votre requete </br> Ressources disponibles : <br/>
<li> /'.$this->service.'/#id (id : L\'identifiant du nom rechercher)</li>
<li> /'.$this->service.'/nt:#id (id : Numero du taxon recherche)</li>
<li> /'.$this->service.'/stats </li>';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
}
 
public function traiterRessourcesStats() {
$this->format_reponse = $this->service.'/stats';
 
$e = "Erreur dans votre requête </br> Ressources disponibles : $this->service/stats/[annees|rangs|initiales]";
if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
switch ($this->ressources[1]) {
case 'annees' :
$this->traiterRessourceStatsAnnees();
break;
case 'rangs' :
$this->traiterRessourceStatsRangs();
break;
case 'initiales' :
$this->traiterRessourceStatsInitiales();
break;
default :
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
break;
}
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
 
/** Vérifie si la première valeur de la table de ressource est un identifiant :
* un numerique ou un numéro taxonomique sous la forme nt:xx */
public function estUnIdentifiant() {
return (is_numeric($this->ressources[0]) || (strrpos($this->ressources[0],'nt:') !== false
&& is_numeric(str_replace('nt:','',$this->ressources[0]))));
}
 
//+------------------------------------------------------------------------------------------------------+
// Fonction d'analyse des parametres
 
/** Permet de remplir le tableau compo_nom. Il comprendra en fct du paramètre ns.structure les éléments à rajouter
* au nom_sci (annee, auteur, biblio ou addendum). */
public function remplirTableCompositionNom($valeur) {
$structure_nom = explode(',', $valeur);
 
foreach ($structure_nom as $structure) {
$structure = trim($structure);
$patterns = array('/^an$/', '/^au$/', '/^bib$/', '/^ad$/', '/^sp$/', '/^gen$/', '/^ssp$/','/^fam$/',
'/^au_ss$/','/^bib_ss$/');
$champs = array('annee', 'auteur', 'biblio_origine', 'nom_addendum', 'epithete_sp', 'genre',
'epithete_infra_sp','famille','auteur', 'biblio_origine');
 
// avec str_replace() 'sp' est inclu dans 'ssp', et la conversion pour 'ssp' est mauvaise
$this->compo_nom[$structure] = preg_replace($patterns, $champs, $structure);
}
}
 
public function mettreAuFormat() {
if ($this->parametres['ns.format'] == 'htm') {
if (strrpos($this->requete_champ, 'nom_sci_html as nom_sci') === false) {
$this->requete_champ = str_replace('nom_sci', 'nom_sci_html as nom_sci', $this->requete_champ);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
// Fonctions de formatage
 
/** Fonction permettant de creer la table dont le nom est passé en paramètre (champs_api, champs_bdtfx,
* correspondance_champs...). Les données de chaque table sont présentes dans le fichier de configuration config.ini
* @param String $table : Peut contenir plusieurs nom de table dont on souhaite récupérer les données : table,table,table. */
public function recupererTableSignification($table) {
$tables = explode(',', $table);
foreach ($tables as $tab) {
if ($tab == 'champs_comp') {
$champ_bdnff_api = array_keys($this->champs_api); //on recupère le nom des champ ds la bdd
$this->champs_comp = array_diff($this->champs_table, $champ_bdnff_api);
} elseif ($tab == 'champs_api') {
foreach ($this->correspondance_champs as $key => $val) {
preg_match('/(hybride[.]parent_0[12](?:[.]notes)?|nom_sci[.][^.]+|[^.]+)(?:[.](id|code))?/', $val, $match);
$val = $match[1];
$this->champs_api[$key] = $val;
}
} else {
$this->$tab = $this->recupererTableauConfig($tab);
}
}
}
 
public function formaterEnOss($resultat) {
$table_nom = array();
$oss = '';
foreach ($resultat as $tab) {
if (isset($tab['nom_sci']) ) {
if (!in_array($tab['nom_sci'], $table_nom)) {
$table_nom[] = $tab['nom_sci'];
$oss[] = $tab['nom_sci'].' '.$this->ajouterCompositionNom($tab);
}
}else {
$res = $this->ajouterCompositionNom($tab);
if($res) {
$oss[] = $res;
}
}
 
}
 
if (isset($this->masque)) $masque = implode('&', $this->masque);
else $masque = 'Pas de masque';
$table_retour_oss = array($masque, $oss);
return $table_retour_oss;
}
 
public function afficherEnteteResultat($url_service) {
$arr = array(
'depart' => $this->limite_requete['depart'],
'limite' => $this->limite_requete['limite'],
'total' => $this->total_resultat);
 
if (isset($this->masque))
$arr['masque'] = implode('&', $this->masque);
 
$url = $this->formulerUrl($this->total_resultat, $url_service);
if (isset($url['precedent']) && $url['precedent'] != '') {
$arr['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$arr['href.suivant'] = $url['suivant'];
}
return $arr;
}
 
public function afficherNomHrefRetenu($tab, $num) {
$this->resultat_req = $tab;
$this->afficherDonnees('num_nom', $num);
if ($this->parametres['retour.format'] == 'min') { // sinon est affiché ds afficherDonnees(num_nom, $val) ci-dessus
$this->table_retour['nom_sci'] = $tab['nom_sci'];
$this->table_retour['nom_sci_complet'] = $tab['nom_sci'].' '.$this->ajouterCompositionNom($tab);
}
if ($tab['num_nom_retenu'] != '') {
$retenu = ($tab['num_nom_retenu'] == $num) ? 'true' : 'false';
} else {
$retenu = 'absent';
}
$this->table_retour['retenu'] = $retenu;
// Pourquoi ce unset ? JPM - 28-03-2013
unset($this->table_retour['id']);
}
 
 
//+------------------------------------------------------------------------------------------------------+
// Fonction de formatage pour les services /#id/
 
public function formaterId($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$this->resultat_req = $resultat;
 
foreach ($resultat as $cle => $valeur) {
if ($valeur != '') {
$this->afficherDonnees($cle, $valeur);
}
}
if (isset($this->parametres['retour.champs']) && $this->format_reponse == 'noms/id') {
$retour = $this->table_retour;
$this->table_retour = array();
$champs = explode(',', $this->parametres['retour.champs']);
$this->ajouterChampsPersonnalises($champs, $retour);
}
unset($this->table_retour['href']);
return $this->table_retour;
}
 
public function formaterIdChamp($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$reponse_id = $this->formaterId($resultat);
$this->table_retour = array();
$champs = explode(' ', $this->ressources[1]);
$this->ajouterChampsPersonnalises($champs, $reponse_id);
return $this->table_retour;
}
 
protected function ajouterChampsPersonnalises($champs, $reponse_id) {
$champs_a_libeller = array('nom_retenu', 'rang', 'basionyme', 'hybride', 'hybride.parent_01',
'hybride.parent_02', 'presence', 'tax_sup', 'statut_origine', 'statut_culture', 'statut_introduction');
$champs_forces = array('rang'); // même s'ils sont dans "à libeller", on les prend quand même en brut, en plus
if (! is_null($champs) && is_array($champs) && count($champs) > 0) {
foreach ($champs as $champ) {
if ($this->verifierValiditeChamp($champ)) {
if (strrpos($champ, '.*') !== false) {
$this->afficherPointEtoile($champ, $reponse_id);
} elseif (in_array($champ, $champs_a_libeller)) {
$this->table_retour[$champ.'.libelle'] =
(isset($reponse_id[$champ.'.libelle'])) ? $reponse_id[$champ.'.libelle'] : null;
} else {
$champ = $this->trouverChampBddCorrespondant($champ);
$this->table_retour[$champ] = (isset($reponse_id[$champ])) ? $reponse_id[$champ] : null;
}
// champs bruts en plus, ajouté pour obtenir le rang, mais retourne rang.code avec du kk dedans :-/
if (in_array($champ, $champs_forces)) {
$champ = $this->trouverChampBddCorrespondant($champ);
$this->table_retour[$champ] = (isset($reponse_id[$champ])) ? $reponse_id[$champ] : null;
}
}
}
}
}
 
public function afficherPointEtoile($champ, $reponse) {
preg_match('/^([^.]+\.)\*$/', $champ, $match);
if ($match[1] == 'nom_sci') {
$this->afficherNomSciPointEpithete($this->resultat_req);
} else {
foreach ($reponse as $chp => $valeur) {
if (strrpos($chp, $match[1]) !== false) {
if ($valeur != '') {
$this->table_retour[$chp] = $valeur;
} else {
$this->table_retour[$chp] = null;
}
}
}
}
}
 
public function decomposerNomChamp($champ) {
$decomposition = false;
if (preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match)) {
$radical_champ = $match[1];
$suffixe = (isset($match[2])) ? $match[2] : "";
$decomposition = array($radical_champ, $suffixe);
}
return $decomposition;
}
 
public function verifierValiditeChamp($champ) {
$decomposition = $this->decomposerNomChamp($champ);
$validite_ressource = true;
if ($decomposition) {
list($radical, $suffixe) = $decomposition;
$champs_complementaire = array('nom_retenu_complet', 'basionyme_complet');
// on verifie si le nom du champ existe bien
if (!$this->estChampApi($radical) && !$this->estChampComplementaire($radical)) {
if (!in_array($radical, $champs_complementaire)) {
$validite_ressource = false;
$e = 'Le champ "'.$radical.'" n\'existe pas dans la base. <br/><br/>';
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
} elseif ($this->estUnPoint($champ)) {
$validite_ressource = $this->verifierValiditeSuffixe($suffixe, $radical);
}
}
return $validite_ressource;
}
 
public function estChampApi($radical_champ) {
$champ_api_ok = false;
if (in_array($radical_champ, $this->champs_api) || in_array($radical_champ, $this->correspondance_champs)) {
$champ_api_ok = true;
}
return $champ_api_ok;
}
 
public function estChampComplementaire($radical_champ) {
$champ_complementaire_ok = in_array($radical_champ, $this->champs_comp) ? true : false;
return $champ_complementaire_ok;
}
 
public function verifierValiditeSuffixe($suffixe, $radical_champ) {
$validite_ressource = true;
if ($this->correspondAUnId($radical_champ) || $radical_champ == 'id') {
$this->verificationSuffixesIdentifiant($suffixe, $radical_champ, $validite_ressource);
} elseif ($this->correspondAUnCode($radical_champ)) {
$this->verificationSuffixesCodes($suffixe, $radical_champ, $validite_ressource);
} elseif ($radical_champ == 'nom_sci') {
if ($suffixe != '*') {
$validite_ressource = false;
$m = 'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'".<br/>
Les suffixes possibles sont les suivants : <li> * </li>';
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $m);
}
} else {
$validite_ressource = false;
$m = 'Erreur : Le paramètre "'.$radical_champ.'" ne peut pas présenter de suffixe. <br/><br/>';
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $m);
}
return $validite_ressource;
}
 
public function verificationSuffixesCodes(&$suffixe, &$radical_champ, &$validite_ressource ) {
if (!in_array($suffixe, array('*', 'code', 'href', 'details'))) {
$validite_ressource = false;
$e = 'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'.<br/> Les suffixes '
.'possibles sont les suivants : <li> .* </li><li> .code </li><li> .href </li><li> .details </li>';
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
 
public function verificationSuffixesIdentifiant(&$suffixe, &$radical_champ, &$validite_ressource) {
if ((strrpos($radical_champ, 'parent') !== false && !in_array($suffixe, array('*', 'id', 'href', 'details', 'notes')))
|| !in_array($suffixe, array('*', 'id', 'href', 'details')) && strrpos($radical_champ, 'parent') === false) {
$validite_ressource = false;
$e = 'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'".<br/> Les suffixes '
.'possibles sont les suivants : <li> .* </li><li> .id </li><li> .href </li><li> .details </li>'
.'<li> .notes (seulement pour les hybride.parent)';
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
 
 
//------------------------------fonction de formatage pour les services /stats/-----------------------------------------
 
public function formaterStatsAnnee($resultat) {
foreach ($resultat as $cle_annee) {
$annee = ($cle_annee['annee'] != '') ? $cle_annee['annee'] : 'ND';
$nb = $cle_annee['nombre'];
$retour_stats_annee[$annee] = $nb;
}
return $retour_stats_annee;
}
 
public function formaterStatsRang($resultat) {
foreach ($resultat as $rangs) {
if ($rangs['rang'] != 0) {
$rang = $rangs['rang'];
if ($this->parametres['retour.format'] == 'max') {
$retour_rang[$rang]['rang'] = $this->ajouterSignificationCode('rang',$rang);
}
$nombre = $rangs['nombre'];
$retour_rang[$rang]['nombre'] = $nombre;
}
}
return $retour_rang;
}
 
public function formaterStatsInitiales($resultat) {
$rang = null;
$table_rang = array();
foreach ($resultat as $tuple) {
if ($tuple['rang'] != 0) {
$this->memoriserRang($table_rang, $tuple, $rang);
if ($tuple['lettre'] == 'x ') {
$this->ajouterHybrideChimere('hybride', $rang, $tuple);
} elseif ($tuple['lettre'] == '+ ') {
$this->ajouterHybrideChimere('chimere', $rang, $tuple);
} else {
$l = substr($tuple['lettre'], 0, 1);
if (isset($this->table_retour[$rang][$l])) {
$this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] += floatval($tuple['nb']);
} else {
$this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] = floatval($tuple['nb']);
}
}
}
}
return $this->table_retour;
}
 
public function memoriserRang(&$table_rang, $tuple, &$rang) {
if (is_array($table_rang)) {
if (!in_array($tuple['rang'], $table_rang)) {
$rang = $tuple['rang'];
$table_rang[] = $rang;
if ($this->parametres['retour.format'] == 'max') {
$rang = $this->ajouterSignificationCode('rang', $rang);
}
}
}
}
 
public function ajouterHybrideChimere($groupe, &$rang, &$tuple) {
if (isset($this->table_retour[$rang][str_replace('hybride', 'hyb', $groupe)])) {
$this->table_retour[$rang][$groupe] += floatval($tuple['nb']);
} else {
$this->table_retour[$rang][$groupe] = floatval($tuple['nb']);
}
}
 
//-----------------------------Fonctions d'affichage utiliser dans les fonctions de formatage---------------------------
 
public function afficherDonnees($champApi, $valeur) {
$champBdd = $this->trouverChampBddCorrespondant($champApi);
 
if ($this->parametres['retour.format'] == 'min') {
if ($champApi == 'nom_sci') {
$valeur = $valeur.' '.$this->ajouterCompositionNom($this->resultat_req);
}
if ($champApi == 'nom_sci_html') {
$valeur = $valeur.' '.$this->ajouterCompositionNom($this->resultat_req, 'htm');
}
$this->table_retour[$champBdd] = $valeur;
// on essaye de permettre l'obtention du nom_sci_complet, y compris en retour.format == 'min',
// tout en évitant les appels aux ontologies
/*if ($this->correspondAUnId($champBdd) || $champBdd == 'id' && $valeur != '0') {
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $champBdd, $match);
if(strpos($this->parametres['retour.format'], $match[1]) !== false) $this->afficherSignification($match[1], $valeur);
}*/
} else {
$this->afficherToutesLesInfos($champBdd, $valeur);
}
}
 
public function trouverChampBddCorrespondant($champApi) {
if (array_key_exists($champApi, $this->champs_api)) {
$champBdd = $this->correspondance_champs[$champApi];
} else {
$champBdd = $champApi;
}
return $champBdd;
}
 
public function afficherToutesLesInfos($nom_champ_api, $valeur) {
if ($this->presentePlusieursId($nom_champ_api, $valeur)) {
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match);
$this->afficherInfosPrecises($match[1], 'details', $valeur);
$this->table_retour[$nom_champ_api] = $valeur;
 
} elseif (strrpos($nom_champ_api, 'parent') !== false && strrpos($nom_champ_api, 'notes') !== false) {
$this->table_retour[$nom_champ_api] = $valeur;
 
} elseif (($this->correspondAUnId($nom_champ_api) || $nom_champ_api == 'id' && $valeur != '0')) {
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match);
$this->afficherInfosPrecises($match[1], 'id,signification,href', $valeur);
 
} elseif ($this->correspondAUnCode($nom_champ_api)) {
preg_match('/^([^.]+)(?:\.code)?$/', $nom_champ_api, $match);
$this->afficherInfosPrecises($match[1], 'code,signification,href', $valeur);
 
} elseif ($nom_champ_api == 'nom_sci_html') {
$this->table_retour['nom_sci_html'] = $valeur;
$this->table_retour['nom_sci_html_complet'] = $valeur.' '.$this->ajouterCompositionNom($this->resultat_req, 'htm');
}elseif ($nom_champ_api != 'nom_sci') {
$this->table_retour[$nom_champ_api] = $valeur;
}
}
 
public function presentePlusieursId($ressource, $valeur = null) {
if ($valeur) {
$presente = strrpos($ressource, 'proparte') !== false && strrpos($valeur, ',') !== false;
} else { //pour la vérification du champ, on ignore alors la valeur de la ressource
$presente = strrpos($ressource, 'proparte') !== false;
}
return $presente;
}
 
public function afficherInfosPrecises($champ, $suffixe, $valeur) {
$suffixes = explode(',', $suffixe);
//on initialise au service appelé. Sera potentiellement modifié dans la fonction afficherSignification()
$this->service_href = $this->service;
foreach ($suffixes as $suffixe) {
switch ($suffixe) {
case 'id' :
$this->table_retour[str_replace('id.id', 'id', $champ.'.id')] = $valeur;
break;
case 'details' :
$this->afficherTableDetails($champ, $valeur);
break;
case 'signification' :
$this->afficherSignification($champ, $valeur);
break;
case 'href' :
$url = $this->creerUrl($champ, $valeur);
$this->table_retour[str_replace('id.href', 'href', $champ.'.href')] = $url;
break;
case 'code' :
$this->table_retour[$champ.'.code'] = $this->obtenirCode($champ, $valeur);
break;
case 'notes' :
$this->table_retour[$champ.'.notes'] = $this->resultat_req[str_replace('.', '_', $champ).'_notes'];
break;
default : break;
}
}
}
 
public function afficherTableDetails($nom_champ_api, $valeur) {
$tab_id = explode(',', $valeur);
$tab_res = $this->table_retour;
$this->table_retour = array();
foreach ($tab_id as $id) {
$this->afficherInfosPrecises($nom_champ_api, 'id,signification,href', $id);
$tab_res[$nom_champ_api.'.details'][] = $this->table_retour;
$this->table_retour = array();
}
$this->table_retour = $tab_res;
}
 
private function obtenirCode($champ, $valeur) {
$code = $this->transformerChampEnCode($champ);
return "bdnt.$code:$valeur";
}
 
private function transformerChampEnCode($champ) {
if (is_null($this->relationsChampsCodesOntologie)) {
$this->relationsChampsCodesOntologie = Outils::recupererTableauConfig('ChampsCodesOntologie');
}
 
$code = $champ;
if (array_key_exists($champ, $this->relationsChampsCodesOntologie)) {
$code = $this->relationsChampsCodesOntologie[$champ];
}
return $code;
}
 
public function creerUrl($champ, $valeur) {
if ($this->correspondAUnId($champ) || $champ == 'id') {
$service = $this->service_href;
$url = $this->ajouterHref($service, $valeur);
} else {
$code = $this->transformerChampEnCode($champ);
$url = $this->ajouterHrefAutreProjet('ontologies', "$code:", $valeur, 'bdnt');
}
return $url;
}
 
public function afficherSignification($champ, $valeur) {
if ($champ == 'id' && isset($this->resultat_req['nom_sci']) && $this->resultat_req['num_nom'] == $valeur) {
//si le nom_sci du num_nom que l'on veut afficher est déjà dans la table de résultat :
$this->table_retour['nom_sci'] = $this->resultat_req['nom_sci'];
$this->table_retour['nom_sci_complet'] = $this->resultat_req['nom_sci'] . (($suff = $this->ajouterCompositionNom($this->resultat_req)) ? ' ' . $suff : '');
} elseif ($this->correspondAUnId($champ) || $champ == 'id') {
$nom = $this->recupererNomSci($valeur);
if ($nom != array()) {
$this->table_retour[$champ.'.libelle'] = $nom['nom_sci'];
$this->table_retour[$champ.'_html'] = $nom['nom_sci_html'];
$this->table_retour[$champ.'_complet'] = $nom['nom_sci_complet'];
$this->table_retour[$champ.'_html_complet'] = $nom['nom_sci_complet_html'];
$this->service_href = $nom['service'];
}
} elseif ($this->correspondAUnCode($champ)) {
$this->table_retour[$champ.'.libelle'] = $this->ajouterSignificationCode($champ, $valeur);
}
}
 
/** Permet d'afficher les élements nomenclatural du nom_sci lors de l'appel dans le service noms/id/champ du champ^nom_sci.*/
public function afficherNomSciPointEpithete($resultat) {
$tab_nom_sci = array('nom_supra_generique', 'genre', 'epithete_infra_generique', 'epithete_sp',
'type_epithete', 'epithete_infra_sp', 'cultivar_groupe', 'cultivar', 'nom_commercial');
foreach ($tab_nom_sci as $compo_nom) {
if (isset($resultat[$compo_nom]) && !empty($resultat[$compo_nom])) {
$this->table_retour['nom_sci.'.$compo_nom] = $resultat[$compo_nom];
}
}
}
 
public function ajouterSignificationCode($champ, $valeur) {
if($this->termeOntologieEstEnCache($champ, $valeur)) {
$nom_code = $this->obtenirTermeOntologieParCache($champ, $valeur);
} else {
$code = $this->transformerChampEnCode($champ);
if (preg_match('/^([^_-]+)(?:_|-)([^_-]+)$/', $code, $match)) {
$code = $match[1].ucfirst($match[2]);
}
$requete = sprintf('SELECT * FROM %s WHERE id IN (SELECT id FROM %s WHERE code = "%s" AND classe_id = (SELECT id FROM %s WHERE code = "%s")) LIMIT 0, 100 -- %s:%s', Config::get('bdd_table_ontologies'), Config::get('bdd_table_ontologies'), $valeur, Config::get('bdd_table_ontologies'), $code, __FILE__, __LINE__);
$res = $this->getBdd()->recuperer($requete);
$nom_code = $valeur;
if (is_array($res)) {
$nom_code = $res['nom'];
}
$this->mettreEnCacheOntologie($champ, $valeur, $nom_code);
}
return $nom_code;
}
 
public function recupererNomSci($id) {
$nom = array();
if ($id != 0) {
if ($this->compo_nom == null) {
$req = 'SELECT nom_sci, num_nom_retenu, nom_sci_html FROM '.$this->table.' WHERE num_nom = '.$id;
} else { //on ajoute à la requete sql, les champs de ns.structure
//print_r($this->compo_nom);
$req = 'SELECT nom_sci, num_nom_retenu, nom_sci_html, '.implode(', ', $this->compo_nom)
.' FROM '.$this->table
.' WHERE num_nom = '.$id;
}
if ($this->parametres['ns.format'] == 'htm') {
$req = str_replace('nom_sci', 'nom_sci_html as nom_sci', $req);
}
$res = $this->getBdd()->recuperer($req . ' -- ' . __FILE__ . ':' . __LINE__);
if ($res) {
$nom['nom_sci'] = $res['nom_sci'];
$nom['nom_sci_html'] = $res['nom_sci_html'];
$nom['nom_sci_complet'] = $res['nom_sci'].' '.$this->ajouterCompositionNom($res);
$nom['nom_sci_complet_html'] = $res['nom_sci_html'].' '.$this->ajouterCompositionNom($res, 'htm');
$nom['service'] = ($res['num_nom_retenu'] == $id && $this->service == 'taxons') ? 'taxons' : 'noms';
}
}
return $nom;
}
 
/** Permet de retourner une chaine de caractère composée des parametres du nom (ns.structure : annnée, auteur,
* bibilio et addendum). A ajouter au nom scientifique */
public function ajouterCompositionNom($tab_res, $format = '') {
$format = ($format == '') ? $this->parametres['ns.format'] : $format;
 
$nom = '';
if (isset($this->compo_nom)) {
if ($format == 'htm') {
$format = array(
'au' => '<span class="auteur">%s</span>',
'an' => '[<span class="annee">%s</span>]',
'an_bib' => '[<span class="annee">%s</span>, <span class="biblio">%s</span>]',
'bib' => '[<span class="biblio">%s</span>]',
'ad' => '[<span class="adendum">%s</span>]');
} else {
$format = array(
'au' => '%s',
'an' => '[%s]',
'an_bib' => '[%s, %s]',
'bib' => '[%s]',
'ad' => '[%s]',
'gen' => '%s',
'sp' => '%s',
'ssp' => '%s',
'fam' => '%s',
'au_ss' => '%s',
'bib_ss' => '%s');
}
$compo_nom = array();
 
foreach ($this->compo_nom as $key => $champ) {
if (isset($tab_res[$champ]) && !empty($tab_res[$champ])) {
$compo_nom[$key] = $tab_res[$champ];
}
}
$nom_complet = $this->formerNomComplet($compo_nom, $format);
$nom = implode(' ', $nom_complet);
}
return rtrim($nom, ' ');
}
 
 
public function formerNomComplet($compo_nom, $format) {
$nom_complet = array();
extract($compo_nom);
if (isset($au)) $nom_complet[] = sprintf($format['au'], $au);
if (isset($an)) {
if (isset($bib)) {
$nom_complet[] = sprintf($format['an_bib'], $an, $bib);
} else {
$nom_complet[] = sprintf($format['an'], $an);
}
} elseif (isset($bib)) {
$nom_complet[] = sprintf($format['bib'], $bib);
}
if (isset($ad)) $nom_complet[] = sprintf($format['ad'], $ad);
if (isset($gen)) $nom_complet[] = sprintf($format['gen'], $gen);
if (isset($ssp)) $nom_complet[] = sprintf($format['ssp'], $ssp);
if (isset($sp)) $nom_complet[] = sprintf($format['sp'], $sp);
if (isset($fam)) $nom_complet[] = sprintf($format['fam'], $fam);
if (isset($au_ss)) $nom_complet[] = sprintf($format['au_ss'], $au_ss);
if (isset($bib_ss)) {
$bibl = $this->tronquerBiblio($bib_ss);
//simule un 'select distinct' sur les biblio tronquées
if (!isset($this->bib_traitees[$bibl])) {
$nom_complet[] = sprintf($format['bib_ss'],$bibl );
$this->bib_traitees[$bibl] = 1;
}
}
return $nom_complet;
}
 
public function tronquerBiblio($valeur){
$bib = '';
if(strpos($valeur,',') !== false) {
$bib = explode(',',$valeur);
}
if(strpos($bib[0],';') !== false) {
 
$bib[0] = strstr($bib[0],';');
$bib[0] = str_replace('; ','',$bib[0]);
}
return $bib[0];
}
 
 
 
public function correspondAUnCode($key) {
return (strrpos($key, '.code') !== false) || (in_array($key.'.code', $this->correspondance_champs));
}
 
public function correspondAUnId($key) {
return (strrpos($key, '.id') !== false) || (in_array($key.'.id', $this->correspondance_champs));
}
 
public function estUnPoint($key) {
if (strrpos($key, 'hybride.parent') !== false) {
$key = str_replace('hybride.parent', 'hybride_parent', $key);
}
return (strrpos($key, '.') !== false);
}
 
public function recupererMasquePrincipal() {
$masque = null;
$tab_masque = array(
'masque' => 'nom_sci',
'masque_sg' => 'nom_supra_generique',
'masque_gen' => 'genre',
'masque_sp' => 'epithete_sp',
'masque_ssp' => 'epithete_infra_sp',
'masque_au' => 'auteur',
'masque_an' => 'annee',
'masque_bib' => 'biblio_origine',
'masque_ad' => 'addendum',
'masque_rg' => 'rang');
$liste_masque = array();
 
if (isset($this->masque['num_nom'])) {
$liste_masque[] = $this->masque['num_nom'];
}
 
foreach ($tab_masque as $key => $filtre) {
if (isset($this->masque[$filtre])) {
if (!isset($masque) && !in_array($filtre, array('rang', 'annee'))) {
$masque = array($key, $filtre);
}
$liste_masque[] = $this->masque[$filtre];
}
}
$this->masque = $liste_masque;
return $masque;
}
 
private function mettreEnCacheOntologie($categorie, $valeur, $correspondance) {
if(!isset($this->ontologie[$categorie])) {
$this->ontologie[$categorie] = array();
}
if(!isset($this->ontologie[$categorie][$valeur])) {
$this->ontologie[$categorie][$valeur] = array();
}
$this->ontologie[$categorie][$valeur] = $correspondance;
}
 
private function termeOntologieEstEnCache($categorie, $valeur) {
return array_key_exists($categorie, $this->ontologie) && array_key_exists($valeur, $this->ontologie[$categorie]);
}
 
private function obtenirTermeOntologieParCache($categorie, $valeur) {
return $this->ontologie[$categorie][$valeur];
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/bdtfx/CommunNomsTaxons2.php
New file
0,0 → 1,821
<?php
/*
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @copyright 2013 Tela Botanica (accueil@tela-botanica.org)
*/
 
abstract class CommunNomsTaxons extends Commun {
 
/** Tableau de correspondance entre les noms des champs et les codes de l'ontologie.*/
private $relationsChampsCodesOntologie = null;
protected $table_retour; //Permet de stocker le tableau de résultat (non encodé en json)
protected $resultat_req; // Permet de stocker le résultat de la requete principale.
protected $table;// Nom de la table dans laquelle on récupèrera les données dans les requetes SQL
protected $total_resultat = null;
/** Stocke le service appelé correspondant. Est utilisé principalement lors de l'affichage du href d'un synonyme
(ex id=12, basionyme num 25 est un synonyme) dans le service taxon */
protected $service_href = null;
protected $erreursParametres = null;
protected $sans_nom_sci = array('gen','sp','ssp','fam','au_ss','bib_ss');
private $bib_traitees = array();
 
static $correspondance_champs = array();
static $champs_api = array();
static $compo_nom = null; //Stocke sous forme de tableau les composant du nom à ajouter au nom scientifique
static $cache_ontologies = array(); // cache des ontologies
//+------------------------------- PARAMÈTRES ---------------------------------------------------------------+
 
public function traiterParametres() {
$this->definirParametresParDefaut();
$this->verifierParametres();
if (isset($this->parametres) && count($this->parametres) > 0) {
foreach ($this->parametres as $param => $val) {
switch ($param) {
case 'ns.structure' :
self::remplirTableCompositionNom($val);
if (in_array($val,$this->sans_nom_sci)){
$this->requete_champ = implode(', ',self::$compo_nom);
}else {
$this->requete_champ .= ' ,'.implode(', ',self::$compo_nom);
}
break;
case 'navigation.depart' :
$this->limite_requete['depart'] = $val;
break;
case 'navigation.limite' :
$this->limite_requete['limite'] = $val;
break;
}
}
$this->traiterParametresSpecifiques();
}
}
 
protected function definirParametresParDefaut() {
if (empty($this->parametres['recherche'])) {
$this->parametres['recherche'] = 'stricte';
}
if (empty($this->parametres['ns.format'])) {
$this->parametres['ns.format'] = 'txt';
}
if (empty($this->parametres['retour.format'])) {
$this->parametres['retour.format'] = 'max';
}
if (empty($this->parametres['ns.structure']) &&
$this->parametres['retour.format'] != 'oss') {
$this->parametres['ns.structure'] = 'au,an,bib';
}
}
 
 
public function verifierParametres() {
//$this->verifierParametresAPI();
 
$this->verifierParametre('recherche', 'stricte|floue|etendue|complete');
$this->verifierParametre('ns.format', 'htm|txt');
$this->verifierParametre('retour.format', 'min|max|oss|perso');
$this->verifierParametreAvecValeurMultipe('ns.structure', 'an|au|bib|ad|gen|sp|ssp|fam|au_ss|bib_ss');
 
/*if (count($this->erreursParametres) > 0) {
$m = 'Erreur dans votre requête : '.implode('<br/>', $this->erreursParametres);
throw new Exception(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $m);
}*/
}
 
public function verifierParametresAPI() {
$parametresApi = Commun::recupererTableauConfig('parametresAPI');
while (!is_null($parametre = key($this->parametres))) {
if (!in_array($parametre, $parametresApi)) {
$this->erreursParametres[] = "Le paramètre '$parametre' n'est pas pris en compte par cette version de l'API.";
}
next($this->parametres);
}
}
 
public function verifierParametre($parametre, $valeursPermises) {
if (isset($this->parametres[$parametre]) && !empty($this->parametres[$parametre])) {
$valeur = $this->parametres[$parametre];
$this->verifierValeursPermises($parametre, $valeur, $valeursPermises);
}
}
 
public function verifierParametreAvecValeurMultipe($parametre, $valeursPermises) {
if (isset($this->parametres[$parametre]) && !empty($this->parametres[$parametre])) {
$valeursConcatenees = $this->parametres[$parametre];
$valeurs = explode(',', $valeursConcatenees);
foreach ($valeurs as $valeur) {
$this->verifierValeursPermises($parametre, $valeur, $valeursPermises);
}
}
}
 
private function verifierValeursPermises($parametre, $valeur, $valeursPermises) {
if (!in_array($valeur, explode('|', $valeursPermises))) {
$this->erreursParametres[] = "Le paramètre '$parametre' ne peut pas prendre la valeur '$valeur'. Valeurs permises : $valeursPermises";
}
}
 
public function ajouterFiltreMasque($nom_champ, $valeur) {
$orig_val = $valeur;
$valeur = explode(',',$valeur);
$conditions = array();
if ($nom_champ == 'annee' || $nom_champ == 'rang') {
foreach ($valeur as $val) {
$conditions[] = "$nom_champ = ".$this->getBdd()->proteger($val);
}
} else {
if ($this->parametres['recherche'] == 'etendue') {
foreach ($valeur as $val) {
$val = self::preparerChainePourRechercheEtendue(self::remplacerCaractereHybrideEtChimere($val));
$conditions[] = "$nom_champ LIKE ".$this->getBdd()->proteger($val);
}
 
} elseif ($this->parametres['recherche'] == 'floue') {
foreach ($valeur as $val) {
$val = $this->getBdd()->proteger($val);
$conditions[] = "( SOUNDEX($nom_champ) = SOUNDEX($val))".
" OR ( SOUNDEX(REVERSE($nom_champ)) = SOUNDEX(REVERSE($val)))";
}
// utile pour la détermination à partir d'un nom retenu (concat(nom_sci,auteur)) lors
// d'un import depuis le CEL
} elseif ($this->parametres['recherche'] == 'concat' && $nom_champ == 'nom_sci') {
$conditions[] = "CONCAT(nom_sci, ' ', auteur) = " . $this->getBdd()->proteger($orig_val);
 
} else {
foreach ($valeur as $val) {
$conditions[] = "$nom_champ LIKE ".$this->getBdd()->proteger($val);
}
}
}
$this->requete_condition[]= '('.implode(' OR ', $conditions ).')';
$this->masque[$nom_champ] = $nom_champ.'='.implode(',',$valeur);
}
 
static function remplacerCaractereHybrideEtChimere($valeur) {
return str_replace(array('×', '%D7', '+', '%2B'),
array('x ','x ', '+', '+'),
$valeur);
}
 
static function preparerChainePourRechercheEtendue($valeur) {
return str_replace(' ', '% ', trim($valeur)) . '%';
}
 
//+-------------------------------Fonctions d'analyse des ressources-------------------------------------+
public function traiterRessources() {
if (isset($this->ressources) && count($this->ressources) > 0) {
if ($this->ressources[0] == 'relations') {
$this->traiterRessourceRelations();
} elseif ($this->estUnIdentifiant($this->ressources[0])) { //l'identifiant peut etre de type /#id ou /nt:#id
$this->traiterRessourcesIdentifiant(); // dans le service noms ou taxons
} elseif ($this->ressources[0] == 'stats') { //ressource = noms/stats
$this->traiterRessourcesStats();
} else {
$e = 'Erreur dans votre requete </br> Ressources disponibles : <br/>
<li> /'.$this->service.'/#id (id : L\'identifiant du nom rechercher)</li>
<li> /'.$this->service.'/nt:#id (id : Numero du taxon recherche)</li>
<li> /'.$this->service.'/stats </li>';
throw new Exception(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
}
 
public function traiterRessourcesStats() {
$this->format_reponse = $this->service.'/stats';
 
$e = "Erreur dans votre requête </br> Ressources disponibles : $this->service/stats/[annees|rangs|initiales]";
if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
switch ($this->ressources[1]) {
case 'annees' :
$this->traiterRessourceStatsAnnees();
break;
case 'rangs' :
$this->traiterRessourceStatsRangs();
break;
case 'initiales' :
$this->traiterRessourceStatsInitiales();
break;
default :
throw new Exception(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
break;
}
} else {
throw new Exception(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
 
/** Vérifie si la première valeur de la table de ressource est un identifiant :
* un numerique ou un numéro taxonomique sous la forme nt:xx */
static function estUnIdentifiant($uripart) {
return (is_numeric($uripart) || (strrpos($uripart,'nt:') !== false
&& is_numeric(str_replace('nt:','',$uripart))));
}
 
//+------------------------------------------------------------------------------------------------------+
// Fonction d'analyse des parametres
 
/** Permet de remplir le tableau compo_nom. Il comprendra en fct du paramètre ns.structure les éléments à rajouter
* au nom_sci (annee, auteur, biblio ou addendum). */
static function remplirTableCompositionNom($valeur) {
$structure_nom = explode(',', $valeur);
 
foreach ($structure_nom as $structure) {
$structure = trim($structure);
$patterns = array('/^an$/', '/^au$/', '/^bib$/', '/^ad$/', '/^sp$/', '/^gen$/', '/^ssp$/','/^fam$/',
'/^au_ss$/','/^bib_ss$/');
$champs = array('annee', 'auteur', 'biblio_origine', 'nom_addendum', 'epithete_sp', 'genre',
'epithete_infra_sp','famille','auteur', 'biblio_origine');
 
// avec str_replace() 'sp' est inclu dans 'ssp', et la conversion pour 'ssp' est mauvaise
self::$compo_nom[$structure] = preg_replace($patterns, $champs, $structure);
}
}
 
public function mettreAuFormat() {
if ($this->parametres['ns.format'] == 'htm') {
if (strrpos($this->requete_champ, 'nom_sci_html as nom_sci') === false) {
$this->requete_champ = str_replace('nom_sci', 'nom_sci_html as nom_sci', $this->requete_champ);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
// Fonctions de formatage
public function formaterEnOss($resultat) {
$table_nom = array();
$oss = '';
foreach ($resultat as $tab) {
if (isset($tab['nom_sci']) ) {
if (!in_array($tab['nom_sci'], $table_nom)) {
$table_nom[] = $tab['nom_sci'];
$oss[] = $tab['nom_sci'].' '.self::ajouterCompositionNom($tab, $this->parametres['ns.format'], $this->bib_traitees);
}
}else {
$res = self::ajouterCompositionNom($tab, $this->parametres['ns.format'], $this->bib_traitees);
if($res) {
$oss[] = $res;
}
}
 
}
 
if (isset($this->masque)) $masque = implode('&', $this->masque);
else $masque = 'Pas de masque';
$table_retour_oss = array($masque, $oss);
return $table_retour_oss;
}
 
public function afficherEnteteResultat($url_service) {
$this->table_retour['depart'] = $this->limite_requete['depart'];
$this->table_retour['limite'] = $this->limite_requete['limite'];
$this->table_retour['total'] = $this->total_resultat;
$url = $this->formulerUrl($this->total_resultat, $url_service);
if (isset($url['precedent']) && $url['precedent'] != '') {
$this->table_retour['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$this->table_retour['href.suivant'] = $url['suivant'];
}
}
 
public function afficherNomHrefRetenu($tab, $num) {
$this->resultat_req = $tab;
$this->afficherDonnees('num_nom', $num);
if ($this->parametres['retour.format'] == 'min') { // sinon est affiché ds afficherDonnees(num_nom, $val) ci-dessus
$this->table_retour['nom_sci'] = $tab['nom_sci'];
$this->table_retour['nom_sci_complet'] = $tab['nom_sci'].' '.self::ajouterCompositionNom($tab, $this->parametres['ns.format'], $this->bib_traitees);
}
if ($tab['num_nom_retenu'] != '') {
$retenu = ($tab['num_nom_retenu'] == $num) ? 'true' : 'false';
} else {
$retenu = 'absent';
}
$this->table_retour['retenu'] = $retenu;
// Pourquoi ce unset ? JPM - 28-03-2013
unset($this->table_retour['id']);
}
 
 
//+------------------------------------------------------------------------------------------------------+
// Fonction de formatage pour les services /#id/
 
public function formaterId($resultat) {
self::$correspondance_champs = Commun::recupererTableauConfig('correspondance_champs');
foreach (self::$correspondance_champs as $key => $val) {
preg_match('/(hybride[.]parent_0[12](?:[.]notes)?|nom_sci[.][^.]+|[^.]+)(?:[.](id|code))?/', $val, $match);
self::$champs_api[$key] = $match[1];
}
 
$this->resultat_req = $resultat;
 
foreach ($resultat as $cle => $valeur) {
if ($valeur != '') {
$this->afficherDonnees($cle, $valeur);
}
}
if (isset($this->parametres['retour.champs']) && $this->format_reponse == 'noms/id') {
$retour = $this->table_retour;
$this->table_retour = array();
$champs = explode(',', $this->parametres['retour.champs']);
self::ajouterChampsPersonnalises($champs, $retour, $this->champs_table, $this->table_retour, $this->resultat_req);
}
unset($this->table_retour['href']);
return $this->table_retour;
}
 
public function formaterIdChamp($resultat) {
self::$correspondance_champs = Commun::recupererTableauConfig('correspondance_champs');
foreach (self::$correspondance_champs as $key => $val) {
preg_match('/(hybride[.]parent_0[12](?:[.]notes)?|nom_sci[.][^.]+|[^.]+)(?:[.](id|code))?/', $val, $match);
self::$champs_api[$key] = $match[1];
}
 
$reponse_id = $this->formaterId($resultat);
$this->table_retour = array();
$champs = explode(' ', $this->ressources[1]);
self::ajouterChampsPersonnalises($champs, $reponse_id, $this->champs_table, $this->table_retour, $this->resultat_req);
return $this->table_retour;
}
 
static function ajouterChampsPersonnalises($champs, $reponse_id, $champs_table, &$retour, $resultat_req) {
$champs_a_libeller = array('nom_retenu', 'rang', 'basionyme', 'hybride', 'hybride.parent_01',
'hybride.parent_02', 'presence', 'tax_sup', 'statut_origine', 'statut_culture', 'statut_introduction');
if (! is_null($champs) && is_array($champs) && count($champs) > 0) {
foreach ($champs as $champ) {
if (! self::verifierValiditeChamp($champ, $champs_table)) continue;
 
if (strrpos($champ, '.*') !== false) {
self::afficherPointEtoile($champ, $reponse_id, $retour, $resultat_req);
} elseif (in_array($champ, $champs_a_libeller)) {
$retour[$champ.'.libelle'] =
(isset($reponse_id[$champ.'.libelle'])) ? $reponse_id[$champ.'.libelle'] : null;
} else {
$champ_bdd = self::trouverChampBddCorrespondant($champ);
$retour[$champ_bdd] = isset($reponse_id[$champ_bdd]) ? $reponse_id[$champ_bdd] : null;
}
}
}
}
 
static function afficherPointEtoile($champ, $reponse, &$retour, $resultat_req) {
preg_match('/^([^.]+\.)\*$/', $champ, $match);
if ($match[1] == 'nom_sci') {
self::afficherNomSciPointEpithete($resultat_req, $retour);
} else {
foreach ($reponse as $chp => $valeur) {
if (strrpos($chp, $match[1]) !== false) {
if ($valeur != '') {
$retour[$chp] = $valeur;
} else {
$retour[$chp] = null;
}
}
}
}
}
 
static function verifierValiditeChamp($champ, $champs_table) {
if (! preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match)) {
return true;
}
// decomposerNomChamp()
$radical = $match[1];
$suffixe = isset($match[2]) ? $match[2] : "";
 
$champs_complementaire = array('nom_retenu_complet', 'basionyme_complet');
// on verifie si le nom du champ existe bien
$champs_complementaire2 = array_diff($champs_table, array_keys(self::$champs_api)); // XXX
if (! self::estChampApi($radical) && ! in_array($radical_champ, $champs_complementaire2)) {
if (!in_array($radical, $champs_complementaire)) {
throw new Exception(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, 'Le champ "'.$radical.'" n\'existe pas dans la base. <br/><br/>');
return FALSE;
}
} elseif (self::estUnPoint($champ)) {
return self::verifierValiditeSuffixe($suffixe, $radical);
}
 
return TRUE;
}
 
static function estChampApi($radical_champ) {
$champ_api_ok = false;
if (in_array($radical_champ, self::$champs_api) || in_array($radical_champ, self::$correspondance_champs)) {
$champ_api_ok = true;
}
return $champ_api_ok;
}
 
static function verifierValiditeSuffixe($suffixe, $radical_champ) {
$validite_ressource = true;
if (self::correspondAUnId($radical_champ) || $radical_champ == 'id') {
self::verificationSuffixesIdentifiant($suffixe, $radical_champ, $validite_ressource);
} elseif (self::correspondAUnCode($radical_champ)) {
if (!in_array($suffixe, array('*', 'code', 'href', 'details'))) {
throw new Exception(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, 'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'.<br/> Les suffixes possibles sont les suivants : <li> .* </li><li> .code </li><li> .href </li><li> .details </li>');
}
} elseif ($radical_champ == 'nom_sci') {
if ($suffixe != '*') {
$validite_ressource = false;
$m = 'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'".<br/>
Les suffixes possibles sont les suivants : <li> * </li>';
throw new Exception( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $m);
}
} else {
$validite_ressource = false;
$m = 'Erreur : Le paramètre "'.$radical_champ.'" ne peut pas présenter de suffixe. <br/><br/>';
throw new Exception( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $m);
}
return $validite_ressource;
}
 
 
static function verificationSuffixesIdentifiant(&$suffixe, &$radical_champ, &$validite_ressource) {
if ((strrpos($radical_champ, 'parent') !== false && !in_array($suffixe, array('*', 'id', 'href', 'details', 'notes')))
|| !in_array($suffixe, array('*', 'id', 'href', 'details')) && strrpos($radical_champ, 'parent') === false) {
$validite_ressource = false;
$e = 'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'".<br/> Les suffixes '
.'possibles sont les suivants : <li> .* </li><li> .id </li><li> .href </li><li> .details </li>'
.'<li> .notes (seulement pour les hybride.parent)';
throw new Exception( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
 
 
//------------------------------fonction de formatage pour les services /stats/-----------------------------------------
public function formaterStatsInitiales($resultat) {
$rang = null;
$table_rang = array();
foreach ($resultat as $tuple) {
if ($tuple['rang'] != 0) {
$this->memoriserRang($table_rang, $tuple, $rang);
if ($tuple['lettre'] == 'x ') {
self::ajouterHybrideChimere('hybride', $this->retour[$rang], $tuple);
} elseif ($tuple['lettre'] == '+ ') {
self::ajouterHybrideChimere('chimere', $this->retour[$rang], $tuple);
} else {
$l = substr($tuple['lettre'], 0, 1);
if (isset($this->table_retour[$rang][$l])) {
$this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] += floatval($tuple['nb']);
} else {
$this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] = floatval($tuple['nb']);
}
}
}
}
return $this->table_retour;
}
 
public function memoriserRang(&$table_rang, $tuple, &$rang) {
if (is_array($table_rang)) {
if (!in_array($tuple['rang'], $table_rang)) {
$rang = $tuple['rang'];
$table_rang[] = $rang;
if ($this->parametres['retour.format'] == 'max') {
$rang = self::ajouterSignificationCode('rang', $rang, $this->getBdd());
}
}
}
}
 
static function ajouterHybrideChimere($groupe, &$tab, &$tuple) {
if (isset($tab[str_replace('hybride', 'hyb', $groupe)])) {
$tab[$groupe] += floatval($tuple['nb']);
} else {
$tab[$groupe] = floatval($tuple['nb']);
}
}
 
//-----------------------------Fonctions d'affichage utiliser dans les fonctions de formatage---------------------------
 
public function afficherDonnees($champApi, $valeur) {
$champBdd = self::trouverChampBddCorrespondant($champApi);
 
if ($this->parametres['retour.format'] == 'min') {
if ($champApi == 'nom_sci') {
$valeur = $valeur.' '.self::ajouterCompositionNom($this->resultat_req, $this->parametres['ns.format'], $this->bib_traitees);
}
if ($champApi == 'nom_sci_html') {
$valeur = $valeur.' '.self::ajouterCompositionNom($this->resultat_req, 'htm', $this->bib_traitees);
}
$this->table_retour[$champBdd] = $valeur;
// on essaye de permettre l'obtention du nom_sci_complet, y compris en retour.format == 'min',
// tout en évitant les appels aux ontologies
/*if ($this->correspondAUnId($champBdd) || $champBdd == 'id' && $valeur != '0') {
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $champBdd, $match);
if(strpos($this->parametres['retour.format'], $match[1]) !== false) $this->afficherSignification($match[1], $valeur);
}*/
} else {
$this->afficherToutesLesInfos($champBdd, $valeur);
}
}
 
static function trouverChampBddCorrespondant($champApi) {
if (array_key_exists($champApi, self::$champs_api)) {
$champBdd = self::$correspondance_champs[$champApi];
} else {
$champBdd = $champApi;
}
return $champBdd;
}
 
public function afficherToutesLesInfos($nom_champ_api, $valeur) {
if ($this->presentePlusieursId($nom_champ_api, $valeur)) {
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match);
$this->afficherInfosPrecises($match[1], 'details', $valeur, $this->table_retour);
$this->table_retour[$nom_champ_api] = $valeur;
 
} elseif (strrpos($nom_champ_api, 'parent') !== false && strrpos($nom_champ_api, 'notes') !== false) {
$this->table_retour[$nom_champ_api] = $valeur;
 
} elseif ((self::correspondAUnId($nom_champ_api) || $nom_champ_api == 'id' && $valeur != '0')) {
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match);
$this->afficherInfosPrecises($match[1], 'id,href', $valeur, $this->table_retour);
self::afficherSignification($match[1], $valeur, $obj->resultat_req, $this->table_retour, $this->getBdd(), $this);
 
} elseif (self::correspondAUnCode($nom_champ_api)) {
preg_match('/^([^.]+)(?:\.code)?$/', $nom_champ_api, $match);
$this->afficherInfosPrecises($match[1], 'code,href', $valeur, $this->table_retour);
self::afficherSignification($match[1], $valeur, $obj->resultat_req, $this->table_retour, $this->getBdd(), $this);
 
} elseif ($nom_champ_api == 'nom_sci_html') {
$this->table_retour['nom_sci_html'] = $valeur;
$this->table_retour['nom_sci_html_complet'] = $valeur.' '.self::ajouterCompositionNom($this->resultat_req, 'htm', $this->bib_traitees);
} elseif ($nom_champ_api != 'nom_sci') {
$this->table_retour[$nom_champ_api] = $valeur;
}
}
 
public function presentePlusieursId($ressource, $valeur = null) {
if ($valeur) {
$presente = strrpos($ressource, 'proparte') !== false && strrpos($valeur, ',') !== false;
} else { //pour la vérification du champ, on ignore alors la valeur de la ressource
$presente = strrpos($ressource, 'proparte') !== false;
}
return $presente;
}
 
public function afficherInfosPrecises($champ, $suffixe, $valeur, &$retour) {
$suffixes = explode(',', $suffixe);
//on initialise au service appelé. Sera potentiellement modifié dans la fonction afficherSignification()
$this->service_href = $this->service;
foreach ($suffixes as $suffixe) {
switch ($suffixe) {
case 'id' :
$retour[str_replace('id.id', 'id', $champ.'.id')] = $valeur;
break;
case 'details' :
$tab_id = explode(',', $valeur);
$tab_res = $retour;
$retour = array();
foreach ($tab_id as $id) {
$this->afficherInfosPrecises($champ, 'id,signification,href', $id, $retour);
$tab_res[$champ.'.details'][] = $retour;
$retour = array();
}
$retour = $tab_res;
break;
case 'href' :
$retour[str_replace('id.href', 'href', $champ.'.href')] = self::creerUrl($champ, $valeur, $this->version_projet);
break;
case 'code' :
$retour[$champ.'.code'] = "bdnt." . self::transformerChampEnCode($champ) . ":$valeur";
break;
case 'notes' :
$retour[$champ.'.notes'] = $this->resultat_req[str_replace('.', '_', $champ).'_notes'];
break;
default : break;
}
}
}
 
static function transformerChampEnCode($champ) {
static $tab;
$tab = Outils::recupererTableauConfig('ChampsCodesOntologie');
if (!array_key_exists($champ, $tab)) return $champ;
return $tab[$champ];
}
 
static function creerUrl($champ, $valeur, $version_projet) {
if (self::correspondAUnId($champ) || $champ == 'id') {
$service = $this->service_href;
$url = self::s_ajouterHref($service, $valeur, $version_projet);
} else {
$code = self::transformerChampEnCode($champ);
$url = self::ajouterHrefAutreProjet('ontologies', "$code:", $valeur, 'bdnt');
}
return $url;
}
 
static function afficherSignification($champ, $valeur, $resreq, &$retour, $db, $obj) {
$fmt = $obj->parametres['ns.format'];
 
if ($champ == 'id' && isset($resreq['nom_sci']) && $resreq['num_nom'] == $valeur) {
//si le nom_sci du num_nom que l'on veut afficher est déjà dans la table de résultat :
$retour['nom_sci'] = $resreq['nom_sci'];
$retour['nom_sci_complet'] = $resreq['nom_sci'] . (($suff = self::ajouterCompositionNom($resreq, $fmt, $obj->bib_traitees)) ? ' ' . $suff : '');
return ;
}
 
if (self::correspondAUnCode($champ)) {
$retour[$champ.'.libelle'] = self::ajouterSignificationCode($champ, $valeur, $db);
return ;
}
 
if (self::correspondAUnId($champ) || $champ == 'id') {
// $nom = $obj->recupererNomSci($valeur);
$id = $valeur;
 
$nom = array();
if ($id != 0) {
if (self::$compo_nom == null) {
$req = 'SELECT nom_sci, num_nom_retenu, nom_sci_html FROM '.$obj->table.' WHERE num_nom = '.$id;
} else { //on ajoute à la requete sql, les champs de ns.structure
//print_r(self::$compo_nom);
$req = 'SELECT nom_sci, num_nom_retenu, nom_sci_html, '.implode(', ', self::$compo_nom)
.' FROM '.$obj->table
.' WHERE num_nom = '.$id;
}
if ($fmt == 'htm') {
$req = str_replace('nom_sci', 'nom_sci_html as nom_sci', $req);
}
$res = $db->recuperer($req . ' -- ' . __FILE__ . ':' . __LINE__);
if ($res) {
$nom['nom_sci'] = $res['nom_sci'];
$nom['nom_sci_html'] = $res['nom_sci_html'];
$nom['nom_sci_complet'] = $res['nom_sci'].' '.self::ajouterCompositionNom($res, $fmt, $obj->bib_traitees);
$nom['nom_sci_complet_html'] = $res['nom_sci_html'].' '.self::ajouterCompositionNom($res, 'htm', $obj->bib_traitees);
$nom['service'] = ($res['num_nom_retenu'] == $id && $obj->service == 'taxons') ? 'taxons' : 'noms';
}
}
 
 
if ($nom != array()) {
$retour[$champ.'.libelle'] = $nom['nom_sci'];
$retour[$champ.'_html'] = $nom['nom_sci_html'];
$retour[$champ.'_complet'] = $nom['nom_sci_complet'];
$retour[$champ.'_html_complet'] = $nom['nom_sci_complet_html'];
$obj->service_href = $nom['service'];
}
}
}
 
/** Permet d'afficher les élements nomenclatural du nom_sci lors de l'appel dans le service noms/id/champ du champ^nom_sci.*/
static function afficherNomSciPointEpithete($resultat, &$retour) {
$tab_nom_sci = array('nom_supra_generique', 'genre', 'epithete_infra_generique', 'epithete_sp',
'type_epithete', 'epithete_infra_sp', 'cultivar_groupe', 'cultivar', 'nom_commercial');
foreach ($tab_nom_sci as $compo_nom) {
if (isset($resultat[$compo_nom]) && !empty($resultat[$compo_nom])) {
$table_retour['nom_sci.'.$compo_nom] = $resultat[$compo_nom];
}
}
}
 
static function ajouterSignificationCode($champ, $valeur, $db) {
// ontologie/cache
if(array_key_exists($champ, self::$cache_ontologies) && array_key_exists($valeur, self::$cache_ontologies[$champ])) {
$nom_code = self::$cache_ontologies[$champ][$valeur];
} else {
$code = self::transformerChampEnCode($champ);
if (preg_match('/^([^_-]+)(?:_|-)([^_-]+)$/', $code, $match)) {
$code = $match[1].ucfirst($match[2]);
}
$requete = sprintf('SELECT * FROM %1$s WHERE id IN (SELECT id FROM %1$s WHERE code = "%2$s" AND classe_id = (SELECT id FROM %1$s WHERE code = "%3$s")) LIMIT 0, 100 -- %4$s:%5$s',
Config::get('bdd_table_ontologies'), $valeur, $code, __FILE__, __LINE__);
$res = $db->recuperer($requete);
$nom_code = $valeur;
if (is_array($res)) {
$nom_code = $res['nom'];
}
// cache
self::$cache_ontologies[$champ][$valeur] = $correspondance;
}
return $nom_code;
}
 
/** Permet de retourner une chaine de caractère composée des parametres du nom (ns.structure : annnée, auteur,
* bibilio et addendum). A ajouter au nom scientifique */
static function ajouterCompositionNom($tab_res, $format, &$bib_traitees) {
if(!self::$compo_nom) return '';
 
if ($format == 'htm') {
$format = array(
'au' => '<span class="auteur">%s</span>',
'an' => '[<span class="annee">%s</span>]',
'an_bib' => '[<span class="annee">%s</span>, <span class="biblio">%s</span>]',
'bib' => '[<span class="biblio">%s</span>]',
'ad' => '[<span class="adendum">%s</span>]');
} else {
$format = array(
'au' => '%s',
'an' => '[%s]',
'an_bib' => '[%s, %s]',
'bib' => '[%s]',
'ad' => '[%s]',
'gen' => '%s',
'sp' => '%s',
'ssp' => '%s',
'fam' => '%s',
'au_ss' => '%s',
'bib_ss' => '%s');
}
$compo_nom_arr = array();
foreach (self::$compo_nom as $key => $champ) {
if (isset($tab_res[$champ]) && !empty($tab_res[$champ])) {
$compo_nom_arr[$key] = $tab_res[$champ];
}
}
return rtrim(implode(' ', self::formerNomComplet($compo_nom_arr, $format, $bib_traitees)), ' ');
}
 
 
static function formerNomComplet($compo_nom_arr, $format, &$bib_traitees) {
$nom_complet = array();
extract($compo_nom_arr);
if (isset($au)) $nom_complet[] = sprintf($format['au'], $au);
if (isset($an)) {
if (isset($bib)) {
$nom_complet[] = sprintf($format['an_bib'], $an, $bib);
} else {
$nom_complet[] = sprintf($format['an'], $an);
}
} elseif (isset($bib)) {
$nom_complet[] = sprintf($format['bib'], $bib);
}
if (isset($ad)) $nom_complet[] = sprintf($format['ad'], $ad);
if (isset($gen)) $nom_complet[] = sprintf($format['gen'], $gen);
if (isset($ssp)) $nom_complet[] = sprintf($format['ssp'], $ssp);
if (isset($sp)) $nom_complet[] = sprintf($format['sp'], $sp);
if (isset($fam)) $nom_complet[] = sprintf($format['fam'], $fam);
if (isset($au_ss)) $nom_complet[] = sprintf($format['au_ss'], $au_ss);
if (isset($bib_ss)) {
$bibl = self::tronquerBiblio($bib_ss);
//simule un 'select distinct' sur les biblio tronquées
if (!isset($bib_traitees[$bibl])) {
$nom_complet[] = sprintf($format['bib_ss'],$bibl );
$bib_traitees[$bibl] = 1;
}
}
return $nom_complet;
}
 
static function tronquerBiblio($valeur){
$bib = '';
if(strpos($valeur,',') !== false) {
$bib = explode(',',$valeur);
}
if(strpos($bib[0],';') !== false) {
$bib[0] = strstr($bib[0],';');
$bib[0] = str_replace('; ','',$bib[0]);
}
return $bib[0];
}
 
 
 
static function correspondAUnCode($key) {
return strrpos($key, '.code') !== false || in_array($key.'.code', self::$correspondance_champs);
}
static function correspondAUnId($key) {
return strrpos($key, '.id') !== false || in_array($key.'.id', self::$correspondance_champs);
}
 
static function estUnPoint($key) {
if (strrpos($key, 'hybride.parent') !== false) {
$key = str_replace('hybride.parent', 'hybride_parent', $key);
}
return (strrpos($key, '.') !== false);
}
 
public function recupererMasquePrincipal() {
$masque = null;
$tab_masque = array(
'masque' => 'nom_sci',
'masque_sg' => 'nom_supra_generique',
'masque_gen' => 'genre',
'masque_sp' => 'epithete_sp',
'masque_ssp' => 'epithete_infra_sp',
'masque_au' => 'auteur',
'masque_an' => 'annee',
'masque_bib' => 'biblio_origine',
'masque_ad' => 'addendum',
'masque_rg' => 'rang');
$liste_masque = array();
 
if (isset($this->masque['num_nom'])) {
$liste_masque[] = $this->masque['num_nom'];
}
 
foreach ($tab_masque as $key => $filtre) {
if (isset($this->masque[$filtre])) {
if (!isset($masque) && !in_array($filtre, array('rang', 'annee'))) {
$masque = array($key, $filtre);
}
$liste_masque[] = $this->masque[$filtre];
}
}
$this->masque = $liste_masque;
return $masque;
}
}
/tags/v5.6-arganeraie/services/modules/0.1/bdtfx/Noms.php
New file
0,0 → 1,666
<?php
// declare(encoding='UTF-8');
/**
* Classe permettant de fournir des informations sur les noms scientifiques.
* Si l'url finit par /noms on retourne une liste de noms latin et leurs identifiants (seulement les 100 premeiers noms par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /noms?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.gen (nom de genre), masque.sp (épithète d'espèce), masque.ssp (épithète infra-spécifique),
* masque.au (auteur du nom), masque.an (année de publication du nom), masque.bib (réf biblio de la publi d'origine du nom), masque.ad (nomen addendum),
* masque.nn (identifiant du nom), recherche, rang, distinct, retour.format, nl.format, nl.structure, navigation.depart et navigation.limite.
* Les différentes requetes :
* - noms | noms/relations/#projet/#id_projet | noms/#id | noms/#id/#champ+#champ
* - noms/#id/relations | noms/#id/relations/synonymie | noms/#id/relations/homonymie | noms/#id/relations/flores
* - noms/stats/rangs | noms/stats/annees | noms/stats/initiales
*
* @package bdtfx
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $Id$
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org)
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Noms
*/
 
class Noms extends CommunNomsTaxons {
 
protected $format_reponse = 'noms'; // Permet de stocker la requete formulée
protected $service = 'noms';
protected $serviceNom = 'noms';
protected $requete_champ = 'num_nom, nom_sci, num_nom_retenu';
protected $requete_condition = null;
protected $requete_group_by = '';
/** Permet de stocker les limite de la requete SQL (par défaut seul les 100 premiers résultats seront retournés).*/
protected $limite_requete = array('depart' => 0, 'limite' => 100);
protected $distinct = null; // Valeur du paramètre de requete distinct (=0|1)
 
public function consulter($ressources, $parametres) {
return parent::consulter($ressources, $parametres);
}
 
//+----------------FONCTION D'ANALYSE DES PARAMETRES---------------------------------------------------------+
 
public function traiterParametresSpecifiques() {
foreach ($this->parametres as $param => $val) {
switch ($param) {
case 'masque' :
$this->ajouterFiltreMasque('nom_sci', $val);
break;
case 'masque.sg' :
$this->ajouterFiltreMasque('nom_supra_generique', $val);
break;
case 'masque.gen' :
$this->ajouterFiltreMasque('genre', $val);
break;
case 'masque.sp' :
$this->ajouterFiltreMasque('epithete_sp', $val);
break;
case 'masque.ssp' :
$this->ajouterFiltreMasque('epithete_infra_sp',$val);
break;
case 'masque.au' :
$this->ajouterFiltreMasque('auteur', $val);
break;
case 'masque.an' :
$this->ajouterFiltreMasque('annee', $val);
break;
case 'masque.bib' :
$this->ajouterFiltreMasque('biblio_origine',$val);
break;
case 'masque.ad' :
$this->ajouterFiltreMasque('nom_addendum', $val);
break;
case 'masque.nn' :
$this->requete_condition []= 'num_nom IN ('.$val.')';
$this->masque['num_nom'] = "num_nom=$val";
break;
case 'masque.nt' :
$this->requete_condition []= 'num_taxonomique IN ('.$val.')';
$this->masque['num_tax'] = "num_taxonomique=$val";
break;
case 'masque.rg' :
$this->ajouterFiltreMasque('rang', $val);
break;
case 'retour.champs' :
$this->verifierParamChamps($param, $val);
break;
case 'distinct' :
$this->ajouterNomDistinct($val);
break;
case 'masque.fam' :
$this->ajouterFiltreMasque('famille', $val);
break;
case 'masque.prga' :
$this->ajouterFiltreMasque('presence_ga', $val);
break;
case 'masque.prco' :
$this->ajouterFiltreMasque('presence_co', $val);
break;
case 'masque.sto' :
$this->ajouterFiltreMasque('statut_origine', $val);
break;
case 'masque.sti' :
$this->ajouterFiltreMasque('statut_introduction', $val);
break;
case 'masque.stc' :
$this->ajouterFiltreMasque('statut_culture', $val);
break;
case 'masque.and' :
$this->requete_condition []= " annee >= ".$this->getBdd()->proteger($val);
break;
case 'masque.anf' :
$this->requete_condition []= " annee <= ".$this->getBdd()->proteger($val);
break;
}
 
}
}
 
public function verifierParamChamps($param, $val) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$champs_demandes = explode(',', $val);
$champs_verifies = array();
$champs_api = array_flip($this->champs_api);
$champs_supp = array('nom_retenu_complet'=>'num_nom_retenu', 'basionyme_complet'=>'basionyme');
$champs_api = array_merge($champs_api, $champs_supp);
foreach ($champs_demandes as $champ) {
if (array_key_exists($champ, $champs_api)) {
$champs_verifies[] = $champs_api[$champ];
}
}
if (count($champs_verifies) > 0) {
$this->requete_champ .= ', '.implode(',', $champs_verifies);
}
}
 
/** Permet de rajouter à la requete sql le parametre distinct. N'est utilisé qu'avec le format oss */
public function ajouterNomDistinct($distinct) {
if (isset($distinct)) {
if ($distinct == 1 && $this->parametres['retour.format'] == 'oss') {
$this->distinct = ' distinct ';
} elseif ($distinct == 1 && $this->parametres['retour.format'] != 'oss') {
$e = 'Erreur dans votre requête </br> L\'utilisation du paramètre distinct ne se fait que sous
le format oss';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
}
 
//-----------------FONCTION D'ANALYSE DES RESSOURCES--------------------------------------------------------------------
 
public function traiterRessourcesIdentifiant() {
//on initialise la condition de la requete sql et le format de réponse
$this->requete_condition = array(); //on vide la table dans le cas de plusieurs version
$this->requete_condition[] = 'num_nom = '.$this->getBdd()->proteger($this->ressources[0]);
$this->format_reponse = $this->service.'/id';
if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
if ($this->ressources[1] == 'relations') {
$this->traiterRessourceIdRelations();
} else {
$e = 'Erreur dans votre requête </br> Ressources disponibles : <br/>
<li> noms/#id/relations </li> <li> noms/#id/#champ+#champ </li>
<li> noms/#id/relations/synonymie </li> <li> noms/#id/relations/flores </li>
<li> noms/#id/relations/homonymie </li>';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
} else { // requete de type noms/#id : rajout du nom_sci pour récupérer le format html par la fct mettreAuFormat()
$this->requete_champ = ' *, nom_sci ';
}
}
 
public function traiterRessourceRelations() {
$this->format_reponse .= '/relations';
$projet = $this->ressources[1];
$num_nom = $this->ressources[2];
if (strrpos($num_nom, 'nn.coste') !== false) {
list($p, $nn) = explode('=', $num_nom);
$num_nom = $nn;
}
$champ = "flore_$projet"."_num";
if (isset($this->ressources[3])) {
$type = $this->ressources[3];
if (!in_array($type, array('homonymie', 'synonymie', 'flores'))) {
$e = "Les types disponibles pour les noms sont homonymie, synonymie et flores";
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
$this->requete_champ = ' num_nom ';
$this->requete_condition = array();
$this->requete_condition[] = "$champ = ".$this->getBdd()->proteger($num_nom);
}
 
public function traiterRessourceIdRelations() {
$this->format_reponse .= '/relations';
if (isset($this->ressources[2]) && !empty($this->ressources[2])) {
// requete de type noms/#id/relations/#relation
switch ($this->ressources[2]) {
case 'synonymie' :
$this->traiterRessourceIdSynonymie();
break;
case 'flores' :
$this->traiterRessourceIdFlores();
break;
case 'homonymie' :
$this->traiterRessourceIdHomonymie();
break;
default :
$e = 'Erreur dans votre requête </br> Ressources disponibles : <br/>
<li> noms/#id/relations </li> <li> noms/#id/relations/synonymie </li>
<li> noms/#id/relations/flores </li> <li> noms/#id/relations/homonymie </li>';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
break;
}
}
}
 
public function traiterRessourceIdSynonymie() {
// SELECT num_nom, nom_sci, num_nom_retenu, basionyme FROM bdtfx_v2_00 WHERE num_nom = X LIMIT 0,100;
$this->format_reponse .= '/synonymie';
if (strrpos($this->requete_champ, ', basionyme') === false) {
$this->requete_champ .= ', basionyme ';
}
if (strrpos($this->requete_champ, ', num_type') === false) {
$this->requete_champ .= ', num_type ';
}
$this->requete_condition[0] = 'num_nom_retenu = '.
'(SELECT num_nom_retenu FROM '.$this->table.' WHERE '.$this->requete_condition[0].')';
}
 
public function traiterRessourceIdHomonymie() {
// SELECT num_nom, nom_sci, num_nom_retenu FROM bdtfx_v2_00 WHERE nom_sci = (SELECT nom_sci FROM bdtfx_v2_00 WHERE num_nom = X);
$this->format_reponse .= '/homonymie';
$this->requete_condition[0] = 'nom_sci = (SELECT nom_sci FROM '.$this->table
.' WHERE '.$this->requete_condition[0].')';
}
 
public function traiterRessourceIdFlores() {
$champ_flores = '';
foreach ($this->champs_table as $champ) {
if (preg_match('/^flore_.*$/', $champ)) {
$champ_flores .= ', '.$champ;
}
}
$this->format_reponse .= '/flores';
$this->requete_champ = 'num_nom'.$champ_flores;
}
 
public function traiterRessourceStatsRangs() {
// SELECT count(*) as nombre, rang FROM bdtfx_v2_00 [WHERE rang = 290] GROUP BY rang ORDER BY rang;
$this->format_reponse .= '/rangs';
$this->requete_champ = 'count(*) as nombre, rang ';
$this->requete_group_by = ' GROUP BY rang ORDER BY rang ';
}
 
public function traiterRessourceStatsAnnees() {
// SELECT count(*) as nombre, annee FROM bdtfx_v2_00 GROUP BY annee ORDER BY annee;
$this->format_reponse .= '/annees';
$this->requete_champ = 'count(*) as nombre, annee ';
$this->requete_condition = null;
$this->requete_group_by = ' GROUP BY annee ORDER BY annee ';
}
 
public function traiterRessourceStatsInitiales() {
// SELECT count(left( nom_sci, 2 )) as nb, rang, left(nom_sci, 2) as lettre GROUP BY rang, left(nom_sci, 2);
$this->format_reponse .= '/initiales';
$this->requete_champ = 'count(left( nom_sci, 2 )) as nb, rang, left(nom_sci, 2) as lettre ';
$this->requete_group_by = ' GROUP BY rang, left(nom_sci, 2)';
}
 
 
 
//-----------------------------FONCTIONS DASSEMBLAGE DE LA REQUETE-----------------------------------------------------
 
public function assemblerLaRequete() {
if ( strrpos($this->format_reponse, 'noms/stats/') === false ) {
$this->mettreAuFormat(); //Ds CommunNomsTaxons.php
}
$requete = 'SELECT '.$this->retournerChamps().' '.
"FROM {$this->table} ".
$this->retournerRequeteCondition().' '.
$this->requete_group_by.' '.
$this->retournerOrderBy().' '.
$this->formerRequeteLimite() .
' -- ' . __FILE__ . ':' . __LINE__ ;
return $requete;
}
 
public function retournerChamps() {
$sql = '';
if ($this->distinct) {
$sql .= $this->distinct.' ';
}
if ($this->requete_champ) {
$sql .= $this->requete_champ.' ';
}
 
// Champs "virtuels" pour tier sur l'ensemble des résultats
if (isset($this->parametres['retour.tri'])) {
list($champ, $ordre) = $this->decouperParametreRetourTri();
if ($champ == 'retenu') {
$sql .= ", IF(num_nom = num_nom_retenu, '0', '1') AS nom_retenu_tri ";
}
}
 
return $sql;
}
 
public function decouperParametreRetourTri() {
$tri = array('', '');
if (isset($this->parametres['retour.tri'])) {
if (preg_match('/^(retenu)(?:,(ASC|DESC)|)$/', $this->parametres['retour.tri'], $match))
$tri[0] = $match[1];
$tri[1] = isset($match[2]) ? $match[2] : '';
}
return $tri;
}
 
public function retournerRequeteCondition() {
$condition = '';
if ($this->requete_condition) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
public function retournerOrderBy() {
$orderBy = array();
 
// Tri sur l'ensemble des résultats
if (isset($this->parametres['retour.tri'])) {
list($champ, $ordre) = $this->decouperParametreRetourTri();
if ($champ == 'retenu') {
$orderBy[] = "nom_retenu_tri $ordre";
}
}
// Tri par défaut
if ($this->format_reponse == 'noms') {
$orderBy[] = 'nom_sci ASC';
}
 
$sql = '';
if (count($orderBy) > 0) {
$sql = 'ORDER BY '.implode(', ', $orderBy).' ';
}
return $sql;
}
 
public function formerRequeteLimite() {
if ($this->format_reponse != 'noms' && $this->format_reponse != 'noms/id/relations/synonymie'
&& $this->format_reponse != 'noms/id/relations/homonymie') {
$this->requete_limite = '';
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) {
$this->limite_requete['depart'] =
(($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']);
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
} else {
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
}
return $this->requete_limite;
}
 
/** Recupere le nombre total de résultat d'une requete lancée. */
public function recupererTotalResultat() {
$total = null;
$requete = 'SELECT count(*) as nombre FROM '.$this->table.$this->retournerRequeteCondition().$this->requete_group_by;
$res = $this->getBdd()->recuperer($requete);
if ($res) {
$total = $res['nombre'];
} else {
$e = 'Fct recupererTotalResultat() : <br/>Données introuvables dans la base';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
}
return $total;
}
 
 
//-------------------FONCTIONS POUR LE FORMATAGE EN JSON----------------------------------------------------------------
 
public function retournerResultatFormate($resultat) {
 
switch ($this->format_reponse) {
case 'noms/relations' :
$reponse = $this->formaterRelations($resultat[0]);
break;
case 'noms/id' : //ds CommunNomsTaxons
$reponse = $this->formaterId($resultat[0]);
break;
case 'noms/id/relations' :
$reponse = $this->formaterIdRelations($resultat[0]);
break;
case 'noms/id/relations/synonymie' :
$reponse = $this->formaterIdSynonymie($resultat);
break;
case 'noms/id/relations/homonymie' :
$reponse = $this->formaterIdHomonymie($resultat);
break;
case 'noms/id/relations/flores' : //ds CommunsNomsTaxons
$reponse = $this->formaterIdFlores($resultat[0]);
break;
case 'noms/stats/annees' : //ds CommunNomsTaxons
$reponse = $this->formaterStatsAnnee($resultat);
break;
case 'noms/stats/rangs' : //ds CommunNomsTaxons
$reponse = $this->formaterStatsRang($resultat);
break;
case 'noms/stats/initiales' : //ds CommunNomsTaxons
$reponse = $this->formaterStatsInitiales($resultat);
break;
case 'noms' :
$reponse = $this->formaterNoms($resultat);
break;
}
return $reponse;
}
 
//+---------------------concerne les resultats pour des requetes de type noms/id-----------------------------+
 
public function formaterRelations($resultat) {
$num_nom = $resultat['num_nom'];
if (isset($this->ressources[3])) {
$url = Config::get('url_service').$this->service."/$num_nom/relations";
} else {
$type = $this->ressources[3];
$url = Config::get('url_service')."/$this->service/$num_nom/relations/$type";
}
$res = $this->consulterHref($url);
return $res;
}
 
public function formaterIdRelations($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$this->resultat_req = $resultat;
$retour_id_rel = array ('entete' => array()); //on initialise pr que l'entete apparaisse en premier lors de l'affichage
 
//on recupère le resultat de chaque relation (appel du WS correspondant)
$flores = $this->ajouterRelations('flores');
if (isset($flores)) $retour_id_rel['resultat']['flores'] = $flores;
$homonymes = $this->ajouterRelations('homonymie');
if (isset($homonymes)) $retour_id_rel['resultat']['homonymes'] = $homonymes;
$synonymes = $this->ajouterRelations('synonymie');
if (isset($synonymes)) $retour_id_rel['resultat']['synonymes'] = $synonymes;
 
//on renvoit null si il n'existe aucune relations (on efface l'entete en premier lieu)
if (!isset($retour_id_rel['resultat'])) {
$retour_id_rel = null;
} else { //on rajoute l'entete si des relations existent
$this->afficherDonnees('num_nom', $this->ressources[0]);
$retour_id_rel['entete'] = $this->table_retour;
$this->table_retour = array();
}
return $retour_id_rel;
}
 
/**
* Recupere les relations (type de la relation passée en paramètres :[type_relation] = synonymie, homonymie ou
* flores) par l'appel du web service [version]/noms/#id/relations/[type_relation]
*/
public function ajouterRelations($relation) {
$version = str_replace(Config::get('bdd_table').'_', '', $this->table);
$res = null;
$parametres_url = '';
if ($this->parametres != array()) $parametres_url = '?'.http_build_query($this->parametres, '', '&');
$url = Config::get('url_service').'/'.$this->service.'/'
.$this->ressources[0].'/relations/'
.$relation.$parametres_url; Debug::printr($url);
 
$relation = $this->consulterHref($url);
 
$res = $relation->resultat;
return $res;
}
 
 
public function formaterIdSynonymie($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$retour_id_syn = array();
if ($resultat[0]['num_nom_retenu'] == '') return array('nom_retenu N.D.');
 
// 1 ou + résultat(s)
$retour_id_syn['entete'] = $this->afficherEnteteResultat('/'.$this->service.'/'.$this->ressources[0].'/relations/synonymie');
$retour_id_syn['entete']['id'] = $this->ressources[0];
$retour_id_syn['resultat'] = array();
 
// résultat contient aussi l'original
if(count($resultat) > 1) {
//on remplit d'abord l'entete du resultat
foreach ($resultat as $tab) {
//pour chaque basionyme, on recupère le résultat : num_nom, nom_sci, basionyme et num_nom_retenu :
$this->resultat_req = $tab;
$num = $tab['num_nom'];
$this->afficherNomHrefRetenu($tab, $num);
$this->afficherDonnees('basionyme', $tab['basionyme']);
$this->afficherDonnees('num_type', $tab['num_type']);
$retour_id_syn['resultat'][$num] = $this->table_retour;
$this->table_retour = array();
}
if (!isset($retour_id_syn['resultat']) && !in_array('nom_retenu N.D.', $retour_id_syn)) {
$retour_id_syn = null; //on initialise le resultat à null
}
}
return $retour_id_syn;
}
 
public function formaterIdHomonymie($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
if (count($resultat) != 1) {
$this->table_retour['id'] = $this->ressources[0];
$this->afficherEnteteResultat($resultat, '/'.$this->service.'/'.$this->ressources[0].'/relations/homonymie');
$retour_id_hom['entete'] = $this->table_retour;
$this->table_retour = array();
foreach ($resultat as $homonyme) {
$this->resultat_req = $homonyme;
$id = $homonyme['num_nom'];
$this->afficherDonnees('num_nom', $id);
if ($homonyme['num_nom_retenu'] != '') {
$retenu = ($id == $homonyme['num_nom_retenu']) ? 'true' : 'false';
} else {
$retenu = 'absent';
}
$this->table_retour['retenu'] = $retenu;
$retour_id_hom['resultat'][$id] = $this->table_retour;
unset($retour_id_hom['resultat'][$id]['id']);
$this->table_retour = array();
}
} else {
$retour_id_hom = null;
}
return $retour_id_hom;
}
 
public function obtenirSynonymesParNumNomAvecInfosFlore($num_nom, $version='1_02') {
 
$champs_flore = 'flore_bonnier_num, flore_bonnier_rem,'.
'flore_cnrs_num, flore_cnrs_rem '.
'flore_fe_num, flore_fe_rem '.
'flore_coste_num, flore_coste_rem '.
'flore_fh_num, flore_fh_rem '.
'flore_fournier_num, flore_fournier_rem';
 
$requete = 'SELECT num_nom, nom_sci, '.$champs_flore.' '.
'FROM '.$this->table.' '.
'WHERE num_nom_retenu = '.
'('.
'SELECT num_nom_retenu FROM '.$this->table.' WHERE num_nom = "'.$num_nom.'"'.
')';
 
return $this->getBdd()->recupererTous($requete . ' -- ' . __FILE__ . ':' . __LINE__ );
}
 
public function formaterIdFlores($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp,noms_projets');
$this->resultat_req = $resultat;
$id = array_shift($resultat);
$reponse['entete']['id'] = $id;
$synonymes_flores = $this->obtenirSynonymesParNumNomAvecInfosFlore($this->ressources[0]);
if(is_array($synonymes_flores)) {
foreach ($synonymes_flores as $synonyme) {
$nom_sci = $synonyme['nom_sci'];
$num_nom = $synonyme['num_nom'];
unset($synonyme['nom_sci']);
unset($synonyme['num_nom']);
foreach ($synonyme as $flores => $valeur) {
if ($valeur != '' && $valeur != '0') {
$this->afficherInfosFlore($synonyme, $flores, $valeur, $nom_sci, $num_nom);
}
}
}
}
 
if ($this->table_retour != array()) {
$reponse['resultat'] = $this->table_retour;
$this->table_retour = array();
} else {
$reponse = null;
}
return $reponse;
}
 
public function getNomCompletFlore($flore) {
return Config::get($flore.'_texte');
}
 
public function afficherInfosFlore(&$resultat, $flores, $valeur, $nom_sci, $num_nom) {
$flore = substr($flores,0,strrpos($flores, '_'));
$projet = $this->noms_projets[$flore];
 
//TODO voir si l'on peut factoriser les affectations à la table retour
// et simplifier ce gros pavé
if (strrpos($flores, 'num') !== false) {
if (preg_match('/^([0-9]+)(?:[.]syn[^a-z]*|(.*))?$/', $valeur, $match)) {
$this->table_retour[$num_nom][$flore]['id'] = $match[1];
if ($projet == 'coste') {
$this->table_retour[$num_nom][$flore]['href'] = $this->ajouterHrefAutreProjet('noms', 'nn_coste:', $match[1], $projet);
}
if (isset($match[2]) && $match[2] != '') $this->table_retour[$num_nom][$flore]['cle'] = $match[2];
$this->table_retour[$num_nom][$flore]['nom_flore'] = $this->getNomCompletFlore($flore);
$this->table_retour[$num_nom][$flore]['nom_sci'] = $nom_sci;
}
if (isset($resultat[$flore.'_rem']) && !empty($resultat[$flore.'_rem'])) {
$this->table_retour[$num_nom][$flore]['remarque'] = $resultat[$flore.'_rem'];
$this->table_retour[$num_nom][$flore]['nom_flore'] = $this->getNomCompletFlore($flore);
$this->table_retour[$num_nom][$flore]['nom_sci'] = $nom_sci;
unset($resultat[$flore.'_rem']);
}
} elseif (strrpos($flores,'belge') !== false) {
if (preg_match('/^([0-9]+) (R|S)?$/', $valeur, $match)) {
if (isset($match[2])) $type = ($match[2] == 'R') ? 'taxons' : 'synonyme';
$this->table_retour[$num_nom][$flore]['page'] = $match[1];
$this->table_retour[$num_nom][$flore]['type'] = $type;
$this->table_retour[$num_nom][$flore]['nom_flore'] = $this->getNomCompletFlore($flore);
$this->table_retour[$num_nom][$flore]['nom_sci'] = $nom_sci;
}
}
}
 
//+---------------------concerne les resultats pour des requetes de type /noms avec ou sans paramètres-------+
 
public function formaterNoms($resultat) {
if ($this->parametres['retour.format'] == 'oss') {
$reponse = $this->formaterEnOss($resultat); //Ds CommunNomsTaxons.php
} else {
$reponse = $this->formaterEnJsonMax($resultat);
}
return $reponse;
}
 
public function formaterEnJsonMax($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
 
// TODO : améliorer le tri des résultats
// ATTENTION : ce comportement est étrange
$masque = $this->recupererMasquePrincipal();
if ($masque && isset($this->parametres[$masque[0]] /* à éclaircir */ ) && !isset($this->parametres['retour.tri'])) {
$resultat = $this->trierRechercheFloue($this->parametres[$masque[0]], $resultat, $masque[1]);
}
 
$table_retour_json['entete'] = $this->afficherEnteteResultat('/'.$this->service);
$table_retour_json['resultat'] = $this->remplirJsonResultat($resultat);
return $table_retour_json;
}
 
public function remplirJsonResultat($resultat) {
$champs = null;
if (array_key_exists('retour.champs', $this->parametres)) {
$champs = explode(',', $this->parametres['retour.champs']);
}
 
$noms = array();
foreach ($resultat as $tab) {
$this->table_retour = array();
$num = $tab['num_nom'];
$this->afficherNomHrefRetenu($tab, $num); // ajoute le nom_sci, href et si le nom est retenu dans $this->table_retour
$retour = $this->table_retour;
$this->table_retour = array();
if ($champs != null) {
$reponse_id = $this->formaterId($tab);
$this->table_retour = array();
$this->ajouterChampsPersonnalises($champs, $reponse_id);
$retour = array_merge($retour, $this->table_retour);
}
$noms[$num] = $retour;
}
 
return $noms;
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/bdtfx/Taxons.php
New file
0,0 → 1,522
<?php
 
// declare(encoding='UTF-8');// ou ISO-8859-15
/**
* Description :
* Classe Taxons.php permettant de fournir des informations sur les noms scientifiques retenu.
* Si l'url finit par /taxons on retourne une liste de noms latin et leurs identifiants (seulement les 100 premeiers noms par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /taxons?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, recherche, rang, distinct, retour.format, nl.format,
* nl.structure, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 1.0
* @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org)
*/
 
 
class Taxons extends CommunNomsTaxons {
/** Permet de stocker la requete formulée taxons | taxons/#id | taxons/#id/#champ+#champ ...*/
protected $format_reponse = 'taxons';
protected $service = 'taxons';
protected $requete_champ = 'num_nom, nom_sci, num_nom_retenu, num_taxonomique ';
protected $requete_condition = null;
protected $requete_group_by = ' ';
/** Permet de stocker les limite de la requete SQL (par défaut seul les 100 premiers résultats seront retournés).*/
protected $limite_requete = array('depart' => 0, 'limite' => 100);
protected $num_nom_taxon; //Stocke le num_nom du nom retenu du num_nom recherché
protected $presence_num_tax = true;
public function consulter($ressources, $parametres) {
return parent::consulter($ressources, $parametres);
}
public function traiterParametresSpecifiques() {
$this->requete_condition[] = 'num_nom = num_nom_retenu';
foreach ($this->parametres as $param => $val) {
switch ($param) {
case 'masque' :
$this->ajouterFiltreMasque('nom_sci', $val);
break;
case 'masque.nt' :
$this->requete_condition[] = "num_taxonomique IN ($val)";
$this->masque[] = "num_tax=$val";
break;
case 'masque.rg':
$this->requete_condition[] = 'rang = '.$this->getBdd()->proteger($val);
$this->masque[] = "rang=$val";
break;
}
}
}
//------------------------------------------Fonction ressources---------------------------------------------------------------------
public function gererNumTax() {
if (!in_array('num_taxonomique', $this->champs_table)) {
$this->presence_num_tax = false;
$this->requete_champ = str_replace(', num_taxonomique ', '', $this->requete_champ);
} else {
$this->presence_num_tax = true;
}
}
public function traiterRessourcesIdentifiant() {
$this->format_reponse = 'taxons/id';
$this->traiterRessourceNtId();
$this->num_nom_taxon = $this->recupererNumNomTaxon(); //on recupere le taxon correspondant au num_nom recherché
if ($this->entete_http == '') {
$this->requete_condition[0] = 'num_nom = '.$this->getBdd()->proteger($this->num_nom_taxon);
if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
//---------------- requete de type taxons/#id/#champ+#champ--------------------------------------
if ($this->ressources[1] != 'relations') { // SELECT *, nom_sci FROM bftfx_v2_00 WHERE num_nom = X;
$this->requete_champ = ' *, nom_sci ';
$this->format_reponse .= '/champ';
//---------------- requete de type taxons/#id/relations/#relation--------------------------------
} elseif ($this->ressources[1] == 'relations') {
$this->traiterRessourceIdRelations();
} else {
$e = 'Erreur dans votre requête </br> Ressources disponibles : <br/>
<li> #id/relations </li> <li> #id/#champ+#champ </li> <li> #id/relations </li>
<li> #id/relations/inferieurs </li> <li> #id/relations/superieurs </li>';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
} else { //--------------- requete de type taxons/#id-----------------------------------------------------
$this->requete_champ = ' *, nom_sci ';
}
}
}
public function traiterRessourceNtId() {
if (strrpos($this->ressources[0], 'nt:') !== false) {
if ($this->presence_num_tax) {
// SELECT num_nom FROM bdtfx_v2_00 WHERE num_nom = num_nom_retenu AND num_taxonomique = X;
$this->requete_condition[0] = ' num_taxonomique = '
.str_replace('nt:', '', $this->ressources[0]).' ';
} else {
$e = 'Erreur dans votre requête : </br> Le numéro taxonomique n\'existe pas dans ce projet';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
} else {
// SELECT num_nom FROM bdtfx_v2_00 WHERE num_nom = (SELECT num_nom_retenu FROM bdtfx_v2_00 WHERE num_nom = X);
$this->requete_condition[0] = 'num_nom = '.$this->ressources[0];
}
}
/** Permet de récupérer le num_nom du taxon recherché. Soit le numéro taxonomique est demandé (avec nt: )
* soit un num_nom dont on recherche le num_nom_retenu */
public function recupererNumNomTaxon() {
$identifiant = '';
if ($this->entete_http == '') {
//on récupere l'identifiant du taxon correspondant au num_nom ou num_taxonomique demandé pour pouvoir l'afficher
$req_tax = 'SELECT num_nom_retenu FROM '.$this->table.' WHERE '.$this->requete_condition[0];
$res_tax = $this->getBdd()->recuperer($req_tax . ' -- ' . __FILE__ . ':' . __LINE__ );
//on recherche ensuite les identifiants des taxons supérieurs ou inférieurs
if ($res_tax && $res_tax != '') {
$identifiant = $res_tax['num_nom_retenu'];
} else {
$e = 'Le numéro de taxon ou l\'identifiant de nom correspondant au num_nom '
.$this->ressources[0].' n\'existe pas dans la base.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
Debug::printr($req_tax);
}
}
return $identifiant;
}
public function traiterRessourceIdRelations() {
//----------------- requete de type taxons/#id/relations-------------------------------------------
// SELECT *, nom_sci FROM bftfx_v2_00 WHERE num_nom = X;
$this->format_reponse .= '/relations';
if (isset($this->ressources[2]) && !empty($this->ressources[2])) {
//------------- requete de type taxons/#id/relations/#relation--------------------------------
switch ($this->ressources[2]) {
case 'superieurs' :
$rel = 'recupererIdSup';
$this->format_reponse .= '/superieurs';
$this->traiterRessourceIdRelationInfSup($rel);
break;
case 'inferieurs' :
$rel = 'recupererIdInf';
$this->format_reponse .= '/inferieurs';
$this->traiterRessourceIdRelationInfSup($rel);
break;
case 'hierarchie' :
$rel = 'recupererIdHierarchie';
$this->format_reponse .= '/hierarchie';
$this->traiterRessourceIdRelationHierarchie($rel);
break;
default :
$e = 'Erreur dans votre requête </br> Ressources disponibles : <br/>
<li> taxons/#id/relations </li><li> #id/relations/inferieurs </li>
<li> #id/relations/superieurs </li>';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
break;
}
}
}
public function traiterRessourceIdRelationInfSup($rel) {
//Appel de la fct récupérerIdSup ou recupererIdInf : retourne les num_nom des noms inferieurs ou superieurs
$res_relation = $this->$rel();
//analyse du résultat retourné par la requete de recherche des identifiants correspondant aux taxons inf|sup :
if ($res_relation == '') { //dans le cas ou la requete comporte des erreurs
$e = 'Fct traiterRessourceIdRelationInfSup : La requête forme comporte une erreur!';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
} elseif ($res_relation) {
//dans le cas ou une ou plusieurs relations est retournée, on récupère les identifiants ss la forme (id, id, id)
foreach ($res_relation as $ligne) $res[] = $ligne['num_nom'];
$res = implode(',',$res);
$this->requete_condition[0] = "num_nom IN ($res)";
$this->requete_champ .= ', rang, num_tax_sup ';
} else { //dans le cas ou aucune relation n'existe
$res = array($this->num_nom_taxon => null);
$this->corps_http = json_encode($res);
$this->entete_http = RestServeur::HTTP_CODE_OK;
}
}
public function traiterRessourceIdRelationHierarchie($rel) {
//Appel de la fct récupérerIdSup ou recupererIdInf : retourne les num_nom des noms inferieurs ou superieurs
$res_relation = $this->$rel();
//analyse du résultat retourné par la requete de recherche des identifiants correspondant aux taxons inf|sup :
if ($res_relation == '') {
//dans le cas ou la requete comporte des erreurs
$e = 'Fct traiterRessourceIdRelationInfSup : La requête forme comporte une erreur!';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
} elseif ($res_relation) {
//dans le cas ou une ou plusieurs relations est retournée, on récupère les identifiants ss la forme (id, id, id)
foreach ($res_relation as $ligne) $res[] = $ligne['num_nom'];
$res = implode(',',$res);
$this->requete_condition[0] = "num_nom IN ($res)";
$this->requete_champ .= ', rang, num_tax_sup ';
} else { //dans le cas ou aucune relation n'existe
$res = array($this->num_nom_taxon => null);
$this->corps_http = json_encode($res);
$this->entete_http = RestServeur::HTTP_CODE_OK;
}
}
public function recupererIdHierarchie() {
$req_relation = 'SELECT num_nom FROM '.$this->table.' '.
' WHERE hierarchie LIKE CONCAT('.
'(SELECT hierarchie FROM '.
$this->table.' '.
'WHERE num_nom = '.$this->getBdd()->proteger($this->num_nom_taxon).')'.
', '.$this->getBdd()->proteger($this->num_nom_taxon.'-%').
')';
$res_relation = $this->getBdd()->recupererTous($req_relation . ' -- ' . __FILE__ . ':' . __LINE__ );
return $res_relation;
}
public function recupererIdInf() {
//SELECT num_nom FROM bfdtx_v2_00 WHERE num_tax_sup = (SELECT num_nom FROM bdtfx_v2_00 WHERE num_nom = X);
$req_relation = 'SELECT num_nom FROM '.$this->table
.' WHERE num_nom = num_nom_retenu AND num_tax_sup = (SELECT num_nom FROM '
.$this->table
.' WHERE '.implode(' AND ', $this->requete_condition).')';
$res_relation = $this->getBdd()->recupererTous($req_relation . ' -- ' . __FILE__ . ':' . __LINE__ );
return $res_relation;
}
public function recupererIdSup() {
//SELECT num_nom FROM bfdtx_v2_00 WHERE num_nom = (SELECT num_tax_sup FROM bdtfx_v2_00 WHERE num_nom = X);
$this->requete_condition[] = "num_nom = num_nom_retenu" ;
$req_relation = 'SELECT num_tax_sup as num_nom FROM '.$this->table
.' WHERE '.implode(' AND ', $this->requete_condition);
$res_relation = $this->getBdd()->recupererTous($req_relation . ' -- ' . __FILE__ . ':' . __LINE__ );
return $res_relation;
}
 
public function traiterRessourceStatsInitiales() {
// SELECT count(nom_sci) as nb, rang, left(nom_sci, 2) as lettre FROM bdtfx_v2_00 GROUP BY rang, left(nom_sci, 2);
$this->format_reponse = 'taxons/stats/initiales';
$this->requete_champ = 'count(nom_sci) as nb, rang, left(nom_sci, 2) as lettre ';
$this->requete_group_by = ' GROUP BY rang, left(nom_sci, 2) ';
}
public function traiterRessourceStatsRangs() {
// SELECT count(*) as nombre, rang FROM bdtfx_v2_00 [WHERE rang = 290] GROUP BY rang ORDER BY rang;
$this->format_reponse = 'taxons/stats/rangs';
$this->requete_champ = 'count(*) as nombre, rang ';
$this->requete_group_by = ' GROUP BY rang ORDER BY rang ';
}
public function traiterRessourceStatsAnnees() {
// SELECT count(*) as nombre, annee FROM bdtfx_v2_00 GROUP BY annee ORDER BY annee;
$this->format_reponse = 'taxons/stats/annees';
$this->requete_champ = 'count(*) as nombre, annee ';
$this->requete_group_by = ' GROUP BY annee ORDER BY annee ';
}
//-----------------------------FONCTIONS DASSEMBLAGE DE LA REQUETE-----------------------------------------------------
public function assemblerLaRequete() {
if ($this->format_reponse != 'taxons/stats/initiales') {
$this->mettreAuFormat(); //on remplace les nom_sci par les nom_sci_html
}
$requete = ' SELECT '.$this->requete_champ.
' FROM '.$this->table
.$this->retournerRequeteCondition()
.$this->requete_group_by
.$this->formerRequeteLimite() .
' -- ' . __FILE__ . ':' . __LINE__ ;
return $requete;
}
public function formerRequeteLimite() {
if ($this->format_reponse != 'taxons' && $this->format_reponse != 'taxons/id/relations/homonymie') {
$this->requete_limite = '';
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) {
$this->limite_requete['depart'] = (($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']);
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
} else {
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
}
return $this->requete_limite;
}
public function retournerRequeteCondition() {
$condition = '';
if ($this->requete_condition) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
public function recupererTotalResultat() {
$requete = 'SELECT count(*) as nombre FROM '.$this->table.$this->retournerRequeteCondition().$this->requete_group_by;
$res = $this->getBdd()->recuperer($requete);
if ($res) {
$total = $res['nombre'];
}
return $total;
}
 
//-------------------------FONCTIONS DE FORMATION DU RESULTAT-----------------------------------------------------------
/** Permet de récupérer le résultat à retourner propre à chaque requete et de l'encoder en json*/
public function retournerResultatFormate($resultat, $version) {
$reponse = null;
switch ($this->format_reponse) {
case 'taxons/id' ://ds CommunNomsTaxons
$reponse = $this->formaterId($resultat[0]);
break;
case 'taxons/id/champ' ://ds CommunNomsTaxons
$reponse = $this->formaterIdChamp($resultat[0]);
break;
case 'taxons/id/relations' :
$reponse = $this->formaterIdRelations($resultat[0],$version);
break;
case 'taxons/id/relations/superieurs' :
$reponse = $this->formaterIdSuperieur($resultat, $version);
break;
case 'taxons/id/relations/inferieurs' :
$reponse = $this->formaterIdInferieur($resultat);
break;
case 'taxons/id/relations/hierarchie' :
// le formatage de la hiérarchie est identique aux relations inférieures
$reponse = $this->formaterIdInferieur($resultat);
break;
case 'taxons/stats/annees' : //ds CommunNomsTaxons
$reponse = $this->formaterStatsAnnee($resultat);
break;
case 'taxons/stats/rangs' ://ds CommunNomsTaxons
$reponse = $this->formaterStatsRang($resultat);
break;
case 'taxons/stats/initiales' ://ds CommunNomsTaxons
$reponse = $this->formaterStatsInitiales($resultat);
break;
case 'taxons' :
$reponse = $this->formatertaxons($resultat);
break;
}
return $reponse;
}
//----------------------concerne les resultats pour des requetes de type /noms avec ou sans paramètres--------------
public function formaterTaxons($resultat) {
if ($this->parametres['retour.format'] == 'oss') {
$reponse = $this->formaterEnOss($resultat);
} else {
$reponse = $this->formaterEnJsonMax($resultat);
}
return $reponse;
}
public function formaterEnJsonMax($resultat) {
//print_r($resultat);
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$masque = $this->recupererMasquePrincipal();
if (isset($masque)) $resultat = $this->trierRechercheFloue($this->parametres[$masque[0]], $resultat, $masque[1]);
$table_retour_json['entete'] = $this->afficherEnteteResultat('/'.$this->service);
//on remplit la table $table_retour_json['resultat']
$tab_tax_inf = $this->recupererListeTaxonInf($resultat);
foreach ($resultat as $tab) {
$num = $tab['num_nom'];
if (isset($this->parametres['masque.nt'])) $this->afficherDonnees('num_taxonomique', $tab['num_taxonomique']);
$this->afficherNomHrefRetenu($tab, $num);
$this->afficherTaxonInfNb($num, $tab_tax_inf);
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array(); //on vide le tableau table_retour
}
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
//--------------------concerne les resultats pour des requetes de type noms/id----------------------------------------
 
public function formaterIdRelations($resultat, $version) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$this->resultat_req = $resultat;
$retour_id_rel = array ('entete' => array()); //on initialise pr que l'entete apparaisse en premier
 
$superieurs = $this->ajouterRelations('superieurs'); //, $version);
if (isset($superieurs)) $retour_id_rel['resultat']['superieurs'] = $superieurs;
$inferieurs = $this->ajouterRelations('inferieurs', $version);
if (isset($inferieurs)) $retour_id_rel['resultat']['inferieurs'] = $inferieurs;
if (!isset($retour_id_rel['resultat'])) { //on renvoit un tableau null si il n'existe aucune relations
$retour_id_rel = 'null';
} else { //on rajoute l'entete si des relations existent
$this->afficherDonnees('num_nom', $this->num_nom_taxon); //$this->afficherEnteteResultat($resultat, '/'.$this->service.'/'.$this->ressources[0].'/relations/synonymie');
$retour_id_rel['entete'] = $this->table_retour;
$this->table_retour = array();
}
return $retour_id_rel;
}
public function ajouterRelations($relation, $version) {
$version = str_replace(Config::get('bdd_table').'_', '', $version);
$res = null;
$taxon = $this->num_nom_taxon;
$parametres_url = '';
if ($this->parametres != array()) $parametres_url = '?'.http_build_query($this->parametres, '', '&');
$url = Config::get('url_service').'/'
.$this->service.'/'.$version.'/'
.$this->ressources[0].'/relations/'
.$relation.$parametres_url;
$relation = $this->consulterHref($url);
if (isset($relation->resultat)) {
$res = $relation->resultat;
} elseif (isset($relation->$taxon)) { //pour les relations inf et sup
$res = $relation->$taxon;
}
return $res;
}
public function formaterIdSuperieur($resultat, $version) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$tab_relation = null; //si il n'existe aucune relation
$taxon_sup_traites = array();
if (($resultat) != '' ) {
//on recupere d'abord les rangs supérieurs
$sup = $resultat[0];
do {
$sup = $this->recupererIdSuperieur($sup['num_tax_sup'], $version);
if(!in_array($sup['num_nom'], $taxon_sup_traites)) {
$taxon_sup_traites[] = $sup['num_nom'];
} else {
$sup = null;
}
if ($sup['rang'] == '0') $sup['rang'] = '10'; //erreur dans la base
if (isset($sup)) $resultat[] = $sup;
} while ($sup != null);
krsort($resultat);
//on les affiche ensuite
foreach ($resultat as $tab) {
$this->resultat_req = $tab;
$num = $tab['num_nom'];
$this->afficherNomHrefRetenu($tab, $num);
$this->afficherDonnees('rang', $tab['rang']);
$tab_inf[$num] = $this->table_retour;
$tab_inf[$num]['num_nom'] = $tab['num_nom'];
$this->table_retour = array();
}
$tab_relation[$this->num_nom_taxon] = $tab_inf;
}
return $tab_relation;
}
public function recupererIdSuperieur($id, $version) {
$req = 'SELECT num_nom, num_nom_retenu, num_tax_sup, rang, nom_sci FROM '
.$version.' WHERE num_nom = '.$this->getBdd()->proteger($id);
$res = $this->getBdd()->recupererTous($req . ' -- ' . __FILE__ . ':' . __LINE__ );
if ($res) {
$resultat = $res[0];
} else {
$resultat = null; //on return null si il n'y a pas de taxon superieur
}
return $resultat;
}
public function formaterIdInferieur($resultat) {
// Attention à l'ordre, on doit d'abord récupérer correpondance_champs avant champs_api
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$tab_relation = null;
if (($resultat) != array()) {
foreach ($resultat as $tab) {
$this->resultat_req = $tab;
$num = $tab['num_nom'];
$this->afficherNomHrefRetenu($tab, $num);
if(!empty($tab['rang'])) {
$this->afficherDonnees('rang', $tab['rang']);
}
$tab_inf[$num] = $this->table_retour;
$tab_inf[$num]['nom_sci'] = $tab['nom_sci'];
$tab_inf[$num]['num_nom'] = $tab['num_nom'];
$this->table_retour = array();
}
$tab_relation[$this->num_nom_taxon] = $tab_inf;
}
return $tab_relation;
}
public function afficherTaxonInfNb($num, $tab_tax_inf) {
foreach ($tab_tax_inf as $taxNb) {
if ($taxNb['num_tax_sup'] == $num) {
$this->table_retour['taxon_inferieur_nbre'] = $taxNb['nb'];
}
}
if (!isset($this->table_retour['taxon_inferieur_nbre'])) {
$this->table_retour['taxon_inferieur_nbre'] = '0';
}
}
public function recupererListeTaxonInf($resultat) {
// SELECT num_tax_sup, count(*) as nb FROM bdtfx_v2_00 WHERE num_tax_sup IN (id, id, id) AND num_nom = num_nom_retenu GROUP BY num_tax_sup';
foreach ($resultat as $tab) {
$tab_num[] = $tab['num_nom']; //on regroupe ici les id des taxons dont on cherche le nb de taxon inf
}
$req = 'SELECT num_tax_sup, count(*) as nb FROM '.$this->table
.' WHERE num_tax_sup IN ('.implode(',',$tab_num)
.') AND num_nom = num_nom_retenu GROUP BY num_tax_sup';
$res = $this->getBdd()->recupererTous($req . ' -- ' . __FILE__ . ':' . __LINE__ );
if ($res) {
$resultat = $res;
} else {
$resultat = array(); //on retourne un tableau vide s'il n'y a pas de taxon inférieurs
}
return $resultat;
}
}
 
?>
/tags/v5.6-arganeraie/services/modules/0.1/sptb/Statuts.php
New file
0,0 → 1,158
<?php
// declare(encoding='UTF-8');
/**
* Classe implémentant l'API d'eFlore concernant les statuts de protection
*
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Status
*
* @package eFlore/services
* @author Aurélien PERONNET <aurelien@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)
*/
// TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests...
class Statuts extends Commun {
 
protected $parametres = array();
protected $ressources = array();
private $bdd;
private $retour_format = 'complet';
private $retours_formats_autorises = array('complet','zone_geo');
 
public function __construct($config = null) {
$this->config = $config;
$this->bdd = $this->getBdd();
}
public function consulter($ressources, $parametres) {
 
$this->parametres = $parametres;
$this->ressources = $ressources;
 
$this->affecterParametresParDefaut();
$this->verifierParametres();
 
$resultat = new ResultatService();
$resultat->corps = $this->obtenirStatuts();
 
return $resultat;
}
//+---------------------------FONCTION D'ANALYSE DES PARAMETRES---------------------------------------------------------+
 
private function affecterParametresParDefaut() {
$this->retour_format = isset($this->parametres['retour.format']) ? $this->parametres['retour.format'] : $this->retour_format;
}
private function verifierParametres() {
$erreurs = array();
if (empty($this->parametres['masque.nn'])) {
$erreurs[] = 'renseignez une valeur pour masque.nn';
}
if(!is_numeric($this->parametres['masque.nn'])) {
$erreurs[] = 'la valeur pour masque.nn doit être un entier';
}
if(!in_array($this->retour_format, $this->retours_formats_autorises)) {
$erreurs[] = 'la valeur '.$this->retour_format.' est inconnue';
}
if (count($erreurs) > 0) {
$message = implode('<br />', $erreurs);
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
//+---------------------------FONCTIONS DE REQUETE---------------------------------------------------------+
 
private function obtenirLois(Array $id_lois) {
$id_lois = array_map(array($this->bdd, 'proteger'), $id_lois);
$requete = "SELECT * FROM ".Config::get('bdd_table_lois').' '.
"WHERE id IN (".implode(',',$id_lois).") ";
return $this->bdd->recupererTous($requete);
}
private function obtenirLoisZoneGeo(Array $id_lois) {
$id_lois = array_map(array($this->bdd, 'proteger'), $id_lois);
$requete = "SELECT DISTINCT zone_application, code_zone_application FROM ".Config::get('bdd_table_lois').' '.
"WHERE id IN (".implode(',',$id_lois).") ";
return $this->bdd->recupererTous($requete);
}
private function obtenirStatuts() {
$nn_demande = $this->parametres['masque.nn'];
$conditions_taxons = array();
$conditions_taxons = $this->obtenirNumNomTaxonsSuperieurs(Config::get('referentiel'), $nn_demande);
$conditions_taxons[] = $this->bdd->proteger($nn_demande);
$requete = "SELECT * FROM ".Config::get('bdd_table_especes').' '.
"WHERE num_nom_retenu IN (".implode(', ', $conditions_taxons).") OR ".
"num_nom IN (".implode(', ', $conditions_taxons).") " . ' -- ' . __FILE__ . ':' . __LINE__;
$statuts = $this->bdd->recuperer($requete);
$statuts = $this->formaterRetour($statuts);
return $statuts;
}
//+---------------------------FONCTIONS DE FORMATAGE---------------------------------------------------------+
 
private function formaterRetour($statuts_taxon) {
switch($this->retour_format) {
case 'zone_geo':
$retour = $this->formaterStatutsTaxonZoneGeo($statuts_taxon);
break;
case 'complet':
$retour = $this->formaterStatutsTaxon($statuts_taxon);
break;
default:
$retour = $this->formaterStatutsTaxon();
break;
}
return $retour;
}
private function formaterStatutsTaxonZoneGeo($statuts_taxon) {
$lois_statuts = array();
// cas ou la requête (obtenirStatuts()) ne retourne rien
if(!$statuts_taxon) return array();
 
foreach ($statuts_taxon as $champ => $statut) {
if($statut == "1") {
$lois_statuts[] = $champ;
}
}
$zones_geo_lois = (!empty($lois_statuts)) ? $this->obtenirLoisZoneGeo($lois_statuts) : array();
return $zones_geo_lois;
}
private function formaterStatutsTaxon($statuts_taxon) {
$statuts_formates = array();
$lois_statuts = array();
if(is_array($statuts_taxon)) {
unset($statuts_taxon['num_nom']);
unset($statuts_taxon['num_nom_retenu']);
unset($statuts_taxon['nom_sci']);
foreach ($statuts_taxon as $champ => $statut) {
if($statut == "1") {
$lois_statuts[] = $champ;
}
}
}
$statuts_formates = (!empty($lois_statuts)) ? $this->obtenirLois($lois_statuts) : array();
return $statuts_formates;
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/sptba/Statuts.php
New file
0,0 → 1,155
<?php
// declare(encoding='UTF-8');
/**
* Classe implémentant l'API d'eFlore concernant les statuts de protection
*
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Status
*
* @package eFlore/services
* @author Aurélien PERONNET <aurelien@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)
*/
// TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests...
class Statuts extends Commun {
 
protected $parametres = array();
protected $ressources = array();
private $bdd;
private $retour_format = 'complet';
private $retours_formats_autorises = array('complet','zone_geo');
 
public function __construct($config = null) {
$this->config = $config;
$this->bdd = $this->getBdd();
}
public function consulter($ressources, $parametres) {
 
$this->parametres = $parametres;
$this->ressources = $ressources;
 
$this->affecterParametresParDefaut();
$this->verifierParametres();
 
$resultat = new ResultatService();
$resultat->corps = $this->obtenirStatuts();
 
return $resultat;
}
//+---------------------------FONCTION D'ANALYSE DES PARAMETRES---------------------------------------------------------+
 
private function affecterParametresParDefaut() {
$this->retour_format = isset($this->parametres['retour.format']) ? $this->parametres['retour.format'] : $this->retour_format;
}
private function verifierParametres() {
$erreurs = array();
if (empty($this->parametres['masque.nn'])) {
$erreurs[] = 'renseignez une valeur pour masque.nn';
}
if(!is_numeric($this->parametres['masque.nn'])) {
$erreurs[] = 'la valeur pour masque.nn doit être un entier';
}
if(!in_array($this->retour_format, $this->retours_formats_autorises)) {
$erreurs[] = 'la valeur '.$this->retour_format.' est inconnue';
}
if (count($erreurs) > 0) {
$message = implode('<br />', $erreurs);
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
//+---------------------------FONCTIONS DE REQUETE---------------------------------------------------------+
 
private function obtenirLois(Array $id_lois) {
$id_lois = array_map(array($this->bdd, 'proteger'), $id_lois);
$requete = "SELECT * FROM ".Config::get('bdd_table_lois').' '.
"WHERE id IN (".implode(',',$id_lois).") ";
return $this->bdd->recupererTous($requete);
}
private function obtenirLoisZoneGeo(Array $id_lois) {
$id_lois = array_map(array($this->bdd, 'proteger'), $id_lois);
$requete = "SELECT DISTINCT zone_application, code_zone_application FROM ".Config::get('bdd_table_lois').' '.
"WHERE id IN (".implode(',',$id_lois).") ";
return $this->bdd->recupererTous($requete);
}
private function obtenirStatuts() {
$nn_demande = $this->parametres['masque.nn'];
$conditions_taxons = array();
$conditions_taxons = $this->obtenirNumNomTaxonsSuperieurs(Config::get('referentiel'), $nn_demande);
$conditions_taxons[] = $this->bdd->proteger($nn_demande);
$requete = "SELECT * FROM ".Config::get('bdd_table_especes').' '.
"WHERE num_nom_retenu IN (".implode(', ', $conditions_taxons).") OR ".
"num_nom IN (".implode(', ', $conditions_taxons).") ";
$statuts = $this->bdd->recuperer($requete);
$statuts = $this->formaterRetour($statuts);
return $statuts;
}
//+---------------------------FONCTIONS DE FORMATAGE---------------------------------------------------------+
 
private function formaterRetour($statuts_taxon) {
switch($this->retour_format) {
case 'zone_geo':
$retour = $this->formaterStatutsTaxonZoneGeo($statuts_taxon);
break;
case 'complet':
$retour = $this->formaterStatutsTaxon($statuts_taxon);
break;
default:
$retour = $this->formaterStatutsTaxon();
break;
}
return $retour;
}
private function formaterStatutsTaxonZoneGeo($statuts_taxon) {
$lois_statuts = array();
foreach ($statuts_taxon as $champ => $statut) {
if($statut == "1") {
$lois_statuts[] = $champ;
}
}
$zones_geo_lois = (!empty($lois_statuts)) ? $this->obtenirLoisZoneGeo($lois_statuts) : array();
return $zones_geo_lois;
}
private function formaterStatutsTaxon($statuts_taxon) {
$statuts_formates = array();
$lois_statuts = array();
if(is_array($statuts_taxon)) {
unset($statuts_taxon['num_nom']);
unset($statuts_taxon['num_nom_retenu']);
unset($statuts_taxon['nom_sci']);
foreach ($statuts_taxon as $champ => $statut) {
if($statut == "1") {
$lois_statuts[] = $champ;
}
}
}
$statuts_formates = (!empty($lois_statuts)) ? $this->obtenirLois($lois_statuts) : array();
return $statuts_formates;
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/eflore/cartes/CbnmedFormateur.php
New file
0,0 → 1,167
<?php
class CbnmedFormateur implements Formateur {
public $dest_map = array();
public $img = array();
public function __construct($info) {
$this->info = $info;
}
public function img() {
$qualite = 9;
imagepng($this->img['cbnmed'], Config::get('cache_stockageChemin').$this->dest_map['cbnmed'], $qualite);
}
//+----------------------------------------------------------------------------------------------------------------+
// Méthodes d'accès aux objets du Framework
/**
* Méthode de connection à la base de données sur demande.
* Tous les services web n'ont pas besoin de s'y connecter.
*/
protected function getBdd() {
if (! isset($this->Bdd)) {
$this->Bdd = new Bdd();
}
return $this->Bdd;
}
public function definirCouleurs() {
// green
$couleur['green'] = imagecolorallocate($this->img['cbnmed'], 0, 255, 0);
// red
$couleur['red'] = imagecolorallocate($this->img['cbnmed'], 255, 0, 0);
// blue
$couleur['blue'] = imagecolorallocate($this->img['cbnmed'], 0, 0, 255);
// purple
$couleur['purple'] = imagecolorallocate($this->img['cbnmed'], 255, 0, 255);
// black
$couleur['black'] = imagecolorallocate($this->img['cbnmed'], 0, 0, 0);
return $couleur;
}
public function initialiserImage() {
// Nom du fichier image en sortie
$this->cheminCartesBase = Config::get('Cartes.chemin');
$this->dest_map['cbnmed'] = 'cbnmed_nt'.$this->info['nt'].'_'.$this->info['src_map'];
$this->img['cbnmed'] = imagecreatefrompng($this->cheminCartesBase.$this->info['src_map']);
}
public function testerParametresProjets() {
$test = true;
if ($this->info['nom'] == '') {
$test = false;
}
return $test;
}
public function chargerDonnees() {
// Recherche nom correspondant au numero nomenclatural en cours (pour etablir le lien avec les donnees moissonnes).
// Collection code = 'FLORE - VAR' (Cbnmed)
$queryCbnmed = "SELECT collection_code, locality as id_location, county as location, ".
" STR_TO_DATE(concat(ifnull(year,0),'/', ifnull(month,0), '/',ifnull(day,0)), '%Y/%m/%d') as date_observation, ".
" latitude as y_utm , longitude as x_utm , max_altitude as sector, collector_name as identifiant ".
"FROM tb_hit_indexation.raw_occurrence_record ".
"WHERE scientific_name = ".$this->getBdd()->proteger($this->info['nom']).
" AND collection_code='FLORE - VAR' ".
" AND (deleted IS NULL OR deleted = '0000-00-00 00:00:00')";
$inventoriesCbnmed = $this->getBdd()->recupererTous($queryCbnmed);
return $inventoriesCbnmed;
}
 
public function dessinerPoint($text, $merge, $couleurs) {
$usemap['cbnmed'] = '';
foreach ($text as $coord => $origines ) {
foreach ($origines as $origine => $maptext ) {
$maptext = preg_replace("/\"/", "\'", $maptext);
list($x,$y) = explode('|', $coord);
$tpl_area = '<area shape="%s" alt="" class="tooltip" coords="%s" title="%s"/>';
$rayon = 2;
$type = 'circle';
$coords = "$x,$y,5";
$on_mouseover = "this.ttBgColor='#99C242';this.ttFontColor='#000000';this.T_OFFSETX=-200;this.T_OFFSETY=-50;this.T_STICKY=1;return escape('$maptext')";
imagefilledellipse($this->img['cbnmed'], $x, $y, 7, 7, $couleurs['blue']);
$usemap['cbnmed'] = $usemap['cbnmed'].sprintf($tpl_area, $type, $coords, $maptext);
}
}
return $usemap;
}
public function formaterCartes($usemap) {
$retour = Config::get('Cartes.cel_dst').$this->dest_map['cbnmed'];
if ($this->info['retour'] == self::MIME_MAP) {
$retour = "<img src=\"".$retour."\" style=\"border:none; ".
"cursor:crosshair\" alt=\"\" usemap=\"#themap\" /><br />\n".
"<map name=\"themap\" id=\"themap\">".utf8_encode($usemap['cbnmed'])."</map>";
}
return $retour;
}
 
//+----------------------------------------------------------------------------------------------------------------+
// sous fonction de calculer répartition
public function chercherVille($inventory, $tab_code_insee = array()) {
$location_protege = $this->getBdd()->proteger($inventory['location']);
$id_location_protege = $this->getBdd()->proteger($inventory['id_location']);
$utm = '';
if (isset($tab_code_insee[$id_location_protege])) {
$utm = array(0 => $tab_code_insee[$id_location_protege]);
} else {
$requete = "SELECT * ".
"FROM tb_cel.locations ".
"WHERE insee_code = $id_location_protege ";
$utm = $this->getBdd()->recupererTous($requete);
}
return $utm;
}
 
public function formerCommentaire($utm, $inventory) {
$comment = '';
if ($inventory['date_observation'] != '0000-00-00 00:00:00') {
$comment .= $this->formerDate($inventory);
}
$comment .= " par ".utf8_decode($inventory['identifiant']);
return $comment;
}
public function formerDate($inventory) {
list($year, $month, $day) = explode ('-',$inventory['date_observation']);
list($day) = explode (' ',$day);
if ($month == '00') {
$date = ', en '.$year;
} else {
$date = ', le '.$day.'/'.$month.'/'.$year;
}
return $date;
}
public function stockerCommentaire($text, $merge, $name, $comment, $origine, $x, $y) {
$prefix = 'CBN MED : ';
// Deja present pour cette origine ? on ajoute
if (isset ($text[$x.'|'.$y][$origine]) && ($text[$x.'|'.$y][$origine])) {
$text[$x.'|'.$y][$origine] = $text[$x.'|'.$y][$origine].'<br>'.$name.$comment;
} else { // Nouveau commentaire
$text[$x.'|'.$y][$origine] = $name.$comment;
}
// Detection superposition de donnee
if ((isset ($text[$x.'|'.$y]['sophy']) && ($text[$x.'|'.$y]['sophy'])) || (isset ($text[$x.'|'.$y]['cel']) && ($text[$x.'|'.$y]['cel'])) ||
(isset ($text[$x.'|'.$y]['flore']) && ($text[$x.'|'.$y]['flore']))) {
$merge[$x.'|'.$y]=true;
}
return array($text, $merge);
}
 
 
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/eflore/cartes/GeneralFormateur.php
New file
0,0 → 1,309
<?php
class GeneralFormateur implements Formateur {
public $dest_map = array();
public $img = array();
public function __construct($info) {
$this->info = $info;
}
public function img() {
$qualite = 9;
imagepng($this->img['general'], Config::get('cache_stockageChemin').$this->dest_map['general'], $qualite);
}
//+----------------------------------------------------------------------------------------------------------------+
// Méthodes d'accès aux objets du Framework
/**
* Méthode de connection à la base de données sur demande.
* Tous les services web n'ont pas besoin de s'y connecter.
*/
protected function getBdd() {
if (! isset($this->Bdd)) {
$this->Bdd = new Bdd();
}
return $this->Bdd;
}
public function definirCouleurs() {
// green
$couleur['green'] = imagecolorallocate($this->img['general'], 0, 255, 0);
// red
$couleur['red'] = imagecolorallocate($this->img['general'], 255, 0, 0);
// blue
$couleur['blue'] = imagecolorallocate($this->img['general'], 0, 0, 255);
// purple
$couleur['purple'] = imagecolorallocate($this->img['general'], 255, 0, 255);
// black
$couleur['black'] = imagecolorallocate($this->img['general'], 0, 0, 0);
return $couleur;
}
public function initialiserImage() {
// Nom du fichier image en sortie
$this->cheminCartesBase = Config::get('Cartes.chemin');
$this->dest_map['general'] = 'nt'.$this->info['nt'].'_'.$this->info['src_map'];
$this->img['general'] = imagecreatefrompng($this->cheminCartesBase.$this->info['src_map']);
}
public function testerParametresProjets() {
$test = true;
return $test;
}
public function chargerDonnees() {
// Recherche nom correspondant au numero nomenclatural en cours (pour etablir le lien avec les donnees moissonnes).
// Récuperation donnée inventaire
/*
* Les donnees issues du carnet en ligne sont recuperes directement, sans passer par le mecanisme de moissonage car :
* - pour l'instant le service de moissonage n'est pas automatise et donc il y a un decalage dans l'affichage des donnees transmises
* - la table contenant les donnees moissonees ne reprend pas tous les champs necessaires a l'exploitation par eflore (notamment pas de code localite, pas d'identifiant libre)
*
* A terme, utilser vraiment le moissonage, y compris pour les donnees issues du CEL, en utilisant ABCD et en modifiant le programme d'harvesting.
*/
if ($this->info['nt'] == 0) {
$inventoriesCel = array();
} else {
$queryCel = "SELECT 'cel' as collection_code, zone_geo as location, REPLACE(ce_zone_geo,'INSEE-C:','') as id_location, date_observation, ".
" longitude as y_utm, latitude as x_utm, geodatum as sector, courriel_utilisateur as identifiant FROM tb_cel.cel_obs ".
"WHERE nt = '".$this->info['nt']."' ".
" AND transmission = 1";
$inventoriesCel = $this->getBdd()->recupererTous($queryCel);
}
// Recuperation des donnees de moissonage
// Collection code = 'flore' (Cenlr)
if ($this->info['nom'] == '') {
$inventoriesCenlr = array();
} else {
$queryCenlr = "SELECT collection_code, locality as location, county as id_location, ".
" STR_TO_DATE(concat(year, '/',month, '/',day), '%Y/%m/%d') as date_observation, latitude as y_utm , ".
" longitude as x_utm , max_altitude as sector, collector_name as identifiant ".
"FROM tb_hit_indexation.raw_occurrence_record ".
"WHERE scientific_name = ".$this->getBdd()->proteger($this->info['nom']).
" AND collection_code = 'flore' ".
" AND (deleted IS NULL OR deleted = '0000-00-00 00:00:00')";
$inventoriesCenlr = $this->getBdd()->recupererTous($queryCenlr);
}
// Collection code = 'FLORE - VAR' (Cbnmed)
/*$queryCbnmed = "SELECT collection_code, locality as location, county as id_location, ".
" STR_TO_DATE(concat(ifnull(year,0),'/', ifnull(month,0), '/',ifnull(day,0)), '%Y/%m/%d') as date_observation, ".
" latitude as y_utm , longitude as x_utm , max_altitude as sector, collector_name as identifiant ".
"FROM tb_hit_indexation.raw_occurrence_record ".
"WHERE scientific_name = ".$this->getBdd()->proteger($this->info['nom']).
" AND collection_code='FLORE - VAR' ".
" AND (deleted IS NULL OR deleted = '0000-00-00 00:00:00')";
$inventoriesCbnmed = $this->getBdd()->recupererTous($queryCbnmed);*/
// Collection code = 'sophy'
if ($this->info['nom_ss_auteur'] == '') {
$inventoriesSophy = array();
} else {
$querySophy = "SELECT 'sophy' as collection_code, lieu_station_nom as location, lieu_commune_code_insee as id_location, ".
" observation_date as date_observation, lieu_station_utm_est as x_utm , ".
" lieu_station_utm_nord as y_utm , lieu_station_utm_zone as sector, observateur_nom_complet as identifiant ".
"FROM sophy_tapir ".
"WHERE nom_scientifique_complet = ".$this->getBdd()->proteger($this->info['nom_ss_auteur']);
$inventoriesSophy = $this->getBdd()->recupererTous($querySophy);
}
return array_merge($inventoriesCel, $inventoriesCenlr, $inventoriesSophy); //$inventoriesCbnmed,
}
 
public function dessinerPoint($text, $merge, $couleurs) {
$usemap['general'] = '';
foreach ($text as $coord => $origines ) {
foreach ($origines as $origine => $maptext ) {
$maptext = preg_replace("/\"/", "\'", $maptext);
list($x,$y) = explode('|', $coord);
$tpl_area = '<area shape="%s" alt="" class="tooltip" coords="%s" title="%s"/>';
$rayon = 2;
$type = 'circle';
$coords = "$x,$y,5";
$on_mouseover = "this.ttBgColor='#99C242';this.ttFontColor='#000000';this.T_OFFSETX=-200;this.T_OFFSETY=-50;this.T_STICKY=1;return escape('$maptext')";
if (isset($merge[$coord]) && $merge[$coord]) {
imagefilledrectangle($this->img['general'], ($x - $rayon), ($y - $rayon), ($x + $rayon), ($y + $rayon), $couleurs['black']);
} elseif (isset ($text[$coord]['cel']) && ($text[$coord]['cel'])) {
imagefilledrectangle($this->img['general'], ($x - $rayon), ($y - $rayon), ($x + $rayon), ($y + $rayon), $couleurs['green']);
} elseif (isset ($text[$coord]['flore']) && ($text[$coord]['flore'])) {
imagefilledrectangle($this->img['general'], ($x - $rayon), ($y - $rayon), ($x + $rayon), ($y + $rayon), $couleurs['red']);
}/* elseif (isset ($text[$coord]['FLORE - VAR']) && ($text[$coord]['FLORE - VAR'])) {
imagefilledrectangle($this->img['general'], ($x - $rayon), ($y - $rayon), ($x + $rayon), ($y + $rayon), $couleurs['blue']);
}*/ elseif (isset ($text[$coord]['sophy']) && ($text[$coord]['sophy'])) {
imagefilledrectangle($this->img['general'], ($x - $rayon), ($y - $rayon), ($x + $rayon), ($y + $rayon), $couleurs['purple']);
}
$usemap['general'] = $usemap['general'].sprintf($tpl_area, $type, $coords, $maptext);
}
}
return $usemap;
}
public function formaterCartes($usemap) {
$retour = Config::get('Cartes.cel_dst').$this->dest_map['general'];
if ($this->info['retour'] == self::MIME_MAP) {
$retour = "<img src=\"".$retour."\" style=\"border:none; ".
"cursor:crosshair\" alt=\"\" usemap=\"#themap\" /><br />\n".
"<map name=\"themap\" id=\"themap\">".utf8_encode($usemap['general'])."</map>";
}
return $retour;
}
//+----------------------------------------------------------------------------------------------------------------+
// sous fonction de calculer répartition
public function chercherVille($inventory, $tab_code_insee = array()) {
$location_protege = $this->getBdd()->proteger($inventory['location']);
$id_location_protege = '"'.$inventory['id_location'].'"';
$utm = array();
if ($inventory['collection_code'] == 'FLORE - VAR') {
if (isset($tab_code_insee[$location_protege])) {
$utm = array(0 => $tab_code_insee[$location_protege]);
}
} elseif ($inventory['collection_code'] == 'sophy') {
if (strpos($inventory['id_location'], '20') === 0) {
$a = str_replace('20', '2A', $inventory['id_location']);
if (isset($tab_code_insee[$a])) {
$utm = array(0 => $tab_code_insee[$a]);
} else {
$b = str_replace('20', '2B', $inventory['id_location']);
if (isset($tab_code_insee[$b])) {
$utm = array(0 => $tab_code_insee[$b]);
}
}
} elseif (isset($tab_code_insee[$inventory['id_location']])) {
$utm = array(0 => $tab_code_insee[$inventory['id_location']]);
} elseif (strpos($inventory['id_location'], '000') === 2) {
$code = $this->getBdd()->proteger(str_replace('000', '', $inventory['id_location']));
$requete = "SELECT chef_lieu ".
"FROM tb_eflore.insee_d_v2011 ".
"WHERE dep = $code ";
$resultat = $this->getBdd()->recupererTous($requete);
if ($resultat != array() && isset($tab_code_insee[$resultat[0]['chef_lieu']])) {
$utm = $tab_code_insee[$resultat[0]['chef_lieu']];
}
}
} else {
if ($inventory['id_location'] != 'null') {
if (isset($tab_code_insee[$id_location_protege])) {
$utm = array(0 => $tab_code_insee[$id_location_protege]);
} else {
$requete = "SELECT nom as name, code as insee_code, utm_x as x_utm, utm_y as y_utm, utm_secteur as sector ".
"FROM tb_cel.cel_zones_geo ".
"WHERE nom LIKE $location_protege ".
" AND code = $id_location_protege ";
$resultat = $this->getBdd()->recupererTous($requete);
if ($resultat != false) {
$utm = $resultat;
}
}
} else {
$requete = "SELECT nom as name, code as insee_code, utm_x as x_utm, utm_y as y_utm, utm_secteur as sector".
" FROM tb_cel.cel_zones_geo WHERE nom LIKE $location_protege ";
$utm = $this->getBdd()->recupererTous($requete);
}
}
return $utm;
}
 
public function formerCommentaire($utm, $inventory) {
$comment = '';
if ($inventory['date_observation'] != '0000-00-00 00:00:00') {
$comment .= $this->formerDate($inventory);
}
if ($inventory['collection_code'] == 'cel') {
list($identifiant) = explode("@", $inventory['identifiant']);
$comment .= " par ".$identifiant."@...";
} else {
$comment .= " par ".utf8_decode($inventory['identifiant']);
}
return $comment;
}
public function formerDate($inventory) {
$date = NULL;
if ($inventory['collection_code'] == 'sophy') {
$date = ', en '.$inventory['date_observation'];
}
elseif($inventory['date_observation']) {
list($year, $month, $day) = explode ('-',$inventory['date_observation']);
list($day) = explode (' ',$day);
if ($month == '00') {
$date = ', en '.$year;
} else {
$date = ', le '.$day.'/'.$month.'/'.$year;
}
}
return $date;
}
/*
* Stockage commentaire associe a un point :
*
* Param :
* @text : texte cumule
* @merge : indicateur de commentaire fusionne
* @name : commune associee
* @comment : commentaire
* @origine : origine de la donnee
*
*
* TODO : rendre cette fonction independante des valeurs d'origine passee en parametre
*/
public function stockerCommentaire($text, $merge, $name, $comment, $origine, $x, $y) {
if ($origine == 'cel') {
$prefix = 'CEL : ';
} elseif ($origine == 'flore') {
$prefix = 'CEN LR : ';
} /*elseif ($origine == 'FLORE - VAR') {
$prefix = 'CBN MED : ';
}*/ elseif ($origine == 'sophy') {
$prefix = 'SOPHY : ';
}
// Cumul toute origine :
if (isset($text[$x.'|'.$y]['tout']) && ($text[$x.'|'.$y])) {
$text[$x.'|'.$y]['tout'] = $text[$x.'|'.$y]['tout'].'<br>'.$prefix.$name.$comment;
} else {
// Nouveau commentaire
$text[$x.'|'.$y]['tout']=$prefix.$name.$comment;
}
// Deja present pour cette origine ? on ajoute
if (isset ($text[$x.'|'.$y][$origine]) && ($text[$x.'|'.$y][$origine])) {
$text[$x.'|'.$y][$origine] = $text[$x.'|'.$y][$origine].'<br>'.$name.$comment;
} else { // Nouveau commentaire
$text[$x.'|'.$y][$origine] = $name.$comment;
}
// Detection superposition de donnee
if ($origine == 'cel') {
if ((isset ($text[$x.'|'.$y]['sophy']) && ($text[$x.'|'.$y]['sophy'])) || (isset ($text[$x.'|'.$y]['flore']) && ($text[$x.'|'.$y]['flore']))
|| (isset ($text[$x.'|'.$y]['FLORE - VAR']) && ($text[$x.'|'.$y]['FLORE - VAR']))) {
$merge[$x.'|'.$y]=true;
}
} elseif ($origine == 'flore') {
if ((isset ($text[$x.'|'.$y]['sophy']) && ($text[$x.'|'.$y]['sophy'])) ||(isset ($text[$x.'|'.$y]['cel']) && ($text[$x.'|'.$y]['cel'])) ||
(isset ($text[$x.'|'.$y]['FLORE - VAR']) && ($text[$x.'|'.$y]['FLORE - VAR']))) {
$merge[$x.'|'.$y]=true;
}
} elseif ($origine == 'FLORE - VAR') {
if ((isset ($text[$x.'|'.$y]['sophy']) && ($text[$x.'|'.$y]['sophy'])) || (isset ($text[$x.'|'.$y]['cel']) && ($text[$x.'|'.$y]['cel'])) ||
(isset ($text[$x.'|'.$y]['flore']) && ($text[$x.'|'.$y]['flore']))) {
$merge[$x.'|'.$y]=true;
}
} elseif ($origine == 'sophy') {
if ((isset ($text[$x.'|'.$y]['cel']) && ($text[$x.'|'.$y]['cel'])) || (isset ($text[$x.'|'.$y]['flore']) && ($text[$x.'|'.$y]['flore'])||
(isset ($text[$x.'|'.$y]['FLORE - VAR']) && ($text[$x.'|'.$y]['FLORE - VAR'])))) {
$merge[$x.'|'.$y]=true;
}
}
return array($text, $merge);
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/eflore/cartes/Formateur.php
New file
0,0 → 1,32
<?php
interface Formateur {
const MIME_MAP = 'text/html';
const MIME_PNG = 'image/png';
public function __construct($info);
public function initialiserImage();
public function chargerDonnees();
public function dessinerPoint($text, $merge, $couleurs);
public function formaterCartes($usemap);
//+----------------------------------------------------------------------------------------------------------------+
// sous fonction de calculer répartition
public function chercherVille($inventory, $tab_code_insee = array());
public function formerCommentaire($utm, $inventory);
public function formerDate($inventory);
/*
* Stockage commentaire associe a un point :
*
* Param :
* @text : texte cumule
* @merge : indicateur de commentaire fusionne
* @name : commune associee
* @comment : commentaire
* @origine : origine de la donnee
*
*
* TODO : rendre cette fonction independante des valeurs d'origine passee en parametre
*/
public function stockerCommentaire($text, $merge, $name, $comment, $origine, $x, $y);
 
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/eflore/cartes/LegendeCartes.php
New file
0,0 → 1,113
<?php
// declare(encoding='UTF-8');
/**
* Gère le sous-service Legende de Cartes.
*
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Cartes
*
* @package eFlore/services
* @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)
*/
// TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests...
class LegendeCartes {
 
private $parametres = array();
private $ressources = array();
 
const MIME_JSON = 'application/json';
const LEGENDE = '10';
 
private $formatsSupportes = array(self::MIME_JSON);
private $tableOntologie = '';
private $ontologies = '';
private $legende = array();
 
public function __construct(Conteneur $conteneur) {
$this->Bdd = $conteneur->getBdd();
$this->tableOntologie = $conteneur->getParametre('bdd_table_ontologies');
}
 
public function consulter($ressources, $parametres) {
//$tpsDebut = microtime(true);
$this->parametres = $parametres;
$this->ressources = $ressources;
 
$this->definirValeurParDefautDesParametres();
$this->verifierParametres();
 
$resultat = $this->obtenirResultat();
 
return $resultat;
}
 
private function definirValeurParDefautDesParametres() {
if (isset($this->parametres['retour']) == false) {
$this->parametres['retour'] = self::MIME_JSON;
}
}
 
private function verifierParametres() {
$erreurs = array();
 
if (isset($this->parametres['retour']) == false) {
$erreurs[] = "Le paramètre type de retour 'retour' est obligatoire.";
}
if ($this->verifierValeurParametreRetour() == false) {
$erreurs[] = "Le type de retour '{$this->parametres['retour']}' n'est pas supporté.";
}
 
if (count($erreurs) > 0) {
$message = implode('<br />', $erreurs);
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
 
private function verifierValeurParametreRetour() {
return in_array($this->parametres['retour'], $this->formatsSupportes);
}
 
private function obtenirResultat() {
$this->chargerOntologies();
$this->chargerLegende();
 
$resultat = new ResultatService();
$resultat->corps = $this->legende;
$resultat->mime = $this->parametres['retour'];
 
return $resultat;
}
 
private function chargerOntologies() {
$requete = "SELECT * FROM {$this->tableOntologie} ";
$resultats = $this->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']] = Commun::extraireComplementsOntologies($ontologie);
}
}
 
private function chargerLegende() {
foreach ($this->ontologies as $ontologie) {
if ($ontologie['classe_id'] == self::LEGENDE) {
$this->legende[] = array(
'code' => $ontologie['code'],
// TODO: cf story "uniformiser le séparateur de compléments d'ontologies"
'couleur' => @$ontologie['legende'],
'nom' => $ontologie['nom'],
'description' => $ontologie['description']);
}
}
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/eflore/cartes/SophyFormateur.php
New file
0,0 → 1,171
<?php
class SophyFormateur implements Formateur {
public $dest_map = array();
public $img = array();
public function __construct($info) {
$this->info = $info;
}
public function img() {
$qualite = 9;
imagepng($this->img['sophy'], Config::get('cache_stockageChemin').$this->dest_map['sophy'], $qualite);
}
//+----------------------------------------------------------------------------------------------------------------+
// Méthodes d'accès aux objets du Framework
/**
* Méthode de connection à la base de données sur demande.
* Tous les services web n'ont pas besoin de s'y connecter.
*/
protected function getBdd() {
if (! isset($this->Bdd)) {
$this->Bdd = new Bdd();
}
return $this->Bdd;
}
public function definirCouleurs() {
// purple
$couleur['purple'] = imagecolorallocate($this->img['sophy'], 255, 0, 255);
return $couleur;
}
public function initialiserImage() {
// Nom du fichier image en sortie
$this->cheminCartesBase = Config::get('Cartes.chemin');
$this->dest_map['sophy'] = 'sophy_nt'.$this->info['nt'].'_'.$this->info['src_map'];
$this->img['sophy'] = imagecreatefromjpeg($this->cheminCartesBase.$this->info['src_map']);
}
public function testerParametresProjets() {
$test = true;
if ($this->info['nom_ss_auteur'] == '') {
$test = false;
}
return $test;
}
public function chargerDonnees() {
// Collection code = 'sophy'
$querySophy = "SELECT 'sophy' as collection_code, lieu_station_nom as location, lieu_commune_code_insee as id_location, ".
" observation_date as date_observation, lieu_station_utm_est as x_utm , ".
" lieu_station_utm_nord as y_utm , lieu_station_utm_zone as sector, observateur_nom_complet as identifiant ".
"FROM sophy_tapir ".
"WHERE nom_scientifique_complet = ".$this->getBdd()->proteger($this->info['nom_ss_auteur']).
" AND lieu_commune_code_insee != '' group by `nom_scientifique_complet`,`lieu_commune_code_insee`, `lieu_station_nom`";
$inventoriesSophy = $this->getBdd()->recupererTous($querySophy);
return $inventoriesSophy;
}
 
public function dessinerPoint($text, $merge, $couleurs) {
$usemap['sophy'] = '';
foreach ($text as $coord => $origines ) {
foreach ($origines as $origine => $maptext ) {
$maptext = preg_replace("/\"/", "\'", $maptext);
list($x,$y) = explode('|', $coord);
$tpl_area = '<area shape="%s" alt="" class="tooltip" coords="%s" title="%s"/>';
$rayon = 2;
$type = 'circle';
$coords = "$x,$y,5";
$on_mouseover = "this.ttBgColor='#99C242';this.ttFontColor='#000000';this.T_OFFSETX=-200;this.T_OFFSETY=-50;this.T_STICKY=1;return escape('$maptext')";
imagefilledrectangle($this->img['sophy'], ($x - $rayon), ($y - $rayon), ($x + $rayon), ($y + $rayon), $couleurs['purple']);
$coords = ($x - $rayon).','.($y - $rayon).','.($x + $rayon).','.($y + $rayon);
$usemap['sophy'] = $usemap['sophy'].sprintf($tpl_area, 'rect', $coords, $maptext);
}
}
return $usemap;
}
public function formaterCartes($usemap) {
$retour = Config::get('Cartes.cel_dst').$this->dest_map['sophy'];
if ($this->info['retour'] == self::MIME_MAP) {
$retour = "<img src=\"".$retour."\" style=\"border:none; ".
"cursor:crosshair\" alt=\"\" usemap=\"#themap\" /><br />\n".
"<map name=\"themap\" id=\"themap\">".utf8_encode($usemap['sophy'])."</map>";
}
return $retour;
}
 
//+----------------------------------------------------------------------------------------------------------------+
// sous fonction de calculer répartition
public function chercherVille($inventory, $tab_code_insee = array()) {
$utm = '';
if (strpos($inventory['id_location'], '20') === 0) {
$a = str_replace('20', '2A', $inventory['id_location']);
if (isset($tab_code_insee[$a])) {
$utm = array(0 => $tab_code_insee[$a]);
} else {
$b = str_replace('20', '2B', $inventory['id_location']);
if (isset($tab_code_insee[$b])) {
$utm = array(0 => $tab_code_insee[$b]);
}
}
} elseif (isset($tab_code_insee[$inventory['id_location']])) {
$utm = array(0 => $tab_code_insee[$inventory['id_location']]);
} elseif (strpos($inventory['id_location'], '000') === 2) {
$code = $this->getBdd()->proteger(str_replace('000', '', $inventory['id_location']));
$requete = "SELECT chef_lieu ".
"FROM tb_eflore.insee_d_v2011 ".
"WHERE dep = $code ";
$resultat = $this->getBdd()->recupererTous($requete);
if ($resultat != array() && isset($tab_code_insee[$resultat[0]['chef_lieu']])) {
$utm = $tab_code_insee[$resultat[0]['chef_lieu']];
}
}
return $utm;
}
 
public function formerCommentaire($utm, $inventory) {
$comment = '';
if ($inventory['date_observation'] != '0000-00-00 00:00:00') {
$comment .= $this->formerDate($inventory);
}
$comment .= " par ".utf8_decode($inventory['identifiant']);
return $comment;
}
public function formerDate($inventory) {
$date = ', en '.$inventory['date_observation'];
return $date;
}
/*
* Stockage commentaire associe a un point :
*
* Param :
* @text : texte cumule
* @merge : indicateur de commentaire fusionne
* @name : commune associee
* @comment : commentaire
* @origine : origine de la donnee
*
*
* TODO : rendre cette fonction independante des valeurs d'origine passee en parametre
*/
public function stockerCommentaire($text, $merge, $name, $comment, $origine, $x, $y) {
$prefix = 'SOPHY : ';
// Deja present pour cette origine ? on ajoute
if (isset ($text[$x.'|'.$y][$origine]) && ($text[$x.'|'.$y][$origine])) {
$text[$x.'|'.$y][$origine] = $text[$x.'|'.$y][$origine].'<br>'.$name.$comment;
} else { // Nouveau commentaire
$text[$x.'|'.$y][$origine] = $name.$comment;
}
if ((isset ($text[$x.'|'.$y]['cel']) && ($text[$x.'|'.$y]['cel'])) || (isset ($text[$x.'|'.$y]['flore']) && ($text[$x.'|'.$y]['flore'])||
(isset ($text[$x.'|'.$y]['FLORE - VAR']) && ($text[$x.'|'.$y]['FLORE - VAR'])))) {
$merge[$x.'|'.$y] = true;
}
return array($text, $merge);
}
 
 
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/eflore/cartes/CelFormateur.php
New file
0,0 → 1,192
<?php
class CelFormateur implements Formateur {
public $dest_map = array();
public $img = array();
public function __construct($info) {
$this->info = $info;
}
public function img() {
$qualite = 9;
imagepng($this->img['cel'], Config::get('cache_stockageChemin').$this->dest_map['cel'], $qualite);
}
//+----------------------------------------------------------------------------------------------------------------+
// Méthodes d'accès aux objets du Framework
/**
* Méthode de connection à la base de données sur demande.
* Tous les services web n'ont pas besoin de s'y connecter.
*/
protected function getBdd() {
if (! isset($this->Bdd)) {
$this->Bdd = new Bdd();
}
return $this->Bdd;
}
public function definirCouleurs() {
// green
$couleurs['green'] = imagecolorallocate($this->img['cel'], 0, 255, 0);
return $couleurs;
}
public function initialiserImage() {
// Nom du fichier image en sortie
$this->cheminCartesBase = Config::get('Cartes.chemin');
$this->dest_map['cel'] = 'cel_nt'.$this->info['nt'].'_'.$this->info['src_map'];
$this->img['cel'] = imagecreatefrompng($this->cheminCartesBase.$this->info['src_map']);
}
public function testerParametresProjets() {
$test = true;
if ($this->info['nt'] == 0) {
$test = false;
}
return $test;
}
public function chargerDonnees() {
// Recherche nom correspondant au numero nomenclatural en cours (pour etablir le lien avec les donnees moissonnes).
// R�cuperation donn�e inventaire
/*
* Les donnees issues du carnet en ligne sont recuperes directement, sans passer par le mecanisme de moissonage car :
* - pour l'instant le service de moissonage n'est pas automatise et donc il y a un decalage dans l'affichage des donnees transmises
* - la table contenant les donnees moissonees ne reprend pas tous les champs necessaires a l'exploitation par eflore (notamment pas de code localite, pas d'identifiant libre)
*
* A terme, utilser vraiment le moissonage, y compris pour les donnees issues du CEL, en utilisant ABCD et en modifiant le programme d'harvesting.
*/
$queryCel = "SELECT 'cel' as collection_code, zone_geo as location, REPLACE(ce_zone_geo,'INSEE-C:','') as id_location, date_observation, ".
" longitude as y_utm, latitude as x_utm, geodatum as sector, courriel_utilisateur as identifiant FROM tb_cel.cel_obs ".
"WHERE nt = '".$this->info['nt']."' ".
" AND transmission = 1";
$inventoriesCel = $this->getBdd()->recupererTous($queryCel);
return $inventoriesCel;
}
 
public function dessinerPoint($text, $merge, $couleurs) {
$usemap['cel'] = '';
foreach ($text as $coord => $origines ) {
foreach ($origines as $origine => $maptext ) {
$maptext = preg_replace("/\"/", "\'", $maptext);
list($x,$y) = explode('|', $coord);
$tpl_area = '<area shape="%s" alt="" class="tooltip" coords="%s" title="%s"/>';
$rayon = 2;
$type = 'circle';
$coords = "$x,$y,5";
$on_mouseover = "this.ttBgColor='#99C242';this.ttFontColor='#000000';this.T_OFFSETX=-200;this.T_OFFSETY=-50;this.T_STICKY=1;return escape('$maptext')";
imagefilledrectangle($this->img['cel'], ($x - $rayon), ($y - $rayon), ($x + $rayon), ($y + $rayon), $couleurs['green']);
$coords = ($x - $rayon).','.($y - $rayon).','.($x + $rayon).','.($y + $rayon);
$usemap['cel'] = $usemap['cel'].sprintf($tpl_area, 'rect', $coords, $maptext);
}
}
return $usemap;
}
public function formaterCartes($usemap) {
$retour = Config::get('Cartes.cel_dst').$this->dest_map['cel'];
if ($this->info['retour'] == self::MIME_MAP) {
$retour = "<img src=\"".$retour."\" style=\"border:none; ".
"cursor:crosshair\" alt=\"\" usemap=\"#themap\" /><br />\n".
"<map name=\"themap\" id=\"themap\">".utf8_encode($usemap['cel'])."</map>";
}
return $retour;
}
 
//+----------------------------------------------------------------------------------------------------------------+
// sous fonction de calculer répartition
public function chercherVille($inventory, $tab_code_insee = array()) {
$location_protege = $this->getBdd()->proteger($inventory['location']);
$id_location_protege = $this->getBdd()->proteger($inventory['id_location']);
$utm = array();
if ($inventory['id_location'] != 'null') {
if (isset($tab_code_insee) & in_array($inventory['id_location'], $tab_code_insee)) {
$utm = array(0 => $this->tab_code_insee[$id_location_protege]);
} else {
$requete = "SELECT nom as name, code as insee_code, utm_x as x_utm, utm_y as y_utm, utm_secteur as sector ".
"FROM cel.cel_zones_geo ".
"WHERE nom LIKE $location_protege ".
" AND code = $id_location_protege ";
$resultat = $this->getBdd()->recupererTous($requete);
$utm = $resultat;
}
} else {
$requete = "SELECT nom as name, code as insee_code, utm_x as x_utm, utm_y as y_utm, utm_secteur as sector".
" FROM tb_cel.cel_zones_geo WHERE nom LIKE $location_protege ";
$utm = $this->getBdd()->recupererTous($requete);
}
return $utm;
}
 
public function formerCommentaire($utm, $inventory) {
$comment = '';
if ($inventory['date_observation'] != '0000-00-00 00:00:00') {
$comment .= $this->formerDate($inventory);
}
list($identifiant) = explode("@", $inventory['identifiant']);
$comment .= " par ".$identifiant."@...";
return $comment;
}
public function formerDate($inventory) {
list($year, $month, $day) = explode ('-',$inventory['date_observation']);
list($day) = explode (' ',$day);
if ($month == '00') {
$date = ', en '.$year;
} else {
$date = ', le '.$day.'/'.$month.'/'.$year;
}
return $date;
}
/*
* Stockage commentaire associe a un point :
*
* Param :
* @text : texte cumule
* @merge : indicateur de commentaire fusionne
* @name : commune associee
* @comment : commentaire
* @origine : origine de la donnee
*
*
* TODO : rendre cette fonction independante des valeurs d'origine passee en parametre
*/
public function stockerCommentaire($text, $merge, $name, $comment, $origine, $x, $y) {
$prefix = 'CEL : ';
// Cumul toute origine :
if (isset($text[$x.'|'.$y]['tout']) && ($text[$x.'|'.$y])) {
$text[$x.'|'.$y]['tout'] = $text[$x.'|'.$y]['tout'].'<br>'.$prefix.$name.$comment;
} else {
// Nouveau commentaire
$text[$x.'|'.$y]['tout']=$prefix.$name.$comment;
}
// Deja present pour cette origine ? on ajoute
if (isset ($text[$x.'|'.$y][$origine]) && ($text[$x.'|'.$y][$origine])) {
$text[$x.'|'.$y][$origine] = $text[$x.'|'.$y][$origine].'<br>'.$name.$comment;
} else { // Nouveau commentaire
$text[$x.'|'.$y][$origine] = $name.$comment;
}
// Detection superposition de donnee
if ((isset ($text[$x.'|'.$y]['sophy']) && ($text[$x.'|'.$y]['sophy'])) || (isset ($text[$x.'|'.$y]['flore']) && ($text[$x.'|'.$y]['flore']))
|| (isset ($text[$x.'|'.$y]['FLORE - VAR']) && ($text[$x.'|'.$y]['FLORE - VAR']))) {
$merge[$x.'|'.$y]=true;
}
return array($text, $merge);
}
 
 
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/eflore/cartes/CenlrFormateur.php
New file
0,0 → 1,150
<?php
class CenlrFormateur implements Formateur {
public $dest_map = array();
public $img = array();
public function __construct($info) {
$this->info = $info;
}
public function img() {
$qualite = 9;
imagepng($this->img['cenlr'], Config::get('cache_stockageChemin').$this->dest_map['cenlr'], $qualite);
}
//+----------------------------------------------------------------------------------------------------------------+
// Méthodes d'accès aux objets du Framework
/**
* Méthode de connection à la base de données sur demande.
* Tous les services web n'ont pas besoin de s'y connecter.
*/
protected function getBdd() {
if (! isset($this->Bdd)) {
$this->Bdd = new Bdd();
}
return $this->Bdd;
}
public function definirCouleurs() {
// green
$couleur['green'] = imagecolorallocate($this->img['cenlr'], 0, 255, 0);
// red
$couleur['red'] = imagecolorallocate($this->img['cenlr'], 255, 0, 0);
// blue
$couleur['blue'] = imagecolorallocate($this->img['cenlr'], 0, 0, 255);
// purple
$couleur['purple'] = imagecolorallocate($this->img['cenlr'], 255, 0, 255);
// black
$couleur['black'] = imagecolorallocate($this->img['cenlr'], 0, 0, 0);
return $couleur;
}
public function initialiserImage() {
// Nom du fichier image en sortie
$this->cheminCartesBase = Config::get('Cartes.chemin');
$this->dest_map['cenlr'] = 'cenlr_nt'.$this->info['nt'].'_'.$this->info['src_map'];
$this->img['cenlr'] = imagecreatefrompng($this->cheminCartesBase.$this->info['src_map']);
}
public function testerParametresProjets() {
$test = true;
if ($this->info['nom'] == '') {
$test = false;
}
return $test;
}
public function chargerDonnees() {
// Collection code = 'flore' (Cenlr)
$queryCenlr = "SELECT collection_code, locality as location, county as id_location, ".
" STR_TO_DATE(concat(year, '/',month, '/',day), '%Y/%m/%d') as date_observation, latitude as y_utm , ".
" longitude as x_utm , max_altitude as sector, collector_name as identifiant ".
"FROM tb_hit_indexation.raw_occurrence_record ".
"WHERE scientific_name = ".$this->getBdd()->proteger($this->info['nom']).
" AND collection_code = 'flore' ".
" AND (deleted IS NULL OR deleted = '0000-00-00 00:00:00')";
$inventoriesCenlr = $this->getBdd()->recupererTous($queryCenlr);
return $inventoriesCenlr;
}
 
public function dessinerPoint($text, $merge, $couleurs) {
$usemap['cenlr'] = '';
foreach ($text as $coord => $origines ) {
foreach ($origines as $origine => $maptext ) {
$maptext = preg_replace("/\"/", "\'", $maptext);
list($x,$y) = explode('|', $coord);
$tpl_area = '<area shape="%s" alt="" class="tooltip" coords="%s" title="%s"/>';
$rayon = 2;
$type = 'circle';
$coords = "$x,$y,5";
$on_mouseover = "this.ttBgColor='#99C242';this.ttFontColor='#000000';this.T_OFFSETX=-200;this.T_OFFSETY=-50;this.T_STICKY=1;return escape('$maptext')";
imagefilledellipse($this->img['cenlr'], $x, $y, 7, 7, $couleurs['red']);
$usemap['cenlr'] = $usemap['cenlr'].sprintf($tpl_area, $type, $coords, $maptext);
}
}
return $usemap;
}
public function formaterCartes($usemap) {
$retour = Config::get('Cartes.cel_dst').$this->dest_map['cenlr'];
if ($this->info['retour'] == self::MIME_MAP) {
$retour = "<img src=\"".$retour."\" style=\"border:none; ".
"cursor:crosshair\" alt=\"\" usemap=\"#themap\" /><br />\n".
"<map name=\"themap\" id=\"themap\">".utf8_encode($usemap['cenlr'])."</map>";
}
return $retour;
}
//+----------------------------------------------------------------------------------------------------------------+
// sous fonction de calculer répartition
public function chercherVille($inventory, $tab_code_insee = array()) {
return $utm = '';
}
 
public function formerCommentaire($utm, $inventory) {
$comment = '';
if ($inventory['date_observation'] != '0000-00-00 00:00:00') {
$comment .= $this->formerDate($inventory);
}
$comment .= " par ".utf8_decode($inventory['identifiant']);
return $comment;
}
public function formerDate($inventory) {
list($year, $month, $day) = explode ('-',$inventory['date_observation']);
list($day) = explode (' ',$day);
if ($month == '00') {
$date = ', en '.$year;
} else {
$date = ', le '.$day.'/'.$month.'/'.$year;
}
return $date;
}
public function stockerCommentaire($text, $merge, $name, $comment, $origine, $x, $y) {
$prefix = 'CEN LR : ';
// Deja present pour cette origine ? on ajoute
if (isset ($text[$x.'|'.$y][$origine]) && ($text[$x.'|'.$y][$origine])) {
$text[$x.'|'.$y][$origine] = $text[$x.'|'.$y][$origine].'<br>'.$name.$comment;
} else { // Nouveau commentaire
$text[$x.'|'.$y][$origine] = $name.$comment;
}
// Detection superposition de donnee
if ((isset ($text[$x.'|'.$y]['sophy']) && ($text[$x.'|'.$y]['sophy'])) ||(isset ($text[$x.'|'.$y]['cel']) && ($text[$x.'|'.$y]['cel'])) ||
(isset ($text[$x.'|'.$y]['FLORE - VAR']) && ($text[$x.'|'.$y]['FLORE - VAR']))) {
$merge[$x.'|'.$y]=true;
}
return array($text, $merge);
}
 
 
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/eflore/Cartes.php
New file
0,0 → 1,282
<?php
/*vim: set expandtab tabstop=4 shiftwidth=4: */
// +------------------------------------------------------------------------------------------------------+
// | PHP version 5.1.1 |
// +------------------------------------------------------------------------------------------------------+
// | Copyright (C) 2006 Tela Botanica (accueil@tela-botanica.org) |
// +------------------------------------------------------------------------------------------------------+
// | This file is part of eFlore-Fiche. |
// | |
// | Foobar is free software; you can redistribute it and/or modify |
// | it under the terms of the GNU General Public License as published by |
// | the Free Software Foundation; either version 2 of the License, or |
// | (at your option) any later version. |
// | |
// | Foobar is distributed in the hope that it will be useful, |
// | but WITHOUT ANY WARRANTY; without even the implied warranty of |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
// | GNU General Public License for more details. |
// | |
// | You should have received a copy of the GNU General Public License |
// | along with Foobar; if not, write to the Free Software |
// | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
// +------------------------------------------------------------------------------------------------------+
// CVS : $Id: effi_cel.action.php,v 1.9 2007-11-06 10:54:03 jp_milcent Exp $
/**
* Fichier d'action du module eFlore-Fiche : Cel
*
* Appel Carnet en ligne
*
*
*@package eFlore
*@subpackage ef_fiche
//Auteur original :
*@author David Delon <dd@clapas.net>
//Autres auteurs :
*@author aucun
*@copyright Tela-Botanica 2000-2006
*@version $Revision: 1.9 $ $Date: 2007-11-06 10:54:03 $
// +------------------------------------------------------------------------------------------------------+
*/
 
// +------------------------------------------------------------------------------------------------------+
// | ENTETE du PROGRAMME |
// +------------------------------------------------------------------------------------------------------+
 
// +------------------------------------------------------------------------------------------------------+
// | CORPS du PROGRAMME |
// +------------------------------------------------------------------------------------------------------+
 
 
 
// TODO : CSS specifique (id)
 
class EfloreCartes {
private $tab_code_insee = array();
public $src_map;
private $cartesFormateur = null;
const MIME_MAP = 'text/html';
const MIME_PNG = 'image/png';
public function consulter($ressources, $param) {
// Initialisation des variables
$this->ressources = $ressources;
$this->param = $param;
if ($this->analyserRessources() == true) {
$resultat = $this->formerLegende();
} else {
$this->traiterParametres();
$resultat = $this->formerCarte();
}
return $resultat;
}
public function formerCarte() {
$this->creerFormateur();
$this->cartesFormateur->initialiserImage();
$inventories = '';
if ($this->cartesFormateur->testerParametresProjets() == true) {
$inventories = $this->cartesFormateur->chargerDonnees();
}
$retour = '';
if (is_array($inventories) && $inventories !== array()){
$this->chargerVille();// Connection referentiel communes
list($text, $merge) = $this->calculerRepartition($inventories);
// Définition des couleurs des points
$couleurs = $this->cartesFormateur->definirCouleurs();
if ($text) {
$usemap = $this->cartesFormateur->dessinerPoint($text, $merge, $couleurs);
}
if (isset($usemap)) {
$this->cartesFormateur->img();
$retour = $this->cartesFormateur->formaterCartes($usemap);
}
}
if ($retour == '') {
$retour = $this->formaterCarteVide();
}
$resultat = new ResultatService();
$resultat->corps = ($this->info['retour'] == self::MIME_MAP) ? $retour : file_get_contents($retour);
$resultat->mime = ($this->info['retour'] == self::MIME_MAP) ? self::MIME_MAP : self::MIME_PNG;
return $resultat;
}
public function creerFormateur(){
$projet = ucwords($this->info['projet']);
$Classe = $projet.'Formateur';
$chemin = dirname(__FILE__).DS.'cartes'.DS;
$cheminClasse = $chemin.$Classe.'.php';
$cheminInterface = $chemin.'Formateur.php';
if (file_exists($cheminInterface)) {
include_once $cheminInterface;
if (file_exists($cheminClasse)) {
include_once $cheminClasse;
$this->cartesFormateur = new $Classe($this->info);
} else {
$message = "La classe '$Classe' est introuvable.";Debug::printr($message);
throw new Exception($message);
}
}
}
private function analyserRessources() {
$ok = false;
if (isset($this->ressources[0]) && $this->ressources[0] == 'legende') {
$ok = true;
}
return $ok;
}
private function formerLegende() {
$classe = 'LegendeCartes';
require_once dirname(__FILE__).DS.'cartes'.DS.$classe.'.php';
$sousService = new $classe(new Conteneur());
$resultat = $sousService->consulter($this->ressources, $this->param);
return $resultat;
}
private function traiterParametres() {
$this->info['miniature'] = (isset($this->param['retour.format'])) ? $this->param['retour.format'] : false;
$this->info['src_map'] = ($this->info['miniature'] == 'min') ? 'france_utm_miniature.png' : 'france_utm_600x564.png';
$this->info['retour'] = (isset($this->param['retour'])) ? $this->param['retour'] : self::MIME_PNG ;
// Ajout du code du référentiel
$this->info['referentiel'] = 'bdtfx';
$projets = array('cenlr', 'cel', 'cbnmed', 'sophy', 'general');
if (isset($this->param['projet']) && in_array($this->param['projet'], $projets)) {
$this->info['projet'] = $this->param['projet'];
} else {
$this->info['projet'] = 'general';
}
// Récupération d'infos générales
// donnees exemple nn = 141; nt = 8522; nom = 'Acer campestre L.'; nom_ss_auteur = 'Acer campestre';
$this->info['nn'] = @$this->param['masque.nn'];
$this->info['nt'] = @$this->param['masque.nt'];
$this->info['nom'] = @$this->param['masque.ns'].' '.@$this->param['masque.au'];
$this->info['nom_ss_auteur'] = @$this->param['masque.ns'];
}
private function chargerVille() {
$requete = "SELECT nom as name, code as insee_code, utm_x as x_utm, utm_y as y_utm, utm_secteur as sector".
" FROM tb_cel.cel_zones_geo;";
$villes = $this->getBdd()->recupererTous($requete);
foreach ($villes as $ville) {
$this->tab_code_insee[$ville['insee_code']] = $ville;
}
}
private function calculerRepartition($inventories) {
$text = '';
// Recuperation du positionnement de la carte
$png_txt = file_get_contents(Config::get('Cartes.chemin').str_replace('png', 'txt', $this->info['src_map']));
parse_str($png_txt);
// "Resolution" calculer à partir du fichier $png_txt par fuseau
$p['31T'] = ($X231T - $X131T) / ($X231TUTM - $X131TUTM);
$p['32T'] = ($X231T - $X131T ) / ($X231TUTM - $X131TUTM);
$p['30T'] = ($X231T - $X131T ) / ($X231TUTM - $X131TUTM);
$text = array();
$merge = array();
foreach ($inventories as $inventory){
$utm = $this->cartesFormateur->chercherVille($inventory, $this->tab_code_insee);
// Ultime tentative
if (!$utm) {
$requete = "SELECT nom as name, code as insee_code, utm_x as x_utm, utm_y as y_utm, utm_secteur as sector".
" FROM tb_cel.cel_zones_geo WHERE nom LIKE ".$this->getBdd()->proteger($inventory['location']);
$utm = $this->getBdd()->recupererTous($requete);
}
 
// Si des doublons sur la commune : pas d'affichage , il vaut mieux ne rien afficher que d'afficher des erreurs.
if (sizeof($utm) == 1) {
$utm = $utm[0];
// On centre le point au milieu de la maille 10x10 par defaut ...
$utm = $this->chercherCentreMaille($utm);
// Calcul coordonnes x, y sur l'image
if ($utm['sector']=='31T') {// Fuseau 31 T
$x = (($utm['x_utm'] - $X131TUTM) * $p['31T'] ) + $X131T;
$y = $Y231T - (($utm['y_utm'] - $Y131TUTM) * $p['31T'] );
} elseif ($utm['sector'] == '32T') {// Fuseau 32 T : une rotation + translation est appliqu�e
$cosa = cos(deg2rad($angle3132));
$sina = sin(deg2rad($angle3132));
$xp = (($utm['x_utm'] - $X132TUTM) * $cosa) + (($utm['y_utm']- $Y132TUTM) * $sina);
$yp = (-($utm['x_utm'] - $X132TUTM)* $sina) + (($utm['y_utm'] - $Y132TUTM) * $cosa);
$x = ($xp * $p['32T'] ) + $X132T;
$y = $Y232T-($yp * $p['32T'] );
} elseif ($utm['sector'] == '30T') {// Fuseau 30 T : une rotation + translation est appliqu�e
$cosa = cos(deg2rad($angle3031));
$sina = sin(deg2rad($angle3031));
$xp = (($utm['x_utm'] - $X130TUTM) * $cosa) + (($utm['y_utm'] - $Y130TUTM) * $sina);
$yp = (-($utm['x_utm'] - $X130TUTM) * $sina) + (($utm['y_utm'] - $Y130TUTM) * $cosa);
$x = ($xp * $p['30T'] ) + $X130T;
$y = $Y230T - ($yp * $p['30T'] );
}
$x = round($x);
$y = round($y);
if ($utm['name'] != null) {
$name = utf8_decode($utm['name']);
}
$comment = ($this->info['retour'] == self::MIME_MAP) ? $this->cartesFormateur->formerCommentaire($utm, $inventory) : '';
// On stocke les commentaires pour affichage dans les tooltips
// Commentaire deja présent ? : on ajoute à la suite
list($text, $merge) = $this->cartesFormateur->stockerCommentaire($text, $merge, $name, $comment, $inventory['collection_code'],$x,$y);
}
}
return array($text, $merge);
}
 
private function formaterCarteVide() {
$this->cheminCartesBase = Config::get('Cartes.chemin');
$dest_map['vide'] = 'vide_'.$this->info['src_map'];
$img['vide'] = imagecreatefrompng($this->cheminCartesBase.$this->info['src_map']);
imagepng($img['vide'], Config::get('cache_stockageChemin').$dest_map['vide'], 9);
$retour = Config::get('cel_dst').$dest_map['vide'];
if ($this->info['retour'] == self::MIME_MAP) {
$retour = "<img src=\"".$retour."\" style=\"border:none; cursor:crosshair\" alt=\"\" />\n";
}
return $retour;
}
 
//+----------------------------------------------------------------------------------------------------------------+
// sous fonction de calculer répartition
private function chercherCentreMaille($utm) {
$pad = str_repeat ('0' ,(7 - strlen( $utm['x_utm'])));
$utm['x_utm'] = $pad.$utm['x_utm'];
$pad = str_repeat ('0' ,(7 - strlen( $utm['y_utm'])));
$utm['y_utm'] = $pad.$utm['y_utm'];
$utm['x_utm'] = substr($utm['x_utm'] ,0,3);
$utm['x_utm'] = $utm['x_utm'].'5000';
$utm['y_utm'] = substr($utm['y_utm'] ,0,3);
$utm['y_utm'] = $utm['y_utm'].'5000';
return $utm;
}
 
//+----------------------------------------------------------------------------------------------------------------+
// Méthodes d'accès aux objets du Framework
/**
* Méthode de connection à la base de données sur demande.
* Tous les services web n'ont pas besoin de s'y connecter.
*/
protected function getBdd() {
if (! isset($this->Bdd)) {
$this->Bdd = new Bdd();
}
return $this->Bdd;
}
 
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/eflore/Ontologies.php
New file
0,0 → 1,459
<?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 EfloreOntologies 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';
 
// beaucoup plus flexible dans le cas de requêtes SQL complexes
protected $mesChamps = '';
protected $mesJoinsEtConditions = '';
 
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' : $this->parametres['retour_champs'] = $valeur; 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) {
// plusieurs couples #classe:#code séparés par des virgules
if(strrpos($this->ressources[0], ',') !== false) {
$this->traiterMultipleRessourceId();
return;
}
 
// ou un unique couple #classe:#code
$this->format_reponse .= '/id';
preg_match('/^([^:]+):([^:]+)$/', $this->ressources[0], $match);
$this->requete_condition[] =
' id IN (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]).'))';
// TODO: optimiser, à voir: traiterMultipleRessourceId() ci-dessous
// SELECT a.*
// FROM $this->table a
// LEFT JOIN $this->table b ON a.id = b.id LEFT JOIN $this->table c ON b.classe_id = c.id
// WHERE b.code = $this->getBdd()->proteger($match[2])
// AND c.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);
}
}
 
// Requète : /ontologies/#classe:#code,[...] (ex : /ontologies/numStatus:2,numStatus:3,genreNombre:10)
public function traiterMultipleRessourceId() {
$this->format_reponse .= '/ids'; // noter le "s"
$this->mesChamps = Array(
// 'a.*' // pourquoi pas, mais alors des unset() seront nécessaire
'a.id',
'a.classe_id AS `classe.id`',
'a.nom',
'a.description',
'a.code',
'a.complements',
'c.nom AS classe', // évite très simplement (un très couteux) ajouterClasseCorrespondante()
'concat(c.code,":", b.code) AS requete'); // permet aux appelants de récupérer la valeur qu'ils recherchent
$this->mesChamps = implode(', ', $this->mesChamps);
 
$this->mesJoinsEtConditions =
// alias de la table première
" a "
. " LEFT JOIN {$this->table} b ON a.id = b.id LEFT JOIN {$this->table} c ON b.classe_id = c.id"
. " WHERE ";
 
$or_stack = false;
$tab = explode(',', $this->ressources[0]);
foreach($tab as $couple) {
preg_match('/^([^:]+):([^:]+)$/', $couple, $match);
if($or_stack) {
// une fois qu'un set de condition et présent,
// les autres sont `OR`-ed.
$this->mesJoinsEtConditions .= " OR ";
}
$this->mesJoinsEtConditions .=
sprintf("(b.code = %s AND c.code = %s)",
$this->getBdd()->proteger($match[2]),
$this->getBdd()->proteger($match[1]));
$or_stack = true;
}
}
 
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() {
if($this->mesChamps) return $this->mesChamps;
 
$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, $champs_possibles)) {
$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() {
if($this->mesJoinsEtConditions) return $this->mesJoinsEtConditions;
 
$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/ids' : $reponse = $this->formaterMultipleOntologiesId($resultat); 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 __anonyme1($val) { return $val != ''; }
 
public function formaterOntologiesId($resultat) {
$table_retour = array_filter($resultat, array($this, '__anonyme1'));
$this->calculerClassID($table_retour);
return $table_retour;
}
 
public function formaterMultipleOntologiesId($resultats) {
$result = Array();
foreach($resultats as $k => $resultat) {
$id = $resultat['requete'];
$result[$id] = array_filter($resultat, array($this, '__anonyme1'));
unset($result[$id]['requete']);
$this->calculerClassID($result[$id]);
}
return $result;
}
 
public function calculerClassID(&$resultat) {
// commenté: pourquoi restreindre le choix des champs au format "max",
// ça ne semble pas logique...
// if ($this->retour_format != 'max') return;
 
// question: pourquoi ne pas passer les infos relatives aux ontologies 0 ?
// et que signifie ce commentaire: "pas de parent"
if (@$resultat['classe_id'] == '0') return;
 
$valeur = isset($resultat['classe_id']) ? $resultat['classe_id'] : $resultat['classe.id'];
if(! isset($resultat['classe.id'])) {
$resultat['classe.id'] = $resultat['classe_id'];
unset($resultat['classe_id']);
}
 
// max-format et pas de champs spécifiques demandés ?
// Alors on rempli "classe" et "classe.href"
// Mais ne pas recalculer (surtout la classe) si ce n'est pas nécessaire
// (c'est le cas si l'on a demandé plusieurs critère [provenons de formaterMultipleOntologiesId()])
if (! isset($this->parametres['retour_champs'])) {
if(! isset($resultat['classe'])) {
$nom_classe = $this->ajouterClasseCorrespondante($valeur);
if (isset($nom_classe)) $resultat['classe'] = $nom_classe;
}
if(! isset($resultat['classe.href'])) {
$resultat['classe.href'] = $this->ajouterHref('ontologies', $valeur);
}
return;
}
 
// cas où des champs sont demandés
$champs = explode(',', $this->parametres['retour_champs']);
if(in_array('classe', $champs) && ! isset($resultat['classe'])) {
$this->ajouterClasseCorrespondante($valeur);
}
 
if(in_array('classe.id', $champs) && ! isset($resultat['classe.id'])) {
$resultat['classe.id'] = $valeur;
}
 
if(in_array('classe.href', $champs) && ! isset($resultat['classe.href'])) {
$resultat['classe.href'] = $this->ajouterHref('ontologies', $valeur);
}
 
if(in_array('classe.*', $champs) && (! isset($resultat['classe.href']) || ! isset($resultat['classe.id']))) {
$resultat['classe.id'] = $valeur;
$resultat['classe.href'] = $this->ajouterHref('ontologies', $valeur);
}
}
 
/** 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.6-arganeraie/services/modules/0.1/baseveg/precisions_sur_niveaux.txt
New file
0,0 → 1,16
Précisions pour les ontologies : voir le fichier log dans le script de baseveg.
 
 
niveaux existants :
ORD,ALL,ASS,CLA,SUBCLA,SUBORD,SUBASS,SUBCLA,SUBALL,BC,DC,GRPT
A ce jour je ne connais pas le sens de BC et DC.
synonymes :
"syn" suivi de un ou plusieurs des termes suivants :
incl,=,= ?,illeg,pp,pmaxp,pminp,compl,ambig,non,inval,nn,ined
on rencontre parfois des textes entre [ ] comme dans : " syn incl illeg [pro race hyperatlantique] ".
catminat : certains codes comme 01/A6.0.1.0.1/01 comportent des lettres (probablement pour bdafx (algues)).
ces cas ont été ignorés.
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/tags/v5.6-arganeraie/services/modules/0.1/baseveg/syntaxons/SyntaxonsCode.php
New file
0,0 → 1,107
<?php
/**
*
* /syntaxons?masque.catminat=#catminat&masque.niveau=#niveau etc.--> retourne les syntaxons répondant à ces critères
* /syntaxons/cle:#cle --> retourne les informations de ce syntaxon ( peut être un synonyme )
*
* Remarque : le code fixe n'est pas tout à fait unique puisque certaines valeurs (ex. 1489)
* apparaissent 2 ou 3 fois avec des codes catminat ou des syntaxons sensiblement différents.
* C'est pourquoi il n'est pas utilisé.
*
*
* @package eflore-projets
* @author mathilde Salthun-Lassalle
* @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 SyntaxonsCode extends SyntaxonsCommun {
public function consulter($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
$this->traiterRessources();
$this->traiterParametres();
$this->definirTables();
$resultats = null;
$requete = '';
foreach ($this->table_version as $version) {
$this->table = $version;
$requete = $this->assemblerLaRequete();
$resultat = $this->Bdd->recupererTous($requete);
$versionResultat = $this->traiterResultat($resultat, $version);
if (count($this->table_version) > 1) {
$resultats[$version] = $versionResultat;
} else {
$resultats = $versionResultat;
}
}
return $resultats;
}
function __construct(Conteneur $conteneur) {
parent::__construct($conteneur);
}
 
//+-------------------------------------traitement des ressources et des paramètres----------------------------------------+//
public function traiterRessources() {
$catminat='';
if(preg_match("/catminat:(([0-9]{2}\-$)|([0-9]{2}\-[0-9]\.$)|([0-9]{2}\-(?:[0-9]\.){1,5}[0-9]$)|([0-9]{2}\-(?:[0-9]\.){4,5}[0-9]\-[0-9]+(?:bis|ter|quater){0,1}$))/",$this->ressources[0], $retour)) {
$this->catminat = str_replace('-', '/',$retour[1]);
$this->requete_condition[] = ' code_catminat = \''.$this->catminat.'\' ' ;
$this->requete_condition[] = ' niveau NOT LIKE \'syn%\' ';
} elseif (preg_match("/cle:([0-9]+)/",$this->ressources[0], $retour)) {
$this->champs_recherches = ' * ';
$this->requete_condition[] = ' cle = '.$retour[1].' ' ;
}elseif ($this->ressources[0]) {
$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);
}
return $catminat;
}
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres) ) {
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
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.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break;
}
}
}
}
//+--------------------------formatages de resultats -------------------------------------------+
public function retournerResultatFormate($resultat) {
$resultat_json = array();
foreach ($resultat as $cle => $res) {
$resultat[$cle] = array_merge($resultat[$cle],$this->traiterOntologieNiveau($res['niveau']));
unset($resultat[$cle]['niveau']);
$resultat[$cle] = $this->enleverValeursVides($resultat[$cle]);
}
$resultat_json['resultat'] = $resultat;
return $resultat_json;
}
 
}
 
?>
/tags/v5.6-arganeraie/services/modules/0.1/baseveg/syntaxons/SyntaxonsTous.php
New file
0,0 → 1,152
<?php
/**
*
* /syntaxons --> retourne l'ensemble des tuples de la table
* /syntaxons?masque.catminat=#catminat&masque.niveau=#niveau etc.--> retourne les syntaxons répondant à ces critères
*
* * @package eflore-projets
* @author mathilde Salthun-Lassalle
* @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 SyntaxonsTous extends SyntaxonsCommun {
 
function __construct(Conteneur $conteneur) {
parent::__construct($conteneur);
$this->champs_recherches = 'cle, code_catminat, syntaxon, code_fixe_nom, code_natura_2000, niveau ';
}
public function consulter($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
$this->traiterParametres();
$this->definirTables();
$resultats = null;
foreach ($this->table_version as $version) {
$this->table = $version;
$requete = $this->assemblerLaRequete();
$resultat = $this->Bdd->recupererTous($requete);
// puisque notre implémentation de retournerResultatFormate() n'utilise pas NULL
// et que le prototype de Commun::traiterResultat() doit être respecté, nous passons
// NULL comme second paramètre.
$versionResultat = $this->traiterResultat($resultat, NULL);
if (count($this->table_version) > 1) {
$resultats[$version] = $versionResultat;
} else {
$resultats = $versionResultat;
}
}
return $resultats;
}
//+-------------------------------------traitement des ressources et des paramètres----------------------------------------+//
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres) ) {
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'navigation.depart' :
$this->definirNavigationDepart($valeur);
break;
case 'navigation.limite' :
$this->definirNavigationLimite($valeur);
break;
case 'version.projet' :
$this->traiterVersion($valeur);
break;
case 'masque.catminat' :
$this->traiterCatminat($valeur);
break;
case 'masque.niveau' :
$this->traiterNiveau($valeur);
break;
case 'masque.retenu' :
$this->traiterRetenu($valeur);
break;
case 'masque.fixe' :
$this->requete_condition[] = ' code_fixe_nom = \''.$valeur.'\' ';
break;
case 'retour.champs' :
$this->champs_recherches .= ','.$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;
}
}
}
}
public function traiterRetenu($valeur) {
$valeur = trim($valeur);
if( $valeur == 'true') {
$this->requete_condition[] = ' niveau NOT LIKE \'syn%\' ';
} elseif ( $valeur == 'false') {
$this->requete_condition[] = ' niveau LIKE \'syn%\' ';
}
}
public function traiterCatminat($valeur) {
$valeur = trim($valeur);
$valeur = str_replace('-', '/', $valeur);
$this->requete_condition[] = ' code_catminat = '.$this->getBdd()->proteger($valeur).'';
}
public function traiterNiveau($valeur) {
$valeur = strtoupper(trim($valeur));
if (in_array($valeur,$this->niv)) {
$this->requete_condition[] = ' niveau = '.$this->getBdd()->proteger($valeur).'';
//$this->requete_condition[] = ' code_catminat = '.$this->catminat.'';
} else {
$e = "Erreur : valeur inconnue pour masque.niveau."
." valeurs possibles : ALL|ORD|CLA|SUBCLA|SUBORD|SUBALL|ASS|SUBASS|BC|DC|GRPT";
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
}
//+--------------------------formatages de resultats -------------------------------------------+
public function retournerResultatFormate($resultat) {
$resultat_json = array();
$resultat_json['entete'] = $this->ajouterEnteteResultat();
foreach ($resultat as $cle => $res) {
$resultat[$cle]['href'] = $this->ajouterHref('syntaxons','cle:'.$res['cle']);
$resultat[$cle] = array_merge($resultat[$cle],$this->traiterOntologieNiveau($res['niveau']));
unset($resultat[$cle]['niveau']);
}
$resultat_json['resultat'] = $resultat;
return $resultat_json;
}
public function ajouterEnteteResultat() {
$entete['depart'] = $this->limite_requete['depart'];
$entete['limite'] = $this->limite_requete['limite'];
$entete['total'] = $this->total_resultat;
$entete['version'] = $this->version_projet;
$ressources = (empty($this->ressources)) ? '/syntaxons' : '/syntaxons/' ;
$url = $this->formulerUrl($this->total_resultat, $ressources.implode('/',$this->ressources));
if (isset($url['precedent']) && $url['precedent'] != '') {
$entete['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$entete['href.suivant'] = $url['suivant'];
}
return $entete;
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/baseveg/syntaxons/SyntaxonsRelation.php
New file
0,0 → 1,256
<?php
/**
*
* syntaxons/relations -> retourne toutes les relations d'un syntaxon en fonction du numéro catminat
*
* /syntaxons/catminat:#code_catminat/relations/niveaux_sup --> retourne les niveaux supérieurs d'un syntaxon
* /syntaxons/catminat:#code_catminat/relations/synonymie --> retourne tous les synonymes pour un code catminat
*
* @package eflore-projets
* @author mathilde Salthun-Lassalle
* @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 SyntaxonsRelation extends SyntaxonsCommun{
public function consulter($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
$this->traiterRessources();
$this->traiterParametres();
$this->definirTables();
$resultats = null;
$requete = '';
foreach ($this->table_version as $version) {
$this->table = $version;
$requete = $this->assemblerLaRequete();
$resultat = $this->Bdd->recupererTous($requete);
$versionResultat = $this->traiterResultat($resultat, $this->version_projet);
if (count($this->table_version) > 1) {
$resultats[$version] = $versionResultat;
} else {
$resultats = $versionResultat;
}
}
return $resultats;
}
 
 
function __construct(Conteneur $conteneur) {
parent::__construct($conteneur);
$this->champs_recherches = 'cle, code_catminat, syntaxon, code_fixe_nom, code_natura_2000, niveau ';
}
 
//surchargée car le web-service est appelé par SyntaxonsRelationsToutes.
//ne doit pas renvoyer une erreur mais un résultat vide.
public function traiterResultat($resultat, $version) {
$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);
} else {
$versionResultat = 'Les données recherchées sont introuvables';
}
return $versionResultat;
}
 
//+-------------------------------------traitement des ressources et des paramètres----------------------------------------+//
public function traiterRessources() {
$catminat='';
if(preg_match("/catminat:(([0-9]{2}\-$)|([0-9]{2}\-[0-9]\.$)|([0-9]{2}\-(?:[0-9]\.){1,5}[0-9]$)|([0-9]{2}\-(?:[0-9]\.){4,5}[0-9]\-[0-9]+(?:bis|ter|quater){0,1}$))/",$this->ressources[0], $retour)) {
$this->catminat = str_replace('-', '/',$retour[1]);
$this->traiterRessourcesRelations();
}elseif ($this->ressources[0]) {
$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);
}
return $catminat;
}
public function traiterRessourcesRelations(){
if($this->ressources[1] == 'relations') {
switch($this->ressources[2]) {
case 'niveaux-sup':
$catminat_sup = $this->chercherCatminatSuperieurs();
if (!empty($catminat_sup)) {
if (count($catminat_sup)>1) {
$this->requete_condition[] = ' code_catminat in ('.implode(',',$catminat_sup).')';
} else {
$this->requete_condition[] = ' code_catminat = '.$catminat_sup[0].' ';
}
} else {
$e = 'Erreur dans l\'url de votre requête : le code catminat est trop court.';
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
break;
case 'synonymie' :
$this->requete_condition[] = " niveau LIKE 'syn%' and code_catminat = '".$this->catminat."' " ;
break;
default :
$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);
}
} 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);
}
}
//ne renvoie que les supérieurs ( sans la valeur initiale )
public function chercherCatminatSuperieurs() {
$catminat_sup = array();
$catminat_slash = explode('/',$this->catminat);
$catminat_slash = $this->enleverValeursVides($catminat_slash);
$taille_slash = count($catminat_slash);
if ($taille_slash > 1) {
$catminat_sup[0] = "'".array_shift($catminat_slash)."/'";
$niveaux = array_shift($catminat_slash);
$unites = explode('.',trim($niveaux)); //attention explode peut renvoyer des cases vides (voir la doc php)
$unites = $this->enleverValeursVides($unites);
$taille = ($taille_slash == 3) ? count($unites) : count($unites)-1 ;
for ($i=0; $i< $taille ; $i++) {
$sup = "'".trim($catminat_sup[$i],"'");
if ($i == 0) {
$sup .= $unites[$i].".'";
} elseif ($i == 1) {
$sup .= $unites[$i]."'";
} else {
$sup .= ".".$unites[$i]."'";
}
$catminat_sup[] = $sup;
}
}
return $catminat_sup;
}
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres) ) {
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'navigation.depart' :
$this->definirNavigationDepart($valeur);
break;
case 'navigation.limite' :
$this->definirNavigationLimite($valeur);
break;
case 'version.projet' :
$this->traiterVersion($valeur);
break;
case 'masque.catminat' :
$this->traiterCatminat($valeur);
break;
case 'masque.niveau' :
$this->traiterNiveau($valeur);
break;
case 'masque.fixe':
$this->requete_condition[] = ' code_fixe_nom = \''.$valeur.'\' ';
break;
case 'retour.champs' :
$this->champs_recherches .= ','.$valeur.' ';
break;
case 'masque.retenu' :
$this->traiterRetenu($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;
}
}
}
}
public function traiterRetenu($valeur) {
if ($this->ressources[2] == 'niveaux-sup') {
$valeur = trim($valeur);
if( $valeur == 'true') {
$this->requete_condition[] = ' niveau NOT LIKE \'syn%\' ';
} elseif ( $valeur == 'false') {
$this->requete_condition[] = ' niveau LIKE \'syn%\' ';
}
} else {
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " masque.retenu " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
public function traiterCatminat($valeur) {
if ($this->ressources[2] == 'niveaux-sup') {
$valeur = trim($valeur);
$valeur = str_replace('-', '/', $valeur);
$this->requete_condition[] = ' code_catminat = '.$this->getBdd()->proteger($valeur).'';
} else {
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " masque.catminat " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break;
}
}
public function traiterNiveau($valeur) {
if ($this->ressources[2] == 'niveaux-sup') {
$valeur = strtoupper(trim($valeur));
if (in_array($valeur,$this->niv)) {
$this->requete_condition[] = ' niveau = '.$this->getBdd()->proteger($valeur).'';
} else {
$e = "Erreur : valeur inconnue pour masque.niveau."
." valeurs possibles : ALL|ORD|CLA|SUBCLA|SUBORD|SUBALL|ASS|SUBASS|BC|DC|GRPT";
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
} else {
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " masque.niveau " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
//+--------------------------formatages de resultats -------------------------------------------+//
public function retournerResultatFormate($resultat) {
$resultat_json = array();
$resultat_json['entete'] = $this->ajouterEnteteResultat();
foreach ($resultat as $cle => $res) {
$resultat[$cle]['href'] = $this->ajouterHref('syntaxons','cle:'.$res['cle']);
$resultat[$cle] = array_merge($resultat[$cle],$this->traiterOntologieNiveau($res['niveau']));
unset($resultat[$cle]['niveau']);
}
$resultat_json['resultat'] = $resultat;
return $resultat_json;
}
public function ajouterEnteteResultat() {
$entete['depart'] = $this->limite_requete['depart'];
$entete['limite'] = $this->limite_requete['limite'];
$entete['total'] = $this->total_resultat;
$entete['version'] = $this->version_projet;
$ressources = (empty($this->ressources)) ? '/syntaxons' : '/syntaxons/' ;
$url = $this->formulerUrl($this->total_resultat, $ressources.implode('/',$this->ressources));
if (isset($url['precedent']) && $url['precedent'] != '') {
$entete['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$entete['href.suivant'] = $url['suivant'];
}
return $entete;
}
 
}
 
?>
/tags/v5.6-arganeraie/services/modules/0.1/baseveg/syntaxons/SyntaxonsCommun.php
New file
0,0 → 1,195
<?php
/**
*
* fonctions et paramètres communs aux traitement des syntaxons
* - traitement de l'ontologie
* - fonction utiles pour les paramètres de configuration entre autres
* - traitement des tables et de leur version
* - traitement de la requête
*
* @package eflore-projets
* @author mathilde Salthun-Lassalle
* @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)
*/
 
require_once(dirname(__FILE__) . '/../../baseflor/Informations.php');
 
class SyntaxonsCommun extends Commun {
protected $table = "";
protected $format_reponse = 'syntaxons';
protected $serviceNom = 'syntaxons';
protected $Bdd;
protected $syn;
protected $niv;
protected $limite_requete = array('depart' => 0, 'limite' => 100);
protected $requete_condition = array();
protected $total_resultat;
protected $champs_recherches = ' * ';
protected $table_version;
protected $version_projet = '+' ;
static $cache = array();
public function __construct(Conteneur $conteneur) {
$this->Bdd = $conteneur->getBdd();
$this->syn = $this->getParametreTableauSpe('Paramètres.synonymes');
$this->niv = $this->getParametreTableauSpe('Paramètres.niveaux');
}
 
 
//+---------------------------------------------------outils------------------------------------------------//
protected function getParametreTableauSpe($cle) {
$tableau = array();
$parametre = Config::get($cle);
if (empty($parametre) === false) {
$tableauPartiel = explode(',', $parametre);
$tableauPartiel = array_map('trim', $tableauPartiel);
foreach ($tableauPartiel as $champ) {
$tableau[] = trim($champ,"'");// spécificité pour le = ? des synonymes
}
}
return $tableau;
}
//la fonction php array_filters ne marche pas sur le serveur
protected function enleverValeursVides($tableau) {
$tab = array();
foreach ($tableau as $cle => $valeur) {
if ($valeur != '' && is_int($cle)) {
$tab[] = $valeur;
} elseif ($valeur != '' && is_string($cle)) {
$tab[$cle] = $valeur;
}
}
return $tab;
}
//+++------------------------------traitement des versions----------------------------------------++
protected 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);
}
}
protected function definirTables() {
$table_num_version = $this->recupererVersionDisponible();
$prefixe_table = config::get('bdd_table');
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);
}
}
//+------------------------------------ontologies----------------------------------------------------+
protected function recupererOntologiesNiveau($valeur, $code){
$ontologie = array();
$url = Config::get('url_service_base').Config::get('nom_projet').
'/ontologies/'.$code.':'.urlencode(urlencode($valeur));
if(array_key_exists($url, self::$cache)) {
$val = self::$cache[$url];
} else {
$val = $this->consulterHref($url);
self::$cache[$url] = $val;
}
$ontologie['niveau.code'] = $valeur;
$ontologie['niveau.libelle'] = $val->nom;
$ontologie['niveau.href'] = $url;
return $ontologie;
}
protected function recupererOntologiesNiveauSyn($niveau){
$ontologie = array();
$synonymes = explode(' ',$niveau[1]);
$libelle = array();
$detail = array();
foreach ($synonymes as $syn) {
if ($syn == '=') {
$syn = 'equi';
} elseif ($syn == '= ?') {
$syn = 'prob';
}
if ($syn != '' && $syn != '?') {
$detail[] = $this->recupererOntologiesNiveau($syn, 'syn');
$dernier = end($detail);
$libelle[] = $dernier['niveau.libelle'].' ';
}
}
$ontologie['niveau.code'] = $niveau[0];
$ontologie['niveau.libelle'] = 'synonyme '.implode(' - ',$libelle);
if (isset($niveau[2])) {
$ontologie['niveau.libelle'] .= ' '.$niveau[2];
}
$ontologie['niveau.detail'] = $detail;
return $ontologie;
}
protected function traiterOntologieNiveau($niveau) {
$ontologie = array();
if ( preg_match('/syn {0,1}(['.implode($this->syn).']*)( *\[.+\])*/',$niveau,$retour)) {
$ontologie = $this->recupererOntologiesNiveauSyn($retour);
} else {
$ontologie = $this->recupererOntologiesNiveau($niveau, 'UP');
}
return $ontologie;
}
//+--------------------------FONCTIONS D'ASSEMBLAGE DE LA REQUETE-------------------------------------------+
protected function assemblerLaRequete() {
$requete = ' SELECT '.$this->champs_recherches.' FROM '.$this->table.' '
.Informations::retournerRequeteCondition($this->requete_condition).' '.$this->delimiterResultatsRequete();
return $requete;
}
protected function delimiterResultatsRequete() {
$this->total_resultat = Informations::calculerTotalResultat(
$this->getBdd(),
$this->table,
Array(),
$this->requete_condition);
 
$requete_limite = '';
if (($this->limite_requete['depart'] <= $this->total_resultat) ){
if (($this->limite_requete['limite'] + $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;
}
 
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/baseveg/syntaxons/SyntaxonsRelationsToutes.php
New file
0,0 → 1,89
<?php
/**
*
* syntaxons/relations -> retourne toutes les relations d'un syntaxon en fonction du numéro catminat
*
* * @package eflore-projets
* @author mathilde Salthun-Lassalle
* @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 SyntaxonsRelationsToutes extends SyntaxonsCommun {
 
public function consulter($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
$this->traiterParametres();
$resultats = null;
$resultat = $this->retournerResultatRelations();
// puisque notre implémentation de retournerResultatFormate() n'utilise pas NULL
// et que le prototype de Commun::traiterResultat() doit être respecté, nous passons
// NULL comme second paramètre.
$versionResultat = $this->traiterResultat($resultat, NULL);
$resultats = $versionResultat;
return $resultats;
}
 
// si je ne réinstancie pas la classe entre les appels à la méthode consulter, çà ne marche pas !
private function retournerResultatRelations () {
$resultat_relation = array();
$classe = new SyntaxonsRelation(new Conteneur());
$ressources_syn = array_merge($this->ressources, array('synonymie') );
$synonymie = $classe->consulter($ressources_syn,$this->parametres);
if ($synonymie != 'Les données recherchées sont introuvables') {
$resultat_relation['synonymie'] = $synonymie['resultat'];
}
$ressources_niv = array_merge($this->ressources, array('niveaux-sup') );
$classe = new SyntaxonsRelation(new Conteneur());
$niveaux = $classe->consulter($ressources_niv,$this->parametres);
if ($niveaux != 'Les données recherchées sont introuvables') {
$resultat_relation['niveaux_superieurs'] = $niveaux['resultat'];
}
return $resultat_relation;
}
//+-------------------------------------traitement des ressources et des paramètres----------------------------------------+//
 
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres) ) {
foreach ($this->parametres as $param => $valeur) {
if ($param != 'version.projet' || $param != 'retour.champs' ) {
$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);
}
}
}
}
 
//+--------------------------formatages de resultats -------------------------------------------+
public function retournerResultatFormate($resultat) {
$resultat_json = array();
$resultat_json['entete']['catminat'] = str_replace('-','/',$this->ressources[0]);
$resultat_json['resultat'] = $resultat;
return $resultat_json;
}
 
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/baseveg/Ontologies.php
New file
0,0 → 1,345
<?php
/**
Classe Ontologies.php fournit des informations sur ensemble structuré des termes et concepts représentant les éléments
* d'un domaine de connaissances pour le projet baseveg.
*/
 
class BasevegOntologies extends Commun {
 
protected $requete_condition = null;
/** 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 = 'baseveg_ontologies';
$this->recupererNomChamp($this->table);
$this->traiterRessources();
$requete = $this->assemblerLaRequete();
$resultat = $this->getBdd()->recupererTous($requete);
$versionResultat = $this->traiterResultat($resultat, '');
$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 'navigation.depart' : $this->limite_requete['depart'] = $valeur; break;
case 'navigation.limite' : $this->limite_requete['limite'] = $valeur; 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 = BINARY '.$this->getBdd()->proteger($match[2])
.' AND classe_id = (SELECT id FROM '.$this->table.' WHERE code = BINARY '.$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) {
if ($classe_id == 0) return NULL;
 
$nom = '';
$req = 'SELECT nom FROM '.$this->table.' WHERE id = '.$this->getBdd()->proteger($classe_id);
$res = $this->getBdd()->recuperer($req . ' -- ' . __FILE__ . ':' . __LINE__);
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.6-arganeraie/services/modules/0.1/baseveg/Syntaxons.php
New file
0,0 → 1,85
<?php
/**
* Classe Syntaxons.php permet de faire des requetes de baseveg autour du code CATMINAT ou des niveaux de syntaxons
* Un syntaxon est une unité de végétation ( groupement )
* Cette classe analyse les ressources pour rediriger vers la classe du web service correpondant
*
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Syntaxons
*
* 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 Syntaxons extends Commun {// héritage de commun à cause du cache !
private $sousService;
public function consulter($ressources, $parametres) {
spl_autoload_register(array($this, 'chargerSyntaxons'));
$this->parametres = $parametres;
$this->ressources = $ressources;
$this->analyserRessources();
$resultat = $this->executerSousService();
return $resultat;
}
private function analyserRessources() {
$nb_ressources = count($this->ressources);
switch ($nb_ressources) {
case 0 : // syntaxons/
$this->sousService = 'SyntaxonsTous';
break;
case 1 : // syntaxons/#type_code:#code
$this->sousService = 'SyntaxonsCode';
break;
case 2 : // syntaxons/code catminat/relations
$this->sousService = 'SyntaxonsRelationsToutes';
break;
case 3 : // syntaxons/code catminat/relations /#type_relation
$this->sousService = 'SyntaxonsRelation';
break;
default:
$message = 'Erreur dans l\'url de votre requête : </br> La ressource demandée n\'existe pas.';
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
break;
}
}
private function executerSousService() {
if (isset($this->sousService)) {
$classe = $this->sousService;
//require_once dirname(__FILE__).DS.'syntaxons'.DS.$classe.'.php';
$sousService = new $classe(new Conteneur());
$resultat = $sousService->consulter($this->ressources, $this->parametres);
} else {
$message = "L'analyse des ressources n'a pu aboutir à déterminer le sous service à executer.";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
return $resultat;
}
 
private function chargerSyntaxons($classe) {
$base = dirname(__FILE__).DS;
$chemin = $base.DS.'syntaxons'.DS;
$fichierATester = $chemin.$classe.'.php';
if (file_exists($fichierATester)) {
include_once $fichierATester;
return null;
}
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/Projets.php
New file
0,0 → 1,332
<?php
/**
* Description :
* Classe principale de chargement des services d'eFlore.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package eflore-projets
* @author Jennifer DHÉ <jennifer.dhe@tela-botanica.org>
* @author Delphine CAUQUIL <delphine@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 0.1
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org)
*/
class Projets extends RestService {
 
/** Contients les paramètres.*/
private $parametres = array();
/** Contients les ressources.*/
private $ressources = array();
 
/** Nom du projet courrant. */
private $projetNom = array();
/** Nom du service demandé. */
private $serviceNom = array();
/** Chemin vers le dossier courrant. */
private $cheminCourrant = null;
private $classe = null;
 
private $cache;
 
/** Indique si oui (true) ou non (false), on veut utiliser les paramètres brutes. */
protected $utilisationParametresBruts = true;
 
public function __construct() {
$this->cheminCourrant = dirname(__FILE__).DS;
}
 
public function consulter($ressources, $parametres) {
$resultat = '';
$reponseHttp = new ReponseHttp();
try {
$this->initialiserRessourcesEtParametres($ressources, $parametres);
$resultat = $this->traiterRessources();
$reponseHttp->setResultatService($resultat);
} catch (Exception $e) {
$reponseHttp->ajouterErreur($e);
}
if(strpos($_SERVER['SCRIPT_NAME'], 'phpunit') === FALSE) $reponseHttp->emettreLesEntetes();
$corps = $reponseHttp->getCorps();
return $corps;
}
 
private function initialiserRessourcesEtParametres($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
}
 
private function traiterRessources() {
$retour = '';
if ($this->avoirRessources()) {
if ($this->avoirRessourceProjet()) {
$this->chargerNomDuService(); // défini $this->serviceNom
$this->initialiserProjet(); // autoload defined here
if ($this->avoirRessourceService()) {
$this->classe = self::debusquerClasse($this->projetNom, $this->serviceNom);
$retour = $this->initialiserService();
}
}
}
return $retour;
}
 
private function avoirRessources() {
$presenceDeRessources = false;
if (isset($this->ressources) && count($this->ressources) > 0) {
$presenceDeRessources = true;
} else {
$message = "Aucune ressource n'a été indiquée.\n".
"Veuillez indiquer au moins un code de projet et un type de service.";
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
return $presenceDeRessources;
}
 
private function avoirRessourceProjet() {
$presenceRessourceProjet = false;
$projet = $this->ressources[0];
$projetsDispo = Outils::recupererTableauConfig('projetsDispo');
if (in_array($projet, $projetsDispo)) {
$presenceRessourceProjet = true;
} else {
$message = "La ressource '$projet' n'indique pas un projet existant.\n".
"Les projets existant sont :\n".implode(', ', $projetsDispo);
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
return $presenceRessourceProjet;
}
 
private function initialiserProjet() {
$this->chargerNomDuProjet();
$this->chargerConfigProjet();
 
// php5.3 : Enregistrement en première position des autoload de la méthode gérant les classes des services
if (phpversion() < 5.3) {
spl_autoload_register(array($this, 'chargerClasseProjet'));
} else {
spl_autoload_register(array($this, 'chargerClasseProjet'), true , true);
}
}
 
private function chargerNomDuProjet() {
$this->projetNom = $this->ressources[0];
}
 
private function chargerConfigProjet() {
$projet = $this->projetNom;
$chemin = Config::get('chemin_configurations')."config_$projet.ini";
Config::charger($chemin);
}
 
/*
1) jusqu'à présent:
* le principe pour URL = a/b est: de charger
* require_once($chemin/a/ucfirst(c).php)
* new ucfirst(c); ucfirst(c)->consulter()
* sachant que ucfirst(c).php et la classe ucfirst(c) apparaîssent à de multiples emplacements (selon a)
 
1") Beurk... (php-className conflicts en PHP 5.2)
 
Ici nous faisons des cas particuliers pour Ontologies, mais en suivant ce principe, sont affectés:
Images, Informations, InformationsTaxonsSup,
LegendeCartes, NomCommune, Noms, NomsVernaculaires, Projets, Statuts,
Taxons, TaxonsCartes, Textes, ZoneGeo
 
cf:
$ grep -r '^[cC]lass '|grep -F '.php:'|egrep -w " \($(grep -rh '^[cC]lass '|awk '{print $2}'|sort|uniq -d|tr "\n" '|')\) " \
|sort -k2
 
PS: "Using two class with the same name"
http://stackoverflow.com/questions/4555186/using-two-class-with-the-same-name
> Stop.
> Whatever you are doing is wrong. Backup. Re-evaluate what you are doing and why.
*/
private static function debusquerClasse($p, $s) {
if($s == 'ontologies') {
switch($p) {
case 'baseflor':
return 'BaseFloreOntologies';
case 'eflore':
return 'EfloreOntologies';
case 'chorodep':
return 'ChorodepOntologies';
case 'baseveg':
return 'BasevegOntologies';
case 'moissonnage':
return 'MoissonnageOntologies';
case 'commun':
return 'Ontologies';
}
}
 
if($s == 'cartes') {
switch($p) {
case 'bdtxa':
return 'BdtxaCartes';
case 'eflore':
return 'EfloreCartes';
case 'chorodep':
return 'ChorodepCartes';
case 'moissonnage':
return 'MoissonnageCartes';
case 'sophy':
return 'SophyCartes';
}
}
 
return NULL;
}
 
private function chargerClasseProjet($classe) {
if (class_exists($classe)) {
return null;
}
 
if($this->serviceNom == 'ontologies') {
$c = NULL;
switch($this->projetNom) {
case 'baseflor':
$c = 'BaseFloreOntologies';
break;
case 'eflore':
$c = 'EfloreOntologies';
break;
case 'chorodep':
$c = 'ChorodepOntologies';
break;
case 'baseveg':
$c = 'BasevegOntologies';
break;
case 'moissonnage':
$c = 'MoissonnageOntologies';
break;
case 'commun':
$c = 'Ontologies';
break;
}
if($c) {
require_once($this->cheminCourrant . 'commun' . DS . 'Commun.php');
require_once($this->cheminCourrant . $this->projetNom . DS . $this->obtenirNomClasseService($this->serviceNom) . '.php');
return;
}
}
 
// problème de class-name conflict. Exemple:
// phpunit --verbose --debug --filter 'ChorodepCartesTest::testCarteGenerique|EfloreCartesTest::testCarteGenerale'
if($this->serviceNom == 'cartes') {
$c = NULL;
switch($this->projetNom) {
case 'bdtxa':
$c = 'BdtxaCartes';
break;
case 'eflore':
$c = 'EfloreCartes';
break;
case 'chorodep':
$c = 'ChorodepCartes';
break;
case 'moissonnage':
$c = 'MoissonnageCartes';
break;
case 'sophy':
$c = 'SophyCartes';
break;
}
if($c) {
require_once($this->cheminCourrant . 'commun' . DS . 'Commun.php');
require_once($this->cheminCourrant . $this->projetNom . DS . $this->obtenirNomClasseService($this->serviceNom) . '.php');
return;
}
}
 
$cheminBiblio = Config::get('chemin_bibliotheque');
$chemins = array();
$chemins[] = $this->cheminCourrant.$this->projetNom.DS;
$chemins[] = $this->cheminCourrant.'commun'.DS;
$chemins[] = $cheminBiblio;
$chemins[] = $cheminBiblio.'robots'.DS;
 
foreach ($chemins as $chemin) {
$chemin = $chemin.$classe.'.php';
if (file_exists($chemin)) {
require_once $chemin;
break;
}
}
}
 
private function avoirRessourceService() {
$presenceRessourceService = false;
$servicesDispo = Outils::recupererTableauConfig('servicesDispo');
if (isset($this->ressources[1])) {
$service = $this->ressources[1];
if (in_array($service, $servicesDispo)) {
$presenceRessourceService = true;
} else {
$message = "Le service demandé '$service' n'est pas disponible pour le projet {$this->projetNom} !\n".
"Les services disponibles sont : ".implode(', ', $servicesDispo);
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
} else {
$message = "Vous n'avez pas indiqué de service pour le projet {$this->projetNom} !\n".
"Les services disponibles sont : ".implode(', ', $servicesDispo);
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
return $presenceRessourceService;
}
 
private function initialiserService() {
if($this->classe) {
$classe = $this->classe;
$service = new $classe($this->getBdd());
return $service->consulter($this->filtrerRessourcesPourService(), $this->parametres, $this->getBdd());
}
$classe = $this->obtenirNomClasseService($this->serviceNom);
$chemins = array();
$chemins[] = $this->cheminCourrant.$this->projetNom.DS.$classe.'.php';
$chemins[] = $this->cheminCourrant.'commun'.DS.$classe.'.php';
 
$service = null;
foreach ($chemins as $chemin) {
if (file_exists($chemin)) {
$service = new $classe($this->getBdd());
// Affichage utile lors de PHPUnit pour détecter les conflits d'autoload de classes de même nom
// $reflector = new ReflectionClass($classe);
// printf("===> Projets init classe '%s' depuis '%s', mais provenant de '%s'\n", $classe, $chemin, $reflector->getFileName());
$ressourcesPourService = $this->filtrerRessourcesPourService();
return $service->consulter($ressourcesPourService, $this->parametres, $this->getBdd());
}
}
if (is_null($service)) {
$message = "Le service demandé '{$this->serviceNom}' n'existe pas dans le projet {$this->projetNom} !";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
return NULL;
}
 
private function chargerNomDuService() {
$this->serviceNom = $this->ressources[1];
}
 
private function obtenirNomClasseService($mot) {
return str_replace(' ', '', ucwords(strtolower(str_replace('-', ' ', $mot))));
}
 
private function filtrerRessourcesPourService() {
$ressourcesPourService = array();
$nbreDeRessources = count($this->ressources);
for ($i = 2; $i < $nbreDeRessources; $i++) {
$ressourcesPourService[] = $this->ressources[$i];
}
return $ressourcesPourService;
}
}
?>
/tags/v5.6-arganeraie/services/modules/0.1/coste/CommunNomsTaxons.php
New file
0,0 → 1,785
<?php
 
abstract class CommunNomsTaxons extends Commun {
protected $table_param = array(); /** Permet de stocker le tableau des parametres (= $parametres) */
protected $table_ressources = array(); /** Permet de stocker le tableau des ressources (= $ressources) */
protected $table_retour; /** Permet de stocker le tableau de résultat (non encodé en json)*/
protected $resultat_req; /** Permet de stocker le résultat de la requete principale. */
/** Permet de stocker sous forme de tableau les composant du nom à ajouter au nom scientifique (fonction du paramètre ns.structure) */
protected $compo_nom;
protected $ordre_masque = array('masque', 'masque_sg', 'masque_gen', 'masque_sp', 'masque_ssp', 'masque_au',
'masque_an', 'masque_bib', 'masque_ad', 'masque_nn', 'masque_rg' );
protected $tab_nom_sci = array('nom_supra_generique', 'genre', 'epithete_infra_generique', 'epithete_sp',
'type_epithete', 'epithete_infra_sp', 'cultivar_groupe', 'cultivar', 'nom_commercial');
protected $retour_format = 'max';
protected $html = 'txt'; /** Valeur du paramètre de requete ns.format */
protected $table_version; /** Stocke les noms des tables de toutes les versions du projet disponibles */
/** Nom de la table dans laquelle on récupèrera les données (remplace Config::get('bdd_table') dans les requetes SQL */
protected $table;
protected $total_resultat = null;
/** Stocke le service appelé correspondant. Est utilisé principalement lors de l'affichage du href d'un synonyme
(ex id=12, basionyme num 25 est un synonyme) dans le service taxon */
protected $service_href = null;
//----------------------------------Fonctions d'analyse des ressources--------------------------------------------------
/** Permet de remplir la variable version_projet et de retirer cette donnée du tableau des ressources */
public function traiterVersionProjet(&$ressources) {
if (isset($ressources) && !empty($ressources)) {
if (preg_match('/(?:[0-9]+(?:_|[.])[0-9]+|[*])/', $ressources[0])) {
$this->version_projet = array_shift($ressources);
$this->version_projet = str_replace('_', '.', $this->version_projet);
} else {
if ($ressources[0] == ' ') array_shift($ressources); //si un + a été ajouté
$this->version_projet = '+';
}
}
//si la liste des noms est demandée pr toutes les versions, on affiche seulement la dernière version pour :
// - la liste des noms et taxons: /noms et /taxons
// - la liste des taxons inferieurs/supérieur : /taxons/relations/inferieurs et /taxons/relations/superieurs
// - la liste des relations : /taxons/relations ou /noms/relations
if ($this->version_projet == '*' && ($ressources == array()
|| (isset($ressources[1]) && $ressources[1] == 'relations' && isset($ressources[2]) && in_array($ressources[2], array('superieurs', 'inferieurs')))
|| (isset($ressources[1]) && $ressources[1] == 'relations' && !isset($ressources[2])) )) {
$this->version_projet = '+';
}
//on recupère les versions du projet disponible dans la table des meta-donnees (utilisation service MetaDonnees)
$table_num_version = $this->recupererVersionDisponible();
//on recupere la liste des noms des tables de la bdd correspondant aux differentes versions du projet en fct de la ou les versions demandées
$this->recupererListeNomTablePrChaqueVersion($table_num_version);
}
public function traiterRessources($ressources) {
$this->table_ressources = $ressources;
if (isset($ressources) && !empty($ressources)) {
if ($this->estUnIdentifiant()) { //l'identifiant peut etre de type /#id ou /nt:#id
$this->traiterRessourcesIdentifiant(); // dans le service noms ou taxons
} elseif ($this->table_ressources[0] == 'stats') { //ressource = noms/stats
$this->traiterRessourcesStats();
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur dans votre requete </br> Ressources disponibles : <br/>
<li> /'.$this->service.'/#id (id : L\'identifiant du nom rechercher)</li>
<li> /'.$this->service.'/nt:#id (id : Numero du taxon recherche)</li>
<li> /'.$this->service.'/stats </li>' );
}
}
}
public function traiterRessourcesStats() {
$this->format_reponse = $this->service.'/stats';
if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) {
switch ($this->table_ressources[1]) {
case 'annees' :
$this->traiterRessourceStatsAnnees();
break;
case 'rangs' :
$this->traiterRessourceStatsRangs();
break;
case 'initiales' :
$this->traiterRessourceStatsInitiales();
break;
default :
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur dans votre requete </br> Ressources disponibles : <br/>
<li> /'.$this->service.'/stats/annees </li>
<li> /'.$this->service.'/stats/rangs </li>
<li> /'.$this->service.'/stats/initiales </li>' );
break;
}
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur dans votre requete </br> Ressources disponibles : <br/>
<li> /'.$this->service.'/stats/annees </li>
<li> /'.$this->service.'/stats/rangs </li>
<li> /'.$this->service.'/stats/initiales </li>' );
}
}
/** Vérifie si la première valeur de la table de ressource est un identifiant : un numerique ou un numéro
* taxonomique sous la forme nt:xx */
public function estUnIdentifiant() {
return (is_numeric($this->table_ressources[0]) || (strrpos($this->table_ressources[0],'nt:') !== false
&& is_numeric(str_replace('nt:','',$this->table_ressources[0]))));
}
//---------------------------------------------Fonction d'analyse des parametres----------------------------------------
/** Permet de remplir le tableau compo_nom. Il comprendra en fct du paramètre ns.structure les éléments à rajouter
* au nom_sci (annee, auteur, biblio ou addendum).*/
public function remplirTableCompositionNom($valeur) {
$structure_nom = explode(",",$valeur);
foreach ($structure_nom as $structure) {
switch ($structure) {
case 'au' : $this->compo_nom['au'] = 'auteur'; break;
case 'an' : $this->compo_nom['an'] = 'annee'; break;
case 'bib' : $this->compo_nom['bib'] = 'biblio_origine'; break;
case 'ad' : $this->compo_nom['ad'] = 'nom_addendum'; break;
default : $this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur : Le parametre "'.$structure.'" n\'existe pas. <br/><br/>
Les parametres du nom possibles sont : <li> au (auteur)</li><li> an (annee)</li>
<li> bib (bibliographie)</li><li> ad (nom_addendum)</li>');
break;
}
}
}
/** Permet de recupérer le nom scientigfique au format html. Le champ nom_sci de la requete sql est remplacé par
* le champ nom_sci_html */
public function mettreAuFormat() {
if ($this->html == 'htm') {
if (strrpos($this->requete_champ, 'nom_sci_html as nom_sci') === false) {
$this->requete_champ = str_replace('nom_sci', 'nom_sci_html as nom_sci', $this->requete_champ);
}
} elseif ($this->html != 'txt') {
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur dans votre requete </br> ns.format = htm ou txt (par defaut)' );
}
}
 
//--------------------------------fonctions de formatage----------------------------------------------------------
 
/** Fonction permettant de creer la table dont le nom est passé en paramètre (champs_api, champs_bdtfx,
* correspondance_champs...). Les données de chaque table sont présentes dans le fichier de configuration config.ini
* @param String $table : Peut contenir plusieurs nom de table dont on souhaite récupérer les données : table,table,table.
* Ex : recupererTableSignification('champs_api,champs_bdtfx') */
public function recupererTableSignification($table) {
$tables = explode(',', $table);
foreach ($tables as $tab) {
if ($tab == 'champs_comp') {
$champ_bdnff_api = array_keys($this->champs_api); //on recupère le nom des champ ds la bdd
$this->champs_comp = array_diff($this->champs_table, $champ_bdnff_api);
} elseif ($tab == 'champs_api') {
foreach ($this->correspondance_champs as $key => $val) {
preg_match('/(hybride[.]parent_0[12](?:[.]notes)?|nom_sci[.][^.]+|[^.]+)(?:[.](id|code))?/', $val, $match);
$val = $match[1];
$this->champs_api[$key] = $val;
}
} else {
$tableau = explode(',', Config::get($tab));
$tableau = array_map('trim', $tableau);
foreach ($tableau as $champ) {
list($code, $rang) = explode('=', $champ);
$tab_tampon[$code] = $rang;
}
$this->$tab = $tab_tampon;
$tab_tampon = array();
}
}
}
public function formaterEnOss($resultat) {
$res = array();
$table_nom = array();
foreach ($resultat as $version => $res_version) {
$oss = '';
foreach ($res_version as $tab) {
if (isset($tab['nom_sci']) ) {
if (!in_array($tab['nom_sci'], $table_nom)) {
$table_nom[] = $tab['nom_sci'];
$oss [] = $tab['nom_sci'].$this->ajouterCompositionNom($tab);
}
}
}
$masque = $this->ordonnerMasque();
if ($masque == '') $masque = 'Pas de masque';
$table_retour_oss = array($masque, $oss);
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
$res = $this->afficherVersionOuPas($version, $table_retour_oss, $res);
}
return $res;
}
/** Permet de récupérer le masque de rang superieur parmi les parametres de la requete.
* Sera affiche dans l'entete du fichier json (clé 'masque') et oss.
* @return string le masque de rang supérieur ou '' si aucun masque n'a été mis en parametre de
* requete (la clé masque ne sera alors pas affichée dans l'entete).*/
public function ordonnerMasque() {
$masque = '';
foreach ($this->ordre_masque as $key => $filtre) {
if (isset($this->table_param[$filtre])) {
$masque .= '&'.$filtre.'='.$this->table_param[$filtre];
}
}
$masque = ltrim($masque, '&'); //on enlève le & du début
$masque = str_replace('masque_','',$masque);
return $masque;
}
/** Affiche l'entete du résultat pour le service /noms et /noms/relations. L'entete comprend le rang (s'il est un
* filtre), le départ, la limite, le total des résultats et les urls suivante et precedente. */
public function afficherEnteteRangBorneTotalUrls($resultat, $url_service) {
if (isset($this->table_param['masque_rg'])) $this->afficherDonnees('rang', $this->table_param['masque_rg']);
$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 precedentes et suivantes
$url = $this->formulerUrl($this->total_resultat, $url_service);
if ($url['precedent'] != '') { $this->table_retour['href.precedent'] = $url['precedent']; }
if ($url['suivant'] != '') { $this->table_retour['href.suivant'] = $url['suivant']; }
}
//----------------------------Fonction de formatage pour les services /#id/---------------------------------------------
/** Ajout du numero de la version au tableau de résultat à retourner :
* 'bdtfx_v2_00' : {'infos' : 'toto' ...}, 'bdtfx_v3_00' : {'infos' : 'tata' ...}
* @param string $num_version : numéro de version (sous la forme de l'intitulé du nom de la table bdd)
* @param array $tab : tableau contenant le resultat à retourner pour une version donnée
* @param array $res : tableau contenant le resultat à retourner pour toutes les versions disponibles */
public function afficherVersionOuPas($version, &$tab, &$res) {
if (count($this->table_version) > 1) {
$res[$version] = $tab;
$tab = array();
} else {
$res = $tab;
}
return $res;
}
public function formaterId($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$res = array();
foreach ($resultat as $version => $res_version) {
$res_version = $res_version[0];
$this->resultat_req = $res_version;
foreach ($res_version as $key => $valeur) {
if ($valeur != '') {
$this->afficherDonnees($key, $valeur);
}
}
unset($this->table_retour['href']);
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
$res = $this->afficherVersionOuPas($version, $this->table_retour, $res);
}
return $res;
}
public function formaterIdChamp($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$res = array();
foreach ($resultat as $version => $res_version) {
$res_version = $res_version[0];
$this->resultat_req = $res_version;
$this->table_retour['id'] = $res_version['num_nom'];
//on récupère les champs (le + est transformé en espace par le navigateur)
$tab_ress = explode(' ', $this->table_ressources[1]);
foreach ($tab_ress as $nom_champ_api) {
if ($this->verifierValiditeChamp($nom_champ_api)) {
switch ($nom_champ_api) {
case 'nom_sci' : $this->afficherNomSci($res_version); break;
case 'nom_sci.*' : $this->afficherNomSciPointEpithete($res_version); break;
case 'hybride.*' :
$this->afficherChamps('hybride.parent_01.*', $res_version['hybride_parent_01']);
$this->afficherChamps('hybride.parent_02.*', $res_version['hybride_parent_02']); break;
default :
$this->afficherChamps($nom_champ_api,
$res_version[$this->trouverChampBddCorrespondant($nom_champ_api)]); break;
}
}
}
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
$res = $this->afficherVersionOuPas($version, $this->table_retour, $res);
}
return $res;
}
/** Les champs passés dans l'url lors de la requete /noms|taxons/#id/#champ+#champ son sous la forme de l'api.
* Les noms de l'api ne st pas les meme que ceux des champs de la base de données.
* Cette fct permet de récupérer le nom du champs de la base de données */
public function trouverChampBddCorrespondant($champ) {
$radical_champ = $champ;
if ($this->estUnPoint($champ) && strrpos($champ, '.notes') === false) {
preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match);
$radical_champ = $match[1];
}
// - Soit un champ de l'api est recherché (pour les champs du référentiel : les noms des champs ont été modifiés),
// - Soit un champ complementaire de la bdnff (les noms de ces champs complementaire sont les memes que ds la base)
if ($this->estChampApi($radical_champ)) {
$champ_bdd = array_search($radical_champ, $this->champs_api);
} elseif ($this->estDansBdnff($radical_champ)) {
$champ_bdd = $radical_champ;
} else {
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Fct trouverChampBddCorrespondant : Le parametre "'.$radical_champ.'" n\'existe pas. <br/><br/>');
}
return $champ_bdd;
}
/** Permet d'afficher des informations précisées des données liées. Utilisé par le service id/champ
* lors de l'appel d'un champ tel que : champ.id, champ.code, champ.*, champ.href. */
public function afficherChamps($champ, $valeur) {
$reponse = $this->table_retour;
$this->table_retour = array();
if ($valeur == '') {
$this->table_retour[$champ] = null;
} else {
preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match);
//si on a un point etoile
if (isset($match[2]) && $match[2] == '*') {
$this->afficherPointEtoile($match[1], $valeur);
//si le champ comprend plusieurs identifiants : pour le champ proparte (liste ou .details recherché, pas de .href)
} elseif ($this->presentePlusieursId($match[1], $valeur)) {
if (isset($match[2]) && $match[2] != 'id') {
$this->afficherInfosPrecises($match[1], $match[2], $valeur);
} else {
$this->table_retour[str_replace('.id', '', $champ)] = $valeur;
}
//si on est en présence d'une donnée liée (la donnée représente un identifiant ou un code)
} elseif ($this->correspondAUnId($match[1]) || $champ == 'id' || $this->correspondAUnCode($match[1])) {
if (isset($match[2])) { //si un .id, un .code ou un .href est demandé :
$this->afficherInfosPrecises($match[1], $match[2], $valeur);
} else {
$this->afficherInfosPrecises($match[1], 'signification', $valeur);
}
//sinon on affiche tel quel
} else {
$this->table_retour[$champ] = $valeur;
}
}
$this->table_retour = array_merge($reponse, $this->table_retour);
}
 
/**Vérifie la validité d'un champ passé dans la requete /#id/#champ+#champ */
public function verifierValiditeChamp($champ) {
preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match);
$radical_champ = $match[1];
$validite_ressource = true;
//on verifie si le nom du champ existe bien
if (!$this->estChampApi($radical_champ) && !$this->estDansBdnff($radical_champ)) {
$validite_ressource = false;
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Fct verifierValiditeChamp : Le parametre "'.$radical_champ.'" n\'existe pas. <br/><br/>');
} elseif ($this->estUnPoint($champ)) {
$suffixe = $match[2];
//On verifie les suffixes pour les identifiants
if ($this->correspondAUnId($radical_champ) || $radical_champ == 'id') {
$this->verificationSuffixesIdentifiant($suffixe, $radical_champ, $validite_ressource);
//On verifie les suffixes pour les codes
} elseif ($this->correspondAUnCode($radical_champ)) {
$this->verficationSuffixesCodes($suffixe, $radical_champ, $validite_ressource);
} elseif ($radical_champ == 'nom_sci' && $suffixe != '*') {
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur : Le suffixe demand&eacute; n\'existe pas pour le champ "'.$radical_champ.'".<br/>
Les suffixes possibles sont les suivants : <li> * </li>');
} else {
$validite_ressource = false;
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur : Le parametre "'.$radical_champ.'" ne peut pas pr&eacute;senter de suffixe. <br/><br/>');
}
}
return $validite_ressource;
}
public function verficationSuffixesCodes(&$suffixe, &$radical_champ, &$validite_ressource ) {
if (!in_array($suffixe, array('*', 'code', 'href', 'details'))) {
$validite_ressource = false;
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur : Le suffixe demand&eacute; n\'existe pas pour le champ "'.$radical_champ.'.<br/>
Les suffixes possibles sont les suivants :
<li> .* </li><li> .code </li><li> .href </li><li> .details </li>');
}
}
public function verificationSuffixesIdentifiant(&$suffixe, &$radical_champ, &$validite_ressource) {
if ((strrpos($radical_champ, 'parent') !== false && !in_array($suffixe, array('*', 'id', 'href', 'details', 'notes')))
|| !in_array($suffixe, array('*', 'id', 'href', 'details')) && strrpos($radical_champ, 'parent') === false) {
$validite_ressource = false;
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur : Le suffixe demand&eacute; n\'existe pas pour le champ "'.$radical_champ.'".<br/>
Les suffixes possibles sont les suivants :
<li> .* </li><li> .id </li><li> .href </li><li> .details </li><li> .notes (seulement pour les hybride.parent)');
}
}
//------------------------------fonction de formatage pour les services /stats/-----------------------------------------
public function formaterStatsAnnee($resultat) {
$res = array();
foreach ($resultat as $version => $res_version) {
foreach ($res_version as $cle_annee) {
foreach ($cle_annee as $key => $val) {
switch($key) {
case 'annee' : $annee = ($val != '') ? $val : 'N.D.'; break;
case 'nombre': $nb = $val; break;
default : break;
}
}
$retour_stats_annee[$annee] = $nb;
}
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
$res = $this->afficherVersionOuPas($version, $retour_stats_annee, $res);
}
return $res;
}
public function formaterStatsRang($resultat) {
$res = array();
foreach ($resultat as $version => $res_version) {
foreach ($res_version as $rangs) {
if ($rangs['rang'] != 0) {
foreach ($rangs as $key => $val) {
switch ($key) {
case 'rang' : $rang = $val; break;
case 'nombre' : $nombre = $val; break;
default : break;
}
}
$retour_rang[$rang] = array(
'rang' => $this->ajouterSignificationCode('rang', $rang),
'nombre' => $nombre
);
}
}
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
$res = $this->afficherVersionOuPas($version, $retour_rang, $res);
}
return $res;
}
public function formaterStatsInitiales($resultat) {
$res = array();
$table_rang = array();
foreach ($resultat as $version => $res_version) {
foreach ($res_version as $tuple) {
if ($tuple['rang'] != 0) {
if (!isset($table_rang[$tuple['rang']])) {
$rang = $this->ajouterSignificationCode('rang', $tuple['rang']);
$table_rang[$tuple['rang']] = $rang;
} else {
$rang = $table_rang[$tuple['rang']];
}
if ($tuple['lettre'] == 'x ') {
if (isset($this->table_retour[$rang]['hyb'])) {
$this->table_retour[$rang]['hybride'] += floatval($tuple['nb']);
} else {
$this->table_retour[$rang]['hybride'] = floatval($tuple['nb']);
}
} elseif ($tuple['lettre'] == '+ ') {
if (isset($this->table_retour[$rang]['chimère'])) {
$this->table_retour[$rang]['chimère'] += floatval($tuple['nb']);
} else {
$this->table_retour[$rang]['chimère'] = floatval($tuple['nb']);
}
} else {
$l = substr($tuple['lettre'], 0, 1);
if (isset($this->table_retour[$rang][$l])) {
$this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] += floatval($tuple['nb']);
} else {
$this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] = floatval($tuple['nb']);
}
}
}
}
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
$res = $this->afficherVersionOuPas($version, $this->table_retour, $res);
}
return $res;
}
//-----------------------------Fonctions d'affichage utiliser dans les fonctions de formatage---------------------------
/** Affiche les résultats en fonction du paramètre retour_format. */
public function afficherDonnees($key, $valeur) {
//on souhaite afficher le nom au format de l'api
if ($this->retour_format == 'min') {
if ($this->correspondAChampApi($key)) { //on affiche l'intitulé selon decrit dans l'api
if ($key == 'nom_sci') $valeur = $valeur.$this->ajouterCompositionNom($this->resultat_req);
$this->table_retour[$this->correspondance_champs[$key]] = $valeur;
} else {
$this->table_retour[$key] = $valeur;
}
} else {
if ($this->correspondAChampApi($key)) {
$nom_champ_api = $this->correspondance_champs[$key]; //on récupere le nom comme définit ds l'api
$this->afficherToutesLesInfos($nom_champ_api, $valeur);
} elseif ($this->estDansBdnff($key)) {
$this->table_retour[$key] = $valeur;
}
}
}
public function afficherToutesLesInfos($nom_champ_api, $valeur) {
if ($this->presentePlusieursId($nom_champ_api, $valeur)) {
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match);
$this->afficherInfosPrecises($match[1], 'details', $valeur);
$this->table_retour[$nom_champ_api] = $valeur;
} elseif (strrpos($nom_champ_api, 'parent') !== false && strrpos($nom_champ_api, 'notes') !== false) {
$this->table_retour[$nom_champ_api] = $valeur;
} elseif (($this->correspondAUnId($nom_champ_api) || $nom_champ_api == 'id') && $valeur != '0') {
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match);
$this->afficherInfosPrecises($match[1], 'id,signification,href', $valeur);
} elseif ($this->correspondAUnCode($nom_champ_api)) {
preg_match('/^([^.]+)(?:\.code)?$/', $nom_champ_api, $match);
$this->afficherInfosPrecises($match[1], 'code,signification,href', $valeur);
}
}
public function presentePlusieursId($ressource, $valeur = null) {
if ($valeur) {
$presente = strrpos($ressource, 'proparte') !== false && strrpos($valeur, ',') !== false;
} else { //pour la vérification du champ, on ignore alors la valeur de la ressource
$presente = strrpos($ressource, 'proparte') !== false;
}
return $presente;
}
public function afficherTableDetails($nom_champ_api, $valeur) {
$tab_id = explode(',',$valeur);
$tab_res = $this->table_retour;
$this->table_retour = array();
foreach ($tab_id as $id) {
$this->afficherInfosPrecises($nom_champ_api, 'id,signification,href', $id);
$tab_res[$nom_champ_api.'.details'][] = $this->table_retour;
$this->table_retour = array();
}
$this->table_retour = $tab_res;
}
public function afficherPointEtoile($champ, $valeur) {
if ($this->presentePlusieursId($champ, $valeur)) {
$this->afficherInfosPrecises($champ, 'details', $valeur);
$this->table_retour[$champ] = $valeur;
} elseif (strrpos($champ, 'parent') !== false) {
$this->afficherInfosPrecises($champ, 'id,href,notes', $valeur);
} elseif ($this->correspondAUnId($champ) || $champ == 'id') {
$this->afficherInfosPrecises($champ, 'id,href', $valeur);
} elseif ($this->correspondAUnCode($champ)) {
$this->afficherInfosPrecises($champ, 'code,href', $valeur);
}
}
public function afficherInfosPrecises($champ, $suffixe, $valeur) {
$suffixes = explode(',', $suffixe);
//on initialise au service appelé. Sera potentiellement modifié dans la fonction afficherSignification()
$this->service_href = $this->service;
foreach ($suffixes as $suff) {
switch ($suff) {
case 'id' :
$this->table_retour[str_replace('id.id', 'id', $champ.'.id')] = $valeur;
break;
case 'details' :
$this->afficherTableDetails($champ, $valeur);
break;
case 'signification' :
$this->afficherSignification($champ, $valeur);
break;
case 'href' :
if ($this->correspondAUnId($champ) || $champ == 'id') {
$service = $this->service_href;
$url = $this->ajouterHref($service, $valeur);
} else {
$service = 'ontologies';
$champ_url = $champ;
$url = $this->ajouterHrefAutreProjet($service, $val, $champ_url);
}
$this->table_retour[str_replace('id.href', 'href', $champ.'.href')] = $url;
break;
case 'code' :
$val = ( $champ == 'rang' ) ? 'bdnt.rangTaxo:'.$valeur : 'bdnt.'.rtrim($champ, '_Ga,_Co').':'.$valeur;
$this->table_retour[$champ.'.code'] = $val;
break;
case 'notes' :
$this->table_retour[$champ.'.notes'] = $this->resultat_req[str_replace('.', '_', $champ).'_notes'];
break;
default :
break;
}
}
}
public function afficherSignification($champ, $valeur) {
if ($champ == 'id' && isset($this->resultat_req['nom_sci']) && $this->resultat_req['num_nom'] == $valeur) {
//si le nom_sci du num_nom que l'on veut afficher est déjà dans la table de résultat :
$this->table_retour['nom_sci'] = $this->resultat_req['nom_sci'].$this->ajouterCompositionNom($this->resultat_req);
} elseif ($this->correspondAUnId($champ) || $champ == 'id') {
$nom = $this->recupererNomSci($valeur);
$champ = ($champ == 'id') ? 'nom_sci' : $champ;
if ($nom != array()) {
$this->table_retour[$champ] = $nom['nom_sci'];
$this->service_href = $nom['service'];
}
} elseif ($this->correspondAUnCode($champ)) {
$this->table_retour[$champ] = $this->ajouterSignificationCode($champ, $valeur);
}
}
/** Permet d'afficher les élements nomenclatural du nom_sci lors de l'appel dans le service noms/id/champ du champ^nom_sci.*/
public function afficherNomSciPointEpithete($resultat) {
foreach ($this->tab_nom_sci as $compo_nom) {
if (isset($resultat[$compo_nom]) && !empty($resultat[$compo_nom])) {
$this->table_retour['nom_sci.'.$compo_nom] = $resultat[$compo_nom];
}
}
}
/** utilisé dans le formatage de /noms/id et de /noms/id/champ seulement */
public function afficherNomSci($resultat) {
if ($this->html == 'htm') {
$this->table_retour['nom_sci'] = $resultat['nom_sci_html'].$this->ajouterCompositionNom($resultat);
} else {
$this->table_retour['nom_sci'] = $resultat['nom_sci'].$this->ajouterCompositionNom($resultat);
}
}
/** Permet d'afficher la signification d'un code pour le rang, la présence, et les differents statuts */
public function ajouterSignificationCode($champ, $valeur) {
$champ = ($champ == 'rang') ? 'rangTaxo' : rtrim($champ, '_Co,_Ga');
if (preg_match('/^([^_-]+)(?:_|-)([^_-]+)$/', $champ, $match)) {
$champ = $match[1].ucfirst($match[2]);
}
$url = Config::get('url_ontologie').$champ.':'.$valeur.'/nom';
$res = $this->consulterHref($url); //dans commun.php
$nom_code = $res->nom;
return $nom_code;
}
/** Recupere le nom_scientifique (formaté ou non en fonction du parametre ns.format) à partir du num_nom */
public function recupererNomSci($id) {
$nom = array();
if ($id != 0) {
if ($this->compo_nom == null) {
$req = 'SELECT nom_sci, num_nom_retenu FROM '.$this->table.' WHERE num_nom = '.$id;
} else { //on ajoute à la requete sql, les champs de ns.structure
$req = 'SELECT nom_sci, num_nom_retenu, '.implode(', ', $this->compo_nom)
.' FROM '.$this->table
.' WHERE num_nom = '.$id;
}
if ($this->html == 'htm') {
$req = str_replace('nom_sci', 'nom_sci_html as nom_sci', $req);
}
$res = $this->getBdd()->recuperer($req);
if ($res) {
$nom['nom_sci'] = $res['nom_sci'].$this->ajouterCompositionNom($res);
$nom['service'] = ($res['num_nom_retenu'] == $id && $this->service == 'taxons') ? 'taxons' : 'noms';
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Fct recupererNomSci() : Donnees introuvables dans la base pour l\'id '.$id);
}
}
return $nom;
}
 
/** Permet de retourner une chaine de caractère composée des parametres du nom (ns.structure : annnée, auteur,
* bibilio et addendum). A ajouter au nom scientifique */
public function ajouterCompositionNom($tab_res) {
$nom_complet = ' ';
$this->ajouterAuteur($tab_res, $nom_complet);
$this->ajouterAnneeEtBiblio($tab_res, $nom_complet);
$this->ajouterAnneeSansBilio($tab_res, $nom_complet);
$this->ajouterBiblioSansAnnee($tab_res, $nom_complet);
$this->ajouterAddendum($tab_res, $nom_complet);
return rtrim($nom_complet);
}
public function ajouterAuteur($tab_res, &$nom_complet) {
if (isset($this->compo_nom['au']) && isset($tab_res['auteur']) && $tab_res['auteur'] != '') {
if ($this->html == 'htm') {
$nom_complet .= '<span class="auteur">'.$tab_res['auteur'].'</span> ';
} else {
$nom_complet .= $tab_res['auteur'].' ';
}
}
}
public function ajouterAnneeEtBiblio($tab_res, &$nom_complet) {
if (isset($this->compo_nom['an']) && isset($this->compo_nom['bib'])
&& isset($tab_res['annee']) && ($tab_res['annee'] != '')
&& isset($tab_res['biblio_origine']) && ($tab_res['biblio_origine'] != '')) {
if ($this->html == 'htm') {
$nom_complet .= '[<span class="annee">'.$tab_res['annee'].'</span>, <span class="biblio">'
.$tab_res['biblio_origine'].'</span>]';
} else {
$nom_complet .= '['.$tab_res['annee'].', '.$tab_res['biblio_origine'].']';
}
}
}
 
public function ajouterAnneeSansBilio($tab_res, &$nom_complet) {
if (isset($this->compo_nom['an']) && !isset($this->compo_nom['bib'])
&& isset($tab_res['annee']) && ($tab_res['annee'] != '')) {
if ($this->html == 'htm') {
$nom_complet .= '[<span class="annee">'.$tab_res['annee'].'</span>]';
} else {
$nom_complet .= '['.$tab_res['annee'].']';
}
}
}
public function ajouterBiblioSansAnnee($tab_res, &$nom_complet) {
if (!isset($this->compo_nom['an']) && isset($this->compo_nom['bib']) && ($tab_res['biblio_origine'] != '')) {
if ($this->html == 'htm') {
$nom_complet .= '[<span class="biblio">'.$tab_res['biblio_origine'].'</span>]';
} else {
$nom_complet .= '['.$tab_res['biblio_origine'].']';
}
}
}
public function ajouterAddendum($tab_res, &$nom_complet) {
if (isset($this->compo_nom['ad']) && ($tab_res['nom_addendum'] != '')) {
if ($this->html == 'htm') {
$nom_complet .= '[<span class="adendum">'.$tab_res['nom_addendum'].'</span>]';
} else {
$nom_complet .= '['.$tab_res['nom_addendum'].']';
}
}
}
public function correspondAUnCode($key) {
return (strrpos($key, '.code') !== false) || (in_array($key.'.code', $this->correspondance_champs));
}
public function correspondAUnId($key) {
return (strrpos($key, '.id') !== false) || (in_array($key.'.id', $this->correspondance_champs));
}
public function estChampApi($champ) {
return (in_array($champ, $this->champs_api) || in_array($champ, $this->correspondance_champs));
}
public function correspondAChampApi($champ_bdd) {
return (array_key_exists($champ_bdd, $this->champs_api) || array_key_exists($champ_bdd, $this->correspondance_champs));
}
public function estDansBdnff($champ) {
return (in_array($champ, $this->champs_comp));
}
public function estUnPoint($key) {
if (strrpos($key, 'hybride.parent') !== false) {
$key = str_replace('hybride.parent', 'hybride_parent', $key);
}
return (strrpos($key, '.') !== false);
}
}
 
?>
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/tags/v5.6-arganeraie/services/modules/0.1/coste/Noms.php
New file
0,0 → 1,711
<?php
 
 
/**
* Description :
* Classe Noms.php permettant de fournir des informations sur les noms scientifiques.
* Si l'url finit par /noms on retourne une liste de noms latin et leurs identifiants (seulement les 100 premeiers noms par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /noms?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.gen (nom de genre), masque.sp (épithète d'espèce), masque.ssp (épithète infra-spécifique),
* masque.au (auteur du nom), masque.an (année de publication du nom), masque.bib (réf biblio de la publi d'origine du nom), masque.ad (nomen addendum),
* masque.nn (identifiant du nom), recherche, rang, distinct, retour.format, nl.format, nl.structure, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 1.0
* @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org)
*/
 
 
class Noms extends CommunNomsTaxons {
/** Permet de stocker la requete formulée :
* - noms | noms/#id | noms/#id/#champ+#champ
* - noms/#id/relations | noms/#id/relations/synonymie | noms/#id/relations/homonymie | noms/#id/relations/flores
* - noms/stats/rangs | noms/stats/annees | noms/stats/initiales */
protected $format_reponse = 'noms';
protected $service = 'noms';
/** Valeur du paramètre de requete recherche : stricte etendue floue */
protected $recherche = false;
/** Valeur du paramètre de requete distinct (=0|1) */
protected $distinct = null;
/** Représente la première partie de la requete SQL (entre le SELECT et le WHERE) */
protected $requete_champ = 'num_nom, nom_sci, num_nom_retenu';
/** Représente la partie de la requete SQL ajoutant une condition (WHERE ...) */
protected $requete_condition = '';
/** Représente la partie GROUP BY de la requete SQL (GROUP BY ...) */
protected $requete_group_by = '';
/** Permet de stocker les limite de la requete SQL (par défaut seul les 100 premiers résultats seront retournés).*/
protected $limite_requete = array(
'depart' => 0,
'limite' => 100
);
public function consulter($ressources, $parametres) {
$resultat_formate = '';
$res_version = '';
$this->initialiserRestClient(); //création d'un objet RestClient
$this->traiterParametres($parametres);
//On récupère les différentes versions existantes ds la table des meta-données (WS metaDonnees) et on traite la version demandée :
$this->traiterVersionProjet($ressources);
if ($this->corps_http == '' && $this->entete_http == '') {
foreach ($this->table_version as $version) {
$this->table = $version; //on stocke le nom de la table correspondant à la version du projet en cours
$this->recupererNomChamp($this->table); //on récupère les noms des champs disponibles (Ds Commun.php)
$this->traiterRessources($ressources); //dans CommunNomsTaxons.php
$requete = $this->assemblerLaRequete();
$resultat = $this->getBdd()->recupererTous($requete);
if ($resultat == '') { //cas ou la requete comporte des erreurs
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'La requ&ecirc;te SQL form&eacute;e comporte une erreur !!');
} elseif ($resultat) {
$res_version[$version] = $resultat;
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Les donn&eacute;es recherch&eacute;es sont introuvables dans la version '.$version);
}
}
}
if ($this->corps_http == '' && $this->entete_http == '') {
$resultat_formate = $this->retournerResultatFormate($res_version);
}
$this->formerReponseHTTP($resultat_formate);
}
//-----------------FONCTION D'ANALYSE DES PARAMETRES--------------------------------------------------------------------
 
/**
*
* Permet d'analyser les paramètres
* @param array $parametres
*/
public function traiterParametres($parametres) {
$this->table_param = $parametres;
if (isset($parametres) && !empty($parametres)) {
//définition de $recherche permettant d'ajouter les % ds la requete sql (cas recherche étendue) utilisé dans la fct ajouterLeFiltreMasque()
if (isset($parametres['recherche']) && $parametres['recherche'] != '') {
$this->recherche = $parametres['recherche'];
}
foreach ($parametres as $param => $val) {
switch ($param) {
case 'ns_format' : $this->html = $val; break;
case 'ns_structure' : $this->remplirTableCompositionNom($val); //ds CommunNomsTaxons.php
$this->requete_champ .= ' ,'.implode(', ',$this->compo_nom); break;
case 'masque' : $this->ajouterLeFiltreMasque('nom_sci', $val); break;
case 'masque_sg' : $this->ajouterLeFiltreMasque('nom_supra_generique', $val); break;
case 'masque_gen' : $this->ajouterLeFiltreMasque('genre', $val); break;
case 'masque_sp' : $this->ajouterLeFiltreMasque('epithete_sp', $val); break;
case 'masque_ssp' : $this->ajouterLeFiltreMasque('epithete_infra_sp',$val); break;
case 'masque_au' : $this->ajouterLeFiltreMasque('auteur', $val); break;
case 'masque_an' : $this->ajouterLeFiltreMasque('annee', $val); break;
case 'masque_bib' : $this->ajouterLeFiltreMasque('biblio_origine',$val); break;
case 'masque_ad' : $this->ajouterLeFiltreMasque('nom_addendum', $val); break;
case 'masque_nn' : $this->requete_condition .= ' AND num_nom IN ('.$val.')'; break;
case 'masque_rg' : $this->ajouterLeFiltreMasque('rang', $val); break;
case 'navigation_depart': $this->limite_requete['depart'] = $val; break;
case 'navigation_limite': $this->limite_requete['limite'] = $val; break;
case 'retour_format' : $this->retour_format = $val; break;
case 'distinct' : $this->distinct = $val; break;
case 'recherche' : break;
default : $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur dans les parametres de recherche de votre requ&ecirc;te :
</br> Le parametre " '.$param.' " n\'existe pas.'); break;
}
}
$this->ajouterNomDistinct();
if ($this->recherche == 'floue') {
$this->rechercheFloue();
}
}
}
/**
*
* fonction d'ajout dans la requete SQL des conditions (WHERE ...) en fonctions des parametres demandés
* @param $nom_champ
* @param $valeur
* @param $masque
*/
public function ajouterLeFiltreMasque($nom_champ, $valeur) {
if ($nom_champ == 'annee' || $nom_champ == 'rang') {
$this->requete_condition .= ' AND '.$nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if ($this->recherche == 'etendue') {
$valeur = str_replace(' ','%', $valeur);
$valeur .= '%';
}
$this->requete_condition .= ' AND '.$nom_champ.' LIKE '.$this->getBdd()->proteger($valeur);
}
}
/**
* Permet de rajouter à la requete sql le parametre distinct. N'est utilisé qu'avec le format oss
*/
public function ajouterNomDistinct() {
if (isset($this->distinct)) {
if (($this->distinct == 1) && ($this->retour_format == 'oss')) {
if ($this->compo_nom == '') {
$this->requete_champ = ' DISTINCT nom_sci ';
} else {
$this->requete_champ = ' DISTINCT nom_sci, '.implode(', ',$this->compo_nom);
}
} elseif (($this->distinct == 1) && ($this->retour_format != 'oss')) {
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,'Erreur dans votre requ&ecirc;te </br>
L\'utilisation du parametre distinct ne se fait que sous le format oss');
}
}
}
/**
*
* Permet d'ajouter à notre requete une condition de recherche floue à l'aide de l'alhorithme soundex.
* On remplace ainsi les filtres exceptés le masque année et le filtre rang
*/
public function rechercheFloue() {
foreach ($this->ordre_masque as $masque) {
if (array_key_exists($masque, $this->table_param)) {
$radical = $this->table_param[$masque];
switch ($masque) {
case 'masque' : $this->ajoutSoundex('nom_sci', $radical); break;
case 'masque_sg' : $this->ajoutSoundex('nom_supra_generique', $radical); break;
case 'masque_gen' : $this->ajoutSoundex('genre', $radical); break;
case 'masque_sp' : $this->ajoutSoundex('epithete_sp', $radical); break;
case 'masque_ssp' : $this->ajoutSoundex('epithete_infra_sp', $radical); break;
case 'masque_au' : $this->ajoutSoundex('auteur', $radical); break;
default : break;
}
}
}
}
/** Ajoute à la requete SQL l'expression pour la recherche floue en fonction du masque demandé */
public function ajoutSoundex($champ, $radical) {
$this->requete_condition = str_replace(' AND '.$champ.' LIKE \''.$radical.'\'',
' AND (SOUNDEX('.$champ.') = SOUNDEX(\''.$radical.'\')'.
' OR SOUNDEX(REVERSE('.$champ.')) = SOUNDEX(REVERSE(\''.$radical.'\'))) ',
$this->requete_condition
);
}
//-----------------FONCTION D'ANALYSE DES RESSOURCES--------------------------------------------------------------------
 
 
public function traiterRessourcesIdentifiant() {
//on initialise la condition de la requete sql et le format de réponse
$this->requete_condition = ' num_nom = '.$this->getBdd()->proteger($this->table_ressources[0]);
$this->format_reponse = $this->service.'/id';
if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) {
// requete de type noms/#id/#champ+#champ
if (($this->table_ressources[1] != 'relations')) {
$this->requete_champ = ' *, nom_sci ';
$this->format_reponse .= '/champ';
// requete de type noms/#id/relations/#relations
} elseif ($this->table_ressources[1] == 'relations') {
$this->traiterRessourceIdRelations();
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur dans votre requ&ecirc;te </br> Ressources disponibles : <br/>
<li> noms/#id/relations </li> <li> noms/#id/#champ+#champ </li>
<li> noms/#id/relations/synonymie </li> <li> noms/#id/relations/flores </li>
<li> noms/#id/relations/homonymie </li>');
}
} else {
// requete de type noms/#id : rajout du nom_sci pour récupérer le format html par la fct mettreAuFormat()
// SELECT *, nom_sci FROM bdtfx_v2_00 WHERE num_nom = X;
$this->requete_champ = ' *, nom_sci ';
}
}
public function traiterRessourceIdRelations() {
$this->format_reponse .= '/relations';
if (isset($this->table_ressources[2]) && !empty($this->table_ressources[2])) {
// requete de type noms/#id/relations/#relation
switch ($this->table_ressources[2]) {
case 'synonymie' : $this->traiterRessourceIdSynonymie(); break;
case 'flores' : $this->traiterRessourceIdFlores(); break;
case 'homonymie' : $this->traiterRessourceIdHomonymie(); break;
default : $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur dans votre requ&ecirc;te </br> Ressources disponibles : <br/>
<li> noms/#id/relations </li> <li> noms/#id/relations/synonymie </li>
<li> noms/#id/relations/flores </li> <li> noms/#id/relations/homonymie </li>'); break;
}
}
}
public function traiterRessourceIdSynonymie() {
// SELECT num_nom, nom_sci, num_nom_retenu, basionyme FROM bdtfx_v2_00 WHERE num_nom = X LIMIT 0,100;
$this->format_reponse .= '/synonymie';
if (strrpos($this->requete_champ, ', basionyme') === false) $this->requete_champ .= ', basionyme ';
$this->requete_condition = ' num_nom_retenu = (SELECT num_nom_retenu FROM '.$this->table
.' WHERE '.$this->requete_condition.')';
}
public function traiterRessourceIdHomonymie() {
// SELECT num_nom, nom_sci, num_nom_retenu FROM bdtfx_v2_00 WHERE nom_sci =
// (SELECT nom_sci FROM bdtfx_v2_00 WHERE num_nom = X);
$this->format_reponse .= '/homonymie';
$this->requete_condition = 'nom_sci = (SELECT nom_sci FROM '.$this->table
.' WHERE '.$this->requete_condition.')';
}
public function traiterRessourceIdFlores() {
$champ_flores = '';
foreach ($this->champs_table as $champ) {
if (preg_match('/^flore_.*$/', $champ)) {
$champ_flores .= ', '.$champ;
}
}
$this->format_reponse .= '/flores';
$this->requete_champ = 'num_nom'.$champ_flores;
}
public function traiterRessourceStatsRangs() {
// SELECT count(*) as nombre, rang FROM bdtfx_v2_00 [WHERE rang = 290] GROUP BY rang ORDER BY rang;
$this->format_reponse .= '/rangs';
$this->requete_champ = 'count(*) as nombre, rang ';
$this->requete_group_by = ' GROUP BY rang ORDER BY rang ';
}
public function traiterRessourceStatsAnnees() {
// SELECT count(*) as nombre, annee FROM bdtfx_v2_00 GROUP BY annee ORDER BY annee;
$this->format_reponse .= '/annees';
$this->requete_champ = 'count(*) as nombre, annee ';
$this->requete_condition = '';
$this->requete_group_by = ' GROUP BY annee ORDER BY annee ';
}
public function traiterRessourceStatsInitiales() {
// SELECT count(left( nom_sci, 2 )) as nb, rang, left(nom_sci, 2) as lettre GROUP BY rang, left(nom_sci, 2);
$this->format_reponse .= '/initiales';
$this->requete_condition = '';
$this->requete_champ = 'count(left( nom_sci, 2 )) as nb, rang, left(nom_sci, 2) as lettre ';
$this->requete_group_by = ' GROUP BY rang, left(nom_sci, 2)';
}
//-----------------------------FONCTIONS DASSEMBLAGE DE LA REQUETE-----------------------------------------------------
public function assemblerLaRequete() {
if ( strrpos($this->format_reponse, 'noms/stats/') === false ) {
$this->mettreAuFormat(); //Ds CommunNomsTaxons.php
}
if ($this->requete_condition != '') {
$this->requete_condition = ltrim($this->requete_condition, ' AND, WHERE');
$this->requete_condition = ' WHERE '.$this->requete_condition;
}
if ($this->format_reponse != 'noms' && $this->format_reponse != 'noms/id/relations/synonymie' && $this->format_reponse != 'noms/id/relations/homonymie') {
$this->requete_limite = '';
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) {
$this->limite_requete['depart'] =
(($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']);
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
} else {
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
}
$requete = ' SELECT '.$this->requete_champ.
' FROM '.$this->table
.$this->requete_condition
.$this->requete_group_by
.$this->requete_limite;
return $requete;
}
 
/**
* Recupere le nombre total de résultat d'une requete lancée.
* Est utilisée lors de l'affichage du total dans le résultat retourné et pr déterminer les limites et départ
* @return nombre total de résultat
*/
public function recupererTotalResultat() {
$total = null;
$requete = 'SELECT count(*) as nombre FROM '.$this->table.$this->requete_condition.$this->requete_group_by;
$res = $this->getBdd()->recuperer($requete);
if ($res) {
$total = $res['nombre'];
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Fct recupererTotalResultat() : <br/>Donn&eacute;es introuvables dans la base');
}
return $total;
}
//-------------------FONCTIONS POUR LE FORMATAGE EN JSON----------------------------------------------------------------
/**
* Permet de récupérer le résultat à retourner propre à chaque requete et de l'encoder en json
* @param array $resultat
* @param array $ressources
* @return le résultat encoder en json
*/
public function retournerResultatFormate($resultat) {
switch ($this->format_reponse) {
case 'noms/id' : $reponse = $this->formaterId($resultat); break; //ds CommunNomsTaxons
case 'noms/id/champ' : $reponse = $this->formaterIdChamp($resultat); break; //ds CommunNomsTaxons
case 'noms/id/relations' : $reponse = $this->formaterIdRelations($resultat); break;
case 'noms/id/relations/synonymie' : $reponse = $this->formaterIdSynonymie($resultat); break;
case 'noms/id/relations/homonymie' : $reponse = $this->formaterIdHomonymie($resultat); break;
case 'noms/id/relations/flores' : $reponse = $this->formaterIdFlores($resultat); break; //ds CommunsNomsTaxons
case 'noms/stats/annees' : $reponse = $this->formaterStatsAnnee($resultat); break; //ds CommunNomsTaxons
case 'noms/stats/rangs' : $reponse = $this->formaterStatsRang($resultat); break; //ds CommunNomsTaxons
case 'noms/stats/initiales' : $reponse = $this->formaterStatsInitiales($resultat); break; //ds CommunNomsTaxons
case 'noms' : $reponse = $this->formaterNoms($resultat); break;
default : break;
}
return json_encode($reponse);
}
//----------------------concerne les resultats pour des requetes de type noms/id----------------------------------------
/**
* Formate et retourne toutes les relations correpondant au nom recherché : les flores, les synonyme et les homonymes
* @param array $resultat
*/
public function formaterIdRelations($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$res = array();
foreach ($resultat as $version => $res_version) {
$res_version = $res_version[0];
$this->resultat_req = $res_version;
$retour_id_rel = array ('entete' => array()); //on initialise pr que l'entete apparaisse en premier lors de l'affichage
//on recupère le resultat de chaque relation (appel du WS correspondant)
$flores = $this->ajouterRelations('flores', $version);
if (isset($flores)) $retour_id_rel['resultat']['flores'] = $flores;
$homonymes = $this->ajouterRelations('homonymie', $version);
if (isset($homonymes)) $retour_id_rel['resultat']['homonymes'] = $homonymes;
$synonymes = $this->ajouterRelations('synonymie', $version);
if (isset($synonymes)) $retour_id_rel['resultat']['synonyme'] = $synonymes;
//on renvoit un tableau null si il n'existe aucune relations (on efface l'entete en premier lieu)
if (!isset($retour_id_rel['resultat'])) {
$retour_id_rel = null;
//on rajoute l'entete si des relations existent
} else {
$this->afficherDonnees('num_nom', $this->table_ressources[0]);
$retour_id_rel['entete'] = $this->table_retour;
$this->table_retour = array();
}
//recuperation du resultat de chaque version
$res = $this->afficherVersionOuPas($version, $retour_id_rel, $res);
}
return $res;
}
/**
* Recupere les relations (type de la relation passée en paramètres :[type_relation] = synonymie, homonymie ou
* flores) par l'appel du web service [version]/noms/#id/relations/[type_relation]
* @param String $relation
* @param String $version (numéro de la version)
*/
public function ajouterRelations($relation, $version) {
$version = str_replace(Config::get('bdd_table').'_v', '', $version);
$res = null;
$parametres_url = '';
if ($this->table_param != array()) $parametres_url = '?'.http_build_query($this->table_param, '', '&');
$url = Config::get('url_service').'/'.$version.'/'.$this->service.'/'.$this->table_ressources[0].'/relations/'
.$relation.$parametres_url;
$relation = $this->rest_client->consulter($url);
$entete = $this->rest_client->getReponseEntetes();
//Si le service meta-donnees fonctionne correctement, l'entete comprend la clé wrapper_data
if (isset($entete['wrapper_data'])) {
$relation = json_decode($relation);
if (isset($relation->resultat)) {
$res = $relation->resultat;
}
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Le service '.$this->service.' de ce projet comporte des erreurs. url lancée : '.$url);
}
return $res;
}
/**
* Formate et retourne toutes les synonymes correpondants au nom recherché
* @param array $resultat
*/
public function formaterIdSynonymie($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$res = array();
foreach ($resultat as $version => $res_version) {
$retour_id_syn = array();
if ($res_version[0]['num_nom_retenu'] == '') {
$retour_id_syn[] = 'nom_retenu N.D.';
} elseif (count($res_version) != 1) {
//on remplit d'abord l'entete du resultat
$this->table_retour['id'] = $this->table_ressources[0];
$this->afficherEnteteRangBorneTotalUrls($res_version, '/'.$this->service.'/'.$this->table_ressources[0].'/relations/synonymie');
$retour_id_syn['entete'] = $this->table_retour;
$this->table_retour = array();
//on remplit ensuite les resultats
foreach ($res_version as $tab) {
//pour chaque basionyme, on recupère le résultat : num_nom, nom_sci, basionyme et num_nom_retenu :
$this->resultat_req = $tab;
foreach ($tab as $key => $val) {
if ($val != '') {
switch ($key) {
case 'num_nom_retenu' : $retenu = ($val == $num) ? 'true' : 'false';
$this->table_retour['retenu'] = $retenu; break;
case 'basionyme' : $this->afficherDonnees($key, $val); break;
case 'num_nom' : $num = $val;
$this->afficherDonnees($key, $val);
unset($this->table_retour['id']); break;
default : break;
}
}
}
$retour_id_syn['resultat'][$num] = $this->table_retour;
$this->table_retour = array();
}
}
if (!isset($retour_id_syn['resultat']) && !in_array('nom_retenu N.D.', $retour_id_syn)) {
$retour_id_syn = null; //on initialise le resultat à null
}
$res = $this->afficherVersionOuPas($version, $retour_id_syn, $res);
}
return $res;
}
/**
* Formate et retourne toutes les homonymes correpondants au nom recherché
* @param array $resultat
*/
public function formaterIdHomonymie($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$res = array();
foreach ($resultat as $version => $res_version) {
if (count($res_version) != 1) {
$this->table_retour['id'] = $this->table_ressources[0];
$this->afficherEnteteRangBorneTotalUrls($res_version, '/'.$this->service.'/'.$this->table_ressources[0].'/relations/homonymie');
$retour_id_hom['entete'] = $this->table_retour;
$this->table_retour = array();
foreach ($res_version as $homonyme) {
$this->resultat_req = $homonyme;
$id = $homonyme['num_nom'];
$this->afficherDonnees('num_nom', $id);
if ($homonyme['num_nom_retenu'] != '') {
$retenu = ($id == $homonyme['num_nom_retenu']) ? 'true' : 'false';
$this->table_retour['retenu'] = $retenu;
}
$retour_id_hom['resultat'][$id] = $this->table_retour;
unset($retour_id_hom['resultat'][$id]['id']);
$this->table_retour = array();
}
} else {
$retour_id_hom = null;
}
$res = $this->afficherVersionOuPas($version, $retour_id_hom, $res);
}
return $res;
}
public function formaterIdFlores($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp,noms_projets');
$res = array();
foreach ($resultat as $version => $res_version) {
$res_version = $res_version[0];
$this->resultat_req = $res_version;
$id = array_shift($res_version);
//-----formatage de l'entete du résultat
$reponse['entete']['id'] = $id;
//-----formatage du résultat
$total = 0;
foreach ($res_version as $flores => $valeur) {
if ($valeur != '' && $valeur != '0') {
$this->afficherInfosFlore($res_version, $flores, $valeur);
$total++;
}
}
$reponse['entete']['total'] = $total;
if ($this->table_retour != array()) {
$reponse['resultat'] = $this->table_retour;
$this->table_retour = array();
} else {
$reponse = null;
}
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version
$res = $this->afficherVersionOuPas($version, $reponse, $res);
}
return $res;
}
public function afficherInfosFlore(&$resultat, $flores, $valeur) {
$flore = substr($flores,0,strrpos($flores, '_'));
if (strrpos($flores, 'num') !== false) {
$projet = $this->noms_projets[$flore];
if (preg_match('/^([0-9]+)(?:[.]syn[^a-z]*|(.*))?$/', $valeur, $match)) {
$this->table_retour[$flore]['id'] = $match[1];
$this->table_retour[$flore]['href'] = $this->ajouterHrefAutreProjet('noms', $match[1], $projet);
if (isset($match[2]) && $match[2] != '') $this->table_retour[$flore]['cle'] = $match[2];
}
if (isset($resultat[$flore.'_rem']) && !empty($resultat[$flore.'_rem'])) {
$this->table_retour[$flore]['remarque'] = $resultat[$flore.'_rem'];
unset($resultat[$flore.'_rem']);
}
} elseif (strrpos($flores,'belge') !== false) {
$projet = $this->noms_projets[$flore];
if (preg_match('/^([0-9]+) (R|S)?$/', $valeur, $match)) {
if (isset($match[2])) $type = ($match[2] == 'R') ? 'taxons' : 'synonyme';
$this->table_retour[$flore]['page'] = $match[1];
$this->table_retour[$flore]['type'] = $type;
//$this->table_retour[$flore]['href'] = $this->ajouterHrefAutreProjet('noms', $match[1], $projet);
}
}
}
//----------------------concerne les resultats pour des requetes de type /noms avec ou sans paramètres------------------
 
/**
*
* Est utilisée pour les requetes de type /noms avec ou sans parametres. Détermine le format json ou oss.
* @param retourne le résultat sous forme de tableau, à encoder en json.
*/
public function formaterNoms($resultat) {
if ($this->retour_format == 'oss') {
$reponse = $this->formaterEnOss($resultat); //Ds CommunNomsTaxons.php
} else {
$reponse = $this->formaterEnJsonMax($resultat);
}
return $reponse;
}
 
/**
*
* Permet de créer un tableau ($table_retour_json) au format defaut puis de l'encoder en json (json_encode).
* Le format comprend deux parties, une partie entete (contenu dans le tableau $entete_json) et une partie
* resultat (contenu dans le tableau $resultat_json).
* @param string $resultat : résultat de la requete (liste des noms et leur identifiant)
* @return une chaine encodé json (format par default)
*/
public function formaterEnJsonMax($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$res = array();
foreach ($resultat as $version => $res_version) {
//on remplit la table $table_retour_json['entete']
$masque = $this->ordonnerMasque();
if ($masque != '') $this->table_retour['masque'] = $masque;
$this->afficherEnteteRangBorneTotalUrls($res_version, '/'.$this->service);
$table_retour_json['entete'] = $this->table_retour;
$this->table_retour = array();
//on remplit la table $table_retour_json['resultat']
foreach ($res_version as $tab) {
$this->resultat_req = $tab;
foreach ($tab as $key => $val) {
if ($val != '') {
switch ($key) {
case 'num_nom' : $num = $val;
$this->afficherDonnees($key, $val); break;
case 'nom_sci' : if ($this->retour_format == 'min') {
// sinon est affiché ds afficherDonnees(num_nom, $val) ci-dessus
$this->table_retour[$key] = $val.$this->ajouterCompositionNom($tab);
} break;
case 'num_nom_retenu' :
$retenu = ($val == $num) ? 'true' : 'false';
$this->table_retour['retenu'] = $retenu; break;
default : break;
}
unset($this->table_retour['id']);
}
}
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array();
}
$table_retour_json['resultat'] = $resultat_json;
$res = $this->afficherVersionOuPas($version, $table_retour_json, $res);
}
return $res;
}
 
}
?>
Property changes:
Added: svn:executable
+*
\ No newline at end of property
<
/tags/v5.6-arganeraie/services/modules/0.1/coste/Taxons.php
New file
0,0 → 1,732
<?php
 
// declare(encoding='UTF-8');// ou ISO-8859-15
/**
* Description :
* Classe Taxons.php permettant de fournir des informations sur les noms scientifiques retenu.
* Si l'url finit par /taxons on retourne une liste de noms latin et leurs identifiants (seulement les 100 premeiers noms par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /taxons?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, recherche, rang, distinct, retour.format, nl.format,
* nl.structure, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 1.0
* @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org)
*/
 
 
class Taxons extends CommunNomsTaxons {
/**
* Valeur du paramètre de requete recherche stricte, etendue, floue */
protected $recherche = false;
/** Permet de stocker la requete formulée :
* - taxons | taxons/#id | taxons/#id/#champ+#champ
* - taxons/#id/relations | taxons/#id/relations/synonymie | taxons/#id/relations/homonymie
* | taxons/#id/relations/flores | taxons/#id/relations/superieurs | taxons/#id/relations/inferieurs
* - taxons/stats/rangs | taxons/stats/annees | taxons/stats/initiales */
protected $format_reponse = 'taxons';
/** Représente la première partie de la requete SQL (entre le SELECT et le WHERE)*/
protected $requete_champ = 'num_nom, nom_sci, num_nom_retenu, num_tax ';
/** Représente la partie de la requete SQL ajoutant une condition (WHERE ...)*/
protected $requete_condition = 'num_nom = num_nom_retenu ';
/** Représente la partie GROUP BY de la requete SQL (GROUP BY ...) */
protected $requete_group_by = ' ';
/** Permet de stocker les limite de la requete SQL (par défaut seul les 100 premiers résultats seront retournés). */
protected $limite_requete = array('depart' => 0, 'limite' => 100);
/** Stocke le num_nom du nom retenu du num_nom recherché */
protected $num_nom_taxon;
protected $service = 'taxons';
protected $presence_num_tax = true;
public function consulter($ressources, $parametres) {
$resultat_formate = '';
$this->initialiserRestClient(); //création d'un objet RestClient
$this->traiterParametres($parametres);
$this->traiterVersionProjet($ressources) ;
if ($this->corps_http == '' && $this->entete_http == '') {
foreach ($this->table_version as $version) {
$this->table = $version; //on stocke ici la table correspondant à la version du projet analysée
$this->recupererNomChamp($this->table);
$this->gererNumTax();
$this->traiterRessources($ressources);
if ($this->corps_http == '' && $this->entete_http == '') {
$requete = $this->assemblerLaRequete();
$resultat = $this->getBdd()->recupererTous($requete);
if ($resultat == '') { //cas ou la requete comporte des erreurs
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Fct consulter() : La requete form&eacute;e comporte une erreur !!');
} elseif ($resultat) {
$res_version[$version] = $resultat;
} else { //cas ou la requete renvoi un tableau vide
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Donn&eacute;es introuvables dans la base '.$version.' <br/>
L\'identifiant demande n\'est pas un taxon et aucun taxon ne lui a ete attribue');
}
}
}
}
if ($this->corps_http == '' && $this->entete_http == '') {
$resultat_formate = $this->retournerResultatFormate($res_version);
}
$this->formerReponseHTTP($resultat_formate);
}
 
 
/**
*
* Permet d'analyser les paramètres
* @param array $parametres
*/
public function traiterParametres($parametres) {
$this->table_param = $parametres;
if (isset($parametres) && ($parametres)) {
if (isset($parametres['recherche']) && $parametres['recherche'] != '') {
$this->recherche = $parametres['recherche'];
}
foreach ($parametres as $param => $val) {
switch ($param) {
case 'ns_format' : $this->html = $val; break;
case 'ns_structure' : $this->remplirTableCompositionNom($val);
$this->requete_champ .= ' ,'.implode(', ',$this->compo_nom); break;
case 'masque' : $this->ajouterFiltreMasque($val); break;
case 'masque_nt' : $this->ajouterFiltreMasqueNt($val); break;
case 'masque_rg' : $this->requete_condition .= ' AND rang = '.$this->getBdd()->proteger($val); break;
case 'navigation_depart': $this->limite_requete['depart'] = $val; break;
case 'navigation_limite': $this->limite_requete['limite'] = $val; break;
case 'retour_format' : $this->retour_format = $val; break;
case 'recherche' : break;
default : $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur dans les parametres de recherche de votre
requete : </br> Le parametre " '.$param.' " n\'existe pas.');
break;
}
}
}
}
public function ajouterFiltreMasque($val) {
if ($this->recherche == 'etendue') {
$val = str_replace(' ','%', $val);
$val .= '%';
$this->requete_condition .= ' AND nom_sci LIKE '.$this->getBdd()->proteger($val);
} elseif ($this->recherche == 'floue') {
$this->requete_condition .= ' AND (SOUNDEX(nom_sci) = SOUNDEX(\''.$val.'\')'
.' OR SOUNDEX(REVERSE(nom_sci)) = SOUNDEX(REVERSE(\''
.$val.'\'))) ';
} else {
$this->requete_condition .= ' AND nom_sci LIKE '.$this->getBdd()->proteger($val);
}
}
public function ajouterFiltreMasqueNt($val) {
if (strrpos($val, ',') !== false) {
$ids_taxon = explode(",", $val);
} else {
$ids_taxon[] = $val;
}
foreach ($ids_taxon as $id) {
$this->requete_condition .= ' OR num_tax = '.$this->getBdd()->proteger($id);
}
$this->requete_condition = str_replace('num_nom = num_nom_retenu OR ',
'num_nom = num_nom_retenu AND (' , $this->requete_condition).')';
}
/**
* Permet d'ajouter à la requete_champ les parametres demandés qui composeront le nom_sci.
* Permet de remplir le tableau compo_nom qui regroupe les parametres demandés qui composeront le nom_sci.
* (parametres à ajouter aux nom_sci sous la forme : Auteur [annee, biblio] [addendum])
* @param la valeur du parametre nl.structure
*/
public function recupererParametreNom($valeur) {
$structure_nom = explode(",",$valeur);
foreach ($structure_nom as $structure) {
switch ($structure) {
case 'au' : $this->compo_nom['au'] = 'auteur'; break;
case 'an' : $this->compo_nom['an'] = 'annee'; break;
case 'bib' : $this->compo_nom['bib'] = 'biblio_origine'; break;
case 'ad' : $this->compo_nom['ad'] = 'nom_addendum'; break;
default : $this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur : Le parametre "'.$structure.'" n\'existe pas. <br/><br/>
Les parametres du nom possibles sont :
<li> au (auteur)</li><li> an (annee)</li>
<li> bib (bibliographie)</li><li> ad (nom_addendum)</li>');
break;
}
}
if (isset($this->compo_nom)) {
$this->requete_champ .= ' ,'.implode(', ',$this->compo_nom);
}
}
//------------------------------------------Fonction ressources---------------------------------------------------------------------
public function gererNumTax() {
if (!in_array('num_tax', $this->champs_table)) {
$this->presence_num_tax = false;
$this->requete_champ = str_replace(', num_tax ', '', $this->requete_champ);
} else {
$this->presence_num_tax = true;
}
}
public function traiterRessourcesIdentifiant() {
$this->format_reponse = 'taxons/id';
$this->num_nom_taxon = $this->recupererNumNomTaxon(); //on recupere le taxon correspondant au num_nom recherché
if ($this->entete_http == '') {
$this->requete_condition = ' num_nom = '.$this->num_nom_taxon;
if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) {
//---------------- requete de type taxons/#id/#champ+#champ--------------------------------------
if ($this->table_ressources[1] != 'relations') {
// SELECT *, nom_sci FROM bftfx_v2_00 WHERE num_nom = X;
$this->requete_champ = ' *, nom_sci ';
$this->format_reponse .= '/champ';
//---------------- requete de type taxons/#id/relations/#relation--------------------------------
} elseif ($this->table_ressources[1] == 'relations') {
$this->traiterRessourceIdRelations();
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur dans votre requete </br> Ressources disponibles : <br/>
<li> #id/relations </li> <li> #id/#champ+#champ </li> <li> #id/relations </li>
<li> #id/relations/inferieurs </li> <li> #id/relations/superieurs </li>');
}
} else {
//--------------- requete de type taxons/#id-----------------------------------------------------
$this->requete_champ = ' *, nom_sci ';
}
}
}
/**
* Permet de récupérer le num_nom du taxon recherché. Soit le numéro taxonomique est demandé (avec nt: )
* soit un num_nom dont on recherche le num_nom_retenu
*/
public function recupererNumNomTaxon() {
$identifiant = '';
if (strrpos($this->table_ressources[0], 'nt:') !== false) {
if ($this->presence_num_tax) {
// SELECT num_nom FROM bdtfx_v2_00 WHERE num_nom = num_nom_retenu AND num_tax = X;
$this->requete_condition = ' num_nom = num_nom_retenu AND num_tax = '
.str_replace('nt:', '', $this->table_ressources[0]).' ';
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur dans votre requete : </br> Le numero taxonomique n\'existe pas dans ce projet' );
}
} else {
// SELECT num_nom FROM bdtfx_v2_00 WHERE num_nom = (SELECT num_nom_retenu FROM bdtfx_v2_00 WHERE num_nom = X);
$this->requete_condition = ' num_nom = (SELECT num_nom_retenu FROM '
.$this->table.' WHERE num_nom = '.$this->table_ressources[0].')';
}
if ($this->entete_http == '') {
//on récupere l'identifiant du taxon correspondant au num_nom ou num_tax demandé pour pouvoir l'afficher
$res = '';
$req_tax = 'SELECT num_nom FROM '.$this->table.' WHERE '.$this->requete_condition;
$res_tax = $this->getBdd()->recuperer($req_tax);
//on recherche ensuite les identifiants des taxons supérieurs ou inférieurs
if ($res_tax == '') {
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Le numéro de taxon ou l\'identifiant de nom correspondant au num_nom '
.$this->table_ressources[0].' n\'existe pas dans la table '.$this->table);
} elseif ($res_tax) {
$identifiant = $res_tax['num_nom'];
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Le numéro de taxon ou l\'identifiant de nom correspondant au num_nom '
.$this->table_ressources[0].' n\'existe pas dans la table '.$this->table);
}
}
return $identifiant;
}
public function traiterRessourceIdRelations() {
//----------------- requete de type taxons/#id/relations-------------------------------------------
// SELECT *, nom_sci FROM bftfx_v2_00 WHERE num_nom = X;
$this->format_reponse .= '/relations';
if (isset($this->table_ressources[2])) {
//------------- requete de type taxons/#id/relations/#relation--------------------------------
switch ($this->table_ressources[2]) {
case 'superieurs' : $rel = 'recupererIdSup';
$this->format_reponse .= '/superieurs';
$this->traiterRessourceIdRelationInfSup($rel); break;
case 'inferieurs' : $rel = 'recupererIdInf';
$this->format_reponse .= '/inferieurs';
$this->traiterRessourceIdRelationInfSup($rel); break;
default : $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,
'Erreur dans votre requ&ecirc;te </br> Ressources disponibles : <br/>
<li> taxons/#id/relations </li> <li> taxons/#id/relations/flores </li>
<li> taxons/#id/relations/homonymie </li> <li> #id/relations/inferieurs </li>
<li> #id/relations/superieurs </li>'); break;
}
}
}
 
 
public function traiterRessourceIdRelationInfSup($rel) {
//Appel de la fct récupérerIdSup ou recupererIdInf : retourne les num_nom des noms inferieurs ou superieurs
$res_relation = $this->$rel();
//analyse du résultat retourné par la requete de recherche des identifiants correspondant aux taxons inf|sup :
if ($res_relation == '') { //dans le cas ou la requete comporte des erreurs
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Fct traiterRessourceIdHomonymie : La requete forme comporte une erreur !!');
} elseif ($res_relation) {
//dans le cas ou une ou plusieurs relations est retournée, on récupère les identifiants ss la forme (id, id, id)
foreach ($res_relation as $ligne) $res[] = $ligne['num_nom'];
$res = implode(',',$res);
$this->requete_condition = ' num_nom IN ('.$res.')';
$this->requete_champ .= ', rang, num_tax_sup ';
} else { //dans le cas ou aucune relation n'existe
$res = array($this->num_nom_taxon => null);
$this->corps_http = json_encode($res);
$this->entete_http = RestServeur::HTTP_CODE_OK;
}
}
public function recupererIdInf() {
//SELECT num_nom FROM bfdtx_v2_00 WHERE num_tax_sup = (SELECT num_nom FROM bdtfx_v2_00 WHERE num_nom = X);
$req_relation = 'SELECT num_nom FROM '.$this->table
.' WHERE num_tax_sup = (SELECT num_nom FROM '
.$this->table
.' WHERE '.$this->requete_condition.')';
$res_relation = $this->getBdd()->recupererTous($req_relation);
return $res_relation;
}
public function recupererIdSup() {
//SELECT num_nom FROM bfdtx_v2_00 WHERE num_nom = (SELECT num_tax_sup FROM bdtfx_v2_00 WHERE num_nom = X);
$req_relation = 'SELECT num_nom FROM '.$this->table
.' WHERE num_nom = (SELECT num_tax_sup FROM '
.$this->table
.' WHERE '.$this->requete_condition.')';
$res_relation = $this->getBdd()->recupererTous($req_relation);
return $res_relation;
}
 
public function traiterRessourceStatsInitiales() {
// SELECT count(nom_sci) as nb, rang, left(nom_sci, 2) as lettre FROM bdtfx_v2_00 GROUP BY rang, left(nom_sci, 2);
$this->format_reponse = 'taxons/stats/initiales';
$this->requete_champ = 'count(nom_sci) as nb, rang, left(nom_sci, 2) as lettre ';
$this->requete_group_by = ' GROUP BY rang, left(nom_sci, 2) ';
}
public function traiterRessourceStatsRangs() {
// SELECT count(*) as nombre, rang FROM bdtfx_v2_00 [WHERE rang = 290] GROUP BY rang ORDER BY rang;
$this->format_reponse = 'taxons/stats/rangs';
$this->requete_champ = 'count(*) as nombre, rang ';
$this->requete_group_by = ' GROUP BY rang ORDER BY rang ';
}
public function traiterRessourceStatsAnnees() {
// SELECT count(*) as nombre, annee FROM bdtfx_v2_00 GROUP BY annee ORDER BY annee;
$this->format_reponse = 'taxons/stats/annees';
$this->requete_champ = 'count(*) as nombre, annee ';
$this->requete_group_by = ' GROUP BY annee ORDER BY annee ';
}
//-----------------------------FONCTIONS DASSEMBLAGE DE LA REQUETE-----------------------------------------------------
public function assemblerLaRequete() {
if ($this->format_reponse != 'taxons/stats/initiales') {
$this->mettreAuFormat(); //on remplace les nom_sci par les nom_sci_html
}
if ($this->requete_condition != '') {
$this->requete_condition = ltrim($this->requete_condition, ' AND, WHERE');
$this->requete_condition = ' WHERE '.$this->requete_condition;
}
if ($this->format_reponse != 'taxons' && $this->format_reponse != 'taxons/id/relations/homonymie') {
$this->requete_limite = '';
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) {
$this->limite_requete['depart'] = (($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']);
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
} else {
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
}
$requete = ' SELECT '.$this->requete_champ.
' FROM '.$this->table
.$this->requete_condition
.$this->requete_group_by
.$this->requete_limite;
return $requete;
}
/**
* Recupere le nombre total de résultat d'une requete lancée.
* Est utilisée lors de l'affichage du total dans le résultat retourné
* @return Le nombre total de résultat
*/
public function recupererTotalResultat() {
$requete = 'SELECT count(*) as nombre FROM '.$this->table.$this->requete_condition.$this->requete_group_by;
$res = $this->getBdd()->recuperer($requete);
if ($res) {
$total = $res['nombre'];
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Fct recupererTotalResultat() : <br/>Donn&eacute;es introuvables dans la base');
}
return $total;
}
 
//-------------------------FONCTIONS DE FORMATION DU RESULTAT-----------------------------------------------------------
/**
* Permet de récupérer le résultat à retourner propre à chaque requete et de l'encoder en json
* @param array $resultat
* @param array $ressources
* @return le résultat encoder en json
*/
public function retournerResultatFormate($resultat) {
switch ($this->format_reponse) {
case 'taxons/id' : $reponse = $this->formaterId($resultat); break; //ds CommunNomsTaxons
case 'taxons/id/champ' : $reponse = $this->formaterIdChamp($resultat); break; //ds CommunNomsTaxons
case 'taxons/id/relations' : $reponse = $this->formaterIdRelations($resultat); break;
case 'taxons/id/relations/superieurs' : $reponse = $this->formaterIdSuperieur($resultat); break;
case 'taxons/id/relations/inferieurs' : $reponse = $this->formaterIdInferieur($resultat); break;
case 'taxons/stats/annees' : $reponse = $this->formaterStatsAnnee($resultat); break; //ds CommunNomsTaxons
case 'taxons/stats/rangs' : $reponse = $this->formaterStatsRang($resultat); break; //ds CommunNomsTaxons
case 'taxons/stats/initiales' : $reponse = $this->formaterStatsInitiales($resultat); break; //ds CommunNomsTaxons
case 'taxons' : $reponse = $this->formatertaxons($resultat); break;
default : break;
}
return json_encode($reponse);
}
//----------------------concerne les resultats pour des requetes de type /noms avec ou sans paramètres--------------
/**
*
* Est utilisée pour les requetes de type /noms avec ou sans parametres. Détermine le format json ou oss.
* @param retourne le résultat sous forme de tableau, à encoder en json.
*/
public function formaterTaxons($resultat) {
if ($this->retour_format == 'oss') {
$reponse = $this->formaterEnOss($resultat);