Subversion Repositories eFlore/Projets.eflore-projets

Compare Revisions

Ignore whitespace Rev 973 → Rev 974

/tags/v5.2-alpage/services/modules/0.1/chorodep/Cartes.php
New file
0,0 → 1,90
<?php
// declare(encoding='UTF-8');
/**
* Classe implémentant l'API d'eFlore Cartes pour le projet CHORODEP.
*
* @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 ChorodepCartes {
 
private $parametres = array();
private $ressources = array();
 
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 : carte proportionnelle ensemble des infos";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
} else if ($nbreRessources == 1) {
if ($this->etreRessourceIdentifiants(0)) {
$this->sousService = 'Taxons';
} else if ($this->etreRessourceLegende(0)) {
$message = "A implémenter : légende carte proportionnelle ensemble des infos";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
} 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 == 2) {
if ($this->etreRessourceIdentifiants(0) && $this->etreRessourceLegende(1)) {
$this->sousService = 'Legende';
}
}
}
 
private function etreRessourceIdentifiants($position) {
$ok = true;
if (isset($this->ressources[$position])) {
$ids = $this->ressources[$position];
$projetPattern = '(?:(?:(?:[A-Za-z0-9]+\.)?(?:nn|nt)?:)?(?:[0-9]+,)*[0-9]+)';
$patternComplet = "/^$projetPattern(?:;$projetPattern)*$/i";
$ok = preg_match($patternComplet, $ids) ? true : false;
}
return $ok;
}
 
private function etreRessourceLegende($position) {
$ok = true;
if (isset($this->ressources[$position])) {
$legende = $this->ressources[$position];
$ok = ($legende == 'legende') ? true : false;
}
return $ok;
}
 
private function executerSousService() {
if (isset($this->sousService)) {
$classe = $this->sousService.'Cartes';
require_once dirname(__FILE__).DS.'cartes'.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;
}
}
?>
/tags/v5.2-alpage/services/modules/0.1/chorodep/Ontologies.php
New file
0,0 → 1,366
<?php
/**
* Description :
* Classe Ontologies.php fournit des informations sur ensemble structuré des termes et concepts représentant les éléments
* d'un domaine de connaissances .
* Le but étant de fournir un ensemble minimal d'information comprenant :
* un identifiant (numérique ou alphanumérique sous forme de ChatMot si possible), un nom, une description et
* éventuellement une relation hiérarchique avec un autre terme (=classe).
* Si l'url finit par /ontologies on retourne une liste de termes (seulement les 100 premières par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /ontologies?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.description , recherche,
* distinct, retour.format, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package eflore-projets
* @author Jennifer DHÉ <jennifer.dhe@tela-botanica.org>
* @author Delphine CAUQUIL <delphine@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 0.1
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org)
*/
class ChorodepOntologies extends Commun {
 
protected $requete_condition = null; //Représente la partie de la requete SQL ajoutant une condition (WHERE ...)
/** Permet de stocker la requete formulée: /ontologies | /ontologies/#id | /ontologies/#id/champ | /ontologies/#id/relations */
protected $format_reponse = 'ontologies';
/** Permet de stocker les limite de la requete SQL (par défaut seul les 100 premiers résultats seront retournés).
* Stocke également les valeurs des paramètres navigation.depart et navigation.limite passés dans la requete*/
protected $limite_requete = array( 'depart' => 0, 'limite' => 100);
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */
protected $total_resultat;
protected $retour_format = 'max';
 
public function consulter($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
$this->service = 'ontologies';
$this->traiterParametres();
$resultats = '';
$this->table = 'chorodep_ontologies'; //on stocke le nom de la table correspondant à la version du projet en cours
$this->recupererNomChamp($this->table); //on récupère les noms des champs disponibles (Ds Commun.php)
$this->traiterRessources(); //dans CommunNomsTaxons.php
$requete = $this->assemblerLaRequete();
$resultat = $this->getBdd()->recupererTous($requete);
$versionResultat = $this->traiterResultat($resultat, '', $requete);
$resultats = $versionResultat;
return $resultats;
}
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres)) {
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'masque' : $this->ajouterLeFiltreMasque('masque', $valeur); break;
case 'masque.code' : $this->ajouterLeFiltreMasque('code', $valeur); break;
case 'masque.nom' : $this->ajouterLeFiltreMasque('nom', $valeur); break;
case 'masque.description' : $this->ajouterLeFiltreMasque('description', $valeur); break;
case 'retour.format' : $this->retour_format = $valeur; break;
case 'retour.champs' : break;
case 'navigation.depart' : $this->limite_requete['depart'] = $valeur; break;
case 'navigation.limite' : $this->limite_requete['limite'] = $valeur; break;
case 'recherche' : break;
case 'version.projet' : break;
default :
$e = 'Erreur dans les parametres de recherche de votre requête : </br> Le paramètre " '
.$param.' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break;
}
}
}
}
 
public function ajouterLeFiltreMasque($nom_champ, $valeur) {
if ($nom_champ == 'code') {
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] == 'floue') {
if ($nom_champ == 'masque') {
$this->requete_condition[] = '( code = '.$this->getBdd()->proteger($valeur)
.' OR ( SOUNDEX(nom) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(nom)) = SOUNDEX(REVERSE(\''.$valeur.'\')) '
.') OR ( SOUNDEX(description) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(description)) = SOUNDEX(REVERSE(\''.$valeur.'\')) ))';
} else {
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\')))';
}
} else {
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] == 'etendue') {
$valeur = str_replace(' ','%', $valeur);
$valeur .= '%';
}
if ($nom_champ == 'masque') {
$this->requete_condition[] = '(code = '.$this->getBdd()->proteger($valeur)
.' OR nom LIKE '.$this->getBdd()->proteger($valeur)
.' OR description LIKE '.$this->getBdd()->proteger($valeur).')';
} else {
$this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur);
}
}
}
}
 
 
public function traiterRessources() {
if (isset($this->ressources) && !empty($this->ressources)) {
if (isset($this->ressources[0]) && !empty($this->ressources[0])) {
//requete = /ontologies/#id
$this->traiterRessourceId();
if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
//requete = /ontologies/#id/relations
$this->traiterRessourceRelations();
}
}
}
}
 
 
public function traiterRessourceId() {
$this->requete_condition = array();
//requete : /ontologies/#id (ex : /ontologies/7)
if (is_numeric($this->ressources[0])) {
$this->requete_condition[] = ' id = '.$this->getBdd()->proteger($this->ressources[0]);
$this->format_reponse .= '/id';
//requete : /ontologies/#classe:#code (ex : /ontologies/rangTaxo:290)
} elseif (strrpos($this->ressources[0], ':') !== false) {
$this->format_reponse .= '/id';
preg_match('/^([^:]+):([^:]+)$/', $this->ressources[0], $match);
$this->requete_condition[] =
' id = (SELECT id FROM '.$this->table.' WHERE code = '.$this->getBdd()->proteger($match[2])
.' AND classe_id = (SELECT id FROM '.$this->table.' WHERE code = '.$this->getBdd()->proteger($match[1]).'))';
} else {
$e = 'Erreur dans les paramètres de recherche de votre requête : </br> Le paramètre " '
.$this->ressources[0].' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
 
 
public function traiterRessourceRelations() {
//requete = /ontologies/#id/relations :
if ($this->ressources[1] == 'relations') {
$this->format_reponse .= '/relations';
$this->requete_condition = array('classe_id = (SELECT classe_id FROM '.$this->table.' WHERE '
.implode(' AND ', $this->requete_condition).')');
}
}
 
//+--------------------------FONCTION ASSEMBLAGE DE LA REQUETE-------------------------------------------+
 
public function assemblerLaRequete() {
$requete = ' SELECT '.$this->formerRequeteChamp().
' FROM '.$this->table
.$this->retournerRequeteCondition()
.$this->formerRequeteLimite(); //print_r($requete);
return $requete;
}
 
public function formerRequeteChamp() {
$champ[] = 'id';
if ($this->format_reponse == 'ontologies') {
$champ[] = 'nom, code ';
}
if (isset($this->parametres['retour_champs']) || $this->format_reponse == 'ontologies/id/champs') {
$champs_recherches = explode(',', $this->parametres['retour_champs']);
$champs_possibles = $this->rechercherChampsPossibles();
foreach ($champs_recherches as $champ_recherche) {
if ($this->verifierValiditeChamp($champ_recherche)) {
$champ[] = (preg_match('/classe/', $champ_recherche)) ? 'classe_id' : $champ_recherche;
}
}
}
if (count($champ) == 1) {
$champ = array(' * ');
}
return implode(', ', $champ);
}
 
public function rechercherChampsPossibles() {
$this->recupererNomChamp($this->table);
$champs_possibles = $this->champs_table;
$champs_possibles[] = 'classe.id';
$champs_possibles[] = 'classe';
$champs_possibles[] = 'classe.href';
return $champs_possibles;
}
 
public function verifierValiditeChamp($champ, $champs_possibles) {
$validite = false;
preg_match('/^([^.]+)(:?\.([^.]+))?$/', $champ, $match);
if (in_array($match[1], $champs_possibles)) {
$validite = true;
} else {
$champs = implode('</li><li>', $champs_possibles);
$e = 'Erreur dans votre requête : </br> Le champ "'.$champ
.'" n\'existe pas. Les champs disponibles sont : <li>'.$champs.'</li>';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
return $validite;
}
 
public function retournerRequeteCondition() {
$condition = '';
if ($this->requete_condition !== null) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
public function formerRequeteLimite() {
$this->total_resultat = $this->recupererTotalResultat();
if (in_array($this->format_reponse , array('textes/id', 'textes/id/relations'))) {
$this->requete_limite = '';
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat)) {
$this->limite_requete['depart'] =
(($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']);
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
} else {
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
}
return $this->requete_limite;
}
 
 
public function recupererTotalResultat() {
//on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /ontologies)
$requete = 'SELECT count(*) as nombre FROM '.$this->table.' '
.$this->retournerRequeteCondition();
$res = $this->getBdd()->recuperer($requete);
if ($res) {
$total = $res['nombre'];
} else {
$e = 'Données introuvables dans la base';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
Debug::printr($requete);
}
return $total;
}
 
//+------------------------------------------------------------------------------------------------------+
public function retournerResultatFormate($resultat) {
// determine en fct du service appelé (/ontologies | /ontologies/#id | /ontologies/#id/champ |
// /ontologies/#id/relations) le format du tableau à retourner. Encode en json
switch ($this->format_reponse) {
case 'ontologies' : $reponse = $this->formaterOntologies($resultat); break;
case 'ontologies/id' : $reponse = $this->formaterOntologiesId($resultat[0]); break;
case 'ontologies/id/relations' : $reponse = $this->formaterOntologiesIdRelations($resultat); break;
default : break;
}
return $reponse;
}
 
 
public function formaterOntologies($resultat) {
$this->ajouterEnteteResultat($resultat);
$table_retour_json['entete'] = $this->ajouterEnteteResultat($resultat);
if (isset($this->parametres['masque_code']) || isset($this->parametres['masque'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque_code'], $resultat, 'code');
} elseif (isset($this->parametres['masque_nom'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque_nom'], $resultat, 'nom');
} elseif (isset($this->parametres['masque_description'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque_description'], $resultat, 'description');
}
//on remplit la table $table_retour_json['resultat']
foreach ($resultat as $tab) {
$num = $tab['id'];
unset($tab['id']);
foreach ($tab as $param => $valeur) {
$resultat_json[$num][$param] = $valeur;
}
if ($this->retour_format == 'max') $resultat_json[$num]['href'] = $this->ajouterHref('ontologies', $num);
}
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
 
public function ajouterEnteteResultat($resultat) {
//on remplit la table $table_retour_json['entete']
$entete['depart'] = $this->limite_requete['depart'];
$entete['limite'] = $this->limite_requete['limite'];
$entete['total'] = $this->total_resultat;
//formuler les urls
$url = $this->formulerUrl($this->total_resultat, '/ontologies');
if (isset($url['precedent']) && $url['precedent'] != '') { $entete['href.precedent'] = $url['precedent']; }
if (isset($url['suivant']) && $url['suivant'] != '') { $entete['href.suivant'] = $url['suivant']; }
return $entete;
}
 
 
public function formaterOntologiesId($resultat) {
$table_retour = array();
foreach ($resultat as $key => $valeur) {
if ($valeur != '') {
$table_retour = array_merge($table_retour, $this->afficherDonnees($key, $valeur));
}
}
return $table_retour;
}
 
public function afficherDonnees($champ, $valeur) {
$retour[$champ] = $valeur;
if ($this->retour_format == 'max') {
if ($champ == 'classe_id') {
unset($retour[$champ]); // remplacer par classe.id
if ($valeur != "0") { // pas de parent
if (isset($this->parametres['retour_champs'])) {
switch ($this->parametres['retour_champs']) {
case 'classe' : $retour['classe'] = $this->ajouterClasseCorrespondante($valeur); break;
case 'classe.id' : $retour['classe.id'] = $valeur; break;
case 'classe.href' : $retour['classe.href'] = $this->ajouterHref('ontologies', $valeur); break;
case 'classe.*' : $retour['classe.id'] = $valeur; $retour['classe.href'] = $this->ajouterHref('ontologies', $valeur); break;
}
} else {
$nom_classe = $this->ajouterClasseCorrespondante($valeur);
if (isset($nom_classe)) $retour['classe'] = $nom_classe;
$retour['classe.id'] = $valeur;
$retour['classe.href'] = $this->ajouterHref('ontologies', $valeur);
}
}
}
}
return $retour;
}
 
/** Recherche par interrogation de la base, le nom de la classe à partir de son identifiant (classe.id) */
public function ajouterClasseCorrespondante($classe_id) {
$nom = null;
if ($classe_id != 0) {
$nom = '';
$req = 'SELECT nom FROM '.$this->table.' WHERE id = '.$this->getBdd()->proteger($classe_id);
$res = $this->getBdd()->recuperer($req);
if ($res) {
$nom = $res['nom'];
} else {
$e = "Données introuvables dans la table $this->table";
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
Debug::printr($req);
}
}
return $nom;
}
 
public function formaterOntologiesIdRelations($resultat) {
$retour = null;
if ($resultat != '') {
$retour['entete'] = $this->ajouterEnteteResultat($resultat);
//on remplit la table $table_retour_json['resultat']
foreach ($resultat as $tab) {
$num = $tab['id'];
$retour['resultat'][$num]['nom'] = $tab['nom'];
if ($this->retour_format == 'max') {
$retour['resultat'][$num]['href'] = $this->ajouterHref('ontologies', $num);
}
}
}
return $retour;
}
}
?>
/tags/v5.2-alpage/services/modules/0.1/chorodep/cartes/TaxonsCartes.php
New file
0,0 → 1,463
<?php
// declare(encoding='UTF-8');
/**
* Gère le sous-service Taxons 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 TaxonsCartes {
 
private $parametres = array();
private $ressources = array();
 
const CODE_REFTAX_DEFAUT = 'bdtfx';
const TYPE_ID_DEFAUT = 'nn';
const CARTE_DEFAUT = 'france_02';
const FORMAT_DEFAUT = '587x550';
const VERSION_DEFAUT = '+';
const MIME_SVG = 'image/svg+xml';
const MIME_PNG = 'image/png';
const PRESENCE_CHOROLOGIE = '1';
 
private $config = array();
private $convertisseur = '';
private $cheminCartesBase = '';
private $formatsSupportes = array(self::MIME_SVG, self::MIME_PNG);
private $reftaxSupportes = array(self::CODE_REFTAX_DEFAUT);
private $UrlNavigation = null;
private $taxonsDemandes = array();
private $imgLargeur = 0;
private $imgHauteur = 0;
private $tableMeta = '';
private $tableOntologie = '';
private $tableChorodep = '';
private $metadonnees = '';
private $ontologies = '';
private $priorites = '';
private $version = '';
private $legende = array();
private $donnees = array();
 
 
public function __construct(Conteneur $conteneur) {
$this->Bdd = $conteneur->getBdd();
$this->tableOntologie = $conteneur->getParametre('bdd_table_ontologies');
$this->config = $conteneur->getParametre('Cartes');
$this->convertisseur = $this->config['convertisseur'];
$this->tableMeta = $conteneur->getParametre('bdd_table_meta');
$this->tableOntologie = $conteneur->getParametre('bdd_table_ontologies');
$this->cheminCartesBase = $this->config['chemin'];
$cacheOptions = array('mise_en_cache' => $this->config['cache_miseEnCache'],
'stockage_chemin' => $this->config['cache_stockageChemin'],
'duree_de_vie' => $this->config['cache_dureeDeVie']);
$this->cache = $conteneur->getCacheSimple($cacheOptions);
}
 
public function consulter($ressources, $parametres) {
$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_SVG;
}
if (isset($this->parametres['retour.format']) == false) {
$this->parametres['retour.format'] = self::FORMAT_DEFAUT;
}
if (isset($this->parametres['version.projet']) == false) {
$this->parametres['version.projet'] = self::VERSION_DEFAUT;
}
}
 
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 (isset($this->parametres['retour.format']) == false) {
$erreurs[] = "Le paramètre de format de retour 'retour.format' est obligatoire.";
}
if ($this->verifierValeurParametreFormat() == false) {
$erreurs[] = "Le type de format '{$this->parametres['retour.format']}' n'est pas supporté.".
"Veuillez indiquer un nombre entier correspondant à la largeur désirée pour la carte.";
}
if ($this->verifierValeurParametreVersionProjet() == false) {
$erreurs[] = "Le format de version.projet '{$this->parametres['version.projet']}' n'est pas supporté.".
"Veuillez indiquer le code '+' (=dernière version) ou une année sur 4 chiffres séparé d'un mois ".
"sur deux chiffres par un point. Ex. : 2012.01";
}
 
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 verifierValeurParametreFormat() {
if ($ok = preg_match('/^([0-9]+)$/', $this->parametres['retour.format'], $match)) {
$this->imgLargeur = $match[1];
} else if ($ok = preg_match('/^([0-9]+)x([0-9]+)$/', $this->parametres['retour.format'], $match)) {
$this->imgLargeur = $match[1];
$this->imgHauteur = $match[2];
}
return $ok;
}
private function verifierValeurParametreVersionProjet() {
$ok = (preg_match('/^(?:[+]|[0-9]{4}\.[0-9]{2})$/', $this->parametres['version.projet']) == 0) ? false : true;
return $ok;
}
 
private function obtenirResultat() {
$this->analyserIdentifiants();
$this->verifierIdentifiants();
 
$this->chargerMetadonnees();
$this->definirVersion();
$this->tableChorodep = 'chorodep_v'.str_replace('.', '_', $this->version);
$this->chargerOntologies();
$this->chargerLegende();
$this->chargerPrioritesLegende();
$this->chargerDonnees();
$svg = $this->genererSVG();
$img = ($this->parametres['retour'] == self::MIME_PNG) ? $this->convertirEnPNG($svg) : $svg;
 
$resultat = new ResultatService();
$resultat->corps = $img;
$resultat->mime = $this->parametres['retour'];
 
return $resultat;
}
 
private function analyserIdentifiants() {
$ids = $this->ressources[0];
if (preg_match('/^[0-9]+$/', $ids)) {
$this->taxonsDemandes[self::CODE_REFTAX_DEFAUT]['nn'][] = $ids;
} else {
// ceci contient potentiellement des formes ref_tax1.nn:1,2;ref_tax2.nt:3,4
$projetsListeEtNumNoms = explode(';', $ids);
if (count($projetsListeEtNumNoms) > 0) {
foreach ($projetsListeEtNumNoms as $projetEtNumNoms) {
$projetEtNumNoms = (strpos($projetEtNumNoms, ':')) ? $projetEtNumNoms : self::CODE_REFTAX_DEFAUT.'.nn:'.$projetEtNumNoms;
list($projetEtType, $numNoms) = explode(':', $projetEtNumNoms);
 
$projetEtType = (strpos($projetEtType, '.')) ? $projetEtType : self::CODE_REFTAX_DEFAUT.'.'.$projetEtType;
list($projet, $type) = explode('.', $projetEtType);
 
$this->taxonsDemandes[$projet][$type] = explode(',', $numNoms);
}
}
}
}
 
private function verifierIdentifiants() {
foreach (array_keys($this->taxonsDemandes) as $reftax) {
$ok = in_array($reftax, $this->reftaxSupportes);
if ($ok == false) {
$message = "Le reférentiel taxonomique '$reftax' n'est pas pris en compte par ce projet.";
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
}
 
private function chargerMetadonnees() {
$requete = 'SELECT * '.
"FROM {$this->tableMeta} ".
"ORDER BY date_creation DESC ";
$resultats = $this->Bdd->recupererTous($requete);
 
if (!is_array($resultats) || count($resultats) <= 0) {
$message = "Les méta-données n'ont pu être chargée pour la ressource demandée";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
 
$this->metadonnees = $resultats;
}
 
private function definirVersion() {
if ($this->parametres['version.projet'] == '+') {
$this->version = $this->metadonnees[0]['version'];
} else {
$this->version = $this->parametres['version.projet'];
}
}
 
private function chargerOntologies() {
$requete = 'SELECT * '.
"FROM {$this->tableOntologie} ";
$resultats = $this->Bdd->recupererTous($requete);
 
if (!is_array($resultats) || count($resultats) <= 0) {
$message = "Les données de légende 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::PRESENCE_CHOROLOGIE) {
$this->legende[$ontologie['code']] = $ontologie['legende'];
}
}
}
 
private function chargerPrioritesLegende() {
foreach ($this->ontologies as $ontologie) {
if ($ontologie['classe_id'] == self::PRESENCE_CHOROLOGIE && isset($ontologie['priorite'])) {
$this->priorites[$ontologie['code']] = $ontologie['priorite'];
}
}
}
 
private function chargerDonnees() {
$conditions = $this->getConditions();
$requete = 'SELECT * '.
"FROM {$this->tableChorodep} ".
(isset($conditions) ? 'WHERE '.implode(' AND ', $conditions) : '');
$resultat = $this->Bdd->recupererTous($requete);
$this->donnees = $resultat;
}
 
private function getConditions() {
$conditions = null;
if ($nnListe = $this->getListeNumNom()) {
$conditions[] = "num_nom IN ($nnListe) ";
}
if ($ntListe = $this->getListeNumTax()) {
$conditions[] = "num_tax IN ($ntListe) ";
}
return $conditions;
}
 
private function getListeNumNom() {
$nnListe = null;
$refTax = self::CODE_REFTAX_DEFAUT;
if (isset($this->taxonsDemandes[$refTax])) {
$nnProteges = array();
if (isset($this->taxonsDemandes[$refTax]['nn'])) {
foreach ($this->taxonsDemandes[$refTax]['nn'] as $nn) {
$nnProteges[] = $this->Bdd->proteger($nn);
}
$nnListe = implode(',', $nnProteges);
}
}
return $nnListe;
}
 
private function getListeNumTax() {
$ntListe = null;
$refTax = self::CODE_REFTAX_DEFAUT;
if (isset($this->taxonsDemandes[$refTax])) {
$ntProteges = array();
if (isset($this->taxonsDemandes[$refTax]['nt'])) {
foreach ($this->taxonsDemandes[$refTax]['nt'] as $nt) {
$ntProteges[] = $this->Bdd->proteger($nt);
}
$ntListe = implode(',', $ntProteges);
}
}
return $ntListe;
}
 
private function genererSVG() {
$dom = new DOMDocument('1.0', 'UTF-8');
$dom->validateOnParse = true;
 
$fichierCarteSvg = $this->cheminCartesBase.self::CARTE_DEFAUT.'.svg';
$dom->load($fichierCarteSvg);
 
$racineElement = $dom->documentElement;
$racineElement->setAttribute('width', $this->imgLargeur);
if ($this->imgHauteur != 0) {
$racineElement->setAttribute('height', $this->imgHauteur);
}
 
$css = $this->creerCssCarte();
$styleElement = $dom->getElementsByTagName('style')->item(0);
$css = $styleElement->nodeValue.$css;
$txtCss = $dom->createCDATASection($css);
$styleElement->nodeValue = '';
$styleElement->appendChild($txtCss);
 
$titre = $this->creerTitre();
$titreCdata = $dom->createCDATASection($titre);
$titreElement = $dom->getElementsByTagName('title')->item(0);
$titreElement->nodeValue = '';
$titreElement->appendChild($titreCdata);
 
$taxonTitre = $this->creerTitreTaxon();
$taxonCdata = $dom->createCDATASection($taxonTitre);
$xpath = new DOMXPath($dom);
$taxonTitreEl = $xpath->query("//*[@id='titre-taxon']")->item(0);
$taxonTitreEl->nodeValue = '';
$taxonTitreEl->setAttribute('title', $taxonTitre);
$taxonTitreEl->appendChild($taxonCdata);
 
$svg = $dom->saveXML();
return $svg;
}
 
private function creerCssCarte() {
$css = '';
$this->getZonesPriorites();
$zonesCouleurs = $this->getZonesCouleurs();
foreach ($zonesCouleurs as $couleur => $zonesClasses) {
$classes = implode(', ', $zonesClasses);
$css .= "$classes{\nfill:$couleur;\n}\n";
}
return $css;
}
 
private function getZonesPriorites() {
$this->zones = array();
$zonesPrioritaires = array();
foreach ($this->donnees as $donnee) {
foreach ($donnee as $zoneId => $codeLegende) {
if (preg_match('/^[0-9][0-9ab]$/i', $zoneId)) {
if (array_key_exists($codeLegende, $this->priorites)) {
$priorite = $this->priorites[$codeLegende];
if (array_key_exists($zoneId, $zonesPrioritaires) == false) {
$zonesPrioritaires[$zoneId] = 0;
}
if ($priorite > $zonesPrioritaires[$zoneId]) {
$zonesPrioritaires[$zoneId] = $priorite;
$this->zones[$zoneId] = $codeLegende;
}
}
}
}
}
}
 
private function getZonesCouleurs() {
$zones = array();
ksort($this->zones);
foreach ($this->zones as $zoneId => $codeLegende) {
if (array_key_exists($codeLegende, $this->legende)) {
$couleur = $this->legende[$codeLegende];
$zones[$couleur][] = strtolower('.departement'.sprintf('%02s', $zoneId));
}
}
return $zones;
}
 
private function creerTitre() {
$titre = "Carte en cours d'élaboration";
if ($this->donnees != array()) {
$titre .= ' pour '.$this->creerTitreTaxon();
}
return $titre;
}
 
private function creerTitreTaxon() {
$titre = '';
$noms = array();
foreach ($this->donnees as $donnee) {
$noms[] = $donnee['nom_sci'];
}
$titre = implode(', ', $noms);
return $titre;
}
 
private function convertirEnPNG($svg) {
$png = null;
if (isset($this->convertisseur)) {
if ($this->convertisseur == 'imagick') {
if (extension_loaded('imagick')) {
$png = $this->convertirEnPNGAvecImageMagick($svg);
} else {
$message = "Impossible de générer l'image sur le serveur. Extension ImageMagick abscente.";
$code = RestServeur::HTTP_CODE_ERREUR;
throw new Exception($message, $code);
}
} else if ($this->convertisseur == 'rsvg') {
$png = Commun::convertirEnPNGAvecRsvg($this->getIdFichier(), $this->config['cache_stockageChemin'], $svg);
} else {
$message = "Le convertisseur indiqué '{$this->convertisseur}' ne fait pas parti de la liste ".
"des convertisseurs disponibles : imagick, rsvg.";
$code = RestServeur::HTTP_CODE_ERREUR;
throw new Exception($message, $code);
}
} else {
$message = "Veuillez indiquer le convertisseur de svg à utiliser pour le service.";
$code = RestServeur::HTTP_CODE_ERREUR;
throw new Exception($message, $code);
}
return $png;
}
 
private function convertirEnPNGAvecImageMagick($svg) {
$convertisseur = new Imagick();
$convertisseur->setBackgroundColor(new ImagickPixel('transparent'));
$convertisseur->readImageBlob($svg);
$convertisseur->setImageFormat('png32');
$convertisseur->resizeImage($this->imgLargeur, $this->imgHauteur, imagick::FILTER_LANCZOS, 0, true);
$png = $convertisseur->getImageBlob();
$convertisseur->clear();
$convertisseur->destroy();
return $png;
}
 
private function getIdFichier() {
$id = '';
foreach ($this->taxonsDemandes as $reftax => $ids) {
$id[] = $reftax;
foreach ($ids as $type => $vals) {
$id[] = $type;
$id[] = implode('-', $vals);
}
}
$id = implode('-', $id);
return $id;
}
 
public function getParametreTableau($cle) {
$tableau = array();
$parametre = $this->config[$cle];
if (empty($parametre) === false) {
$tableauPartiel = explode(',', $parametre);
$tableauPartiel = array_map('trim', $tableauPartiel);
foreach ($tableauPartiel as $champ) {
if (strpos($champ, '=') === false) {
$tableau[] = trim($champ);
} else {
list($cle, $val) = explode('=', $champ);
$tableau[trim($cle)] = trim($val);
}
}
}
return $tableau;
}
}
?>
/tags/v5.2-alpage/services/modules/0.1/chorodep/cartes/LegendeCartes.php
New file
0,0 → 1,112
<?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 PRESENCE_CHOROLOGIE = '1';
 
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::PRESENCE_CHOROLOGIE) {
$this->legende[] = array(
'code' => $ontologie['code'],
'couleur' => $ontologie['legende'],
'nom' => $ontologie['nom'],
'description' => $ontologie['description']);
}
}
}
}
?>
/tags/v5.2-alpage/services/modules/0.1/chorodep/Observations.php
New file
0,0 → 1,710
<?php
/**
* Description :
* Classe Observations.php permettant de fournir des informations sur les observations.
* Si l'url finit par /observations on retourne une liste d'observations (seulement les 100 premières par défaut) :
* espèce, lieu, date, observateur.
* 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.type (type d'observation : chorologie),
* masque.date_observation (date d'observation), masque.station (département), masque.determination (nom scientifique de l'espèce)
* masque.observateur (prénom, nom), masque.nn (identifiant du nom), 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 Observations extends Commun {
protected $serviceNom = 'observations';
/** Stockage des paramétres */
protected $table_param = array();
/** 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 = 'stricte';
/** Valeur du paramètre de requete distinct (=0|1)
* Indique que l'on veut les noms distincts (par défaut tous les noms, même semblable, sont renvoyés) */
protected $distinct = null;
protected $retour_format = 'max';
protected $presenceChorologie = '';
/** Variables constituant les parametres de la requete SQL (champ, condition, group by, limit) remplie
* selon ressources et paramètres */
protected $requete_champ = ' id, num_nom, nom_sci ';
protected $requete_condition = array();
/** Une observation est défini par départ qui correspont à un num_nom et dept qui correspond à un departement */
protected $limite_requete = array(
'depart' => 0,
'dept' => 01,
'limite' => 20
);
/**
* 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
* Est remplit au cours de l'analyse des ressources (traiterRessources()).
* Est utilisée principalement pr déterminer le format du tableau à retourner.
*/
protected $format_reponse = 'observations';
 
// +-------------------------------------------------------------------------------------------------------------------+
public function consulter($ressources, $parametres) {
$this->parametres = $parametres;
$this->traiterVersionProjet($ressources);
$this->traiterRessources($ressources);
$resultat_formate = '';
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->traiterParametres($parametres);
$requete = $this->assemblerLaRequete(); //print_r($requete);
$resultat = $this->getBdd()->recupererTous($requete);
$res_version = $this->testerResultat($resultat, $requete);
}
if ($this->corps_http == '' && $this->entete_http == '') {
if (isset($res_version)) {
$resultat_formate = $res_version;
}
}
}
return $resultat_formate;
}
public function testerResultat($resultat, $requete) {
if ($resultat == '') { //cas ou la requete comporte des erreurs
$s = 'La requête SQL resultat formée comporte une erreur !!';
Debug::printr($requete);
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $s);
} elseif ($resultat) {
if (count($this->table_version) > 1) {
$res_version[$version] = $this->retournerResultatFormate($resultat);
} else {
$res_version = $this->retournerResultatFormate($resultat);
}
} else {
if ($this->format_reponse == 'zone-geo/id/relations') {
//si aucune relations n'existe, la valeur null est retournée
$res_version = null;
} else {
$d = 'Données recherchées introuvables dans la base'.$requete;
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $d);
Debug::printr($requete);
}
}
return $res_version;
}
public function assemblerLaRequete() {
$requete = "SELECT ".$this->formerRequeteChamp().
" FROM ".$this->table.$this->formerRequeteCondition().
' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];//echo $requete;
return $requete;
}
public function formerRequeteChamp() {
if (!isset($this->table_ressources)) {
if (!isset($this->table_param['masque_station']) && !isset($this->table_param['masque_contributeur']) ) {
$champ = ' * ';
} else {
$champ = $this->requete_champ;
}
} else {
$champ = $this->requete_champ;
}
return $champ;
}
public function formerRequeteCondition() {
$condition = '';
if ($this->requete_condition != null) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
// +-------------------------------------------------------------------------------------------------------------------+
public function traiterRessources(&$ressources) {
if (isset($ressources) && !empty($ressources)) {
$this->table_ressources = $ressources;
if (isset($this->table_ressources[0]) && !empty($this->table_ressources[0])) {
$this->traiterRessourceId();
if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) {
$this->traiterRessourceChamp;
}
}
}
}
public function traiterRessourceId() {
//requete : /observations/#num_nom:#dept (ex : /observations/10:34)
if (preg_match('/^([0-9]*):([0-9]{2})$/', $this->table_ressources[0], $conditions)) {
$this->requete_condition[] = ' num_nom = '.$this->getBdd()->proteger($conditions[1]).' AND `'.$conditions[2]."` != '' ";
$this->requete_champ .= ' ,catminat, rang, num_tax, freq_abs, freq_rel, rare_nat, `'.$conditions[2].'`';
$this->format_reponse .= '/id';
//requete : /observations/nom:#dept (ex : /observations/coquelicot:30)
} elseif (preg_match('/^(.*):([0-9]{2})$/', $this->table_ressources[0], $conditions)) {
$this->requete_condition[] = ' nom_sci like '.$this->getBdd()->proteger($conditions[1].'%').' AND `'.$conditions[2]."` != '' ";
$this->requete_champ .= ' ,catminat, rang, num_tax, freq_abs, freq_rel, rare_nat, `'.$conditions[2].'`';
$this->format_reponse .= '/id';
//requete : /observations/num_nom:#num_nom (ex : /observations/num_nom:290) ??
} elseif (strrpos($this->table_ressources[0], ':') !== false) {
} 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 traiterParametres($parametres) {
if (isset($parametres) && !empty($parametres)) {
$this->table_param = $parametres;
if (isset($parametres['recherche']) && $parametres['recherche'] != '') {
$this->recherche = $parametres['recherche'];
}
foreach ($parametres as $param => $valeur) {
switch ($param) {
case 'masque' : $this->ajouterLeFiltreMasque($valeur); break;
case 'masque.date.observation' : break;
case 'masque.station' : $this->limite_requete['dept'] = $valeur;
$this->ajouterUnFiltre('station', $valeur); break;
case 'masque.departement' :
$this->ajouterUnFiltre("`".$valeur."`", '1'); break;
case 'masque.determination' : $this->ajouterUnFiltre('nom_sci', $valeur); break;
case 'masque.determination.nn' :
$this->requete_condition[] = '`num_nom` = '.$this->getBdd()->proteger($valeur); break;
case 'masque.determination.nt' :
$this->requete_condition[] = '`num_tax` = '.$this->getBdd()->proteger($valeur); break; case 'masque.observateur' : $this->ajouterLeFiltreContributeur($valeur); break;
case 'masque.valeur' : $this->presenceChorologie = $valeur; break;
case 'retour.format' : $this->retour_format = $valeur; break;
case 'navigation.depart' : $this->ajouterLimiteDepart($valeur); break;
case 'navigation.limite' : $this->limite_requete['limite'] = $valeur; break;
case 'recherche' : break;
case 'version.projet' : break;
default : $p = 'Erreur dans les paramètres de recherche de votre requête : '.
'</br> Le paramètre " '.$param.' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $p); break;
}
}
}
}
/** 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 ajouterUnFiltre($nom_champ, $valeur) {
if ($nom_champ == 'station') {
if (!preg_match('/^\s*([0-9]{2})\s*$/', $valeur, $colonne)) { // si le nom est passé
$this->requete_condition[] = '1';
/* $url = $this->ajouterHrefAutreProjet('zone-geo',$key,'INSEE-D');// d'apres nom
$dept = $this->rest_client->consulter($url);
$entete = $this->rest_client->getReponseEntetes();
if (isset($entete['wrapper_data'])) {
$colonne = json_decode($relation);
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Le service '.$this->service.' de ce projet comporte des erreurs. url lancée : '.$url);
}*/
} else {
$this->requete_condition[] = '`'.$valeur."` != '' ";
$this->requete_champ .= ', `'.$valeur.'` ';
}
} else {
// recherche floue
if ($this->recherche == 'floue') {//ajout_soundex
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ';
// recherche étendue
} elseif ($this->recherche == 'etendue') {
$valeur = str_replace(' ','%', $valeur);
$valeur .= '%';
}
// recherche stricte
$this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur);
}
}
/** fonction d'ajout dans la requete SQL des conditions (WHERE ...) quand le paramètre passé est masque
* @param $valeur
*/
public function ajouterLeFiltreMasque($valeur) {
$this->ajouterUnfiltre('station', $valeur);
$condition = '(( '.array_pop($this->requete_condition);
$this->ajouterUnfiltre('num_nom', $valeur);
$condition .= ' ) OR ('.array_pop($this->requete_condition);
$condition = str_replace('( 1 ) OR', '', $condition); // si la valeur passée est une varchar supprime le filtre station
$this->ajouterUnfiltre('nom_sci', $valeur);
$this->requete_condition[] = $condition.' ) OR ('.array_pop($this->requete_condition).' )) ';
}
/** fonction d'ajout dans la requete SQL des conditions (WHERE ...) quand le paramètre passé est masque.contributeur
* @param $valeur
*/
public function ajouterLeFiltreContributeur($valeur) {
$requete_contr = $this->creerRequeteContributeur($valeur);
$res = $this->getBdd()->recupererTous($requete_contr);
if ($res == '') { //cas ou la requete comporte des erreurs
$c = 'La requête SQL formée comporte une erreur !!';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $c);
Debug::printr($requete_contr);
} elseif ($res) {
unset($res[0]['id'],$res[0]['nom'],$res[0]['prenom'],$res[0]['courriel']);
// si il y a un masque station et que le contributeur n'a pas de données dans ce dept
if (isset($this->table_param['masque_station']) && isset($res[0][$this->table_param['masque_station']])) {
if ($res[0][$this->table_param['masque_station']] != 1) {
$d = "Les données recherchées sont introuvables pour l'observateur ".$valeur." dans le département "
.$this->table_param['masque_station'];
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $d);
}
} else {
foreach ($res[0] as $dept=>$presence) {
if ($presence == 1) {
$this->ajouterUnfiltre('station', $dept);
$requete_condition[] = array_pop($this->requete_condition); // recupere le filtre créé précédement
}
}
$this->requete_condition[] = '(( '.implode(' ) OR ( ', $requete_condition).' ))'; // créé un filtre sur les dept
}
} else {
$i = "Les données recherchées sont introuvables pour l'observateur ".$valeur;
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $i);
}
}
public function creerRequeteContributeur($valeur) {
$condition = '';
if (preg_match('/(.*@[a-z]+\.[a-z]{2,3})/', $valeur, $match)) {// cherche sur le mail
$condition = 'courriel = '.$this->getBdd()->proteger($match[1]);
} elseif (preg_match('/^(\w+)\s+(\w+)$/', $valeur, $match)) {// cherche sur les nom prenom
$condition = ' ((nom = '.$this->getBdd()->proteger($match[1]).' OR prenom = '.$this->getBdd()->proteger($match[1]).
' ) AND (nom = '.$this->getBdd()->proteger($match[2]).' OR prenom = '.$this->getBdd()->proteger($match[2]).'))'.
' OR ( nom LIKE '.$this->getBdd()->proteger($valeur.'%').')';
} else {// cherche si nom association
$condition = 'nom LIKE '.$this->getBdd()->proteger($valeur.'%');
}
list($table, $version) = explode('_v',$this->table);
$requete_contr = "SELECT * FROM chorodep_contributeurs_v$version WHERE ".$condition;
}
public function ajouterLimiteDepart($id) {
$d = explode(":", $id);
$this->limite_requete['depart'] = 0;
$this->limite_requete['dept'] = $d[1];
if (!isset($this->parametres['masque.determination.nn'])) {
$requete_condition = (is_numeric($d[0])) ? '`num_nom` = '.$d[0] : '`nom_sci` like "'.urldecode($d[0]).'%"';
$requete = "SELECT id FROM $this->table WHERE ".$requete_condition;
$res = $this->getBdd()->recuperer($requete);
if ($res == '') { //cas ou la requete comporte des erreurs
$r = 'La requête SQL formée comporte une erreur !!';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r);
Debug::printr($requete);
} elseif ($res) {
$this->limite_requete['depart'] = $res['id'] - 1;
} else {
$i = "Les données recherchées sont introuvables";
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $i);
}
}
}
// +-------------------------------------------------------------------------------------------------------------------+
public function retournerResultatFormate($resultat) {
$this->table_retour = array(); // stocke les données générales d'une observation et écrase les données d'un dep
$this->chargerInfosGenerales();
switch ($this->format_reponse) {
case 'observations' : $reponse = $this->formaterObservations($resultat); break;
case 'observations/id' : $reponse = $this->formaterObservationsId($resultat[0]); break;
case 'observations/id/champ': $reponse = $this->formaterObservationsIdChamp($resultat[0]); break;
default : break;
}
return $reponse;
}
public function formaterObservations($resultat) {
$num = 0; // compte le nombre d'observations pour retourner le nombre d'obs indiqué
$depart = false; //le depart du resultat est noté ss forme #ligne:#departement $depart indique le departement est correct
//on remplit la table $table_retour_json['resultat']
$this->table_retour = array();
foreach ($resultat as $tab) {
foreach ($tab as $key => $valeur) {
switch ($key) {
case 'id' : break;
case 'catminat' : break;
case 'rang' : break;
case 'num_tax' : break;
case 'freq_abs' : break;
case 'freq_rel' : break;
case 'rare_nat' : break;
case 'num_nom' : ($valeur == 'nc')? $num_nom = urlencode($tab['nom_sci']) : $num_nom = $valeur ; break;
case 'nom_sci' : $this->table_retour['determination.nom_sci'] = $valeur; break;
default : // pour les depts
if (isset($this->parametres['masque.station'])) {
if ($key == $this->parametres['masque.station']) {
$id = $num_nom.":".$key;
$this->completerDonnees($key, $valeur, $id);
$resultat_json[$id] = $this->table_retour;
$num++;
}
} else {
if ($depart == true && $valeur != '') {
if (($this->presenceChorologie != '' && $valeur == $this->presenceChorologie) ||
($this->presenceChorologie == '' && $valeur != $this->presenceChorologie)) {
$id = $num_nom.":".$key;
$this->completerDonnees($key, $valeur, $id);
$resultat_json[$id] = $this->table_retour;
$num++;
}
}
if ($key == $this->limite_requete['dept']) $depart = true;
}
break;
}
if ($num == $this->limite_requete['limite']) {
break;
}
}
if ($num == $this->limite_requete['limite']) {
break;
}
$this->table_retour = array();
}
//on remplit la table $table_retour_json['entete']
//formuler les urls precedentes et suivantes affichées dans l'entete du resultat
$url = $this->formulerUrlObs($id, $num, '/observations');
if ($url['precedent'] != '') { $this->table_entete['href.precedent'] = $url['precedent']; }
if ($url['suivant'] != '') { $this->table_entete['href.suivant'] = $url['suivant']; }
$this->table_entete['total'] = $num;
$table_retour_json['entete'] = $this->table_entete;
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
public function completerDonnees($key, $valeur, $id) {
if ($this->retour_format == 'max' ) {
$this->afficherDonneesMax($key, $valeur);
$this->table_retour['href'] = $this->ajouterHref('observations',$id);
} else {
$this->table_retour['station.departement.code'] = 'INSEE-D.'.$key;
$this->table_retour['valeur.code'] = $valeur;
}
}
public function formaterObservationsId($resultat) {
foreach ($resultat as $key => $valeur) {
switch ($key) {
case 'id' : break;
case 'catminat' : if ($this->retour_format == 'max') $this->table_retour['determination.catminat'] = $valeur; break;
case 'rang' : $this->table_retour['determination.rang'] = $valeur; break;
case 'num_tax' : $this->table_retour['determination.num_tax'] = $valeur; break;
case 'freq_abs' : break;
case 'freq_rel' : break;
case 'rare_nat' : $this->table_retour['determination.rarete_nationale.code'] = $valeur; break;
case 'nom_sci' : $this->table_retour['determination.nom_sci'] = $valeur; break;
case 'num_nom' : $this->table_retour['determination.num_nom'] = $valeur; break;
default : if ($this->retour_format == 'max') {
$this->afficherDonneesMax($key, $valeur, true);
} else {
$this->table_retour['station.departement.code'] = 'INSEE-D.'.$key;
$this->table_retour['valeur.code'] = $valeur;
} break;
}
}
return $this->table_retour;
}
public function afficherDonneesMax($key, $valeur, $id = false) {
if ($key != 20) { //à part la Corse
$url_dep = $this->ajouterHrefAutreProjet('zone-geo','',$key, 'insee-d');
$dep = $this->consulterHref($url_dep);
if (isset($dep)) {
$this->table_retour['station.departement'] = $dep->nom;
$this->table_retour['station.departement.code'] = 'INSEE-D.'.$key;
$this->table_retour['station.departement.href'] = $url_dep;
} else {
$this->table_retour['station.departement.code'] = 'INSEE-D.'.$key;
}
} else {
$this->table_retour['station.departement.code'] = 'INSEE-D.'.$key;
}
//double encodage des paramétres contre validation de Apache
$url_val = $this->ajouterHref('ontologies', 'presenceChorologie:'.urlencode(urlencode($valeur)));
$val = $this->consulterHref($url_val);
$this->table_retour['valeur'] = $val->nom;
$this->table_retour['valeur.code'] = $valeur;
$this->table_retour['valeur.href'] = $url_val;
if ($this->format_reponse == 'observations/id') { // si on est
$contr = $this->chargerContributeurs($key);
if (isset($contr['general'])) {
$this->table_retour['contributeur'] = $contr['general'];
$this->table_retour['contributeur.details'] = $contr['details'];
}
$source = $this->chargerSources($key);
if (isset($source['general'])) $this->table_retour['sources'] = $source['general'];
if (isset($source['autres'])) $this->table_retour['sources.autres'] = $source['autres'];
}
}
public function chargerInfosGenerales() {
list($table, $version) = explode('_v',$this->table);
$version = str_replace('_', '.', $version);
$requete = "SELECT createurs, date_creation FROM chorodep_meta WHERE version = \"$version\";";
$resultat = $this->getBdd()->recuperer($requete); //Debug::printr($resultat);
if ($resultat == '') { //cas ou la requete comporte des erreurs
$r = 'La requête SQL metadonnees formée comporte une erreur !!';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r);
Debug::printr($requete);
} elseif ($resultat) {
$this->table_retour['type'] = 'chorologie';
$this->table_retour['date_observation'] = $resultat['date_creation'];
$this->table_retour['observateur.details'] = $this->traiterChampFormateDCSV($resultat['createurs']);
}
}
public function chargerContributeurs($dept) {
$contributeur = array();
list($table, $version) = explode('_v',$this->table);
$requete = "SELECT prenom, nom, courriel FROM chorodep_contributeurs WHERE `$dept` = '1';";
$resultat = $this->getBdd()->recupererTous($requete); //Debug::printr($resultat);
if ($resultat == '') { //cas ou la requete comporte des erreurs
$r = 'La requête SQL contributeurs formée comporte une erreur !!';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r);
Debug::printr($requete);
} elseif ($resultat) {
$contributeur['general'] = '';
foreach ($resultat as $res) {
$contributeur['general'] .= $res['prenom'].' '.$res['nom'].', ';
foreach ($res as $cle => $valeur) {
if ($valeur == "") {
unset($res[$cle]);
}
}
$type = ($res['prenom'] == '') ? 'o' : 'p';
$url = $this->ajouterHrefAutreProjet('ontologies', 'contactType:', $type, 'eflore');
$val = $this->consulterHref($url);
$res['type'] = $val->nom;
$res['type.code'] = $type;
$res['type.href'] = $url;
$contributeur['details'][] = $res;
}
}
return $contributeur;
}
// prend en paramètre un champ comme createur, contributeur... sous forme p.prenom=ygggg,p.nom=fk;p.prenom=fdfs,p.nom=ek
//retourne un tableau
public function creerPointDetails($resultat) {
$organismes = explode(';', $resultat);
$num_org = 1;
$general = '';
foreach ($organismes as $organisme) {
$infos = explode(',', $organisme);
$t = '';
$type = '.';
foreach ($infos as $info) {
list($key, $val) = explode('=', $info);
list($type, $champ) = explode('.', trim($key));
if ($type == 'p' && $champ == 'prenom') $general .= $val.' ';
if (($type == 'p' || $type == 'o') && $champ == 'nom') $general .= $val.' ';
$res[$num_org][$champ] = $val;
$res[$num_org]['type'] = $type;// à modifier
}
$general = rtrim($general).', ';
$num_org ++;
}
$this->table_retour['observateur'] = rtrim($general, ', ');
$this->table_retour['observateur.details'] = $res;
}
/**
* Recupère à partir de la valeur du champ les différentes informations séparées par ';' (stocke ds un tableau)
* pour éditeurs, créateurs, contributeurs,...
* (ex : nom=Tela Botanica,guid=urn:lsid:tela-botanica.org,courriel=accueil@tela-botanica.org,...
*/
public function traiterChampFormateDCSV($val) {
$tab = array();
$num_entite = 0;
$type = '';
// découpe chaque participant
$tab_entites = explode(';', $val);
foreach ($tab_entites as $entite) {
$tab[$num_entite] = array();
if ($entite != '') {
// découpe les informations du participant
$entite_detail = explode(',', $entite);
foreach ($entite_detail as $detail) {
if ($detail != '') {
if (preg_match('/^([^=]*)\.([^=]+)=([^=]*)$/', $detail, $match)) {
$tab[$num_entite][$match[2]] = $match[3];
if ($match[1] != $type) $type = $match[1];
} else {
$tab[$num_entite][] = $detail;
}
}
}
if ($type != '') {
if ($this->retour_format == 'max') {
}
}
}
$num_entite++;
}
return $tab;
}
public function chargerSources($dept) {
$contributeur = array();
$requete = "SELECT biblio FROM chorodep_sources WHERE `$dept` = '1';";
$resultat = $this->getBdd()->recupererTous($requete); //Debug::printr($resultat);
if ($resultat == '') { //cas ou la requete comporte des erreurs
$r = 'La requête SQL sources formée comporte une erreur !!';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r);
Debug::printr($requete);
} elseif ($resultat) {
foreach ($resultat as $cle=>$res) {
if ($cle == 0) {
$contributeur['general'] = $res['biblio'];
} else {
$contributeur['autres'][] = $res['biblio'];
}
}
}
return $contributeur;
}
/* public function formaterObservationsIdChamp($resultat) {
//on recupère tous les resultats possibles
$reponse = $this->formaterObservationsId($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['id'];
$champs = explode(' ', $this->table_ressources[1]);
foreach ($champs as $champ) {
if ($this->verifierValiditeChamp($champ, $reponse)) {
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;
}*/
// +-------------------------------------------------------------------------------------------------------------------+
/**
* Description :
* Est appelée pour former l'url complete des resultats precedants ou suivants.
* @param int : Permet de connaitre le nombre de noms obtenus par la requete
* @return string Retourne l'url complete des resultats precedents ou suivant sous la forme d'un tableau
*/
public function formulerUrlObs($suivant, $total, $id = null) {
$debut_url = Config::get('url_service').$id.'?';
//on recrée l'url sans les parametres de navigation qui seront rajouter ci-apres. On les enlève dc de la table des parametres
$table_bis = $this->table_param;
if (isset($table_bis['navigation.depart'] )) {
unset($table_bis['navigation.depart']);
}
if (isset($table_bis['navigation.limite'])) {
unset($table_bis['navigation.limite']);
}
$parametre_url = http_build_query($table_bis);
//on recupere les limites
$url['suivant'] = $this->recupererLesLimitesSuivantesObs($suivant, $total);
$url['precedent'] = $this->recupererLesLimitesPrecedentesObs($suivant);
//on reconstitue les deux urls avec leurs limites
foreach ($url as $key => $limite) {
if ($limite != '') {
if ($parametre_url == '') {
//si il n'y a aucun parametres, seules les limites sont à ajouter.On enleve dc le signe & du début
$limite = str_replace('&navigation.depart=', 'navigation.depart=', $limite);
if (strpos($limite, 'navigation.depart') === false) {
$limite = str_replace('&navigation.limite=', 'navigation.limite=', $limite);
}
}
$url_complete = $debut_url.$parametre_url.$limite;
$url[$key] = $url_complete;
}
}
return $url;
}
/**
* Description :
* Permet de former les limites de la requete retournant les résultats suivants.
* Cette url sera afficher dans l'entete de la reponse retournée en format JSON (retour.format=defaut).
* @param int : $nb_resultat : Permet de connaitre le nombre de résultats obtenus par la requete
* @return string : la fin de l'url decrivant les limites des resultats suivants. Si aucun résultats ne suient,
* une chaine de caractère vide est retournée
*/
public function recupererLesLimitesSuivantesObs($suivant, $total) {
if ($this->limite_requete['limite'] <= $total) {
$url_suivante = '&navigation.depart='.$suivant.'&navigation.limite='.$this->limite_requete['limite'];
} else {
$url_suivante = '';
}
return $url_suivante;
}
/**
* Description :
* Permet de former les limites de la requete retournant les résultats precedents.
* Cette url sera afficher dans l'entete de la taxons/105reponse retournée en format JSON (retour.format=defaut)
* @return string : la fin de l'url decrivant les limites des resultats precedents.
* Si aucun résultats ne precedent, une chaine de caractère vide est retournée
*/
public function recupererLesLimitesPrecedentesObs($suivant) {
$url_precedente = '';
if (isset($this->table_param['navigation_depart'])) { // si on utilise un parametre de départ
// si l'adresse d'appel de la page est inférieur au départ
$regex = '/http:\/\/.*\/service:eflore:0.1\/chorodep\/observations\?.*navigation.depart=(.*\:[0-9]*).*/';
if (isset($_SERVER['HTTP_REFERER']) && preg_match($regex, $_SERVER['HTTP_REFERER'], $match)) {
if ($match[1] != $this->table_param['navigation_depart'] && $match[1] != $suivant) {
$url_precedente = '&navigation.depart='.$match[1].'&navigation.limite='.$this->limite_requete['limite'];
}
} else {
$url_precedente = '&navigation.limite='.$this->limite_requete['limite'];
}
}
return $url_precedente;
}
 
}
?>