| /trunk/applications/jrest/services/OdsEvenement.php |
|---|
| New file |
| 0,0 → 1,131 |
| <?php |
| class OdsEvenement extends JRestService { |
| const PREFIXE = 'get'; |
| /** |
| * Méthode appelée avec une requête de type GET. |
| * |
| */ |
| function getElement($param = array()) { |
| $type = $param[0]; |
| if ($type == '*' || is_numeric($type)) { |
| $info = $this->getElementParDefaut($param); |
| } else { |
| $methode = self::PREFIXE.$type; |
| if (method_exists($this, $methode)) { |
| array_shift($param); |
| $info = $this->$methode($param); |
| } else { |
| $this->messages[] = "Le type d'information demandé '$type' n'est pas disponible."; |
| } |
| } |
| // Envoi sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| $this->envoyer((string) $id_personne); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| //Mise à jour de la personne |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| } catch (PDOException $e) { |
| $messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un élément |
| */ |
| public function deleteElement($uid) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant d'utilisateur ou de personne manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des id passés par l'url |
| $identifiants = explode(',', rtrim($uid[1], ',')); |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| foreach ($identifiants as $id_personne) { |
| try { |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| private function getElementParDefaut($param) { |
| } |
| private function getEvenementsPourEspece($id_espece) { |
| return array( |
| '1' => array( |
| 'id' => '1', |
| 'nom' => 'feuillaison', |
| 'stades' => array('6','12') |
| ), |
| '2' => array( |
| 'id' => '2', |
| 'nom' => 'floraison', |
| 'stades' => array('22','33') |
| ), |
| '3' => array( |
| 'id' => '3', |
| 'nom' => 'fructification', |
| 'stades' => array('85') |
| ), |
| '4' => array( |
| 'id' => '4', |
| 'nom' => 'senescence', |
| 'stades' => array('90','95') |
| ) |
| ); |
| } |
| } |
| ?> |
| /trunk/applications/jrest/services/OdsIndividu.php |
|---|
| New file |
| 0,0 → 1,147 |
| <?php |
| class OdsIndividu extends JRestService { |
| /** |
| * Méthode appelée avec une requête de type GET. |
| * |
| */ |
| function getElement($param = array()) { |
| $donnees_test = $this->retournerDonneesTest(); |
| if($param[0] == "*") { |
| $info = $donnees_test; |
| } else if(is_numeric($param[0])) { |
| $info = $donnees_test[$param[0]]; |
| } |
| // Envoi sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| $this->envoyer((string) $id_personne); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| //Mise à jour de la personne |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| } catch (PDOException $e) { |
| $messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un élément |
| */ |
| public function deleteElement($uid) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant d'utilisateur ou de personne manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des id passés par l'url |
| $identifiants = explode(',', rtrim($uid[1], ',')); |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| foreach ($identifiants as $id_personne) { |
| try { |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| private function retournerDonneesTest() { |
| return array( |
| '1' => |
| array( |
| 'id' => '1', |
| 'nom' => 'Individu 1', |
| 'nom_scientifique' => 'Acer monspessulanum', |
| 'nom_vernaculaire' => 'Erable de Montpellier', |
| 'description' => 'Quel bel individu!' |
| ), |
| '2' => |
| array( |
| 'id' => '2', |
| 'nom' => 'Individu 2', |
| 'nom_scientifique' => 'Acer monspessulanum', |
| 'nom_vernaculaire' => 'Erable de Montpellier', |
| 'description' => 'Quel bel individu!' |
| ), |
| '3' => |
| array( |
| 'id' => '3', |
| 'nom' => 'Individu 3', |
| 'nom_scientifique' => 'Acer monspessulanum', |
| 'nom_vernaculaire' => 'Erable de Montpellier', |
| 'description' => 'Quel bel individu!' |
| ), |
| '4' => |
| array( |
| 'id' => '4', |
| 'nom' => 'Individu 4', |
| 'nom_scientifique' => 'Acer monspessulanum', |
| 'nom_vernaculaire' => 'Erable de Montpellier', |
| 'description' => 'Quel bel individu!' |
| ), |
| '5' => |
| array( |
| 'id' => '5', |
| 'nom' => 'Individu 5', |
| 'nom_scientifique' => 'Acer monspessulanum', |
| 'nom_vernaculaire' => 'Erable de Montpellier', |
| 'description' => 'Quel bel individu!' |
| ), |
| '6' => |
| array( |
| 'id' => '6', |
| 'nom' => 'Individu 6', |
| 'nom_scientifique' => 'Acer monspessulanum', |
| 'nom_vernaculaire' => 'Erable de Montpellier', |
| 'description' => 'Quel bel individu!' |
| ) |
| ); |
| } |
| } |
| ?> |
| /trunk/applications/jrest/services/OdsObservation.php |
|---|
| New file |
| 0,0 → 1,130 |
| <?php |
| class OdsObservation extends JRestService { |
| const PREFIXE = 'get'; |
| /** |
| * Méthode appelée avec une requête de type GET. |
| * |
| */ |
| function getElement($param = array()) { |
| $type = $param[0]; |
| if ($type == '*' || is_numeric($type)) { |
| $info = $this->getElementParDefaut($param); |
| } else { |
| $methode = self::PREFIXE.$type; |
| if (method_exists($this, $methode)) { |
| array_shift($param); |
| $info = $this->$methode($param); |
| } else { |
| $this->messages[] = "Le type d'information demandé '$type' n'est pas disponible."; |
| } |
| } |
| // Envoi sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| $this->envoyer((string) $id_personne); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| //Mise à jour de la personne |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| } catch (PDOException $e) { |
| $messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un élément |
| */ |
| public function deleteElement($uid) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant d'utilisateur ou de personne manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des id passés par l'url |
| $identifiants = explode(',', rtrim($uid[1], ',')); |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| foreach ($identifiants as $id_personne) { |
| try { |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| private function getElementParDefaut($params) { |
| } |
| private function getObservationsPourStation($params) { |
| $id_station = $param[0]; |
| $annee = $param[1]; |
| return ; |
| } |
| private function getObservationsPourIndividu($params) { |
| $id_individu = $param[0]; |
| $annee = $param[1]; |
| return array( |
| '1' => '01/01/2010', |
| '2' => '13/01/2010', |
| '3' => '06/02/2010', |
| '4' => '08/05/2010', |
| '5' => '09/07/2010', |
| '6' => '08/08/2010', |
| '7' => '25/10/2010', |
| ); |
| } |
| } |
| ?> |
| /trunk/applications/jrest/services/OdsStation.php |
|---|
| New file |
| 0,0 → 1,226 |
| <?php |
| class OdsStation extends GestionTriple { |
| /** |
| * Méthode appelée avec une requête de type GET. |
| * |
| */ |
| function getElement($param = array()) { |
| if(isset($param[0])) { |
| $id_participant = $param[0]; |
| } else { |
| return; |
| } |
| if($param[1] == "*") { |
| $info = $this->obtenirListeStationPourParticipant($id_participant); |
| } else if(is_numeric($param[1])) { |
| $id_station = $param[1]; |
| $info = $this->obtenirInformationsStation($id_station); |
| } |
| // Envoi sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| $elements_requis = array('id_participant','station_nom', 'station_commune', 'station_lat', 'station_lon','station_milieu'); |
| $erreurs = array(); |
| foreach($elements_requis as $requis) { |
| if(!isset($params[$requis])) { |
| //$erreurs[$requis] = 'erreur '; |
| } |
| } |
| if(!empty($erreurs)) { |
| $this->envoyer($erreurs); |
| } |
| $station['alt'] = '0'; |
| $id_participant = $params['id_participant']; |
| $requete_creation_station = 'INSERT INTO ods_stations '. |
| '(os_ce_participant, os_nom, os_ce_commune, os_latitude, os_longitude, os_altitude, os_ce_environnement, os_commentaire) '. |
| 'VALUES ('. |
| $this->bdd->quote($id_participant).','. |
| $this->bdd->quote($params['station_nom']).','. |
| $this->bdd->quote($params['station_commune']).','. |
| $this->bdd->quote($params['station_lat']).','. |
| $this->bdd->quote($params['station_lon']).','. |
| $this->bdd->quote($params['station_alt']).','. |
| $this->bdd->quote($params['station_milieu']).','. |
| $this->bdd->quote($params['station_description']).')'; |
| $creation_station = $this->executerRequeteSimple($requete_creation_station); |
| if(!$creation_station) { |
| // TODO: comment gère t'on les erreurs ? |
| } |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| if(!isset($uid[0])) { |
| $id_participant = $uid[0]; |
| } else { |
| return; |
| } |
| if(!isset($uid[1])) { |
| $id_station = $uid[1]; |
| } else { |
| return; |
| } |
| $requete_modification_station = 'UPDATE ods_stations '. |
| 'SET '. |
| 'os_nom ='.$this->bdd->quote($params['station_nom']).','. |
| 'os_latitude ='.$this->bdd->quote($params['station_commune']).','. |
| 'os_latitude ='.$this->bdd->quote($params['station_lat']).','. |
| 'os_longitude ='.$this->bdd->quote($params['station_lon']).','. |
| 'os_altitude ='.$this->bdd->quote($params['station_alt']).','. |
| 'os_ce_environnement ='.$this->bdd->quote($params['station_milieu']).','. |
| 'os_commentaire ='.$this->bdd->quote($params['station_description']).' '. |
| 'WHERE os_ce_particant = '.$this->bdd->quote($id_participant).' '. |
| 'AND os_id_station = '.$this->bdd->quote($id_station); |
| $modification_station = $this->executerRequeteSimple($requete_creation_station); |
| if(!$modification_station) { |
| // TODO: comment gère t'on les erreurs ? |
| } |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un élément |
| */ |
| public function deleteElement($uid) { |
| // Pour le moment, pas de suppression des stations |
| return ; |
| if(!isset($uid[0])) { |
| $id_participant = $uid[0]; |
| } else { |
| return; |
| } |
| if(!isset($uid[1])) { |
| $id_station = $uid[1]; |
| } else { |
| return; |
| } |
| $requete_suppression_station = 'DELETE FROM ods_stations '. |
| 'WHERE os_ce_particant = '.$this->bdd->quote($id_participant).' '. |
| 'AND os_id_station = '.$this->bdd->quote($id_station); |
| // TODO : supprimer également tout ce qui est associé à la station (observations, etc...) |
| $suppression_station = $this->executerRequeteSimple($requete_suppression_station); |
| if(!$suppression_station) { |
| // TODO: comment gère t'on les erreurs ? |
| } |
| $this->envoyer(); |
| } |
| // +---------------------------------------------------------------------------------------------------------------+ |
| // METHODES D'ACCES A LA BASE DE DONNEES |
| private function obtenirListeStationPourParticipant($id_participant) { |
| $requete_liste_station = 'SELECT * FROM ods_stations WHERE os_ce_participant = '.$this->bdd->quote($id_participant); |
| $liste_station = $this->executerRequete($requete_liste_station); |
| $liste_station_formatees = array(); |
| foreach($liste_station as $indice => $station) { |
| $station_champs_formates = $this->formaterChampsStationPourEnvoi($station); |
| $liste_station_formatees[$station['os_id_station']] = $station_champs_formates; |
| } |
| return $liste_station_formatees; |
| } |
| private function obtenirInformationsStation($id_station) { |
| $requete_infos_station = 'SELECT * FROM ods_stations WHERE os_id_station = '.$this->bdd->quote($id_station); |
| $infos_station = $this->executerRequete($requete_infos_station); |
| $infos_station_formatees = array(); |
| if(!empty($infos_station)) { |
| $infos_station = $infos_station[0]; |
| $infos_station_formatees = $this->formaterChampsStationPourEnvoi($infos_station); |
| } |
| return $infos_station_formatees; |
| } |
| private function formaterChampsStationPourEnvoi($station) { |
| $station_champs_formates = array( |
| 'id' => $station['os_id_station'], |
| 'nom' => $station['os_nom'], |
| 'id_commune' => $station['os_ce_commune'], |
| 'commune' => 'Montpellier',//$this->obtenirInformationsCommuneParCodeInsee($station['os_ce_commune']), |
| 'milieu' => 'Urbain',//$this->obtenirInformationsMilieuParAbreviation($station['os_milieu']), |
| 'latitude' => $station['os_latitude'], |
| 'longitude' => $station['os_longitude'], |
| 'altitude' => $station['os_altitude'], |
| 'description' => $station['os_commentaire'] |
| ); |
| return $station_champs_formates; |
| } |
| private function obtenirInformationsCommuneParId($id_commune) { |
| $requete_infos_commune = 'SELECT * FROM ods_communes WHERE oc_id_commune = '.$this->bdd->quote($id_commune); |
| $infos_commune = $this->executerRequete($requete_infos_commune); |
| return $infos_commune; |
| } |
| private function obtenirInformationsCommuneParCodeInsee($code_insee_commune) { |
| $requete_infos_commune = 'SELECT * FROM ods_communes WHERE oc_code_insee = '.$this->bdd->quote($code_insee_commune); |
| $infos_commune = $this->executerRequete($requete_infos_commune); |
| return $infos_commune; |
| } |
| private function obtenirInformationsMilieuParAbreviation($abreviation_milieu) { |
| $informations_milieu = $this->obtenirValeurTripleParAbreviation($abreviation_milieu); |
| return $informations_milieu; |
| } |
| } |
| ?> |
| /trunk/applications/jrest/services/GestionTriple.php |
|---|
| New file |
| 0,0 → 1,43 |
| <?php |
| class GestionTriple extends JRestService { |
| protected function obtenirValeursListeParId($id_liste) { |
| $requete = 'SELECT * FROM ods_triple WHERE ot_ce_parent ='.$this->proteger($id_liste); |
| $resultat = $this->executerRequete($requete); |
| return $resultat; |
| } |
| protected function obtenirValeursListeParAbreviation($abreviation_triple) { |
| $requete = 'SELECT * FROM ods_triple WHERE ot_ce_parent = (SELECT ot_id_triple WHERE ot_cle ='.$this->proteger($abreviation_triple).')'; |
| $resultat = $this->executerRequete($requete); |
| return $resultat; |
| } |
| protected function obtenirValeurTripleParId($id_triple) { |
| $requete = 'SELECT * FROM ods_triple WHERE ot_id_triple = '.$this->proteger($id_triple); |
| $resultat = $this->executerRequete($requete); |
| return $resultat['ot_valeur']; |
| } |
| protected function obtenirValeurTripleParAbreviation($abreviation_triple) { |
| $requete = 'SELECT * FROM ods_triple WHERE ot_cle = '.$this->proteger($abreviation_triple); |
| $resultat = $this->executerRequete($requete); |
| return $resultat['ot_valeur']; |
| } |
| } |
| ?> |
| /trunk/applications/jrest/services/JRestService.php |
|---|
| New file |
| 0,0 → 1,311 |
| <?php |
| /** |
| * Classe mère abstraite contenant les méthodes génériques des services. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| abstract class JRestService { |
| public $config; |
| protected $bdd; |
| protected $log = array(); |
| protected $messages = array(); |
| protected $debug = array(); |
| protected $distinct = false; |
| protected $orderby = null; |
| protected $formatRetour = 'objet'; |
| protected $start = 0; |
| protected $limit = 150; |
| public function __construct($config, $demarrer_session = true) { |
| // Tableau contenant la config de Jrest |
| $this->config = $config; |
| // Connection à la base de données |
| $this->bdd = $this->connecterPDO($this->config, 'appli'); |
| // Nettoyage du $_GET (sécurité) |
| if (isset($_GET)) { |
| $get_params = array('orderby', 'distinct', 'start', 'limit', 'formatRetour'); |
| foreach ($get_params as $get) { |
| $verifier = array('NULL', "\n", "\r", "\\", "'", '"', "\x00", "\x1a", ';'); |
| $_GET[$get] = str_replace($verifier, '', $_GET[$get]); |
| if (isset($_GET[$get]) && $_GET[$get] != '') { |
| $this->$get = $_GET[$get]; |
| } else { |
| $_GET[$get] = null; |
| } |
| } |
| } |
| } |
| /** |
| * Méthode appelée quand aucun paramètre n'est passé dans l'url et avec une requête de type GET. |
| */ |
| public function getRessource() { |
| $this->getElement(array()); |
| } |
| protected function envoyer($donnees = null, $mime = 'text/html', $encodage = 'utf-8', $json = true) { |
| // Traitements des messages d'erreurs et données |
| if (count($this->messages) != 0) { |
| header('HTTP/1.1 500 Internal Server Error'); |
| $mime = 'text/html'; |
| $encodage = 'utf-8'; |
| $json = true; |
| $sortie = $this->messages; |
| } else { |
| $sortie = $donnees; |
| if (is_null($donnees)) { |
| $sortie = 'OK'; |
| } |
| } |
| // Gestion de l'envoie du déboguage |
| $this->envoyerDebogage(); |
| // Encodage au format et JSON et envoie sur la sortie standard |
| $contenu = $json ? json_encode($sortie) : $sortie; |
| $this->envoyerContenu($encodage, $mime, $contenu); |
| } |
| protected function envoyerDebogage() { |
| if (!is_array($this->debug)) { |
| $this->debug[] = $this->debug; |
| } |
| if (count($this->debug) != 0) { |
| foreach ($this->debug as $cle => $val) { |
| if (is_array($val)) { |
| $this->debug[$cle] = print_r($val, true); |
| } |
| } |
| header('X-DebugJrest-Data:'.json_encode($this->debug)); |
| } |
| } |
| protected function envoyerContenu($encodage, $mime, $contenu) { |
| header("Content-Type: $mime; charset=$encodage"); |
| print $contenu; |
| } |
| private function connecterPDO($config, $base = 'database') { |
| $cfg = $config[$base]; |
| $dsn = $cfg['phptype'].':dbname='.$cfg['database'].';host='.$cfg['hostspec']; |
| try { |
| $PDO = new PDO($dsn, $cfg['username'], $cfg['password']); |
| } catch (PDOException $e) { |
| echo 'La connexion à la base de donnée via PDO a échouée : ' . $e->getMessage(); |
| } |
| // Passe en UTF-8 la connexion à la BDD |
| $PDO->exec("SET NAMES 'utf8'"); |
| // Affiche les erreurs détectées par PDO (sinon mode silencieux => aucune erreur affiché) |
| $PDO->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); |
| return $PDO; |
| } |
| protected function executerRequete($requete, $retour = 'All', $mode = PDO::FETCH_ASSOC) { |
| try { |
| switch ($retour) { |
| case 'All' : |
| $resultat = $this->bdd->query($requete)->fetchAll($mode); |
| break; |
| case 'Column' : |
| $resultat = $this->bdd->query($requete)->fetchColumn(); |
| break; |
| default: |
| $resultat = false; |
| $this->messages[] = "Le type de retour '$retour' est inconnu."; |
| } |
| if ($resultat === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur_requete'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| return $resultat; |
| } |
| protected function executerRequeteSimple($requete) { |
| try { |
| $resultat = false; |
| $resultat = $this->bdd->query($requete); |
| if ($resultat === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur_requete'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| return $resultat; |
| } |
| protected function getTxt($id) { |
| $sortie = ''; |
| switch ($id) { |
| case 'sql_erreur' : $sortie = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s'; break; |
| default : $sortie = $id; |
| } |
| return $sortie; |
| } |
| protected function traiterParametresUrl($params_attendu, $params, $pourBDD = true) { |
| $sortie = array(); |
| foreach ($params_attendu as $num => $nom) { |
| if (isset($params[$num]) && $params[$num] != '*') { |
| if ($pourBDD) { |
| $params[$num] = $this->bdd->quote($params[$num]); |
| } |
| $sortie[$nom] = $params[$num]; |
| } |
| } |
| return $sortie; |
| } |
| protected function traiterParametresPost($params) { |
| $sortie = array(); |
| foreach ($params as $cle => $valeur) { |
| $sortie[$cle] = $this->bdd->quote($valeur); |
| } |
| return $sortie; |
| } |
| protected function getIdentification(&$params) { |
| // Initialisation des variables |
| $utilisateur = array(0, session_id()); |
| // L'id utilisateur est soit passé par le POST soit dans l'url |
| if (is_array($params) && isset($params['cmhl_ce_modifier_par'])) { |
| $utilisateur[0] = $params['cmhl_ce_modifier_par']; |
| unset($params['cmhl_ce_modifier_par']); |
| } else if (is_string($params)) { |
| $utilisateur[0] = $params; |
| } |
| return $utilisateur; |
| } |
| protected function etreAutorise($id_utilisateur) { |
| $autorisation = false; |
| if (($_SESSION['coel_utilisateur'] != '') && $_SESSION['coel_utilisateur']['id'] != $id_utilisateur) { |
| $this->messages[] = 'Accès interdit.'; |
| } else if ($_SESSION['coel_utilisateur'] == '') { |
| $this->messages[] = 'Veuillez vous identifiez pour accéder à cette fonction.'; |
| } else { |
| $autorisation = true; |
| } |
| return $autorisation; |
| } |
| private function gererIdentificationPermanente() { |
| // Pour maintenir l'utilisateur tjrs réellement identifié nous sommes obligé de recréer une SESSION et de le recharger depuis la bdd |
| if ($this->getUtilisateur() == '' |
| && isset($_COOKIE['coel_login']) |
| && ($utilisateur = $this->chargerUtilisateur($_COOKIE['coel_login'], $_COOKIE['coel_mot_de_passe']))) { |
| $this->setUtilisateur($utilisateur, $_COOKIE['coel_permanence']); |
| } |
| } |
| protected function getUtilisateur() { |
| return (isset($_SESSION['coel_utilisateur']) ? $_SESSION['coel_utilisateur'] : ''); |
| } |
| /** |
| * Méthode prenant en paramètre un chemin de fichier squelette et un tableau associatif de données, |
| * en extrait les variables, charge le squelette et retourne le résultat des deux combinés. |
| * |
| * @param String $fichier le chemin du fichier du squelette |
| * @param Array $donnees un tableau associatif contenant les variables a injecter dans le squelette. |
| * |
| * @return boolean false si le squelette n'existe pas, sinon la chaine résultat. |
| */ |
| public static function traiterSquelettePhp($fichier, Array $donnees = array()) { |
| $sortie = false; |
| if (file_exists($fichier)) { |
| // Extraction des variables du tableau de données |
| extract($donnees); |
| // Démarage de la bufferisation de sortie |
| ob_start(); |
| // Si les tags courts sont activés |
| if ((bool) @ini_get('short_open_tag') === true) { |
| // Simple inclusion du squelette |
| include $fichier; |
| } else { |
| // Sinon, remplacement des tags courts par la syntaxe classique avec echo |
| $html_et_code_php = self::traiterTagsCourts($fichier); |
| // Pour évaluer du php mélangé dans du html il est nécessaire de fermer la balise php ouverte par eval |
| $html_et_code_php = '?>'.$html_et_code_php; |
| // Interprétation du html et du php dans le buffer |
| echo eval($html_et_code_php); |
| } |
| // Récupèration du contenu du buffer |
| $sortie = ob_get_contents(); |
| // Suppression du buffer |
| @ob_end_clean(); |
| } else { |
| $msg = "Le fichier du squelette '$fichier' n'existe pas."; |
| trigger_error($msg, E_USER_WARNING); |
| } |
| // Retourne le contenu |
| return $sortie; |
| } |
| /** |
| * Fonction chargeant le contenu du squelette et remplaçant les tags court php (<?= ...) par un tag long avec echo. |
| * |
| * @param String $chemin_squelette le chemin du fichier du squelette |
| * |
| * @return string le contenu du fichier du squelette php avec les tags courts remplacés. |
| */ |
| private static function traiterTagsCourts($chemin_squelette) { |
| $contenu = file_get_contents($chemin_squelette); |
| // Remplacement de tags courts par un tag long avec echo |
| $contenu = str_replace('<?=', '<?php echo ', $contenu); |
| // Ajout systématique d'un point virgule avant la fermeture php |
| $contenu = preg_replace("/;*\s*\?>/", "; ?>", $contenu); |
| return $contenu; |
| } |
| /* ====================== Fonctions à trier ou factoriser héritées de l'ancienne classe JrestService ======================= */ |
| public function isAdmin($id) { |
| $admins = $this->config['jrest_admin']['admin']; |
| $admin_tab = split(',',$admins); |
| if (in_array($id,$admin_tab)) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| public function controleUtilisateur($id) { |
| if ($_SESSION['user']['name'] == '') { |
| //cas de la session temporaire, on ne fait rien de particulier |
| } else { |
| if (!$this->isAdmin($_SESSION['user']['name']) && $_SESSION['user']['name'] != $id) { |
| // cas d'usurpation d'identité |
| print 'Accès interdit'; |
| exit(); |
| } |
| } |
| } |
| public function logger($index,$chaine) { |
| if(!class_exists('Log')) { |
| include_once('Log.php'); |
| Log::getInstance(); |
| } |
| Log::setCheminLog($this->config['log']['cheminlog']); |
| Log::setTimeZone($this->config['log']['timezone']); |
| Log::setTailleMax($this->config['log']['taillemax']); |
| Log::ajouterEntree($index,$chaine); |
| } |
| } |
| ?> |
| /trunk/applications/jrest/services/squelettes/rss1.tpl.xml |
|---|
| New file |
| 0,0 → 1,45 |
| <?php echo '<?xml version="1.0" encoding="UTF-8"?>'."\n";?> |
| <!DOCTYPE rdf:RDF [ |
| <!ENTITY % HTMLlat1 PUBLIC |
| "-//W3C//ENTITIES Latin 1 for XHTML//EN" |
| "http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent"> |
| %HTMLlat1; |
| ]> |
| <rdf:RDF |
| xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" |
| xmlns:dc="http://purl.org/dc/elements/1.1/" |
| xmlns="http://purl.org/rss/1.0/"> |
| <channel rdf:about="<?=$guid?>"> |
| <title><?=$titre?></title> |
| <link><?=$lien_coel?></link> |
| <description><?=$description?></description> |
| <dc:publisher><?=$editeur?></dc:publisher> |
| <dc:date><?=$date_maj_W3C?></dc:date> |
| <?php if (isset($items)) : ?> |
| <items> |
| <rdf:Seq> |
| <?php foreach ($items as $item) : ?> |
| <rdf:li resource="<?=$item['guid']?>" /> |
| <?php endforeach; ?> |
| </rdf:Seq> |
| </items> |
| <?php endif; ?> |
| </channel> |
| <?php if (isset($items)) : ?> |
| <?php foreach ($items as $item) : ?> |
| <item rdf:about="<?=$item['guid']?>"> |
| <title><?=$item['titre']?></title> |
| <link><?=$item['lien']?></link> |
| <description><?=$item['description_encodee']?></description> |
| <dc:date><?=$item['date_maj_W3C']?></dc:date> |
| </item> |
| <?php endforeach; ?> |
| <?php endif; ?> |
| </rdf:RDF> |
| /trunk/applications/jrest/services/squelettes/rss2.tpl.xml |
|---|
| New file |
| 0,0 → 1,22 |
| <?php echo '<?xml version="1.0" encoding="UTF-8"?>'."\n";?> |
| <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"> |
| <channel> |
| <title><?=$titre?></title> |
| <link><?=$lien_coel?></link> |
| <atom:link href="<?=$lien_service?>" rel="self" type="application/rss+xml" /> |
| <description><?=$description?></description> |
| <?php if (isset($items)) : ?> |
| <?php foreach ($items as $item) : ?> |
| <item> |
| <guid><?=$item['guid']?></guid> |
| <title><?=$item['titre']?></title> |
| <link><?=$item['lien']?></link> |
| <description><?=$item['description_encodee']?></description> |
| <pubDate><?=$item['date_maj_RSS']?></pubDate> |
| </item> |
| <?php endforeach; ?> |
| <?php endif; ?> |
| </channel> |
| </rss> |
| /trunk/applications/jrest/services/squelettes/diff.tpl.html |
|---|
| New file |
| 0,0 → 1,36 |
| <table style="border:1px solid black;border-collapse:collapse;" summary="Différences entre les données du <?=$date_ancienne?> et du <?=$date_nouvelle?>."> |
| <caption style="text-align:left;font-weight:bold;">Différences</caption> |
| <thead style="border:1px solid black;"> |
| <tr> |
| <th rowspan="2" style="border:1px dotted;">Champ</th> |
| <th rowspan="2" style="border:1px dotted;">Type</th> |
| <th <?=(($etat == 'M') ? 'colspan="2"' : '');?> style="border:1px dotted;">Valeur</th> |
| </tr> |
| <tr> |
| <?php if ($etat == 'M') : ?> |
| <th style="border:1px dotted;">Ancienne (<?=$date_ancienne?>)</th> |
| <?php endif; ?> |
| <th style="border:1px dotted;">Nouvelle (<?=$date_nouvelle?>)</th> |
| </tr> |
| </thead> |
| <tbody> |
| <?php foreach ($differences as $champ => $diff) : ?> |
| <?php if ($diff['type'] == 'A') : |
| $couleur = CFC; |
| elseif ($diff['type'] == 'M') : |
| $couleur = FFC; |
| elseif ($diff['type'] == 'S') : |
| $couleur = F99; |
| endif; ?> |
| <tr style="background-color:#<?=$couleur?>;"> |
| <td style="border:1px dotted;"><?=$champ?></td> |
| <td style="text-align:center;border:1px dotted;"><?=$diff['type_txt']?></td> |
| <?php if ($etat == 'M') : ?> |
| <td style="border:1px dotted;"><?=$diff['ancien']?></td> |
| <?php endif; ?> |
| <td style="border:1px dotted;"><?=$diff['nouveau']?></td> |
| </tr> |
| <?php endforeach; ?> |
| </tbody> |
| </table> |
| /trunk/applications/jrest/services/squelettes/atom.tpl.xml |
|---|
| New file |
| 0,0 → 1,33 |
| <?php echo '<?xml version="1.0" encoding="UTF-8"?>'."\n";?> |
| <feed xmlns="http://www.w3.org/2005/Atom"> |
| <title><?=$titre?></title> |
| <link href="<?=$lien_coel?>" rel="alternate" type="text/html" hreflang="fr" /> |
| <link href="<?=$lien_service?>" rel="self" type="application/atom+xml"/> |
| <updated><?=$date_maj_ATOM?></updated> |
| <author> |
| <name><?=$editeur?></name> |
| </author> |
| <id><?=$guid?></id> |
| <rights>Copyright (c) <?=$annee_courante?>, <?=$editeur?></rights> |
| <generator uri="<?=$lien_coel?>" version="<?=$generateur_version?>"><?=$generateur?></generator> |
| <?php if (isset($items)) : ?> |
| <?php foreach ($items as $item) : ?> |
| <entry> |
| <id><?=$item['lien']?></id> |
| <title><?=$item['titre']?></title> |
| <link href="<?=$item['lien']?>"/> |
| <updated><?=$item['date_maj_ATOM']?></updated> |
| <author><name><?=$item['modifier_par']?></name></author> |
| <content type="xhtml" xml:lang="fr"> |
| <div xmlns="http://www.w3.org/1999/xhtml"> |
| <?=$item['description'];?> |
| </div> |
| </content> |
| </entry> |
| <?php endforeach; ?> |
| <?php endif; ?> |
| </feed> |
| /trunk/applications/jrest/services/OdsEspece.php |
|---|
| New file |
| 0,0 → 1,201 |
| <?php |
| class OdsEspece extends JRestService { |
| const PREFIXE = 'get'; |
| /** |
| * Méthode appelée avec une requête de type GET. |
| * |
| */ |
| function getElement($param = array()) { |
| $type = $param[0]; |
| if ($type == '*' || is_numeric($type)) { |
| $info = $this->getElementParDefaut($param); |
| } else { |
| $methode = self::PREFIXE.$type; |
| if (method_exists($this, $methode)) { |
| array_shift($param); |
| $info = $this->$methode($param); |
| } else { |
| $this->messages[] = "Le type d'information demandé '$type' n'est pas disponible."; |
| } |
| } |
| // Envoi sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| $this->envoyer((string) $id_personne); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| //Mise à jour de la personne |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| } catch (PDOException $e) { |
| $messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un élément |
| */ |
| public function deleteElement($uid) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant d'utilisateur ou de personne manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des id passés par l'url |
| $identifiants = explode(',', rtrim($uid[1], ',')); |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| foreach ($identifiants as $id_personne) { |
| try { |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** ======================= Methodes privées d'accès au informations ================================ */ |
| private function getElementParDefaut() { |
| return $this->getEspeces(); |
| } |
| private function getEspeces() { |
| return array( |
| '1' => array( |
| 'id' => '1', |
| 'nom_vernaculaire' => 'Erable de Montpellier' |
| ), |
| '2' => array( |
| 'id' => '2', |
| 'nom_vernaculaire' => 'Herbe à canard' |
| ), |
| '3' => array( |
| 'id' => '3', |
| 'nom_vernaculaire' => 'Coquelicot' |
| ), |
| '4' => array( |
| 'id' => '4', |
| 'nom_vernaculaire' => 'Herbe à chat' |
| ), |
| '5' => array( |
| 'id' => '5', |
| 'nom_vernaculaire' => 'Hibou' |
| ), |
| '6' => array( |
| 'id' => '6', |
| 'nom_vernaculaire' => 'Coucou' |
| ) |
| ); |
| } |
| private function getEspece($params) { |
| $id_espece = $params[0]; |
| $infos_espece = array( |
| 'id' => $id_espece, |
| 'nom_scientifique' => 'Acer monspessulanum', |
| 'nom_vernaculaire' => 'Erable de Montpellier', |
| 'description' => 'Un arbre bien connu de tous', |
| 'url_image' => 'http://www.tela-botanica.org/sites/eflore/generique/images/projets/eflore/bdnff/4.02/nt/8523/002543.jpg' |
| ); |
| return $infos_espece; |
| } |
| private function getEspecesPourStation($params) { |
| $id_station = $params[0]; |
| $especes_dans_station = $this->getEspeces(); |
| $modulo = ($id_station+7)%6; |
| if($modulo == 0) $modulo = 1; |
| return array_slice($especes_dans_station, 0, $modulo); |
| } |
| private function getEspecesParType($params) { |
| $id_type = $params[0]; |
| return $especes_par_type = array( |
| '1' => array( |
| 'nom' => 'herbacées', |
| 'especes' => array( |
| '1' => array('id' => '1', |
| 'nom_vernaculaire' => 'Herbe de Montpellier' |
| ) |
| ) |
| ), |
| '2' => array( |
| 'nom' => 'arbres', |
| 'especes' => array( |
| 'id' => array('id' => '1', |
| 'nom_vernaculaire' => 'Erable de Montpellier' |
| ) |
| ) |
| ), |
| '3' => array( |
| 'nom' => 'animaux', |
| 'especes' => array( |
| 'id' => array('id' => '1', |
| 'nom_vernaculaire' => 'Hibou de Montpellier' |
| ) |
| ) |
| ) |
| ); |
| return $especes_par_type; |
| } |
| } |
| ?> |