Subversion Repositories eFlore/Applications.del

Compare Revisions

No changes between revisions

Ignore whitespace Rev 701 → Rev 702

/trunk/services/biliotheque/ReponseHttp.php
File deleted
\ No newline at end of file
/trunk/services/biliotheque/ResultatService.php
File deleted
\ No newline at end of file
/trunk/services/configurations/config.ini
New file
0,0 → 1,72
; Encodage : UTF-8
 
; +------------------------------------------------------------------------------------------------------+
; URLs
; Le séparateur utilisé par le framework lorsqu'il génère des URL pour séparer les arguments.
; Pour remettre les valeurs par défaut, utitliser : "php:ini_get('arg_separator.output')"
url_arg_separateur_sortie = "&"
 
; +------------------------------------------------------------------------------------------------------+
; Info sur l'application
info.nom = Services d'Identiplante
; Abréviation de l'application
info.abr = del-services
; Version du Framework nécessaire au fonctionnement de cette application
info.framework.version = 0.3
;Encodage de l'application
encodage_appli = "UTF-8"
 
; +------------------------------------------------------------------------------------------------------+
; Débogage
; Indique si oui ou non on veut afficher le débogage.
debogage = true
; Indique sous quelle forme les méssages de débogage doivent s'afficher :
; - "php:Debug::MODE_ECHO" : le message est affiché en utilisant echo
; - "php:Debug::MODE_NOTICE" : le message est affiché en utilisant une erreur de type notice
; - "php:Debug::MODE_ENTETE_HTTP" : les messages sont envoyés dans un entête HTTP "X_REST_DEBOGAGE".
; - "Autre valeur" : les messages sont formatés puis retournés par la méthode de débogage utilisée.
debogage_mode = "php:Debug::MODE_ECHO"
; Indique si oui ou non on veut lancer le chronométrage
chronometrage = false
 
 
; +------------------------------------------------------------------------------------------------------+
; Paramètrage de la base de données.
; Abstraction de la base de données.
bdd_abstraction = pdo
; Protocole de la base de données.
bdd_protocole = mysql
; Nom du serveur de bases de données.
bdd_serveur = localhost
; Nom de l'utilisateur de la base de données.
bdd_utilisateur = "greg"
; Mot de passe de l'utilisateur de la base de données.
bdd_mot_de_passe = "gre85duc"
; Nom de la base de données principale.
bdd_nom = "del"
; Encodage de la base de données principale au format base de données (ex. pour l'utf-8 ne pas mettre le tiret!).
bdd_encodage = "utf8"
 
; +------------------------------------------------------------------------------------------------------+
; Infos sur les services
;chemin direct aux services
serveur.baseURL = /del/services/
;URL à rediriger
serveur.baseAlternativeURL = /service:del:0.1/
 
; Version des service web du projet
service_version = 0.1
; Standard utilisé pour les codes de langue
langue_source = "ISO-639-1";
; Standard utilisé pour les codes de zones géographiques
zone_geo_source = "ISO-3166-1";
 
; URL de base des services
url_base="http://localhost/"
; URL de base des services
url_service_base='{ref:url_base}service:del:0.1/'
 
; +------------------------------------------------------------------------------------------------------+
; Infos sur les projets
; Liste des projets disponibles
projetsDispo = "del"
/trunk/services/configurations/config_del.ini
3,9 → 3,6
; 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"
12,6 → 9,8
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
/trunk/services/bibliotheque/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/bibliotheque/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/bibliotheque/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/bibliotheque/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/bibliotheque/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/Commun.php
File deleted
\ No newline at end of file
/trunk/services/modules/0.1/Outils.php
File deleted
\ No newline at end of file
/trunk/services/modules/0.1/EnteteHttp.php
File deleted
\ No newline at end of file
/trunk/services/modules/0.1/ResultatService.php
File deleted
\ No newline at end of file
/trunk/services/modules/0.1/ReponseHttp.php
File deleted
\ No newline at end of file
/trunk/services/modules/0.1/del/Images.php
1,6 → 1,4
<?php
// VOIR IMAGE RECREATION L 294
 
/*vim: set expandtab tabstop=4 shiftwidth=4: */
// +------------------------------------------------------------------------------------------------------+
// | PHP version 5.1.1 |
25,54 → 23,63
// +------------------------------------------------------------------------------------------------------+
// 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 $
* 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 $
// +------------------------------------------------------------------------------------------------------+
*/
class Images extends Commun {
//Paramètres
private $config;
private $schemaBdd;
private $depart = 0;
private $limite = 1;
private $format = 'json';
private $total;
private $idImage;
private $config;
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();
$this->UrlNavigation = new Url($this->config['url_service']);
// Lancement du service
$liaisons = $this->chargerLiaisons();
$images = $this->chargerImage($liaisons);
$this->chargerAuteurs($images);
$this->chargerVotes($images);
// Mettre en forme le résultat et l'envoyer pour affichage
$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);
$resultat->corps = array('entete' => $this->getEntete(), 'resultats' => $images);
return $resultat;
}
/*-------------------------------------------------------------------------------
CONFIGURATION DU SERVICE
--------------------------------------------------------------------------------*/
/**
* Récupérer l'id de l'image depuis les paramètres
* 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
* */
public function chargerParametres($parametres) {
$this->parametres = $parametres;
85,11 → 92,73
$this->limite = $this->parametres['navigation.limite'];
}
if (isset($this->parametres['masque.id'])) {
$idImage = $this->parametres['masque.id'];
$this->idImage = $idImage;
foreach ($parametres as $id => $parametre) {
if (strpos($id, 'masque.') === 0) {
$champ = substr($id, 7, strlen($id));
$this->masque[$champ] = $parametre;
}
}
}
/**
* 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);
}
/**
96,14 → 165,147
* 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 ';
$requeteNbImages = 'SELECT COUNT(*) AS nb '.
'FROM '.$this->schemaBdd.'.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() {
134,16 → 336,17
$departSuivant = $departActuel - $limite;
$url = null;
if ($departSuivant > 0) {
if ($departActuel > 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;
152,18 → 355,19
$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);
173,93 → 377,7
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) {
268,40 → 386,6
$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