Subversion Repositories Applications.framework

<?php

// declare(encoding='UTF-8');

/**

 * Classe modèle, donc 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 diveres possibilités

 * d'abstraction de base de données (PDO, mysql, mysqli, sqlite)

 * Elle est abstraite donc doit obligatoirement être étendue.

 *

 * @category	PHP 5.2

 * @package		Framework

 * @author		Aurélien PERONNET <aurelien@tela-botanica.org>

 * @copyright	Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)

 * @license		GNU-GPL-v3 <http://www.gnu.org/licenses/gpl.html>

 * @license		CECILL-v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt>

 */

abstract class Modele {

	/**

	 * Mode de fetch associatif

	 */

	private $ASSOC = '';

	/**

	 * Mode de fetch objet

	 */

	private $OBJECT = '';

	/**

	 * abstraction de base de données utilisée

	 */

	private $abstraction;

	/**

	 * registre global

	 */

	private $registre;

	/**

	 * 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() {

		// les différents paramètres nécessaires sont lus à partir du registre

		$this->registre = Registre::getInstance();

		$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 'pdo':

				try {

					$this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass);

					$this->connexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

				} catch (PDOException $e) {

					throw new Exception('Erreur de connexion à la base de données : '.$e->getMessage());

				}

			break;

			case 'mysql':

				$this->connexion = mysql_connect($this->hote,$this->utilisateur,$this->pass);

				if ($this->connexion != null) {

					mysql_select_db($this->bdd_nom, $this->connexion);

				} else {

					throw new Exception('Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration');

				}

			break;

			case 'mysqli':

				$this->connexion = new mysqli($this->hote,$this->utilisateur,$this->pass, $this->bdd_nom);

				if (!$this->connexion) {

					throw new Exception('Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration');

					return;

				}

			break;

			case '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) {

					throw new Exception('Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration');

					return;

				}

			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) {

		// on ne se connecte que lors du premier appel à une requete (lazy connexion)

		if ($this->connexion == null) {

			$this->connecter();

		}

		$retour = null;

		switch ($this->abstraction) {

			case 'pdo':

				$retour = $this->connexion->query($requete);

				break;

			case 'mysql':

				$retour = mysql_query($requete,$this->connexion);

				break;

			case 'mysqli':

				$retour = $this->connexion->query($requete);

				break;

			case 'sqlite3':

				$retour = $this->connexion->exec($requete);

				break;

		}

		return $retour;

	}

	final protected function requeteUn($requete,$mode = 'ASSOC') {

		// Connection seulement lors du premier appel à une requete (lazy connexion)

		if ($this->connexion == null) {

			$this->connecter();

		}

		$retour = null;

		switch ($this->abstraction) {

			case 'pdo':

				try {

					$res_req = $this->connexion->query($requete);

					$retour = ($res_req !== false) ? $res_req->fetch($this->$mode) : $res_req;

				} catch (PDOException $e) {

					$message = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s';

					trigger_error(sprintf($message, $e->getFile(), $e->getLine(), $e->getMessage()), E_USER_WARNING);

				}

				break;

			case 'mysql':

				$res = mysql_query($requete,$this->connexion);

				$fonction_fetch = $this->$mode;

				$retour = $fonction_fetch($res);

				break;

			case 'mysqli':

				$res = $this->connexion->query($requete);

				$fonction_fetch = $this->$mode;

				$retour = $res->$fonction_fetch();

				break;

			case 'sqlite3':

				$retour = $this->connexion->querySingle($requete);

				break;

		}

		return $retour;

	}

	final protected function requeteTous($requete,$mode = 'ASSOC') {

		// Connexion seulement lors du premier appel à une requete (lazy connexion)

		if ($this->connexion == null) {

			$this->connecter();

		}

		$retour = null;

		switch ($this->abstraction) {

			case 'pdo':

				try {

					$res_req = $this->connexion->query($requete);

					if ($res_req !== false) {

						$retour = $res_req->fetchAll($this->$mode);

					} else {

						$retour = false;

					}

				} catch (PDOException $e) {

					$message = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s';

					trigger_error(sprintf($message, $e->getFile(), $e->getLine(), $e->getMessage()), E_USER_WARNING);

				}

				break;

			case 'mysql':

				$res = mysql_query($requete, $this->connexion);

				$fonction_fetch = $this->$mode;

				while ($ligne = $fonction_fetch($res)) {

					$retour[] = $ligne;

				}

				break;

			case 'mysqli':

				$res = $this->connexion->query($requete);

				$function_fetch = $this->$mode;

				while ($ligne = $res->$function_fetch()) {

					$retour[] = $ligne;

				}

				break;

			case 'sqlite3':

				$res = $this->connexion->query($requete);

				while ($ligne = $res->fetch_array($this->ASSOC)) {

					if ($mode == $this->ASSOC) {

						$retour[] = $ligne;

					} elseif ($mode == $this->OBJECT) {

						// cas particulier de sqllite

						// qui n'a pas de fonction fetch_object

						$ligneObjet = new stdClass();

						foreach ($ligne as $colonne => $valeur) {

							$ligneObjet->$colonne = $valeur;

						}

						$retour[] = $ligneObjet;

					}

				}

				break;

		}

		return $retour;

	}

	/**

	 * protège une chaine de caractères avant l'insertion dans la base de données

	 */

	final protected function proteger($chaine) {

		// on ne se connecte que lors du premier appel à une requete

		if ($this->connexion == null) {

			$this->connecter();

		}

		$retour = $chaine;

		switch ($this->abstraction) {

			case 'pdo':

				$retour = $this->connexion->quote($chaine);

				break;

			case 'mysql':

				$retour = '"'.mysql_real_escape_string($chaine, $this->connexion).'"';

				break;

			case 'mysqli':

				$retour = '"'.$this->connexion->real_escape_string($chaine).'"';

				break;

			case 'sqlite3':

				$retour = $this->connexion->escapeString($chaine);

				break;

		}

		return $retour;

	}

	/**

	 * initialise les constantes de classe à leur bonne valeur

	 * et lance une exception si le protocole n'est pas bien défini

	 * @throws Exception

	 */

	final public function initialiserProtocole() {

		switch ($this->abstraction) {

			case 'pdo':

				$this->ASSOC = PDO::FETCH_ASSOC;

				$this->OBJECT = PDO::FETCH_CLASS;

				break;

			case 'mysql':

				$this->ASSOC = 'mysql_fetch_assoc';

				$this->OBJECT = 'mysql_fetch_object';

				break;

			case 'mysqli':

				$this->ASSOC = 'fetch_assoc';

				$this->OBJECT = 'fetch_object';

				break;

			case 'sqlite3':

				$this->ASSOC = 'SQLITE3_ASSOC';

				$this->OBJECT = 'SQLITE3_OBJECT';

				break;

			default:

				throw new Exception('Erreur : l\'abstraction '.$this->abstraction.' n\'est pas prise en charge');

				break;

		}

	}

	/**

	 * Destructeur de classe, se contente de fermer explicitement la connexion

	 */

	final public function __destruct() {

		switch ($this->abstraction) {

			case 'pdo':

				$this->connexion = null;

				break;

			case 'mysql':

				return mysql_close($this->connexion);

				break;

			case 'mysqli':

				$this->connexion->close();

				break;

			case 'sqlite3':

				$this->connexion->close();

				break;

		}

	}

}

?>