| 1721 | 
           raphael | 
           1 | 
           <?php
  | 
        
        
           | 2460 | 
           jpm | 
           2 | 
           // declare(encoding='UTF-8');
  | 
        
        
           | 1721 | 
           raphael | 
           3 | 
           /**
  | 
        
        
           | 2460 | 
           jpm | 
           4 | 
            * Classe de gestion de la base de données.
  | 
        
        
           | 1721 | 
           raphael | 
           5 | 
            *
  | 
        
        
           | 2460 | 
           jpm | 
           6 | 
            * @internal   Mininum PHP version : 5.2
  | 
        
        
            | 
            | 
           7 | 
            * @category   CEL
  | 
        
        
            | 
            | 
           8 | 
            * @package    Services
  | 
        
        
            | 
            | 
           9 | 
            * @subpackage Bibliothèques
  | 
        
        
            | 
            | 
           10 | 
            * @version    0.1
  | 
        
        
            | 
            | 
           11 | 
            * @author     Mathias CHOUET <mathias@tela-botanica.org>
  | 
        
        
            | 
            | 
           12 | 
            * @author     Raphaël Droz <raphael@tela-botanica.org>
  | 
        
        
            | 
            | 
           13 | 
            * @author     Jean-Pascal MILCENT <jpm@tela-botanica.org>
  | 
        
        
            | 
            | 
           14 | 
            * @author     Aurelien PERONNET <aurelien@tela-botanica.org>
  | 
        
        
            | 
            | 
           15 | 
            * @license    GPL v3 <http://www.gnu.org/licenses/gpl.txt>
  | 
        
        
            | 
            | 
           16 | 
            * @license    CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
  | 
        
        
            | 
            | 
           17 | 
            * @copyright  1999-2014 Tela Botanica <accueil@tela-botanica.org>
  | 
        
        
           | 1721 | 
           raphael | 
           18 | 
            */
  | 
        
        
           | 2461 | 
           jpm | 
           19 | 
           class Bdd extends PDO {
  | 
        
        
           | 1721 | 
           raphael | 
           20 | 
              | 
        
        
            | 
            | 
           21 | 
           	const SQL_MODE_ASSOC = PDO::FETCH_ASSOC;
  | 
        
        
            | 
            | 
           22 | 
           	const SQL_MODE_OBJET = PDO::FETCH_OBJ;
  | 
        
        
            | 
            | 
           23 | 
           	const SQL_RETOUR_COMPLET = 'All';
  | 
        
        
            | 
            | 
           24 | 
           	const SQL_RETOUR_LIGNE = 'Row';
  | 
        
        
            | 
            | 
           25 | 
           	const SQL_RETOUR_COLONNE = 'Column';
  | 
        
        
            | 
            | 
           26 | 
           	const SQL_RETOUR_BRUT = 'Raw';
  | 
        
        
            | 
            | 
           27 | 
              | 
        
        
           | 2144 | 
           jpm | 
           28 | 
           	public function __construct($config, $base = 'database_cel') {
  | 
        
        
            | 
            | 
           29 | 
           		$cfg = $config[$base];
  | 
        
        
            | 
            | 
           30 | 
           		// ATTENTION : la connexin à la bdd peut échouer si l'host vaut localhost. Utiliser 127.0.0.1 à la place.
  | 
        
        
           | 1721 | 
           raphael | 
           31 | 
           		$dsn = $cfg['phptype'].':dbname='.$cfg['database'].';host='.$cfg['hostspec'];
  | 
        
        
            | 
            | 
           32 | 
           		try {
  | 
        
        
           | 2144 | 
           jpm | 
           33 | 
           			// Création de la connexion en UTF-8 à la BDD
  | 
        
        
           | 1721 | 
           raphael | 
           34 | 
           			parent::__construct($dsn, $cfg['username'], $cfg['password'], array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES 'UTF8'"));
  | 
        
        
           | 2342 | 
           mathias | 
           35 | 
           			// Affiche les erreurs détectées par PDO (sinon mode silencieux => aucune erreur affichée)
  | 
        
        
           | 1721 | 
           raphael | 
           36 | 
           			parent::setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  | 
        
        
            | 
            | 
           37 | 
           		} catch (PDOException $e) {
  | 
        
        
           | 2342 | 
           mathias | 
           38 | 
           			echo 'La connexion à la base de donnée via PDO a échoué : ' .$dsn . "\n". $e->getMessage();
  | 
        
        
           | 1721 | 
           raphael | 
           39 | 
           		}
  | 
        
        
            | 
            | 
           40 | 
           	}
  | 
        
        
            | 
            | 
           41 | 
              | 
        
        
            | 
            | 
           42 | 
           	/**
  | 
        
        
            | 
            | 
           43 | 
           	 * Protège automatiquement toutes les chaines comprises entre deux caractères '|'.
  | 
        
        
            | 
            | 
           44 | 
           	 * Puis execute la requete.
  | 
        
        
            | 
            | 
           45 | 
           	 * @see protegerRequete()
  | 
        
        
            | 
            | 
           46 | 
           	 * @param unknown_type $requete
  | 
        
        
            | 
            | 
           47 | 
           	 */
  | 
        
        
            | 
            | 
           48 | 
           	public function requeter($requete, $retour = self::SQL_RETOUR_COMPLET, $mode = PDO::FETCH_ASSOC) {
  | 
        
        
            | 
            | 
           49 | 
           		return $this->executerRequete($requete, $retour, $mode);
  | 
        
        
            | 
            | 
           50 | 
           	}
  | 
        
        
            | 
            | 
           51 | 
              | 
        
        
            | 
            | 
           52 | 
           	/**
  | 
        
        
           | 2143 | 
           jpm | 
           53 | 
           	 * Execute la requete retournant une seule ligne de résultat.
  | 
        
        
            | 
            | 
           54 | 
           	 * @param String $requete
  | 
        
        
           | 1721 | 
           raphael | 
           55 | 
           	 */
  | 
        
        
           | 2143 | 
           jpm | 
           56 | 
           	public function requeterLigne($requete, $mode = PDO::FETCH_ASSOC) {
  | 
        
        
            | 
            | 
           57 | 
           		return $this->executerRequete($requete, self::SQL_RETOUR_LIGNE, $mode);
  | 
        
        
           | 1721 | 
           raphael | 
           58 | 
           	}
  | 
        
        
            | 
            | 
           59 | 
              | 
        
        
            | 
            | 
           60 | 
           	/**
  | 
        
        
           | 2143 | 
           jpm | 
           61 | 
           	 * Execute la requete retournant une seule colone de résultat.
  | 
        
        
            | 
            | 
           62 | 
           	 * @param String $requete
  | 
        
        
           | 1721 | 
           raphael | 
           63 | 
           	 */
  | 
        
        
           | 2143 | 
           jpm | 
           64 | 
           	public function requeterValeurUnique($requete, $mode = PDO::FETCH_ASSOC) {
  | 
        
        
            | 
            | 
           65 | 
           		return $this->executerRequete($requete, self::SQL_RETOUR_COLONNE, $mode);
  | 
        
        
           | 1721 | 
           raphael | 
           66 | 
           	}
  | 
        
        
            | 
            | 
           67 | 
              | 
        
        
            | 
            | 
           68 | 
           	public function executerRequete($requete, $retour = self::SQL_RETOUR_COMPLET, $mode = PDO::FETCH_ASSOC) {
  | 
        
        
            | 
            | 
           69 | 
           		$resultat = false;
  | 
        
        
            | 
            | 
           70 | 
           		try {
  | 
        
        
            | 
            | 
           71 | 
           			switch ($retour) {
  | 
        
        
            | 
            | 
           72 | 
           				case self::SQL_RETOUR_COMPLET :
  | 
        
        
            | 
            | 
           73 | 
           					$resultat = $this->query($requete)->fetchAll($mode);// Retourne toutes les lignes
  | 
        
        
            | 
            | 
           74 | 
           					break;
  | 
        
        
            | 
            | 
           75 | 
           				case self::SQL_RETOUR_LIGNE :
  | 
        
        
            | 
            | 
           76 | 
           					$resultat = $this->query($requete)->fetch($mode);// Retourne la première ligne
  | 
        
        
            | 
            | 
           77 | 
           					break;
  | 
        
        
            | 
            | 
           78 | 
           				case self::SQL_RETOUR_COLONNE :
  | 
        
        
            | 
            | 
           79 | 
           					$resultat = $this->query($requete)->fetchColumn();// Retourne la première colonne de la première ligne
  | 
        
        
            | 
            | 
           80 | 
           					break;
  | 
        
        
            | 
            | 
           81 | 
           				case self::SQL_RETOUR_BRUT :
  | 
        
        
            | 
            | 
           82 | 
           					$resultat = $this->query($requete);// Retourne l'objet brut pour être utilisé dans une boucle de type foreach
  | 
        
        
            | 
            | 
           83 | 
           					break;
  | 
        
        
            | 
            | 
           84 | 
           				default:
  | 
        
        
            | 
            | 
           85 | 
           					$this->debug[] = "Le type de retour '$retour' est inconnu.";
  | 
        
        
            | 
            | 
           86 | 
           			}
  | 
        
        
            | 
            | 
           87 | 
           			if ($resultat === false) {
  | 
        
        
            | 
            | 
           88 | 
           				$this->debug[] = "La requête a retourné aucun résultat : $requete";
  | 
        
        
            | 
            | 
           89 | 
           			}
  | 
        
        
            | 
            | 
           90 | 
           		} catch (PDOException $e) {
  | 
        
        
           | 2143 | 
           jpm | 
           91 | 
           			$msgTpl = "Requête echec.\nFichier : %s.\nLigne : %s.\nMessage : %s.\nRequête : %s";
  | 
        
        
            | 
            | 
           92 | 
           			$this->debug[] = sprintf($msgTpl, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
  | 
        
        
           | 1721 | 
           raphael | 
           93 | 
           		}
  | 
        
        
            | 
            | 
           94 | 
           		return $resultat;
  | 
        
        
            | 
            | 
           95 | 
           	}
  | 
        
        
            | 
            | 
           96 | 
              | 
        
        
           | 2143 | 
           jpm | 
           97 | 
           	/**
  | 
        
        
            | 
            | 
           98 | 
           	 * Execute la requete retournant l'objet brut de résultat pour l'utiliser dans un foreach.
  | 
        
        
            | 
            | 
           99 | 
           	 * @param String $requete
  | 
        
        
            | 
            | 
           100 | 
           	 */
  | 
        
        
            | 
            | 
           101 | 
           	public function requeterBrut($requete) {
  | 
        
        
            | 
            | 
           102 | 
           		return $this->executerRequete($requete, self::SQL_RETOUR_BRUT);
  | 
        
        
            | 
            | 
           103 | 
           	}
  | 
        
        
            | 
            | 
           104 | 
              | 
        
        
            | 
            | 
           105 | 
           	public function executer($requete) {
  | 
        
        
            | 
            | 
           106 | 
           		try {
  | 
        
        
            | 
            | 
           107 | 
           			$resultat = $this->exec($requete);
  | 
        
        
            | 
            | 
           108 | 
           			if ($resultat === false) {
  | 
        
        
            | 
            | 
           109 | 
           				$this->debug[] = "La requête a échoué : $requete";
  | 
        
        
            | 
            | 
           110 | 
           			}
  | 
        
        
            | 
            | 
           111 | 
           		} catch (PDOException $e) {
  | 
        
        
            | 
            | 
           112 | 
           			$message = "Fichier : {$e->getFile()} \nLigne : {$e->getLine()} \nMessage : {$e->getMessage()} \nRequête : $requete";
  | 
        
        
            | 
            | 
           113 | 
           			$code = E_USER_ERROR;
  | 
        
        
            | 
            | 
           114 | 
           			throw new Exception($message, $code);
  | 
        
        
           | 1721 | 
           raphael | 
           115 | 
           		}
  | 
        
        
           | 2143 | 
           jpm | 
           116 | 
           		return $resultat;
  | 
        
        
           | 1721 | 
           raphael | 
           117 | 
           	}
  | 
        
        
           | 2143 | 
           jpm | 
           118 | 
              | 
        
        
            | 
            | 
           119 | 
           	public function proteger($donnees) {
  | 
        
        
            | 
            | 
           120 | 
           		if (is_array($donnees)) {
  | 
        
        
            | 
            | 
           121 | 
           			$retour = $this->protegerTableau($donnees);
  | 
        
        
            | 
            | 
           122 | 
           		} else {
  | 
        
        
            | 
            | 
           123 | 
           			$retour = $this->quote($donnees);
  | 
        
        
            | 
            | 
           124 | 
           		}
  | 
        
        
            | 
            | 
           125 | 
           		return $retour;
  | 
        
        
            | 
            | 
           126 | 
           	}
  | 
        
        
            | 
            | 
           127 | 
              | 
        
        
            | 
            | 
           128 | 
           	private function protegerTableau(Array $tableau) {
  | 
        
        
            | 
            | 
           129 | 
           		foreach ($tableau as $id => $val) {
  | 
        
        
            | 
            | 
           130 | 
           			if (is_array($val)) {
  | 
        
        
            | 
            | 
           131 | 
           				$tableau[$id] = $this->protegerTableau($val);
  | 
        
        
            | 
            | 
           132 | 
           			} else {
  | 
        
        
            | 
            | 
           133 | 
           				$tableau[$id] = $this->proteger($val);
  | 
        
        
            | 
            | 
           134 | 
           			}
  | 
        
        
            | 
            | 
           135 | 
           		}
  | 
        
        
            | 
            | 
           136 | 
           		return $tableau;
  | 
        
        
            | 
            | 
           137 | 
           	}
  | 
        
        
            | 
            | 
           138 | 
              | 
        
        
           | 2042 | 
           aurelien | 
           139 | 
           	public function obtenirDernierId() {
  | 
        
        
            | 
            | 
           140 | 
           		return $this->lastInsertId();
  | 
        
        
            | 
            | 
           141 | 
           	}
  | 
        
        
           | 1721 | 
           raphael | 
           142 | 
           }
  |