| /trunk/services/index.php |
|---|
| New file |
| 0,0 → 1,43 |
| <?php |
| // Encodage : UTF-8 |
| // Permet d'afficher le temps d'execution du service |
| $temps_debut = (isset($_GET['chrono']) && $_GET['chrono'] == 1) ? microtime(true) : ''; |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| /** |
| * Serveur |
| * |
| * Description : initialise le chargement et l'exécution des services web. |
| * |
| //Auteur original : |
| * @author auteur <aut@tela-botanica.org> |
| * @copyright Tela-Botanica 1999-2008 |
| * @licence GPL v3 & CeCILL v2 |
| * @version $Id$ |
| */ |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| // Le fichier autoload.inc.php du Framework de Tela Botanica doit être appelée avant tout autre chose dans l'application. |
| // Sinon, rien ne sera chargé. |
| // Chemin du fichier chargeant le framework requis |
| $framework = dirname(__FILE__).DIRECTORY_SEPARATOR.'framework.php'; |
| if (!file_exists($framework)) { |
| $e = "Veuillez paramétrer l'emplacement et la version du Framework dans le fichier $framework"; |
| trigger_error($e, E_USER_ERROR); |
| } else { |
| // Inclusion du Framework |
| require_once $framework; |
| // Ajout d'information concernant cette application |
| Framework::setCheminAppli(__FILE__);// Obligatoire |
| Framework::setInfoAppli(Config::get('info')); |
| // Initialisation et lancement du serveur |
| $Serveur = new RestServeur(); |
| $Serveur->executer(); |
| // Affiche le temps d'execution du service |
| if (isset($_GET['chrono']) && $_GET['chrono'] == 1) { |
| $temps_fin = microtime(true); |
| echo 'Temps d\'execution : '.round($temps_fin - $temps_debut, 4); |
| } |
| } |
| ?> |
| /trunk/services/framework.php |
|---|
| New file |
| 0,0 → 1,6 |
| <?php |
| // Inclusion du Framework |
| // Renomer ce fichier en "framework.php" |
| // Indiquer ci-dessous le chemin absolu vers le fichier autoload.inc.php de la bonne version du Framework |
| require_once '/home/greg/web/framework-0.3/framework/Framework.php'; |
| ?> |
| /trunk/services/modules/0.1/ReponseHttp.php |
|---|
| New file |
| 0,0 → 1,62 |
| <?php |
| class ReponseHttp { |
| private $resultatService = null; |
| private $erreurs = array(); |
| public function __construct() { |
| $this->resultatService = new ResultatService(); |
| } |
| public function setResultatService($resultat) { |
| if (!($resultat instanceof ResultatService)) { |
| $this->resultatService->corps = $resultat; |
| } else { |
| $this->resultatService = $resultat; |
| } |
| } |
| public function getCorps() { |
| if ($this->etreEnErreur()) { |
| $this->resultatService->corps = $this->erreurs[0]['message']; |
| } else { |
| $this->transformerReponseCorpsSuivantMime(); |
| } |
| return $this->resultatService->corps; |
| } |
| public function ajouterErreur(Exception $e) { |
| $this->erreurs[] = array('entete' => $e->getCode(), 'message' => $e->getMessage()); |
| } |
| public function emettreLesEntetes() { |
| $enteteHttp = new EnteteHttp(); |
| if ($this->etreEnErreur()) { |
| $enteteHttp->code = $this->erreurs[0]['entete']; |
| $enteteHttp->mime = 'text/html'; |
| } else { |
| $enteteHttp->encodage = $this->resultatService->encodage; |
| $enteteHttp->mime = $this->resultatService->mime; |
| } |
| header("Content-Type: $enteteHttp->mime; charset=$enteteHttp->encodage"); |
| RestServeur::envoyerEnteteStatutHttp($enteteHttp->code); |
| } |
| private function etreEnErreur() { |
| $enErreur = false; |
| if (count($this->erreurs) > 0) { |
| $enErreur = true; |
| } |
| return $enErreur; |
| } |
| private function transformerReponseCorpsSuivantMime() { |
| switch ($this->resultatService->mime) { |
| case 'application/json' : |
| $this->resultatService->corps = json_encode($this->resultatService->corps); |
| break; |
| } |
| } |
| } |
| ?> |
| /trunk/services/modules/0.1/Commun.php |
|---|
| New file |
| 0,0 → 1,419 |
| <?php |
| /** |
| * Classe Commun.php est une classe abstraite qui contient les méthodes de base communes à tous les |
| * sous-services des projets. |
| * |
| * 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 1.0 |
| * @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| abstract class Commun { |
| /** Objet Bdd. */ |
| private $Bdd = null; |
| /** Objet Rest Client. */ |
| private $RestClient = null; |
| /** Contients les paramètres. Doit remplacer table_param. */ |
| protected $parametres = array(); |
| /** Contients les ressources. Doit remplacer table_ressources. */ |
| protected $ressources = array(); |
| /** Le nom du service courrant. */ |
| protected $serviceNom = null; |
| //Classe commune à tous les services web d'un projet. Contient par exemple les fonctions permettant de |
| //renvoyer la réponse http... |
| protected $entete_http; // Entete de la réponse correspondant au code de réponse de la requete http */ |
| protected $corps_http; // Tableau de résultat à retourner au format json ou la description de l'erreur si elle existe */ |
| protected $service; // Nom du service appelé |
| /** Stocke la version du projet demandée dans la requete |
| * - "*" : (/#projet/* /meta-donnees) Renvoi les meta-données de toutes les versions du projet |
| * - "numero de la version" : (/#projet/2.00/meta-donnees) Renvoi les meta-données de la version 2.00 du projet */ |
| protected $version_projet = '+'; |
| protected $table_version; //Stocke les noms des tables de toutes les versions du projet disponibles |
| /** tableau contenant tous les champs d'une table (est rempli par la fonction Commun::recupererNomChamp($table)) */ |
| protected $champs_table = array(); |
| private static $tri_multi_dimension = array(); |
| private static $tri_type = ''; |
| public function consulter($ressources, $parametres) { |
| $this->ressources = $ressources; |
| $this->parametres = $parametres; |
| $this->chargerNomDuService(); |
| $this->traiterParametres(); |
| $this->traiterVersionProjet(); |
| $resultats = ''; |
| 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(); //dans CommunNomsTaxons.php |
| $requete = $this->assemblerLaRequete(); |
| $resultat = $this->getBdd()->recupererTous($requete); |
| $versionResultat = $this->traiterResultat($resultat, $version, $requete); |
| if (count($this->table_version) > 1) { |
| $resultats[$version] = $versionResultat; |
| } else { |
| $resultats = $versionResultat; |
| } |
| } |
| return $resultats; |
| } |
| private function chargerNomDuService() { |
| $this->serviceNom = get_class($this); |
| } |
| public function traiterResultat($resultat, $version, $requete) { |
| $versionResultat = null; |
| if ($resultat == '') { |
| //cas ou la requete comporte des erreurs |
| $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, $version); |
| } else { |
| $message = 'Les données recherchées sont introuvables.'; |
| $code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
| throw new Exception($message, $code); |
| } |
| return $versionResultat; |
| } |
| //+------------------------------------------------------------------------------------------------------+ |
| // Méthodes concernant les paramètres |
| /** |
| * Permet de récupérer une liste des noms des champs de la table passée en paramètre |
| * @param $table : Nom de la table dont on souhaite connaitre les champs |
| */ |
| public function recupererNomChamp($table) { |
| $requete = 'SHOW FIELDS FROM '.$table; |
| $resultat = $this->getBdd()->recupererTous($requete); |
| if ($resultat == '') { |
| $e = 'La requête SQL formée comporte une erreur!'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
| } elseif ($resultat) { |
| foreach ($resultat as $info) { |
| $this->champs_table[] = $info['Field']; |
| } |
| } else { |
| $m = "La table recherchée n'existe pas"; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $m); |
| } |
| } |
| /** |
| * 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 : recupererTableConfig('champs_api,champs_bdtfx') |
| */ |
| public function recupererTableConfig($table) { |
| $tables = explode(',', $table); |
| foreach ($tables as $tab) { |
| $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 renvoyerErreur($entete, $message) { |
| throw new Exception($message, $entete); |
| } |
| /** |
| * Permet de remplir la variable version_projet et de retirer cette donnée du tableau des ressources |
| * @param $ressources |
| */ |
| public function traiterVersionProjet() { |
| if (isset($this->parametres['version.projet'])) { |
| if (preg_match('/^[0-9]+(?:[._][0-9]+|)$/', $this->parametres['version.projet'])) { |
| $this->version_projet = $this->parametres['version.projet']; |
| $this->version_projet = 'v'.str_replace('.', '_', $this->version_projet); |
| } else { |
| $this->version_projet = $this->parametres['version.projet']; |
| } |
| } |
| //si la liste des noms est demandée pr toutes les versions, on affiche seulement la dernière version : |
| 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); |
| } |
| //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); |
| } |
| /** |
| * Recupération des versions disponibles par appel du service metaDonnees |
| * Verification de l'existance du service recherché dans la requete (si précisé : hors *) |
| * @return array : tableau contenant le numéro de chaque version disponible |
| */ |
| public function recupererVersionDisponible() { |
| $versions_dispo = ''; |
| $req_version = 'SELECT version FROM '.Config::get('bdd_table_meta'); |
| $res_version = $this->getBdd()->recupererTous($req_version); |
| if ($res_version == '') { //cas ou la requete comporte des erreurs |
| $e = "La requête SQL de versionnage formée comporte une erreur : $req_version"; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
| } elseif ($res_version) { |
| foreach ($res_version as $version) { |
| $versions_dispo[] = $version['version']; |
| } |
| } else { |
| $m = 'Versions introuvables dans la table des méta-données'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $m); |
| } |
| return $versions_dispo; |
| } |
| public function recupererListeNomTablePrChaqueVersion($table_num_version) { |
| switch ($this->serviceNom) { |
| case 'Ontologies' : |
| $prefixe_table = 'bdd_table_ontologies'; |
| break; |
| default: |
| $prefixe_table = 'bdd_table'; |
| } |
| switch ($this->version_projet) { |
| case '+' : |
| $derniere_version = $table_num_version[count($table_num_version) - 1]; |
| $this->table_version[] = Config::get($prefixe_table).'_v'.str_replace('.', '_', $derniere_version); |
| break; |
| case '*' : |
| foreach ($table_num_version as $num_version) { |
| $this->table_version[] = Config::get($prefixe_table).'_v'.str_replace('.', '_', $num_version); |
| } |
| break; |
| default : |
| $this->table_version[] = Config::get($prefixe_table).'_'.$this->version_projet; |
| break; |
| } |
| } |
| /** |
| * Est appelée pour former l'url complete des resultats precedants ou suivants. |
| * @param int : Permet de connaitre le nombre de noms obtenus par la requete |
| * @return string Retourne l'url complete des resultats precedents ou suivant sous la forme d'un tableau |
| */ |
| public function formulerUrl($nb_resultat, $id = null) { |
| $url = array(); |
| $debut_url = Config::get('url_service').$id.'?'; |
| //on recré l'url sans les parametres de navigation qui seront rajouter ci-apres. On les enlève dc de la table des parametres |
| foreach($this->parametres as $cle => $val) { |
| $param_url[str_replace('_', '.', $cle)] = $val; |
| } |
| $this->recupererLesLimitesSuivantes($nb_resultat, $param_url); |
| if (isset($param_url['navigation.depart']) && isset($param_url['navigation.limite'])) { |
| $url['suivant'] = $debut_url.http_build_query($param_url); |
| } |
| $this->recupererLesLimitesPrecedentes($param_url); |
| if (isset($param_url['navigation.depart']) && isset($param_url['navigation.limite'])) { |
| $url['precedent'] = $debut_url.http_build_query($param_url); |
| } |
| return $url; |
| } |
| public function supprimerNavigation(&$param_url) { |
| unset($param_url['navigation.depart']); |
| unset($param_url['navigation.limite']); |
| } |
| /** |
| * Description : |
| * Permet de former les limites de la requete retournant les résultats suivants. |
| * Cette url sera afficher dans l'entete de la reponse retournée en format JSON (retour.format=defaut). |
| * @param int : $nb_resultat : Permet de connaitre le nombre de résultats obtenus par la requete |
| * @return string : la fin de l'url decrivant les limites des resultats suivants. Si aucun résultats ne suient, |
| * une chaine de caractère vide est retournée |
| */ |
| public function recupererLesLimitesSuivantes($nb_resultat, &$param_url_suiv) { |
| $this->supprimerNavigation($param_url); |
| $depart = $this->limite_requete['depart']; |
| $limite = $this->limite_requete['limite']; |
| $depart_suivant = $depart + $limite; |
| $limite_suivant = $limite; |
| if ($nb_resultat > $depart_suivant) { |
| $param_url_suiv['navigation.depart'] = $depart_suivant; |
| $param_url_suiv['navigation.limite'] = $limite_suivant; |
| } else { |
| $param_url_suiv['navigation.depart'] = null; |
| $param_url_suiv['navigation.limite'] = null; |
| } |
| } |
| /** |
| * Description : |
| * Permet de former les limites de la requete retournant les résultats precedents. |
| * Cette url sera afficher dans l'entete de la taxons/105reponse retournée en format JSON (retour.format=defaut) |
| * @return string : la fin de l'url decrivant les limites des resultats precedents. |
| * Si aucun résultats ne precedent, une chaine de caractère vide est retournée |
| */ |
| public function recupererLesLimitesPrecedentes(&$param_url) { |
| $this->supprimerNavigation($param_url); |
| $depart = $this->limite_requete['depart']; |
| $limite = $this->limite_requete['limite']; |
| if ($depart == 0) { |
| $url_precedente = ''; |
| } else { |
| if (($depart - $limite) < 0) { |
| $depart_precedent = 0; |
| } else { |
| $depart_precedent = $depart - $limite; |
| } |
| $param_url['navigation.depart'] = $depart_precedent; |
| $param_url['navigation.limite'] = $limite; |
| } |
| } |
| public function ajouterHref($service, $val) { |
| // http://tela-botanica.org/service:eflore:0.1/[projet]/[version_projet]/[service]/[ressource]:[valeur] |
| if ($this->version_projet == '+') { |
| $url = Config::get('url_service_base').Config::get('nom_projet').'/'.$service.'/'.$val; |
| } else { |
| $url = Config::get('url_service_base').Config::get('nom_projet').'/'.$service.'/'.$val.'?version.projet='.ltrim($this->version_projet, 'v'); |
| } |
| return $url; |
| } |
| public function ajouterHrefAutreProjet($service, $ressource, $valeur, $projet = null, $param = null) { |
| //on enleve les GA et Co, les meta ou les "_" |
| $this->transliterer($service, $valeur); |
| //on définit les nom des projets, des services et des ressources de l'url (dans les méta-donnees) |
| $tab = array( |
| 'langue' => array('service' => 'langues', 'projet' => 'iso-639-1', 'ressource' => ''), |
| 'couverture_spatiale' => array('service' => 'zone-geo', 'projet' => 'iso-3166-1', 'ressource' => ''), |
| 'type' => array('service' => 'ontologies', 'projet' => 'eflore', 'ressource' => 'contactType:'), |
| 'datum' => array('service' => 'ontologies', 'projet' => 'eflore', 'ressource' => 'datum:') |
| ); |
| if (array_key_exists($service, $tab)) { |
| extract($tab[$service]); |
| } else { |
| if (strpos(Config::get('nom_projet'), 'bd') === 0 && $projet == null) { |
| $projet = 'bdnt'; |
| $service = 'ontologies'; |
| $ressource = ''; |
| } |
| } |
| $param = ($param) ? "?".$param : ""; |
| $url = Config::get('url_service_base').$projet.'/'.$service.'/'.$ressource.$valeur.$param; |
| return $url; |
| } |
| /**Permet de consulter une url et retourne le résultat ou une erreur |
| * @param $url */ |
| public function consulterHref($url) { |
| $res = $this->getRestClient()->consulter($url); |
| $entete = $this->getRestClient()->getReponseEntetes(); |
| //Si le service meta-donnees fonctionne correctement, l'entete comprend la clé wrapper_data |
| if (isset($entete['wrapper_data'])) { |
| $res = json_decode($res); |
| return $res; |
| } else { |
| $u = 'L\'url <a href="'.$url.'">'.$url.'</a> lancée via RestClient renvoie une erreur'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $u); |
| } |
| } |
| public function transliterer(&$service, &$val) { |
| if (preg_match('/^.+:(.+)$/', $val, $match)) { |
| $val = $match[1]; |
| } |
| $service = str_replace(array('_Ga','_Co','_meta'), '', $service); |
| if ($service == 'rang') { |
| $ressource = 'rangTaxo'; |
| } elseif (preg_match('/^(statut)(?:_|-)([^_-]+)$/', $service, $match)) { |
| $service = $match[1].ucfirst($match[2]); |
| } elseif (strrpos($service, 'datum') !== false) { |
| $service = 'datum'; |
| } |
| } |
| // prend en valeur la valeur de la recherche, les résultats approchés, le paramétre recherche |
| // retourne le tableau trié en fonction de la ressemble entre le résultat approché et la valeur recherchée |
| public function trierRechercheFloue($nom_demande, $tab_approchee, $nom) { |
| $trie = ''; |
| $resultat = array(); |
| foreach ($tab_approchee as $id => $tab) { |
| $nom_demande_ss = strtolower(Chaine::supprimerAccents($nom_demande)); |
| $nom_flou_ss = strtolower(Chaine::supprimerAccents($tab[$nom])); |
| $stat = array(); |
| // Prime pour la ressemblance globale : |
| $score = 500 - levenshtein($nom_flou_ss, $nom_demande_ss); |
| // On affine |
| $score = $score + (similar_text($nom_demande_ss, $nom_flou_ss) * 3); |
| $stat['score'] = $score; |
| foreach ($tab as $key => $valeur) { |
| $stat[$key] = $valeur; |
| } |
| $resultat[] = $stat; |
| } |
| // Vérification que nous avons bien trouvé un nom approché |
| if (count($resultat) > 0) { |
| $trie = Tableau::trierMD($resultat, array('score' => SORT_DESC)); |
| } |
| return $trie; |
| } |
| protected function recupererTableauConfig($param) { |
| $tableau = array(); |
| $tableauPartiel = explode(',', Config::get($param)); |
| $tableauPartiel = array_map('trim', $tableauPartiel); |
| foreach ($tableauPartiel as $champ) { |
| if (strpos($champ, '=') === false) { |
| $tableau[] = $champ; |
| } else { |
| list($cle, $val) = explode('=', $champ); |
| $tableau[$cle] = $val; |
| } |
| } |
| return $tableau; |
| } |
| //+------------------------------------------------------------------------------------------------------+ |
| // 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; |
| } |
| /** |
| * Méthode permettant de faire appel à un client REST en fonction des besoins du service. |
| */ |
| protected function getRestClient() { |
| if (! isset($this->RestClient)) { |
| $this->RestClient = new RestClient(); |
| } |
| return $this->RestClient; |
| } |
| } |
| ?> |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /trunk/services/modules/0.1/del/Images.php |
|---|
| New file |
| 0,0 → 1,322 |
| <?php |
| // VOIR IMAGE RECREATION L 294 |
| /*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 DEL. | |
| // | | |
| // | 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 $ |
| /** |
| * Gestion des des images dans la base de donnée de Détermination en Ligne (DEL) |
| * |
| * |
| *@package del |
| *@subpackage images |
| //Auteur original : |
| *@author Grégoire Duché <gregoire@tela-botanica.org> |
| *@copyright Tela-Botanica 2000-2012 |
| *@version $Revision: 1.9 $ $Date: 2007-11-06 10:54:03 $ |
| // +------------------------------------------------------------------------------------------------------+ |
| */ |
| class Images extends Commun { |
| //Paramètres |
| private $depart = 0; |
| private $limite = 1; |
| private $format = 'json'; |
| private $total; |
| private $idImage; |
| private $config; |
| /** |
| * Méthode principale de la classe |
| * Lance la récupération des images dans la base et les place dans un objet ResultatService |
| * pour l'afficher. |
| * */ |
| public function consulter($ressources, $parametres) { |
| $this->config = Config::get('images'); |
| $this->chargerParametres($parametres); |
| $this->UrlNavigation = new Url($this->config['url_service']); |
| $resultat = new ResultatService(); |
| $this->compterImages(); |
| $entete = $this->getEntete(); |
| $resultats = $this->chargerImages($this->idImage); |
| $this->formaterImages($resultats); |
| $this->chargerObservations($resultats); |
| $this->chargerVotes($resultats); |
| $resultat->corps = array('entete' => $entete, 'resultats' => $resultats); |
| return $resultat; |
| } |
| /** |
| * Récupérer l'id de l'image depuis les paramètres |
| * */ |
| public function chargerParametres($parametres) { |
| $this->parametres = $parametres; |
| if (isset($this->parametres['navigation.depart'])) { |
| $this->depart = $this->parametres['navigation.depart']; |
| } |
| if (isset($this->parametres['navigation.limite'])) { |
| $this->limite = $this->parametres['navigation.limite']; |
| } |
| if (isset($this->parametres['masque.id'])) { |
| $idImage = $this->parametres['masque.id']; |
| $this->idImage = $idImage; |
| } |
| } |
| /** |
| * Compter le nombre total d'images dans la base pour affichage dans entete. |
| * */ |
| private function compterImages() { |
| //TODO : gérer le nom de la base par fichier de config |
| //TODO : gérer les erreurs de connexion à la bdd |
| $requeteNbImages = 'SELECT COUNT(*) AS nb FROM del.del_image '; |
| $resultatNbImages = $this->getBdd()->recuperer($requeteNbImages); |
| $this->total = $resultatNbImages['nb']; |
| } |
| /** |
| * Créer l'entête en fonction des paramètres donnés |
| * */ |
| private function getEntete() { |
| $entete = array(); |
| $entete['masque'] = $this->recupererMasque(); |
| $entete['depart'] = $this->depart; |
| $entete['limite'] = $this->limite; |
| $entete['total'] = $this->total; |
| $lienPrecedent = $this->recupererHrefPrecedent(); |
| if ($lienPrecedent != null) { |
| $entete['entete.precedent'] = $lienPrecedent; |
| } |
| $lienSuivant = $this->recupererHrefSuivant(); |
| if ($lienSuivant) { |
| $entete['entete.suivant'] = $lienSuivant; |
| } |
| return $entete; |
| } |
| /** |
| * Récupérer le lien pour afficher les images précédentes en fonction des paramètres |
| * */ |
| private function recupererHrefPrecedent() { |
| $departActuel = $this->depart; |
| $limite = $this->limite; |
| $departSuivant = $departActuel - $limite; |
| $url = null; |
| if ($departSuivant > 0) { |
| $parametres = array(); |
| if ($this->idImage != null) { |
| $parametres['masque.id'] = $this->idImage; |
| } |
| $url = $this->obtenirUrlNavigation($departSuivant, $limite, $parametres); |
| } |
| return $url; |
| } |
| private function recupererHrefSuivant() { |
| $departActuel = $this->depart; |
| $limite = $this->limite; |
| $departSuivant = $departActuel + $limite; |
| $url = null; |
| if ($departSuivant < $this->total) { |
| $parametres = array(); |
| if ($this->idImage != null) { |
| $parametres['masque.id'] = $this->idImage; |
| } |
| $url = $this->obtenirUrlNavigation($departSuivant, $limite, $parametres); |
| } |
| return $url; |
| } |
| private function obtenirUrlNavigation($depart, $limite, $parametresAdditionnels) { |
| $parametres = array( |
| 'navigation.depart' => $depart, |
| 'navigation.limite' => $limite); |
| if ($parametresAdditionnels != null) { |
| $parametres = array_merge($parametres, $parametresAdditionnels); |
| } |
| $this->UrlNavigation->setRequete($parametres); |
| $url = $this->UrlNavigation->getURL(); |
| return $url; |
| } |
| /** |
| * Chargement depuis la bdd d'une ou plusieurs images |
| * */ |
| private function chargerImages($imageId = null) { |
| //TODO : gérer le nom de la base par fichier de config |
| $requeteImages = 'SELECT * FROM del.del_image'; |
| if ($imageId != null) { |
| $requeteImages .= ' WHERE id_image = '.$this->getBdd()->proteger($imageId); |
| } |
| $requeteImages .= $this->getLimite(); |
| return $this->getBdd()->recupererTous($requeteImages); |
| } |
| /** |
| * Créer la chaine de limite de requête en fonction des paramètres donnés |
| * */ |
| private function getLimite() { |
| return ' LIMIT '.$this->depart.', '.$this->limite; |
| } |
| /** |
| * Charger les observations pour chaque image |
| * */ |
| private function chargerObservations(&$images) { |
| $i = 0; |
| foreach ($images as $image) { |
| $idImage = $image['id_image']; |
| $requeteLiaison = 'SELECT ce_observation as idObs '. |
| 'FROM del.del_obs_images WHERE ce_image = '.$this->getBdd()->proteger($idImage); |
| $resultatLiaison = $this->getBdd()->recupererTous($requeteLiaison); |
| $observations = array(); |
| foreach ($resultatLiaison as $liaison) { |
| $idObs = $liaison['idObs']; |
| $requeteObservation = 'SELECT * FROM del.del_observation '. |
| 'WHERE id_observation = '.$this->getBdd()->proteger($idObs); |
| $resultatObservation = $this->getBdd()->recuperer($requeteObservation); |
| $observations[] = $this->formaterObservation($resultatObservation); |
| } |
| $images[$i]['observations'] = $observations; |
| $i++; |
| } |
| } |
| /** |
| * Charger les votes pour chaque image |
| * */ |
| private function chargerVotes(&$images) { |
| $i = 0; |
| foreach ($images as $image) { |
| $idImage = $image['id_image']; |
| $requeteVotes = 'SELECT * FROM del.del_vote_image WHERE ce_image = '.$this->getBdd()->proteger($idImage); |
| $votes = $this->getBdd()->recupererTous($requeteVotes); |
| $images[$i]['votes'] = $votes; |
| $i++; |
| } |
| } |
| /** |
| * Formater les résultats des images de la requête pour retour |
| * */ |
| private function formaterImages(&$resultats) { |
| $images = array(); |
| foreach ($resultats as $ligne) { |
| $image = array(); |
| $image['id_image'] = $ligne['id_image']; |
| $image['date'] = $ligne['date_prise_de_vue']; |
| // TODO : gérer le lien vers tela à partir de l'identifiant |
| $image['binaire.href'] = $this->formaterLienImage($ligne['id_image']); |
| $image['hauteur'] = $ligne['hauteur']; |
| $image['largeur'] = $ligne['largeur']; |
| // Votes et observations sont mis à jour plus a posteriori dans l'application |
| $image['votes'] = array(); |
| $image['observations'] = array(); |
| $images[] = $image; |
| } |
| $resultats = $images; |
| } |
| /** |
| * Formater le lien de l'image en fonction du fichier de config et de l'identifiant de l'image |
| * */ |
| private function formaterLienImage($idImage) { |
| $idImage = sprintf('%09s', $idImage); |
| $url = $this->config['url_images']; |
| $urlImage = str_replace('%s', $idImage, $url); |
| return $urlImage; |
| } |
| /** |
| * Formater les résultats de la requête observation pour retour |
| * */ |
| private function formaterObservation(&$observation) { |
| $retour = array(); |
| $retour['id_observation'] = $observation['id_observation']; |
| $retour['date_observation'] = $observation['date_observation']; |
| $retour['date_transmission'] = $observation['date_transmission']; |
| $retour['determination.famille'] = $observation['famille']; |
| $retour['determination.ns'] = $observation['nom_sel']; |
| $retour['determination.nn'] = $observation['nom_sel_nn']; |
| $retour['determination.nt'] = $observation['nt']; |
| $retour['id_zone_geo'] = $observation['ce_zone_geo']; |
| $retour['zone_geo'] = $observation['zone_geo']; |
| $retour['lieudit'] = $observation['lieudit']; |
| $retour['station'] = $observation['station']; |
| $retour['milieu'] = $observation['milieu']; |
| $retour['auteur.id'] = $observation['ce_utilisateur']; |
| $this->chargerAuteur($retour); |
| return $retour; |
| } |
| /** |
| * Récupérer le nom et prénom de l'auteur dans la table utilisateurs |
| * */ |
| private function chargerAuteur(&$retour) { |
| $idAuteur = $retour['auteur.id']; |
| $requeteAuteur = 'SELECT * FROM del.del_utilisateur WHERE id_utilisateur = '.$this->getBdd()->proteger($idAuteur); |
| $resultatAuteur = $this->getBdd()->recuperer($requeteAuteur); |
| $retour['auteur.nom'] = $resultatAuteur['nom']; |
| $retour['auteur.prenom'] = $resultatAuteur['prenom']; |
| } |
| /** |
| * Récupérer le masque depuis les paramètres |
| * */ |
| 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; |
| } |
| } |
| ?> |
| /trunk/services/modules/0.1/Outils.php |
|---|
| New file |
| 0,0 → 1,21 |
| <?php |
| class Outils { |
| public static function recupererTableauConfig($parametres) { |
| $tableau = array(); |
| $tableauPartiel = explode(',', Config::get($parametres)); |
| $tableauPartiel = array_map('trim', $tableauPartiel); |
| foreach ($tableauPartiel as $champ) { |
| if (strpos($champ, '=') === false) { |
| $tableau[] = $champ; |
| } else { |
| list($cle, $val) = explode('=', $champ); |
| $clePropre = trim($cle); |
| $valeurPropre = trim($val); |
| $tableau[$clePropre] = $valeurPropre; |
| } |
| } |
| return $tableau; |
| } |
| } |
| ?> |
| /trunk/services/modules/0.1/EnteteHttp.php |
|---|
| New file |
| 0,0 → 1,7 |
| <?php |
| class EnteteHttp { |
| public $code = RestServeur::HTTP_CODE_OK; |
| public $encodage = 'utf-8'; |
| public $mime = 'application/json'; |
| } |
| ?> |
| /trunk/services/modules/0.1/ResultatService.php |
|---|
| New file |
| 0,0 → 1,7 |
| <?php |
| class ResultatService { |
| public $mime = 'application/json'; |
| public $encodage = 'utf-8'; |
| public $corps = ''; |
| } |
| ?> |
| /trunk/services/modules/0.1/Projets.php |
|---|
| New file |
| 0,0 → 1,207 |
| <?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; |
| /** 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(); |
| $retour = $service->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; |
| } |
| } |
| ?> |
| /trunk/services/biliotheque/ResultatService.php |
|---|
| New file |
| 0,0 → 1,7 |
| <?php |
| class ResultatService { |
| public $mime = 'application/json'; |
| public $encodage = 'utf-8'; |
| public $corps = ''; |
| } |
| ?> |
| /trunk/services/biliotheque/ReponseHttp.php |
|---|
| New file |
| 0,0 → 1,62 |
| <?php |
| class ReponseHttp { |
| private $resultatService = null; |
| private $erreurs = array(); |
| public function __construct() { |
| $this->resultatService = new ResultatService(); |
| } |
| public function setResultatService($resultat) { |
| if (!($resultat instanceof ResultatService)) { |
| $this->resultatService->corps = $resultat; |
| } else { |
| $this->resultatService = $resultat; |
| } |
| } |
| public function getCorps() { |
| if ($this->etreEnErreur()) { |
| $this->resultatService->corps = $this->erreurs[0]['message']; |
| } else { |
| $this->transformerReponseCorpsSuivantMime(); |
| } |
| return $this->resultatService->corps; |
| } |
| public function ajouterErreur(Exception $e) { |
| $this->erreurs[] = array('entete' => $e->getCode(), 'message' => $e->getMessage()); |
| } |
| public function emettreLesEntetes() { |
| $enteteHttp = new EnteteHttp(); |
| if ($this->etreEnErreur()) { |
| $enteteHttp->code = $this->erreurs[0]['entete']; |
| $enteteHttp->mime = 'text/html'; |
| } else { |
| $enteteHttp->encodage = $this->resultatService->encodage; |
| $enteteHttp->mime = $this->resultatService->mime; |
| } |
| header("Content-Type: $enteteHttp->mime; charset=$enteteHttp->encodage"); |
| RestServeur::envoyerEnteteStatutHttp($enteteHttp->code); |
| } |
| private function etreEnErreur() { |
| $enErreur = false; |
| if (count($this->erreurs) > 0) { |
| $enErreur = true; |
| } |
| return $enErreur; |
| } |
| private function transformerReponseCorpsSuivantMime() { |
| switch ($this->resultatService->mime) { |
| case 'application/json' : |
| $this->resultatService->corps = json_encode($this->resultatService->corps); |
| break; |
| } |
| } |
| } |
| ?> |
| /trunk/services/framework.defaut.php |
|---|
| New file |
| 0,0 → 1,6 |
| <?php |
| // Inclusion du Framework |
| // Renomer ce fichier en "framework.php" |
| // Indiquer ci-dessous le chemin absolu vers le fichier autoload.inc.php de la bonne version du Framework |
| require_once '/home/delphine/web/framework-0.3/framework/Framework.php'; |
| ?> |
| /trunk/services/README.txt |
|---|
| New file |
| 0,0 → 1,5 |
| Configurer le .htacces de la racine du serveur pour placer la ligne : |
| # Règle de ré-ecriture d'url pour l'accès au format eFlore |
| RewriteRule ^service:del:([0-9]\.[0-9])/([^/]+)/(v[0-9]+[_.][0-9]+|[+*]|v[0-9]+)/([^/]+)/?(.*)?$ /del/services/$1/projets/$2/$4/$5?version.projet=$3 |
| RewriteRule ^service:del:([0-9]\.[0-9])/([^/]+)/(.+)$ /del/services/$1/projets/$2/$3 |
| Property changes: |
| Added: svn:eol-style |
| +native |
| \ No newline at end of property |