Subversion Repositories eFlore/Projets.eflore-projets

Compare Revisions

No changes between revisions

Ignore whitespace Rev 849 → Rev 850

/tags/v0.1-20130830-1/initialiserBdd.sh
New file
0,0 → 1,91
#!/bin/bash
##############################################################################################################
# But : Script permettant d'initialiser en une seule commande l'ensemble de la base de données eFlore.
# Auteur : Jean-Pascal Milcent <jpm@tela-botanica.org> (translate bat file to shell script)
# Exemple : /opt/lampp/bin/php -d memory_limit=3500M ./cli.php bdtxa -a supprimerTous
# License : GPL v3
# Création : 07 decembre 2011
# Version: 0.1
# 2011-12-07 - Création
# $Id$
##############################################################################################################
# Constante
APPDIR_ABSOLU=`pwd`;
#
CHEMIN_PHP="/opt/lampp/bin"
CHEMIN_TBF_CLI="$APPDIR_ABSOLU/scripts"
MEMORY_LIMIT="3500M"
echo -e "\033[31m`tput blink`ATTENTION :`tput sgr0` Nécessite la création préalable de la base de données \033[31mtb_eflore\033[00m"
echo "Nettoyage et chargement en cours...";
# BASEFLORE : doit être placé apèrs BDTFX (dépendance !)
echo "BASEVEG :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php baseveg -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php baseveg -a chargerTous
echo "BDNT :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php bdnt -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php bdnt -a chargerTous
echo "BDTFX :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php bdtfx -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php bdtfx -a chargerTous
echo "BASEFLOR :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php baseflor -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php baseflor -a chargerTous
echo "BDTXA :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php bdtxa -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php bdtxa -a chargerTous
echo "BIBLIO_BOTA :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php biblio_bota -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php biblio_bota -a chargerTous
# echo "BONNIER :";
# Pas encore utilisé !
echo "CHORODEP :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php chorodep -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php chorodep -a chargerTous
echo "COSTE :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php coste -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php coste -a chargerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php coste -a chargerTxt
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php coste -a chargerIndex
echo "EFLORE :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php eflore -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php eflore -a chargerTous
# echo "FOURNIER :";
# Pas encore utilisé !
echo "INSEE-D :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php insee_d -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php insee_d -a chargerTous
echo "ISO-3166-1 :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php iso_3166_1 -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php iso_3166_1 -a chargerTous
echo "ISO-639-1 :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php iso_639_1 -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php iso_639_1 -a chargerTous
echo "NVJFL :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php nvjfl -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php nvjfl -a chargerTous
echo "NVPS :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php nvps -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php nvps -a chargerTous
echo "NVA :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php nva -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php nva -a chargerTous
echo "PHOTOFLORA :";
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php photoflora -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php photoflora -a chargerTous
# echo "PROMETHEUS :";
# Ontologie botanique.
# Pas encore utilisé !
echo "SPTB :";
# Statut de protection Tela Botanica
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php sptb -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php sptb -a chargerTous
echo "CEL :";
echo -e "\033[31m`tput blink`ATTENTION :`tput sgr0` Nécessite la création préalable de la base de données \033[31mtb_cel\033[00m"
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php cel -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php cel -a chargerTous
echo "TAPIRLINK :";
echo -e "\033[31m`tput blink`ATTENTION :`tput sgr0` Nécessite la création préalable de la base de données \033[31mtb_hit_indexation\033[00m"
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php tapirlink -a supprimerTous
$CHEMIN_PHP/php -d memory_limit=$MEMORY_LIMIT $CHEMIN_TBF_CLI/cli.php tapirlink -a chargerTous
 
 
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
Added: svn:executable
+*
\ No newline at end of property
/tags/v0.1-20130830-1/livraison.sh
New file
0,0 → 1,21
#!/bin/bash
##############################################################################################################
# But : Script permettant d'initialiser en une seule commande l'ensemble de la base de données eFlore.
# Auteur : Jean-Pascal Milcent <jpm@tela-botanica.org> (translate bat file to shell script)
# License : GPL v3
# Création : 07 decembre 2011
# Version: 0.1
# 2011-12-07 - Création
# $Id$
##############################################################################################################
 
# ATTENTION NE PAS UTILISER !!!
 
# compresser les services en excluant les fichiers svn et les fichiers de config et framework
#tar cvzf services.tar.gz services/ --exclude=".svn" --exclude="*.ini" --exclude="framework.php" --exclude="*.sh"
# envoyer sur tela
#scp services.tar.gz root@tela-botanica.org:/home/telabotap/www/eflore-test/.
 
# se connecter sur tela botanica en ssh et effectuer le déploiement
#ssh root@tela-botanica.org "cd /home/telabotap/www/eflore-test/; cd services; tar cvzf ../backup/services.tar.gz .; cd ../; rm -Rf services; tar xvzf services.tar.gz; cd services; cp ../configurations/services/* . -R; chown #telabotap:users /home/telabotap/www/eflore-test/services -R; chmod 755 /home/telabotap/www/eflore-test/services -R; exit";
#echo "Done !"
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
Added: svn:executable
+*
\ No newline at end of property
/tags/v0.1-20130830-1/chargerDonnees.sh
New file
0,0 → 1,50
#!/bin/bash
##############################################################################################################
# But : téléchargement automatique en local des données des projets depuis le serveur de Tela Botanica par ftp
# Auteur : Jean-Pascal Milcent <jpm@tela-botanica.org> (translate bat file to shell script)
# License : GPL v3
# Création : 07 decembre 2011
# Version: 0.1
# 2011-12-07 - Création
# $Id$
##############################################################################################################
# Constante
NBREPARAM=$#
APPDIR_ABSOLU=`pwd`;
DOSSIER_LOCAL="$APPDIR_ABSOLU/donnees/"
DOSSIER_DISTANT="/www/eflore/donnees/"
# Aide
E_OPTERR=65
if [ "$1" = '--help' ]
then # Le script a besoin d'au moins un argument sur la ligne de commande
echo "Usage $0 -[parameters -u, -p ]"
echo "Paramétres : "
echo " -h: indiquer l'hote ftp"
echo " -u: indiquer le nom de l'utilisateur ftp"
echo " -p: indiquer le mot de passe de l'utilisateur ftp"
exit $E_OPTERR
fi
 
# Récupération des paramètres et des options de la ligne de commande
TEMP=`getopt -o u:p:h: -l help: -- "$@"`
if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
eval set -- "$TEMP"
while [ ! -z "$1" ] ; do
#echo $1" # "$2
case "$1" in
-h) HOST=$2;;
-u) FTP_USER=$2;;
-p) FTP_PASSWD=$2;;
--) shift ; break ;;
*) echo "Internal error!" ; exit 1 ;;
esac
shift 2
done
 
# Transfert sur le serveur par FTP
if [ $NBREPARAM -eq 0 ]; then
echo "Pas de transfert sur le serveur. Utiliser --help pour voir les options de transfert."
else
echo "Téléchargement en cours :";
lftp ftp://$FTP_USER:$FTP_PASSWD@$HOST -e "set ftp:passive off; mirror -e --no-symlinks -x '.*cel\/images\/.*' -x '.*osm\/.*' -x '.*plantscan\/.*' -x '.*coste\/cles\/.*' -x '.*coste\/descriptions\/.*' -x '.*coste\/images\/.*' -x '.*coste\/ressources\/.*' $DOSSIER_DISTANT $DOSSIER_LOCAL ; quit"
fi;
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
Added: svn:executable
+*
\ No newline at end of property
/tags/v0.1-20130830-1/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/v0.1-20130830-1/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/v0.1-20130830-1/services/modules/0.1/baseveg/syntaxons/SyntaxonsCommun.php
New file
0,0 → 1,205
<?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)
*/
 
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 = '';
protected $total_resultat;
protected $champs_recherches = ' * ';
protected $table_version;
protected $version_projet = '+' ;
public function __construct(Conteneur $conteneur) {
$this->Bdd = $conteneur->getBdd();
$this->syn = $this->getParametreTableauSpe('synonymes');
$this->niv = $this->getParametreTableauSpe('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));
$val = $this->consulterHref($url);
$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 ($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.' '
.$this->retournerRequeteCondition().' '.$this->delimiterResultatsRequete();
return $requete;
}
protected function calculerTotalResultat() {
$requete = 'SELECT count(*) as nombre FROM '.$this->table.' '.$this->retournerRequeteCondition();
$res = $this->getBdd()->recuperer($requete);
if ($res) {
$this->total_resultat = $res['nombre'];
} else {
$this->total_resultat = 0;
$e = 'Données introuvables dans la base';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
}
}
protected function delimiterResultatsRequete() {
$this->calculerTotalResultat();
$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;
}
protected function retournerRequeteCondition() {
$condition = '';
if (empty($this->requete_condition) == false) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
}
?>
/tags/v0.1-20130830-1/services/modules/0.1/baseveg/syntaxons/SyntaxonsRelationsToutes.php
New file
0,0 → 1,87
<?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();
$versionResultat = $this->traiterResultat($resultat);
$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/v0.1-20130830-1/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/v0.1-20130830-1/services/modules/0.1/baseveg/syntaxons/SyntaxonsTous.php
New file
0,0 → 1,149
<?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);
$versionResultat = $this->traiterResultat($resultat);
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/v0.1-20130830-1/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/v0.1-20130830-1/services/modules/0.1/baseveg/Ontologies.php
New file
0,0 → 1,347
<?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) {
$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/v0.1-20130830-1/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/v0.1-20130830-1/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/v0.1-20130830-1/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/v0.1-20130830-1/services/modules/0.1/eflore/cartes/LegendeCartes.php
New file
0,0 → 1,123
<?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']] = $this->extraireComplementsOntologies($ontologie);
}
}
 
private function extraireComplementsOntologies($ontologie) {
if ($ontologie['complements'] != '') {
$complements = explode(',', trim($ontologie['complements']));
foreach ($complements as $complement) {
list($cle, $val) = explode('=', trim($complement));
$ontologie[trim($cle)] = trim($val);
}
}
return $ontologie;
}
 
private function chargerLegende() {
foreach ($this->ontologies as $ontologie) {
if ($ontologie['classe_id'] == self::LEGENDE) {
$this->legende[] = array(
'code' => $ontologie['code'],
'couleur' => $ontologie['legende'],
'nom' => $ontologie['nom'],
'description' => $ontologie['description']);
}
}
}
}
?>
/tags/v0.1-20130830-1/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/v0.1-20130830-1/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/v0.1-20130830-1/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/v0.1-20130830-1/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/v0.1-20130830-1/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/v0.1-20130830-1/services/modules/0.1/Projets.php
New file
0,0 → 1,328
<?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);
}
$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';
}
}
 
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;
}
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 = "La service demandé '$service' n'est pas disponible pour le projet {$this->projetNom} !\n".
"Les services disponibles sont : ".implode(', ', $servicesDispo);
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
} 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);
}
$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();
$this->cache = new CacheEflore($service, $this->projetNom, $this->serviceNom, Config::get('cache'));
return $this->cache->consulter($ressourcesPourService, $this->parametres);
}
}
if (is_null($service)) {
$message = "La service demandé '{$this->serviceNom}' n'existe pas dans le projet {$this->projetNom} !";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
return 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/v0.1-20130830-1/services/modules/0.1/coste/A_LIRE.txt
New file
0,0 → 1,6
 
!!!Attention à vérifier dans le config.ini de eflore-consultation que cette ligne existe bien avec le paramètre
num_taxonomique : ( utile pour le web service Images )!!!
 
nomsRechercheDeterminationTpl = "{ref:nomsTpl}?masque={valeur}&recherche={type}
&ns.format=txt&retour.champs=nom_retenu,nom_retenu.*,num_taxonomique&navigation.limite=3000"
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
Added: svn:executable
+*
\ No newline at end of property
/tags/v0.1-20130830-1/services/modules/0.1/coste/Images.php
New file
0,0 → 1,222
<?php
 
/**
* classe pour web service qui affiche les images de Coste.
* il n'existe qu'une seule version pour les images de Coste : 2.00
* retour en application/json
*
* exemple d'appel du service :
* .../service:eflore:0.1/coste/images?masque.nt=1053
* .../service:eflore:0.1/coste/images?masque.nn=39594,39601
* .../service:eflore:0.1/coste/images
*
* paramètres disponibles : navigation.depart, navigation.limite, masque.nn, masque.nt
*
* @package eFlore/services
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @author Mathilde Salthun-Lassalle <mathilde@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 1.0
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org)
*/
 
class Images extends Commun {
protected $table ;
private $requete_condition = array(" image != '' ");
private $champs_recherches = " num_nom, image, flore_bdtfx_nn, flore_bdtfx_nt ";
private $total_resultat;
protected $limite_requete = array('depart' => 0, 'limite' => 100);
private $masque = array();
 
public function consulter($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
$this->traiterRessources();
$this->traiterParametres();
$this->table = config::get('bdd_table').'_v2_00';
$requete = $this->assemblerLaRequete();
$resultat = $this->getBdd()->recupererTous($requete);
$resultats = $this->formaterResultat($resultat);
return $resultats;
}
//+-----------------------------------traitement ressources et paramètres --------------------------------+
public function traiterRessources() {
if (empty($this->ressources) ) {
if (isset($this->parametres['masque.nn']) == false
&& isset($this->parametres['masque.nt']) == false) {
$this->requete_condition[] = " flore_bdtfx_nt != '' AND flore_bdtfx_nn != '' ";
}
} else {
$e = "La ressource {$this->ressources[0]} n'existe pas.";
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,$e);
}
}
public function traiterParametres() {
foreach ($this->parametres as $param => $val ) {
switch ($param) {
case 'masque.nt' :
$this->analyserMasque($val,'nt');
break;
case 'masque.nn' :
$this->analyserMasque($val,'nn');
break;
case 'referentiel' :
// ce paramètre est ignoré dans le cas de coste
// car seul le cel le prend en compte pour le moment
// on l'indique ici dans le switch car ce sont les mêmes url
// qui sont appelées pour le cel et coste (à retirer donc si ça change)
break;
case 'navigation.depart' :
$this->limite_requete['depart'] = $val;
break;
case 'navigation.limite' :
$this->limite_requete['limite'] = $val;
break;
default :
$e = 'Erreur dans les paramètres de recherche de votre requête : </br> Le parametre " '
.$param.' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,$e);
break;
}
}
}
 
private function analyserMasque($valeur, $type_masque) {
$this->masque[] = "$type_masque=$valeur";
if (empty($valeur)) {
$e = 'renseignez une valeur pour masque.nn';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,$e);
} elseif (preg_match('/^[0-9]+$/', $valeur)) {
$this->requete_condition[] = " flore_bdtfx_".$type_masque." = $valeur";
} elseif (preg_match('/[0-9]+/', $valeur)){
// suppression des valeurs vides
while(strstr($valeur,',,')) {
$valeur = str_replace(',,',',',$valeur);
}
$condition = " flore_bdtfx_".$type_masque." IN ($valeur) AND flore_bdtfx_".$type_masque." not in (0, '')";
$this->requete_condition[] = $condition;
} else {
$e = "valeur incorrecte pour masque.".$type_masque;
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,$e);
}
}
 
//+-------------------------------------------formatage résultats---------------------------------------------+
 
public function formaterResultat($resultat) {
$versionResultat['entete'] = $this->formaterEnteteResultat();;
if ($resultat == '') {
$message = 'La requête SQL formée comporte une erreur!';
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
} elseif ($resultat) {
$versionResultat = $this->retournerResultatFormate($resultat);
} else {
$versionResultat['resultats'] = array();
}
return $versionResultat;
}
public function retournerResultatFormate($resultat) {
$resultat_json = array();
foreach ($resultat as $tab) {
$num_coste = $tab['num_nom'];
unset($tab['num_nom']);
$resultat_json['resultats'][$num_coste]['num_nomenclatural'] = $tab['flore_bdtfx_nn'];
$resultat_json['resultats'][$num_coste]['num_taxonomique'] = $tab['flore_bdtfx_nt'];
$resultat_json['resultats'][$num_coste]['binaire.href'] = $this->formaterUrlImage($tab['image']);
$resultat_json['resultats'][$num_coste]['mime'] = "images/png";
}
return $resultat_json;
}
public function formaterUrlImage($fichier) {
$chemin = config::get('donnees')."2.00/img/$fichier";
return $chemin;
}
 
public function formaterEnteteResultat() {
$entete['depart'] = $this->limite_requete['depart'];
$entete['limite'] = $this->limite_requete['limite'];
$entete['total'] = $this->total_resultat;
$entete['masque'] = empty($this->masque) ? 'aucun' : implode('&', $this->masque);
$url = $this->formulerUrl($this->total_resultat, '/images');
if (isset($url['precedent']) && $url['precedent'] != '') {
$entete['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$entete['href.suivant'] = $url['suivant'];
}
return $entete;
}
//+--------------------------FONCTIONS D'ASSEMBLAGE DE LA REQUETE-------------------------------------------+
public function assemblerLaRequete() {
$requete = ' SELECT '.$this->champs_recherches.' FROM '.$this->table.' '
.$this->retournerRequeteCondition().' '
.$this->delimiterResultatsRequete();
return $requete;
}
 
public function retournerRequeteCondition() {
$condition = '';
if (empty($this->requete_condition) == false) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
public function calculerTotalResultat() {
$requete = 'SELECT count(*) as nombre FROM '.$this->table.' '
.$this->retournerRequeteCondition();
$res = $this->getBdd()->recuperer($requete);
if ($res) {
$this->total_resultat = $res['nombre'];
} else {
$this->total_resultat = 0;
$e = 'Données introuvables dans la base';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
}
}
public function delimiterResultatsRequete() {
$this->calculerTotalResultat();
$requete_limite = '';
if ((count($this->ressources)) == 0) {
if (($this->limite_requete['depart'] < $this->total_resultat) &&
(($this->limite_requete['limite'] + $this->limite_requete['depart'] )
< $this->total_resultat )) {
$requete_limite = 'LIMIT '.$this->limite_requete['depart'].', '
.$this->limite_requete['limite'];
}
}
return $requete_limite;
}
}
?>
/tags/v0.1-20130830-1/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/v0.1-20130830-1/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/v0.1-20130830-1/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);
} 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']
if (isset($this->table_param['masque'])) $this->afficherDonnees('masque', $this->table_param['masque']);
if (isset($this->table_param['masque_nt'])) $this->afficherDonnees('masque.nt', $this->table_param['masque_nt']);
$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']
$tab_tax_inf = $this->recupererListeTaxonInf($res_version);
foreach ($res_version as $tab) {
$this->resultat_req = $tab;
if (isset($this->table_param['masque_nt'])) $this->afficherDonnees('num_tax', $tab['num_tax']);
foreach ($tab as $key => $val) {
if ($val != '') {
switch ($key) {
case 'num_nom' : $num = $val;
$this->afficherDonnees($key, $val); break;
case 'num_nom_retenu' : $retenu = ($val == $num) ? 'true' : 'false';
$this->table_retour['retenu'] = $retenu; break;
default : break;
}
}
}
$this->afficherTaxonInfNb($num, $tab_tax_inf);
unset($this->table_retour['id']);
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array(); //on vide le tableau table_retour
}
$table_retour_json['resultat'] = $resultat_json;
$res = $this->afficherVersionOuPas($version, $table_retour_json, $res);
}
return $res;
}
//--------------------concerne les resultats pour des requetes de type noms/id----------------------------------------
 
public function formaterIdRelations($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$res = array();
foreach ($resultat as $version => $res_version) {
$this->resultat_req = $res_version;
$retour_id_rel = array ('entete' => array()); //on initialise pr que l'entete apparaisse en premier
//on affiche le resultat
$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;
//on renvoit un tableau null si il n'existe aucune relations
if (!isset($retour_id_rel['resultat'])) {
$retour_id_rel = null;
 
//on rajoute l'entete si des relations existent
} else {
$this->afficherDonnees('num_nom', $this->num_nom_taxon); //$this->afficherEnteteRangBorneTotalUrls($resultat, '/'.$this->service.'/'.$this->table_ressources[0].'/relations/synonymie');
$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;
}
public function ajouterRelations($relation, $version) {
$version = str_replace(Config::get('bdd_table').'_v', '', $version);
$res = null;
$taxon = $this->num_nom_taxon;
$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;
} elseif (isset($relation->$taxon)) { //pour les relations inf et sup
$res = $relation->$taxon;
}
} else {
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,
'Le service '.$this->service.' de ce projet comporte des erreurs. url lancée : '.$url);
}
return $res;
}
 
public function formaterIdSuperieur($resultat) {
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp');
$res = array();
foreach ($resultat as $version => $res_version) {
//on remplit le tableau de formatage
if (($res_version) != '' ) {
//on recupere d'abord les rangs supérieurs
$sup = $res_version[0];
do {
$sup = $this->recupererIdSuperieur($sup['num_tax_sup'], $version);
if ($sup['rang'] == '0') $sup['rang'] = '10'; //erreur dans la base
if (isset($sup)) $res_version[] = $sup;
} while ($sup != null);
krsort($res_version);
//on les affiche ensuite
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, $num); break;
case 'num_nom_retenu' : $retenu = ($val == $num) ? 'true' : 'false';
$this->table_retour['retenu'] = $retenu; break;
case 'rang' : $this->afficherDonnees($key, $val); break;
default : break;
}
}
}
unset($this->table_retour['id']);
$tab_inf[$num] = $this->table_retour;
$this->table_retour = array();
}
$tab_relation[$this->num_nom_taxon] = $tab_inf;
} else { //si il n'existe aucune relation
$tab_relation = null;
}
//recuperation du resultat de chaque version
$res = $this->afficherVersionOuPas($version, $tab_relation, $res);
}
return $res;
}
public function recupererIdSuperieur($id, $version) {
$req = 'SELECT num_nom, num_nom_retenu, num_tax_sup, rang FROM '
.$version.' WHERE num_nom = '.$this->getBdd()->proteger($id);
$res = $this->getBdd()->recupererTous($req);
if ($res) {
$resultat = $res[0];
} else {
$resultat = null; //on return null si il n'y a pas de taxon superieur
}
return $resultat;
}
public function formaterIdInferieur($resultat) {
$this->recupererTableSignification('champs_api,champs_comp,correspondance_champs');
$res = array();
foreach ($resultat as $version => $res_version) {
//on veut récupérer pour chacun des taxons inférieur le nb de taxons inf :
$tab_tax_inf = $this->recupererListeTaxonInf($res_version);
//on commence le formatage
if (($res_version) != '' ) {
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, $num); break;
case 'num_nom_retenu' : $retenu = ($val == $num) ? 'true' : 'false';
$this->table_retour['retenu'] = $retenu; break;
default : break;
}
}
}
$this->afficherTaxonInfNb($num, $tab_tax_inf);
unset($this->table_retour['id']);
$tab_inf[$num] = $this->table_retour;
$this->table_retour = array(); //on vide le tableau table_retour
}
$tab_relation[$this->num_nom_taxon] = $tab_inf;
} else {
$tab_relation = null;
}
//recuperation du resultat de chaque version
$res = $this->afficherVersionOuPas($version, $tab_relation, $res);
}
return $res;
}
public function afficherTaxonInfNb($num, $tab_tax_inf) {
foreach ($tab_tax_inf as $taxNb) {
if ($taxNb['num_tax_sup'] == $num) {
$this->table_retour['taxon_inferieur_nbre'] = $taxNb['nb'];
}
}
if (!isset($this->table_retour['taxon_inferieur_nbre'])) {
$this->table_retour['taxon_inferieur_nbre'] = '0';
}
}
public function recupererListeTaxonInf($resultat) {
// SELECT num_tax_sup, count(*) as nb FROM bdtfx_v2_00 WHERE num_tax_sup IN (id, id, id) AND num_nom = num_nom_retenu GROUP BY num_tax_sup';
foreach ($resultat as $tab) {
$tab_num[] = $tab['num_nom']; //on regroupe ici les id des taxons dont on cherche le nb de taxon inf
}
$req = 'SELECT num_tax_sup, count(*) as nb FROM '.$this->table
.' WHERE num_tax_sup IN ('.implode(',',$tab_num)
.') AND num_nom = num_nom_retenu GROUP BY num_tax_sup';
$res = $this->getBdd()->recupererTous($req);
if ($res) {
$resultat = $res;
} else {
$resultat = array(); //on return un tableau vide s'il n'y a pas de taxon inférieurs
}
return $resultat;
}
}
 
?>
/tags/v0.1-20130830-1/services/modules/0.1/coste/Textes.php
New file
0,0 → 1,497
<?php
 
/**
* Description :
* Classe Textes.php est une classe qui contient les méthodes permettant la consultation des textes (clé de détermination
* ou description). Les identifiants des textes correspondent au tag de type CleCoste1937TXXPXXNomSci pour le projet
* coste.
* 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 Textes extends Commun {
protected $limite_requete = array('depart' => 0, 'limite' => 100);
protected $requete_champ = ' t1.resource AS tag, t1.value AS num_nom, t2.value AS titre, p.body AS texte';
protected $requete_condition = null;
protected $requete_group_by = ' ORDER BY CAST( t1.value AS DECIMAL )';
protected $table_retour;
protected $retour_format = 'max';
protected $format_reponse = 'textes';
protected $table_param = array();
protected $total_resultat;
protected $table_ressources = array();
protected $html = 'txt';
protected $recherche = 'stricte';
protected $service = 'textes';
protected $masque = null;
protected $config;
public function __construct($config) {
$this->config = is_null($config) ? Config::get('Textes') : $config;
}
public function consulter($ressources, $parametres) {
$resultat_formate = '';
$this->table = array(Config::get("bdd_triples")." t1", Config::get("bdd_triples")." t2", Config::get("bdd_pages")." p");
$this->traiterParametres($parametres);
$this->traiterRessources($ressources);
if ($this->corps_http == '' && $this->entete_http == '') {
$requete = $this->assemblerLaRequete();
$resultat = $this->getBdd()->recupererTous($requete);
$this->testerResultat($resultat, $resultat_formate, $requete);
}
return $this->formerReponseHTTP($resultat_formate);
}
public function formerReponseHTTP($resultat_formate, $mime = 'application/json', $encodage= 'utf-8') {
// Si aucune erreur n'a été établie (donc un tableau de résultat a bien ete renvoyé...)
if ($this->corps_http == '' && $this->entete_http == '') {
$this->entete_http = RestServeur::HTTP_CODE_OK;
$this->corps_http = $resultat_formate;
}
if ($this->entete_http != RestServeur::HTTP_CODE_OK) {
$mime = 'text/html';
}
// Gestion du type de contenu
if (!is_null($mime) && !is_null($encodage)) {
header("Content-Type: $mime; charset=$encodage");
} else if (!is_null($mime) && is_null($encodage)) {
header("Content-Type: $mime");
}
// Envoie de l'entête
RestServeur::envoyerEnteteStatutHttp($this->entete_http);
// Envoie du corps
return $this->corps_http;
}
public function testerResultat($resultat, &$resultat_formate, $requete) {
if ($resultat == '') { //cas ou coste/services/ ou la requete comporte des erreurs
$e = 'La requête SQL formée comporte une erreur!';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,$e);
Debug::printr($requete);
} elseif ($resultat) {
$resultat_formate = $this->retournerResultatFormate($resultat);
} else {
if ($this->format_reponse == 'textes/relations') {
$resultat_formate = 'null';
} else {
$m = 'Données introuvables dans la base';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE,$m);
Debug::printr($requete);
}
}
}
//---------------------------------TRAITER RESSOURCES-----------------------------------------------------------------
public function traiterRessources(&$ressources) {
if (isset($ressources) && !empty($ressources)) {
$this->table = Config::get('bdd_triples');
$this->table_ressources = $ressources;
if ($ressources[0] == 'relations') {
$this->traiterRelationsProjet($ressources);
$this->format_reponse .= '/relations';
} elseif (isset($this->table_ressources[0]) && !empty($this->table_ressources[0])) {
$this->traiterRessourceId($this->table_ressources[0]);
if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) {
$this->format_reponse .= '/champ';
}
} else {
$e = "Erreur dans votre requête. <br/> Les ressources disponibles sont :
<li> /textes/#id (id correspondant au tag de la page </li>
<li> /textes/#id/#champ+#champ </li>
<li> /textes/relations/bdtfx/#id (id correspondant au num_nom du projet bdtfx </li>";
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
} else {
$this->traiterRessourcesListe();
}
$this->requete_condition[] = "p.latest = 'Y'";
}
public function traiterRessourceId($id) {
$this->format_reponse .= '/id';
if ($this->recherche == 'etendue') {
$id = '%'.str_replace(' ','%', $id).'%';
}
if (is_numeric($id)) {
$this->requete_condition[] = 'c.id ='.$this->getBdd()->proteger($id);
} else {
$id = explode('bdtfx.nn:', $id);
if (isset($id[1]) && is_numeric($id[1])) {
$this->requete_condition[] = 'c.num_nom ='.$this->getBdd()->proteger($id[1]);
} else {
$e = "Erreur dans votre requête. <br/> Dans le cas d'une ressource bdtfx.nn: le num nom est obligatoire !";
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
$this->requete_champ = 'c.id AS num_nom, i.nom_sci AS titre, t1.resource AS tag, p.body AS texte';
$this->table = array(Config::get("bdd_correspondance_bdnff").' c',
Config::get("bdd_triples").' t1',
Config::get("bdd_index").' i',
Config::get("bdd_pages").' p');
$this->requete_condition[] = 'c.id = i.num_nom';
$this->requete_condition[] = 'i.nom_sci = t1.value';
$this->requete_condition[] = 't1.resource = p.tag';
/*$this->requete_champ = ' t1.resource AS tag, t1.value AS num_nom, t2.value AS titre, p.body AS texte';
$this->requete_condition[] = 't1.resource LIKE '.$this->getBdd()->proteger($id);
$this->requete_condition[] = 't1.property = "num_nom"';
$this->requete_condition[] = '(t1.resource = t2.resource AND t2.property = "titre")';
$this->requete_condition[] = 't1.resource = p.tag';
$this->table = array(Config::get("bdd_triples").' t1',
Config::get("bdd_triples").' t2',
Config::get("bdd_pages").' p');
$this->ajouterRechercheFloue('t1.resource', $id);*/
}
public function traiterRessourcesListe() {
$this->requete_condition[] = "t1.property = 'num_nom'";
$this->requete_condition[] = "(t1.resource = t2.resource AND t2.property = 'titre')";
$this->requete_condition[] = "t1.resource = p.tag";
}
public function traiterRelationsProjet($tab_ress) {
$this->table = array(Config::get("bdd_triples")." t1", Config::get("bdd_pages")." p", Config::get("bdd_table").'_v0_1 c');
$projet = $tab_ress[1];
$num_nom = $tab_ress[2];
$nom_champ_projet = "flore_$projet"."_num";
if (isset($tab_ress[3])) {
$type = $tab_ress[3];
if (!in_array($type, array('cle', 'dsc'))) {
$e = "Le type de texte ne peut etre que clé ou description";
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
$this->requete_condition[] = "c.flore_bdnff_num = ".$this->getBdd()->proteger($num_nom);
$this->requete_condition[] = "t1.value = c.num_nom";
$this->requete_condition[] = "t1.property = 'num_nom'";
$this->requete_condition[] = "t1.resource = p.tag";
$this->requete_champ = 't1.resource AS tag, t1.value AS num_nom, p.body AS texte';
if (isset($type)) $this->requete_condition[] = "t1.resource LIKE ".$this->getBdd()->proteger(ucfirst($type.'%'));
}
public function ajouterRechercheFloue($nom_champ, $id) {
if ($this->recherche == 'floue') {
$id = $this->getBdd()->proteger($id);
$this->requete_condition[array_search("$nom_champ LIKE $id",
$this->requete_condition)] =
"($nom_champ LIKE $id)".
" OR ( SOUNDEX($nom_champ) = SOUNDEX($id))".
" OR SOUNDEX(REVERSE($nom_champ)) = SOUNDEX(REVERSE($id))))";
}
}
//---------------------------------------TRAITER PARAMETRES-------------------------------------------------------------
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 => $val) {
switch ($param) {
case 'retour.format' : $this->retour_format = $val; break;
case 'masque.titre' : $this->ajouterLeFiltreMasque('titre', $val); break;
case 'masque.famille' : $this->ajouterLeFiltreMasque('famille', $val); break;
case 'masque.ns' : $this->ajouterLeFiltreMasque('nom_sci', $val); break;
case 'masque.type' : $this->ajouterLeFiltreMasque('type', $val); break;
case 'masque.txt' : $this->ajouterLeFiltreMasque('texte', $val); break;
case 'masque.page' : $this->ajouterLeFiltreMasque('page',$val); break;
case 'masque.tome' : $this->ajouterLeFiltreMasque('tome',$val); break;
case 'navigation.depart': $this->limite_requete['depart'] = $val; break;
case 'navigation.limite': $this->limite_requete['limite'] = $val; break;
case 'recherche' : break;
case 'txt.format' : break;
default :
$e = "Erreur dans les paramètres de recherche de votre requête : </br> Le parametre $param n\'existe pas.";
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE,$e);
break;
}
}
}
}
public function ajouterLeFiltreMasque($masque, $valeur) {
if ($this->recherche == 'etendue') {
$valeur = '%'.str_replace(' ','%', $valeur).'%';
}
$valeur = $this->getBdd()->proteger($valeur);
$this->masque[] = "$masque=$valeur";
switch ($masque) {
case 'famille' :
break;
case 'nom_sci' :
$this->requete_condition[] = "t1.value = c.num_nom AND nom_sci LIKE $valeur)";
$this->ajouterRechercheFloue('nom_sci', $valeur);
$this->table[] = Config::get("bdd_table").'_v0_1 c';
break;
case 'type' :
$type = ($this->getBdd()->proteger($valeur) == '"cle"') ? 'Cle%' : 'Dsc%';
$this->requete_condition[] = 't1.resource LIKE '.$this->getBdd()->proteger($type);
break;
case 'texte' :
$this->requete_condition[] = "p.body LIKE $valeur";
$this->ajouterRechercheFloue('p.body', $valeur);
break;
case 'titre' :
$this->requete_condition[] = "t2.value LIKE $valeur";
$this->ajouterRechercheFloue('t2.value', $valeur);
break;
case 'page' :
$this->requete_condition[] = "t1.value = c.num_nom AND c.page = $valeur";
$this->table[] = Config::get("bdd_table").'_v0_1 c';
break;
case 'tome' :
$this->requete_condition[] = "t1.value = c.num_nom AND c.tome = $valeur";
$this->table[] = Config::get("bdd_table").'_v0_1 c';
break;
default :
break;
}
}
//-----------------------------FONCTIONS DASSEMBLAGE DE LA REQUETE-----------------------------------------------------
public function assemblerLaRequete() {
$requete = ' SELECT '.$this->requete_champ.
' FROM '.implode(', ', $this->table)
.$this->retourneRequeteCondition()
.$this->requete_group_by
.$this->formerRequeteLimite();
return $requete;
}
 
public function retourneRequeteCondition() {
$condition = '';
if ($this->requete_condition !== null) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
public function formerRequeteLimite() {
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->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.
* 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 '
.implode(', ', $this->table).$this->retourneRequeteCondition()
.$this->requete_group_by;
$res = $this->getBdd()->recuperer($requete);
if ($res) {
$total = $res['nombre'];
} else {
$e = 'Données introuvables dans la base ou erreur dans la requête SQL';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
}
return $total;
}
 
//-------------------FONCTIONS POUR LE FORMATAGE EN JSON----------------------------------------------------------------
public function retournerResultatFormate($resultat) {
$reponse = '';
switch ($this->format_reponse) {
case 'textes' : $reponse = $this->formaterTextes($resultat); break;
case 'textes/relations' : $reponse = $this->formaterTextesRelations($resultat); break;
case 'textes/id' : $reponse = $this->formaterTextesId($resultat[0]); break;
case 'textes/id/champ' : $reponse = $this->formaterTextesIdChamp($resultat[0]); break;
default : break;
}
return $reponse;
}
public function formaterTextes($resultat) {
$this->ajouterEnteteResultat($resultat);
$reponse['entete'] = $this->table_retour;
$this->table_retour = array();
foreach ($resultat as $description) {
$tag = $description['tag'];
$this->afficherDonnees('titre', $description['titre']);
$type = (preg_match('/^Cle.*$/', $tag)) ? '1' : '2' ;
$this->afficherDonnees('type', $type);
$this->table_retour['texte'] = $description['texte'];
$reponse['resultat'][$tag] = $this->table_retour;
$this->table_retour = array();
$reponse['resultat'][$tag]['href'] = $this->ajouterHref('textes', $tag);
}
return $reponse;
}
public function formaterTextesRelations($resultat) {
foreach ($resultat as $description) {
$tag = $description['tag'];
$type = (preg_match('/^Cle.*$/', $tag)) ? '1' : '2' ;
$this->afficherDonnees('type', $type);
$this->table_retour['texte'] = $description['texte'];
$reponse[$tag] = $this->table_retour;
$this->table_retour = array();
$reponse[$tag]['href'] = $this->ajouterHref('textes', $tag);
}
return $reponse;
}
public function ajouterEnteteResultat($resultat) {
if ($this->masque) {
$this->table_retour['masque'] = implode('&', $this->masque);
}
$this->table_retour['depart'] = $this->limite_requete['depart'];
$this->table_retour['limite'] = $this->limite_requete['limite'];
$this->table_retour['total'] = $this->total_resultat;
//formuler les urls
$url = $this->formulerUrl($this->total_resultat, '/'.$this->service);
if ($url['precedent'] != '') { $this->table_retour['href.precedent'] = $url['precedent']; }
if ($url['suivant'] != '') { $this->table_retour['href.suivant'] = $url['suivant']; }
}
public function formaterTextesId($reponse) {
$this->afficherDonnees('titre', $reponse['titre']);
$type = (preg_match('/^Cle.*$/', $reponse['tag'])) ? '2' : '1' ;
$this->afficherDonnees('type', $type);
$this->table_retour['texte'] = $reponse['texte'];
//$this->afficherDonnees('id', $reponse['num_nom']);
return $this->table_retour;
}
public function formaterTextesIdChamp($resultat) {
//on recupère tous les resultats possibles
$reponse_id = $this->formaterTextesId($resultat);
$this->table_retour = array();
//on recupère les résultats demandés à partir du tableau de résultat complet
$this->table_retour['id'] = $resultat['tag'];
$champs = explode(' ', $this->table_ressources[1]);
foreach ($champs as $champ) {
if ($this->verifierValiditeChamp($champ, $reponse_id)) {
if (preg_match('/^[^.]+\.\*$/', $champ)) {
$this->afficherPointEtoile($champ, $reponse_id);
} else {
$this->table_retour[$champ] = $reponse_id[$champ];
}
}
}
return $this->table_retour;
}
public function afficherPointEtoile($champ, $reponse_id) {
preg_match('/^([^.]+\.)\*$/', $champ, $match);
foreach ($reponse_id as $chp => $valeur) {
if (strrpos($chp, $match[1]) !== false) {
$this->table_retour[$chp] = $valeur;
}
}
}
public function verifierValiditeChamp($champ, $reponse_id) {
$validite = false;
preg_match('/^([^.]+)(:?\.([^.]+))?$/', $champ, $match);
if (array_key_exists($match[1], $reponse_id)) {
$validite = true;
if (isset($match[2]) && !empty($match[2])) {
if ($match[1] == 'type') {
$suffixes = array('.code', '.href', '.*');
$validite = (in_array($match[2], $suffixes)) ? true : false;
} else {
$validite = false;
}
}
}
if (!$validite) {
$champs = implode('</li><li>', array_keys($reponse_id));
$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;
}
//------------------------------------------------Fonction d'affichage ------------------------------------------------
public function afficherDonnees($champ, $valeur) {
if ($this->retour_format == 'min') {
$champ = ($champ == 'type') ? $champ.'.code' : $champ;
$this->table_retour[$champ] = $valeur;
} else {
$this->afficherDonneesMax($champ, $valeur);
}
}
public function afficherDonneesMax($champ, $valeur) {
if ($champ == 'id') {
$this->table_retour[$champ] = "coste.".$valeur;
$this->table_retour['nom_sci'] = $this->recupererNomSci($valeur);
$this->table_retour['id.href'] = $this->ajouterHref('noms', $valeur);
} elseif (in_array($champ, array('type'))) {
$this->table_retour[$champ.'.code'] = $valeur;
$this->table_retour[$champ] = $this->recupererSignificationCode($valeur);
$this->table_retour[$champ.'.href'] = $this->ajouterHrefAutreProjet('ontologies', 'texteType:', $valeur, 'eflore');
} else {
$this->table_retour[$champ] = $valeur;
}
}
public function recupererSignificationCode($code) {
$url = $this->ajouterHrefAutreProjet('ontologies', 'texteType:', $code.'/nom', 'eflore');
$res = $this->consulterHref($url);
return $res->nom;
}
public function recupererNomSci($id) {
$req = 'SELECT nom_sci FROM coste_v0_1 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);
return $res['nom_sci'];
}
 
}
 
?>
/tags/v0.1-20130830-1/services/modules/0.1/photoflora/Images.php
New file
0,0 → 1,421
<?php
/**
* Web service particulier pour photoflora, qui ne doitpas être installé sur tela botanica
* mais sur photoflora.free.fr
* Une redirection htaccess est à faire, redirigeant /service:eflore:0.1/photoflora/image
* vers le site photoflora à l'adresse ou seront installé les services web et le minimum
* nécessaire pour les faire fonctionner (framework + base de code eflore-projet ou peut-être moins)
*
* La table des metadonnées est, elle, stockée sur Tela Botanica
* Le service est dans le même dépot que les autres par souci de commodité
*
*/
class Images {
 
const MIME_JPEG = 'image/jpeg';
const MIME_PNG = 'image/png';
const MIME_JSON = 'application/json';
const MIME_XML = 'text/xml';
 
//TODO déplacer ceci dans des parametres de config
const BDD_PF = 'photoflora';
private $efph_url_photo = 'http://photoflora.free.fr/photos/%s/max/%s';
private $efph_url_photo_bb = 'http://photoflorabb.free.fr/max/%s';
private $efph_url_photo_jlt = 'http://photoflorajlt.free.fr/max/%s';
 
private $efph_url_photo_min = 'http://photoflora.free.fr/photos/%s/min/%s';
private $efph_url_photo_bb_min = 'http://photoflora.free.fr/photos/bb/min/%s';
private $efph_url_photo_jlt_min = 'http://photoflora.free.fr/photos/jlt/min/%s';
 
private $parametres = array();
private $ressources = array();
private $Bdd;
 
private $format = 'min';
private $retour_mime = 'application/json';
private $nbreImages = '0';
 
public function __construct(Bdd $bdd = null, Array $config = null) {
$this->config = is_null($config) ? Config::get('Images') : $config;
$this->Bdd = is_null($bdd) ? new Bdd() : $bdd;
}
 
public function consulter($ressources, $parametres) {
 
$this->parametres = $parametres;
$this->ressources = $ressources;
 
$this->definirValeurParDefautDesParametres();
 
$this->format = (isset($this->parametres['retour.format']) && $this->parametres['retour.format'] != '') ? $this->parametres['retour.format'] : $this->format;
$this->retour_mime = (isset($this->parametres['retour']) && $this->parametres['retour'] != '') ? $this->parametres['retour'] : $this->retour_mime;
$photographies = $this->getResultatTest();
if($this->retour_mime == self::MIME_JPEG) {
$photo = $this->obtenirPremiereImage();
$retour = $this->formaterRetourImageBinaire($photo);
echo $retour;
} elseif($this->retour_mime == self::MIME_JSON) {
$photographies = $this->obtenirImages();
$this->nbreImages = count($photographies);
$photographies_formatees = $this->formaterRetourJson($photographies);
$resultat = $photographies_formatees;
$entete = $this->construireEntete();
return array('entete' => $entete, 'resultats' => $resultat);
} elseif ($this->retour_mime == self::MIME_XML) {
$photographies = $this->obtenirImages();
$this->nbreImages = count($photographies);
$photographies_formatees = $this->formaterRetourXml($photographies);
header('Content-Type: '.self::MIME_XML);
echo $photographies_formatees;
exit;
}
}
 
private function construireEntete() {
$entete = array('masque' => '', 'depart' => 0, 'limite' => 100, 'total' => 0);
 
$entete['masque'] = $this->recupererMasque();
$entete['depart'] = (int) $this->parametres['navigation.depart'];
$entete['limite'] = (int) $this->parametres['navigation.limite'];
$entete['total'] = $this->nbreImages;
 
return $entete;
}
 
private function recupererMasque() {
$masqueEntete = '';
foreach ($this->parametres as $param => $cle) {
if ($param == 'masque') {
$masqueEntete = 'masque='.$cle.',';
} elseif (substr($param, 0, 7) == 'masque.') {
$masqueEntete .= substr($param, 7).'='.$cle.',';
}
}
$masqueEntete = rtrim($masqueEntete,',');
return $masqueEntete;
}
 
private function definirValeurParDefautDesParametres() {
if (isset($this->parametres['retour']) == false) {
$this->parametres['retour'] = self::MIME_JSON;
}
if (isset($this->parametres['retour.format']) == false) {
$this->parametres['retour.format'] = 'min';
}
if (isset($this->parametres['navigation.depart']) == false) {
$this->parametres['navigation.depart'] = 0;
}
if (isset($this->parametres['navigation.limite']) == false) {
$this->parametres['navigation.limite'] = 100;
}
}
 
public function obtenirPremiereImage() {
$this->parametres['navigation.depart'] = 0;
$this->parametres['navigation.limite'] = 1;
$images = $this->obtenirImages();
if (!is_array($images) || count($images) <= 0) {
$message = "Aucune image ne correspond au numéro numenclatural $refTax:$numNom";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
} else {
return $images[0];
}
}
 
public function obtenirImages() {
//TODO: tri par date, mais les dates dans la bdd photoflora sont des chaines en entités HTML
// donc un tri dessus n'a pas de sens
$requete = 'SELECT photos.*, taxons.NumTaxon, taxons.NumNomen, taxons.Combinaison, photographes.Nom, '.
' photographes.Prenom, photographes.Initiales, photographes.Mail '.
'FROM '.self::BDD_PF.'.photos, '.self::BDD_PF.'.photographes, '.self::BDD_PF.'.taxons '.
'WHERE '.
'photos.Auteur = photographes.ID '.
'AND photos.NumTaxon = taxons.NumTaxon '.
$this->construireWhereNumNom().' '.
$this->construireWhereNumTax().' '.
$this->construireWhereNomSci().' '.
$this->construireWhereAuteur().' '.
'ORDER BY photos.support LIMIT '.$this->parametres['navigation.depart'].','.$this->parametres['navigation.limite'];
$resultat = $this->Bdd->recupererTous($requete);
return $resultat;
}
 
private function construireWhereNumNom() {
return (isset($this->parametres['masque.nn'])) ? 'AND taxons.NumNomen = '.$this->Bdd->proteger($this->parametres['masque.nn']).' ' : '';
}
 
private function construireWhereNumTax() {
return (isset($this->parametres['masque.nt'])) ? 'AND taxons.NumTaxon = '.$this->Bdd->proteger($this->parametres['masque.nt']).' ' : '';
}
 
private function construireWhereNomSci() {
return (isset($this->parametres['masque.ns'])) ? 'AND taxons.Combinaison LIKE '.$this->Bdd->proteger($this->parametres['masque.ns'].'%').' ' : '';
}
 
private function construireWhereAuteur() {
$requete_auteur = '';
if (isset($this->parametres['masque.auteur'])) {
$auteur_like = $this->Bdd->proteger($this->parametres['masque.auteur'].'%');
$requete_auteur = 'AND photos.auteur = '.
'(SELECT id FROM '.self::BDD_PF.'.photographes '.
'WHERE '.
'Nom LIKE '.$auteur_like.' OR '.
'Prenom LIKE '.$auteur_like.' OR '.
'Initiales LIKE '.$auteur_like.' OR '.
'Mail LIKE '.$auteur_like.') ';
}
return $requete_auteur;
}
 
private function formaterRetourImageBinaire($photo) {
$image = '';
$chemin = $url = $this->getUrlPhotoPourInitiales($photo['Initiales'], $photo['NumPhoto'], $this->format);
$image = file_get_contents($chemin);
if ($image === false) {
$message = "L'image demandée est introuvable sur le serveur : $chemin";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
return $image;
}
 
private function formaterRetourJson($photographies) {
$resultat = array();
if (is_array($photographies)) {
foreach ($photographies as $photo) {
$image = array();
$url = $this->getUrlPhotoPourInitiales($photo['Initiales'], $photo['NumPhoto'], $this->format);
$urlmax = $this->getUrlPhotoPourInitiales($photo['Initiales'], $photo['NumPhoto'], 'max');
$id = str_replace(array('.jpg','.jpeg', '.png'), '', $photo['NumPhoto']);
 
// Post-traitement des valeurs
$image['date'] = $this->donnerDate($this->formaterChaineEncodeeBddPhotoflora($photo['Date']));
$image['mime'] = $this->extraireMime($photo['NumPhoto']);
$image['auteur.libelle'] = $this->formaterChaineEncodeeBddPhotoflora($photo['Prenom'].' '.$photo['Nom']);
$image['binaire.href'] = $url;
$image['binaire.hrefmax'] = $urlmax;
$image['determination.libelle'] = $photo['Combinaison'].' ['.$photo['Prenom'].' '.$photo['Nom'].']';
$image['determination.nom_sci.libelle'] = $photo['Combinaison'];
$image['determination.nom_sci.code'] = "bdtfx.".$photo['NumNomen'];
$image['station.libelle'] = $this->formaterStation($photo['lieu']);
 
$resultat[$id] = $image;
}
}
return $resultat;
}
 
private function extraireMime($fichierImg) {
$mime = '';
if (strpos($fichierImg, '.jpg') || strpos($fichierImg, '.jpeg')) {
$mime = self::MIME_JPEG;
} else if (strpos($fichierImg, '.png')) {
$mime = self::MIME_PNG;
}
return $mime;
}
 
private function formaterStation($station) {
$station = $this->formaterChaineEncodeeBddPhotoflora($station);
$station = preg_replace('/^ : /', '', $station);
return $station;
}
 
private function callBackReplace($m) {
return mb_convert_encoding($m[1], "UTF-8", "HTML-ENTITIES");
}
 
private function formaterChaineEncodeeBddPhotoflora($chaine) {
return $chaine = preg_replace_callback("/(&#[0-9]+;)/", array($this, 'callBackReplace'), $chaine);
}
 
// TODO: garder ancien web service pour retour xml ou bien fusionner les deux ?
private function formaterRetourXml($photographies) {
// Formatage du xml
$xml = '<?xml version="1.0" encoding="utf-8"?>'."\n";
$xml .= '<rdf:RDF'."\n";
$xml .= ' xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"'."\n";
$xml .= ' xmlns:dc="http://purl.org/dc/elements/1.1/"'."\n";
$xml .= ' xmlns:dcterms="http://purl.org/dc/terms">'."\n";
foreach ($photographies as $photo) {
 
$url = $this->getUrlPhotoPourInitiales($photo['Initiales'], $photo['NumPhoto'], $this->format);
 
// Post-traitement des valeurs
$photo['lieu'] = preg_replace('/^[ ]*:[ ]*/', '', $photo['lieu']);
 
// Gestion du XML
$xml .= ' <rdf:Description about="'.$url.'"'."\n";
$xml .= ' dc:identifier="'.preg_replace('/\.\w+$/', '', $photo['NumPhoto']).'"'."\n";
$xml .= ' dc:title="'.$photo['Combinaison'].'"'."\n";
$xml .= ' dc:description="'.$photo['Objet'].'"'."\n";
$xml .= ' dc:creator="'.$photo['Prenom'].' '.$photo['Nom'].'"'."\n";
// $xml .= ' dc:contributor="Daniel MATHIEU (Détermination)"'."\n";
$xml .= ' dc:publisher="Photoflora"'."\n";
$xml .= ' dc:type="'.$this->donnerTxtSupport($photo['Support']).'"'."\n";
$xml .= ' dc:format="'.$this->donnerTypeMime($photo['NumPhoto']).'"'."\n";
$xml .= ' dcterms:spatial="'.$photo['lieu'].'"'."\n";
$xml .= ' dcterms:created="'.$photo['Date'].'"'."\n";
// $xml .= ' dcterms:dateSubmitted="2006-10-18 08:32:00"'."\n";
$xml .= ' dcterms:licence="Utilisation des photos non autorisée sans accord avec le gestionnaire du site et sous certaines conditions - Tous droits réservés - All rights reserved"/>'."\n";
}
$xml .= '</rdf:RDF>'."\n";
 
return $xml;
}
 
private function getUrlPhotoPourInitiales($initiales, $num_photo, $format) {
// Gestion des urls des photos
$url = '';
if ($initiales == 'bb') {
$base_url = ($format == 'max') ? $this->efph_url_photo_bb : $this->efph_url_photo_bb_min;
$url = sprintf($base_url, $num_photo);
} else if ($initiales == 'jlt') {
$base_url = ($format == 'max') ? $this->efph_url_photo_jlt : $this->efph_url_photo_jlt_min;
$url = sprintf($base_url, $num_photo);
} else {
$base_url = ($format == 'max') ? $this->efph_url_photo : $this->efph_url_photo_min;
$url = sprintf($base_url, $initiales, $num_photo);
}
 
return $url;
}
 
private function getResultatTest() {
$photographies = array();
$photographies[] = array('Initiales' => 'bb',
'NumPhoto' => 'bb047230.jpg',
'NumNomen' => '182',
'lieu' => 'Ristolas - Hautes Alpes (05) [France]',
'Combinaison' => '',
'Objet' => 'Vue générale, en fleur cv Musik - Canon EOS 350D DIGITAL - Expo : 1/160 sec. - Ouv. : f8 - ISO : 100 - flash : non - foc. : 60 - pix. : 8 Mp.',
'Prenom' => 'Benoit',
'Nom' => 'BOCK',
'Support' => 'Photographie numérique',
'Date' => 'Mai 2006');
 
return $photographies;
}
 
/**
* Fonction remplaçant les caractères posant problème dans le xml
*
* @param string le texte à nettoyer
* @return string le texte nettoyé
*/
function nettoyerXml($xml) {
// Remplacement des esperluettes
$xml = str_replace(' & ', ' &#38; ', $xml);
// Remplacement du caractère spécial de fin de ligne : VT
$xml = preg_replace('/ /', "\n", $xml);
return $xml;
}
 
/**
* Fonction fournissant les intitulés des types de support des images
*
* @param integer identifiant du support
* @return string le texte correspondant au type de support
*/
function donnerTxtSupport($support) {
switch ($support) {
case '0':
$support = 'Photographie num&#233;rique (6 mégapixels)';
break;
case '1':
$support = 'Diapositive';
break;
case '10':
$support = 'Scan de la flore de Coste';
break;
case '11':
$support = 'Scan de plante fraiche';
break;
default:
$support = 'Erreur code support : pr&#233;venir eflore_remarques@tela-botanica.org';
}
return $support;
}
 
/**
* Fonction fournissant les types MIME des fichiers images
*
* @param string le nom du fichier
* @return string le texte du type MIME du fichier
*/
function donnerTypeMime($fichier) {
if (preg_match('/\.(\w+)$/', $fichier, $match)) {
switch (strtolower($match[1])) {
case 'jpeg':
case 'jpg':
$type = 'image/jpeg';
break;
case 'png':
$type = 'image/png';
break;
default:
$type = 'Erreur Mime : prévenir eflore_remarques@tela-botanica.org';
}
} else {
$type = 'Erreur Mime : prévenir eflore_remarques@tela-botanica.org';
}
return $type;
}
 
/**
* Fonction fournissant une date au format Mysql
*
* @param string la date composé du nom du mois en français et de l'année sous 4 chiffres
* @return string la date dans le format Mysql
*/
function donnerDate($chaine) {
if (preg_match('/^(\w+) (\d{4})$/',$chaine, $match)) {
$mois = $match[1];
$annee = $match[2];
switch (strtolower($mois)) {
case 'janvier' :
$mois_sortie = '01';
break;
case 'février' :
$mois_sortie = '02';
break;
case 'mars' :
$mois_sortie = '03';
break;
case 'avril' :
$mois_sortie = '04';
break;
case 'mai' :
$mois_sortie = '05';
break;
case 'juin' :
$mois_sortie = '06';
break;
case 'juillet' :
$mois_sortie = '07';
break;
case 'aout' :
case 'août' :
$mois_sortie = '08';
break;
case 'septembre' :
$mois_sortie = '09';
break;
case 'octobre' :
$mois_sortie = '10';
break;
case 'novembre' :
$mois_sortie = '11';
break;
case 'decembre' :
$mois_sortie = '12';
break;
}
return $annee.'-'.$mois_sortie.'-01 01:01:01';
} else {
return '1970-01-01 01:01:01';
}
}
}
?>
/tags/v0.1-20130830-1/services/modules/0.1/photoflora/ALIRE.txt
New file
0,0 → 1,8
; l'utilisation d'une redirection transparente des appels à l'api photoflora peut se faire
; en incluant dans le .htaccess du site, la ligne suivante :
RewriteRule ^service:eflore:([0-9]\.[0-9])/photoflora/images$ http://photoflora.free.fr/eflore-photoflora/services/index.php/$1/projets/photoflora/images
; Attention ! Il faut l'inclure avant la ligne de redirection des services web eflore
 
; Free ne supporte pas la redirection .htacess, il faut donc donc la désactiver dans le .htaccess de la racine des services
; Photoflora étant hébergé chez free, il faut changer ce paramètre dans le fichier de config général en ce qui suit
serveur.baseURL = "/eflore-photoflora/services/index.php/"
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/tags/v0.1-20130830-1/services/modules/0.1/nvjfl/NomsVernaculaires.php
New file
0,0 → 1,838
<?php
/**
* Description :
* Classe NomsVernaculaires.php fournit une liste de noms vernaculaires et leur liaison à la bdtfx
* Le but étant de fournir un ensemble minimal d'information comprenant :
* un identifiant (numérique ou alphanumérique sous forme de ChatMot si possible), un nom, une langue et
* une relation avec un taxon de la bdtfx.
* Si l'url finit par /noms-vernaculaires on retourne une liste de noms (seulement les 100 premières par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /observations?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche,
* distinct, retour.format, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Delphine Cauquil <delphine@tela-botanica.org>
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 1.0
* @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org)
*/
 
// Un caractère de concaténation entre le projet et le service.
// Ce caractère ne doit pas faire partie d'aucun des noms de service ou projet
define('RES_VAL_SEP', '@');
define('SPE_INDEX_NVJFL', '_result_ontologies' . RES_VAL_SEP . 'nvjfl');
 
class NomsVernaculaires extends Commun {
 
static $onto_multi_support = array('conseil_emploi', 'genre');
static $champ_infos = array(
'taxon' => array('service' => 'taxons', 'ressource' => 'nt:', 'projet' => 'bdtfx', 'nom' => 'nom_sci',
// utilisés par ajouterChampsOntologieLigneResultat()
'intitule' => 'taxon.code', // intitulé du champ tel qu'il sera renvoyé en JSON
'bdd_champ' => 'num_taxon'), // intitulé du champ tel qu'il est présent dans l'enregistrement MySQL
'conseil_emploi' => array('service' => 'ontologies', 'ressource' => 'numStatut:', 'projet' => 'nvjfl', 'nom' => 'nom',
'intitule' => 'conseil_emploi', 'bdd_champ' => 'num_statut'),
'genre' => array('service' => 'ontologies', 'ressource' => 'genreNombre:', 'projet' => 'nvjfl', 'nom' => 'nom',
'intitule' => 'genre', 'bdd_champ' => 'num_genre'));
 
protected $service = 'noms-vernaculaires';
 
/**
* Permet de stocker la requete formulée : /noms-vernaculaires | /noms-vernaculaires/#id |
* /noms-vernaculaires/#id/champ | /noms-vernaculaires/#id/relations
* Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service.
* Est utilisée principalement pr déterminer le format du tableau à retourner. */
protected $format_reponse = 'noms-vernaculaires';
 
/** Variables constituant les parametres de la requete SQL (champ, condition, limit) remplie
* selon ressources et paramètres */
protected $requete_champ = array(' * ');
protected $requete_condition = '';
protected $limite_requete = array(
'depart' => 0,
'limite' => 100
);
protected $champ_tri = 'code_langue';
protected $direction_tri = 'asc';
/**
* Indique les champs supplémentaires à retourner
* - conseil_emploi = conseil d'emploi du nom vernaculaire
* - genre = genre et nombre du nom
* - taxon = nom retenu associé à ce nom
*/
protected $champs_supp = array();
 
/**
* Precise la contenance plus ou moins précise du tableau à retourner :
* - min = les données présentes dans la table
* - max = les données de la table + les informations complémentaires (pour les identifiants et les codes)
* - oss = la liste des nom_sci (uniquement pour noms et taxons) */
protected $retour_format = 'max';
/** Valeur du paramètre de requete recherche :
* - stricte : le masque est passé tel quel à l'opérateur LIKE.
* - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE.
* - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */
protected $recherche;
/** Permet de stocker le tableau de résultat (non encodé en json) */
protected $table_retour = array();
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */
protected $total_resultat;
private $config;
public function __construct($config) {
$this->config = is_null($config) ? Config::get('NomsVernaculaires') : $config;
}
 
//+------------------------------------------------------------------------------------------------------+
// créer une condition en fonction du paramétre
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres)) {
 
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') {
$this->recherche = $this->parametres['recherche'];
}
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'masque' :
$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
break;
case 'masque.nt' :
$this->ajouterFiltreMasque('num_taxon', $valeur);
break;
case 'masque.nv' :
$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
break;
case 'masque.lg' :
$this->ajouterFiltreMasque('code_langue', $valeur);
break;
case 'masque.cce' :
$this->ajouterFiltreMasque('num_statut', $valeur);
break;
case 'retour.format' :
$this->retour_format = $valeur;
break;
case 'navigation.depart' :
$this->limite_requete['depart'] = $valeur;
break;
case 'navigation.limite' :
$this->limite_requete['limite'] = $valeur;
break;
case 'retour.champs' :
$this->champs_supp = explode(',',$valeur);
break;
case 'recherche' :
break;
case 'version.projet' :
break;
default :
$p = 'Erreur dans les paramètres de recherche de votre requête : '.
'</br> Le paramètre " '.$param.' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $p);
}
}
}
}
 
public function ajouterFiltreMasque($nom_champ, $valeur) {
if ($nom_champ == 'num_taxon') { // si il s'agit d'un chiffre
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if ($this->recherche == 'floue') {
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ';
} else {
if ($this->recherche == 'etendue') {
$valeur = '%'.str_replace(' ','% ', $valeur);
$valeur .= '%';
}
$this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
// en fonction de la présence des ressources modifie requete_champ et requete_condition
public function traiterRessources() {
if (isset($this->ressources) && !empty($this->ressources)) {
if (isset($this->ressources[0]) && !empty($this->ressources[0])) {
$this->traiterRessourceId(); // ajoute condition id=#valeur
if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
$this->traiterRessourceChamp(); //modifie requete_champ ou requete_condition
}
}
} else { //rajoute distinct pour ne pas avoir plusieurs fois le même nom
$this->requete_champ = array('distinct(id)', 'nom_vernaculaire ');
}
}
 
//requete : /noms-vernaculaires/#id (ex : /noms-vernaculaires/7)
public function traiterRessourceId() {
if (is_numeric($this->ressources[0])) {
$this->requete_condition[] = ' id = '.$this->getBdd()->proteger($this->ressources[0]);
$this->format_reponse .= '/id';
} elseif ($this->ressources[0] == 'attributions') {
$this->format_reponse .= '/attributions';
} else {
$r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->ressources[0].
' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r);
}
}
 
 
public function traiterRessourceChamp() {
$this->format_reponse .= '/champ';
$this->analyserChamp();
}
 
public function analyserChamp() {
$this->requete_champ = array();
$this->recupererTableConfig('champs_possibles');// s'il y a plusieurs champs correspondant au champ demandé ils sont séparé par des |
$champs = explode(' ', $this->ressources[1]);
foreach ($champs as $champ) {
preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match);
if (isset($this->champs_possibles[$match[1]])) {
$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[1]]);
} elseif (isset($this->champs_possibles[$match[0]])) {
$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[0]]);
} else {
$champs_possibles = implode('</li><li>', array_keys($this->champs_possibles));
$c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '.
'Les champs disponibles sont : <li>'.$champs_possibles.'</li> et leurs déclinaisons (ex. ".code").';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
public function assemblerLaRequete() {
$requete = ' SELECT '.$this->formerRequeteChamp().
', CASE num_statut WHEN "" THEN 1 ELSE 0 END AS is_null '.
' FROM '.$this->table
.$this->formerRequeteCondition().
' ORDER BY is_null ASC, num_statut ASC '
.$this->formerRequeteLimite();
return $requete;
}
 
public function formerRequeteChamp() {
if (in_array('*', $this->requete_champ)) {
$champ = ' * ';
} else {
$champ = implode(', ', $this->requete_champ);
}
return $champ;
}
 
public function formerRequeteCondition() {
$condition = '';
if ($this->requete_condition != null) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
//ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes
// suivantes : /noms-vernaculaires et /noms-vernaculaires/#id/relations)
public function formerRequeteLimite() {
if (in_array($this->format_reponse , array($this->service.'/id', $this->service.'/id/champs'))) {
$this->requete_limite = '';
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) {
$this->limite_requete['depart'] =
(($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']);
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
} else {
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
}
return $this->requete_limite;
}
 
//on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /noms-vernaculaires)
public function recupererTotalResultat() {
$distinct = ($this->format_reponse == 'noms-vernaculaires/attributions') ? 'id' : 'distinct(id)';
$requete = 'SELECT count('.$distinct.') as nombre FROM '
.$this->table
.$this->formerRequeteCondition();
$res = $this->getBdd()->recuperer($requete);
 
if ($res) {
$total = $res['nombre'];
} else {
$t = 'Fonction recupererTotalResultat() : <br/>Données introuvables dans la base '.$requete;
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $t);
}
return $total;
}
 
//+------------------------------------------------------------------------------------------------------+
// determine en fct du service appelé (/noms-vernaculaires | /noms-vernaculaires/#id | /noms-vernaculaires/#id/champ |
// /noms-vernaculaires/#id/relations) le format du tableau à retourner.
public function retournerResultatFormate($resultat) {
$this->recupererTableConfig('correspondance_champs');
switch ($this->format_reponse) {
case 'noms-vernaculaires' :
$reponse = ($this->retour_format == 'oss') ? $this->formaterEnOss($resultat) : $this->formaterNomsVernaculaires($resultat); break;
case 'noms-vernaculaires/attributions' : $reponse = $this->formaterNomsVernaculairesAttributions($resultat); break;
case 'noms-vernaculaires/id' : $reponse = $this->formaterNomsVernaculairesId($resultat); break;
case 'noms-vernaculaires/id/champ' : $reponse = $this->formaterNomsVernaculairesIdChamp($resultat); break;
default : break;
}
return $reponse;
}
public function ajouterJsonEnTeteNV() {
$table_retour_json['masque'] = $this->recupererMasque();
$table_retour_json['depart'] = $this->limite_requete['depart'];
$table_retour_json['limite'] = $this->limite_requete['limite'];
$table_retour_json['total'] = $this->total_resultat;
$url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires');
if (isset($url['precedent']) && $url['precedent'] != '') {
$table_retour_json['href.precedent'] = $url['precedent'];
}
if (isset($url['suivant']) && $url['suivant'] != '') {
$table_retour_json['href.suivant'] = $url['suivant'];
}
return $table_retour_json;
}
public function ajouterJsonResultatNV($resultat) {
foreach ($resultat as $tab) {
foreach ($tab as $key => $valeur) {
if ($valeur != '') {
switch ($key) {
case 'id' : $num = $valeur; break;
case 'nom_vernaculaire' : $this->table_retour['nom'] = $valeur; break;
default : break;
}
}
}
if ($this->retour_format == 'max') $this->table_retour['href'] = $this->ajouterHref('noms-vernaculaires', $num);
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array();
}
return $resultat_json;
}
 
public function formaterNomsVernaculaires($resultat) {
$table_retour_json['entete'] = $this->ajouterJsonEnTeteNV();
$resultat = $this->hierarchiserResultat($resultat);
$table_retour_json['resultat'] = $this->ajouterJsonResultatNV($resultat);
return $table_retour_json;
}
public function hierarchiserResultat($resultat) {
//tri recherche floue
if (isset($this->parametres['masque.nv'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque.nv'], $resultat, 'nom_vernaculaire');
}
if (isset($this->parametres['masque'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque'], $resultat, 'nom_vernaculaire');
}
return $resultat;
}
public function recupererMasque() {
$tab_masque = array();
foreach ($this->parametres as $param=>$valeur) {
if (strstr($param, 'masque') != false) {
$tab_masque[] = $param.'='.$valeur;
}
}
$masque = implode('&', $tab_masque);
return $masque;
}
public function formaterEnOss($resultat) {
$table_nom = array();
$oss = '';
foreach ($resultat as $tab) {
if (isset($tab['nom_vernaculaire']) ) {
if (!in_array($tab['nom_vernaculaire'], $table_nom)) {
$table_nom[] = $tab['nom_vernaculaire'];
$oss [] = $tab['nom_vernaculaire'];
}
}
}
if (isset($this->masque)) $masque = implode('&', $this->masque);
else $masque = 'Pas de masque';
$table_retour_oss = array($masque, $oss);
return $table_retour_oss;
}
public function formaterNomsVernaculairesAttributions($resultat) {
//on remplie la table $table_retour_json['entete']
$table_retour_json['entete']['masque'] = $this->recupererMasque();
$table_retour_json['entete']['depart'] = $this->limite_requete['depart'];
$table_retour_json['entete']['limite'] = $this->limite_requete['limite'];
$table_retour_json['entete']['total'] = $this->total_resultat;
$url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires/attributions');
if (!empty($url['precedent'])) {
$table_retour_json['entete']['href.precedent'] = $url['precedent'];
}
if (!empty($url['suivant'])) {
$table_retour_json['entete']['href.suivant'] = $url['suivant'];
}
foreach ($resultat as &$tab) {
$nnv = $tab['num_nom_vernaculaire'];
$resultat_json[$nnv]['id'] = $tab['id'];
$resultat_json[$nnv]['nom_vernaculaire'] = $tab['nom_vernaculaire'];
$resultat_json[$nnv]['langue.code'] = $tab['code_langue'];
$resultat_json[$nnv]['taxon.code'] = 'bdtfx.nt:'.$tab['num_taxon'];
if ($this->retour_format == 'max') {
$this->taxons[] = $tab['num_taxon']; // utilisé pour chercher les noms latins plus bas
if($this->champs_supp) {
//$resultat_json[$nnv] = $this->ajouterChampsOntologieLigneResultat($tab);
// simple initialisation par copie de la référence de l'original
$resultat_json[$nnv] = &$tab;
}
else {
$resultat_json[$nnv]['num_taxon'] = $tab['num_taxon'];
$resultat_json[$nnv]['nom_retenu.code'] = $tab['num_taxon'];
$resultat_json[$nnv]['taxon'] = $tab['num_taxon'];
$resultat_json[$nnv]['href'] = $this->ajouterHref('noms-vernaculaires', $tab['id']);
}
}
}
 
// dans ce cas (particulier?) nous n'avons pour l'heure initialisé qu'une référence
// vers le tableau de valeurs original
if ($this->retour_format == 'max' && $this->champs_supp) {
// récupérons désormais les ontologies
$this->ajouterChampsOntologieLigneTousResultats($resultat_json);
}
 
if ($this->retour_format == 'max') {
// On est obligé de faire un deuxième boucle pour demander tous les taxons présents en une
// fois et les attribuer aux noms car c'est beaucoup plus rapide
$noms_sci = $this->recupererNomTaxons();
foreach ($resultat_json as $num_nom => &$tab) {
$tab = $this->ajouterTaxonsAttributionsLigneResultat($tab, $noms_sci);
if($tab == null) {
unset($resultat_json[$num_nom]);
}
}
}
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
/**
* Ajoute les champs d'ontologie supplémentaires si necéssaire
* en faisant appels aux web services associés.
* Les appels peuvent être fait individuellement (pour un couple <ontologie:valeur>) ou bien
* regroupés, **si le webservice correspondant le supporte**.
*
* Nous disposons à ce jour de 3 (trois) webservices d'ontologies correspondant aux noms vernaculaires (cf $champ_infos)
* Mais 2 d'entre eux sont identiques, il s'agit de /nvjfl/ontologies/. Or ce webservice supporte le multi-critère.
* Nous pouvons donc factorisé l'appel pour "conseil_emploi" et "genre", mais pas pour "taxon".
*
* @param array in/out $resultats: tous les résultats
*/
public function ajouterChampsOntologieLigneTousResultats(&$resultats) {
$champs_sup = array_intersect($this->champs_supp, array_keys(self::$champ_infos));
 
// La regroupement des toutes les valeurs recherchées (pour tous les
// résultats), pour "les" onotologies supportant le multi-critère est effectué ci-dessous.
// Dans les faits ce n'est le cas que pour nvjfl.
$ontologieParamPending = self::NvjflOntologieIndex($resultats, $champs_sup);
$this->NvjflOntologieExpand($ontologieParamPending);
self::NvjflOntologieCombine($resultats);
 
// pour les ontologies multi-critères, on vient de le régler ci-dessus
$champs_sup = array_diff($champs_sup, self::$onto_multi_support);
 
 
// ici, $champs_sup ne peut contenir, au plus, que "taxon".
// code historique:
foreach($champs_sup as $cle) {
$champs_supplementaires = self::$champ_infos[$cle];
// extrait, depuis un élément de $champ_infos:
// $service, $ressource, $projet, $nom, $intitule, $bdd_champ
extract($champs_supplementaires);
 
foreach ($resultats as &$tab) {
$valeur_recherche = $tab[$bdd_champ];
if(!trim($valeur_recherche)) continue;
 
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur_recherche, $projet);
$tab[$intitule] = $this->chercherSignificationCode($url, $nom);
}
}
}
 
/* Récupère les valeurs recherchées pour une liste de résultats, (plus ou moins)
spécifiquement au service d'Ontologies de NVJFL.
Aggrège les valeurs dans le tableau retourné.
Une référence vers l'index du tableau (NULL pour l'instant) est laissée dans
un élément du résultat. */
static function NvjflOntologieIndex(&$resultats, $champs_sup) {
// nous ne supportons le multi-critère que sur les ontologies nvjfl, et nous
// avons précisé celles qui sont concernées dans self::$onto_multi_support
$champs_sup = array_intersect($champs_sup, self::$onto_multi_support);
$ontologieParamPending = Array();
foreach($resultats as &$resultat) {
foreach($champs_sup as $v) {
// de cet extract() nous n'utilisons que $bdd_champ et $ressource
extract(self::$champ_infos[$v]);
if(!isset($resultat[$bdd_champ])) continue;
 
$valeur_recherche = $resultat[$bdd_champ];
if(!trim($valeur_recherche)) continue;
 
// XXX: $ressource contient déjà ':' comme suffixe
$critere = $ressource . $valeur_recherche;
$ontologieParamPending[$critere] = NULL;
// placeholder pour le résultat
$resultat[SPE_INDEX_NVJFL][$v][$critere] =
&$ontologieParamPending[$critere];
}
}
return $ontologieParamPending;
}
 
// TODO: switch to static si il peut en être de même pour ajouterHrefAutreProjet()
/* À partir d'un aggrégat des critère de requêtes d'ontologies, spécifiques à NVJFL,
créé une URL multi-critère.
Celle-ci, dans ce cas précis, n'est que la concaténation, par des virgules,
des couples <ressource:ValeurRecherchée>.
L'URL est appelée et la valeur correspondante est remplacée dans $criteres_requete.
 
Note: dans le cadre du tryptique index/expand/combine pour lequel cette fonction existe,
la valeur est référencée par un élément d'une ou plusieurs lignes de $resultat correspondantes.
Celle(s)-ci sera[ont] donc changée(s) dans la foulée. */
public function NvjflOntologieExpand(&$criteres_requete) {
// équivalent spécifique de ajouterHrefAutreProjet()
$valeurs_requises = implode(',', array_keys($criteres_requete));
// en vérité, nous ne supportons ceci ici que pour nvjfl et non n'importe quel url_service
$url = Config::get('url_service').'/ontologies/'.$valeurs_requises;
$val = $this->consulterHref($url);
 
// TODO, le webservice d'ontologies devrait être modifié pour retourner un tableau
// indexé par critère requesté à *CHAQUE* fois, y compris lorsque 1 seul critère est
// demandé.
if(array_key_exists('id', $val) && count($criteres_requete) == 1) {
$k = key($criteres_requete);
$criteres_requete[$k] = $val;
return;
}
 
// subtilité, cette affectation modifie par conséquent les valeurs dans
// $resultats[X][SPE_INDEX_NVJFL]
// dont la référence pointe toujours sur $v
foreach($val as $k => $v) $criteres_requete[$k] = $val->$k;
}
 
/* Fonction finale du tryptique: réordonne les valeurs obtenues auprès du web-service
NVJFL en adéquation avec les champs attendus en sortie.
Dès l'indexation des critères, nous avons associé une (ou plusieurs) référence(s) du
tableau de résultats vers le tableau de retour des ontologies à l'aide d'un index
particulier l'index SPE_INDEX_NVJFL qui contient comme élément(s)
un ou plusieurs ontologies (les indexes de self::$champ_infos) qui elles-mêmes contiennent
une ou plusieurs valeurs représentant les valeurs recherchées appartement à cette ontologies.
Celui-ci est supprimé après avoir été correctement copié. */
/**
* @param array in/out $resultats: tous les résultats
* @param array in $critere: tableau des ontologies:valeur demandées, de la forme [ numStatut:1, genreNombre:11, ... ]
*/
static function NvjflOntologieCombine(&$resultats) {
foreach($resultats as &$resultat) {
if(!array_key_exists(SPE_INDEX_NVJFL, $resultat)) continue;
 
/* Note: la complétude d'un résultat peut dépendre de plusieurs ontologies différentes,
d'où cette boucle. Cependant une seule valeur sera demandé pour cette ontologie, c'est pourquoi
$resultat[SPE_INDEX_NVJFL][$onto_name], s'il existe, ne contiendra toujours qu'un seul élément.
Puisque par définition un résultat contenant des valeurs d'ontologie n'aura jamais qu'un seul et unique
attribut num_genre (ou num_statut, ou autre) */
foreach(self::$onto_multi_support as $onto_name) {
if(!array_key_exists($onto_name, $resultat[SPE_INDEX_NVJFL])) continue;
 
/* $onto_name est un nom d'ontologie (l'une des clefs, parmi conseil_emploi et genre,
cf la boucle sur $champs_sup dans NvjflOntologieIndex()
de cet extract() nous n'utilisons que $intitule et $nom */
extract(self::$champ_infos[$onto_name]);
 
// equivalent de l'affectation finale de chercherSignificationCode()
// (utilisé lors de recherches d'ontologies en mono-critère)
// XXX: PHP-5.3 pas de récupération d'attribut sur fonction
$r = current($resultat[SPE_INDEX_NVJFL][$onto_name]);
$resultat[$intitule] = $r->$nom;
 
// XXX: certes nous pourrions nous contenter du unset() final
unset($resultat[SPE_INDEX_NVJFL][$onto_name]);
}
unset($resultat[SPE_INDEX_NVJFL]);
}
}
 
/**
* Ajoute les champs d'ontologie supplémentaires si necéssaire
* en faisant appels aux web services associés
* @param array $ligne_resultat
*
* @return array la ligne modifiée
*/
public function ajouterChampsOntologieLigneResultat($ligne_resultat) {
foreach(self::$champ_infos as $cle => $champs_supplementaires) {
if(!in_array($cle, $this->champs_supp)) continue;
// extrait, depuis un élément de $champ_infos:
// $service, $ressource, $projet, $nom, $intitule, $bdd_champ
extract($champs_supplementaires);
$valeur_recherche = $ligne_resultat[$bdd_champ];
if(!trim($valeur_recherche)) continue;
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur_recherche, $projet);
$ligne_resultat[$intitule] = $this->chercherSignificationCode($url, $nom);
}
return $ligne_resultat;
}
/**
* Fonction qui ajoute les attributions à une ligne de résultats
*
* @param array $ligne_tableau_resultat
* @param array $nom_sci
*/
public function ajouterTaxonsAttributionsLigneResultat(&$ligne_tableau_resultat, &$noms_sci) {
if (isset($noms_sci[$ligne_tableau_resultat['num_taxon']])) {
$ligne_tableau_resultat['nom_retenu.code'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['id'];
$ligne_tableau_resultat['taxon'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['nom_sci'];
} else {
$ligne_tableau_resultat = null;
}
return $ligne_tableau_resultat;
}
private function trierLigneTableau($a, $b) {
$retour = 0;
if ($a[$this->champ_tri] == $b[$this->champ_tri]) {
$retour = 0;
}
if($this->champ_tri == 'code_langue') {
if ($a[$this->champ_tri] == 'fra' && $b[$this->champ_tri] != 'fra') {
$retour = ($this->direction_tri == 'asc') ? -1 : 1;
} else if ($a[$this->champ_tri] != 'fra' && $b[$this->champ_tri] == 'fra') {
$retour = ($this->direction_tri == 'asc') ? 1 : -1;
} else {
$retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]);
}
} else {
$retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]);
}
return $retour;
}
private function comparerChaineSelonDirectionTri($a, $b) {
if($this->direction_tri == 'asc') {
return ($a < $b) ? -1 : 1;
} else {
return ($a > $b) ? -1 : 1;
}
}
// formatage de la reponse /id ss la forme
// id, nom_vernaculaire, attributions
// langue
// num_nom (correspond à un taxon bdtfx)
public function formaterNomsVernaculairesId($resultat) {
foreach ($resultat as $taxon) { // pour chaque attribution à un taxon bdtfx
// on crée les variables qui serviront de clés et on les enléves du tableau
$num_nom = $taxon['num_nom_vernaculaire']; // unique pour un trinôme id, langue, taxon
unset($taxon['num_nom_vernaculaire']);
$langue = $taxon['code_langue'];
unset($taxon['code_langue']);
 
foreach ($this->correspondance_champs as $key => $correspondance) { // ordonne les infos pour affichage
if (isset($taxon[$key]) && $taxon[$key] != "") {
$this->afficherDonnees($correspondance, $taxon[$key], $langue, $num_nom);
}
}
foreach ($taxon as $key => $valeur) { // rajoute les champs non prévus dans l'api
if (!isset($this->correspondance_champs[$key]) && $valeur != "") {
$this->afficherDonnees($key, $valeur, $langue, $num_nom);
}
}
if ($this->retour_format == 'max') $this->chargerBiblio($num_nom, $langue);
}
if ($this->retour_format == 'max') $this->afficherTaxons(); // va chercher les noms de tous les taxons
unset($this->table_retour['href']);
return $this->table_retour;
}
 
public function afficherDonnees($champ, $valeur, $langue = '', $num_nom = '') {
if ($champ == 'id' || $champ == 'nom_vernaculaire') {
$this->table_retour[$champ] = $valeur;
} elseif (preg_match('/^(.*)\.code$/', $champ, $match)) {
switch ($match[1]) {
case 'taxon' : if ($this->retour_format == 'max') {$this->taxons[$num_nom] = $valeur;}
$this->afficherPointCode($match[1], $langue, $num_nom, $valeur); break;
case 'langue' : //$this->afficherPointCode($match[1], 'iso-639-3', 'langues', $valeur);
break;
case 'genre' : $this->afficherPointCode($match[1], $langue, $num_nom, $valeur); break;
case 'conseil_emploi' : $this->afficherPointCode($match[1], $langue, $num_nom, $valeur); break;
default : break;
}
 
} elseif ($langue != '') {
$this->table_retour['attributions'][$langue][$num_nom][$champ] = $valeur;
} else {
$this->table_retour[$champ] = $valeur;
}
}
 
public function afficherPointCode($nomChamp, $langue, $num_nom, $valeur) {
if (isset(self::$champ_infos[$nomChamp])) {
extract(self::$champ_infos[$nomChamp]);
}
 
if ($this->retour_format == 'max') {
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet);
if ($service == 'taxons') {
$code_valeur = '';
$this->table_retour['attributions'][$langue][$num_nom]['nom_retenu.code'] = $code_valeur;
} else {
$code_valeur = $this->chercherSignificationCode($url, $nom);
}
if ($projet != '') $projet .= '.';
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp] = $code_valeur;
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.href'] = $url;
} else {
if ($projet != '') $projet .= '.';
$this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur;
}
}
 
public function chercherSignificationCode($url, $nom) {
if (isset($this->signification_code[$url])) {
$valeur = $this->signification_code[$url];
} else {
$res = $this->consulterHref($url);
$valeur = $res->$nom;
$this->signification_code[$url] = $valeur;
}
return $valeur;
}
 
public function afficherTaxons() {
$resultat = $this->recupererNomTaxons();
foreach ($this->table_retour['attributions'] as $code_langue=>$langue) {
foreach ($langue as $num_nom=>$taxon) {
$num_tax = ltrim($taxon['taxon.code'], 'bdtfx.nt:');
if (isset($resultat[$num_tax])) {
$this->table_retour['attributions'][$code_langue][$num_nom]['nom_retenu.code'] = $resultat[$num_tax]['id'];
$this->table_retour['attributions'][$code_langue][$num_nom]['taxon'] = $resultat[$num_tax]['nom_sci'];
}
}
}
}
public function recupererNomTaxons() {
$taxons = array_unique($this->taxons);
$url = Config::get('url_service_base').'bdtfx/taxons?navigation.limite=500&ns.structure=au&masque.nt='.implode(',', $taxons);
$res = $this->consulterHref($url);
foreach ($res->resultat as $id=>$taxon) {
$resultat[$taxon->num_taxonomique]['id'] = 'bdtfx.nn:'.$id;
$resultat[$taxon->num_taxonomique]['nom_sci'] = $taxon->nom_sci_complet;
}
return $resultat;
}
 
public function formaterNomsVernaculairesIdChamp($resultat) {
$this->table_retour['id'] = $this->ressources[0];
$champs = explode(' ', $this->ressources[1]);
if (in_array('attributions', $champs) != false) {
$this->formaterNomsVernaculairesId($resultat);
unset($this->table_retour['nom_vernaculaire']);
} else {
$champ_attributions = array('num_taxon', 'zone_usage', 'num_statut', 'num_genre', 'notes');
foreach ($resultat as $taxon) {
foreach ($taxon as $key=>$valeur) {
if ($key == 'code_langue' && in_array('langue', $champs) != false) {
$this->table_retour['attributions']['langue'][] = $valeur;
} elseif (in_array($key, $champ_attributions) != false) {
$this->afficherPoint($this->correspondance_champs[$key] , $valeur, $taxon['code_langue'], $taxon['num_nom_vernaculaire']);
} elseif (in_array($key, $champs) != false) {
$this->table_retour[$key] = $valeur;
}
}
if (in_array('biblio', $champs) != false) $this->chargerBiblio($taxon['num_nom_vernaculaire'], $taxon['code_langue']);
}
if (in_array('biblio', $champs) != false && array_search('biblio.num_ref', $this->table_retour) != false) $this->table_retour['biblio'] = null;
}
return $this->table_retour;
}
 
public function afficherPoint($champ, $valeur, $langue, $num_nom) {
preg_match('/^(.*)\.code$/', $champ, $match);
$champ = $match[1];
if (isset(self::$champ_infos[$champ])) {
extract(self::$champ_infos[$champ]);
$url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet);
$projet .= '.';
}
 
$champs = explode(' ', $this->ressources[1]);
if (in_array($champ.'.*', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url;
}
if (in_array($champ.'.code', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur;
}
if (in_array($champ.'.href', $champs) !== false && isset($projet)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url;
}
if (in_array($champ, $champs) !== false) {
if (isset($url)) {
$this->table_retour['attributions'][$langue][$num_nom][$champ] = $this->chercherSignificationCode($url, $nom);
} else {
$this->table_retour['attributions'][$langue][$champ] = $valeur;
}
}
}
 
public function afficherLangue($nomChamp, $projet, $service, $valeur, $ressource = '', $nom = 'nom') {
if ($this->retour_format == 'max') {
$this->table_retour['attributions'][$nomChamp] = $nom;
$this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur;
$this->table_retour['attributions'][$nomChamp.'.href'] = $url;
} else {
$this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur;
}
}
 
public function chargerBiblio($num_nom, $langue) {
list($table, $version) = explode('_v',$this->table);
$requete = "SELECT b.*, lb.notes FROM nvjfl_lien_biblio_v$version lb, nvjfl_biblio_v$version b ".
"WHERE b.num_ref = lb.num_ref AND lb.num_nom = '$num_nom' ;";
$resultat = $this->getBdd()->recupererTous($requete);
 
if ($resultat == '') { //cas ou la requete comporte des erreurs
$r = 'La requête SQL formée comporte une erreur !!';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r);
Debug::printr($requete);
} elseif ($resultat) {
foreach ($resultat as $res) {
foreach ($res as $cle => $valeur) {
if ($valeur !== "") {
$this->table_retour['attributions'][$langue][$num_nom]['biblio.'.$cle] = $valeur;
}
}
}
}
}
 
}
?>
/tags/v0.1-20130830-1/services/modules/0.1/lion1906/NomCommune.php
New file
0,0 → 1,143
<?php
// declare(encoding='UTF-8');
/**
* Classe permettant d'obtenir le nom et le code INSEE des communes les plus proches d'un point (latitude et longitude).
* La latitude et longitude doivent être exprimée par un nombre décimal.
* Ce service fonctionne uniquement sur les communes de France métropolitaine (Corse comprise) présentent
* dans les données Lion1906 téléchargeable à cette adrese : http://www.lion1906.com/Pages/francais/utile/telechargements.html.
* Source des données : Lion1906.com http://www.lion1906.com
* Paramètres du service :
* - lat : latitude
* - lon : longitude
* Exemple :
* http://localhost/lion1906/services/0.1/nom-commune?lat=44.71546&lon=3.84216
*
* @category php 5.2
* @package lion1906
* @author Mohcen BENMOUNAH <mohcen@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class NomCommune {
 
const PATTERN_LAT = '/^[0-9]+(?:[.][0-9]+|)$/';
const PATTERN_LON = '/^[-]?[0-9]+(?:[.][0-9]+|)$/';
const LAT_MAX = 51.071667;
const LAT_MIN = 41.316667;
const LON_MAX = 9.513333;
const LON_MIN = -5.140278;
const NBRE_COMMUNE_PAR_DEFAUT = 10;
const NBRE_COMMUNE_MAX = 100;
const MIME_JSON = 'application/json';
 
private $parametres = array();
private $ressources = array();
private $bdd = null;
 
public function __construct(Bdd $bdd) {
$this->bdd = $bdd;
}
 
public function consulter($ressources, $parametres) {
$this->parametres = $parametres;
$this->ressources = $ressources;
 
$this->definirParametresParDefaut();
$this->verifierParametres();
 
$nomINSEEs = $this->trouverCommunesProches();
$corps = $this->formaterResultats($nomINSEEs);
 
$resultat = new ResultatService();
$resultat->mime = self::MIME_JSON;
$resultat->corps = $corps;
return $resultat;
}
 
private function definirParametresParDefaut() {
if (array_key_exists('nbre', $this->parametres) === false) {
$this->parametres['nbre'] = self::NBRE_COMMUNE_PAR_DEFAUT;
}
}
 
private function verifierParametres() {
extract($this->parametres);
$messages = array();
if (! array_key_exists('lat', $this->parametres)) {
$messages[] = "Vous devez indiquer une latitude en degré décimal à l'aide du paramètres d'url : lat";
} else if (!preg_match(self::PATTERN_LAT, $lat)) {
$messages[] = "La valeur de latitude doit être un nombre décimal positif dont le séparateur décimal est un point. Ex. : 44 ou 43.03";
} else if ($lat > self::LAT_MAX) {
$messages[] = "La valeur de latitude indiquée est supérieure à {self::LAT_MAX} qui est le point le plus au Nord de la France métropolitaine.";
} else if ($lat < self::LAT_MIN) {
$messages[] = "La valeur de latitude indiquée est infèrieure à {self::LAT_MIN} qui est le point le plus au Sud de la France métropolitaine.";
}
if (! array_key_exists('lon', $this->parametres)) {
$messages[] = "Vous devez indiquer une longitude en degré décimal à l'aide du paramètres d'url : lon";
} else if (!preg_match(self::PATTERN_LON, $lon)) {
$messages[] = "La valeur de longitude doit être un nombre décimal dont le séparateur décimal est un point. Ex. : -4.03 ou 3.256";
} else if ($lon > self::LON_MAX) {
$messages[] = "La valeur de longitude indiquée est supérieure à {self::LON_MAX} qui est le point le plus à l'Est de la France métropolitaine.";
} else if ($lon < self::LON_MIN) {
$messages[] = "La valeur de longitude indiquée est infèrieure à {self::LON_MIN} qui est le point le plus à l'Ouest de la France métropolitaine.";
}
if (array_key_exists('nbre', $this->parametres)) {
if (!preg_match('/^[0-9]+$/', $nbre)) {
$messages[] = "Le nombre de commune le plus proche à retourner doit être un entier positif. Ex. : 10";
} else if ($nbre > self::NBRE_COMMUNE_MAX) {
$messages[] = "Le nombre de commune le plus proche à retourner doit être un entier positif inférieur à 100. Ex. : 10";
}
}
 
if (count($messages) != 0) {
$message = implode('<br />', $messages);
$code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE;
throw new Exception($message, $code);
}
}
 
private function formaterResultats($nomINSEEs) {
$communes_trouvees = null;
if (isset($nomINSEEs) && !empty($nomINSEEs)) {
foreach ($nomINSEEs as $nomINSEE) {
$communes_trouvees[] = array('nom' => $nomINSEE['nom'], 'codeINSEE' => $nomINSEE['insee']);
}
if (!is_null($communes_trouvees)) {
if ($this->parametres['nbre'] == 1 && count($communes_trouvees) == 1) {
$communes_trouvees = $communes_trouvees[0];
}
} else {
$message = "Le service '".get_class($this)."' n'a trouvé aucune commune correspondant aux coordonnées : {$parametres['lat']}, {$parametres['lon']}.";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
} else {
$message = "Le service '".get_class($this)."' n'a trouvé aucune commune dont le centroïde correspond aux coordonnées : {$parametres['lat']}, {$parametres['lon']}.";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
return $communes_trouvees;
}
 
/**
* requête qui récupère les 20 communes les plus proches du point recherché
* La distance(AB = \sqrt{(x_B-x_A)^2 + (y_B-y_A)^2}) est calculée sans la racine
* (calcul en plus qui change pas le résultat).
*/
private function trouverCommunesProches() {
$lat = $this->parametres['lat'];
$lon = $this->parametres['lon'];
$requete = 'SELECT '.
" (({$lat} - X(centroide)) * ({$lat} - X(centroide)) + ({$lon} - Y(centroide)) * ({$lon} - Y(centroide))) AS distance, ".
"insee, nom ".
'FROM lion1906_communes_v2008 '.
'ORDER BY distance '.
"LIMIT {$this->parametres['nbre']} ";
$resultat = $this->bdd->recupererTous($requete);
return $resultat;
}
}
?>
/tags/v0.1-20130830-1/services/modules/0.1/moissonnage/Cartes.php
New file
0,0 → 1,230
<?php
 
/**
* Classe qui remplit un fond cartographique SVG a partir des observations en base de donnees
* pour un taxon de plante. Elle verifie dans un premier temps la validite des parametres saisis,
* puis charge le fond cartographique depuis le fichier, recupere dans la base de donnees
* les observations sur la France metropolitaine pour le taxon donne et remplit la carte
* en changeant le style CSS des mailles en fonction des coordonnees des points d'observation.
* Le format et la taille de la carte renvoyee au client est parametrable.
*
* Parametres :
* - referentiel : le referentiel taxonomique a interroger pour verifier le taxon. Pour l'instant,
* seul bdtfx (Tracheophytes de France metropolirtaine) est utilise par le web service
* - num_taxon : le numero taxonomique de la plante dont on veut obtenir la carte de repartition.
* Le rang des taxons traites par le web service sont la famille, le genre, l'espece et la sous-espece.
* La recherche des observations s'etend en pus sur les sous taxons et les synonymes.
* - source : une ou plusieurs sources de donnees a interroger. Si le parametre n'est pas indique,
* le web service ira rechercher les observatipons dans toutes les sources de donnees.
* - format : la largeur de la carte, exprimee dans une valeur entiere en pixels.
* Le ratio largeur:hauteur est conserve lors du redimensionnement de la carte pour le retour
* - retour : le type MIME (ou format de fichier) de retour. Sont acceptes par le web service
* le PNG (image/png) et le XML (text/html) pour renvoyer le web service
*
* @package framework-0.4
* @author Alexandre GALIBERT <alexandre.galibert@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $Id$
* @copyright 2013 Tela Botanica (accueil@tela-botanica.org)
*
*/
 
class MoissonnageCartes {
 
const MIME_MAP = "text/html";
const MIME_PNG = "image/png";
private $ressources;
private $parametres;
private $referentiel = '';
private $taxon = null;
private $sources = array();
private $format = 0;
private $retour = self::MIME_MAP;
private $erreurs = array();
public function consulter($ressources, $parametres) {
$this->parametres = $parametres;
$this->ressources = $ressources;
$resultat = null;
$this->chargerClassesSousDossier();
if ($this->analyserRessources() == true) {
$resultat = $this->formerLegende();
} else {
$this->traiterParametres();
$resultat = $this->formerCarte();
}
return $resultat;
}
private function analyserRessources() {
$ok = false;
if (isset($this->ressources[0]) && $this->ressources[0] == 'legende') {
$ok = true;
}
return $ok;
}
private function formerLegende() {
$legende = new LegendeCartes();
$resultat = $legende->obtenirLegende();
return $resultat;
}
private function chargerClassesSousDossier() {
$this->verifierExistenceDossier("cartes");
$nomDossier = dirname(__FILE__).DS."cartes";
$dossier = opendir($nomDossier);
$fichiersAInclure = array();
while ($fichier = readdir($dossier)) {
if (filetype($nomDossier.DS.$fichier) == 'file') {
$fichiersAInclure[] = $nomDossier.DS.$fichier;
}
}
$fichiersAInclure = array_reverse($fichiersAInclure);
foreach ($fichiersAInclure as $fichier) {
include_once($fichier);
}
}
private function verifierExistenceDossier($nomDossier) {
$dossier = dirname(__FILE__).DS.$nomDossier;
if (!file_exists($dossier) || !is_dir($dossier)) {
$message = "Problème rencontré lors de la génération de la carte : des ressources ".
"nécessaires au fonctionnement du service n'ont pas été localisées sur le serveur.\n";
throw new Exception($message);
}
}
private function verifierExistenceFichier($nomFichier) {
if (!file_exists($nomFichier)) {
$message = "Problème rencontré lors de la génération de la carte : des ressources ".
"nécessaires au fonctionnement du service n'ont pas été localisées sur le serveur.\n";
throw new Exception($message);
}
}
private function traiterParametres() {
$this->verifierReferentielEtTaxon();
$this->verifierParametreSource();
$this->verifierParametreFormat();
$this->verifierParametreRetour();
if (count($this->erreurs) > 0) {
$this->renvoyerErreurs();
}
}
private function verifierParametreFormat() {
if (!isset($this->parametres['format'])) {
$this->erreurs[] = "Le paramètre format (dimensions) de l'image n'a pas été indiqué dans l'URL du service.";
} elseif (preg_match('/^[1-9]\d{2}$/', $this->parametres['format']) != 1) {
$this->erreurs[] = "La valeur du paramètre format n'est pas acceptée par le service. ".
"Une largeur valide doit être un nombre entier compris entre 100 et 999.";
} else {
$this->format = $this->parametres['format'];
}
}
private function verifierParametreRetour() {
$typesMime = array(self::MIME_MAP, self::MIME_PNG);
if (!isset($this->parametres['retour'])) {
$this->erreurs[] = "Le paramètre type de retour de l'image n'a pas été indiqué dans l'URL du service.";
} elseif (!in_array($this->parametres['retour'], $typesMime)) {
$this->erreurs[] = "Le format de retour ".$this->parametres['retour']." n'est pas acceptée par le service. ".
" Seuls les types MIME suivants sont gérés : ".implode(',', $typesMime);
} else {
$this->retour = $this->parametres['retour'];
}
}
private function verifierParametreSource() {
$sourcesDisponibles = explode(',', trim(Config::get('sourcesDonnees')));
if (isset($this->parametres['source'])) {
$sourcesParametre = explode(',', trim($this->parametres['source']));
foreach ($sourcesParametre as $source) {
if (!in_array($source, $sourcesDisponibles)) {
$this->erreurs[] = "La source de données $source n'est pas disponible pour ce service. ".
"Les sources suivantes sont utilisables : ".implode(',', $sourcesDisponibles).".";
} else {
$this->sources[] = $source;
}
}
} else {
$this->sources = $sourcesDisponibles;
}
}
private function verifierReferentielEtTaxon() {
if (!$this->estReferentielDisponible()) {
$this->erreurs[] = "Le référentiel ".$this->parametres['referentiel']." n'a pas été trouvé. ".
"La liste des référentiels disponibles pour ce service sont : ".Config::get('referentielsDispo');
} else {
$this->referentiel = $this->parametres['referentiel'];
$taxon = $this->recupererInformationsTaxon();
if (is_null($taxon)) {
$this->erreurs[] = "Le taxon d'espèce que vous avez demandé n'a pas été trouvé dans le référentiel.";
} else {
$this->taxon = $taxon;
}
}
}
private function renvoyerErreurs() {
$message = "Les erreurs suivantes ont été rencontrées : \n".implode('\n', $this->erreurs);
throw new Exception($message, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
private function estReferentielDisponible() {
$referentielsDispo = explode(',', Config::get('referentielsDispo'));
$estDisponible = (isset($this->parametres['referentiel'])
&& in_array($this->parametres['referentiel'], $referentielsDispo));
return $estDisponible;
}
private function recupererInformationsTaxon() {
$taxon = null;
if (isset($this->parametres['num_taxon'])) {
$numTaxon = $this->parametres['num_taxon'];
$nomTable = $this->recupererNomTableReferentiel();
$bdd = new Bdd();
$requete = "SELECT num_nom, num_nom_retenu, nom_sci, rang, num_taxonomique FROM {$nomTable} ".
"WHERE num_taxonomique={$numTaxon} ORDER BY If(num_nom=num_nom_retenu,0,1) LIMIT 0,1";
$taxon = $bdd->recuperer($requete);
if ($taxon === false) {
$taxon = null;
}
}
return $taxon;
}
private function recupererNomTableReferentiel() {
$tablesReferentiel = explode(',', Config::get('bdd_table_referentiel'));
$nomTable = '';
foreach ($tablesReferentiel as $table) {
if (strstr($table, $this->referentiel) !== false) {
$nomTable = $table;
}
}
return $nomTable;
}
private function formerCarte() {
$suffixe = 'france_moissonnage';
$nomFichierSVG = Config::get('chemin')."{$suffixe}.svg";
$this->verifierExistenceFichier($nomFichierSVG);
$formateur = new FormateurSVG($nomFichierSVG, $this->sources, $this->retour, $this->format);
$formateur->formaterCarte($this->taxon);
$resultat = new ResultatService();
$resultat->corps = $formateur->renvoyerCarte();
$resultat->mime = $this->retour;
 
return $resultat;
}
}
 
?>
/tags/v0.1-20130830-1/services/modules/0.1/moissonnage/Ontologies.php
New file
0,0 → 1,366
<?php
/**
* Description :
* Classe Ontologies.php fournit des informations sur ensemble structuré des termes et concepts représentant les éléments
* d'un domaine de connaissances .
* Le but étant de fournir un ensemble minimal d'information comprenant :
* un identifiant (numérique ou alphanumérique sous forme de ChatMot si possible), un nom, une description et
* éventuellement une relation hiérarchique avec un autre terme (=classe).
* Si l'url finit par /ontologies on retourne une liste de termes (seulement les 100 premières par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /ontologies?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.description , recherche,
* distinct, retour.format, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package eflore-projets
* @author Jennifer DHÉ <jennifer.dhe@tela-botanica.org>
* @author Delphine CAUQUIL <delphine@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 0.1
* @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org)
*/
class MoissonnageOntologies extends Commun {
 
protected $requete_condition = null; //Représente la partie de la requete SQL ajoutant une condition (WHERE ...)
/** Permet de stocker la requete formulée: /ontologies | /ontologies/#id | /ontologies/#id/champ | /ontologies/#id/relations */
protected $format_reponse = 'ontologies';
/** Permet de stocker les limite de la requete SQL (par défaut seul les 100 premiers résultats seront retournés).
* Stocke également les valeurs des paramètres navigation.depart et navigation.limite passés dans la requete*/
protected $limite_requete = array( 'depart' => 0, 'limite' => 100);
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */
protected $total_resultat;
protected $retour_format = 'max';
 
public function consulter($ressources, $parametres) {
$this->ressources = $ressources;
$this->parametres = $parametres;
$this->service = 'ontologies';
$this->traiterParametres();
$resultats = '';
$this->table = 'eflore_ontologies'; //on stocke le nom de la table correspondant à la version du projet en cours
$this->recupererNomChamp($this->table); //on récupère les noms des champs disponibles (Ds Commun.php)
$this->traiterRessources(); //dans CommunNomsTaxons.php
$requete = $this->assemblerLaRequete();
$resultat = $this->getBdd()->recupererTous($requete);
$versionResultat = $this->traiterResultat($resultat, '', $requete);
$resultats = $versionResultat;
return $resultats;
}
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres)) {
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'masque' : $this->ajouterLeFiltreMasque('masque', $valeur); break;
case 'masque.code' : $this->ajouterLeFiltreMasque('code', $valeur); break;
case 'masque.nom' : $this->ajouterLeFiltreMasque('nom', $valeur); break;
case 'masque.description' : $this->ajouterLeFiltreMasque('description', $valeur); break;
case 'retour.format' : $this->retour_format = $valeur; break;
case 'retour.champs' : break;
case 'navigation.depart' : $this->limite_requete['depart'] = $valeur; break;
case 'navigation.limite' : $this->limite_requete['limite'] = $valeur; break;
case 'recherche' : break;
case 'version.projet' : break;
default :
$e = 'Erreur dans les parametres de recherche de votre requête : </br> Le paramètre " '
.$param.' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break;
}
}
}
}
 
public function ajouterLeFiltreMasque($nom_champ, $valeur) {
if ($nom_champ == 'code') {
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] == 'floue') {
if ($nom_champ == 'masque') {
$this->requete_condition[] = '( code = '.$this->getBdd()->proteger($valeur)
.' OR ( SOUNDEX(nom) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(nom)) = SOUNDEX(REVERSE(\''.$valeur.'\')) '
.') OR ( SOUNDEX(description) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(description)) = SOUNDEX(REVERSE(\''.$valeur.'\')) ))';
} else {
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\')))';
}
} else {
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] == 'etendue') {
$valeur = str_replace(' ','%', $valeur);
$valeur .= '%';
}
if ($nom_champ == 'masque') {
$this->requete_condition[] = '(code = '.$this->getBdd()->proteger($valeur)
.' OR nom LIKE '.$this->getBdd()->proteger($valeur)
.' OR description LIKE '.$this->getBdd()->proteger($valeur).')';
} else {
$this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur);
}
}
}
}
 
 
public function traiterRessources() {
if (isset($this->ressources) && !empty($this->ressources)) {
if (isset($this->ressources[0]) && !empty($this->ressources[0])) {
//requete = /ontologies/#id
$this->traiterRessourceId();
if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
//requete = /ontologies/#id/relations
$this->traiterRessourceRelations();
}
}
}
}
 
 
public function traiterRessourceId() {
$this->requete_condition = array();
//requete : /ontologies/#id (ex : /ontologies/7)
if (is_numeric($this->ressources[0])) {
$this->requete_condition[] = ' id = '.$this->getBdd()->proteger($this->ressources[0]);
$this->format_reponse .= '/id';
//requete : /ontologies/#classe:#code (ex : /ontologies/rangTaxo:290)
} elseif (strrpos($this->ressources[0], ':') !== false) {
$this->format_reponse .= '/id';
preg_match('/^([^:]+):([^:]+)$/', $this->ressources[0], $match);
$this->requete_condition[] =
' id = (SELECT id FROM '.$this->table.' WHERE code = '.$this->getBdd()->proteger($match[2])
.' AND classe_id = (SELECT id FROM '.$this->table.' WHERE code = '.$this->getBdd()->proteger($match[1]).'))';
} else {
$e = 'Erreur dans les paramètres de recherche de votre requête : </br> Le paramètre " '
.$this->ressources[0].' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
}
 
 
public function traiterRessourceRelations() {
//requete = /ontologies/#id/relations :
if ($this->ressources[1] == 'relations') {
$this->format_reponse .= '/relations';
$this->requete_condition = array('classe_id = (SELECT classe_id FROM '.$this->table.' WHERE '
.implode(' AND ', $this->requete_condition).')');
}
}
 
//+--------------------------FONCTION ASSEMBLAGE DE LA REQUETE-------------------------------------------+
 
public function assemblerLaRequete() {
$requete = ' SELECT '.$this->formerRequeteChamp().
' FROM '.$this->table
.$this->retournerRequeteCondition()
.$this->formerRequeteLimite(); //print_r($requete);
return $requete;
}
 
public function formerRequeteChamp() {
$champ[] = 'id';
if ($this->format_reponse == 'ontologies') {
$champ[] = 'nom, code ';
}
if (isset($this->parametres['retour_champs']) || $this->format_reponse == 'ontologies/id/champs') {
$champs_recherches = explode(',', $this->parametres['retour_champs']);
$champs_possibles = $this->rechercherChampsPossibles();
foreach ($champs_recherches as $champ_recherche) {
if ($this->verifierValiditeChamp($champ_recherche)) {
$champ[] = (preg_match('/classe/', $champ_recherche)) ? 'classe_id' : $champ_recherche;
}
}
}
if (count($champ) == 1) {
$champ = array(' * ');
}
return implode(', ', $champ);
}
 
public function rechercherChampsPossibles() {
$this->recupererNomChamp($this->table);
$champs_possibles = $this->champs_table;
$champs_possibles[] = 'classe.id';
$champs_possibles[] = 'classe';
$champs_possibles[] = 'classe.href';
return $champs_possibles;
}
 
public function verifierValiditeChamp($champ, $champs_possibles) {
$validite = false;
preg_match('/^([^.]+)(:?\.([^.]+))?$/', $champ, $match);
if (in_array($match[1], $champs_possibles)) {
$validite = true;
} else {
$champs = implode('</li><li>', $champs_possibles);
$e = 'Erreur dans votre requête : </br> Le champ "'.$champ
.'" n\'existe pas. Les champs disponibles sont : <li>'.$champs.'</li>';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e);
}
return $validite;
}
 
public function retournerRequeteCondition() {
$condition = '';
if ($this->requete_condition !== null) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
public function formerRequeteLimite() {
$this->total_resultat = $this->recupererTotalResultat();
if (in_array($this->format_reponse , array('textes/id', 'textes/id/relations'))) {
$this->requete_limite = '';
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat)) {
$this->limite_requete['depart'] =
(($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']);
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
} else {
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
}
return $this->requete_limite;
}
 
 
public function recupererTotalResultat() {
//on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /ontologies)
$requete = 'SELECT count(*) as nombre FROM '.$this->table.' '
.$this->retournerRequeteCondition();
$res = $this->getBdd()->recuperer($requete);
if ($res) {
$total = $res['nombre'];
} else {
$e = 'Données introuvables dans la base';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
Debug::printr($requete);
}
return $total;
}
 
//+------------------------------------------------------------------------------------------------------+
public function retournerResultatFormate($resultat) {
// determine en fct du service appelé (/ontologies | /ontologies/#id | /ontologies/#id/champ |
// /ontologies/#id/relations) le format du tableau à retourner. Encode en json
switch ($this->format_reponse) {
case 'ontologies' : $reponse = $this->formaterOntologies($resultat); break;
case 'ontologies/id' : $reponse = $this->formaterOntologiesId($resultat[0]); break;
case 'ontologies/id/relations' : $reponse = $this->formaterOntologiesIdRelations($resultat); break;
default : break;
}
return $reponse;
}
 
 
public function formaterOntologies($resultat) {
$this->ajouterEnteteResultat($resultat);
$table_retour_json['entete'] = $this->ajouterEnteteResultat($resultat);
if (isset($this->parametres['masque_code']) || isset($this->parametres['masque'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque_code'], $resultat, 'code');
} elseif (isset($this->parametres['masque_nom'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque_nom'], $resultat, 'nom');
} elseif (isset($this->parametres['masque_description'])) {
$resultat = $this->trierRechercheFloue($this->parametres['masque_description'], $resultat, 'description');
}
//on remplit la table $table_retour_json['resultat']
foreach ($resultat as $tab) {
$num = $tab['id'];
unset($tab['id']);
foreach ($tab as $param => $valeur) {
$resultat_json[$num][$param] = $valeur;
}
if ($this->retour_format == 'max') $resultat_json[$num]['href'] = $this->ajouterHref('ontologies', $num);
}
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
 
public function ajouterEnteteResultat($resultat) {
//on remplit la table $table_retour_json['entete']
$entete['depart'] = $this->limite_requete['depart'];
$entete['limite'] = $this->limite_requete['limite'];
$entete['total'] = $this->total_resultat;
//formuler les urls
$url = $this->formulerUrl($this->total_resultat, '/ontologies');
if (isset($url['precedent']) && $url['precedent'] != '') { $entete['href.precedent'] = $url['precedent']; }
if (isset($url['suivant']) && $url['suivant'] != '') { $entete['href.suivant'] = $url['suivant']; }
return $entete;
}
 
 
public function formaterOntologiesId($resultat) {
$table_retour = array();
foreach ($resultat as $key => $valeur) {
if ($valeur != '') {
$table_retour = array_merge($table_retour, $this->afficherDonnees($key, $valeur));
}
}
return $table_retour;
}
 
public function afficherDonnees($champ, $valeur) {
$retour[$champ] = $valeur;
if ($this->retour_format == 'max') {
if ($champ == 'classe_id') {
unset($retour[$champ]); // remplacer par classe.id
if ($valeur != "0") { // pas de parent
if (isset($this->parametres['retour_champs'])) {
switch ($this->parametres['retour_champs']) {
case 'classe' : $retour['classe'] = $this->ajouterClasseCorrespondante($valeur); break;
case 'classe.id' : $retour['classe.id'] = $valeur; break;
case 'classe.href' : $retour['classe.href'] = $this->ajouterHref('ontologies', $valeur); break;
case 'classe.*' : $retour['classe.id'] = $valeur; $retour['classe.href'] = $this->ajouterHref('ontologies', $valeur); break;
}
} else {
$nom_classe = $this->ajouterClasseCorrespondante($valeur);
if (isset($nom_classe)) $retour['classe'] = $nom_classe;
$retour['classe.id'] = $valeur;
$retour['classe.href'] = $this->ajouterHref('ontologies', $valeur);
}
}
}
}
return $retour;
}
 
/** Recherche par interrogation de la base, le nom de la classe à partir de son identifiant (classe.id) */
public function ajouterClasseCorrespondante($classe_id) {
$nom = null;
if ($classe_id != 0) {
$nom = '';
$req = 'SELECT nom FROM '.$this->table.' WHERE id = '.$this->getBdd()->proteger($classe_id);
$res = $this->getBdd()->recuperer($req);
if ($res) {
$nom = $res['nom'];
} else {
$e = "Données introuvables dans la table $this->table";
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e);
Debug::printr($req);
}
}
return $nom;
}
 
public function formaterOntologiesIdRelations($resultat) {
$retour = null;
if ($resultat != '') {
$retour['entete'] = $this->ajouterEnteteResultat($resultat);
//on remplit la table $table_retour_json['resultat']
foreach ($resultat as $tab) {
$num = $tab['id'];
$retour['resultat'][$num]['nom'] = $tab['nom'];
if ($this->retour_format == 'max') {
$retour['resultat'][$num]['href'] = $this->ajouterHref('ontologies', $num);
}
}
}
return $retour;
}
}
?>
/tags/v0.1-20130830-1/services/modules/0.1/moissonnage/cartes/SourceDonnees.php
New file
0,0 → 1,162
<?php
 
class SourceDonnees {
private $bdd = null;
private $limitesCarte = '';
private $taxon = array();
private $nomRang = '';
private $taxons = array();
private $genres = array();
public function __construct($limitesCarte, $taxon) {
$this->limitesCarte = $limitesCarte;
foreach ($this->limitesCarte as $bord => $valeur) {
$this->limitesCarte[$bord] = str_replace(",", ".", round($valeur, 6));
}
$this->bdd = new Bdd();
$this->taxon = $taxon;
$this->nomRang = $this->obtenirNomRang();
if ($this->nomRang == 'espece' || $this->nomRang == 'sous_espece') {
$this->taxons = $this->recupererSynonymesEtSousEspeces();
} elseif ($this->nomRang == 'famille') {
$this->genres = $this->recupererGenres();
}
}
private function obtenirNomRang() {
$nomsRangs = array('famille', 'genre', 'espece', 'sous_espece');
$rangs = explode(',', Config::get('rangs'));
for ($index = 0; $index < count($nomsRangs) && $rangs[$index] != $this->taxon['rang']; $index ++);
$position = $index == count($nomsRangs) ? count($nomsRangs)-1 : $index;
return $nomsRangs[$position];
}
protected function recupererSynonymesEtSousEspeces() {
$requete =
"SELECT num_nom, nom_sci, num_taxonomique FROM bdtfx_v1_01 WHERE hierarchie LIKE '%-{$this->taxon['num_nom']}-%' ".
"OR num_taxonomique = {$this->taxon['num_taxonomique']}";
return $this->bdd->recupererTous($requete);
}
protected function recupererGenres() {
$this->bdd->requeter("USE ".Config::get('bdd_nom'));
$requete =
"SELECT num_nom, nom_sci, num_taxonomique FROM bdtfx_v1_01 WHERE rang=220 AND num_tax_sup={$this->taxon['num_nom']}";
return $this->bdd->recupererTous($requete);
}
public function recupererStationsFloradata() {
$this->bdd->requeter("USE ".Config::get('bdd_nom_floradata'));
$requete =
"SELECT DISTINCTROW zone_geo AS commune, Date(date_observation) AS date, Floor(wgs84_latitude*10)/10 AS lat, ".
"Floor(wgs84_longitude*10)/10 AS lng, courriel_utilisateur AS auteur ".
"FROM cel_obs LEFT JOIN cel_zones_geo cz ON ce_zone_geo=id_zone_geo ".
"WHERE ".$this->construireWhereTaxonFloradata()." AND transmission=1 AND ".
"wgs84_longitude BETWEEN ".$this->limitesCarte['ouest']." AND ".$this->limitesCarte['est']." ".
"AND wgs84_latitude BETWEEN ".$this->limitesCarte['sud']." AND ".$this->limitesCarte['nord']." ".
"AND date_observation<>'0000-00-00 00-00-00' ORDER BY lat DESC, lng ASC, commune, date";
return $this->bdd->recupererTous($requete);
}
private function construireWhereTaxonFloradata() {
$criteres = array();
$nomRang = $this->obtenirNomRang($this->taxon);
if ($this->nomRang == 'famille') {
$criteres[] = "famille=".$this->bdd->proteger($this->taxon['nom_sci']);
} elseif ($this->nomRang == 'genre') {
$criteres[] = "nom_sel LIKE ".$this->bdd->proteger($this->taxon['nom_sci'].'%');
} else {
$taxons = array($this->taxon['num_taxonomique']);
foreach ($this->taxons as $sousTaxon) {
$taxons[] = $sousTaxon['num_taxonomique'];
}
$criteres[] = "nt IN (".implode(',', array_unique($taxons)) .")";
}
return "(".implode(' OR ',array_unique($criteres)).")";
}
public function recupererStationsMoissonnage($source) {
$this->bdd->requeter("USE ".Config::get('bdd_nom'));
$requete =
"SELECT DISTINCTROW lieu_commune_code_insee, observation_date AS date, observateur_nom_complet AS auteur ".
"FROM {$source}_tapir WHERE ".$this->construireWhereTaxonMoissonnage()." ".
"AND lieu_station_longitude BETWEEN ".$this->limitesCarte['ouest']." AND ".$this->limitesCarte['est']." ".
"AND lieu_station_latitude BETWEEN ".$this->limitesCarte['sud']." AND ".$this->limitesCarte['nord']." ".
"AND Length(lieu_commune_code_insee)=5 ORDER BY lieu_commune_code_insee, date";
$stations = $this->bdd->recupererTous($requete);
$this->rechercherInfosCommune($stations);
return $stations;
}
private function construireWhereTaxonMoissonnage() {
$nomRang = $this->obtenirNomRang();
$criteres = array();
$criteres[] = "nom_scientifique_complet LIKE ".$this->bdd->proteger($this->taxon['nom_sci']."%");
if ($this->nomRang == 'espece' || $this->nomRang == 'sous_espece') {
foreach ($this->taxons as $sousTaxon) {
$criteres[] = "nom_scientifique_complet LIKE ".$this->bdd->proteger($sousTaxon['nom_sci']."%");
}
} elseif ($this->nomRang == 'famille') {
foreach ($this->genres as $genre) {
$criteres[] = "nom_scientifique_complet LIKE ".$this->bdd->proteger($genre['nom_sci']."%");
}
}
return "(".implode(' OR ',array_unique($criteres)).")";
}
private function rechercherInfosCommune(& $stations) {
$codesInsee = array();
foreach ($stations as $station) {
$codeInsee = $station['lieu_commune_code_insee'];
if (substr($codeInsee, 0, 2) == '20') {
$codeInsee = '2A'.substr($codeInsee, 2);
$codeInsee2 = '2B'.substr($codeInsee, 2);
}
if (!in_array($codeInsee, $codesInsee)) {
if (substr($codeInsee, 0, 2) == '20') {
$codesInsee[] = "'$codeInsee2'";
}
$codesInsee[] = "'$codeInsee'";
}
}
$nomTableCommunes = Config::get('bdd_table_communes');
$requete =
"SELECT insee, nom AS commune, Floor(latitude_degre*10)/10 AS lat, Floor(longitude_degre*10)/10 AS lng ".
"FROM $nomTableCommunes WHERE insee IN (".implode(',', array_unique($codesInsee)).") ORDER BY insee";
$communes = $this->bdd->recupererTous($requete);
$indexStation = 0;
foreach ($communes as $commune) {
$codeInsee = $commune['insee'];
if (substr($codeInsee, 0, 2) == '2A' || substr($codeInsee, 0, 2) == '2B') {
$codeInsee = '20'.substr($codeInsee, 2);
}
while ($stations[$indexStation]['lieu_commune_code_insee'] < $codeInsee) {
$indexStation ++;
}
if ($stations[$indexStation]['lieu_commune_code_insee'] == $codeInsee) {
$stations[$indexStation]['lat'] = $commune['lat'];
$stations[$indexStation]['lng'] = $commune['lng'];
$stations[$indexStation]['commune'] = $commune['commune'];
}
}
$lat = array();
$lng = array();
foreach ($stations as $index => $station) {
if (!isset($station['lat'])) {
$station['lat'] = -100;
$station['lng'] = -100;
}
$lat[$index] = $station['lat'];
$lng[$index] = $station['lng'];
}
array_multisort($lat, SORT_DESC, $lng, SORT_ASC, $stations);
}
}
 
?>
/tags/v0.1-20130830-1/services/modules/0.1/moissonnage/cartes/FormateurSVG.php
New file
0,0 → 1,314
<?php
 
/**
* Classe qui genere la carte SVG pour les parametres de la requete qui a ete utilisee pour appeler
* le web service
*
* @package framework-0.4
* @author Alexandre GALIBERT <alexandre.galibert@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $Id$
* @copyright 2013 Tela Botanica (accueil@tela-botanica.org)
*
*/
 
 
class FormateurSVG {
private $documentXML;
private $coordonnees = array();
private $grille = null;
private $largeur = 0;
private $hauteur = 0;
private $typeMime = '';
private $format = 0;
private $sources = array();
private $image = null;
const ORIGINE = 20037508.342789244;
const MIME_MAP = 'text/html';
public function __construct($nomFichierSVG, $sources, $typeMime, $format) {
$this->chargerSVG($nomFichierSVG);
$this->chargerCoordonnees();
$this->construireParametresRetour($typeMime, $format);
$this->creerStyleSources();
$this->sources = $sources;
}
private function chargerSVG($nomFichierSVG) {
$this->documentXML = new DOMDocument("1.0", "UTF-8");
$this->documentXML->load($nomFichierSVG);
}
private function chargerCoordonnees() {
$viewbox = $this->recupererNoeuds('qgisviewbox');
$this->coordonnees = array(
'xMin' => $viewbox->attributes->getNamedItem('xMin')->value,
'xMax' => $viewbox->attributes->getNamedItem('xMax')->value,
'yMin' => $viewbox->attributes->getNamedItem('yMin')->value,
'yMax' => $viewbox->attributes->getNamedItem('yMax')->value
);
}
private function recupererNoeuds($nomCouche) {
$contenuSVG = $this->documentXML->documentElement->childNodes;
$noeudCouche = null;
$index = 0;
while ($index < $contenuSVG->length && is_null($noeudCouche)) {
$id = $contenuSVG->item($index)->attributes->getNamedItem('id');
if ($id->value == $nomCouche) {
$noeudCouche = $contenuSVG->item($index);
}
$index ++;
}
$noeuds = null;
if (!is_null($noeudCouche)) {
$noeuds = $noeudCouche->firstChild;
}
return $noeuds;
}
private function construireParametresRetour($typeMime, $format) {
$viewBox = $this->documentXML->documentElement->attributes->getNamedItem('viewBox');
$limitesPixels = explode(' ',$viewBox->value);
$this->largeur = intval($limitesPixels[2]);
$this->hauteur = intval($limitesPixels[3]);
$this->typeMime = $typeMime;
$this->format = intval($format);
}
private function creerStyleSources() {
$couleurs = $this->recupererCouleursSources();
$reglesCss = array();
foreach ($couleurs as $codeSource => $codeCouleur) {
$reglesCss[] = ".{$codeSource} {\nfill:{$codeCouleur}\n}\n";
}
$texteCss = $this->documentXML->createCDATASection(implode(' ', $reglesCss));
$noeudStyle = new DomElement('style', '');
$this->documentXML->documentElement->appendChild($noeudStyle);
$noeudStyle->appendChild($texteCss);
}
private function recupererCouleursSources() {
$sourcesDonnees = Config::get('sourcesDonnees');
$codesSources = str_replace('floradata', 'cel', $sourcesDonnees).',tout';
$codes = explode(',', $codesSources);
for ($index = 0; $index < count($codes); $index ++) {
$codes[$index] = "'".$codes[$index]."'";
}
$codesSources = implode(',', $codes);
$bdd = new Bdd();
$requete = "SELECT code, SUBSTR(complements,9) AS couleur FROM ".Config::get('bdd_table_ontologies')." WHERE code IN ({$codesSources})";
$couleurs = $bdd->recupererTous($requete);
$listeCouleurs = array();
foreach ($couleurs as $couleur) {
$couleur['code'] = $couleur['code'] == 'cel' ? 'floradata' : $couleur['code'];
$listeCouleurs[$couleur['code']] = $couleur['couleur'];
}
return $listeCouleurs;
}
 
public function formaterCarte($taxon) {
$limitesCarte = $this->renvoyerLimitesCarte();
$sourceDonnees = new SourceDonnees($limitesCarte, $taxon);
foreach ($this->sources as $source) {
$nomMethode = "recupererStations".($source == 'floradata' ? 'Floradata' : 'Moissonnage');
$stations = $sourceDonnees->$nomMethode($source);
$this->ajouterStations($stations, $source);
}
$this->supprimerMaillesVides();
}
public function renvoyerLimitesCarte() {
$limites = array();
list($limites['ouest'], $limites['sud']) = $this->convertirMetresEnPixels(
$this->coordonnees['xMin'], $this->coordonnees['yMin']);
list($limites['est'], $limites['nord']) = $this->convertirMetresEnPixels(
$this->coordonnees['xMax'], $this->coordonnees['yMax']);
return $limites;
}
private function convertirMetresEnPixels($x, $y) {
$longitude = ($x / self::ORIGINE) * 180;
$latitude = ($y / self::ORIGINE) * 180;
$latitude = 180 / M_PI * (2 * atan(exp($latitude * M_PI / 180.0)) - M_PI / 2.0);
return array(round($longitude, 6), round($latitude, 6));
}
private function ajouterStations($stations, $source) {
$grille = $this->recupererNoeuds('grille')->childNodes;
$index = 0;
$maille = $grille->item($index);
foreach ($stations as $station) {
if (!isset($station['lat']) || !isset($station['lng']) || !isset($station['commune'])) {
continue;
}
$idMaille = $maille->attributes->getNamedItem('id')->value;
$bbox = explode('_', substr($idMaille, 5));
$bbox[0] = floatval($bbox[0]);
$bbox[1] = floatval($bbox[1]);
while ($index < $grille->length && (
$bbox[1] > $station['lat'] || ($bbox[1] == $station['lat'] && $bbox[0] < $station['lng'])
)) {
$maille = $grille->item($index ++);
$idMaille = $maille->attributes->getNamedItem('id')->value;
$bbox = explode('_', substr($idMaille, 5));
$bbox[0] = floatval($bbox[0]);
$bbox[1] = floatval($bbox[1]);
}
if ($bbox[1] == $station['lat'] && $bbox[0] == $station['lng']) {
$this->ajouterCommentaire($station, $source, $maille);
$this->appliquerStyleMaille($source, $maille);
}
if ($index == $grille->length) {
break;
}
}
}
private function supprimerMaillesVides() {
$grille = $this->recupererNoeuds('grille')->childNodes;
$index = 0;
while ($index < $grille->length) {
if (!$grille->item($index)->hasAttribute('title')) {
$grille->item($index)->parentNode->removeChild($grille->item($index));
} else {
$index ++;
}
}
}
private function appliquerStyleMaille($source, & $maille) {
if ($maille->hasAttribute('class') && $maille->attributes->getNamedItem('class')->value != $source) {
$maille->setAttribute('class', 'tout');
} elseif (!$maille->hasAttribute('class')) {
$maille->setAttribute('class', $source);
}
}
private function ajouterCommentaire($station, $source, & $maille) {
$commentaires = array();
if ($maille->hasAttribute('title')) {
$commentaires = explode("; ", $maille->attributes->getNamedItem('title')->value);
}
$commentaire = ucfirst($source)." : {$station['commune']}, ";
if (strlen($station['date']) == 4) {
$commentaire .= "en {$station['date']} par {$station['auteur']}";
} else {
$date = preg_replace("/(\d{4})-(\d{2})-(\d{2})/", "$3/$2/$1", $station['date']);
$commentaire .= "le {$date} par {$station['auteur']}";
}
$commentaires[] = trim($commentaire);
$maille->setAttribute('title', implode('; ', $commentaires));
}
public function renvoyerCarte() {
$this->documentXML->documentElement->setAttribute("width", $this->format);
$this->documentXML->documentElement->setAttribute("height", $this->hauteur * $this->format / $this->largeur);
$retour = '';
if ($this->typeMime == self::MIME_MAP) {
$retour = $this->documentXML->saveHTML();
} else {
$retour = $this->convertirEnPng();
}
return $retour;
}
private function convertirEnPng() {
$this->image = imagecreatetruecolor($this->format, $this->hauteur * $this->format / $this->largeur);
imagefill($this->image, 0, 0, imagecolorallocate($this->image, 255, 255, 255));
$this->transformerLignesEnPng('departements');
$this->transformerPolygonesEnPng('grille');
// stocker le contenu encode de l'image generee dans une chaine de caracteres
ob_start();
imagepng($this->image);
$png = ob_get_contents();
ob_end_clean();
return $png;
}
private function transformerLignesEnPng($nomCouche) {
$facteur = floatval($this->format) / floatval($this->largeur);
$noeudCouche = $this->recupererNoeuds($nomCouche);
$couleurContour = $noeudCouche->attributes->getNamedItem('stroke')->value;
for ($index = 0; $index < $noeudCouche->childNodes->length; $index ++) {
$noeudLigne = $noeudCouche->childNodes->item($index);
for ($indexPath = 0; $indexPath < $noeudLigne->childNodes->length; $indexPath ++) {
$coordonneesSvg = $noeudLigne->childNodes->item($indexPath)->attributes->getNamedItem('points')->value;
preg_match_all('/\d+.\d/', $coordonneesSvg, $coordonnees);
$coordonnees = current($coordonnees);
foreach ($coordonnees as $indexCoord => $valeur) {
$coordonnees[$indexCoord] = intval(floatval($valeur) * $facteur);
}
if ($couleurContour != 'none') {
for ($i = 0; $i < count($coordonnees) - 2; $i += 2) {
imageline($this->image, $coordonnees[$i], $coordonnees[$i+1], $coordonnees[$i+2],
$coordonnees[$i+3], $this->allouerCouleur($couleurContour));
}
}
}
}
}
private function transformerPolygonesEnPng($nomCouche) {
$couleurs = $this->recupererCouleursSources();
$facteur = floatval($this->format) / floatval($this->largeur);
$noeudCouche = $this->recupererNoeuds($nomCouche);
$couleurRemplissage = $noeudCouche->attributes->getNamedItem('fill')->value;
$couleurContour = $noeudCouche->attributes->getNamedItem('stroke')->value;
for ($index = 0; $index < $noeudCouche->childNodes->length; $index ++) {
$noeudPolygone = $noeudCouche->childNodes->item($index);
$couleurPolygone = 'none';
if ($noeudPolygone->hasAttribute('class')) {
$couleurPolygone = $couleurs[$noeudPolygone->attributes->getNamedItem('class')->value];
}
for ($indexPath = 0; $indexPath < $noeudPolygone->childNodes->length; $indexPath ++) {
$coordonneesSvg = $noeudPolygone->childNodes->item($indexPath)->attributes->getNamedItem('points')->value;
preg_match_all('/\d+.\d/', $coordonneesSvg, $coordonnees);
$coordonnees = current($coordonnees);
foreach ($coordonnees as $indexCoord => $valeur) {
$coordonnees[$indexCoord] = intval(floatval($valeur) * $facteur);
}
if ($couleurRemplissage != 'none') {
imagefilledpolygon($this->image, $coordonnees, count($coordonnees) / 2, $this->allouerCouleur($couleurRemplissage));
}
if ($couleurContour != 'none') {
imagepolygon($this->image, $coordonnees, count($coordonnees) / 2, $this->allouerCouleur($couleurContour));
}
if ($couleurPolygone != 'none') {
$contourGrille = "rgba(255,255,255,".($this->format >= 300 ? 0.4 : 0).")";
imagefilledrectangle($this->image, $coordonnees[0], $coordonnees[1], $coordonnees[4], $coordonnees[5],
$this->allouerCouleur($couleurPolygone));
imagerectangle($this->image, $coordonnees[0], $coordonnees[1], $coordonnees[4], $coordonnees[5],
$this->allouerCouleur($contourGrille));
}
}
}
}
private function allouerCouleur($couleurTexte) {
preg_match_all('/\d+/', $couleurTexte, $valeurs);
$rouge = $valeurs[0][0];
$vert = $valeurs[0][1];
$bleu = $valeurs[0][2];
$alpha = 0;
if (count($valeurs[0]) > 3) {
$valeurAlpha = floatval($valeurs[0][3].".".$valeurs[0][4]);
$alpha = intval((1.0 - $valeurAlpha) * 127.0);
}
return imagecolorallocatealpha($this->image, $rouge, $vert, $bleu, $alpha);
}
}
 
?>
/tags/v0.1-20130830-1/services/modules/0.1/moissonnage/cartes/LegendeCartes.php
New file
0,0 → 1,76
<?php
 
/**
* Classe qui fournit une legende recuperee dans une table d'ontologies pour la renvoyer au client
*
* @package framework-0.4
* @author Alexandre GALIBERT <alexandre.galibert@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $Id$
* @copyright 2013 Tela Botanica (accueil@tela-botanica.org)
*
*/
 
class LegendeCartes {
const TYPE_MIME = 'application/json';
const ID_CLASSE = '10';
private $tableOntologies = '';
private $ontologies = array();
private $legende = array();
public function __construct() {
$this->tableOntologies = Config::get('bdd_table_ontologies');
}
public function obtenirLegende() {
$this->chargerOntologies();
$this->chargerLegende();
$resultat = new ResultatService();
$resultat->corps = $this->legende;
$resultat->mime = self::TYPE_MIME;
return $resultat;
}
private function chargerOntologies() {
$bdd = new Bdd();
$requete = "SELECT * FROM {$this->tableOntologies}";
$resultats = $bdd->recupererTous($requete);
if (!is_array($resultats) || count($resultats) <= 0) {
$message = "Les données d'ontologies n'ont pu être chargées pour la ressource demandée";
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE;
throw new Exception($message, $code);
}
foreach ($resultats as $ontologie) {
$this->ontologies[$ontologie['id']] = $this->extraireComplementsOntologies($ontologie);
}
}
private function extraireComplementsOntologies($ontologie) {
if (strlen(trim($ontologie['complements'])) > 0) {
list($cle, $valeur) = explode('=', trim($ontologie['complements']));
$ontologie[trim($cle)] = trim($valeur);
}
return $ontologie;
}
private function chargerLegende() {
foreach ($this->ontologies as $ontologie) {
if ($ontologie['classe_id'] == self::ID_CLASSE && isset($ontologie['legende'])) {
$this->legende[] = array(
'code' => $ontologie['code'],
'couleur' => $ontologie['legende'],
'nom' => $ontologie['nom'],
'description' => $ontologie['description']
);
}
}
}
}
 
?>
/tags/v0.1-20130830-1/services/modules/0.1/insee-d/ZoneGeo.php
New file
0,0 → 1,405
<?php
/**
* Description :
* Classe ZoneGeo.php fournit des informations sur ensemble structuré des termes et concepts représentant les éléments
* d'un domaine de connaissances .
* Le but étant de fournir un ensemble minimal d'information comprenant :
* un identifiant (numérique ou alphanumérique sous forme de ChatMot si possible), un nom, une region et
* éventuellement une relation hiérarchique avec un autre terme (=classe).
* Si l'url finit par /zone-geo on retourne une liste de termes (seulement les 100 premières par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /observations?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche,
* distinct, retour.format, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Delphine Cauquil <delphine@tela-botanica.org>
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 1.0
* @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org)
*/
 
class ZoneGeo extends Commun {
 
protected $service = 'zone-geo';
 
/**
* Permet de stocker la requete formulée : /zone-geo | /zone-geo/#id | /zone-geo/#id/champ | /zone-geo/#id/relations
* Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service.
* Est utilisée principalement pr déterminer le format du tableau à retourner. */
protected $format_reponse = 'zone-geo';
 
/** Variables constituant les parametres de la requete SQL (champ, condition, group by, limit) remplie
* selon ressources et paramètres */
protected $requete_champ = ' * ';
protected $requete_condition = '';
protected $limite_requete = array(
'depart' => 0,
'limite' => 100
);
 
/** Stockage des ressources et paramétres */
protected $table_ressources = array();
protected $table_param = array();
/**
* Precise la contenance plus ou moins précise du tableau à retourner :
* - min = les données présentes dans la table
* - max = les données de la table + les informations complémentaires (pour les identifiants et les codes)
* - oss = la liste des nom_sci (uniquement pour noms et taxons)
*/
protected $retour_format = 'max';
/** Valeur du paramètre de requete recherche :
* - stricte : le masque est passé tel quel à l'opérateur LIKE.
* - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE.
* - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */
protected $recherche;
 
/** Permet de stocker le tableau de résultat (non encodé en json) */
protected $table_retour = array();
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */
protected $total_resultat;
 
// +-----------------------------------------------------------------------------------------------------+
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres)) {
$this->table_param = $this->parametres;
 
// masque : filtre la liste en fonction d'un masque de recherche portant sur le code, le nom ou la region.
// masque.code : filtre uniquement sur le code. masque.nom : filtre uniquement sur le nom.
// masque.region : filtre uniquement sur la region.
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') {
$this->recherche = $this->parametres['recherche'];
}
 
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'masque' :
$this->ajouterLeFiltreMasque('masque', $valeur);
break;
case 'masque.code' :
$this->ajouterLeFiltreMasque('dep', $valeur);
break;
case 'masque.nom' :
$this->ajouterLeFiltreMasque('nccenr', $valeur);
break;
case 'masque.region' :
$this->ajouterLeFiltreMasque('region', $valeur);
break;
case 'retour.format' :
$this->retour_format = $valeur;
break;
case 'navigation.depart' :
$this->limite_requete['depart'] = $valeur;
break;
case 'navigation.limite' :
$this->limite_requete['limite'] = $valeur;
break;
case 'recherche' :
break;
default :
$p = 'Erreur dans les paramètres de recherche de votre requête : '.
'</br> Le paramètre " '.$param.' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $p);
}
}
}
}
 
public function ajouterLeFiltreMasque($nom_champ, $valeur) {
if ($nom_champ == 'dep' || $nom_champ == 'region') {
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if ($this->recherche == 'floue') {
if ($nom_champ == 'masque') {
$this->requete_condition[] = '( dep = '.$this->getBdd()->proteger($valeur)
.' OR region = '.$this->getBdd()->proteger($valeur)
.' OR ( SOUNDEX(nccenr) = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE(nccenr)) = SOUNDEX(REVERSE(\''.$valeur.'\')) '
.')) ';
} else {
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ';
}
} else {
if ($this->recherche == 'etendue') {
$valeur = str_replace(' ','%', $valeur);
$valeur .= '%';
}
 
if ($nom_champ == 'masque') {
$this->requete_condition[] = ' (dep = '.$this->getBdd()->proteger($valeur)
.' OR nccenr LIKE '.$this->getBdd()->proteger($valeur)
.' OR region = '.$this->getBdd()->proteger($valeur).')';
} else {
$this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur);
}
}
}
}
 
 
//+------------------------------------------------------------------------------------------------------+
public function traiterRessources() {
if (isset($this->ressources) && !empty($this->ressources)) {
$this->table_ressources = $this->ressources;
if (isset($this->table_ressources[0]) && !empty($this->table_ressources[0])) {
//requete = /zone-geo/#id
$this->traiterRessourceId();
if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) {
//dans le cas /zone-geo/#id/#champ ou /zone-geo/#id/relations
$this->traiterRessourceChampOuRelations();
}
}
}
}
 
//requete : /zone-geo/#id (ex : /zone-geo/7)
public function traiterRessourceId() {
if (is_numeric($this->table_ressources[0])) {
$this->requete_condition[] = ' dep = '.$this->getBdd()->proteger($this->table_ressources[0]);
$this->format_reponse .= '/id';
} else {
$r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->table_ressources[0].
' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r);
}
}
 
 
public function traiterRessourceChampOuRelations() {
//requete = /zone-geo/#id/relations :
if ($this->table_ressources[1] == 'relations') {
$this->format_reponse .= '/relations';
$this->requete_condition[] = 'region = (SELECT region FROM '.$this->table.' WHERE '
.implode(' AND ', $this->requete_condition).')';
//requete = /zone-geo/#id/#champ :
} else {
$this->format_reponse .= '/champ';
}
}
 
//+------------------------------------------------------------------------------------------------------+
public function assemblerLaRequete() {
//assemblage de la requete :
$requete = ' SELECT '.$this->requete_champ.
' FROM '.$this->table
.$this->formerRequeteCondition()
.$this->formerRequeteLimite();
return $requete;
}
 
public function formerRequeteCondition() {
$condition = '';
if ($this->requete_condition != null) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
 
//ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes
// suivantes : /zone-geo et /zone-geo/#id/relations)
public function formerRequeteLimite() {
if ($this->format_reponse != 'zone-geo' && $this->format_reponse != 'zone-geo/id/relations') {
$this->requete_limite = '';
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) {
//cas où la requete presente un navigation.depart supérieur au nb total de resultats.
$this->limite_requete['depart'] =
(($nb - $this->limite_requete['limite']) < 0) ? 0 : ($nb - $this->limite_requete['limite']);
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
} else {
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
}
return $this->requete_limite;
}
 
public function recupererTotalResultat() {
//on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /zone-geo)
$requete = 'SELECT count(*) as nombre FROM '
.$this->table
.$this->formerRequeteCondition();
$res = $this->getBdd()->recuperer($requete);
 
if ($res) {
$total = $res['nombre'];
} else {
$t = 'Fonction recupererTotalResultat() : <br/>Données introuvables dans la base';
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $t);
}
return $total;
}
 
//+------------------------------------------------------------------------------------------------------+
// determine en fct du service appelé (/zone-geo | /zone-geo/#id | /zone-geo/#id/champ |
// /zone-geo/#id/relations) le format du tableau à retourner.
public function retournerResultatFormate($resultat) {
$this->recupererTableConfig('correspondance_champs');
switch ($this->format_reponse) {
case 'zone-geo' : $reponse = $this->formaterZoneGeo($resultat); break;
case 'zone-geo/id' : $reponse = $this->formaterZoneGeoId($resultat[0]); break;
case 'zone-geo/id/champ' : $reponse = $this->formaterZoneGeoIdChamp($resultat[0]); break;
case 'zone-geo/id/relations' : $reponse = $this->formaterZoneGeoIdRelations($resultat); break;
default : break;
}
return $reponse;
}
 
public function formaterZoneGeo($resultat) {
//on remplit la table $table_retour_json['entete']
$this->table_retour['depart'] = $this->limite_requete['depart'];
$this->table_retour['limite'] = $this->limite_requete['limite'];
$this->table_retour['total'] = $this->total_resultat;
$url = $this->formulerUrl($this->total_resultat, '/zone-geo');
if (isset($url['precedent']) && $url['precedent'] != '') { $this->table_retour['href.precedent'] = $url['precedent']; }
if (isset($url['suivant']) && $url['suivant'] != '') { $this->table_retour['href.suivant'] = $url['suivant']; }
$table_retour_json['entete'] = $this->table_retour;
 
//on remplit la table $table_retour_json['resultat']
$this->table_retour = array();
if (isset($this->table_param['masque_nom'])) $resultat = $this->trierRechercheFloue($this->table_param['masque_nom'], $resultat, 'nccenr');
foreach ($resultat as $tab) {
foreach ($tab as $key => $valeur) {
if ($valeur != '') {
switch ($key) {
case 'dep' : $num = $valeur; $this->table_retour['code'] = $valeur; break;
case 'nccenr' : $this->table_retour['nom'] = $valeur; break;
default : break;
}
}
}
if ($this->retour_format == 'max') {
$this->table_retour['href'] = $this->ajouterHref('zone-geo', $num);
}
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array();
}
$table_retour_json['resultat'] = $resultat_json;
return $table_retour_json;
}
 
public function formaterZoneGeoId($resultat) {
foreach ($resultat as $key => $valeur) {
if ($valeur != '') {
$this->afficherDonnees($key, $valeur);
}
}
unset($this->table_retour['href']);
return $this->table_retour;
}
 
public function formaterZoneGeoIdRelations($resultat) {
if ($resultat == '') {
$retour = null;
} else {
//on remplit la table $table_retour_json['entete']
$this->table_retour['depart'] = $this->limite_requete['depart'];
$this->table_retour['limite'] = $this->limite_requete['limite'];
$this->table_retour['total'] = $this->total_resultat;
//formuler les urls
$url = $this->formulerUrl(count($resultat), '/zone-geo');
if ($url['precedent'] != '') { $this->table_retour['href.precedent'] = $url['precedent']; }
if ($url['suivant'] != '') { $this->table_retour['href.suivant'] = $url['suivant']; }
$retour['entete'] = $this->table_retour;
$this->table_retour = array();
 
//on remplit la table $table_retour_json['resultat']
foreach ($resultat as $tab) {
foreach ($tab as $key => $valeur) {
switch ($key) {
case 'dep' : $num = $valeur; $this->table_retour['code'] = $valeur; break;
case 'nccenr' : $this->table_retour['nom'] = $valeur; break;
default : break;
}
}
if ($this->retour_format == 'max') $this->table_retour['href'] = $this->ajouterHref('zone-geo', $num);
$resultat_json[$num] = $this->table_retour;
$this->table_retour = array();
}
$retour['resultat'] = $resultat_json;
}
return $retour;
}
 
public function formaterZoneGeoIdChamp($resultat) {
//on recupère tous les resultats possibles
$reponse = $this->formaterZoneGeoId($resultat);
$this->table_retour = array();
//on recupère les résultats demandés à partir du tableau de résultat complet
$this->table_retour['id'] = $reponse['code'];
$champs = explode(' ', $this->table_ressources[1]);
 
foreach ($champs as $champ) {
if ($this->verifierValiditeChamp($champ)) {
if (strrpos($champ, '.*') !== false) {
$this->afficherPointEtoile($champ, $reponse);
 
} else {
if (isset($reponse[$champ])) {
$this->table_retour[$champ] = $reponse[$champ];
} else {
$this->table_retour[$champ] = null;
}
}
}
}
return $this->table_retour;
}
 
public function verifierValiditeChamp($champ) {
preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match);
$champs_possibles = $this->correspondance_champs;
$champs_possibles[] = 'nom.*';
 
if (in_array($match[1], $champs_possibles)) {
$validite = true;
} elseif (in_array($match[0], $champs_possibles)) {
$validite = true;
} else {
$champs_possibles = implode('</li><li>', $champs_possibles);
$c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '.
'Les champs disponibles sont : <li>'.$champs_possibles.'</li>';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c);
}
return $validite;
}
 
public function afficherPointEtoile($champ, $reponse) {
preg_match('/^([^.]+\.)\*$/', $champ, $match);
foreach ($reponse as $chp => $valeur) {
if (strrpos($chp, $match[1]) !== false) {
if ($valeur != '') {
$this->table_retour[$chp] = $valeur;
} else {
$this->table_retour[$chp] = null;
}
}
}
}
 
public function afficherDonnees($champ, $valeur) {
if ($this->retour_format == 'max') {
if ($champ == 'region' || $champ == 'chef_lieu') {
$projet = 'insee-'.substr($champ, 0, 1);
$this->table_retour[$champ.'.code'] = $valeur;
$this->table_retour[$champ.'.href'] = $this->ajouterHrefAutreProjet('zone-geo', '', $valeur, $projet);
} elseif ($champ == 'tncc') {
$url = $this->ajouterHref('ontologies', $valeur);
$res = $this->consulterHref($url);
$this->table_retour['type_nom'] = $res->nom;
$this->table_retour['type_nom.code'] = $valeur;
$this->table_retour['type_nom.href'] = $url;
} else {
$this->table_retour[$this->correspondance_champs[$champ]] = $valeur;
}
} else {
$this->table_retour[$this->correspondance_champs[$champ]] = $valeur;
}
}
 
}
 
?>
/tags/v0.1-20130830-1/services/modules/0.1/nva/NomsVernaculaires.php
New file
0,0 → 1,646
<?php
/**
* Description :
* Classe NomsVernaculaires.php fournit une liste de noms vernaculaires et leur liaison à la bdtxa
* Le but étant de fournir un ensemble minimal d'information comprenant :
* un identifiant (numérique ou alphanumérique sous forme de ChatMot si possible), un nom, une langue et
* une relation avec un taxon de la bdtxa.
* Si l'url finit par /noms-vernaculaires on retourne une liste de noms (seulement les 100 premières par défaut).
* L'url peut contenir des paramètres optionnels passés après le ? : /observations?param1=val1&param2=val2&...
*
* Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche,
* distinct, retour.format, navigation.depart et navigation.limite.
*
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* @package framework-v3
* @author Delphine Cauquil <delphine@tela-botanica.org>
* @author Jennifer Dhé <jennifer.dhe@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version 1.0
* @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org)
*/
class NomsVernaculaires extends Commun {
protected $champ_infos = array(
'taxon' => array('service' => 'taxons', 'ressource' => 'nt:', 'projet' => 'bdtxa', 'nom' => 'nom_sci'));
 
protected $service = 'noms-vernaculaires';
 
/**
* Permet de stocker la requete formulée : /noms-vernaculaires | /noms-vernaculaires/#id |
* /noms-vernaculaires/#id/champ | /noms-vernaculaires/#id/relations
* Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service.
* Est utilisée principalement pr déterminer le format du tableau à retourner. */
protected $format_reponse = 'noms-vernaculaires';
 
/** Variables constituant les parametres de la requete SQL (champ, condition, limit) remplie
* selon ressources et paramètres */
protected $requete_champ = array(' * ');
protected $requete_condition = '';
protected $limite_requete = array(
'depart' => 0,
'limite' => 100
);
protected $champ_tri = 'code_langue';
protected $direction_tri = 'asc';
/**
* Indique les champs supplémentaires à retourner
* - conseil_emploi = conseil d'emploi du nom vernaculaire
* - genre = genre et nombre du nom
* - taxon = nom retenu associé à ce nom
*/
protected $champs_supp = array();
 
/**
* Precise la contenance plus ou moins précise du tableau à retourner :
* - min = les données présentes dans la table
* - max = les données de la table + les informations complémentaires (pour les identifiants et les codes)
* - oss = la liste des nom_sci (uniquement pour noms et taxons) */
protected $retour_format = 'max';
/** Valeur du paramètre de requete recherche :
* - stricte : le masque est passé tel quel à l'opérateur LIKE.
* - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE.
* - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */
protected $recherche;
/** Permet de stocker le tableau de résultat (non encodé en json) */
protected $table_retour = array();
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */
protected $total_resultat;
private $config;
public function __construct($config) {
$this->config = is_null($config) ? Config::get('NomsVernaculaires') : $config;
}
 
//+------------------------------------------------------------------------------------------------------+
// créer une condition en fonction du paramétre
public function traiterParametres() {
if (isset($this->parametres) && !empty($this->parametres)) {
 
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') {
$this->recherche = $this->parametres['recherche'];
}
foreach ($this->parametres as $param => $valeur) {
switch ($param) {
case 'masque' :
$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
break;
case 'masque.nt' :
$this->ajouterFiltreMasque('num_taxon', $valeur);
break;
case 'masque.nv' :
$this->ajouterFiltreMasque('nom_vernaculaire', $valeur);
break;
case 'masque.lg' :
$this->ajouterFiltreMasque('code_langue', $valeur);
break;
case 'retour.format' :
$this->retour_format = $valeur;
break;
case 'navigation.depart' :
$this->limite_requete['depart'] = $valeur;
break;
case 'navigation.limite' :
$this->limite_requete['limite'] = $valeur;
break;
case 'retour.champs' :
$this->champs_supp = explode(',',$valeur);
break;
case 'recherche' :
break;
case 'version.projet' :
break;
default :
$p = 'Erreur dans les paramètres de recherche de votre requête : '.
'</br> Le paramètre " '.$param.' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $p);
}
}
}
}
 
public function ajouterFiltreMasque($nom_champ, $valeur) {
if ($nom_champ == 'num_taxon') { // si il s'agit d'un chiffre
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur);
} else {
if ($this->recherche == 'floue') {
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')'
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ';
} else {
if ($this->recherche == 'etendue') {
$valeur = '%'.str_replace(' ','% ', $valeur);
$valeur .= '%';
}
$this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
// en fonction de la présence des ressources modifie requete_champ et requete_condition
public function traiterRessources() {
if (isset($this->ressources) && !empty($this->ressources)) {
if (isset($this->ressources[0]) && !empty($this->ressources[0])) {
$this->traiterRessourceId(); // ajoute condition id=#valeur
if (isset($this->ressources[1]) && !empty($this->ressources[1])) {
$this->traiterRessourceChamp(); //modifie requete_champ ou requete_condition
}
}
} else { //rajoute distinct pour ne pas avoir plusieurs fois le même nom
$this->requete_champ = array('distinct(id)', 'nom_vernaculaire ');
}
}
 
//requete : /noms-vernaculaires/#id (ex : /noms-vernaculaires/7)
public function traiterRessourceId() {
if (is_numeric($this->ressources[0])) {
$this->requete_condition[] = ' id = '.$this->getBdd()->proteger($this->ressources[0]);
$this->format_reponse .= '/id';
} elseif ($this->ressources[0] == 'attributions') {
$this->format_reponse .= '/attributions';
} else {
$r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->ressources[0].
' " n\'existe pas.';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r);
}
}
 
 
public function traiterRessourceChamp() {
$this->format_reponse .= '/champ';
$this->analyserChamp();
}
 
public function analyserChamp() {
$this->requete_champ = array();
$this->recupererTableConfig('champs_possibles');// s'il y a plusieurs champs correspondant au champ demandé ils sont séparé par des |
$champs = explode(' ', $this->ressources[1]);
foreach ($champs as $champ) {
preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match);
if (isset($this->champs_possibles[$match[1]])) {
$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[1]]);
} elseif (isset($this->champs_possibles[$match[0]])) {
$this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[0]]);
} else {
$champs_possibles = implode('</li><li>', array_keys($this->champs_possibles));
$c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '.
'Les champs disponibles sont : <li>'.$champs_possibles.'</li> et leurs déclinaisons (ex. ".code").';
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c);
}
}
}
 
//+------------------------------------------------------------------------------------------------------+
public function assemblerLaRequete() {
$requete = ' SELECT '.$this->formerRequeteChamp().
', CASE code_langue WHEN "fra" THEN 1 ELSE 0 END AS tri '.
' FROM '.$this->table
.$this->formerRequeteCondition().
' ORDER BY tri DESC, nom_vernaculaire ASC '
.$this->formerRequeteLimite();
return $requete;
}
 
public function formerRequeteChamp() {
if (in_array('*', $this->requete_champ)) {
$champ = ' * ';
} else {
$champ = implode(', ', $this->requete_champ);
}
return $champ;
}
 
public function formerRequeteCondition() {
$condition = '';
if ($this->requete_condition != null) {
$condition = ' WHERE '.implode(' AND ', $this->requete_condition);
}
return $condition;
}
 
//ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes
// suivantes : /noms-vernaculaires et /noms-vernaculaires/#id/relations)
public function formerRequeteLimite() {
if (in_array($this->format_reponse , array($this->service.'/id', $this->service.'/id/champs'))) {
$this->requete_limite = '';
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) {
$this->limite_requete['depart'] =
(($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']);
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];
} else {
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];