Subversion Repositories Applications.framework

<?php
// declare(encoding='UTF-8');
/**
* Classe modèle, d'accés au données, elle ne devrait pas être appelée de l'extérieur.
* Elle fait office d'abstraction légère de base de données en utilisant diverses possibilités
* d'abstraction de base de données (PDO, mysql, mysqli, SQLite3).
* Les valeurs pour le paramètre 'bdd_abstraction' du fichier config.ini sont : pdo, mysql, mysqli, sqlite3
* Elle est abstraite et doit donc obligatoirement être étendue.
*
* @category     php 5.2
* @package              Framework
* @author               Aurélien PERONNET <aurelien@tela-botanica.org>
* @copyright    2009 Tela-Botanica
* @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              SVN: $Id: Modele.php 219 2010-11-10 13:27:48Z jpm $
* @link         /doc/framework/
*
*/
abstract class Modele {
        /** Constante stockant le squelette du message en cas d'erreur de requête sql. */
        const ERREUR_REQUETE_TPL = 'Requête echec.\nFichier : %s.\nLigne : %s.\nMessage : %s.\nRequête : %s';
        
        /** Constante stockant le squelette du message en cas d'erreur de connexion à la base de données. */
        const ERREUR_CONNEXION_TPL = 'Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration.\nMessage : %S.';
        
        /** Constante stockant le squelette du message en cas d'erreur de sélection de la base de données. */
        const ERREUR_CONNEXION_TPL = 'Erreur de sélection de la base de données, vérifiez les paramètres du fichier de configuration.\nMessage : %S.';
        
        /** Constante stockant le code pour l'abstraction de PDO. */
        const ABSTRACTION_PDO = 'pdo';
        
        /** Constante stockant le code pour l'abstraction de mysql. */
        const ABSTRACTION_MYSQL = 'mysql';
        
        /** Constante stockant le code pour l'abstraction de mysqli. */
        const ABSTRACTION_MYSQLI = 'mysqli';
        
        /** Constante stockant le code pour l'abstraction de SQLite3. */
        const ABSTRACTION_SQLITE3 = 'sqlite3';
        
        /** Constante stockant le code pour le mode tableau associatif des résultats des requêtes. */
        const MODE_ASSOC = 'ASSOC';
        
        /** Constante stockant le code pour le mode objet des résultats des requêtes. */
        const MODE_OBJET = 'OBJECT';
        
        /** Mode de fetch associatif */
        private $ASSOC = '';
        
        /** Mode de fetch objet */
        private $OBJECT = '';

        /** abstraction de base de données utilisée */
        private $abstraction;
        
        /** DSN pour accéder à la base de données */
        private $dsn;
        
        /** Type de base de données (mysql, mysqli, etc ...) */
        private $type;
        
        /** Hote herbergeant la base de données */
        private $hote;
        
        /** Nom de la base de données à laquelle le modèle doit se connecter */
        private $bdd_nom;
        
        /** Nom d'utilisateur */
        private $utilisateur;
        
        /** Mot de passe */
        private $pass;

        /** Encodage de la base de données */
         private $encodage = null;
        
        /** Connexion à la base de données */
        private $connexion = null;

        /**
         * Constructeur par défaut, appelé à l'initialisation.
         */
        public function __construct() {
                $this->abstraction = strtolower(Config::get('bdd_abstraction'));
                $this->type = Config::get('bdd_protocole');
                $this->hote = Config::get('bdd_serveur');
                $this->bdd_nom = Config::get('bdd_nom');
                $this->utilisateur = Config::get('bdd_utilisateur');
                $this->pass = Config::get('bdd_mot_de_passe');
                $this->encodage = Config::get('bdd_encodage');

                $this->dsn = $this->type.':dbname='.$this->bdd_nom.';host='.$this->hote;
                $this->initialiserProtocole();
        }

        /**
         * Connection à la base de données en utilisant les informations fournies par
         * le fichier de configuration.
         * private et final car n'a pas vocation a être appelée par l'utilisateur.
         *
         * @throws Exception une exception dans le cas ou là connexion échoue
         */
        final private function connecter() {
                switch ($this->abstraction) {
                        case self::ABSTRACTION_PDO :
                                try {
                                        $this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass);
                                } catch (PDOException $e) {
                                        $e = sprintf(self::ERREUR_CONNEXION_TPL, $e->getMessage());
                                        trigger_error($e, E_USER_WARNING);
                                }
                                break;
                        case self::ABSTRACTION_MYSQL :
                                $this->connexion = mysql_connect($this->hote, $this->utilisateur, $this->pass);
                                if ($this->connexion !== false) {
                                        $selection = mysql_select_db($this->bdd_nom, $this->connexion);
                                        if ($selection === false) {
                                                $e = sprintf(self::ERREUR_SELECTION_BDD_TPL, mysql_error());
                                                trigger_error($e, E_USER_WARNING);
                                        }
                                } else {
                                        $e = sprintf(self::ERREUR_CONNEXION_TPL, mysql_error());
                                        trigger_error($e, E_USER_WARNING);
                                }
                                break;
                        case self::ABSTRACTION_MYSQLI :
                                $this->connexion = @new mysqli($this->hote, $this->utilisateur, $this->pass, $this->bdd_nom);
                                if ($this->connexion->connect_errno) {
                                        $e = sprintf(self::ERREUR_CONNEXION_TPL, $this->connexion->connect_error);
                                        trigger_error($e, E_USER_WARNING);
                                }
                                break;
                        case self::ABSTRACTION_SQLITE3 :
                                // cas particulier de sqllite, on considère que le nom de la base de données correspond au fichier à ouvrir
                                $this->connexion = new SQLite3($this->bdd_nom);
                                if (!$this->connexion) {
                                        $e = sprintf(self::ERREUR_CONNEXION_TPL, '');
                                        trigger_error($e, E_USER_WARNING);
                                }
                                break;
                        default:
                                $this->connexion = null;
                }

                if ($this->encodage != null) {
                        $this->requete("SET names '".$this->encodage."'");
                }
        }

        /**
         * Fonction qui appelle la bonne fonction pour executer une requête suivant le type de bdd.
         *
         * @param string la requete à effectuer
         * @return PDOStatement un objet contenant le résultat de la requête
         */
        final protected function requete($requete) {
                if ($this->connexion == null) {
                        $this->connecter();
                }
                $retour = null;
                
                switch ($this->abstraction) {
                        case self::ABSTRACTION_PDO :
                                try {
                                        $retour = $this->connexion->query($requete);
                                } catch (PDOException $e) {
                                        $m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
                                        trigger_error($m, E_USER_WARNING);
                                }
                                break;
                        case self::ABSTRACTION_MYSQL :
                                $retour = mysql_query($requete, $this->connexion);
                                break;
                        case self::ABSTRACTION_MYSQLI :
                                $retour = $this->connexion->query($requete);
                                break;
                        case self::ABSTRACTION_SQLITE3 :
                                $retour = $this->connexion->exec($requete);
                                break;
                }
                return $retour;
        }

        final protected function requeteUn($requete, $mode = self::MODE_ASSOC) {
                if ($this->connexion == null) {
                        $this->connecter();
                }

                $retour = null;
                switch ($this->abstraction) {
                        case self::ABSTRACTION_PDO :
                                try {
                                        $res_req = $this->connexion->query($requete);
                                        $retour =$res_req->fetch($this->$mode);
                                } catch (PDOException $e) {
                                        $m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
                                        trigger_error($m, E_USER_WARNING);
                                }
                                break;
                        case self::ABSTRACTION_MYSQL :
                                $res = mysql_query($requete,$this->connexion);
                                $fonction_fetch = $this->$mode;
                                $retour = $fonction_fetch($res);
                                break;
                        case self::ABSTRACTION_MYSQLI :
                                $res = $this->connexion->query($requete);
                                $fonction_fetch = $this->$mode;
                                $retour = $res->$fonction_fetch();
                                break;
                        case self::ABSTRACTION_SQLITE3 :
                                $retour = $this->connexion->querySingle($requete);
                                break;
                }

                return $retour;
        }


        final protected function requeteTous($requete, $mode = self::MODE_ASSOC) {
                if ($this->connexion == null) {
                        $this->connecter();
                }

                $retour = null;

                switch ($this->abstraction) {
                        case self::ABSTRACTION_PDO :
                                try {
                                        $res_req = $this->connexion->query($requete);
                                        if ($res_req !== false) {
                                                $retour = $res_req->fetchAll($this->$mode);
                                        } else {
                                                $retour = false;
                                        }
                                } catch (PDOException $e) {
                                        $m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
                                        trigger_error($m, E_USER_WARNING);
                                }
                                break;
                        case self::ABSTRACTION_MYSQL :
                                $res = mysql_query($requete, $this->connexion);
                                $fonction_fetch = $this->$mode;
                                while ($ligne = $fonction_fetch($res)) {
                                        $retour[] = $ligne;
                                }
                                break;
                        case self::ABSTRACTION_MYSQLI :
                                $res = $this->connexion->query($requete);
                                $function_fetch = $this->$mode;
                                while ($ligne = $res->$function_fetch()) {
                                        $retour[] = $ligne;
                                }
                                break;
                        case self::ABSTRACTION_SQLITE3 :
                                $res = $this->connexion->query($requete);
                                while ($ligne = $res->fetch_array($this->ASSOC)) {
                                        if ($mode == self::MODE_OBJET) {
                                                // Cas particulier de sqllite qui n'a pas de fonction fetch_object
                                                $ligneObjet = new stdClass();
                                                foreach ($ligne as $colonne => $valeur) {
                                                        $ligneObjet->$colonne = $valeur;
                                                }
                                                $ligne = $ligneObjet;
                                        }
                                        $retour[] = $ligne;
                                }
                                break;
                }

                return $retour;
        }

        /**
         * Protège une chaine de caractères avant l'insertion dans la base de données.
         */
        final protected function proteger($chaine) {
                if ($this->connexion == null) {
                        $this->connecter();
                }

                $retour = $chaine;

                switch ($this->abstraction) {
                        case self::ABSTRACTION_PDO :
                                $retour = $this->connexion->quote($chaine);
                                break;
                        case self::ABSTRACTION_MYSQL :
                                $retour = '"'.mysql_real_escape_string($chaine, $this->connexion).'"';
                                break;
                        case self::ABSTRACTION_MYSQLI :
                                $retour = '"'.$this->connexion->real_escape_string($chaine).'"';
                                break;
                        case self::ABSTRACTION_SQLITE3 :
                                $retour = $this->connexion->escapeString($chaine);
                                break;
                }

                return $retour;
        }

        /**
         * Initialise les constantes de classe à leur bonne valeur et déclenche une erreur si le protocole n'est pas bien défini.
         */
        final public function initialiserProtocole() {
                switch ($this->abstraction) {
                        case self::ABSTRACTION_PDO :
                                $this->ASSOC = PDO::FETCH_ASSOC;
                                $this->OBJECT = PDO::FETCH_CLASS;
                                break;
                        case self::ABSTRACTION_MYSQL :
                                $this->ASSOC = 'mysql_fetch_assoc';
                                $this->OBJECT = 'mysql_fetch_object';
                                break;
                        case self::ABSTRACTION_MYSQLI :
                                $this->ASSOC = 'fetch_assoc';
                                $this->OBJECT = 'fetch_object';
                                break;
                        case self::ABSTRACTION_SQLITE3 :
                                $this->ASSOC = 'SQLITE3_ASSOC';
                                $this->OBJECT = 'SQLITE3_OBJECT';
                                break;
                        default:
                                $m = "Erreur : l'abstraction '{$this->abstraction}' n'est pas prise en charge";
                                trigger_error($m, E_USER_WARNING);
                }
        }

        /**
         * Destructeur de classe, se contente de fermer explicitement la connexion à la base de donnée.
         */
        final public function __destruct() {
                switch ($this->abstraction) {
                        case self::ABSTRACTION_PDO :
                                $this->connexion = null;
                                break;
                        case self::ABSTRACTION_MYSQL :
                                return mysql_close($this->connexion);
                                break;
                        case self::ABSTRACTION_MYSQLI :
                                $this->connexion->close();
                                break;
                        case self::ABSTRACTION_SQLITE3 :
                                $this->connexion->close();
                                break;
                }
        }
}
?>