Subversion Repositories eFlore/Applications.cel

Rev

Rev 477 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
416 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
 * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
9
 * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
10
 * @version $Id$
11
 * @copyright © 2010, Jean-Pascal MILCENT
12
 */
13
abstract class Cel {
14
 
15
	public $config;
16
	protected $bdd;
17
	protected $messages = array();
18
	protected $debug = array();
19
 
20
	public function __construct($config) {
21
		// Tableau contenant la config de Jrest
22
		$this->config = $config;
23
 
24
		// Réglages de PHP
25
		setlocale(LC_ALL, $this->config['settings']['locale']);
26
		date_default_timezone_set($this->config['settings']['fuseauHoraire']);
27
 
28
		// Connection à la base de données
29
		$this->bdd = $this->connecterPDO($this->config, 'database_cel');
30
 
31
		// Nettoyage du _GET (sécurité)
32
		$this->recupererParametresUrl();
33
		$this->definirParametresUrlParDefaut();
34
 
35
		// Définition de variable générale dans la config
36
		$this->config['settings']['baseURLAbsoluDyn'] = 'http://'.$_SERVER['SERVER_NAME'].$this->config['settings']['baseURL'].'%s';
37
	}
38
 
39
	//+----------------------------------------------------------------------------------------------------------------+
40
	// GESTION de la BASE de DONNÉES
41
 
42
	private function connecterPDO($config, $base = 'database') {
43
        $cfg = $config[$base];
477 delphine 44
        // ATTENTION : la connexin à la bdd peut échouer si l'host vaut localhost. Utiliser 127.0.0.1 à la place.
416 aurelien 45
		$dsn = $cfg['phptype'].':dbname='.$cfg['database'].';host='.$cfg['hostspec'];
46
		try {
477 delphine 47
    		// Création de la connexion en UTF-8 à la BDD
48
			$PDO = new PDO($dsn, $cfg['username'], $cfg['password'], array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES 'UTF8'"));
416 aurelien 49
		} catch (PDOException $e) {
50
    		echo 'La connexion à la base de donnée via PDO a échouée : ' . $e->getMessage();
51
		}
52
		// Affiche les erreurs détectées par PDO (sinon mode silencieux => aucune erreur affiché)
53
		$PDO->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
54
        return $PDO;
55
	}
56
 
57
	protected function executerRequete($requete, $retour = 'All', $mode = PDO::FETCH_ASSOC) {
58
		try {
59
			switch ($retour) {
60
				case 'All' :
61
					$resultat = $this->bdd->query($requete)->fetchAll($mode);
62
					break;
63
				case 'Column' :
64
					$resultat = $this->bdd->query($requete)->fetchColumn();
65
					break;
66
				default:
67
					$resultat = false;
68
					$this->messages[] = "Le type de retour '$retour' est inconnu.";
69
			}
70
			if ($resultat === false) {
71
				$this->messages[] = "La requête a retourné aucun résultat.";
72
			}
73
		} catch (PDOException $e) {
74
			$this->messages[] = sprintf($this->getTxt('sql_erreur_requete'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
75
		}
76
		return $resultat;
77
	}
78
 
79
	protected function getTxt($id) {
80
		$sortie = '';
81
		switch ($id) {
82
			case 'sql_erreur' : $sortie = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s'; break;
83
			case 'sql_erreur_requete' : $sortie = "Requête echec.\nFichier : %s.\nLigne : %s.\nMessage : %s.\nRequête : %s"; break;
84
			default : $sortie = $id;
85
		}
86
		return $sortie;
87
	}
88
 
89
	//+----------------------------------------------------------------------------------------------------------------+
90
	// TRAITEMENT des URLs et des PARAMÊTRES
91
 
92
	private function recupererParametresUrl() {
93
		if (isset($_GET)) {
94
			$get_params = array('orderby', 'distinct', 'start', 'limit', 'formatRetour');
95
			foreach ($get_params as $get) {
96
				if (isset($_GET[$get])) {
97
					$verifier = array('NULL', "\n", "\r", "\\", "'", '"', "\x00", "\x1a", ';');
98
					$_GET[$get] = strip_tags(str_replace($verifier, '', $_GET[$get]));
99
					if ($_GET[$get] != '') {
100
						if (!isset($this->$get)) {
101
							$this->$get = $_GET[$get];
102
						} else {
103
							$e = "Impossible d'ajouter l'attribut $get à la classe du service car elle possède déjà un attribut nommé : $get";
104
							trigger_error($e, E_USER_WARNING);
105
						}
106
					} else {
107
						$_GET[$get] = null;
108
					}
109
				}
110
			}
111
		}
112
	}
113
 
114
	private function definirParametresUrlParDefaut() {
115
		if (!isset($this->start)) {
116
			$this->start = 0;
117
		}
118
		if (!isset($this->limit)) {
119
			$this->limit = 150;
120
		}
121
	}
122
 
123
	protected function traiterParametres($params_attendu, $params, $pourBDD = true) {
124
		$sortie = array();
125
		foreach ($params_attendu as $num => $nom) {
126
			if (isset($params[$num]) && $params[$num] != '*') {
127
				if ($pourBDD) {
128
					$params[$num] = $this->bdd->quote($params[$num]);
129
				}
130
				$sortie[$nom] = $params[$num];
131
			}
132
		}
133
		return $sortie;
134
	}
135
 
136
	protected function traiterNomMethodeGet($nom) {
137
		$methode = 'get';
138
		$methode .= str_replace(' ', '', ucwords(str_replace('-', ' ', strtolower($nom))));
139
		return $methode;
140
	}
141
 
142
	//+----------------------------------------------------------------------------------------------------------------+
143
	// GESTION de l'ENVOIE au NAVIGATEUR
144
 
145
	protected function envoyerJson($variable, $donnees = null, $encodage = 'utf-8') {
146
		$contenu = "var $variable = ".json_encode($donnees);
147
		$this->envoyer($contenu, 'text/html', $encodage);
148
	}
149
 
150
	protected function envoyer($donnees = null, $mime = 'text/html', $encodage = 'utf-8', $json = false) {
151
		// Traitements des messages d'erreurs et données
152
		if (count($this->messages) != 0) {
153
			header('HTTP/1.1 500 Internal Server Error');
154
			$mime = 'text/html';
155
			$encodage = 'utf-8';
156
			$json = true;
157
			$sortie = $this->messages;
158
		} else {
159
			$sortie = $donnees;
160
			if (is_null($donnees)) {
161
				$sortie = 'OK';
162
			}
163
		}
164
 
165
		// Gestion de l'envoie du déboguage
166
		$this->envoyerDebogage();
167
 
168
		// Encodage au format et JSON et envoie sur la sortie standard
169
		$contenu = $json ? json_encode($sortie) : $sortie;
170
		$this->envoyerContenu($encodage, $mime, $contenu);
171
	}
172
 
173
	private function envoyerDebogage() {
174
		if (!is_array($this->debug)) {
175
			$this->debug[] = $this->debug;
176
		}
177
		if (count($this->debug) != 0) {
178
			foreach ($this->debug as $cle => $val) {
179
				if (is_array($val)) {
180
					$this->debug[$cle] = print_r($val, true);
181
				}
182
			}
183
			header('X-DebugJrest-Data:'.json_encode($this->debug));
184
		}
185
	}
186
 
187
	private function envoyerContenu($encodage, $mime, $contenu) {
188
		if (!is_null($mime) && !is_null($encodage)) {
189
			header("Content-Type: $mime; charset=$encodage");
190
		} else if (!is_null($mime) && is_null($encodage)) {
191
			header("Content-Type: $mime");
192
		}
193
		print $contenu;
194
	}
195
 
196
	private function envoyerAuth($message_accueil, $message_echec) {
197
		header('HTTP/1.0 401 Unauthorized');
198
		header('WWW-Authenticate: Basic realm="'.mb_convert_encoding($message_accueil, 'ISO-8859-1', 'UTF-8').'"');
199
		header('Content-type: text/plain; charset=UTF-8');
200
		print $message_echec;
201
		exit(0);
202
	}
203
 
204
	//+----------------------------------------------------------------------------------------------------------------+
205
	// GESTION DU DAO
206
 
207
	protected function getDao() {
208
		if (isset($this->dao)) {
209
			return $this->dao;
210
		} else {
211
			$e = "Le DAO n'a pas été initialisé. Utiliser la méthode initialiserDao().";
212
			trigger_error($e, E_USER_WARNING);
213
		}
214
	}
215
 
216
	protected function initialiserDao($url_services_distant) {
217
		if (is_null($this->dao)) {
218
			$this->dao = new CelDao($url_services_distant);
219
		} else {
220
			$this->dao->url_jrest = $url_services_distant;
221
		}
222
	}
223
 
224
	//+----------------------------------------------------------------------------------------------------------------+
225
	// GESTION DE L'IDENTIFICATION
226
 
227
	public function authentifier() {
228
		$message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica.";
229
		$message_echec = "Accès limité aux administrateurs du CEL.\n".
230
			"Votre tentative d'identification a échouée.\n".
231
			"Actualiser la page pour essayer à nouveau.";
232
		if (!isset($_SERVER['PHP_AUTH_USER'])) {
233
			$this->envoyerAuth($message_accueil, $message_echec);
234
		} else {
235
			if ($this->etreAutorise($_SERVER['PHP_AUTH_USER']) == false) {
236
				$this->envoyerAuth($message_accueil, $message_echec);
237
			}
238
		}
239
		return true;
240
	}
241
 
242
	public function etreAutorise($identifiant) {
243
		$this->initialiserDao('http://www.tela-botanica.org/client/annuaire_nouveau/actuelle/jrest/');
244
		$mdp = md5($_SERVER['PHP_AUTH_PW']);
245
		$url = $this->getDao()->url_jrest."TestLoginMdp/$identifiant/$mdp";
246
		$json = $this->getDao()->envoyerRequeteConsultation($url);
247
		$existe = json_decode($json);
248
		$autorisation = false;
249
		if ($existe == true && $this->etreAdminCel($identifiant)) {
250
			$autorisation = true;
251
		}
252
		return $autorisation;
253
	}
254
 
255
	public function etreAdminCel($courriel) {
256
		$admins = $this->config['jrest_admin']['admin'];
257
		$courriels_autorises = explode(',', $admins);
258
 
259
		$autorisation = (in_array($courriel, $courriels_autorises)) ? true : false ;
260
		return $autorisation;
261
	}
262
 
263
	//+----------------------------------------------------------------------------------------------------------------+
264
	// GESTION DE MÉTHODES COMMUNES ENTRE LES SERVICES
265
 
266
	protected function encoderMotCle($mot_cle) {
267
		return md5(mb_strtolower($mot_cle));
268
	}
269
 
474 jpm 270
	protected function tronquerCourriel($courriel) {
271
		$courriel = preg_replace('/[^@]+$/i', '...', $courriel);
272
		return $courriel;
273
	}
274
 
488 jpm 275
	protected function nettoyerTableau(Array $tableau) {
474 jpm 276
		foreach ($tableau as $cle => $valeur) {
277
			if (is_array($valeur)) {
278
				$valeur = $this->nettoyerTableau($valeur);
279
			} else {
280
				$valeur = $this->nettoyerTexte($valeur);
281
			}
282
			$tableau[$cle] = $valeur;
283
		}
284
		return $tableau;
285
	}
286
 
287
	protected function nettoyerTexte($txt) {
288
		$txt = preg_replace('/&(?!(a-z+|#0-9+|#x0-9a-f+);)/i', '&amp;', $txt);
289
		$txt = preg_replace('/000null/i', '', $txt);
290
		return $txt;
291
	}
292
 
416 aurelien 293
	//+----------------------------------------------------------------------------------------------------------------+
294
	// GESTION DES SQUELETTES PHP
295
 
296
	/**
297
	 * Méthode prenant en paramètre un chemin de fichier squelette et un tableau associatif de données,
298
	 * en extrait les variables, charge le squelette et retourne le résultat des deux combinés.
299
	 *
300
	 * @param String $fichier	le chemin du fichier du squelette
301
	 * @param Array  $donnees	un tableau associatif contenant les variables a injecter dans le squelette.
302
	 *
303
	 * @return boolean false si le squelette n'existe pas, sinon la chaine résultat.
304
	 */
305
	public static function traiterSquelettePhp($fichier, Array $donnees = array()) {
306
		$sortie = false;
307
		if (file_exists($fichier)) {
308
			// Extraction des variables du tableau de données
309
			extract($donnees);
310
			// Démarage de la bufferisation de sortie
311
			ob_start();
312
			// Si les tags courts sont activés
313
			if ((bool) @ini_get('short_open_tag') === true) {
314
				// Simple inclusion du squelette
315
				include $fichier;
316
			} else {
317
				// Sinon, remplacement des tags courts par la syntaxe classique avec echo
318
				$html_et_code_php = self::traiterTagsCourts($fichier);
319
				// Pour évaluer du php mélangé dans du html il est nécessaire de fermer la balise php ouverte par eval
320
				$html_et_code_php = '?>'.$html_et_code_php;
321
				// Interprétation du html et du php dans le buffer
322
				echo eval($html_et_code_php);
323
			}
324
			// Récupèration du contenu du buffer
325
			$sortie = ob_get_contents();
326
			// Suppression du buffer
327
			@ob_end_clean();
328
		} else {
329
			$msg = "Le fichier du squelette '$fichier' n'existe pas.";
330
			trigger_error($msg, E_USER_WARNING);
331
		}
332
		// Retourne le contenu
333
		return $sortie;
334
	}
335
 
336
	/**
337
	 * Fonction chargeant le contenu du squelette et remplaçant les tags court php (<?= ...) par un tag long avec echo.
338
	 *
339
	 * @param String $chemin_squelette le chemin du fichier du squelette
340
	 *
341
	 * @return string le contenu du fichier du squelette php avec les tags courts remplacés.
342
	 */
343
	private static function traiterTagsCourts($chemin_squelette) {
344
		$contenu = file_get_contents($chemin_squelette);
345
		// Remplacement de tags courts par un tag long avec echo
346
		$contenu = str_replace('<?=', '<?php echo ',  $contenu);
347
		// Ajout systématique d'un point virgule avant la fermeture php
348
		$contenu = preg_replace("/;*\s*\?>/", "; ?>", $contenu);
349
		return $contenu;
350
	}
351
}