Subversion Repositories Sites.obs-saisons.fr

<?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 proteger($chaine) {
                return $this->bdd->quote($chaine);
        }

        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);
        }       
}
?>