/trunk/services/bibliotheque/ReponseHttp.php |
---|
File deleted |
\ No newline at end of file |
/trunk/services/bibliotheque/Commun.php |
---|
File deleted |
\ No newline at end of file |
/trunk/services/bibliotheque/Outils.php |
---|
File deleted |
\ No newline at end of file |
/trunk/services/bibliotheque/EnteteHttp.php |
---|
File deleted |
\ No newline at end of file |
/trunk/services/bibliotheque/ResultatService.php |
---|
File deleted |
\ No newline at end of file |
/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 |
---|
1,4 → 1,6 |
<?php |
// VOIR IMAGE RECREATION L 294 |
/*vim: set expandtab tabstop=4 shiftwidth=4: */ |
// +------------------------------------------------------------------------------------------------------+ |
// | PHP version 5.1.1 | |
23,63 → 25,54 |
// +------------------------------------------------------------------------------------------------------+ |
// CVS : $Id: effi_cel.action.php,v 1.9 2007-11-06 10:54:03 jp_milcent Exp $ |
/** |
* Le web service image récupère toutes les données de la table del_obs_images |
* pour retourner une liste d'images associée à une observation |
* |
* @package del |
* @subpackage images |
* @author Grégoire Duché <gregoire@tela-botanica.org> |
* @copyright Tela-Botanica 2000-2012 |
* @version $Revision: 1.9 $ $Date: 2007-11-06 10:54:03 $ |
* 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; |
private $schemaBdd; |
private $depart = 0; |
private $limite = 10; |
private $total; // Le nombre total d'images |
private $masque = array(); //Enregistrer les paramètres du masque |
private $auteurIds = array(); // La liste des identifiants des auteurs pour retrouver leur nom dans la base |
private $imageIds = array(); |
/** |
* 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. |
* @param $ressources les ressources situées après l'url de base (ex : http://url/ressource1/ressource2) |
* @param $parametres les paramètres situés après le ? dans l'url |
* */ |
public function consulter($ressources, $parametres) { |
// Gestion des configuration du script |
// TODO : gérer les erreurs de config |
// TODO : voir la classe Conteneur |
$this->config = Config::get('images'); |
$this->schemaBdd = $this->config['schemaBdd']; |
$this->UrlNavigation = new Url($this->config['url_service']); |
$this->chargerParametres($parametres); |
$this->compterImages(); |
// Lancement du service |
$liaisons = $this->chargerLiaisons(); |
$images = $this->chargerImage($liaisons); |
$this->chargerAuteurs($images); |
$this->chargerVotes($images); |
$this->UrlNavigation = new Url($this->config['url_service']); |
// Mettre en forme le résultat et l'envoyer pour affichage |
$resultat = new ResultatService(); |
$resultat->corps = array('entete' => $this->getEntete(), 'resultats' => $images); |
$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; |
} |
/*------------------------------------------------------------------------------- |
CONFIGURATION DU SERVICE |
--------------------------------------------------------------------------------*/ |
/** |
* Gestion des paramètres de l'application pour stockage dans variable de classe |
* @param $parametres les paramètres tels que passés à la méthode consulter |
* Récupérer l'id de l'image depuis les paramètres |
* */ |
public function chargerParametres($parametres) { |
$this->parametres = $parametres; |
92,73 → 85,11 |
$this->limite = $this->parametres['navigation.limite']; |
} |
foreach ($parametres as $id => $parametre) { |
if (strpos($id, 'masque.') === 0) { |
$champ = substr($id, 7, strlen($id)); |
$this->masque[$champ] = $parametre; |
} |
if (isset($this->parametres['masque.id'])) { |
$idImage = $this->parametres['masque.id']; |
$this->idImage = $idImage; |
} |
} |
/** |
* 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 la clause WHERE en fonction des paramètres de masque |
* */ |
private function chargerClauseWhere() { |
$where = array(); |
if (isset($this->masque['famille'])) { |
$where[] = " famille = '".$this->masque['famille']."' "; |
} |
if (isset($this->masque['genre'])) { |
$where[] = " genre = '".$this->masque['genre']."' "; |
} |
if (isset($this->masque['espece'])) { |
$where[] = " nom_sel = '".$this->masque['espece']."' "; |
} |
if (isset($this->masque['ns'])) { |
$where[] = " nom_sel_nn = '".$this->masque['ns']."' "; |
} |
// TODO : voir la définition du webservice et la gestion nn et ns |
/*if (isset($this->masque['nn'])) { |
$where[] = " nn = '".$this->masque['nn']."' "; |
}*/ |
// TODO : voir la liaision avec auteur : sur id ? |
if (isset($this->masque['auteur'])) { |
$where[] = " ce_utilisateur = '".$this->masque['auteur']."' "; |
} |
// TODO : date de quoi ? |
/*if (isset($this->masque['date'])) { |
$where[] = " date = '".$this->masque['date']."' "; |
}*/ |
//TODO : ??? |
/*if (isset($this->masque['commune'])) { |
$where[] = " commune = '".$this->masque['commune']."' "; |
}*/ |
//TODO : ??? |
/*if (isset($this->masque['departement'])) { |
$where[] = " departement = '".$this->masque['departement']."' "; |
}*/ |
if (isset($this->masque['tag'])) { |
$where[] = " mots_cles_texte = '".$this->masque['tag']."' "; |
} |
return 'WHERE '.implode('AND', $where); |
} |
/** |
165,147 → 96,14 |
* Compter le nombre total d'images dans la base pour affichage dans entete. |
* */ |
private function compterImages() { |
$requeteNbImages = 'SELECT COUNT(*) AS nb '. |
'FROM '.$this->schemaBdd.'.del_image '; |
//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']; |
} |
/*------------------------------------------------------------------------------- |
CHARGEMENT DES IMAGES |
--------------------------------------------------------------------------------*/ |
/** |
* Chargement depuis la bdd de toutes les liaisons entre images et observations |
* */ |
private function chargerLiaisons() { |
$requeteLiaisons = 'SELECT * '. |
'FROM '.$this->schemaBdd.'.del_obs_images doi '. |
'INNER JOIN del_image di '. |
'ON doi.ce_image = di.id_image '. |
'INNER JOIN del_observation dob '. |
'ON doi.ce_observation = dob.id_observation '; |
$requeteLiaisons .= $this->chargerClauseWhere(); |
$requeteLiaisons .= $this->getLimite(); |
return $this->getBdd()->recupererTous($requeteLiaisons); |
} |
/** |
* Retourner un tableau d'images formaté en fonction des liaisons trouvées |
* @param $liaisons les liaisons de la table del_obs_images |
* */ |
private function chargerImage($liaisons) { |
$images = array(); |
foreach ($liaisons as $liaison) { |
$idImage = $liaison['ce_image']; |
// On enregistre l'ID de l'auteur pour n'effectuer qu'une seule requête par la suite |
$this->auteursIds[$liaison['ce_utilisateur']] = true; |
// On enregistre l'ID de l'image pour n'effectuer qu'une seule requête par la suite |
$this->imageIds[] = $idImage; |
$images[] = array('id_image' => $idImage, 'date' => $liaison['date_prise_de_vue'], 'binaire.href' => $this->formaterLienImage($idImage), |
'hauteur' => $liaison['hauteur'], 'largeur' => $liaison['largeur'], 'votes' => array(), 'observation' => $this->formaterObservation($liaison)); |
} |
return $images; |
} |
/** |
* Récupère les auteurs utilisés dans la sous-liste, effectue une requête, et met à jour |
* les résultats |
* @param $images le tableau d'images récupéré et mis en forme |
* */ |
private function chargerAuteurs(&$images) { |
if (sizeof($this->auteursIds) > 0) { |
$auteursIds = array_keys($this->auteursIds); |
$chaineAuteursIds = implode(',', $auteursIds); |
$requeteAuteurs = 'SELECT * FROM '.$this->schemaBdd.'.del_utilisateur '. |
'WHERE id_utilisateur IN ('.$chaineAuteursIds.')'; |
$resultatAuteurs = $this->getBdd()->recupererTous($requeteAuteurs); |
$auteurs = array(); |
foreach ($resultatAuteurs as $auteur) { |
$id = $auteur['id_utilisateur']; |
$auteurs[$id]['nom'] = $auteur['nom']; |
$auteurs[$id]['prenom'] = $auteur['prenom']; |
} |
foreach ($images as &$image) { |
$idAuteur = $image['observation']['auteur.id']; |
$image['observation']['auteur.nom'] = $auteurs["$idAuteur"]['nom']; |
$image['observation']['auteur.prenom'] = $auteurs["$idAuteur"]['prenom']; |
} |
} |
} |
/** |
* Charger les votes pour chaque image |
* */ |
private function chargerVotes(&$images) { |
if (sizeof($this->imageIds) > 0) { |
$chaineImageIds = implode(',', $this->imageIds); |
$requeteVotes = 'SELECT * FROM '. |
$this->schemaBdd.'.del_vote_image '. |
'WHERE ce_image IN ('.$chaineImageIds.')'; |
$resultatsVotes = $this->getBdd()->recupererTous($requeteVotes); |
$votes = array(); |
foreach ($resultatsVotes as $vote) { |
$idImage = $vote['ce_image']; |
$id = $vote['id_vote_image']; |
$id_protocole = $vote['ce_protocole']; |
$auteur_id = $vote['ce_utilisateur']; |
$valeur = $vote['valeur_vote']; |
//TODO : voir la définition du webservice ! La date n'est pas présent dans la base |
//$date = $vote['']; |
//TODO : voir la définition du webservice : ne devrait pas être "valeur" ? |
$votes[$idImage]['vote'] = $valeur; |
$votes[$idImage]['protocole'] = $id_protocole; |
$votes[$idImage]['auteur_id'] = $auteur_id; |
} |
foreach ($images as &$image) { |
if (isset($votes[$image['id_image']])) { |
$image['votes'] = $votes[$image['id_image']]; |
} |
} |
} |
} |
/*------------------------------------------------------------------------------- |
FORMATER ET METTRE EN FORME |
--------------------------------------------------------------------------------*/ |
/** |
* Formater une observation depuis une ligne liaison |
* @param $liaison liaison issue de la recherche |
* */ |
private function formaterObservation($liaison) { |
$observation = array(); |
$observation['id_observation'] = $liaison['id_observation']; |
$observation['date_observation'] = $liaison['date_observation']; |
$observation['date_transmission'] = $liaison['date_transmission']; |
$observation['determination.famille'] = $liaison['famille']; |
$observation['determination.ns'] = $liaison['nom_sel']; |
$observation['determination.nn'] = $liaison['nom_sel_nn']; |
$observation['determination.nt'] = $liaison['nt']; |
$observation['id_zone_geo'] = $liaison['ce_zone_geo']; |
$observation['zone_geo'] = $liaison['zone_geo']; |
$observation['lieudit'] = $liaison['lieudit']; |
$observation['station'] = $liaison['station']; |
$observation['milieu'] = $liaison['milieu']; |
$observation['auteur.id'] = $liaison['ce_utilisateur']; |
//$this->chargerAuteur($observation); |
return $observation; |
} |
/** |
* Créer l'entête en fonction des paramètres donnés |
* */ |
private function getEntete() { |
336,17 → 134,16 |
$departSuivant = $departActuel - $limite; |
$url = null; |
if ($departActuel > 0) { |
if ($departSuivant > 0) { |
$parametres = array(); |
if ($this->idImage != null) { |
$parametres['masque.id'] = $this->idImage; |
} |
$url = $this->obtenirUrlNavigation($departSuivant, $limite, $parametres); |
} |
return $url; |
} |
/** |
* Récupérer le lien pour afficher les images suivantes en fonction des paramètres |
* */ |
private function recupererHrefSuivant() { |
$departActuel = $this->depart; |
$limite = $this->limite; |
355,19 → 152,18 |
$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; |
} |
/** |
* Récupérer l'url de navigation en concaténant d'éventuels paramètres |
* @param $depart l'entier de départ de la recherche |
* @param $limite le nombre de résultats à retourner |
* @param $parametresAdditionnels le tableau contenant les parametres => valeurs additionnels |
* */ |
private function obtenirUrlNavigation($depart, $limite, $parametresAdditionnels) { |
$parametres = array('navigation.depart' => $depart, 'navigation.limite' => $limite); |
$parametres = array( |
'navigation.depart' => $depart, |
'navigation.limite' => $limite); |
if ($parametresAdditionnels != null) { |
$parametres = array_merge($parametres, $parametresAdditionnels); |
377,7 → 173,93 |
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) { |
386,6 → 268,40 |
$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 |
/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/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/biliotheque/ResultatService.php |
---|
New file |
0,0 → 1,7 |
<?php |
class ResultatService { |
public $mime = 'application/json'; |
public $encodage = 'utf-8'; |
public $corps = ''; |
} |
?> |
/trunk/services/configurations/config.ini |
---|
File deleted |
\ No newline at end of file |
/trunk/services/configurations/config_del.ini |
---|
3,6 → 3,9 |
; Nom du projet |
nom_projet = "del" |
; Nom de la base utilisée. |
bdd_nom = "del" |
['images'] |
; URL de base des services de ce projet |
url_service="{ref:url_base}del/services/0.1/projets/del/images" |
9,8 → 12,6 |
url_images= "http://www.tela-botanica.org/appli:cel-img:%sXL.jpg"; |
; URL de l'ontologie des bdnt |
url_ontologie="{ref:url_base}service:eflore:0.1/bdnt/ontologies/" |
; Nom de la base utilisée. |
schemaBdd = "del" |
; +------------------------------------------------------------------------------------------------------+ |
; Config spécifique au projet |