| /tags/v1.0-hydrogene/services/bibliotheque/Masque.php |
|---|
| New file |
| 0,0 → 1,80 |
| <?php |
| /** |
| * Navigation gère les url de navigation en fonction d'un départ et d'une limite |
| * @category php 5.2 |
| * @package del |
| * @author Grégoire Duché <gregoire@tela-botanica.org> |
| * @copyright Copyright (c) 2012, Tela Botanica (accueil@tela-botanica.org) |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version $Id: Bdd.php 403 2012-02-22 14:35:20Z gduche $ |
| */ |
| class Masque { |
| const prefixe = 'masque.'; |
| const masqueGeneral = 'masque'; |
| private $masquesPossibles; |
| private $parametres; |
| private $masque; |
| /** |
| * Constructeur de la classe Masque |
| * @param $masquesPossibles la liste des masques autorisés séparé par des ',' |
| * */ |
| public function __construct($masquesPossibles, $parametres = null) { |
| if ($masquesPossibles != null && trim($masquesPossibles) == '') { |
| $message = 'La liste des masques possibles est obligatoire'; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } |
| $this->masquesPossibles = explode(',', $masquesPossibles); |
| $this->parametres = $parametres; |
| $this->chargerMasque(); |
| } |
| /** |
| * Parcourir le tableau Paramètres pour trouver tous les champs masque |
| */ |
| public function chargerMasque() { |
| if ($this->parametres != null) { |
| foreach ($this->parametres as $id => $parametre) { |
| if (strpos($id, self::prefixe) === 0 || $id == self::masqueGeneral) { |
| if (in_array(str_replace(self::prefixe, '', $id), $this->masquesPossibles)) { |
| $this->masque[$id] = $parametre; |
| } |
| } |
| } |
| } |
| } |
| /** |
| * Retourner les masques sous forme de chaine |
| * @return String la chaine de caractère sous la forme masque=valeur&masque2=valeur*/ |
| public function getChaineMasque() { |
| if (!empty($this->masque)) { |
| $chaine = array(); |
| foreach ($this->masque as $id => $valeur) { |
| $chaine[] = $id.'='.$valeur; |
| } |
| return implode('&', $chaine); |
| } else { |
| return ''; |
| } |
| } |
| /** |
| * Récupérer tout ou partie du masque |
| * @param String $id (optionnel) l'idenfiant du masque |
| * @return une chaine de caractère si l'identifiant est passé en paramètre, un tableau sinon |
| * */ |
| public function getMasque($id = null) { |
| if (isset($id)) { |
| return $this->masque[self::prefixe.$id]; |
| } else { |
| return $this->masque; |
| } |
| } |
| } |
| ?> |
| /tags/v1.0-hydrogene/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; |
| } |
| } |
| } |
| ?> |
| /tags/v1.0-hydrogene/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 |
| /tags/v1.0-hydrogene/services/bibliotheque/Navigation.php |
|---|
| New file |
| 0,0 → 1,131 |
| <?php |
| /** |
| * Navigation gère les url de navigation en fonction d'un départ et d'une limite |
| * @category php 5.2 |
| * @package del |
| * @author Grégoire Duché <gregoire@tela-botanica.org> |
| * @copyright Copyright (c) 2012, Tela Botanica (accueil@tela-botanica.org) |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version $Id: Bdd.php 403 2012-02-22 14:35:20Z gduche $ |
| */ |
| class Navigation { |
| private $parametres; |
| private $urlNavigation; |
| private $total; |
| /** |
| * Constructeur de la classe Navigation |
| * @param Array $parametres (optionnel) la liste des paramètre issus du Conteneur |
| * */ |
| public function __construct($parametres = null) { |
| $this->parametres = $parametres; |
| } |
| /** |
| * Obtenir la valeur courante de départ |
| * */ |
| public function getDepart() { |
| return isset($this->parametres['navigation.depart']) ? $this->parametres['navigation.depart'] : 0; |
| } |
| /** |
| * Obtenir la limite courante |
| * */ |
| public function getLimite() { |
| $limite = 10; |
| if (isset($this->parametres['navigation.limite']) && is_numeric($this->parametres['navigation.limite'])) { |
| $limite = $this->parametres['navigation.limite']; |
| $limite = ($limite < 1000) ? $limite : 1000;// Pour éviter les abus ! |
| } |
| return $limite; |
| } |
| /** |
| * Configurer l'Url de navigation en fonction du fichier de configuration |
| * */ |
| public function chargerUrl() { |
| $this->urlNavigation = new Url(Config::get('url_service')); |
| $this->urlNavigation->setOption(Url::OPTION_ENCODER_VALEURS, true); |
| } |
| /** |
| * Obtenir l'url en fonction d'un départ et d'une limite donnée |
| * @param int $depart l'entier de départ |
| * @param int $limite le nombre d'éléments limite |
| * */ |
| public function getUrl($depart = null, $limite = null) { |
| if ($depart == null && $limite == null) { |
| return $this->urlNavigation; |
| } else { |
| return $this->obtenirUrlNavigation($depart, $limite); |
| } |
| } |
| /** |
| * 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) { |
| $parametres = $this->parametres; |
| $parametres['navigation.depart'] = $depart; |
| $parametres['navigation.limite'] = $limite; |
| $this->urlNavigation->setRequete($parametres); |
| $url = $this->urlNavigation->getURL(); |
| return $url; |
| } |
| /** |
| * Récupérer le lien pour afficher les images précédentes en fonction des paramètres |
| * */ |
| public function recupererHrefPrecedent() { |
| $departActuel = $this->getDepart(); |
| $limite = $this->getLimite(); |
| $departPrecedent = $departActuel - $limite; |
| $url = null; |
| if ($departActuel > 0) { |
| $url = $this->getUrl($departPrecedent, $limite); |
| } |
| return $url; |
| } |
| /** |
| * Récupérer le lien pour afficher les images suivantes en fonction des paramètres |
| * */ |
| public function recupererHrefSuivant() { |
| $departActuel = $this->getDepart(); |
| $limite = $this->getLimite(); |
| $departSuivant = $departActuel + $limite; |
| $url = null; |
| if ($departSuivant < $this->total) { |
| $url = $this->getUrl($departSuivant, $limite); |
| } |
| return $url; |
| } |
| /** |
| * Retourner le nombre total d'éléments |
| * */ |
| public function getTotal() { |
| return $this->total; |
| } |
| /** |
| * Enregistrer le nombre total d'éléments |
| * @param int $total le nombre d'éléments |
| * */ |
| public function setTotal($total) { |
| $this->total = $total; |
| } |
| } |
| ?> |
| /tags/v1.0-hydrogene/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; |
| } |
| } |
| ?> |
| /tags/v1.0-hydrogene/services/bibliotheque/Conteneur.php |
|---|
| New file |
| 0,0 → 1,168 |
| <?php |
| /** |
| * Le conteneur encapsule les classe Masque, Navigation et GestionBdd |
| * Il gère leur instanciation, ainsi que la récupération des paramètres depuis l'url ou |
| * les fichiers de configuration |
| * |
| * @category php 5.2 |
| * @package del |
| * @author Grégoire Duché <gregoire@tela-botanica.org> |
| * @copyright Copyright (c) 2012, Tela Botanica (accueil@tela-botanica.org) |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version $Id: Bdd.php 403 2012-02-22 14:35:20Z gduche $ |
| */ |
| class Conteneur { |
| protected $parametres; |
| protected $navigation; |
| protected $masque; |
| protected $gestionBdd; |
| protected $sansLimite = false; |
| //TODO : initialiser tous les objets dans le conteneur |
| //TODO : créer un tableau de partage |
| /** |
| * Constructeur de la classe |
| * @param Array $parametres (optionnel) les paramètres additionnels à ajouter à ceux des fichiers de config |
| * */ |
| public function __construct(array $parametres = null) { |
| $this->parametres = is_null($parametres) ? array() : $parametres; |
| } |
| /** |
| * Charger la configuration depuis le fichier |
| * @param String $chemin le chemin relatif depuis le dossier configurations du fichier |
| * */ |
| public function chargerConfiguration($chemin) { |
| $cheminConfigurations = Config::get('chemin_configurations'); |
| if ($cheminConfigurations == null || $cheminConfigurations == '') { |
| $message = 'Le chemin vers le répertoire Configurations n\'est pas renseigné'; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } |
| Config::charger($cheminConfigurations.DS.$chemin); |
| if ($this->masque = $this->creerMasque()) { |
| $this->masque->chargerMasque(); |
| } else { |
| $message = 'Erreur lors de la création du Masque'; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } |
| if ($this->navigation = $this->creerNavigation()) { |
| $this->navigation->chargerUrl(); |
| } else { |
| $message = 'Erreur lors de la création de la Navigation'; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } |
| $this->creerGestionBdd($this->navigation, Config::get('schemaBdd')); |
| } |
| /** |
| * Créer l'objet Masque en fonction des configurations |
| * */ |
| private function creerMasque() { |
| $this->masque = new Masque(Config::get('masques_possibles'), $this->parametres); |
| return $this->masque; |
| } |
| /** |
| * Créer l'objet navigation avec les paramètres |
| * */ |
| private function creerNavigation() { |
| return ($this->navigation = new Navigation($this->parametres)); |
| } |
| /** |
| * Créer l'objet Gestion BDD |
| * */ |
| private function creerGestionBdd($navigation, $schemaBdd) { |
| $this->gestionBdd = new GestionBdd($navigation, $schemaBdd); |
| } |
| /** |
| * Récupérer l'objet GestionBdd |
| * */ |
| public function getGestionBdd() { |
| return $this->gestionBdd; |
| } |
| /** |
| * Récupérer l'objet Navigation |
| * */ |
| public function getNavigation() { |
| return $this->navigation; |
| } |
| /** |
| * Changer la valeur de sans limite pour ne pas l'afficher dans l'entete |
| * */ |
| public function setSansLimite() { |
| $this->sansLimite = true; |
| } |
| /** |
| * Créer l'entête en fonction des paramètres donnés |
| * */ |
| public function getEntete() { |
| $entete = array(); |
| $entete['masque'] = $this->masque->getChaineMasque(); |
| $entete['total'] = $this->navigation->getTotal(); |
| if ($this->sansLimite == false) { |
| $entete['depart'] = $this->navigation->getDepart(); |
| $entete['limite'] = $this->navigation->getLimite(); |
| $lienPrecedent = $this->navigation->recupererHrefPrecedent(); |
| if ($lienPrecedent != null) { |
| $entete['href.precedent'] = $lienPrecedent; |
| } |
| $lienSuivant = $this->navigation->recupererHrefSuivant(); |
| if ($lienSuivant) { |
| $entete['href.suivant'] = $lienSuivant; |
| } |
| } |
| return $entete; |
| } |
| public function getRestClient() { |
| if (!isset($this->restClient)) { |
| $this->restClient = new RestClient(); |
| } |
| return $this->restClient; |
| } |
| /** |
| * Récupérer l'objet Masque |
| * */ |
| public function getMasque() { |
| return $this->masque; |
| } |
| /** |
| * Obtenir un paramètre depuis le tableau de paramètres ou depuis le fichier de config |
| * @param String $cle le nom du paramètre |
| * @return la valeur du paramètre |
| * */ |
| public function getParametre($cle) { |
| $valeur = isset($this->parametres[$cle]) ? $this->parametres[$cle] : Config::get($cle); |
| return $valeur; |
| } |
| /** |
| * Enregistrer la valeur d'un paramètre |
| * */ |
| public function setParametre($cle, $valeur) { |
| $this->parametres[$cle] = $valeur; |
| } |
| } |
| ?> |
| /tags/v1.0-hydrogene/services/bibliotheque/GestionBdd.php |
|---|
| New file |
| 0,0 → 1,91 |
| <?php |
| /** |
| * Gestion BDD permet l'appel à l'objet BDD du framework, |
| * gère les noms de table en fonction du schéma de la table |
| * ainsi que la limite SQL en fonction de l'objet Navigation |
| * @category php 5.2 |
| * @package del |
| * @author Grégoire Duché <gregoire@tela-botanica.org> |
| * @copyright Copyright (c) 2012, Tela Botanica (accueil@tela-botanica.org) |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version $Id: Bdd.php 403 2012-02-22 14:35:20Z gduche $ |
| */ |
| class GestionBdd { |
| private $bdd; |
| private $schemaBdd; |
| private $navigation; |
| /** |
| * Constructeur de la classe GestionBdd |
| * @param Navigation $navigation l'objet navigation issu du Conteneur, et contenant les informations de départ et limite |
| * @param String $schemaBdd (optionnel) le schéma de la base issu du fichier de config |
| * @param Bdd $bdd (optionnel) un objet Bdd pour la connection à la base de données |
| * */ |
| public function __construct($navigation, $schemaBdd = null, $bdd = null) { |
| if ($navigation == null) { |
| $message = 'L\'objet Navigation est nécessaire pour configurer l\'objet GestionBdd'; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } else { |
| $this->navigation = $navigation; |
| $this->schemaBdd = $schemaBdd; |
| if ($bdd == null) { |
| $this->bdd = new Bdd(); |
| } else { |
| $this->bdd = $bdd; |
| } |
| } |
| } |
| /** |
| * Créer la chaine de limite de requête en fonction des paramètres donnés |
| * */ |
| public function getLimitSql() { |
| return ' LIMIT '.$this->navigation->getDepart().', '.$this->navigation->getLimite(); |
| } |
| /** |
| * Récupérer l'objet Bdd ou le créer s'il n'existe pas |
| * @return Bdd l'objet Bdd |
| * */ |
| public function getBdd() { |
| if (!isset($this->bdd)){ |
| $this->bdd = new Bdd(); |
| } |
| return $this->bdd; |
| } |
| /** Formater un nom de table avec le schéma de la base de données, s'il existe |
| * @param String $table le nom de la table |
| * @param String $as (optionnel) l'alias de la table |
| * @return String la chaine de caractère sous la forme "schema.nomtable as nt" |
| * */ |
| public function formaterTable($table, $as = null) { |
| $chaineTable = $table; |
| if ($this->schemaBdd != null) { |
| $chaineTable = $this->schemaBdd.'.'.$table; |
| } |
| if ($as != null && $as != '') { |
| $chaineTable .= ' as '.$as; |
| } |
| return $chaineTable.' '; |
| } |
| /** Formater des noms de table avec le schéma de la base de données, s'il existe |
| * @param Array $tables un tableau à deux dimensions contenant le nom et l'alias de la table |
| * Ex : Array("nom" => "as", "table" => "") |
| * @return String la chaine de caractère sous la forme "schema.nomtable as nt, schema.nomtable2 as nt2" |
| * */ |
| public function formaterTables($tables) { |
| $tablesFormatees = array(); |
| foreach ($tables as $nom => $as) { |
| $tablesFormatees[] = $this->formaterTable($nom, $as); |
| } |
| return implode(',', $tablesFormatees); |
| } |
| } |
| ?> |
| /tags/v1.0-hydrogene/services/bibliotheque/gestionUtilisateur.php |
|---|
| New file |
| 0,0 → 1,88 |
| <?php |
| class gestionUtilisateur { |
| private $conteneur; |
| private $gestionBdd; |
| private $bdd; |
| public function __construct(Conteneur $conteneur = null) { |
| $this->conteneur = $conteneur == null ? new Conteneur() : $conteneur; |
| $this->conteneur->chargerConfiguration('config_utilisateurs.ini'); |
| $this->gestionBdd = $conteneur->getGestionBdd(); |
| $this->bdd = $this->gestionBdd->getBdd(); |
| $this->demarrerSession(); |
| } |
| private function demarrerSession() { |
| if(session_id() == '') { |
| // modifier ce test lors du passage en php 5.4 |
| session_start(); |
| } |
| } |
| protected function getUtilisateurAnonyme() { |
| return array('connecte' => false, |
| 'id_utilisateur' => session_id(), |
| 'courriel' => '', |
| 'mot_de_passe' => '', |
| 'nom' => '', |
| 'prenom' => '', |
| 'session_id' => session_id() |
| ); |
| } |
| protected function utilisateurEstIdentifie() { |
| $utilisateur = null; |
| $utilisateur = $this->utilisateurEstIdentifieCookie(); |
| if ($utilisateur != null) { |
| $utilisateur['session_id'] = session_id(); |
| } |
| return $utilisateur; |
| } |
| protected function utilisateurEstIdentifieCookie() { |
| $retour = null; |
| if(isset($_COOKIE["del_courriel"]) && isset($_COOKIE["del_mot_de_passe"])) { |
| $retour = $this->identifierUtilisateurSansEncryptionMotDePasse($_COOKIE["del_courriel"], $_COOKIE["del_mot_de_passe"]); |
| } |
| return $retour; |
| } |
| protected function identifierUtilisateur($login, $motDePasse) { |
| $requete = 'SELECT id_utilisateur, nom, prenom, courriel, mot_de_passe FROM '.$this->gestionBdd->formaterTable('del_utilisateur', 'du'). |
| 'WHERE courriel = '.$this->bdd->proteger($login).' '. |
| 'AND mot_de_passe = MD5('.$this->bdd->proteger($motDePasse).')'; |
| $utilisateur = $this->bdd->recupererTous($requete); |
| return $utilisateur; |
| } |
| protected function identifierUtilisateurSansEncryptionMotDePasse($login, $mot_de_passe) { |
| $requete = 'SELECT id_utilisateur, nom, prenom, courriel, mot_de_passe FROM '.$this->gestionBdd->formaterTable('del_utilisateur', 'du'). |
| 'WHERE courriel = '.$this->bdd->proteger($login).' '. |
| 'AND mot_de_passe = '.$this->bdd->proteger($mot_de_passe); |
| $utilisateur = $this->bdd->recuperer($requete); |
| return $utilisateur; |
| } |
| protected function setUtilisateur($utilisateur) { |
| $utilisateur['session_id'] = session_id(); |
| $utilisateur['connecte'] = true; |
| $this->setPersistentCookie("del_courriel", $utilisateur['courriel'], 1); |
| $this->setPersistentCookie("del_mot_de_passe", $utilisateur['mot_de_passe'], 1); |
| return $utilisateur; |
| } |
| protected function setPersistentCookie($name, $value, $remember = 1) { |
| setcookie($name, $value, time() + ($remember ? (60*60*24*100) : (60*60)),'/'); |
| } |
| protected function oublierUtilisateur() { |
| setcookie("del_courriel", $_COOKIE['del_courriel'], time()-3600, '/'); |
| setcookie("del_mot_de_passe", $_COOKIE['del_mot_de_passe'], time()-3600, '/'); |
| unset($_COOKIE['del_courriel']); |
| unset($_COOKIE['del_mot_de_passe']); |
| } |
| } |
| ?> |
| /tags/v1.0-hydrogene/services/bibliotheque/ControleAcces.php |
|---|
| New file |
| 0,0 → 1,143 |
| <?php |
| /** |
| * Classe de controle d'accès utilisant l'authentification http pour bloquer ou autoriser l'accès. |
| * Elle offre des méthodes permettant de réserver l'accès à une section aux admins ou bien aux utilisateurs identifiés |
| * |
| * @category php 5.2 |
| * @package del |
| * @author Aurélien Peronnet <aurelien@tela-botanica.org> |
| * @copyright Copyright (c) 2012, Tela Botanica (accueil@tela-botanica.org) |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version $Id$ |
| */ |
| class ControleAcces { |
| private $conteneur; |
| private $gestionBdd; |
| private $bdd; |
| public function __construct($conteneur) { |
| $this->conteneur = $conteneur; |
| $this->gestionBdd = $conteneur->getGestionBdd(); |
| $this->bdd = $this->gestionBdd->getBdd(); |
| } |
| public function demanderAuthentificationAdmin() { |
| if(!$this->etreAdminAutorise()) { |
| $this->authentifierAdmin(); |
| } |
| } |
| public function demanderAuthentificationUtilisateur() { |
| if(!$this->etreUtilisateurAutorise()) { |
| $this->authentifierUtilisateur(); |
| } |
| } |
| public function etreUtilisateurAutorise() { |
| $identifiant = $this->getAuthIdentifiant(); |
| $mdp = $this->getAuthMotDePasse(); |
| $existe = $this->obtenirUtilisateur($identifiant, $mdp); |
| $autorisation = (isset($existe) && $existe) ? true :false; |
| return $autorisation; |
| } |
| private function obtenirUtilisateur($login, $motDePasse) { |
| $requete = 'SELECT id_utilisateur, nom, prenom, courriel, mot_de_passe FROM '.$this->gestionBdd->formaterTable('del_utilisateur', 'du'). |
| 'WHERE courriel = '.$this->gestionBdd->getBdd()->proteger($login).' '. |
| 'AND mot_de_passe = MD5('.$this->gestionBdd->getBdd()->proteger($motDePasse).')'; |
| $utilisateur = $this->gestionBdd->getBdd()->recuperer($requete . ' -- ' . __FILE__ . ':' . __LINE__); |
| return $utilisateur; |
| } |
| private function obtenirUtilisateurSansEncryptionMdp($login, $motDePasseEncrypte) { |
| $requete = 'SELECT id_utilisateur, nom, prenom, courriel, mot_de_passe FROM '.$this->gestionBdd->formaterTable('del_utilisateur', 'du'). |
| 'WHERE courriel = '.$this->gestionBdd->getBdd()->proteger($login).' '. |
| 'AND mot_de_passe = '.$this->gestionBdd->getBdd()->proteger($motDePasseEncrypte).' '; |
| $utilisateur = $this->gestionBdd->getBdd()->recuperer($requete . ' -- ' . __FILE__ . ':' . __LINE__); |
| return $utilisateur; |
| } |
| public function etreAdminAutorise() { |
| $identifiant = $this->getAuthIdentifiant(); |
| $autorisation = ($this->etreAdminDel($identifiant) && $this->etreUtilisateurAutorise()) ? true : false; |
| return $autorisation; |
| } |
| public function etreAdminDel($courriel) { |
| $admins = Config::get('admins'); |
| $courriels_autorises = explode(',', $admins); |
| $autorisation = (in_array($courriel, $courriels_autorises)) ? true : false ; |
| return $autorisation; |
| } |
| private function getAuthIdentifiant() { |
| $id = (isset($_SERVER['PHP_AUTH_USER'])) ? $_SERVER['PHP_AUTH_USER'] : null; |
| return $id; |
| } |
| private function getAuthMotDePasse() { |
| $mdp = (isset($_SERVER['PHP_AUTH_PW'])) ? $_SERVER['PHP_AUTH_PW'] : null; |
| return $mdp; |
| } |
| //TODO: externaliser noms et adresses spécifiques à Tela Botanica |
| private function authentifierAdmin() { |
| $message_accueil = "Veuillez vous identifier avec votre compte administrateur Tela Botanica."; |
| $message_echec = "Accès limité aux administrateurs de DEL.\n". |
| "Votre tentative d'identification a échoué.\n". |
| "Actualiser la page pour essayer à nouveau si vous êtes bien inscrit comme administrateur."; |
| return $this->authentifier($message_accueil, $message_echec, 'Admin'); |
| } |
| private function authentifierUtilisateur() { |
| $message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica."; |
| $message_echec = "Accès limité aux utilisateurs de DEL.\n". |
| "Inscrivez vous http://www.tela-botanica.org/page:inscription pour le devenir.\n". |
| "Votre tentative d'identification a échoué.\n". |
| "Actualiser la page pour essayer à nouveau si vous êtes déjà inscrit ou contacter 'accueil@tela-botanica.org'."; |
| return $this->authentifier($message_accueil, $message_echec, 'Utilisateur'); |
| } |
| private function authentifier($message_accueil, $message_echec, $type) { |
| $id = $this->getAuthIdentifiant(); |
| if (!isset($id)) { |
| $this->envoyerAuth($message_accueil, $message_echec); |
| } else { |
| if ($type == 'Utilisateur' && $this->getAuthMotDePasse() == 'debug') { |
| $autorisation = true; |
| } else { |
| $methodeAutorisation = "etre{$type}Autorise"; |
| $autorisation = $this->$methodeAutorisation(); |
| } |
| if ($autorisation == false) { |
| $this->envoyerAuth($message_accueil, $message_echec); |
| } |
| } |
| return true; |
| } |
| public function getInfosUtilisateurConnecte() { |
| if(isset($_COOKIE["del_courriel"])) { |
| $utilisateur = array('del_courriel' => $_COOKIE["del_courriel"], |
| 'del_mot_de_passe' => $_COOKIE["del_mot_de_passe"]); |
| $utilisateur = $this->obtenirUtilisateurSansEncryptionMdp($utilisateur['del_courriel'], $utilisateur['del_mot_de_passe']); |
| } |
| return $utilisateur; |
| } |
| public function getIdAnonymeTemporaire() { |
| $this->demarrerSession(); |
| return session_id(); |
| } |
| private function demarrerSession() { |
| if(session_id() == '') { |
| // modifier ce test lors du passage en php 5.4 |
| session_start(); |
| } |
| } |
| } |
| /tags/v1.0-hydrogene/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'; |
| } |
| ?> |
| /tags/v1.0-hydrogene/services/bibliotheque/ResultatService.php |
|---|
| New file |
| 0,0 → 1,7 |
| <?php |
| class ResultatService { |
| public $mime = 'application/json'; |
| public $encodage = 'utf-8'; |
| public $corps = ''; |
| } |
| ?> |