| /branches/refact/initialiserBdd.sh |
|---|
| New file |
| 0,0 → 1,66 |
| #!/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$ |
| ############################################################################################################## |
| # 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..."; |
| 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 "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 "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 "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 "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 "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 "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 |
| /branches/refact/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 |
| /branches/refact/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 |
| /branches/refact/services/modules/0.1/sptb/Statuts.php |
|---|
| New file |
| 0,0 → 1,175 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe implémentant l'API d'eFlore concernant les statuts de protection |
| * |
| * @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Status |
| * |
| * @package eFlore/services |
| * @author Aurélien PERONNET <aurelien@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| // TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests... |
| class Statuts extends Commun { |
| protected $parametres = array(); |
| protected $ressources = array(); |
| private $bdd; |
| private $retour_format = 'complet'; |
| private $retours_formats_autorises = array('complet','zone_geo'); |
| protected $table_version = null; |
| public function __construct($config = null) { |
| $this->config = $config; |
| $this->bdd = $this->getBdd(); |
| $this->table_version = Config::get('table_version'); |
| } |
| public function consulter($ressources, $parametres) { |
| $this->parametres = $parametres; |
| $this->ressources = $ressources; |
| $this->affecterParametresParDefaut(); |
| $this->verifierParametres(); |
| $resultat = new ResultatService(); |
| $resultat->corps = $this->obtenirStatuts(); |
| return $resultat; |
| } |
| //+---------------------------FONCTION D'ANALYSE DES PARAMETRES---------------------------------------------------------+ |
| private function affecterParametresParDefaut() { |
| $this->retour_format = isset($this->parametres['retour.format']) ? $this->parametres['retour.format'] : $this->retour_format; |
| } |
| private function verifierParametres() { |
| $erreurs = array(); |
| if (empty($this->parametres['masque.nn'])) { |
| $erreurs[] = 'renseignez une valeur pour masque.nn'; |
| } |
| if(!is_numeric($this->parametres['masque.nn'])) { |
| $erreurs[] = 'la valeur pour masque.nn doit être un entier'; |
| } |
| if(!in_array($this->retour_format, $this->retours_formats_autorises)) { |
| $erreurs[] = 'la valeur '.$this->retour_format.' est inconnue'; |
| } |
| if (count($erreurs) > 0) { |
| $message = implode('<br />', $erreurs); |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($message, $code); |
| } |
| } |
| //+---------------------------FONCTIONS DE REQUETE---------------------------------------------------------+ |
| private function obtenirLois(Array $id_lois) { |
| $id_lois = array_map(array($this->bdd, 'proteger'), $id_lois); |
| $requete = "SELECT * FROM sptb_lois_v".$this->table_version.' '. |
| "WHERE id IN (".implode(',',$id_lois).") "; |
| return $this->bdd->recupererTous($requete); |
| } |
| private function obtenirLoisZoneGeo(Array $id_lois) { |
| $id_lois = array_map(array($this->bdd, 'proteger'), $id_lois); |
| $requete = "SELECT DISTINCT zone_application, code_zone_application FROM sptb_lois_v".$this->table_version.' '. |
| "WHERE id IN (".implode(',',$id_lois).") "; |
| return $this->bdd->recupererTous($requete); |
| } |
| private function obtenirStatuts() { |
| $nn_demande = $this->parametres['masque.nn']; |
| $conditions_taxons = array(); |
| $conditions_taxons = $this->obtenirNumNomTaxonsSuperieurs($nn_demande); |
| $conditions_taxons[] = $this->bdd->proteger($nn_demande); |
| $requete = "SELECT * FROM sptb_especes_v".$this->table_version.' '. |
| "WHERE num_nom_retenu IN (".implode(', ', $conditions_taxons).") OR ". |
| "num_nom IN (".implode(', ', $conditions_taxons).") "; |
| $statuts = $this->bdd->recuperer($requete); |
| $statuts = $this->formaterRetour($statuts); |
| return $statuts; |
| } |
| private function obtenirNumNomTaxonsSuperieurs($nn_demande) { |
| $nn_taxons_sup = array(); |
| // TODO: ceci ramène trop de champs alors que l'on a besoin que du numéro nomenclatural |
| // et il y a peut-être un meilleur moyen que ramener la hierarchie des taxons supérieurs |
| // mais pour le moment ça marche et c'est assez rapide |
| $url = $this->ajouterHrefAutreProjet('taxons', $nn_demande, '/relations/superieurs','bdtfx'); |
| $classification = $this->consulterHref($url); |
| $classification = is_object($classification) ? get_object_vars($classification) : array(); |
| if(isset($classification[$nn_demande])) { |
| $classification_nn_demande = get_object_vars($classification[$nn_demande]); |
| $tab_nn_demandes = array_keys($classification_nn_demande); |
| $nn_taxons_sup = array_map(array($this->bdd,'proteger'), $tab_nn_demandes); |
| } |
| return $nn_taxons_sup; |
| } |
| //+---------------------------FONCTIONS DE FORMATAGE---------------------------------------------------------+ |
| private function formaterRetour($statuts_taxon) { |
| switch($this->retour_format) { |
| case 'zone_geo': |
| $retour = $this->formaterStatutsTaxonZoneGeo($statuts_taxon); |
| break; |
| case 'complet': |
| $retour = $this->formaterStatutsTaxon($statuts_taxon); |
| break; |
| default: |
| $retour = $this->formaterStatutsTaxon(); |
| break; |
| } |
| return $retour; |
| } |
| private function formaterStatutsTaxonZoneGeo($statuts_taxon) { |
| $lois_statuts = array(); |
| foreach ($statuts_taxon as $champ => $statut) { |
| if($statut == "1") { |
| $lois_statuts[] = $champ; |
| } |
| } |
| $zones_geo_lois = (!empty($lois_statuts)) ? $this->obtenirLoisZoneGeo($lois_statuts) : array(); |
| return $zones_geo_lois; |
| } |
| private function formaterStatutsTaxon($statuts_taxon) { |
| $statuts_formates = array(); |
| $lois_statuts = array(); |
| if(is_array($statuts_taxon)) { |
| unset($statuts_taxon['num_nom']); |
| unset($statuts_taxon['num_nom_retenu']); |
| unset($statuts_taxon['nom_sci']); |
| foreach ($statuts_taxon as $champ => $statut) { |
| if($statut == "1") { |
| $lois_statuts[] = $champ; |
| } |
| } |
| } |
| $statuts_formates = (!empty($lois_statuts)) ? $this->obtenirLois($lois_statuts) : array(); |
| return $statuts_formates; |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/Projets.php |
|---|
| New file |
| 0,0 → 1,209 |
| <?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 $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->initialiserProjet(); |
| if ($this->avoirRessourceService()) { |
| $retour = $this->initialiserService(); |
| } |
| } |
| } |
| return $retour; |
| } |
| private function avoirRessources() { |
| $presenceDeRessources = false; |
| if (isset($this->ressources) && count($this->ressources) > 0) { |
| $presenceDeRessources = true; |
| } else { |
| $message = "Aucune ressource n'a été indiquée.\n". |
| "Veuillez indiquer au moins un code de projet et un type de service."; |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($message, $code); |
| } |
| return $presenceDeRessources; |
| } |
| private function avoirRessourceProjet() { |
| $presenceRessourceProjet = false; |
| $projet = $this->ressources[0]; |
| $projetsDispo = Outils::recupererTableauConfig('projetsDispo'); |
| if (in_array($projet, $projetsDispo)) { |
| $presenceRessourceProjet = true; |
| } else { |
| $message = "La ressource '$projet' n'indique pas un projet existant.\n". |
| "Les projets existant sont :\n".implode(', ', $projetsDispo); |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($message, $code); |
| } |
| return $presenceRessourceProjet; |
| } |
| private function initialiserProjet() { |
| $this->chargerNomDuProjet(); |
| $this->chargerConfigProjet(); |
| // 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); |
| } |
| private function chargerClasseProjet($classe) { |
| if (class_exists($classe)) { |
| return null; |
| } |
| $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() { |
| $this->chargerNomDuService(); |
| $classe = $this->obtenirNomClasseService($this->serviceNom); |
| $chemins = array(); |
| $chemins[] = $this->cheminCourrant.$this->projetNom.DS.$classe.'.php'; |
| $chemins[] = $this->cheminCourrant.'commun'.DS.$classe.'.php'; |
| $retour = ''; |
| $service = null; |
| foreach ($chemins as $chemin) { |
| if (file_exists($chemin)) { |
| $service = new $classe($this->getBdd()); |
| $ressourcesPourService = $this->filtrerRessourcesPourService(); |
| $this->cache = new CacheEflore($service, $this->projetNom, $this->serviceNom, Config::get('cache')); |
| $retour = $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 $retour; |
| } |
| private function chargerNomDuService() { |
| $this->serviceNom = $this->ressources[1]; |
| } |
| private function obtenirNomClasseService($mot) { |
| $classeNom = str_replace(' ', '', ucwords(strtolower(str_replace('-', ' ', $mot)))); |
| return $classeNom; |
| } |
| private function filtrerRessourcesPourService() { |
| $ressourcesPourService = array(); |
| $nbreDeRessources = count($this->ressources); |
| for ($i = 2; $i < $nbreDeRessources; $i++) { |
| $ressourcesPourService[] = $this->ressources[$i]; |
| } |
| return $ressourcesPourService; |
| } |
| } |
| ?> |
| /branches/refact/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); |
| 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; |
| } |
| } |
| ?> |
| /branches/refact/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; |
| } |
| } |
| ?> |
| /branches/refact/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; |
| } |
| } |
| ?> |
| /branches/refact/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; |
| } |
| } |
| ?> |
| /branches/refact/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; |
| } |
| } |
| ?> |
| /branches/refact/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 Ontologies 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; |
| } |
| } |
| ?> |
| /branches/refact/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; |
| } |
| } |
| } |
| ?> |
| /branches/refact/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 |
| /branches/refact/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 Cartes { |
| 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 name 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; |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/eflore/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¶m2=val2&... |
| * |
| * Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.description , recherche, |
| * distinct, retour.format, navigation.depart et navigation.limite. |
| * |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * @package eflore-projets |
| * @author Jennifer DHÉ <jennifer.dhe@tela-botanica.org> |
| * @author Delphine CAUQUIL <delphine@tela-botanica.org> |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 0.1 |
| * @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class Ontologies extends Commun { |
| protected $requete_condition = null; //Représente la partie de la requete SQL ajoutant une condition (WHERE ...) |
| /** Permet de stocker la requete formulée: /ontologies | /ontologies/#id | /ontologies/#id/champ | /ontologies/#id/relations */ |
| protected $format_reponse = 'ontologies'; |
| /** Permet de stocker les limite de la requete SQL (par défaut seul les 100 premiers résultats seront retournés). |
| * Stocke également les valeurs des paramètres navigation.depart et navigation.limite passés dans la requete*/ |
| protected $limite_requete = array( 'depart' => 0, 'limite' => 100); |
| /** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */ |
| protected $total_resultat; |
| protected $retour_format = 'max'; |
| public function 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; |
| } |
| } |
| ?> |
| /branches/refact/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']); |
| } |
| } |
| } |
| } |
| ?> |
| /branches/refact/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); |
| } |
| } |
| ?> |
| /branches/refact/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); |
| } |
| } |
| ?> |
| /branches/refact/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); |
| } |
| } |
| ?> |
| /branches/refact/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); |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/eflore/cartes/GeneralFormateur.php |
|---|
| New file |
| 0,0 → 1,307 |
| <?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) { |
| if ($inventory['collection_code'] == 'sophy') { |
| $date = ', en '.$inventory['date_observation']; |
| } else { |
| 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); |
| } |
| } |
| ?> |
| /branches/refact/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); |
| } |
| ?> |
| /branches/refact/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 |
| /branches/refact/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(' & ', ' & ', $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é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é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'; |
| } |
| } |
| } |
| ?> |
| /branches/refact/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 |
| /branches/refact/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; |
| } |
| } |
| ?> |
| /branches/refact/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é 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é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é 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é 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 |
| /branches/refact/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¶m2=val2&... |
| * |
| * Les paramètres de requête disponibles sont : masque, masque.gen (nom de genre), masque.sp (épithète d'espèce), masque.ssp (épithète infra-spécifique), |
| * masque.au (auteur du nom), masque.an (année de publication du nom), masque.bib (réf biblio de la publi d'origine du nom), masque.ad (nomen addendum), |
| * masque.nn (identifiant du nom), recherche, rang, distinct, retour.format, nl.format, nl.structure, navigation.depart et navigation.limite. |
| * |
| * 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ête SQL formée comporte une erreur !!'); |
| } elseif ($resultat) { |
| $res_version[$version] = $resultat; |
| } else { |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, |
| 'Les données recherché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ê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ê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ê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ê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é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 |
| /branches/refact/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¶m2=val2&... |
| * |
| * Les paramètres de requête disponibles sont : masque, recherche, rang, distinct, retour.format, nl.format, |
| * nl.structure, navigation.depart et navigation.limite. |
| * |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * @package framework-v3 |
| * @author Jennifer Dhé <jennifer.dhe@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class Taxons extends CommunNomsTaxons { |
| /** |
| * 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é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é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ê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é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; |
| } |
| } |
| ?> |
| /branches/refact/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']; |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/nvjfl/NomsVernaculaires.php |
|---|
| New file |
| 0,0 → 1,683 |
| <?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¶m2=val2&... |
| * |
| * Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche, |
| * distinct, retour.format, navigation.depart et navigation.limite. |
| * |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * @package framework-v3 |
| * @author Delphine Cauquil <delphine@tela-botanica.org> |
| * @author Jennifer Dhé <jennifer.dhe@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class NomsVernaculaires extends Commun { |
| protected $champ_infos = array( |
| 'taxon' => array('service' => 'taxons', 'ressource' => 'nt:', 'projet' => 'bdtfx', 'nom' => 'nom_sci'), |
| 'conseil_emploi' => array('service' => 'ontologies', 'ressource' => 'numStatut:', 'projet' => 'nvjfl', 'nom' => 'nom'), |
| 'genre' => array('service' => 'ontologies', 'ressource' => 'genreNombre:', 'projet' => 'nvjfl', 'nom' => 'nom')); |
| protected $service = 'noms-vernaculaires'; |
| /** |
| * Permet de stocker la requete formulée : /noms-vernaculaires | /noms-vernaculaires/#id | |
| * /noms-vernaculaires/#id/champ | /noms-vernaculaires/#id/relations |
| * Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service. |
| * Est utilisée principalement pr déterminer le format du tableau à retourner. */ |
| protected $format_reponse = 'noms-vernaculaires'; |
| /** Variables constituant les parametres de la requete SQL (champ, condition, limit) remplie |
| * selon ressources et paramètres */ |
| protected $requete_champ = array(' * '); |
| protected $requete_condition = ''; |
| protected $limite_requete = array( |
| 'depart' => 0, |
| 'limite' => 100 |
| ); |
| protected $champ_tri = 'code_langue'; |
| protected $direction_tri = 'asc'; |
| /** |
| * Indique les champs supplémentaires à retourner |
| * - conseil_emploi = conseil d'emploi du nom vernaculaire |
| * - genre = genre et nombre du nom |
| * - taxon = nom retenu associé à ce nom |
| */ |
| protected $champs_supp = array(); |
| /** |
| * Precise la contenance plus ou moins précise du tableau à retourner : |
| * - min = les données présentes dans la table |
| * - max = les données de la table + les informations complémentaires (pour les identifiants et les codes) |
| * - oss = la liste des nom_sci (uniquement pour noms et taxons) */ |
| protected $retour_format = 'max'; |
| /** Valeur du paramètre de requete recherche : |
| * - stricte : le masque est passé tel quel à l'opérateur LIKE. |
| * - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE. |
| * - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */ |
| protected $recherche; |
| /** Permet de stocker le tableau de résultat (non encodé en json) */ |
| protected $table_retour = array(); |
| /** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */ |
| protected $total_resultat; |
| private $config; |
| public function __construct($config) { |
| $this->config = is_null($config) ? Config::get('NomsVernaculaires') : $config; |
| } |
| //+------------------------------------------------------------------------------------------------------+ |
| // créer une condition en fonction du paramétre |
| public function traiterParametres() { |
| if (isset($this->parametres) && !empty($this->parametres)) { |
| if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') { |
| $this->recherche = $this->parametres['recherche']; |
| } |
| foreach ($this->parametres as $param => $valeur) { |
| switch ($param) { |
| case 'masque' : |
| $this->ajouterFiltreMasque('nom_vernaculaire', $valeur); |
| break; |
| case 'masque.nt' : |
| $this->ajouterFiltreMasque('num_taxon', $valeur); |
| break; |
| case 'masque.nv' : |
| $this->ajouterFiltreMasque('nom_vernaculaire', $valeur); |
| break; |
| case 'masque.lg' : |
| $this->ajouterFiltreMasque('code_langue', $valeur); |
| break; |
| case 'masque.cce' : |
| $this->ajouterFiltreMasque('num_statut', $valeur); |
| break; |
| case 'retour.format' : |
| $this->retour_format = $valeur; |
| break; |
| case 'navigation.depart' : |
| $this->limite_requete['depart'] = $valeur; |
| break; |
| case 'navigation.limite' : |
| $this->limite_requete['limite'] = $valeur; |
| break; |
| case 'retour.champs' : |
| $this->champs_supp = explode(',',$valeur); |
| break; |
| case 'recherche' : |
| break; |
| case 'version.projet' : |
| break; |
| default : |
| $p = 'Erreur dans les paramètres de recherche de votre requête : '. |
| '</br> Le paramètre " '.$param.' " n\'existe pas.'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $p); |
| } |
| } |
| } |
| } |
| public function ajouterFiltreMasque($nom_champ, $valeur) { |
| if ($nom_champ == 'num_taxon') { // si il s'agit d'un chiffre |
| $this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur); |
| } else { |
| if ($this->recherche == 'floue') { |
| $this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')' |
| .' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) '; |
| } else { |
| if ($this->recherche == 'etendue') { |
| $valeur = '%'.str_replace(' ','% ', $valeur); |
| $valeur .= '%'; |
| } |
| $this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur); |
| } |
| } |
| } |
| //+------------------------------------------------------------------------------------------------------+ |
| // en fonction de la présence des ressources modifie requete_champ et requete_condition |
| public function traiterRessources() { |
| if (isset($this->ressources) && !empty($this->ressources)) { |
| if (isset($this->ressources[0]) && !empty($this->ressources[0])) { |
| $this->traiterRessourceId(); // ajoute condition id=#valeur |
| if (isset($this->ressources[1]) && !empty($this->ressources[1])) { |
| $this->traiterRessourceChamp(); //modifie requete_champ ou requete_condition |
| } |
| } |
| } else { //rajoute distinct pour ne pas avoir plusieurs fois le même nom |
| $this->requete_champ = array('distinct(id)', 'nom_vernaculaire '); |
| } |
| } |
| //requete : /noms-vernaculaires/#id (ex : /noms-vernaculaires/7) |
| public function traiterRessourceId() { |
| if (is_numeric($this->ressources[0])) { |
| $this->requete_condition[] = ' id = '.$this->getBdd()->proteger($this->ressources[0]); |
| $this->format_reponse .= '/id'; |
| } elseif ($this->ressources[0] == 'attributions') { |
| $this->format_reponse .= '/attributions'; |
| } else { |
| $r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->ressources[0]. |
| ' " n\'existe pas.'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r); |
| } |
| } |
| public function traiterRessourceChamp() { |
| $this->format_reponse .= '/champ'; |
| $this->analyserChamp(); |
| } |
| public function analyserChamp() { |
| $this->requete_champ = array(); |
| $this->recupererTableConfig('champs_possibles');// s'il y a plusieurs champs correspondant au champ demandé ils sont séparé par des | |
| $champs = explode(' ', $this->ressources[1]); |
| foreach ($champs as $champ) { |
| preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match); |
| if (isset($this->champs_possibles[$match[1]])) { |
| $this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[1]]); |
| } elseif (isset($this->champs_possibles[$match[0]])) { |
| $this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[0]]); |
| } else { |
| $champs_possibles = implode('</li><li>', array_keys($this->champs_possibles)); |
| $c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '. |
| 'Les champs disponibles sont : <li>'.$champs_possibles.'</li> et leurs déclinaisons (ex. ".code").'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c); |
| } |
| } |
| } |
| //+------------------------------------------------------------------------------------------------------+ |
| public function assemblerLaRequete() { |
| $requete = ' SELECT '.$this->formerRequeteChamp(). |
| ' FROM '.$this->table |
| .$this->formerRequeteCondition() |
| .$this->formerRequeteLimite(); |
| return $requete; |
| } |
| public function formerRequeteChamp() { |
| if (in_array('*', $this->requete_champ)) { |
| $champ = ' * '; |
| } else { |
| $champ = implode(', ', $this->requete_champ); |
| } |
| return $champ; |
| } |
| public function formerRequeteCondition() { |
| $condition = ''; |
| if ($this->requete_condition != null) { |
| $condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
| } |
| return $condition; |
| } |
| //ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes |
| // suivantes : /noms-vernaculaires et /noms-vernaculaires/#id/relations) |
| public function formerRequeteLimite() { |
| if (in_array($this->format_reponse , array($this->service.'/id', $this->service.'/id/champs'))) { |
| $this->requete_limite = ''; |
| } elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) { |
| $this->limite_requete['depart'] = |
| (($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']); |
| $this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
| } else { |
| $this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
| } |
| return $this->requete_limite; |
| } |
| //on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /noms-vernaculaires) |
| public function recupererTotalResultat() { |
| $distinct = ($this->format_reponse == 'noms-vernaculaires/attributions') ? 'id' : 'distinct(id)'; |
| $requete = 'SELECT count('.$distinct.') as nombre FROM ' |
| .$this->table |
| .$this->formerRequeteCondition(); |
| $res = $this->getBdd()->recuperer($requete); |
| if ($res) { |
| $total = $res['nombre']; |
| } else { |
| $t = 'Fonction recupererTotalResultat() : <br/>Données introuvables dans la base '.$requete; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $t); |
| } |
| return $total; |
| } |
| //+------------------------------------------------------------------------------------------------------+ |
| // determine en fct du service appelé (/noms-vernaculaires | /noms-vernaculaires/#id | /noms-vernaculaires/#id/champ | |
| // /noms-vernaculaires/#id/relations) le format du tableau à retourner. |
| public function retournerResultatFormate($resultat) { |
| $this->recupererTableConfig('correspondance_champs'); |
| switch ($this->format_reponse) { |
| case 'noms-vernaculaires' : |
| $reponse = ($this->retour_format == 'oss') ? $this->formaterEnOss($resultat) : $this->formaterNomsVernaculaires($resultat); break; |
| case 'noms-vernaculaires/attributions' : $reponse = $this->formaterNomsVernaculairesAttributions($resultat); break; |
| case 'noms-vernaculaires/id' : $reponse = $this->formaterNomsVernaculairesId($resultat); break; |
| case 'noms-vernaculaires/id/champ' : $reponse = $this->formaterNomsVernaculairesIdChamp($resultat); break; |
| default : break; |
| } |
| return $reponse; |
| } |
| public function ajouterJsonEnTeteNV() { |
| $table_retour_json['masque'] = $this->recupererMasque(); |
| $table_retour_json['depart'] = $this->limite_requete['depart']; |
| $table_retour_json['limite'] = $this->limite_requete['limite']; |
| $table_retour_json['total'] = $this->total_resultat; |
| $url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires'); |
| if (isset($url['precedent']) && $url['precedent'] != '') { |
| $table_retour_json['href.precedent'] = $url['precedent']; |
| } |
| if (isset($url['suivant']) && $url['suivant'] != '') { |
| $table_retour_json['href.suivant'] = $url['suivant']; |
| } |
| return $table_retour_json; |
| } |
| public function ajouterJsonResultatNV($resultat) { |
| foreach ($resultat as $tab) { |
| foreach ($tab as $key => $valeur) { |
| if ($valeur != '') { |
| switch ($key) { |
| case 'id' : $num = $valeur; break; |
| case 'nom_vernaculaire' : $this->table_retour['nom'] = $valeur; break; |
| default : break; |
| } |
| } |
| } |
| if ($this->retour_format == 'max') $this->table_retour['href'] = $this->ajouterHref('noms-vernaculaires', $num); |
| $resultat_json[$num] = $this->table_retour; |
| $this->table_retour = array(); |
| } |
| return $resultat_json; |
| } |
| public function formaterNomsVernaculaires($resultat) { |
| $table_retour_json['entete'] = $this->ajouterJsonEnTeteNV(); |
| $resultat = $this->hierarchiserResultat($resultat); |
| $table_retour_json['resultat'] = $this->ajouterJsonResultatNV($resultat); |
| return $table_retour_json; |
| } |
| public function hierarchiserResultat($resultat) { |
| //tri recherche floue |
| if (isset($this->parametres['masque.nv'])) { |
| $resultat = $this->trierRechercheFloue($this->parametres['masque.nv'], $resultat, 'nom_vernaculaire'); |
| } |
| if (isset($this->parametres['masque'])) { |
| $resultat = $this->trierRechercheFloue($this->parametres['masque'], $resultat, 'nom_vernaculaire'); |
| } |
| return $resultat; |
| } |
| public function recupererMasque() { |
| $tab_masque = array(); |
| foreach ($this->parametres as $param=>$valeur) { |
| if (strstr($param, 'masque') != false) { |
| $tab_masque[] = $param.'='.$valeur; |
| } |
| } |
| $masque = implode('&', $tab_masque); |
| return $masque; |
| } |
| public function formaterEnOss($resultat) { |
| $table_nom = array(); |
| $oss = ''; |
| foreach ($resultat as $tab) { |
| if (isset($tab['nom_vernaculaire']) ) { |
| if (!in_array($tab['nom_vernaculaire'], $table_nom)) { |
| $table_nom[] = $tab['nom_vernaculaire']; |
| $oss [] = $tab['nom_vernaculaire']; |
| } |
| } |
| } |
| if (isset($this->masque)) $masque = implode('&', $this->masque); |
| else $masque = 'Pas de masque'; |
| $table_retour_oss = array($masque, $oss); |
| return $table_retour_oss; |
| } |
| public function formaterNomsVernaculairesAttributions($resultat) { |
| //on remplie la table $table_retour_json['entete'] |
| $table_retour_json['entete']['masque'] = $this->recupererMasque(); |
| $table_retour_json['entete']['depart'] = $this->limite_requete['depart']; |
| $table_retour_json['entete']['limite'] = $this->limite_requete['limite']; |
| $table_retour_json['entete']['total'] = $this->total_resultat; |
| $url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires/attributions'); |
| if (isset($url['precedent']) && $url['precedent'] != '') { |
| $table_retour_json['entete']['href.precedent'] = $url['precedent']; |
| } |
| if (isset($url['suivant']) && $url['suivant'] != '') { |
| $table_retour_json['entete']['href.suivant'] = $url['suivant']; |
| } |
| foreach ($resultat as &$tab) { |
| $resultat_json[$tab['num_nom_vernaculaire']]['id'] = $tab['id']; |
| $resultat_json[$tab['num_nom_vernaculaire']]['nom_vernaculaire'] = $tab['nom_vernaculaire']; |
| $resultat_json[$tab['num_nom_vernaculaire']]['code_langue'] = $tab['code_langue']; |
| $resultat_json[$tab['num_nom_vernaculaire']]['taxon.code'] = 'bdtfx.nt:'.$tab['num_taxon']; |
| if ($this->retour_format == 'max') { |
| $resultat_json[$tab['num_nom_vernaculaire']]['num_taxon'] = $tab['num_taxon']; |
| $resultat_json[$tab['num_nom_vernaculaire']]['nom_retenu.code'] = $tab['num_taxon']; |
| $resultat_json[$tab['num_nom_vernaculaire']]['taxon'] = $tab['num_taxon']; |
| $this->taxons[] = $tab['num_taxon']; // utilisé pour chercher les noms latins plus bas |
| $resultat_json[$tab['num_nom_vernaculaire']]['href'] = $this->ajouterHref('noms-vernaculaires', $tab['id']); |
| if($this->champs_supp != array()) { |
| $resultat_json[$tab['num_nom_vernaculaire']] = $this->ajouterChampsOntologieLigneResultat($tab); |
| } |
| } |
| } |
| if ($this->retour_format == 'max') { |
| // On est obligé de faire un deuxième boucle pour demander tous les taxons présents en une |
| // fois et les attribuer aux noms car c'est beaucoup plus rapide |
| $noms_sci = $this->recupererNomTaxons(); |
| foreach ($resultat_json as $num_nom => &$tab) { |
| $tab = $this->ajouterTaxonsAttributionsLigneResultat($tab, $noms_sci); |
| if($tab == null) { |
| unset($resultat_json[$num_nom]); |
| } |
| } |
| } |
| uasort($resultat_json, array($this,'trierLigneTableau')); |
| $table_retour_json['resultat'] = $resultat_json; |
| return $table_retour_json; |
| } |
| /** |
| * Ajoute les champs d'ontologie supplémentaires si necéssaire |
| * en faisant appels aux web services associés |
| * @param array $ligne_resultat |
| * |
| * @return array la ligne modifiée |
| */ |
| public function ajouterChampsOntologieLigneResultat($ligne_resultat) { |
| $intitule = ''; |
| foreach($this->champ_infos as $cle => $champs_supplementaires) { |
| if(in_array($cle, $this->champs_supp)) { |
| extract($champs_supplementaires); |
| $valeur_recherche = ''; |
| switch($cle) { |
| case 'taxon': |
| $valeur_recherche = $ligne_resultat['num_taxon']; |
| $intitule = 'taxon.code'; |
| break; |
| case 'genre': |
| $valeur_recherche = $ligne_resultat['num_genre']; |
| $intitule = 'genre'; |
| break; |
| case 'conseil_emploi': |
| $valeur_recherche = $ligne_resultat['num_statut']; |
| $intitule = 'conseil_emploi'; |
| break; |
| } |
| $code_valeur = ''; |
| if(trim($valeur_recherche) != '') { |
| $url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur_recherche, $projet); |
| $code_valeur = $this->chercherSignificationCode($url, $nom); |
| } |
| $ligne_resultat[$intitule] = $code_valeur; |
| } |
| } |
| return $ligne_resultat; |
| } |
| /** |
| * Fonction qui ajoute les attributions à une ligne de résultats |
| * |
| * @param array $ligne_tableau_resultat |
| * @param array $nom_sci |
| */ |
| public function ajouterTaxonsAttributionsLigneResultat(&$ligne_tableau_resultat, &$noms_sci) { |
| if (isset($noms_sci[$ligne_tableau_resultat['num_taxon']])) { |
| $ligne_tableau_resultat['nom_retenu.code'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['id']; |
| $ligne_tableau_resultat['taxon'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['nom_sci']; |
| } else { |
| $ligne_tableau_resultat = null; |
| } |
| return $ligne_tableau_resultat; |
| } |
| private function trierLigneTableau($a, $b) { |
| $retour = 0; |
| if ($a[$this->champ_tri] == $b[$this->champ_tri]) { |
| $retour = 0; |
| } |
| if($this->champ_tri == 'code_langue') { |
| if ($a[$this->champ_tri] == 'fra' && $b[$this->champ_tri] != 'fra') { |
| $retour = ($this->direction_tri == 'asc') ? -1 : 1; |
| } else if ($a[$this->champ_tri] != 'fra' && $b[$this->champ_tri] == 'fra') { |
| $retour = ($this->direction_tri == 'asc') ? 1 : -1; |
| } else { |
| $retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]); |
| } |
| } else { |
| $retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]); |
| } |
| return $retour; |
| } |
| private function comparerChaineSelonDirectionTri($a, $b) { |
| if($this->direction_tri == 'asc') { |
| return ($a < $b) ? -1 : 1; |
| } else { |
| return ($a > $b) ? -1 : 1; |
| } |
| } |
| // formatage de la reponse /id ss la forme |
| // id, nom_vernaculaire, attributions |
| // langue |
| // num_nom (correspond à un taxon bdtfx) |
| public function formaterNomsVernaculairesId($resultat) { |
| foreach ($resultat as $taxon) { // pour chaque attribution à un taxon bdtfx |
| // on crée les variables qui serviront de clés et on les enléves du tableau |
| $num_nom = $taxon['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($this->champ_infos[$nomChamp])) { |
| extract($this->champ_infos[$nomChamp]); |
| } |
| if ($this->retour_format == 'max') { |
| $url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet); |
| if ($service == 'taxons') { |
| $code_valeur = ''; |
| $this->table_retour['attributions'][$langue][$num_nom]['nom_retenu.code'] = $code_valeur; |
| } else { |
| $code_valeur = $this->chercherSignificationCode($url, $nom); |
| } |
| if ($projet != '') $projet .= '.'; |
| $this->table_retour['attributions'][$langue][$num_nom][$nomChamp] = $code_valeur; |
| $this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur; |
| $this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.href'] = $url; |
| } else { |
| if ($projet != '') $projet .= '.'; |
| $this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur; |
| } |
| } |
| public function chercherSignificationCode($url, $nom) { |
| if (isset($this->signification_code[$url])) { |
| $valeur = $this->signification_code[$url]; |
| } else { |
| $res = $this->consulterHref($url); |
| $valeur = $res->$nom; |
| $this->signification_code[$url] = $valeur; |
| } |
| return $valeur; |
| } |
| public function afficherTaxons() { |
| $resultat = $this->recupererNomTaxons(); |
| foreach ($this->table_retour['attributions'] as $code_langue=>$langue) { |
| foreach ($langue as $num_nom=>$taxon) { |
| $num_tax = ltrim($taxon['taxon.code'], 'bdtfx.nt:'); |
| if (isset($resultat[$num_tax])) { |
| $this->table_retour['attributions'][$code_langue][$num_nom]['nom_retenu.code'] = $resultat[$num_tax]['id']; |
| $this->table_retour['attributions'][$code_langue][$num_nom]['taxon'] = $resultat[$num_tax]['nom_sci']; |
| } |
| } |
| } |
| } |
| public function recupererNomTaxons() { |
| $taxons = array_unique($this->taxons); |
| $url = Config::get('url_service_base').'bdtfx/taxons?navigation.limite=500&ns.structure=au&masque.nt='.implode(',', $taxons); |
| $res = $this->consulterHref($url); |
| foreach ($res->resultat as $id=>$taxon) { |
| $resultat[$taxon->num_taxonomique]['id'] = 'bdtfx.nn:'.$id; |
| $resultat[$taxon->num_taxonomique]['nom_sci'] = $taxon->nom_sci_complet; |
| } |
| return $resultat; |
| } |
| public function formaterNomsVernaculairesIdChamp($resultat) { |
| $this->table_retour['id'] = $this->ressources[0]; |
| $champs = explode(' ', $this->ressources[1]); |
| if (in_array('attributions', $champs) != false) { |
| $this->formaterNomsVernaculairesId($resultat); |
| unset($this->table_retour['nom_vernaculaire']); |
| } else { |
| $champ_attributions = array('num_taxon', 'zone_usage', 'num_statut', 'num_genre', 'notes'); |
| foreach ($resultat as $taxon) { |
| foreach ($taxon as $key=>$valeur) { |
| if ($key == 'code_langue' && in_array('langue', $champs) != false) { |
| $this->table_retour['attributions']['langue'][] = $valeur; |
| } elseif (in_array($key, $champ_attributions) != false) { |
| $this->afficherPoint($this->correspondance_champs[$key] , $valeur, $taxon['code_langue'], $taxon['num_nom_vernaculaire']); |
| } elseif (in_array($key, $champs) != false) { |
| $this->table_retour[$key] = $valeur; |
| } |
| } |
| if (in_array('biblio', $champs) != false) $this->chargerBiblio($taxon['num_nom_vernaculaire'], $taxon['code_langue']); |
| } |
| if (in_array('biblio', $champs) != false && array_search('biblio.num_ref', $this->table_retour) != false) $this->table_retour['biblio'] = null; |
| } |
| return $this->table_retour; |
| } |
| public function afficherPoint($champ, $valeur, $langue, $num_nom) { |
| preg_match('/^(.*)\.code$/', $champ, $match); |
| $champ = $match[1]; |
| if (isset($this->champ_infos[$champ])) { |
| extract($this->champ_infos[$champ]); |
| $url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet); |
| $projet .= '.'; |
| } |
| $champs = explode(' ', $this->ressources[1]); |
| if (in_array($champ.'.*', $champs) !== false && isset($projet)) { |
| $this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur; |
| $this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url; |
| } |
| if (in_array($champ.'.code', $champs) !== false && isset($projet)) { |
| $this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur; |
| } |
| if (in_array($champ.'.href', $champs) !== false && isset($projet)) { |
| $this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url; |
| } |
| if (in_array($champ, $champs) !== false) { |
| if (isset($url)) { |
| $this->table_retour['attributions'][$langue][$num_nom][$champ] = $this->chercherSignificationCode($url, $nom); |
| } else { |
| $this->table_retour['attributions'][$langue][$champ] = $valeur; |
| } |
| } |
| } |
| public function afficherLangue($nomChamp, $projet, $service, $valeur, $ressource = '', $nom = 'nom') { |
| if ($this->retour_format == 'max') { |
| $this->table_retour['attributions'][$nomChamp] = $nom; |
| $this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur; |
| $this->table_retour['attributions'][$nomChamp.'.href'] = $url; |
| } else { |
| $this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur; |
| } |
| } |
| 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; |
| } |
| } |
| } |
| } |
| } |
| } |
| ?> |
| /branches/refact/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; |
| } |
| } |
| ?> |
| /branches/refact/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¶m2=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; |
| } |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/iso-3166-1/ZoneGeo.php |
|---|
| New file |
| 0,0 → 1,401 |
| <?php |
| /** |
| * Description : |
| * Classe ZoneGeo.php fournit des informations sur un ensemble de lieux à une échelle donnée. |
| * Le but étant de fournir un ensemble minimal d'information comprenant : |
| * un identifiant (numérique ou alphanumérique sous forme de ChatMot si possible), un nom, une region et |
| * éventuellement une relation hiérarchique avec un autre terme (=classe). |
| * Si l'url finit par /zone-geo on retourne une liste de zones (seulement les 100 premières par défaut). |
| * L'url peut contenir des paramètres optionnels passés après le ? : /zone-geo?param1=val1¶m2=val2&... |
| * |
| * Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche, |
| * distinct, retour.format, navigation.depart et navigation.limite. |
| * |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * @package framework-v3 |
| * @author Delphine Cauquil <delphine@tela-botanica.org> |
| * @author Jennifer Dhé <jennifer.dhe@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class ZoneGeo extends Commun { |
| protected $service = 'zone-geo'; |
| /** |
| * Permet de stocker la requete formulée : /zone-geo | /zone-geo/#id | /zone-geo/#id/champ | /zone-geo/#id/relations |
| * Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service. |
| * Est utilisée principalement pr déterminer le format du tableau à retourner. */ |
| protected $format_reponse = 'zone-geo'; |
| /** Variables constituant les parametres de la requete SQL (champ, condition, group by, limit) remplie |
| * selon ressources et paramètres */ |
| protected $requete_champ = ' * '; |
| protected $requete_condition = ''; |
| protected $limite_requete = array( |
| 'depart' => 0, |
| 'limite' => 100 |
| ); |
| /** Stockage des ressources et paramétres */ |
| protected $table_ressources = array(); |
| protected $table_param = array(); |
| /** |
| * Precise la contenance plus ou moins précise du tableau à retourner : |
| * - min = les données présentes dans la table |
| * - max = les données de la table + les informations complémentaires (pour les identifiants et les codes) |
| * - oss = la liste des nom_sci (uniquement pour noms et taxons) |
| */ |
| protected $retour_format = 'max'; |
| /** Valeur du paramètre de requete recherche : |
| * - stricte : le masque est passé tel quel à l'opérateur LIKE. |
| * - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE. |
| * - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */ |
| protected $recherche; |
| /** Permet de stocker le tableau de résultat (non encodé en json) */ |
| protected $table_retour = array(); |
| /** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */ |
| protected $total_resultat; |
| // +-----------------------------------------------------------------------------------------------------+ |
| public function traiterParametres() { |
| if (isset($this->parametres) && !empty($this->parametres)) { |
| $this->table_param = $this->parametres; |
| // masque : filtre la liste en fonction d'un masque de recherche portant sur le code, le nom ou la region. |
| // masque.code : filtre uniquement sur le code. masque.nom : filtre uniquement sur le nom. |
| // masque.region : filtre uniquement sur la region. |
| if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') { |
| $this->recherche = $this->parametres['recherche']; |
| } |
| foreach ($this->parametres as $param => $valeur) { |
| switch ($param) { |
| case 'masque' : |
| $this->ajouterLeFiltreMasque('masque', $valeur); |
| break; |
| case 'masque.code' : |
| $this->ajouterLeFiltreMasque('codet', $valeur); |
| break; |
| case 'masque.nom' : |
| $this->ajouterLeFiltreMasque('nom', $valeur); |
| break; |
| case 'masque.statut' : |
| $this->ajouterLeFiltreMasque('codet_statut', $valeur); |
| break; |
| case 'retour.format' : |
| $this->retour_format = $valeur; |
| break; |
| case 'navigation.depart' : |
| $this->limite_requete['depart'] = $valeur; |
| break; |
| case 'navigation.limite' : |
| $this->limite_requete['limite'] = $valeur; |
| break; |
| case 'recherche' : |
| break; |
| default : |
| $p = 'Erreur dans les paramètres de recherche de votre requête : '. |
| '</br> Le paramètre " '.$param.' " n\'existe pas.'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $p); break; |
| } |
| } |
| } |
| } |
| public function ajouterLeFiltreMasque($nom_champ, $valeur) { |
| if ($nom_champ == 'codet') { |
| $this->requete_condition[] .= $nom_champ.' = '.$this->getBdd()->proteger($valeur); |
| } else { |
| if ($this->recherche == 'floue') { |
| if ($nom_champ == 'masque') { |
| $this->requete_condition[] = ' ( codet = '.$this->getBdd()->proteger($valeur) |
| .' OR (SOUNDEX(nom_francais) = SOUNDEX(\''.$valeur.'\')' |
| .' OR SOUNDEX(REVERSE(nom_francais)) = SOUNDEX(REVERSE(\''.$valeur.'\')) OR ' |
| .'SOUNDEX(nom_anglais) = SOUNDEX(\''.$valeur.'\')' |
| .' OR SOUNDEX(REVERSE(nom_anglais)) = SOUNDEX(REVERSE(\''.$valeur.'\'))) ' |
| .' OR ( SOUNDEX(codet_statut) = SOUNDEX(\''.$valeur.'\')' |
| .' OR SOUNDEX(REVERSE(codet_statut)) = SOUNDEX(REVERSE(\''.$valeur.'\')) ' |
| .')) '; |
| } elseif ($nom_champ == 'nom') { |
| $this->requete_condition[] = '(SOUNDEX(nom_francais) = SOUNDEX(\''.$valeur.'\')' |
| .' OR SOUNDEX(REVERSE(nom_francais)) = SOUNDEX(REVERSE(\''.$valeur.'\'))) OR |
| (SOUNDEX(nom_anglais) = SOUNDEX(\''.$valeur.'\')' |
| .' OR SOUNDEX(REVERSE(nom_anglais)) = SOUNDEX(REVERSE(\''.$valeur.'\'))) '; |
| } else { |
| $this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')' |
| .' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) '; |
| } |
| } else { |
| if ($this->recherche == 'etendue') { |
| $valeur = str_replace(' ','%', $valeur); |
| $valeur .= '%'; |
| } |
| if ($nom_champ == 'masque') { |
| $this->requete_condition[] = '(codet = '.$this->getBdd()->proteger($valeur) |
| .' OR nom_francais LIKE '.$this->getBdd()->proteger($valeur) |
| .' OR nom_anglais LIKE '.$this->getBdd()->proteger($valeur) |
| .' OR codet_statut LIKE '.$this->getBdd()->proteger($valeur).')'; |
| } elseif ($nom_champ == 'nom') { |
| $this->requete_condition[] = '(nom_francais LIKE '.$this->getBdd()->proteger($valeur).' OR ' |
| .'nom_anglais LIKE '.$this->getBdd()->proteger($valeur).') '; |
| } else { |
| $this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur); |
| } |
| } |
| } |
| } |
| // +-----------------------------------------------------------------------------------------------------+ |
| public function traiterRessources() { |
| if (isset($this->ressources) && !empty($this->ressources)) { |
| $this->table_ressources = $this->ressources; |
| if (isset($this->table_ressources[0]) && !empty($this->table_ressources[0])) { |
| //requete = /zone-geo/#id |
| $this->traiterRessourceId(); |
| if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) { |
| //requete = /zone-geo/#id/#champ ou /zone-geo/#id/relations |
| $this->traiterRessourceChampOuRelations(); |
| } |
| } |
| } |
| } |
| public function traiterRessourceId() { |
| //requete : /zone-geo/#id (ex : /zone-geo/7) |
| if ($this->table_ressources[0]) { |
| $this->requete_condition[] = ' codet = '.$this->getBdd()->proteger($this->table_ressources[0]); |
| $this->format_reponse .= '/id'; |
| } else { |
| $r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->table_ressources[0]. |
| ' " n\'existe pas.'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r); |
| } |
| } |
| public function traiterRessourceChampOuRelations() { |
| if ($this->table_ressources[1] == 'relations') { |
| $r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->table_ressources[1]. |
| ' " n\'existe pas.'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r); |
| } else { |
| $this->format_reponse .= '/champ'; |
| } |
| } |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| public function assemblerLaRequete() { |
| //assemblage de la requete : |
| $requete = ' SELECT '.$this->requete_champ. |
| ' FROM '.$this->table |
| .$this->formerRequeteCondition() |
| .$this->formerRequeteLimite(); |
| return $requete; |
| } |
| //ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes |
| // suivantes : /zone-geo et /zone-geo/#id/relations) |
| public function formerRequeteLimite() { |
| if ($this->format_reponse != 'zone-geo') { |
| $this->requete_limite = ''; |
| } elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) { |
| //cas ou la requete presente un navigation.depart supérieur au nb total de resultats. |
| $this->limite_requete['depart'] = |
| (($nb - $this->limite_requete['limite']) < 0) ? 0 : ($nb - $this->limite_requete['limite']); |
| $this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
| } else { |
| $this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
| } |
| return $this->requete_limite; |
| } |
| public function formerRequeteCondition() { |
| $condition = ''; |
| if ($this->requete_condition != null) { |
| $condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
| } |
| return $condition; |
| } |
| public function recupererTotalResultat() { |
| //on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /zone-geo) |
| $requete = 'SELECT count(*) as nombre FROM ' |
| .$this->table |
| .$this->formerRequeteCondition(); |
| $res = $this->getBdd()->recuperer($requete); |
| if ($res) { |
| $total = $res['nombre']; |
| } else { |
| $t = 'Fonction recupererTotalResultat() : <br/>Données introuvables dans la base'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $t); |
| } |
| return $total; |
| } |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| // determine en fct du service appelé (/zone-geo | /zone-geo/#id | /zone-geo/#id/champ | |
| // /zone-geo/#id/relations) le format du tableau à retourner. Encode en json |
| public function retournerResultatFormate($resultat) { |
| $this->recupererTableConfig('correspondance_champs'); |
| switch ($this->format_reponse) { |
| case 'zone-geo' : $reponse = $this->formaterZoneGeo($resultat); break; |
| case 'zone-geo/id' : $reponse = $this->formaterZoneGeoId($resultat[0]); break; |
| case 'zone-geo/id/champ' : $reponse = $this->formaterZoneGeoIdChamp($resultat[0]); break; |
| default : break; |
| } |
| return $reponse; |
| } |
| public function formaterZoneGeo($resultat) { |
| //on remplit la table $table_retour_json['entete'] |
| $this->table_retour['depart'] = $this->limite_requete['depart']; |
| $this->table_retour['limite'] = $this->limite_requete['limite']; |
| $this->table_retour['total'] = $this->total_resultat; |
| $url = $this->formulerUrl($this->total_resultat, '/zone-geo'); |
| if (isset($url['precedent']) && $url['precedent'] != '') { |
| $this->table_retour['href.precedent'] = $url['precedent']; |
| } |
| if (isset($url['suivant']) && $url['suivant'] != '') { |
| $this->table_retour['href.suivant'] = $url['suivant']; |
| } |
| $table_retour_json['entete'] = $this->table_retour; |
| //on remplit la table $table_retour_json['resultat'] |
| $this->table_retour = array(); |
| if (isset($this->table_param['masque_nom'])) $resultat = $this->trierRechercheFloue($this->table_param['masque_nom'], $resultat, 'nom_francais'); |
| foreach ($resultat as $tab) { |
| foreach ($tab as $key => $valeur) { |
| $valeur = rtrim($valeur); |
| if ($valeur != '') { |
| switch ($key) { |
| case 'codet' : $num = $valeur; $this->table_retour['code'] = $valeur; break; |
| case 'nom_francais' : $this->table_retour['nom'] = $valeur; break; |
| case 'nom_anglais' : if ($tab['nom_francais'] == '') $this->table_retour['nom'] = $valeur; break; |
| case 'codet_statut' : $this->table_retour['statut'] = $valeur; break; |
| default : break; |
| } |
| } |
| } |
| if ($this->retour_format == 'max') { |
| $this->table_retour['href'] = $this->ajouterHref('zone-geo', $num); |
| } |
| $resultat_json[$num] = $this->table_retour; |
| $this->table_retour = array(); |
| } |
| $table_retour_json['resultat'] = $resultat_json; |
| return $table_retour_json; |
| } |
| public function formaterZoneGeoId($resultat) { |
| foreach ($resultat as $key => $valeur) { |
| if ($valeur != '') { |
| $this->afficherDonnees($key, $valeur); |
| } |
| } |
| unset($this->table_retour['href']); |
| return $this->table_retour; |
| } |
| public function formaterZoneGeoIdChamp($resultat) { |
| //on recupère tous les resultats possibles |
| $reponse = $this->formaterZoneGeoId($resultat); |
| $this->table_retour = array(); |
| //on recupère les résultats demandés à partir du tableau de résultat complet |
| $this->table_retour['id'] = $reponse['code']; |
| $champs = explode(' ', $this->table_ressources[1]); |
| foreach ($champs as $champ) { |
| if ($champ == 'nom') $champ = 'nom.fr'; |
| if ($this->verifierValiditeChamp($champ)) { |
| if (strrpos($champ, '.*') !== false) { |
| $this->afficherPointEtoile($champ, $reponse); |
| } else { |
| if (isset($reponse[$champ])) { |
| $this->table_retour[$champ] = $reponse[$champ]; |
| } else { |
| $this->table_retour[$champ] = null; |
| } |
| } |
| } |
| } |
| return $this->table_retour; |
| } |
| public function verifierValiditeChamp($champ) { |
| preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match); |
| $champs_possibles = $this->correspondance_champs; |
| $champs_possibles[] = 'nom.*'; |
| if (in_array($match[1], $champs_possibles)) { |
| $validite = true; |
| } elseif (in_array($match[0], $champs_possibles)) { |
| $validite = true; |
| } else { |
| $champs_possibles = implode('</li><li>', $champs_possibles); |
| $c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '. |
| 'Les champs disponibles sont : <li>'.$champs_possibles.'</li>'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c); |
| } |
| return $validite; |
| } |
| public function afficherPointEtoile($champ, $reponse) { |
| preg_match('/^([^.]+\.)\*$/', $champ, $match); |
| foreach ($reponse as $chp => $valeur) { |
| if (strrpos($chp, $match[1]) !== false) { |
| if ($valeur != '') { |
| $this->table_retour[$chp] = $valeur; |
| } else { |
| $this->table_retour[$chp] = null; |
| } |
| } |
| } |
| } |
| public function afficherDonnees($champ, $valeur) { |
| if ($this->retour_format == 'max') { |
| if ($champ == 'codet_statut') { |
| $this->table_retour[$this->correspondance_champs[$champ]] = $valeur; |
| $this->table_retour[$this->correspondance_champs[$champ].'.href'] = |
| $this->ajouterHref('ontologies', 'masque.nom=Codet '.$valeur, '?'); |
| } else { |
| $this->table_retour[$this->correspondance_champs[$champ]] = $valeur; |
| } |
| } else { |
| $this->table_retour[$this->correspondance_champs[$champ]] = $valeur; |
| } |
| } |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| /** Permet de retourner l'url http://tela-botanica.org/service:eflore:0.1/[projet]/[version_projet]/[service]/[ressource]:[valeur] |
| * @param $service : correspond au nom de la ressource à laquelle on souhaite acceder |
| * @param $val : correspond au paramètre de la ressource (ex : |
| * @param $projet : est remplit dans les cas suivants : |
| * - si le projet dans lequel se trouve l'information est différent de celui du service appelé |
| * - si on souhaite rappeler le meme projet avec la meme ressource mais un parametre de ressource différent |
| */ |
| public function ajouterHref($service, $val, $separation = '/') { |
| $val = $this->encoderUrl($val); |
| if ($this->version_projet == '+') { |
| $url = Config::get('url_service_base').Config::get('nom_projet').'/'.$service.$separation.$val; |
| } else { |
| $url = Config::get('url_service_base').Config::get('nom_projet').'/'.$this->version_projet.'/'.$service.$separation.$val; |
| } |
| return $url; |
| } |
| public function encoderUrl($url) { |
| $url = str_replace(' ', '%20', $url); |
| $url = str_replace('?', urlencode('?'), $url); |
| return $url; |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/nvps/NomsVernaculaires.php |
|---|
| New file |
| 0,0 → 1,652 |
| <?php |
| /** |
| * Description : |
| * Classe NomsVernaculaires.php fournit une liste de noms vernaculaires et leur liaison à la bdtfx |
| * Le but étant de fournir un ensemble minimal d'information comprenant : |
| * un identifiant (numérique ou alphanumérique sous forme de ChatMot si possible), un nom, une langue et |
| * une relation avec un taxon de la bdtfx. |
| * Si l'url finit par /noms-vernaculaires on retourne une liste de noms (seulement les 100 premières par défaut). |
| * L'url peut contenir des paramètres optionnels passés après le ? : /observations?param1=val1¶m2=val2&... |
| * |
| * Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.region , recherche, |
| * distinct, retour.format, navigation.depart et navigation.limite. |
| * |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * @package framework-v3 |
| * @author Delphine Cauquil <delphine@tela-botanica.org> |
| * @author Jennifer Dhé <jennifer.dhe@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-${year} Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class NomsVernaculaires extends Commun { |
| protected $champ_infos = array( |
| 'taxon' => array('service' => 'taxons', 'ressource' => 'nt:', 'projet' => 'bdtfx', 'nom' => 'nom_sci')); |
| protected $service = 'noms-vernaculaires'; |
| /** |
| * Permet de stocker la requete formulée : /noms-vernaculaires | /noms-vernaculaires/#id | |
| * /noms-vernaculaires/#id/champ | /noms-vernaculaires/#id/relations |
| * Est remplit au cours de l'analyse des ressources (traiterRessources()), par défaut, a la valeur du service. |
| * Est utilisée principalement pr déterminer le format du tableau à retourner. */ |
| protected $format_reponse = 'noms-vernaculaires'; |
| /** Variables constituant les parametres de la requete SQL (champ, condition, limit) remplie |
| * selon ressources et paramètres */ |
| protected $requete_champ = array(' * '); |
| protected $requete_condition = ''; |
| protected $limite_requete = array( |
| 'depart' => 0, |
| 'limite' => 100 |
| ); |
| protected $champ_tri = 'code_langue'; |
| protected $direction_tri = 'asc'; |
| /** |
| * Indique les champs supplémentaires à retourner |
| * - conseil_emploi = conseil d'emploi du nom vernaculaire |
| * - genre = genre et nombre du nom |
| * - taxon = nom retenu associé à ce nom |
| */ |
| protected $champs_supp = array(); |
| /** |
| * Precise la contenance plus ou moins précise du tableau à retourner : |
| * - min = les données présentes dans la table |
| * - max = les données de la table + les informations complémentaires (pour les identifiants et les codes) |
| * - oss = la liste des nom_sci (uniquement pour noms et taxons) */ |
| protected $retour_format = 'max'; |
| /** Valeur du paramètre de requete recherche : |
| * - stricte : le masque est passé tel quel à l'opérateur LIKE. |
| * - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE. |
| * - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */ |
| protected $recherche; |
| /** Permet de stocker le tableau de résultat (non encodé en json) */ |
| protected $table_retour = array(); |
| /** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */ |
| protected $total_resultat; |
| private $config; |
| public function __construct($config) { |
| $this->config = is_null($config) ? Config::get('NomsVernaculaires') : $config; |
| } |
| //+------------------------------------------------------------------------------------------------------+ |
| // créer une condition en fonction du paramétre |
| public function traiterParametres() { |
| if (isset($this->parametres) && !empty($this->parametres)) { |
| if (isset($this->parametres['recherche']) && $this->parametres['recherche'] != '') { |
| $this->recherche = $this->parametres['recherche']; |
| } |
| foreach ($this->parametres as $param => $valeur) { |
| switch ($param) { |
| case 'masque' : |
| $this->ajouterFiltreMasque('nom_vernaculaire', $valeur); |
| break; |
| case 'masque.nt' : |
| $this->ajouterFiltreMasque('num_taxon', $valeur); |
| break; |
| case 'masque.nv' : |
| $this->ajouterFiltreMasque('nom_vernaculaire', $valeur); |
| break; |
| case 'masque.lg' : |
| $this->ajouterFiltreMasque('code_langue', $valeur); |
| break; |
| case 'masque.cce' : |
| $this->ajouterFiltreMasque('num_statut', $valeur); |
| break; |
| case 'retour.format' : |
| $this->retour_format = $valeur; |
| break; |
| case 'navigation.depart' : |
| $this->limite_requete['depart'] = $valeur; |
| break; |
| case 'navigation.limite' : |
| $this->limite_requete['limite'] = $valeur; |
| break; |
| case 'retour.champs' : |
| $this->champs_supp = explode(',',$valeur); |
| break; |
| case 'recherche' : |
| break; |
| case 'version.projet' : |
| break; |
| default : |
| $p = 'Erreur dans les paramètres de recherche de votre requête : '. |
| '</br> Le paramètre " '.$param.' " n\'existe pas.'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $p); |
| } |
| } |
| } |
| } |
| public function ajouterFiltreMasque($nom_champ, $valeur) { |
| if ($nom_champ == 'num_taxon') { // si il s'agit d'un chiffre |
| $this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur); |
| } else { |
| if ($this->recherche == 'floue') { |
| $this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')' |
| .' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) '; |
| } else { |
| if ($this->recherche == 'etendue') { |
| $valeur = '%'.str_replace(' ','% ', $valeur); |
| $valeur .= '%'; |
| } |
| $this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur); |
| } |
| } |
| } |
| //+------------------------------------------------------------------------------------------------------+ |
| // en fonction de la présence des ressources modifie requete_champ et requete_condition |
| public function traiterRessources() { |
| if (isset($this->ressources) && !empty($this->ressources)) { |
| if (isset($this->ressources[0]) && !empty($this->ressources[0])) { |
| $this->traiterRessourceId(); // ajoute condition id=#valeur |
| if (isset($this->ressources[1]) && !empty($this->ressources[1])) { |
| $this->traiterRessourceChamp(); //modifie requete_champ ou requete_condition |
| } |
| } |
| } else { //rajoute distinct pour ne pas avoir plusieurs fois le même nom |
| $this->requete_champ = array('distinct(id)', 'nom_vernaculaire '); |
| } |
| } |
| //requete : /noms-vernaculaires/#id (ex : /noms-vernaculaires/7) |
| public function traiterRessourceId() { |
| if (is_numeric($this->ressources[0])) { |
| $this->requete_condition[] = ' id = '.$this->getBdd()->proteger($this->ressources[0]); |
| $this->format_reponse .= '/id'; |
| } elseif ($this->ressources[0] == 'attributions') { |
| $this->format_reponse .= '/attributions'; |
| } else { |
| $r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->ressources[0]. |
| ' " n\'existe pas.'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r); |
| } |
| } |
| public function traiterRessourceChamp() { |
| $this->format_reponse .= '/champ'; |
| $this->analyserChamp(); |
| } |
| public function analyserChamp() { |
| $this->requete_champ = array(); |
| $this->recupererTableConfig('champs_possibles');// s'il y a plusieurs champs correspondant au champ demandé ils sont séparé par des | |
| $champs = explode(' ', $this->ressources[1]); |
| foreach ($champs as $champ) { |
| preg_match('/^([^.]+)(\.([^.]+))?$/', $champ, $match); |
| if (isset($this->champs_possibles[$match[1]])) { |
| $this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[1]]); |
| } elseif (isset($this->champs_possibles[$match[0]])) { |
| $this->requete_champ[] = str_replace('|', ', ', $this->champs_possibles[$match[0]]); |
| } else { |
| $champs_possibles = implode('</li><li>', array_keys($this->champs_possibles)); |
| $c = 'Erreur dans votre requête : </br> Le champ "'.$champ_possibles.'" n\'existe pas. '. |
| 'Les champs disponibles sont : <li>'.$champs_possibles.'</li> et leurs déclinaisons (ex. ".code").'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $c); |
| } |
| } |
| } |
| //+------------------------------------------------------------------------------------------------------+ |
| public function assemblerLaRequete() { |
| $requete = ' SELECT '.$this->formerRequeteChamp(). |
| ' FROM '.$this->table |
| .$this->formerRequeteCondition() |
| .$this->formerRequeteLimite(); |
| return $requete; |
| } |
| public function formerRequeteChamp() { |
| if (in_array('*', $this->requete_champ)) { |
| $champ = ' * '; |
| } else { |
| $champ = implode(', ', $this->requete_champ); |
| } |
| return $champ; |
| } |
| public function formerRequeteCondition() { |
| $condition = ''; |
| if ($this->requete_condition != null) { |
| $condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
| } |
| return $condition; |
| } |
| //ajout d'une limite seulement pour les listes (pas plus de 100 resultats retournés pr les requetes |
| // suivantes : /noms-vernaculaires et /noms-vernaculaires/#id/relations) |
| public function formerRequeteLimite() { |
| if (in_array($this->format_reponse , array($this->service.'/id', $this->service.'/id/champs'))) { |
| $this->requete_limite = ''; |
| } elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat = $this->recupererTotalResultat())) { |
| $this->limite_requete['depart'] = |
| (($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']); |
| $this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
| } else { |
| $this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
| } |
| return $this->requete_limite; |
| } |
| //on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /noms-vernaculaires) |
| public function recupererTotalResultat() { |
| $distinct = ($this->format_reponse == 'noms-vernaculaires/attributions') ? 'id' : 'distinct(id)'; |
| $requete = 'SELECT count('.$distinct.') as nombre FROM ' |
| .$this->table |
| .$this->formerRequeteCondition(); |
| $res = $this->getBdd()->recuperer($requete); |
| if ($res) { |
| $total = $res['nombre']; |
| } else { |
| $t = 'Fonction recupererTotalResultat() : <br/>Données introuvables dans la base '.$requete; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $t); |
| } |
| return $total; |
| } |
| //+------------------------------------------------------------------------------------------------------+ |
| // determine en fct du service appelé (/noms-vernaculaires | /noms-vernaculaires/#id | /noms-vernaculaires/#id/champ | |
| // /noms-vernaculaires/#id/relations) le format du tableau à retourner. |
| public function retournerResultatFormate($resultat) { |
| $this->recupererTableConfig('correspondance_champs'); |
| switch ($this->format_reponse) { |
| case 'noms-vernaculaires' : |
| $reponse = ($this->retour_format == 'oss') ? $this->formaterEnOss($resultat) : $this->formaterNomsVernaculaires($resultat); break; |
| case 'noms-vernaculaires/attributions' : $reponse = $this->formaterNomsVernaculairesAttributions($resultat); break; |
| case 'noms-vernaculaires/id' : $reponse = $this->formaterNomsVernaculairesId($resultat); break; |
| case 'noms-vernaculaires/id/champ' : $reponse = $this->formaterNomsVernaculairesIdChamp($resultat); break; |
| default : break; |
| } |
| return $reponse; |
| } |
| public function ajouterJsonEnTeteNV() { |
| $table_retour_json['masque'] = $this->recupererMasque(); |
| $table_retour_json['depart'] = $this->limite_requete['depart']; |
| $table_retour_json['limite'] = $this->limite_requete['limite']; |
| $table_retour_json['total'] = $this->total_resultat; |
| $url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires'); |
| if (isset($url['precedent']) && $url['precedent'] != '') { |
| $table_retour_json['href.precedent'] = $url['precedent']; |
| } |
| if (isset($url['suivant']) && $url['suivant'] != '') { |
| $table_retour_json['href.suivant'] = $url['suivant']; |
| } |
| return $table_retour_json; |
| } |
| public function ajouterJsonResultatNV($resultat) { |
| foreach ($resultat as $tab) { |
| foreach ($tab as $key => $valeur) { |
| if ($valeur != '') { |
| switch ($key) { |
| case 'id' : $num = $valeur; break; |
| case 'nom_vernaculaire' : $this->table_retour['nom'] = $valeur; break; |
| default : break; |
| } |
| } |
| } |
| if ($this->retour_format == 'max') $this->table_retour['href'] = $this->ajouterHref('noms-vernaculaires', $num); |
| $resultat_json[$num] = $this->table_retour; |
| $this->table_retour = array(); |
| } |
| return $resultat_json; |
| } |
| public function formaterNomsVernaculaires($resultat) { |
| $table_retour_json['entete'] = $this->ajouterJsonEnTeteNV(); |
| $resultat = $this->hierarchiserResultat($resultat); |
| $table_retour_json['resultat'] = $this->ajouterJsonResultatNV($resultat); |
| return $table_retour_json; |
| } |
| public function hierarchiserResultat($resultat) { |
| //tri recherche floue |
| if (isset($this->parametres['masque.nv'])) { |
| $resultat = $this->trierRechercheFloue($this->parametres['masque.nv'], $resultat, 'nom_vernaculaire'); |
| } |
| if (isset($this->parametres['masque'])) { |
| $resultat = $this->trierRechercheFloue($this->parametres['masque'], $resultat, 'nom_vernaculaire'); |
| } |
| return $resultat; |
| } |
| public function recupererMasque() { |
| $tab_masque = array(); |
| foreach ($this->parametres as $param=>$valeur) { |
| if (strstr($param, 'masque') != false) { |
| $tab_masque[] = $param.'='.$valeur; |
| } |
| } |
| $masque = implode('&', $tab_masque); |
| return $masque; |
| } |
| public function formaterEnOss($resultat) { |
| $table_nom = array(); |
| $oss = ''; |
| foreach ($resultat as $tab) { |
| if (isset($tab['nom_vernaculaire']) ) { |
| if (!in_array($tab['nom_vernaculaire'], $table_nom)) { |
| $table_nom[] = $tab['nom_vernaculaire']; |
| $oss [] = $tab['nom_vernaculaire']; |
| } |
| } |
| } |
| if (isset($this->masque)) $masque = implode('&', $this->masque); |
| else $masque = 'Pas de masque'; |
| $table_retour_oss = array($masque, $oss); |
| return $table_retour_oss; |
| } |
| public function formaterNomsVernaculairesAttributions($resultat) { |
| //on remplie la table $table_retour_json['entete'] |
| $table_retour_json['entete']['masque'] = $this->recupererMasque(); |
| $table_retour_json['entete']['depart'] = $this->limite_requete['depart']; |
| $table_retour_json['entete']['limite'] = $this->limite_requete['limite']; |
| $table_retour_json['entete']['total'] = $this->total_resultat; |
| $url = $this->formulerUrl($this->total_resultat, '/noms-vernaculaires/attributions'); |
| if (isset($url['precedent']) && $url['precedent'] != '') { |
| $table_retour_json['entete']['href.precedent'] = $url['precedent']; |
| } |
| if (isset($url['suivant']) && $url['suivant'] != '') { |
| $table_retour_json['entete']['href.suivant'] = $url['suivant']; |
| } |
| foreach ($resultat as &$tab) { |
| $resultat_json[$tab['id']]['id'] = $tab['id']; |
| $resultat_json[$tab['id']]['nom_vernaculaire'] = $tab['nom_vernaculaire']; |
| $resultat_json[$tab['id']]['code_langue'] = $tab['code_langue']; |
| $resultat_json[$tab['id']]['taxon.code'] = 'bdtfx.nt:'.$tab['num_taxon']; |
| if ($this->retour_format == 'max') { |
| $resultat_json[$tab['id']]['num_taxon'] = $tab['num_taxon']; |
| $resultat_json[$tab['id']]['nom_retenu.code'] = $tab['num_taxon']; |
| $resultat_json[$tab['id']]['taxon'] = $tab['num_taxon']; |
| $this->taxons[] = $tab['num_taxon']; // utilisé pour chercher les noms latins plus bas |
| $resultat_json[$tab['id']]['href'] = $this->ajouterHref('noms-vernaculaires', $tab['id']); |
| if($this->champs_supp != array()) { |
| $resultat_json[$tab['id']] = $this->ajouterChampsOntologieLigneResultat($tab); |
| } |
| } |
| } |
| if ($this->retour_format == 'max') { |
| // On est obligé de faire un deuxième boucle pour demander tous les taxons présents en une |
| // fois et les attribuer aux noms car c'est beaucoup plus rapide |
| $noms_sci = $this->recupererNomTaxons(); |
| foreach ($resultat_json as $num_nom => &$tab) { |
| $tab = $this->ajouterTaxonsAttributionsLigneResultat($tab, $noms_sci); |
| if($tab == null) { |
| unset($resultat_json[$num_nom]); |
| } |
| } |
| } |
| uasort($resultat_json, array($this,'trierLigneTableau')); |
| $table_retour_json['resultat'] = $resultat_json; |
| return $table_retour_json; |
| } |
| /** |
| * Ajoute les champs d'ontologie supplémentaires si necéssaire |
| * en faisant appels aux web services associés |
| * @param array $ligne_resultat |
| * |
| * @return array la ligne modifiée |
| */ |
| public function ajouterChampsOntologieLigneResultat($ligne_resultat) { |
| $intitule = ''; |
| foreach($this->champ_infos as $cle => $champs_supplementaires) { |
| if(in_array($cle, $this->champs_supp)) { |
| extract($champs_supplementaires); |
| $valeur_recherche = ''; |
| switch($cle) { |
| case 'taxon': |
| $valeur_recherche = $ligne_resultat['num_taxon']; |
| $intitule = 'taxon.code'; |
| break; |
| } |
| $code_valeur = ''; |
| if(trim($valeur_recherche) != '') { |
| $url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur_recherche, $projet); |
| $code_valeur = $this->chercherSignificationCode($url, $nom); |
| } |
| $ligne_resultat[$intitule] = $code_valeur; |
| } |
| } |
| return $ligne_resultat; |
| } |
| /** |
| * Fonction qui ajoute les attributions à une ligne de résultats |
| * |
| * @param array $ligne_tableau_resultat |
| * @param array $nom_sci |
| */ |
| public function ajouterTaxonsAttributionsLigneResultat(&$ligne_tableau_resultat, &$noms_sci) { |
| if (isset($noms_sci[$ligne_tableau_resultat['num_taxon']])) { |
| $ligne_tableau_resultat['nom_retenu.code'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['id']; |
| $ligne_tableau_resultat['taxon'] = $noms_sci[$ligne_tableau_resultat['num_taxon']]['nom_sci']; |
| } else { |
| $ligne_tableau_resultat = null; |
| } |
| return $ligne_tableau_resultat; |
| } |
| private function trierLigneTableau($a, $b) { |
| $retour = 0; |
| if ($a[$this->champ_tri] == $b[$this->champ_tri]) { |
| $retour = 0; |
| } |
| if($this->champ_tri == 'code_langue') { |
| if ($a[$this->champ_tri] == 'fra' && $b[$this->champ_tri] != 'fra') { |
| $retour = ($this->direction_tri == 'asc') ? -1 : 1; |
| } else if ($a[$this->champ_tri] != 'fra' && $b[$this->champ_tri] == 'fra') { |
| $retour = ($this->direction_tri == 'asc') ? 1 : -1; |
| } else { |
| $retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]); |
| } |
| } else { |
| $retour = $this->comparerChaineSelonDirectionTri($a[$this->champ_tri], $b[$this->champ_tri]); |
| } |
| return $retour; |
| } |
| private function comparerChaineSelonDirectionTri($a, $b) { |
| if($this->direction_tri == 'asc') { |
| return ($a < $b) ? -1 : 1; |
| } else { |
| return ($a > $b) ? -1 : 1; |
| } |
| } |
| // formatage de la reponse /id ss la forme |
| // id, nom_vernaculaire, attributions |
| // langue |
| // num_nom (correspond à un taxon bdtfx) |
| public function formaterNomsVernaculairesId($resultat) { |
| foreach ($resultat as $taxon) { // pour chaque attribution à un taxon bdtfx |
| // on crée les variables qui serviront de clés et on les enléves du tableau |
| $num_nom = $taxon['id']; // unique pour un trinôme id, langue, taxon |
| $langue = $taxon['code_langue']; |
| unset($taxon['code_langue']); |
| foreach ($this->correspondance_champs as $key => $correspondance) { // ordonne les infos pour affichage |
| if (isset($taxon[$key]) && $taxon[$key] != "") { |
| $this->afficherDonnees($correspondance, $taxon[$key], $langue, $num_nom); |
| } |
| } |
| foreach ($taxon as $key => $valeur) { // rajoute les champs non prévus dans l'api |
| if (!isset($this->correspondance_champs[$key]) && $valeur != "") { |
| $this->afficherDonnees($key, $valeur, $langue, $num_nom); |
| } |
| } |
| } |
| if ($this->retour_format == 'max') $this->afficherTaxons(); // va chercher les noms de tous les taxons |
| unset($this->table_retour['href']); |
| return $this->table_retour; |
| } |
| public function afficherDonnees($champ, $valeur, $langue = '', $num_nom = '') { |
| if ($champ == 'id' || $champ == 'nom_vernaculaire') { |
| $this->table_retour[$champ] = $valeur; |
| } elseif (preg_match('/^(.*)\.code$/', $champ, $match)) { |
| switch ($match[1]) { |
| case 'taxon' : if ($this->retour_format == 'max') {$this->taxons[$num_nom] = $valeur;} |
| $this->afficherPointCode($match[1], $langue, $num_nom, $valeur); break; |
| case 'langue' : //$this->afficherPointCode($match[1], 'iso-639-3', 'langues', $valeur); |
| break; |
| default : break; |
| } |
| } elseif ($langue != '') { |
| $this->table_retour['attributions'][$langue][$num_nom][$champ] = $valeur; |
| } else { |
| $this->table_retour[$champ] = $valeur; |
| } |
| } |
| public function afficherPointCode($nomChamp, $langue, $num_nom, $valeur) { |
| if (isset($this->champ_infos[$nomChamp])) { |
| extract($this->champ_infos[$nomChamp]); |
| } |
| if ($this->retour_format == 'max') { |
| $url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet); |
| if ($service == 'taxons') { |
| $code_valeur = ''; |
| $this->table_retour['attributions'][$langue][$num_nom]['nom_retenu.code'] = $code_valeur; |
| } else { |
| $code_valeur = $this->chercherSignificationCode($url, $nom); |
| } |
| if ($projet != '') $projet .= '.'; |
| $this->table_retour['attributions'][$langue][$num_nom][$nomChamp] = $code_valeur; |
| $this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur; |
| $this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.href'] = $url; |
| } else { |
| if ($projet != '') $projet .= '.'; |
| $this->table_retour['attributions'][$langue][$num_nom][$nomChamp.'.code'] = $projet.$ressource.$valeur; |
| } |
| } |
| public function chercherSignificationCode($url, $nom) { |
| if (isset($this->signification_code[$url])) { |
| $valeur = $this->signification_code[$url]; |
| } else { |
| $res = $this->consulterHref($url); |
| $valeur = $res->$nom; |
| $this->signification_code[$url] = $valeur; |
| } |
| return $valeur; |
| } |
| public function afficherTaxons() { |
| $resultat = $this->recupererNomTaxons(); |
| foreach ($this->table_retour['attributions'] as $code_langue=>$langue) { |
| foreach ($langue as $num_nom=>$taxon) { |
| $num_tax = ltrim($taxon['taxon.code'], 'bdtfx.nt:'); |
| if (isset($resultat[$num_tax])) { |
| $this->table_retour['attributions'][$code_langue][$num_nom]['nom_retenu.code'] = $resultat[$num_tax]['id']; |
| $this->table_retour['attributions'][$code_langue][$num_nom]['taxon'] = $resultat[$num_tax]['nom_sci']; |
| } |
| } |
| } |
| } |
| public function recupererNomTaxons() { |
| $taxons = array_unique($this->taxons); |
| $url = Config::get('url_service_base').'bdtfx/taxons?navigation.limite=500&ns.structure=au&masque.nt='.implode(',', $taxons); |
| $res = $this->consulterHref($url); |
| foreach ($res->resultat as $id=>$taxon) { |
| $resultat[$taxon->num_taxonomique]['id'] = 'bdtfx.nn:'.$id; |
| $resultat[$taxon->num_taxonomique]['nom_sci'] = $taxon->nom_sci_complet; |
| } |
| return $resultat; |
| } |
| public function formaterNomsVernaculairesIdChamp($resultat) { |
| $this->table_retour['id'] = $this->ressources[0]; |
| $champs = explode(' ', $this->ressources[1]); |
| if (in_array('attributions', $champs) != false) { |
| $this->formaterNomsVernaculairesId($resultat); |
| unset($this->table_retour['nom_vernaculaire']); |
| } else { |
| $champ_attributions = array('num_taxon', 'genre', 'notes'); |
| foreach ($resultat as $taxon) { |
| foreach ($taxon as $key=>$valeur) { |
| if ($key == 'code_langue' && in_array('langue', $champs) != false) { |
| $this->table_retour['attributions']['langue'][] = $valeur; |
| } elseif (in_array($key, $champ_attributions) != false) { |
| $this->afficherPoint($this->correspondance_champs[$key] , $valeur, $taxon['code_langue'], $taxon['id']); |
| } elseif (in_array($key, $champs) != false) { |
| $this->table_retour[$key] = $valeur; |
| } |
| } |
| } |
| } |
| return $this->table_retour; |
| } |
| public function afficherPoint($champ, $valeur, $langue, $num_nom) { |
| preg_match('/^(.*)\.code$/', $champ, $match); |
| $champ = $match[1]; |
| if (isset($this->champ_infos[$champ])) { |
| extract($this->champ_infos[$champ]); |
| $url = $this->ajouterHrefAutreProjet($service, $ressource, $valeur, $projet); |
| $projet .= '.'; |
| } |
| $champs = explode(' ', $this->ressources[1]); |
| if (in_array($champ.'.*', $champs) !== false && isset($projet)) { |
| $this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur; |
| $this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url; |
| } |
| if (in_array($champ.'.code', $champs) !== false && isset($projet)) { |
| $this->table_retour['attributions'][$langue][$num_nom][$champ.'.code'] = $projet.$ressource.$valeur; |
| } |
| if (in_array($champ.'.href', $champs) !== false && isset($projet)) { |
| $this->table_retour['attributions'][$langue][$num_nom][$champ.'.href'] = $url; |
| } |
| if (in_array($champ, $champs) !== false) { |
| if (isset($url)) { |
| $this->table_retour['attributions'][$langue][$num_nom][$champ] = $this->chercherSignificationCode($url, $nom); |
| } else { |
| $this->table_retour['attributions'][$langue][$champ] = $valeur; |
| } |
| } |
| } |
| public function afficherLangue($nomChamp, $projet, $service, $valeur, $ressource = '', $nom = 'nom') { |
| if ($this->retour_format == 'max') { |
| $this->table_retour['attributions'][$nomChamp] = $nom; |
| $this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur; |
| $this->table_retour['attributions'][$nomChamp.'.href'] = $url; |
| } else { |
| $this->table_retour['attributions'][$nomChamp.'.code'] = $projet.$ressource.$valeur; |
| } |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/baseflor/GraphiquesBaseflor.php |
|---|
| New file |
| 0,0 → 1,119 |
| <?php |
| /** |
| * Classe GraphiquesBaseflor.php transforme les données écologiques de la table baseflor |
| * en graphique svg |
| * graphiques/#typegraphique/#bdnt.nn:#num_nomen --> renvoie un graphique avec les données connues |
| * |
| * |
| * @package eflore-projets |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @author Mathilde SALTHUN-LASSALLE <mathilde@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class GraphiquesBaseflor extends CommunGraphiques{ |
| public function definirTable($version){ |
| $this->table = Config::get('bdd_table')."_v".$version; |
| } |
| //+--------------------------traitement ressources ou paramètres -------------------------------------------+ |
| public function traiterReferentieletNum(){ |
| if (!empty($this->ressources[1])) { |
| if(preg_match('/^(.+)\.nn:([0-9]+)$/', $this->ressources[1], $retour) == 1){ |
| switch ($retour[1]) { |
| case 'bdtfx' : |
| $this->requete_condition[]= "num_nomen = ".$retour[2]." AND bdnt = 'bdtfx' "; |
| break; |
| case 'bdafx' : |
| $this->requete_condition[] = "num_nomen = ".$retour[2]." AND bdnt = 'bdafx' "; |
| break; |
| case 'bdbfx' : |
| $this->requete_condition[] = "num_nomen = ".$retour[2]." AND bdnt = 'bdbfx' "; |
| break; |
| default : |
| $e = "Le référentiel {$retour[1]} n'existe pas."; |
| throw new Exception( $e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| break; |
| } |
| }else { |
| $e = "Erreur dans l'url de votre requête :". |
| " précisez le référentiel et le numéro nomenclatural sous la forme {bdnt}.nn:{nn}."; |
| throw new Exception( $e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| } else { |
| throw new Exception( "Erreur dans l'url de votre requête :". |
| " précisez le référentiel et le numéro nomenclatural sous la forme {bdnt}.nn:{nn}.", |
| RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| } |
| public function traiterTypeGraphique(){ |
| if (!empty($this->ressources[0])) { |
| switch ($this->ressources[0]) { |
| case 'climat' : |
| $this->requete_champs = ' ve_lumiere , ve_temperature, ve_continentalite, ve_humidite_atmos' ; |
| $this->nomGraphique= 'climat'; |
| break; |
| case 'sol' : |
| $this->requete_champs = ' ve_humidite_edaph , ve_reaction_sol, ve_nutriments_sol, ve_salinite,' |
| .'ve_texture_sol, ve_mat_org_sol' ; |
| $this->nomGraphique = 'sol'; |
| break; |
| default : |
| $e = "Erreur dans l'url de votre requête :". |
| "</br> precisez le graphique -> \"sol\" ou \"climat\"."; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| break; |
| } |
| }else { |
| throw new Exception("Erreur dans l'url de votre requête :". |
| "</br> precisez le graphique -> \"sol\" ou \"climat\".", RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| } |
| //+-------------------------- formatage du résultat -------------------------------------------+ |
| /// ++++ svg +++++ /// |
| public function changerValeursSVG(){ |
| $Dompath = new DOMXPath($this->dom); |
| foreach ($this->valeurs_en_pourcentage as $cle => $val){ |
| $val = preg_replace('/,/','.', $val); |
| $grad_id = array_search($val,$this->graduations_id); |
| $element = $Dompath->query("//*[@id='".$grad_id."']")->item(0); |
| $pos_x = $element->getAttribute('x1'); |
| $curseur = $Dompath->query("//*[@id='".$cle."']")->item(0); |
| $curseur->setAttribute('cx', $pos_x); |
| $curseur->setAttribute('class', 'curseur'); |
| $this->ajouterInfoAuSurvol($curseur); |
| $changement = true; |
| } |
| $this->ajusterFormatSVG(); |
| } |
| public function ajouterInfoAuSurvol($curseur){ |
| $champs = $curseur->getAttribute('id'); |
| $valeurTexte = $this->recupererOntologies($this->valeurs_champs[$champs], $champs ); |
| $valeurTexte = $this->traiterIntermediaires($valeurTexte->nom, $champs, $champs); |
| $curseur->setAttribute('title',$this->valeurs_champs[$champs].": ".$valeurTexte ); |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/baseflor/InformationsBaseflor.php |
|---|
| New file |
| 0,0 → 1,520 |
| <?php |
| /** |
| * Classe InformationsBaseflor.php permet de faire des requetes de baseflor en fonction d'un référentiel |
| *( BDTFX, BDAFX, BDBFX ) et d'un numéro nomenclatural ( différent de 0 ). |
| * fin d'url possibles : |
| * /informations/#bdnt.nn:#num_nomen --> retourne tous les champs pour un BDNT et un num_nomen |
| * /informations/#bdnt.nn:#num_nomen?champs=description --> retourne champs description pour un BDNT et un num_nomen |
| * /informations/#bdnt.nn:#num_nomen?champs=ecologie --> retourne champs ecologiques pour un BDNT et un num_nomen |
| * /informations/#bdnt.nn:#num_nomen/relations/catminat --> donne les num nomen et les bdnt pour tous |
| * les taxons qui ont le même code catminat ( code milieu ) que celui entré |
| * |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * @package eflore-projets |
| * @author Mathilde SALTHUN-LASSALLE <mathilde@tela-botanica.org> |
| * @author Delphine CAUQUIL <delphine@tela-botanica.org> |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class InformationsBaseflor extends Commun{ |
| protected $table = ""; |
| private $format_reponse = 'informations'; |
| private $retour_format = 'max'; |
| private $champs_ontologiques = array(); |
| protected $serviceNom = 'informations'; |
| private $Bdd; |
| private $requete_condition = ""; |
| private $champs_recherches = '*'; |
| private $resultat_json; |
| private $nb_ressources; |
| protected $limite_requete = array( 'depart' => 0, 'limite' => 10); |
| public function consulter($ressources, $parametres) { |
| $this->ressources = $ressources; |
| $this->parametres = $parametres; |
| $this->nb_ressources = count($ressources); |
| $this->traiterParametres(); |
| $this->definirTables(); |
| $this->traiterRessources(); |
| $resultats = null; |
| foreach ($this->table_version as $version) { |
| $this->table = $version; |
| $requete = $this->assemblerLaRequete(); |
| $resultat = $this->Bdd->recupererTous($requete); |
| $versionResultat = $this->analyserResultat($resultat); |
| if (count($this->table_version) > 1) { |
| $resultats[$version] = $versionResultat; |
| } else { |
| $resultats = $versionResultat; |
| } |
| } |
| return $resultats; |
| } |
| public function __construct(Conteneur $Conteneur) { |
| $this->Bdd = $Conteneur->getBdd(); |
| } |
| public function analyserResultat($resultat) { |
| $versionResultat = null; |
| if ($resultat == '') { |
| $message = 'La requête SQL formée comporte une erreur!'; |
| $code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
| throw new Exception($message, $code); |
| } elseif ($resultat) { |
| $versionResultat = $this->retournerResultatFormate($resultat); |
| } |
| return $versionResultat; |
| } |
| //+--------------------------traitement ressources ou paramètres -------------------------------------------+ |
| public function traiterParametres() { |
| if (isset($this->parametres) && !empty($this->parametres)) { |
| foreach ($this->parametres as $param => $valeur) { |
| switch ($param) { |
| case 'categorie' : |
| if ($valeur == "description" && $this->nb_ressources == 1 ) { |
| $this->champs_recherches = "num_nomen, BDNT, chorologie, inflorescence," |
| ." sexualite, ordre_maturation, " |
| ."pollinisation, fruit, dissemination, couleur_fleur, macule, floraison, type_bio, " |
| ."form_vegetale "; |
| $this->requete_condition[] = "( chorologie != '' OR inflorescence != '' ". |
| "OR sexualite != '' OR ordre_maturation != '' OR pollinisation != '' ". |
| "OR fruit != '' OR dissemination != '' OR couleur_fleur != '' OR macule != '' ". |
| "OR floraison != '' OR type_bio != '' OR form_vegetale != '' )"; |
| }elseif ($valeur == "ecologie" && $this->nb_ressources == 1) { |
| $this->champs_recherches = " num_nomen, BDNT, ve_lumiere , ve_temperature," |
| ." ve_continentalite, ve_humidite_atmos, ve_humidite_edaph, ve_reaction_sol," |
| ." ve_nutriments_sol, ve_salinite, ve_texture_sol, ve_mat_org_sol, " |
| ." vi_lumiere, vi_temperature, vi_continentalite, vi_humidite_edaph," |
| ." vi_reaction_sol, vi_nutriments_sol, vi_salinite "; |
| $this->requete_condition[] = "( ve_lumiere != '' OR ve_temperature != '' ". |
| "OR ve_continentalite != '' OR ve_humidite_atmos != '' ". |
| "OR ve_humidite_edaph != '' OR ve_reaction_sol != '' ". |
| "OR ve_nutriments_sol != '' OR ve_salinite != '' ". |
| "OR ve_texture_sol != '' OR ve_mat_org_sol != '' )"; |
| } else { |
| $e = "Valeur de paramètre inconnue pour 'categorie'. Ce paramètre n'est pas autorisé pour informations/#id/relations/catminat"; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| break; |
| case 'retour.format' : |
| if ($valeur == 'min' || $valeur == 'max' && $this->nb_ressources == 1) { |
| $this->retour_format = $valeur; |
| } else { |
| $e = "Valeur de paramètre inconnue pour 'retour.format'. Ce paramètre n'est pas autorisé pour informations/#id/relations/catminat"; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| break; |
| case 'navigation.depart' : |
| $this->definirNavigationDepart($valeur); |
| break; |
| case 'navigation.limite' : |
| $this->definirNavigationLimite($valeur); |
| break; |
| case 'version.projet' : |
| $this->traiterVersion($valeur); |
| break; |
| default : |
| $e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " ' |
| .$param.' " n\'existe pas.'; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| break; |
| } |
| } |
| } |
| } |
| public function traiterRessources() { |
| if(preg_match('/^(.+)\.nn:([0-9]+)$/', $this->ressources[0], $retour)){ |
| $id = $retour[2]; |
| $ref = $retour[1]; |
| if ($ref == 'bdtfx' || $ref == 'bdafx' || $ref == 'bdbfx') { |
| if($this->nb_ressources == 1) { |
| $this->requete_condition[] = "num_nomen = ".$id." AND BDNT = '".strtoupper($ref)."' "; |
| } else { |
| $this->definirParametresRequeteRelations($ref, $id); |
| } |
| } else { |
| $e = 'Erreur dans l\'url de votre requête : </br> Le référentiel " ' |
| .$ref.' " 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); |
| } |
| } |
| function definirParametresRequeteRelations($ref, $id){ |
| if ($this->ressources[1] == 'relations'){ |
| switch ($this->ressources[2]) { |
| case 'catminat' : |
| $this->requete_condition[] = "catminat_code = ( SELECT catminat_code from ".$this->table_version[0]." WHERE " |
| ." num_nomen = ".$id." AND BDNT = '".$ref. "' ) AND num_nomen != ".$id." "; |
| $this->champs_recherches = " catminat_code, num_nomen, BDNT, idiotaxon "; |
| break; |
| default : |
| $e = 'Erreur dans l\'url de votre requête : </br> Le type de relation " ' |
| .$this->ressources[2].' " n\'existe pas.'; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| break; |
| } |
| } else { |
| $e = 'Erreur dans l\'url de votre requête : </br> Le type de ressources " ' |
| .$this->ressources[1].' " n\'existe pas.'; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| } |
| //+++------------------------------traitement des versions----------------------------------------++ |
| public function traiterVersion($valeur) { |
| if (preg_match('/^[0-9]+(?:[._][0-9]+)*$/', $valeur) || $valeur == '+') { |
| $this->version_projet = $valeur; |
| } elseif ($valeur == '*') { |
| $this->version_projet = ($this->nb_ressources == 1) ? $valeur : '+' ; |
| } else { |
| $e = "Erreur : La version est inconnue."; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| } |
| public 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); |
| } |
| } |
| //+--------------------------formatages de resultats -------------------------------------------+ |
| public function retournerResultatFormate($resultat) { |
| $resultat_json = $resultat[0]; |
| if ($this->retour_format == 'max'){ |
| if ($this->nb_ressources == 1) { |
| if ($this->parametres['categorie'] == 'ecologie') { |
| $this->formaterResultatsChampsEcologie($resultat_json); |
| } elseif ($this->parametres['categorie'] == 'description') { |
| $this->formaterResultatsChampsDescription($resultat_json); |
| }else { |
| $this->formaterResultatsTousChamps($resultat_json); |
| } |
| } else { |
| $this->formaterResultatsRelations($resultat); |
| } |
| } else { |
| $this->resultat_json = $resultat_json; |
| } |
| return $this->resultat_json; |
| } |
| public function formaterResultatsRelations($resultat) { |
| $this->resultat_json['entete'] = $this->ajouterEnteteResultat(); |
| $resultat_json = array(); |
| foreach ($resultat as $cle => $res){ |
| $resultat_json[$cle] = $res ; |
| $resultat_json[$cle]['href'] = $this->ajouterHref('informations',strtolower($res['BDNT']).".nn:".$res['num_nomen']); |
| } |
| $this->resultat_json['resultat'] = $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; |
| if ($this->limite_requete['limite'] != '*') { |
| $url = $this->formulerUrl($this->total_resultat, '/informations/'.$this->ressources[0].'/relations/catminat'); |
| 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 formaterResultatsTousChamps($resultat) { |
| $this->resultat_json = $resultat; |
| $this->traiterTypeBio(); |
| $graphique_presence = $this->traiterEcologie() ; |
| if ($graphique_presence) { |
| $graphique = $this->ajouterLiensGraphique($graphique_presence); |
| } |
| } |
| public function formaterResultatsChampsEcologie($resultat) { |
| $this->resultat_json = $resultat; |
| $graphique_presence = $this->traiterEcologie() ; |
| if ($graphique_presence) { |
| $graphique = $this->ajouterLiensGraphique($graphique_presence); |
| } |
| } |
| public function formaterResultatsChampsDescription($resultat) { |
| $this->resultat_json = $resultat; |
| $this->traiterTypeBio(); |
| } |
| //vérifie la présence de données écologiques pour les graphiques et récupère leur ontologie |
| public function traiterEcologie() { |
| $donnees_presence = false; |
| $this->champs_ontologiques = $this->recupererTableauConfig('champs_ontologiques'); |
| foreach ($this->champs_ontologiques as $cle => $valeur){ |
| if ($this->resultat_json[$cle] != ""){ |
| $donnees_presence[$this->getNomGraphique($valeur)] = true; |
| $this->recupererOntologies($this->resultat_json[$cle], $cle); |
| unset($this->resultat_json[$cle]); |
| } |
| } |
| return $donnees_presence; |
| } |
| //donne le nom du graphique correspondant à un champ écologique |
| public function getNomGraphique($code_ecolo) { |
| $graphique = null; |
| if (in_array($code_ecolo, explode(',',Config::get('Paramètres.climat')))) { |
| $graphique = 'climat'; |
| } elseif (in_array($code_ecolo, explode(',', Config::get('Paramètres.sol')) )) { |
| $graphique = 'sol'; |
| } |
| return $graphique; |
| } |
| public function traiterTypeBio() { |
| if ($this->resultat_json['type_bio'] != ""){ |
| $tab_ontologie = $this->recupererOntologiePrTypeBio($this->resultat_json['type_bio']); |
| unset($this->resultat_json['type_bio']); |
| $this->resultat_json= array_merge($this->resultat_json,$tab_ontologie); |
| } |
| } |
| public function ajouterLiensGraphique($graphique_presence) { |
| if ($graphique_presence['climat']) { |
| $this->resultat_json['graphique_climat']['libelle'] = 'climat'; |
| $this->resultat_json['graphique_climat']['href'] = |
| $this->ajouterHref('graphiques/climat', strtolower($this->resultat_json['BDNT']).'.nn:'.$this->resultat_json['num_nomen']); |
| } |
| if ($graphique_presence['sol']) { |
| $this->resultat_json['graphique_sol']['libelle'] = 'sol'; |
| $this->resultat_json['graphique_sol']['href'] = |
| $this->ajouterHref('graphiques/sol', strtolower($this->resultat_json['BDNT']).'.nn:'.$this->resultat_json['num_nomen']); |
| } |
| } |
| //+--------------------------traitement ontologies -------------------------------------------+ |
| public function recupererOntologies($valeur, $champs){ |
| $url = Config::get('url_service_base').Config::get('nom_projet'). |
| '/ontologies/'.$this->champs_ontologiques[$champs].':'.urlencode(urlencode($valeur)); |
| $val = $this->consulterHref($url); |
| $this->resultat_json[$champs.'.libelle'] = $val->nom; |
| $this->resultat_json[$champs.'.code'] = $valeur; |
| $this->resultat_json[$champs.'.href'] = $url; |
| } |
| //+-------------ontologie pour le champs type biologique (lire le .txt)---+ |
| public function recupererOntologiePrTypeBio($type_a_traiter){ |
| $resultat_typeBio = ""; |
| if ($type_a_traiter != "") { |
| $types_prim_sec = $this->separerTypesPrimairesSecondaires($type_a_traiter); |
| $types_sstypes = $this->classerPrimSecEnTypesSsTypes($types_prim_sec); |
| $resultat_typeBio = $this->formaterJsonTypeBio($types_sstypes, $type_a_traiter ); |
| } |
| return $resultat_typeBio; |
| } |
| public function classerPrimSecEnTypesSsTypes($types_prim_sec) { |
| $types_sstypes = ''; |
| foreach ($types_prim_sec as $cle => $tb) { |
| $types_sstypes[$cle]= $this->separerTypes_SousTypes($tb, $cle); |
| } |
| switch (count($types_sstypes)) { |
| case 1 : |
| $types_sstypes = $types_sstypes['principal']; |
| break; |
| case 2 : |
| $types_sstypes = array_merge($types_sstypes['principal'],$types_sstypes['secondaire']); |
| break; |
| } |
| return $types_sstypes; |
| } |
| public function formaterJsonTypeBio( $types_sstypes, $type_a_traiter) { |
| $resultat_typeBio['type_bio.code'] = $type_a_traiter; |
| foreach ($types_sstypes as $cle => $tb) { |
| if (($cle == 'type.principal') || ($cle == 'type.secondaire')) { |
| $i = 0; |
| foreach ($tb as $types) { |
| $url = Config::get('url_service_base').Config::get('nom_projet'). |
| '/ontologies/TB:'.urlencode(urlencode($types)); |
| $val = $this->consulterHref($url); |
| $libelle[$cle][$i]= $val->nom; |
| $detail[$cle][$i]['libelle'] = $val->nom; |
| $detail[$cle][$i]['code'] = $val->code; |
| $detail[$cle][$i]['href'] = $url; |
| $i++; |
| } |
| } |
| if ($cle == 'sous_type.principal' || $cle == 'sous_type.secondaire' ) { |
| $i = 0; |
| foreach ($tb as $sstypes) { |
| $url = Config::get('url_service_base').Config::get('nom_projet'). |
| '/ontologies/ssTT:'.urlencode(urlencode($sstypes)); |
| $val = $this->consulterHref($url); |
| $libelle[$cle][$i]=$val->nom; |
| $detail[$cle][$i]['libelle'] = $val->nom; |
| $detail[$cle][$i]['code'] = $val->code; |
| $detail[$cle][$i]['href'] = $url; |
| $i++; |
| } |
| } |
| } |
| //var_dump($libelle); exit; |
| $resultat_typeBio['type_bio.libelle']= $this->formaterTypeBioPrLibelle($libelle); |
| $resultat_typeBio['type_bio.detail'] = $detail; |
| return $resultat_typeBio; |
| } |
| public function formaterTypeBioPrLibelle($info) { |
| $libelle = implode(', ',$info['type.principal'])." "; |
| $libelle .= isset($info['sous_type.principal']) ? " (".implode(', ',$info['sous_type.principal']).") " : ""; |
| $libelle .= isset($info['type.secondaire']) ? ", ".implode(', ',$info['type.secondaire'])." " : ""; |
| $libelle .= isset($info['sous_type.secondaire']) ? "(".implode(', ',$info['sous_type.secondaire']).") " : ""; |
| return $libelle; |
| } |
| //séparation des principaux et des secondaires |
| public function separerTypesPrimairesSecondaires($type) { |
| $types = array(); |
| if (preg_match("/(.+)\((.+)\)\-{0,1}(.+){0,1}/", $type,$retour)) { |
| $types['principal'] = isset($retour[3]) ? $retour[1].'-'. $retour[3] : $retour[1] ; |
| $types['secondaire'] = $retour[2]; |
| } else { |
| $types['principal'] = $type; |
| } |
| return $types; |
| } |
| public function separerTypes_SousTypes($type_a_traiter, $typePrimOuSec) { |
| $types = array(); |
| if (preg_match("/^([a-zA-Zé]+)\-(.+)$|^([a-zA-Zé,]+[^\-])$/", $type_a_traiter, $retour)) { |
| //type |
| $type = array(); |
| $type[0] = (isset($retour[3])) ? $retour[3] : $retour[1] ; |
| $type = explode(",", $type[0]); |
| for ($i = 0 ; $i < count($type); $i++) { |
| $types['type.'.$typePrimOuSec][$i] = $type[$i]; |
| } |
| //sous types |
| $ss_types = array(); |
| if (isset($retour[2]) && $retour[2] != '') { |
| $ss_types[0] = $retour[2] ; |
| $ss_types = explode("-", $ss_types[0]); |
| for ($i = 0 ; $i < count($ss_types); $i++) { |
| $types['sous_type.'.$typePrimOuSec][$i] = $ss_types[$i]; |
| } |
| } |
| } |
| return $types; |
| } |
| //+--------------------------FONCTIONS D'ASSEMBLAGE DE LA REQUETE-------------------------------------------+ |
| public function assemblerLaRequete() { |
| $requete = ' SELECT '.$this->champs_recherches.' FROM '.$this->table.' ' |
| .$this->retournerRequeteCondition().' '; |
| if ($this->nb_ressources != 1 ) { |
| $requete .= $this->delimiterResultatsRequete(); |
| } |
| return $requete; |
| } |
| 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 ($this->limite_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; |
| } |
| public function retournerRequeteCondition() { |
| $condition = ''; |
| if (empty($this->requete_condition) == false) { |
| $condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
| } |
| return $condition; |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/baseflor/CommunGraphiques.php |
|---|
| New file |
| 0,0 → 1,391 |
| <?php |
| /** |
| * Classe CommunGraphiques.php regroupement de fonctions pour les graphiques |
| * graphiques/#typegraphique/#bdnt.nn:#num_nomen --> renvoie un graphique avec les données connues |
| * |
| * |
| * @package eflore-projets |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @author Mathilde SALTHUN-LASSALLE <mathilde@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| abstract class CommunGraphiques extends Commun{ |
| protected $parametres = array(); |
| protected $ressources = array(); |
| protected $Bdd; |
| protected $config; |
| protected $cache; |
| protected $metadonnees; |
| protected $version; |
| protected $serviceNom = 'Graphiques'; |
| protected $graduations_id = array(); |
| protected $champs_ontologiques = array(); |
| protected $nomGraphique = array(); |
| protected $table = ''; |
| protected $requete_condition = ""; |
| protected $requete_champs; |
| protected $convertisseur; |
| protected $cheminGraphBase; |
| protected $valeurs_en_pourcentage = array(); |
| protected $dom; |
| protected $largeurSVG = "500"; |
| protected $hauteurSVG; |
| protected $valeurs_champs; |
| public function consulter($ressources, $parametres) { |
| $this->ressources = $ressources; |
| $this->parametres = $parametres; |
| $this->verifierParametres(); |
| $this->initialiserConfiguration(); |
| $resultats = ''; |
| $this->traiterRessources(); |
| $requete = $this->assemblerLaRequete(); |
| $resultat = $this->resultat = $this->Bdd->recupererTous($requete); |
| $versionResultat = $this->obtenirResultat($resultat); |
| return $versionResultat; |
| } |
| //+--------------------------initialisation de paramètres -------------------------------------------+ |
| private function initialiserConfiguration() { |
| $conteneur = new Conteneur(); |
| $this->Bdd = $conteneur->getBdd(); |
| $this->config = $conteneur->getParametre('Graphiques'); |
| $this->convertisseur = $this->config['convertisseur']; |
| $this->graduations_id = $this->getParametreTableau('graduations_id'); |
| $this->champs_ontologiques = $this->getParametreTableau('champs_ontologiques'); |
| $this->cheminGraphBase = $this->config['chemin']; |
| $cacheOptions = array('mise_en_cache' => $this->config['cache']['miseEnCache'], |
| 'stockage_chemin' => $this->config['cache']['stockageChemin'], |
| 'duree_de_vie' => $this->config['cache']['dureeDeVie']); |
| $this->cache = $conteneur->getCacheSimple($cacheOptions); |
| $this->definirVersion(); |
| $this->definirFormat(); |
| $this->definirTable($this->version); |
| } |
| abstract function definirTable($version); |
| private function getParametreTableau($cle) { |
| $tableau = array(); |
| $parametre = Config::get($cle); |
| if (empty($parametre) === false) { |
| $tableauPartiel = explode(',', $parametre); |
| $tableauPartiel = array_map('trim', $tableauPartiel); |
| foreach ($tableauPartiel as $champ) { |
| if (strpos($champ, '=') !== false && strlen($champ) >= 3) { |
| list($cle, $val) = explode('=', $champ); |
| $tableau[trim($cle)] = trim($val); |
| } else { |
| $tableau[] = trim($champ); |
| } |
| } |
| } |
| return $tableau; |
| } |
| //+--------------------------traitement ressources ou paramètres -------------------------------------------+ |
| //+---- paramètres ----+ |
| private function verifierParametres() { |
| if (isset($this->parametres)) { |
| $parametres_dispo = array('retour', 'retour.format', 'version.projet'); |
| $parametres = array_keys($this->parametres); |
| foreach ($parametres as $param) { |
| if (!in_array($param, $parametres_dispo)) { |
| $erreur = "Erreur : Le paramètre $param est inconnu."; |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($erreur, $code); |
| } |
| } |
| } |
| } |
| //on n'affiche qu'une version de graphique à la fois ( la dernière ou celle demandée ) |
| private function definirVersion() { |
| $this->chargerVersions(); |
| if (!isset($this->parametres['version.projet']) ) { |
| $this->version = $this->metadonnees[0]['version']; |
| } elseif ($this->parametres['version.projet'] == '+') { |
| $this->version = $this->metadonnees[0]['version']; |
| } else { |
| if($this->verifierVersion($this->parametres['version.projet'])) { |
| $this->version = $this->parametres['version.projet']; |
| }else { |
| $erreur = "Erreur : La version est inconnue."; |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($erreur, $code); |
| } |
| } |
| } |
| private function verifierVersion($version){ |
| $retour = false; |
| foreach ($this->metadonnees as $vers) { |
| if ($vers['version'] == $version ) { |
| $retour = true; |
| } |
| } |
| return $retour; |
| } |
| private function definirFormat() { |
| if (isset($this->parametres['retour.format']) ){ |
| if (preg_match("/^[0-9]+$/", $this->parametres['retour.format'])){ |
| if ($this->parametres['retour.format'] > 0) { |
| $this->largeurSVG = $this->parametres['retour.format']; |
| } else { |
| $erreur = "Erreur : valeur pour retour.format négative ou égale à 0."; |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($erreur, $code); |
| } |
| }else { |
| $erreur = "Erreur : valeur inconnue. Entrez la largeur voulue (en pixels) pour le paramètre retour.format."; |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($erreur, $code); |
| } |
| } |
| if (!isset($this->parametres['retour']) ){ |
| $this->parametres['retour'] = 'image/svg+xml'; |
| }else { |
| if (( $this->parametres['retour'] != 'image/svg+xml')&& ( $this->parametres['retour'] != 'image/png')){ |
| $erreur = "Erreur : valeur inconnue. Choisissez le format de retour pour le paramètre retour : image/svg%2Bxml ou image/png."; |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($erreur, $code); |
| } |
| } |
| } |
| private function chargerVersions() { |
| $requete = "SELECT version ". |
| "FROM ".Config::get('bdd_table_meta')." ". |
| "ORDER BY date_creation DESC "; |
| $resultats = $this->Bdd->recupererTous($requete); |
| if (!is_array($resultats) || count($resultats) <= 0) { |
| $message = "Les méta-données n'ont pu être chargée pour la ressource demandée"; |
| $code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
| throw new Exception($message, $code); |
| } |
| $this->metadonnees = $resultats; |
| } |
| //+----- ressources -----+ |
| public function traiterRessources() { |
| if(isset($this->ressources)) { |
| $this->traiterTypeGraphique(); |
| $this->traiterReferentielEtNum(); |
| } else { |
| $e = 'Erreur dans l\'url de votre requête : </br> ressources insuffisantes.'; |
| throw new Exception( $e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| } |
| abstract function traiterReferentielEtNum(); |
| abstract function traiterTypeGraphique(); |
| //+--------------------------FONCTIONS D'ASSEMBLAGE DE LA REQUETE-------------------------------------------+ |
| public function assemblerLaRequete() { |
| $requete = ' SELECT '.$this->requete_champs.' FROM '.$this->table.' '.$this->retournerRequeteCondition(); |
| return $requete; |
| } |
| public function retournerRequeteCondition() { |
| $condition = ''; |
| if ($this->requete_condition !== "") { |
| $condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
| } |
| return $condition; |
| } |
| //+-------------------------- formatage du résultat -------------------------------------------+ |
| public function obtenirResultat($resultat) { |
| 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) { |
| if ((count($this->ressources)) != 0) { |
| //$Atraiter = array_filter($resultat[0],function($var){return ($var != '');}); |
| foreach ($resultat[0] as $champs => $valeur) { |
| if ($valeur !== '') { |
| $Atraiter[$champs] = $valeur; |
| } |
| } |
| if (!empty($Atraiter)) { |
| $this->traiterValeursEcologiques($Atraiter); |
| $svg = $this->genererSVG(); |
| $resultat = new ResultatService(); |
| $resultat->corps = ($this->parametres['retour'] == 'image/png') ? $this->convertirEnPNG($svg) : $svg; |
| $resultat->mime = $this->parametres['retour']; |
| } else { |
| $resultat = null; |
| } |
| } |
| } else { |
| $resultat = null; |
| } |
| return $resultat; |
| } |
| //+----- modification svg -----+ |
| public function traiterValeursEcologiques($valeur){ |
| $this->valeurs_champs = $valeur; |
| foreach($this->valeurs_champs as $cle => $val){ |
| if (preg_match("/ve_humidite_edaph/", $cle)) { |
| $this->valeurs_en_pourcentage[$cle] = round($val/13,1); |
| } elseif (preg_match("/ve_salinite/", $cle)) { |
| $this->valeurs_en_pourcentage[$cle] = round(($val+1)/11,1); |
| } else { |
| $this->valeurs_en_pourcentage[$cle] = round($val/10,1); |
| } |
| } |
| } |
| public function donnerHauteur($ancienne_largeur, $ancienne_hauteur) { |
| $nouvelle_largeur = $this->largeurSVG; |
| $ancienne_largeur = str_replace('px','',$ancienne_largeur); |
| $ancienne_hauteur = str_replace('px','',$ancienne_hauteur); |
| $rapport = $nouvelle_largeur / $ancienne_largeur ; |
| $nouvelle_hauteur = $ancienne_hauteur * $rapport; |
| $this->hauteurSVG = $nouvelle_hauteur; |
| } |
| public function ajusterFormatSVG(){ |
| $svg = $this->dom->getElementsByTagName("svg")->item(0); |
| $largeur = $svg->getAttribute('width'); |
| $hauteur = $svg->getAttribute('height'); |
| $this->donnerHauteur($largeur , $hauteur); |
| $svg->setAttribute('width',round($this->largeurSVG).'px'); |
| $svg->setAttribute('height',round($this->hauteurSVG).'px'); |
| } |
| public function genererSVG(){ |
| $svg = null; |
| $this->dom = new DOMDocument('1.0', 'UTF-8'); |
| $this->dom->validateOnParse = true; |
| $fichierSvg = $this->cheminGraphBase."".$this->nomGraphique.".svg"; |
| $this->dom->load($fichierSvg); |
| $this->changerValeursSVG(); |
| $svg = $this->dom->saveXML(); |
| return $svg; |
| } |
| abstract function changerValeursSVG(); |
| public function recupererOntologies($valeur, $champs){ |
| $url = $this->ajouterHref('ontologies',$this->champs_ontologiques[$champs].':'.urlencode(urlencode($valeur))); |
| $val = $this->consulterHref($url); |
| return $val; |
| } |
| public function traiterIntermediaires($valeurTexte,$champsOntologie, $champsTable){ |
| if (preg_match("/(?:I|i)nterm(?:é|e)diaire(?:s)*/", $valeurTexte )) { |
| $prec = $this->recupererOntologies(($this->valeurs_champs[$champsTable]-1), $champsOntologie ); |
| $suiv = $this->recupererOntologies(($this->valeurs_champs[$champsTable]+1), $champsOntologie ); |
| $valeurTexte = "Intermédiaires entre $prec->nom et $suiv->nom "; |
| } |
| return $valeurTexte; |
| } |
| /// +---- convertir png ----+ |
| public function convertirEnPNG($svg) { |
| $png = null; |
| if (isset($this->convertisseur)) { |
| if ($this->convertisseur == 'imagick') { |
| if (extension_loaded('imagick')) { |
| $png = $this->convertirEnPNGAvecImageMagick($svg); |
| } else { |
| $message = "Impossible de générer l'image sur le serveur. Extension ImageMagick absente."; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } |
| } else if ($this->convertisseur == 'rsvg') { |
| $png = $this->convertirEnPNGAvecRsvg($svg); |
| } else { |
| $message = "Le convertisseur indiqué '{$this->convertisseur}' ne fait pas partie de la liste ". |
| "des convertisseurs disponibles : imagick, rsvg."; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } |
| } else { |
| $message = "Veuillez indiquer le convertisseur de svg à utiliser pour le service."; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } |
| return $png; |
| } |
| public function convertirEnPNGAvecImageMagick($svg) { |
| $convertisseur = new Imagick(); |
| $convertisseur->setBackgroundColor(new ImagickPixel('#F8F8F8')); |
| $convertisseur->readImageBlob($svg); |
| $convertisseur->setImageFormat('png32'); |
| $convertisseur->resizeImage($this->largeurSVG,$this->hauteurSVG, imagick::FILTER_LANCZOS, 0, true); |
| $png = $convertisseur->getImageBlob(); |
| $convertisseur->clear(); |
| $convertisseur->destroy(); |
| return $png; |
| } |
| public function convertirEnPNGAvecRsvg($svg) { |
| $idFichier = $this->getIdFichier(); |
| $fichierPng = $this->config['cache']['stockageChemin']."".$idFichier.'.png'; |
| $fichierSvg = $this->config['cache']['stockageChemin']."".$idFichier.'.svg'; |
| file_put_contents($fichierSvg, $svg); |
| $commande = "rsvg-convert $fichierSvg -w ".$this->largeurSVG ." -h ".$this->hauteurSVG ." -o $fichierPng"; |
| //echo $commande; exit; |
| $rsvg = exec($commande); |
| $this->indexerFichierPng($fichierPng); |
| $png = file_get_contents($fichierPng); |
| return $png; |
| } |
| public function indexerFichierPng($fichierPng) { |
| $img = imagecreatefrompng($fichierPng); |
| imagetruecolortopalette($img, false, 32); |
| imagepng($img, $fichierPng, 9, PNG_ALL_FILTERS); |
| } |
| public function getIdFichier(){ |
| $idfichier = str_replace(".","-",$this->ressources[1]); |
| $idfichier = str_replace(':','-',$idfichier); |
| $idfichier .= "-".$this->ressources[0]; |
| return $idfichier; |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/baseflor/Graphiques.php |
|---|
| New file |
| 0,0 → 1,42 |
| <?php |
| /** |
| * Classe Graphiques.php détermine le type de graphiques à afficher en fonction des données des tables |
| * baseflor et baseflor_rang_sup_ecologie |
| * fin d'url possibles : |
| * graphiques/#typegraphique/#bdnt.nn:#num_nomen --> renvoie une graphique avec les données connues |
| * |
| * |
| * @package eflore-projets |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @author Mathilde SALTHUN-LASSALLE <mathilde@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class Graphiques extends Commun{ |
| private $Graph_tables = array('GraphiquesBaseflor', 'GraphiquesTaxonsSup'); |
| public function consulter($ressources, $parametres) { |
| $versionResultat = null; |
| foreach ($this->Graph_tables as $graph_tab) { |
| $Graph = new $graph_tab(); |
| $versionResultat = $Graph->consulter($ressources, $parametres); |
| if($versionResultat != null) {break;} |
| } |
| if ($versionResultat == null) { |
| $message = 'Les données recherchées sont introuvables.'; |
| $code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
| throw new Exception($message, $code); |
| } |
| return $versionResultat; |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/baseflor/Informations.php |
|---|
| New file |
| 0,0 → 1,282 |
| <?php |
| /** |
| * Classe Informations.php interroge la table Index |
| * et redirige vers une autre classe si besoin |
| * d'interroger une autre table (comme baseflor ou baseflor_rang_sup) |
| * elle traite également le retour du web service : /informations |
| * |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * @package eflore-projets |
| * @author Mathilde SALTHUN-LASSALLE <mathilde@tela-botanica.org> |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org) |
| * |
| * |
| */ |
| class Informations extends Commun { |
| protected $limite_requete = array( 'depart' => 0, 'limite' => 10); |
| private $tables; |
| private $champs_recherches = '*'; |
| private $requete_jointure = ""; |
| private $requete_condition = ""; |
| private $total_resultat; |
| protected $serviceNom = 'informations'; |
| private $masque; |
| public function consulter($ressources, $parametres) { |
| $this->ressources = $ressources; |
| $this->parametres = $parametres; |
| $versionResultat = null; |
| if (empty($this->ressources)){ |
| $this->traiterParametres(); |
| } |
| $this->definirTables(array ('index' => config::get('bdd_table_index'), |
| 'baseflor' => config::get('bdd_table'), |
| 'rangSup' => config::get('bdd_table_rang_sup') |
| ) |
| ); |
| $this->traiterRessources(); |
| $requete = $this->assemblerLaRequete(); |
| $resultat = $this->Bdd->recupererTous($requete); |
| $versionResultat = $this->renvoyerResultat($resultat); |
| if ($versionResultat == null) { |
| $message = 'Les données recherchées sont introuvables.'; |
| $code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
| throw new Exception($message, $code); |
| } |
| return $versionResultat; |
| } |
| public function __construct() { |
| $Conteneur = new Conteneur(); |
| $this->Bdd = $Conteneur ->getBdd(); |
| } |
| public function renvoyerResultat($resultat) { |
| $res_formate = array(); |
| if (empty($this->ressources)) { |
| $res_formate = $this->retournerResultatFormate($resultat); |
| } else { |
| $classe = empty($resultat[0]['baseflor']) ? 'InformationsTaxonsSup' : 'InformationsBaseflor'; |
| $info = new $classe(new Conteneur()); |
| $res_formate = $info->consulter($this->ressources, $this->parametres); |
| } |
| return $res_formate; |
| } |
| //+--------------------------traitement ressources ou paramètres -------------------------------------+ |
| public function traiterRessources() { |
| if (empty($this->ressources)) { |
| $this->requete_jointure = array( |
| 'LEFT JOIN '. $this->tables['baseflor'].' ON ' |
| .$this->tables['baseflor'].".cle =".$this->tables['index'].".baseflor", |
| 'LEFT JOIN '. $this->tables['rangSup'].' ON ' |
| .$this->tables['rangSup'].".cle = ".$this->tables['index'].".RangSup"); |
| $this->champs_recherches = " {$this->tables['baseflor']}.num_nomen as 'baseflor.nn', |
| {$this->tables['baseflor']}.BDNT as 'baseflor.bdnt', |
| {$this->tables['baseflor']}.catminat_code, |
| {$this->tables['baseflor']}.num_taxon , |
| {$this->tables['baseflor']}.idiotaxon , |
| {$this->tables['rangSup']}.num_nomen as 'rangSup.nn', |
| {$this->tables['rangSup']}.bdnt as 'rangSup.bdnt', |
| {$this->tables['index']}.cle as 'index.cle' "; |
| } else { |
| if(preg_match('/^(.+)\.nn:([0-9]+)$/', $this->ressources[0], $retour)){ |
| $this->champs_recherches = " baseflor, rangSup "; |
| $this->requete_condition[] = " `bdnt.nn` = '{$retour[0]}' "; |
| } else { |
| $e = 'Erreur dans l\'url de votre requête : </br> La ressource demandée n\'existe pas.'; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| break; |
| } |
| } |
| } |
| public function traiterParametres() { |
| if (isset($this->parametres) && !empty($this->parametres) ) { |
| foreach ($this->parametres as $param => $valeur) { |
| switch ($param) { |
| case 'navigation.depart' : |
| $this->definirNavigationDepart($valeur); |
| break; |
| case 'navigation.limite' : |
| $this->definirNavigationLimite($valeur); |
| break; |
| case 'version.projet' : |
| $this->traiterVersion($valeur); |
| break; |
| case 'masque.cat' : |
| $this->masque = 'catminat='.str_replace('-','/',$valeur); |
| $this->requete_condition[] = " catminat_code = '".str_replace('-','/',$valeur)."' "; |
| break; |
| default : |
| $e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " ' |
| .$param.' " n\'existe pas.'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break; |
| } |
| } |
| } |
| } |
| //+++------------------------------traitement des versions----------------------------------------++ |
| public function traiterVersion($valeur) { |
| if (preg_match('/^[0-9]+(?:[._][0-9]+)*$/', $valeur) || $valeur == '*' || $valeur == '+') { |
| $this->version_projet = $valeur; |
| } else { |
| $e = "Erreur : La version est inconnue."; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| if ($this->version_projet == '*' && empty($this->ressources)) { |
| $message = "L'affichage de plusieurs versions ne fonctionne que pour les ressources de type /ressources/#id"; |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($message, $code); |
| } |
| } |
| public function definirTables($prefixe_table) { |
| $table_num_version = $this->recupererVersionDisponible(); |
| foreach ($prefixe_table as $nom => $prefixe ) { |
| if ( in_array($this->version_projet,$table_num_version) ) { |
| $tables[$nom] = $prefixe.'_v'.$this->version_projet; |
| } elseif ($this->version_projet == '+') { |
| $derniere_version = $table_num_version[count($table_num_version) - 1]; |
| $tables[$nom] = $prefixe.'_v'.str_replace('.', '_', $derniere_version); |
| } else { |
| $e = "Erreur : La version est inconnue."; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| } |
| $this->tables = $tables; |
| } |
| //+--------------------------formatages de resultats -------------------------------------------+ |
| public function retournerResultatFormate($resultat) { |
| $resultat_json = array(); |
| $resultat_json['entete'] = $this->ajouterEnteteResultat(); |
| $resultat_json['resultats'] = array(); |
| foreach ($resultat as $ligne => $tab) { |
| $num = $tab['index.cle']; |
| $json['resultats'][$num]['num_nomen'] = |
| (empty ($tab['baseflor.nn'])) ? $tab['rangSup.nn'] : $tab['baseflor.nn']; |
| $resultat_json['resultats'][$num]['bdnt'] = |
| (empty ($tab['baseflor.bdnt'])) ? $tab['rangSup.bdnt'] : $tab['baseflor.bdnt']; |
| $resultat_json['resultats'][$num]['catminat_code'] = |
| (empty ($tab['catminat_code'])) ? '' : $tab['catminat_code']; |
| $resultat_json['resultats'][$num]['idiotaxon'] = |
| (empty ($tab['idiotaxon'])) ? '' : $tab['idiotaxon']; |
| $resultat_json['resultats'][$num]['num_taxon'] = |
| (empty ($tab['num_taxon'])) ? '' : $tab['num_taxon']; |
| if ($resultat_json['resultats'][$num]['num_nomen'] != 0) { |
| $bdnt = strtolower($resultat_json['resultats'][$num]['bdnt']); |
| $nn = $resultat_json['resultats'][$num]['num_nomen']; |
| $resultat_json['resultats'][$num]['href'] = |
| $this->ajouterHref('informations',$bdnt.".nn:".$nn); |
| } |
| } |
| return $resultat_json; |
| } |
| public function ajouterEnteteResultat() { |
| $entete['depart'] = $this->limite_requete['depart']; |
| $entete['limite'] = $this->limite_requete['limite']; |
| $entete['total'] = $this->total_resultat; |
| if ($this->masque) { |
| $entete['masque'] = $this->masque; |
| } |
| $entete['version'] = $this->version_projet; |
| $url = $this->formulerUrl($this->total_resultat, '/informations'); |
| if (isset($url['precedent']) && $url['precedent'] != '') { |
| $entete['href.precedent'] = $url['precedent']; |
| } |
| if (isset($url['suivant']) && $url['suivant'] != '') { |
| $entete['href.suivant'] = $url['suivant']; |
| } |
| return $entete; |
| } |
| //+-------------------------------------assemblage de requête------------------------------------// |
| public function assemblerLaRequete() { |
| $requete = ' SELECT '.$this->champs_recherches.' FROM '.$this->tables['index'].' ' |
| .$this->retournerRequeteJointure().' '.$this->retournerRequeteCondition(). |
| ' '.$this->delimiterResultatsRequete(); |
| return $requete; |
| } |
| public function retournerRequeteCondition() { |
| $condition = ''; |
| if ($this->requete_condition !== "") { |
| $condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
| } |
| return $condition; |
| } |
| public function calculerTotalResultat() { |
| $requete = 'SELECT count(*) as nombre FROM '.$this->tables['index'].' ' |
| .$this->retournerRequeteJointure().' '.$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 (($this->limite_requete['depart'] <= $this->total_resultat) ){ |
| if ( $this->limite_requete['depart'] < $this->total_resultat ){ |
| $requete_limite = 'LIMIT '.$this->limite_requete['depart'].', ' |
| .$this->limite_requete['limite']; |
| } |
| } else { |
| $e = "Erreur : la valeur pour le paramètre navigation.départ est supérieure". |
| " au nombre total de résultats."; |
| throw new Exception($e, RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE); |
| } |
| return $requete_limite; |
| } |
| public function retournerRequeteJointure() { |
| $jointure = ''; |
| if ($this->requete_jointure !== "") { |
| $jointure = implode(' ', $this->requete_jointure); |
| } |
| return $jointure; |
| } |
| } |
| /branches/refact/services/modules/0.1/baseflor/GraphiquesTaxonsSup.php |
|---|
| New file |
| 0,0 → 1,143 |
| <?php |
| /** |
| * Classe GraphiquesTaxonsSup.php transforme les données écologiques de la table baseflor_rang_sup_ecologie |
| * en graphique svg |
| * graphiques/#typegraphique/#bdnt.nn:#num_nomen --> renvoie un graphique avec les données connues |
| * |
| * |
| * @package eflore-projets |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @author Mathilde SALTHUN-LASSALLE <mathilde@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class GraphiquesTaxonsSup extends CommunGraphiques{ |
| public function definirTable($version){ |
| $this->table = Config::get('bdd_table_rang_sup')."_v".$version; |
| } |
| //+---- ressources ----+ |
| public function traiterReferentieletNum(){ |
| if (!empty($this->ressources[1])) { |
| if(preg_match('/^(.+)\.nn:([0-9]+)$/', $this->ressources[1], $retour) == 1){ |
| switch ($retour[1]) { |
| case 'bdtfx' : // pour le moment un seul referentiel disponible |
| $this->requete_condition[]= "num_nomen = ".$retour[2]." AND bdnt = 'bdtfx' "; |
| break; |
| default : |
| $e = "Le référentiel {$retour[1]} n'existe pas."; |
| throw new Exception( $e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| break; |
| } |
| }else { |
| $e = "Erreur dans l'url de votre requête :". |
| " précisez le référentiel et le numéro nomenclatural sous la forme {bdnt}.nn:{nn}."; |
| throw new Exception( $e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| } else { |
| throw new Exception( "Erreur dans l'url de votre requête :". |
| " précisez le référentiel et le numéro nomenclatural sous la forme {bdnt}.nn:{nn}.", |
| RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| } |
| public function traiterTypeGraphique(){ |
| if (!empty($this->ressources[0])) { |
| switch ($this->ressources[0]) { |
| case 'climat' : |
| $this->requete_champs = ' ve_lumiere_min, ve_lumiere_max, ve_temperature_min,'. |
| ' ve_temperature_max, ve_continentalite_min,'. |
| ' ve_continentalite_max, ve_humidite_atmos_min,'. |
| ' ve_humidite_atmos_max' ; |
| $this->nomGraphique= 'climat_min_max'; |
| break; |
| case 'sol' : |
| $this->requete_champs = ' ve_humidite_edaph_min , ve_humidite_edaph_max,'. |
| ' ve_reaction_sol_min, ve_reaction_sol_max, '. |
| ' ve_nutriments_sol_min, ve_nutriments_sol_max,'. |
| ' ve_salinite_min, ve_salinite_max,'. |
| ' ve_texture_sol_min, ve_texture_sol_max,'. |
| 've_mat_org_sol_min,ve_mat_org_sol_max ' ; |
| $this->nomGraphique = 'sol_min_max'; |
| break; |
| default : |
| $e = "Erreur dans l'url de votre requête :". |
| "</br> précisez le graphique -> \"sol\" ou \"climat\"."; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| break; |
| } |
| }else { |
| throw new Exception("Erreur dans l'url de votre requête :". |
| "</br> precisez le graphique -> \"sol\" ou \"climat\".", RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| } |
| //+-------------------------- formatage du résultat -------------------------------------------+ |
| public function changerValeursSVG(){ |
| $this->ajouterValeursIntermediaires(); |
| $Dompath = new DOMXPath($this->dom); |
| foreach ($this->valeurs_en_pourcentage as $cle => $val){ |
| $val = preg_replace('/,/','.', $val); |
| $grad_id = array_search($val,$this->graduations_id); |
| $champs = preg_replace('/_min|_max|_[0-9]/','', $cle); |
| $case = $Dompath->query("//*[@id='".$grad_id."_".$champs."']")->item(0); |
| $case->setAttribute('fill','#EA6624'); |
| $case->setAttribute('stroke','#EA6624'); |
| $this->ajouterInfoAuSurvol($champs,$case); |
| $changement = true; |
| } |
| $this->ajusterFormatSVG(); |
| } |
| public function ajouterValeursIntermediaires(){ |
| $champs_ecolo = array_keys($this->champs_ontologiques); |
| foreach ($champs_ecolo as $chps ){ |
| $min = !empty($this->valeurs_en_pourcentage[$chps.'_min']) ? $this->valeurs_en_pourcentage[$chps.'_min'] : -1; |
| $max = !empty($this->valeurs_en_pourcentage[$chps.'_max']) ? $this->valeurs_en_pourcentage[$chps.'_max'] : -1; |
| if ($min < ($max-0.1) ){ |
| $i = $min + 0.1; |
| $num = 1; |
| for ($i ; $i < $max; $i += 0.1) { |
| $this->valeurs_en_pourcentage[$chps.'_'.$num] = $i; |
| $num++; |
| } |
| } |
| } |
| } |
| public function ajouterInfoAuSurvol($champs, $case){ |
| $min = $this->valeurs_champs[$champs."_min"]; |
| $max = $this->valeurs_champs[$champs."_max"]; |
| if ($min != $max){ |
| $valeurMin = $this->recupererOntologies($min, $champs ); |
| $valeurMax = $this->recupererOntologies($max, $champs ); |
| $valeurMin = $this->traiterIntermediaires($valeurMin->nom, $champs, $champs.'_min'); |
| $valeurMax = $this->traiterIntermediaires($valeurMax->nom, $champs, $champs.'_max'); |
| $case->setAttribute('title',"de $min: $valeurMin à $max: $valeurMax " ); |
| } else { |
| $valeurMin = $this->recupererOntologies($min, $champs ); |
| $valeurMin = $this->traiterIntermediaires($valeurMin->nom, $champs, $champs.'_min'); |
| $case->setAttribute('title',"$min: $valeurMin" ); |
| } |
| } |
| } |
| ?> |
| /branches/refact/services/modules/0.1/baseflor/InformationsTaxonsSup.php |
|---|
| New file |
| 0,0 → 1,253 |
| <?php |
| /** |
| * Classe InformationsTaxonsSup.php permet de faire des requetes pour les rangs superieurs de baseflor |
| * du référentiel BDTFX et avec un numéro nomenclatural ( différent de 0 ). |
| * fin d'url possibles : |
| * |
| * /informations/#bdnt.nn:#num_nomen?champs=ecologie --> retourne champs ecologiques pour un BDNT et un num_nomen |
| * |
| * |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * @package eflore-projets |
| * @author Mathilde SALTHUN-LASSALLE <mathilde@tela-botanica.org> |
| * @author Delphine CAUQUIL <delphine@tela-botanica.org> |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version 1.0 |
| * @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class InformationsTaxonsSup extends Commun{ |
| protected $table = ""; |
| private $champs_ontologiques = array(); |
| private $format_reponse = 'informations'; |
| protected $serviceNom = 'informations'; |
| private $retour_format = 'max'; |
| private $Bdd; |
| private $requete_condition = ""; |
| private $champs_recherches = '*'; |
| public function consulter($ressources, $parametres) { |
| $this->ressources = $ressources; |
| $this->parametres = $parametres; |
| $this->traiterParametres(); |
| $this->definirTables(); |
| $this->traiterRessources(); |
| $resultats = ''; |
| foreach ($this->table_version as $version) { |
| $this->table = $version; |
| $requete = $this->assemblerLaRequete(); |
| $resultat = $this->Bdd->recupererTous($requete); |
| $versionResultat = $this->analyserResultat($resultat); |
| if (count($this->table_version) > 1) { |
| $resultats[$version] = $versionResultat; |
| } else { |
| $resultats = $versionResultat; |
| } |
| } |
| return $resultats; |
| } |
| public function analyserResultat($resultat) { |
| $versionResultat = null; |
| if ($resultat == '') { |
| $message = 'La requête SQL formée comporte une erreur!'; |
| $code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
| throw new Exception($message, $code); |
| } elseif ($resultat) { |
| $versionResultat = $this->retournerResultatFormate($resultat); |
| } |
| return $versionResultat; |
| } |
| public function __construct(Conteneur $Conteneur) { |
| $this->Bdd = $Conteneur->getBdd(); |
| } |
| //+--------------------------traitement ressources ou paramètres -------------------------------------------+ |
| public function traiterRessources() { |
| if(preg_match('/^(.+)\.nn:([0-9]+)$/', $this->ressources[0], $retour)==1){ |
| switch ($retour[1]) { |
| case 'bdtfx' : |
| $this->requete_condition[] = "num_nomen = ".$retour[2]." AND bdnt = 'bdtfx' "; |
| break; |
| default : |
| $e = 'Erreur dans l\'url de votre requête : </br> Le référentiel " ' |
| .$retour[1].' " n\'existe pas.'; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| break; |
| } |
| } |
| } |
| //+---- paramètres ----+ |
| public function traiterParametres() { |
| if (isset($this->parametres) && !empty($this->parametres) ) { |
| foreach ($this->parametres as $param => $valeur) { |
| switch ($param) { |
| case 'categorie' : |
| if ($valeur == "ecologie"){ |
| $this->champs_recherches = ' num_nomen, bdnt, ve_lumiere_min , ve_lumiere_max,' |
| .' ve_temperature_min, ve_temperature_max, ve_continentalite_min,' |
| .' ve_continentalite_max, ve_humidite_atmos_min, ve_humidite_atmos_max,' |
| .' ve_humidite_edaph_min, ve_humidite_edaph_max, ve_reaction_sol_min,' |
| .' ve_reaction_sol_max, ve_nutriments_sol_min, ve_nutriments_sol_max,' |
| .' ve_salinite_min, ve_salinite_max, ve_texture_sol_min,ve_texture_sol_max,' |
| .' ve_mat_org_sol_min, ve_mat_org_sol_max '; |
| } else { |
| $e = "Valeur de paramètre inconnue pour 'categorie'. Ce paramètre n'est pas autorisé pour informations/#id/relations/catminat"; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| break; |
| case 'retour.format' : |
| if ($valeur == 'min' || $valeur == 'max') { |
| $this->retour_format = $valeur; |
| break; |
| } else { |
| $e = "Valeur de paramètre inconnue pour 'retour.format'. Ce paramètre n'est pas autorisé pour informations/#id/relations/catminat"; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| case 'version.projet' : |
| $this->traiterVersion($valeur); |
| break; |
| default : |
| $e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " ' |
| .$param.' " n\'existe pas.'; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); break; |
| } |
| } |
| } |
| } |
| //+++------------------------------traitement des versions----------------------------------------++ |
| public function traiterVersion($valeur) { |
| if (preg_match('/^[0-9]+(?:[._][0-9]+)*$/', $valeur) || $valeur == '*' || $valeur == '+') { |
| $this->version_projet = $valeur; |
| } else { |
| $e = "Erreur : La version est inconnue."; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| if ($this->version_projet == '*' && $this->ressources == array()) { |
| $message = "L'affichage de plusieurs versions ne fonctionne que pour les ressources de type /ressources/#id"; |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($message, $code); |
| } |
| } |
| public function definirTables() { |
| $table_num_version = $this->recupererVersionDisponible(); |
| $prefixe_table = config::get('bdd_table_rang_sup'); |
| if ( in_array($this->version_projet,$table_num_version) ) { |
| $this->table_version[] = $prefixe_table.'_v'.$this->version_projet; |
| } elseif ($this->version_projet == '+') { |
| $derniere_version = $table_num_version[count($table_num_version) - 1]; |
| $this->table_version[] = $prefixe_table.'_v'.str_replace('.', '_', $derniere_version); |
| } elseif ($this->version_projet == '*') { |
| foreach ($table_num_version as $num_version) { |
| $this->table_version[] = $prefixe_table.'_v'.str_replace('.', '_', $num_version); |
| } |
| } else { |
| $e = "Erreur : La version est inconnue."; |
| throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
| } |
| } |
| //+--------------------------formatages de resultats -------------------------------------------+ |
| public function retournerResultatFormate($resultat) { |
| $this->resultat_json = $resultat[0]; |
| if ($this->retour_format == 'max') { |
| $graphique_presence = $this->traiterEcologie() ; |
| if ($graphique_presence) { |
| $this->ajouterLiensGraphique($graphique_presence); |
| } |
| } |
| return $this->resultat_json ; |
| } |
| public function traiterEcologie() { |
| $donnees_presence = false; |
| $this->champs_ontologiques = $this->recupererTableauConfig('champs_ontologiques'); |
| foreach ($this->champs_ontologiques as $cle => $valeur){ |
| if ($this->resultat_json[$cle.'_min'] != ""){ |
| $donnees_presence[$this->getNomGraphique($valeur)] = true; |
| $tab_ontologie = $this->recupererOntologies($this->resultat_json[$cle.'_min'], $cle.'_min'); |
| unset($this->resultat_json[$cle.'_min']); |
| } |
| if ($this->resultat_json[$cle.'_max'] != ""){ |
| $this->recupererOntologies($this->resultat_json[$cle.'_max'], $cle.'_max'); |
| unset($this->resultat_json[$cle.'_max']); |
| } |
| } |
| return $donnees_presence; |
| } |
| //donne le nom du graphique correspondant à un champ écologique |
| public function getNomGraphique($code_ecolo) { |
| $graphique = null; |
| if (in_array($code_ecolo, explode(',',Config::get('Paramètres.climat')))) { |
| $graphique = 'climat'; |
| } elseif (in_array($code_ecolo, explode(',', Config::get('Paramètres.sol')) )) { |
| $graphique = 'sol'; |
| } |
| return $graphique; |
| } |
| public function ajouterLiensGraphique($graphique_presence) { |
| if ($graphique_presence['climat']) { |
| $this->resultat_json['graphique_climat']['libelle'] = 'climat'; |
| $this->resultat_json['graphique_climat']['href'] = $this->ajouterHref('graphiques/climat', |
| strtolower($this->resultat_json['bdnt']).'.nn:'.$this->resultat_json['num_nomen']); |
| } |
| if ($graphique_presence['sol']) { |
| $this->resultat_json['graphique_sol']['libelle'] = 'sol'; |
| $this->resultat_json['graphique_sol']['href'] = $this->ajouterHref('graphiques/sol', |
| strtolower($this->resultat_json['bdnt']).'.nn:'.$this->resultat_json['num_nomen']); |
| } |
| } |
| //+--------------------------traitement ontologies -------------------------------------------+ |
| public function recupererOntologies($valeur, $champs){ |
| $chps_sans = preg_replace("/_min|_max/", '', $champs); |
| $url = Config::get('url_service_base').Config::get('nom_projet'). |
| '/ontologies/'.$this->champs_ontologiques[$chps_sans].':'.urlencode(urlencode($valeur)); |
| $val = $this->consulterHref($url); |
| $this->resultat_json[$champs.'.libelle'] = $val->nom; |
| $this->resultat_json[$champs.'.code'] = $valeur; |
| $this->resultat_json[$champs.'.href'] = $url; |
| } |
| //+--------------------------FONCTIONS D'ASSEMBLAGE DE LA REQUETE-------------------------------------------+ |
| public function assemblerLaRequete() { |
| $requete = ' SELECT '.$this->champs_recherches.' FROM '.$this->table.' ' |
| .$this->retournerRequeteCondition(); |
| return $requete; |
| } |
| public function retournerRequeteCondition() { |
| $condition = ''; |
| if (empty($this->requete_condition) == false) { |
| $condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
| } |
| return $condition; |
| } |
| } |
| ?> |