Subversion Repositories eFlore/Applications.del

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 aurelien 1
<?php
2
/**
3
 * Classe mère abstraite contenant les méthodes génériques des services.
4
 * Encodage en entrée : utf8
5
 * Encodage en sortie : utf8
6
 *
7
 * @author Jean-Pascal MILCENT <jpm@clapas.org>
8
 * @author AUrélien PERONNET <aurelien@tela-botanica.org>
9
 * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
10
 * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
11
 * @version $Id$
12
 * @copyright © 2010, Jean-Pascal MILCENT
13
 */
14
abstract class Del {
15
 
16
	const SQL_MODE_ASSOC = PDO::FETCH_ASSOC;
17
	const SQL_RETOUR_COMPLET = 'All';
18
	const SQL_RETOUR_LIGNE = 'Row';
19
	const SQL_RETOUR_COLONNE = 'Column';
20
	const SQL_RETOUR_BRUT = 'Raw';
21
 
22
	public $config;
23
	private $ressources;
24
	protected $parametres = array();
25
	protected $bdd;
26
	protected $messages = array();
27
	protected $debug = array();
28
 
29
	public function __construct($config) {
30
		// Tableau contenant la config de Jrest
31
		$this->config = $config;
32
 
33
		// Réglages de PHP
34
		setlocale(LC_ALL, $this->config['settings']['locale']);
35
		date_default_timezone_set($this->config['settings']['fuseauHoraire']);
36
 
37
		// Nettoyage du _GET (sécurité)
38
		$this->collecterParametres();// Récupération de tous les parametres de _GET, nettoyage et mise dans $this->parametres
39
		$this->recupererParametresUrl();// Vidage de _GET et création d'attribut de la classe
40
		$this->definirParametresUrlParDefaut();
41
 
42
		// Définition de variable générale dans la config
43
		$this->config['settings']['baseURLAbsoluDyn'] = 'http://'.$_SERVER['SERVER_NAME'].$this->config['settings']['baseURL'].'%s';
44
	}
45
 
46
	//+----------------------------------------------------------------------------------------------------------------+
47
	// GESTION de la BASE de DONNÉES
48
	private function connecterPDOSiNecessaire() {
49
		if($this->bdd == null) {
50
			// Connection à la base de données
51
			$this->bdd = $this->connecterPDO($this->config, 'database');
52
		}
53
	}
54
 
55
	private function connecterPDO($config, $base = 'database') {
56
        $cfg = $config[$base];
57
        // ATTENTION : la connexin à la bdd peut échouer si l'host vaut localhost. Utiliser 127.0.0.1 à la place.
58
		$dsn = $cfg['phptype'].':dbname='.$cfg['database'].';host='.$cfg['hostspec'];
59
		try {
60
    		// Création de la connexion en UTF-8 à la BDD
61
			$PDO = new PDO($dsn, $cfg['username'], $cfg['password'], array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES 'UTF8'"));
62
			// Affiche les erreurs détectées par PDO (sinon mode silencieux => aucune erreur affiché)
63
			$PDO->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
64
		} catch (PDOException $e) {
65
    		echo 'La connexion à la base de donnée via PDO a échouée : ' .$dsn. $e->getMessage();
66
		}
67
        return $PDO;
68
	}
69
 
70
	/**
71
	 * Protège automatiquement toutes les chaines comprises entre deux caractères '|'.
72
	 * Puis execute la requete.
73
	 * @see protegerRequete()
74
	 * @param unknown_type $requete
75
	 */
76
	protected function requeter($requete, $retour = self::SQL_RETOUR_COMPLET, $mode = PDO::FETCH_ASSOC) {
77
		$requete = $this->protegerRequete($requete);
78
		return $this->executerRequete($requete, $retour, $mode);
79
	}
80
 
81
	/**
82
	 * Protège automatiquement toutes les chaines comprises entre deux caractères '|'.
83
	 * @see protegerRequete()
84
	 * @param unknown_type $requete
85
	 */
86
	protected function executer($requete) {
87
		$requete = $this->protegerRequete($requete);
88
		return $this->executerRequeteSimple($requete);
89
	}
90
 
91
	/**
92
	 * Méthode permettant de rechercher dans une requete SQL sous forme de chaine (String) les chaines
93
	 * à protéger. Cela évite de protéger chaque variable avant de l'insérer dans une requete SQL.
94
	 * Par contre, il est important que les chaine à protéger ne contiennent pas le caractère '|'.
95
	 *
96
	 * @param $requete
97
	 */
98
	protected function protegerRequete($requete) {
99
 
100
		$this->connecterPDOSiNecessaire();
101
 
102
		if (substr_count($requete, '|') % 2 === 0) {
103
			if (preg_match_all('/\|([^|]*)\|/', $requete, $correspondances, PREG_SET_ORDER)) {
104
				foreach ($correspondances as $chaine) {
105
					$chaine_protegee = $this->bdd->quote($chaine[1]);
106
					$requete = str_replace($chaine[0], $chaine_protegee, $requete);
107
				}
108
			}
109
		} else {
110
			$this->messages[] = "La requête a protéger contient un nombre impair de caractère de protection '|'.";
111
			$requete = false;
112
		}
113
		return $requete;
114
	}
115
 
116
	protected function proteger($chaine) {
117
		$this->connecterPDOSiNecessaire();
118
		return $this->bdd->quote($chaine);
119
	}
120
 
121
	protected function protegerTableau(Array $tableau) {
122
		foreach ($tableau as $id => $val) {
123
			$tableau[$id] = $this->proteger($val);
124
		}
125
		return $tableau;
126
	}
127
 
128
	/**
129
	 * @deprecated utiliser executer() à la place
130
	 * @see executer()
131
	 */
132
	protected function executerRequeteSimple($requete) {
133
		$this->connecterPDOSiNecessaire();
134
		$resultat = false;
135
		try {
136
			$resultat = $this->bdd->exec($requete);
137
			if ($resultat === false) {
138
				$this->debug[] = "La requête a échoué : $requete";
139
			}
140
		} catch (PDOException $e) {
141
			$this->debug[] = sprintf($this->getTxt('sql_erreur_requete'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
142
		}
143
		return $resultat;
144
	}
145
 
146
	/**
147
	 * @deprecated utiliser requeter() à la place
148
	 * @see requeter()
149
	 */
150
	protected function executerRequete($requete, $retour = self::SQL_RETOUR_COMPLET, $mode = PDO::FETCH_ASSOC) {
151
		$this->connecterPDOSiNecessaire();
152
		$resultat = false;
153
		try {
154
			switch ($retour) {
155
				case self::SQL_RETOUR_COMPLET :
156
					$resultat = $this->bdd->query($requete)->fetchAll($mode);// Retourne toutes les lignes
157
					break;
158
				case self::SQL_RETOUR_LIGNE :
159
					$resultat = $this->bdd->query($requete)->fetch($mode);// Retourne la première ligne
160
					break;
161
				case self::SQL_RETOUR_COLONNE :
162
					$resultat = $this->bdd->query($requete)->fetchColumn();// Retourne la première colonne de la première ligne
163
					break;
164
				case self::SQL_RETOUR_BRUT :
165
					$resultat = $this->bdd->query($requete);// Retourne l'objet brut pour être utilisé dans une boucle de type foreach
166
					break;
167
				default:
168
					$this->debug[] = "Le type de retour '$retour' est inconnu.";
169
			}
170
			if ($resultat === false) {
171
				$this->debug[] = "La requête a retourné aucun résultat : $requete";
172
			}
173
		} catch (PDOException $e) {
174
			$this->debug[] = sprintf($this->getTxt('sql_erreur_requete'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
175
		}
176
		return $resultat;
177
	}
178
 
179
	protected function getTxt($id) {
180
		$sortie = '';
181
		switch ($id) {
182
			case 'sql_erreur' : $sortie = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s'; break;
183
			case 'sql_erreur_requete' : $sortie = "Requête echec.\nFichier : %s.\nLigne : %s.\nMessage : %s.\nRequête : %s"; break;
184
			default : $sortie = $id;
185
		}
186
		return $sortie;
187
	}
188
 
189
	//+----------------------------------------------------------------------------------------------------------------+
190
	// TRAITEMENT des URLs et des PARAMÊTRES
191
 
192
	private function collecterParametres() {
193
		if (isset($_GET) && $_GET != '') {
194
			foreach ($_GET as $cle => $valeur) {
195
				$this->parametres[$cle] = $this->verifierSecuriteParametreUrl($valeur);
196
			}
197
		}
198
	}
199
 
200
	private function recupererParametresUrl() {
201
		if (isset($_GET)) {
202
			$get_params = array('orderby', 'distinct', 'start', 'limit', 'formatRetour');
203
			foreach ($get_params as $get) {
204
				if (isset($_GET[$get])) {
205
					$_GET[$get] = $this->verifierSecuriteParametreUrl($_GET[$get]);
206
					if ($_GET[$get] != '') {
207
						if (!isset($this->$get)) {
208
							$this->$get = $_GET[$get];
209
						} else {
210
							$e = "Impossible d'ajouter l'attribut $get à la classe du service car elle possède déjà un attribut nommé : $get";
211
							trigger_error($e, E_USER_WARNING);
212
						}
213
					} else {
214
						$_GET[$get] = null;
215
					}
216
				}
217
			}
218
		}
219
	}
220
 
221
	protected function verifierSecuriteParametreUrl($param) {
222
		$verifier = array('NULL', "\n", "\r", "\\", "'", '"', "\x00", "\x1a", ';');
223
		$param = strip_tags(str_replace($verifier, '', $param));
224
		return $param;
225
	}
226
 
227
	private function definirParametresUrlParDefaut() {
228
		if (!isset($this->start)) {
229
			$this->start = 0;
230
		}
231
		if (!isset($this->limit)) {
232
			$this->limit = 150;
233
		}
234
	}
235
 
236
	protected function traiterParametres($params_attendu, $params, $pourBDD = true) {
237
		$sortie = array();
238
		foreach ($params_attendu as $num => $nom) {
239
			if (isset($params[$num]) && $params[$num] != '*') {
240
				if ($pourBDD) {
241
					$params[$num] = $this->bdd->quote($params[$num]);
242
				}
243
				$sortie[$nom] = $params[$num];
244
			}
245
		}
246
		return $sortie;
247
	}
248
 
249
	protected function traiterNomMethodeGet($nom) {
250
		$methode = 'get';
251
		$methode .= str_replace(' ', '', ucwords(str_replace('-', ' ', strtolower($nom))));
252
		return $methode;
253
	}
254
 
255
	//+----------------------------------------------------------------------------------------------------------------+
256
	// GESTION de l'ENVOI au NAVIGATEUR
257
 
258
	protected function envoyerJson($donnees, $encodage = 'utf-8') {
259
		$encodage_json = true;
260
		$this->envoyer($donnees, 'application/json', $encodage, $encodage_json);
261
	}
262
 
263
	protected function envoyerJsonVar($variable, $donnees = null, $encodage = 'utf-8') {
264
		$contenu = "var $variable = ".json_encode($donnees);
265
		$this->envoyer($contenu, 'text/html', $encodage);
266
	}
267
 
268
	protected function envoyerJsonp($donnees = null, $encodage = 'utf-8') {
269
		$contenu = $this->parametres['callback'].'('.json_encode($donnees).');';
270
		$this->envoyer($contenu, 'text/html', $encodage);
271
	}
272
 
273
	protected function envoyer($donnees = null, $mime = 'text/html', $encodage = 'utf-8', $json = false) {
274
		// Traitements des messages d'erreurs et données
275
		if (count($this->messages) != 0) {
276
			header('HTTP/1.1 500 Internal Server Error');
277
			$json = true;
278
			$sortie = $this->messages;
279
		} else {
280
			$sortie = $donnees;
281
			if (is_null($donnees)) {
282
				$sortie = 'OK';
283
			}
284
		}
285
		// Gestion de l'envoie du déboguage
286
		$this->envoyerDebogage();
287
 
288
		// Encodage au format et JSON et envoie sur la sortie standard
289
		$contenu = $json ? json_encode($sortie) : $sortie;
290
		$this->envoyerContenu($encodage, $mime, $contenu);
291
	}
292
 
293
	private function envoyerDebogage() {
294
		if (!is_array($this->debug)) {
295
			$this->debug[] = $this->debug;
296
		}
297
		if (count($this->debug) != 0) {
298
			foreach ($this->debug as $cle => $val) {
299
				if (is_array($val)) {
300
					$this->debug[$cle] = print_r($val, true);
301
				}
302
			}
303
			header('X-DebugJrest-Data:'.json_encode($this->debug));
304
		}
305
	}
306
 
307
	private function envoyerContenu($encodage, $mime, $contenu) {
308
		if (!is_null($mime) && !is_null($encodage)) {
309
			header("Content-Type: $mime; charset=$encodage");
310
		} else if (!is_null($mime) && is_null($encodage)) {
311
			header("Content-Type: $mime");
312
		}
313
		print $contenu;
314
	}
315
 
316
	private function envoyerAuth($message_accueil, $message_echec) {
317
		header('HTTP/1.0 401 Unauthorized');
318
		header('WWW-Authenticate: Basic realm="'.mb_convert_encoding($message_accueil, 'ISO-8859-1', 'UTF-8').'"');
319
		header('Content-type: text/plain; charset=UTF-8');
320
		print $message_echec;
321
		exit(0);
322
	}
323
 
324
	//+----------------------------------------------------------------------------------------------------------------+
325
	// GESTION DU DAO
326
 
327
	protected function getDao() {
328
		if (isset($this->dao)) {
329
			return $this->dao;
330
		} else {
331
			$e = "Le DAO n'a pas été initialisé. Utiliser la méthode initialiserDao().";
332
			trigger_error($e, E_USER_WARNING);
333
		}
334
	}
335
 
336
	protected function initialiserDao($url_services_distant) {
337
		if (!isset($this->dao)) {
338
			$this->dao = new Dao($url_services_distant);
339
		} else {
340
			$this->dao->url_jrest = $url_services_distant;
341
		}
342
	}
343
 
344
	//+----------------------------------------------------------------------------------------------------------------+
345
	// GESTION DU LOG
346
 
347
	public function logger($index,$chaine) {
348
 
349
		Log::getInstance();
350
 
351
		Log::setCheminLog($this->config['log']['cheminlog']);
352
		Log::setTimeZone($this->config['log']['timezone']);
353
		Log::setTailleMax($this->config['log']['taillemax']);
354
 
355
		Log::ajouterEntree($index,$chaine);
356
	}
357
 
358
	//+----------------------------------------------------------------------------------------------------------------+
359
	// GESTION DE MÉTHODES COMMUNES ENTRE LES SERVICES
360
 
361
	protected function nettoyerTableau(Array $tableau) {
362
		foreach ($tableau as $cle => $valeur) {
363
			if (is_array($valeur)) {
364
				$valeur = $this->nettoyerTableau($valeur);
365
			} else {
366
				$valeur = $this->nettoyerTexte($valeur);
367
			}
368
			$tableau[$cle] = $valeur;
369
		}
370
		return $tableau;
371
	}
372
 
373
	/**
374
	 * Fonction nettoyant les caractères spéciaux (&,<) et les valeurs nulles du CEL dans un texte comprenant du HTML.
375
	 */
376
	protected function nettoyerTexte($txt) {
377
		$txt = preg_replace('/&(?!([a-z]+|#[0-9]+|#x[0-9][a-f]+);)/i', '&amp;', $txt);
378
		// TODO : trouver une regexp qui permet de remplacer les symboles < et > isolés
379
		//$txt = preg_replace('/<(?!([a-z][a-z0-9]*)\b[^>]*>(.*?)<\/\1>|\/\s*([a-z][a-z0-9]*)\s*>)/i', '&lt;', $txt);
380
		//$txt = preg_replace('/(?!<([a-z][a-z0-9]*)\b[^>]*)>(?!(.*?)<\/\1>)/i', '&gt;', $txt);
381
		$txt = preg_replace('/(?:000null|null)/i', '', $txt);
382
		return $txt;
383
	}
384
 
385
	protected function convertirDateHeureMysqlEnTimestamp($date_heure_mysql){
386
       $val = explode(' ', $date_heure_mysql);
387
       $date = explode('-', $val[0]);
388
       $heure = explode(':', $val[1]);
389
       return mktime((int) $heure[0], (int) $heure[1], (int) $heure[2], (int) $date[1], (int) $date[2], (int) $date[0]);
390
	}
391
 
540 aurelien 392
	protected function formaterChaineMinusculeSansAccents($chaine) {
393
		$chaine = $this->supprimerAccents($chaine);
394
		$chaine = str_replace(' ','_',$chaine);
395
		$chaine = str_replace('-','_',$chaine);
396
 
397
		return mb_strtolower($chaine);
398
	}
399
 
400
	protected function supprimerAccents($str, $charset='utf-8') {
401
		$str = htmlentities($str, ENT_NOQUOTES, $charset);
402
 
403
		$str = preg_replace('#&([A-za-z])(?:acute|cedil|circ|grave|orn|ring|slash|th|tilde|uml);#', '\1', $str);
404
		$str = preg_replace('#&([A-za-z]{2})(?:lig);#', '\1', $str); // pour les ligatures e.g. '&oelig;'
405
		$str = preg_replace('#&[^;]+;#', '', $str); // supprime les autres caractères
406
 
407
		return $str;
408
	}
409
 
1 aurelien 410
	protected function etreNull($valeur) {
411
		$etre_null = false;
412
		if ($valeur == '' || $valeur == null || $valeur == '000null' || $valeur == 'null' || $valeur == '*') {
413
			$etre_null = true;
414
		}
415
		return $etre_null;
416
	}
417
 
418
	protected function formaterDate($date_heure_mysql, $format = '%A %d %B %Y à %H:%M') {
419
		$date_formatee = '';
420
		if (!$this->etreNull($date_heure_mysql)) {
421
			$timestamp = $this->convertirDateHeureMysqlEnTimestamp($date_heure_mysql);
422
			$date_formatee = strftime($format, $timestamp);
423
		}
424
		return $date_formatee;
425
	}
426
 
427
	protected function traiterValeursMultiples($valeurs, $separateur_entree = ',' , $separateur_sortie = ',') {
428
		if (! $this->etreNull($valeurs)) {
429
			$valeurs_a_proteger = explode($separateur_entree,trim(trim($valeurs), $separateur_entree));
430
			foreach ($valeurs_a_proteger as $valeur) {
431
				$valeurs_protegees[] = $this->bdd->quote($valeur);
432
			}
433
			$valeurs = implode($separateur_sortie, $valeurs_protegees);
434
		}
435
		return ($this->etreNull($valeurs)) ? null : $valeurs;
436
	}
437
 
438
	//+----------------------------------------------------------------------------------------------------------------+
439
	// GESTION DES SQUELETTES PHP
440
 
441
	/**
442
	 * Méthode prenant en paramètre un chemin de fichier squelette et un tableau associatif de données,
443
	 * en extrait les variables, charge le squelette et retourne le résultat des deux combinés.
444
	 *
445
	 * @param String $fichier	le chemin du fichier du squelette
446
	 * @param Array  $donnees	un tableau associatif contenant les variables a injecter dans le squelette.
447
	 *
448
	 * @return boolean false si le squelette n'existe pas, sinon la chaine résultat.
449
	 */
450
	public static function traiterSquelettePhp($fichier, Array $donnees = array()) {
451
		$sortie = false;
452
		if (file_exists($fichier)) {
453
			// Extraction des variables du tableau de données
454
			extract($donnees);
455
			// Démarage de la bufferisation de sortie
456
			ob_start();
457
			// Si les tags courts sont activés
458
			if ((bool) @ini_get('short_open_tag') === true) {
459
				// Simple inclusion du squelette
460
				include $fichier;
461
			} else {
462
				// Sinon, remplacement des tags courts par la syntaxe classique avec echo
463
				$html_et_code_php = self::traiterTagsCourts($fichier);
464
				// Pour évaluer du php mélangé dans du html il est nécessaire de fermer la balise php ouverte par eval
465
				$html_et_code_php = '?>'.$html_et_code_php;
466
				// Interprétation du html et du php dans le buffer
467
				echo eval($html_et_code_php);
468
			}
469
			// Récupèration du contenu du buffer
470
			$sortie = ob_get_contents();
471
			// Suppression du buffer
472
			@ob_end_clean();
473
		} else {
474
			$msg = "Le fichier du squelette '$fichier' n'existe pas.";
475
			trigger_error($msg, E_USER_WARNING);
476
		}
477
		// Retourne le contenu
478
		return $sortie;
479
	}
480
 
481
	/**
482
	 * Fonction chargeant le contenu du squelette et remplaçant les tags court php (<?= ...) par un tag long avec echo.
483
	 *
484
	 * @param String $chemin_squelette le chemin du fichier du squelette
485
	 *
486
	 * @return string le contenu du fichier du squelette php avec les tags courts remplacés.
487
	 */
488
	private static function traiterTagsCourts($chemin_squelette) {
489
		$contenu = file_get_contents($chemin_squelette);
490
		// Remplacement de tags courts par un tag long avec echo
491
		$contenu = str_replace('<?=', '<?php echo ',  $contenu);
492
		// Ajout systématique d'un point virgule avant la fermeture php
493
		$contenu = preg_replace("/;*\s*\?>/", "; ?>", $contenu);
494
		return $contenu;
495
	}
496
}
497
?>