1: <?php
  2: // declare(encoding='UTF-8');
  3: /**
  4:  * Classe modèle, donc d'accés au données, elle ne devrait pas être appelée de l'extérieur.
  5:  * Elle fait office d'abstraction légère de base de données en utilisant diveres possibilités
  6:  * d'abstraction de base de données (PDO, mysql, mysqli, sqlite)
  7:  * Elle est abstraite donc doit obligatoirement être étendue.
  8:  *
  9:  * @category    PHP 5.2
 10:  * @package     Framework
 11:  * @author      Aurélien PERONNET <aurelien@tela-botanica.org>
 12:  * @copyright   Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)
 13:  * @license     GNU-GPL-v3 <http://www.gnu.org/licenses/gpl.html>
 14:  * @license     CECILL-v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt>
 15:  */
 16: abstract class Modele {
 17: 
 18:     /**
 19:      * Mode de fetch associatif
 20:      */
 21:     private $ASSOC = '';
 22:     /**
 23:      * Mode de fetch objet
 24:      */
 25:     private $OBJECT = '';
 26: 
 27:     /**
 28:      * abstraction de base de données utilisée
 29:      */
 30:     private $abstraction;
 31:     /**
 32:      * registre global
 33:      */
 34:     private $registre;
 35:     /**
 36:      * DSN pour accéder à la base de données
 37:      */
 38:     private $dsn;
 39:     /**
 40:      * Type de base de données (mysql, mysqli, etc ...)
 41:      */
 42:     private $type;
 43:     /**
 44:      * Hote herbergeant la base de données
 45:      */
 46:     private $hote;
 47:     /**
 48:      * Nom de la base de données à laquelle le modèle doit se connecter
 49:      */
 50:     private $bdd_nom;
 51:     /**
 52:      * Nom d'utilisateur
 53:      */
 54:     private $utilisateur;
 55:     /**
 56:      * Mot de passe
 57:      */
 58:     private $pass;
 59: 
 60:     /**
 61:      * Encodage de la base de données
 62:      */
 63:      private $encodage = null;
 64:     /**
 65:      * Connexion à la base de données
 66:      */
 67:     private $connexion = null;
 68: 
 69:     /**
 70:      * Constructeur par défaut, appelé à l'initialisation.
 71:      */
 72:     public function __construct() {
 73:         // les différents paramètres nécessaires sont lus à partir du registre
 74:         $this->registre = Registre::getInstance();
 75:         $this->abstraction = strtolower(Config::get('bdd_abstraction'));
 76:         $this->type = Config::get('bdd_protocole');
 77:         $this->hote = Config::get('bdd_serveur');
 78:         $this->bdd_nom = Config::get('bdd_nom');
 79:         $this->utilisateur = Config::get('bdd_utilisateur');
 80:         $this->pass = Config::get('bdd_mot_de_passe');
 81:         $this->encodage = Config::get('bdd_encodage');
 82: 
 83:         $this->dsn = $this->type.':dbname='.$this->bdd_nom.';host='.$this->hote;
 84:         $this->initialiserProtocole();
 85:     }
 86: 
 87:     /**
 88:      * Connection à la base de données en utilisant les informations fournies par
 89:      * le fichier de configuration.
 90:      * private et final car n'a pas vocation a être appelée par l'utilisateur.
 91:      *
 92:      * @throws Exception une exception dans le cas ou là connexion échoue
 93:      */
 94:     final private function connecter() {
 95:         switch ($this->abstraction) {
 96:             case 'pdo':
 97:                 try {
 98:                     $this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass);
 99:                     $this->connexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
100:                 } catch (PDOException $e) {
101:                     throw new Exception('Erreur de connexion à la base de données : '.$e->getMessage());
102:                 }
103:             break;
104: 
105:             case 'mysql':
106:                 $this->connexion = mysql_connect($this->hote,$this->utilisateur,$this->pass);
107:                 if ($this->connexion != null) {
108:                     mysql_select_db($this->bdd_nom, $this->connexion);
109:                 } else {
110:                     throw new Exception('Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration');
111:                 }
112:             break;
113: 
114:             case 'mysqli':
115:                 $this->connexion = new mysqli($this->hote,$this->utilisateur,$this->pass, $this->bdd_nom);
116:                 if (!$this->connexion) {
117:                     throw new Exception('Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration');
118:                     return;
119:                 }
120:             break;
121: 
122:             case 'sqlite3':
123:                 // cas particulier de sqllite, on considère que le nom de la base de données correspond au fichier à ouvrir
124:                 $this->connexion = new SQLite3($this->bdd_nom);
125:                 if (!$this->connexion) {
126:                     throw new Exception('Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration');
127:                     return;
128:                 }
129:             break;
130: 
131:             default:
132:                 $this->connexion = null;
133:         }
134: 
135:         if ($this->encodage != null) {
136:             $this->requete("SET names '".$this->encodage."'");
137:         }
138:     }
139: 
140:     /**
141:      * Fonction qui appelle la bonne fonction pour executer une requête suivant le type de bdd.
142:      *
143:      * @param string la requete à effectuer
144:      * @return PDOStatement un objet contenant le résultat de la requête
145:      */
146:     final protected function requete($requete) {
147:         // on ne se connecte que lors du premier appel à une requete (lazy connexion)
148:         if ($this->connexion == null) {
149:             $this->connecter();
150:         }
151: 
152:         $retour = null;
153: 
154:         switch ($this->abstraction) {
155:             case 'pdo':
156:                 $retour = $this->connexion->query($requete);
157:                 break;
158:             case 'mysql':
159:                 $retour = mysql_query($requete,$this->connexion);
160:                 break;
161:             case 'mysqli':
162:                 $retour = $this->connexion->query($requete);
163:                 break;
164:             case 'sqlite3':
165:                 $retour = $this->connexion->exec($requete);
166:                 break;
167:         }
168: 
169:         return $retour;
170:     }
171: 
172:     final protected function requeteUn($requete,$mode = 'ASSOC') {
173:         // Connection seulement lors du premier appel à une requete (lazy connexion)
174:         if ($this->connexion == null) {
175:             $this->connecter();
176:         }
177: 
178:         $retour = null;
179:         switch ($this->abstraction) {
180:             case 'pdo':
181:                 try {
182:                     $res_req = $this->connexion->query($requete);
183:                     $retour = ($res_req !== false) ? $res_req->fetch($this->$mode) : $res_req;
184:                 } catch (PDOException $e) {
185:                     $message = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s';
186:                     trigger_error(sprintf($message, $e->getFile(), $e->getLine(), $e->getMessage()), E_USER_WARNING);
187:                 }
188:                 break;
189:             case 'mysql':
190:                 $res = mysql_query($requete,$this->connexion);
191:                 $fonction_fetch = $this->$mode;
192:                 $retour = $fonction_fetch($res);
193:                 break;
194:             case 'mysqli':
195:                 $res = $this->connexion->query($requete);
196:                 $fonction_fetch = $this->$mode;
197:                 $retour = $res->$fonction_fetch();
198:                 break;
199:             case 'sqlite3':
200:                 $retour = $this->connexion->querySingle($requete);
201:                 break;
202:         }
203: 
204:         return $retour;
205:     }
206: 
207: 
208:     final protected function requeteTous($requete,$mode = 'ASSOC') {
209:         // Connexion seulement lors du premier appel à une requete (lazy connexion)
210:         if ($this->connexion == null) {
211:             $this->connecter();
212:         }
213: 
214:         $retour = null;
215: 
216:         switch ($this->abstraction) {
217:             case 'pdo':
218:                 try {
219:                     $res_req = $this->connexion->query($requete);
220:                     if ($res_req !== false) {
221:                         $retour = $res_req->fetchAll($this->$mode);
222:                     } else {
223:                         $retour = false;
224:                     }
225:                 } catch (PDOException $e) {
226:                     $message = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s';
227:                     trigger_error(sprintf($message, $e->getFile(), $e->getLine(), $e->getMessage()), E_USER_WARNING);
228:                 }
229:                 break;
230:             case 'mysql':
231:                 $res = mysql_query($requete, $this->connexion);
232:                 $fonction_fetch = $this->$mode;
233:                 while ($ligne = $fonction_fetch($res)) {
234:                     $retour[] = $ligne;
235:                 }
236:                 break;
237:             case 'mysqli':
238:                 $res = $this->connexion->query($requete);
239:                 $function_fetch = $this->$mode;
240:                 while ($ligne = $res->$function_fetch()) {
241:                     $retour[] = $ligne;
242:                 }
243:                 break;
244:             case 'sqlite3':
245:                 $res = $this->connexion->query($requete);
246:                 while ($ligne = $res->fetch_array($this->ASSOC)) {
247:                     if ($mode == $this->ASSOC) {
248:                         $retour[] = $ligne;
249:                     } elseif ($mode == $this->OBJECT) {
250:                         // cas particulier de sqllite
251:                         // qui n'a pas de fonction fetch_object
252:                         $ligneObjet = new stdClass();
253:                         foreach ($ligne as $colonne => $valeur) {
254:                             $ligneObjet->$colonne = $valeur;
255:                         }
256:                         $retour[] = $ligneObjet;
257:                     }
258:                 }
259:                 break;
260:         }
261: 
262:         return $retour;
263:     }
264: 
265:     /**
266:      * protège une chaine de caractères avant l'insertion dans la base de données
267:      */
268:     final protected function proteger($chaine) {
269:         // on ne se connecte que lors du premier appel à une requete
270:         if ($this->connexion == null) {
271:             $this->connecter();
272:         }
273: 
274:         $retour = $chaine;
275:         switch ($this->abstraction) {
276:             case 'pdo':
277:                 $retour = $this->connexion->quote($chaine);
278:                 break;
279:             case 'mysql':
280:                 $retour = '"'.mysql_real_escape_string($chaine, $this->connexion).'"';
281:                 break;
282:             case 'mysqli':
283:                 $retour = '"'.$this->connexion->real_escape_string($chaine).'"';
284:                 break;
285:             case 'sqlite3':
286:                 $retour = $this->connexion->escapeString($chaine);
287:                 break;
288:         }
289:         return $retour;
290:     }
291: 
292:     /**
293:      * initialise les constantes de classe à leur bonne valeur
294:      * et lance une exception si le protocole n'est pas bien défini
295:      * @throws Exception
296:      */
297:     final public function initialiserProtocole() {
298: 
299:         switch ($this->abstraction) {
300:             case 'pdo':
301:                 $this->ASSOC = PDO::FETCH_ASSOC;
302:                 $this->OBJECT = PDO::FETCH_CLASS;
303:                 break;
304:             case 'mysql':
305:                 $this->ASSOC = 'mysql_fetch_assoc';
306:                 $this->OBJECT = 'mysql_fetch_object';
307:                 break;
308:             case 'mysqli':
309:                 $this->ASSOC = 'fetch_assoc';
310:                 $this->OBJECT = 'fetch_object';
311:                 break;
312:             case 'sqlite3':
313:                 $this->ASSOC = 'SQLITE3_ASSOC';
314:                 $this->OBJECT = 'SQLITE3_OBJECT';
315:                 break;
316:             default:
317:                 throw new Exception('Erreur : l\'abstraction '.$this->abstraction.' n\'est pas prise en charge');
318:                 break;
319:         }
320:     }
321: 
322:     /**
323:      * Destructeur de classe, se contente de fermer explicitement la connexion
324:      */
325:     final public function __destruct() {
326:         switch ($this->abstraction) {
327:             case 'pdo':
328:                 $this->connexion = null;
329:                 break;
330:             case 'mysql':
331:                 return mysql_close($this->connexion);
332:                 break;
333:             case 'mysqli':
334:                 $this->connexion->close();
335:                 break;
336:             case 'sqlite3':
337:                 $this->connexion->close();
338:                 break;
339:         }
340:     }
341: }
342: ?>