Subversion Repositories eFlore/Applications.coel

Rev

Rev 1508 | Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1497 jpm 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@tela-botanica.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 2009
12
 */
13
abstract class Coel {
14
 
15
	const ETAT_AJOUTER = 1;
16
	const ETAT_MODIFIER = 2;
17
	const ETAT_SUPPRIMER = 3;
18
 
19
	protected $sessionName = 'CoelSession';
20
	protected $sessionExpireTime = 8640000;// 60*60*24*100 = 100 jours
21
	protected static $cookieChemin = '';
22
	public $config;
23
	protected $bdd;
24
	protected $log = array();
25
	protected $messages = array();
26
	protected $debug = array();
27
	protected $distinct = false;
28
	protected $orderby = null;
29
	protected $formatRetour = 'objet';
30
	protected $start = 0;
31
	protected $limit = 150;
32
 
33
	public function __construct($config, $demarrer_session = true) {
34
		// Tableau contenant la config de Jrest
35
		$this->config = $config;
36
 
37
		// Connection à la base de données
38
		$this->bdd = $this->connecterPDO($this->config, 'coel');
39
 
40
		$this->gererSession($demarrer_session);
41
		$this->gererIdentificationPermanente();
42
 
43
		// Nettoyage du $_GET (sécurité)
44
		if (isset($_GET)) {
45
			$get_params = array('orderby', 'distinct', 'start', 'limit', 'formatRetour');
46
			foreach ($get_params as $get) {
47
				$verifier = array('NULL', "\n", "\r", "\\", "'", '"', "\x00", "\x1a", ';');
48
				$_GET[$get] = str_replace($verifier, '', $_GET[$get]);
49
				if (isset($_GET[$get]) && $_GET[$get] != '') {
50
					$this->$get = $_GET[$get];
51
				} else {
52
					$_GET[$get] = null;
53
				}
54
			}
55
		}
56
	}
57
 
58
	/**
59
	 * Méthode appelée quand aucun paramètre n'est passé dans l'url et avec une requête de type GET.
60
	 */
61
	public function getRessource() {
62
		$this->getElement(array());
63
	}
64
 
65
 
66
	protected function creerXmlHisto($donnees) {
67
		// Création du xml de l'enregistrement à historiser
68
		$info = null;
69
		$xml_tpl = '<?xml version="1.0" encoding="UTF-8" ?>'."\n<resultset>\n<row>\n%s</row>\n</resultset>";
70
		$xml = null;
71
 
72
		foreach ($donnees as $cle => $valeur) {
73
			if (!is_null($valeur) && $valeur != '') {
74
				$xml .= "<$cle>$valeur</$cle>\n";
75
			}
76
		}
77
		if ($xml !== null) {
78
			$info = sprintf($xml_tpl, $xml);
79
			$info = $this->bdd->quote($info);
80
		}
81
 
82
		return $info;
83
	}
84
 
85
	protected function getTableauDepuisXmlHisto($xml) {
86
		// Création du xml de l'enregistrement à historiser
87
		$info = array();
88
 
89
		if (!empty($xml) && preg_match_all('|<([^>]+)>(.*)</[^>]+>|U', $xml, $matches, PREG_SET_ORDER)) {
90
			foreach ($matches as $val) {
91
				$info[$val[1]] = $val[2];
92
			}
93
		}
94
 
95
		return $info;
96
	}
97
 
98
	protected function historiser($table_id, $ligne_cle, $info, $id_utilisateur, $etat, $id_session) {
99
		// Pré-traitement des variables
100
		$info = (is_null($info)) ? 'NULL' : $info;
101
 
102
		// Historisation (Ajout des méta-données)
103
		$requete = 	'INSERT INTO coel_meta_historique_ligne '.
104
					'	(cmhl_ce_table, cmhl_cle_ligne, cmhl_enregistrement, cmhl_date_modification, cmhl_ce_modifier_par, cmhl_ce_etat, cmhl_ip, cmhl_session_id) '.
105
					'VALUES ('.
106
					"		$table_id, ".
107
					'		"'.$ligne_cle.'", '.
108
					"		$info, ".
109
 					'		"'.date('Y-m-d H:i:s', time()).'", '.
110
					"		$id_utilisateur, ".
111
					"		$etat, ".
112
					'		"'.$_SERVER['REMOTE_ADDR'].'", '.
113
					'		"'.$id_session.'") ';
114
 
115
   		// Exécution de la requêtre SQL et test d'éventuelles erreurs
116
		$resultat = $this->bdd->exec($requete);
117
		if ($resultat === false ) {
118
			$this->log[] = "Des données de la table '$table_id' (enrg. $ligne_cle) n'ont pas été historisées car la requête a échouée.";
119
		}
120
		return $this->bdd->lastInsertId();
121
	}
122
 
123
	protected function envoyer($donnees = null, $mime = 'text/html', $encodage = 'utf-8', $json = true) {
124
		// Traitements des messages d'erreurs et données
125
		if (count($this->messages) != 0) {
126
			header('HTTP/1.1 500 Internal Server Error');
127
			$mime = 'text/html';
128
			$encodage = 'utf-8';
129
			$json = true;
130
			$sortie = $this->messages;
131
		} else {
132
			$sortie = $donnees;
133
			if (is_null($donnees)) {
134
				$sortie = 'OK';
135
			}
136
		}
137
 
138
		// Gestion de l'envoie du déboguage
139
		$this->envoyerDebogage();
140
 
141
		// Encodage au format et JSON et envoie sur la sortie standard
142
		$contenu = $json ? json_encode($sortie) : $sortie;
143
		$this->envoyerContenu($encodage, $mime, $contenu);
144
	}
145
 
146
	protected function envoyerDebogage() {
147
		if (!is_array($this->debug)) {
148
			$this->debug[] = $this->debug;
149
		}
150
		if (count($this->debug) != 0) {
151
			foreach ($this->debug as $cle => $val) {
152
				if (is_array($val)) {
153
					$this->debug[$cle] = print_r($val, true);
154
				}
155
			}
156
			header('X-DebugJrest-Data:'.json_encode($this->debug));
157
		}
158
	}
159
 
160
	protected function envoyerContenu($encodage, $mime, $contenu) {
161
		header("Content-Type: $mime; charset=$encodage");
162
		print $contenu;
163
	}
164
 
165
	private function connecterPDO($config, $base = 'database') {
166
        $cfg = $config[$base];
167
		$dsn = $cfg['phptype'].':dbname='.$cfg['database'].';host='.$cfg['hostspec'];
168
		try {
169
    		$PDO = new PDO($dsn, $cfg['username'], $cfg['password']);
170
		} catch (PDOException $e) {
171
    		echo 'La connexion à la base de donnée via PDO a échouée : ' . $e->getMessage();
172
		}
173
		// Passe en UTF-8 la connexion à la BDD
174
		$PDO->exec("SET NAMES 'utf8'");
175
		// Affiche les erreurs détectées par PDO (sinon mode silencieux => aucune erreur affiché)
176
		$PDO->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
177
        return $PDO;
178
	}
179
 
180
	protected function getTxt($id) {
181
		$sortie = '';
182
		switch ($id) {
183
			case 'sql_erreur' : $sortie = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s'; break;
184
			default : $sortie = $id;
185
		}
186
		return $sortie;
187
	}
188
 
189
	protected function concatenerChamps($champs, $prefixe = null) {
190
		$chaine = '';
191
		foreach ($champs as $cle => $valeur) {
192
			if (is_null($prefixe) || (!is_null($prefixe) && stristr($cle, $prefixe.'_'))) {
193
				$chaine .= ", $cle = $valeur";
194
			}
195
		}
196
		return ltrim($chaine, ', ');
197
	}
198
 
199
	protected function separerChampsValeurs($donnees, $prefixe = null) {
200
		$sortie = array('', '');
201
		// Concaténation des champs et des valeurs dans des chaines séparées
202
		foreach ($donnees as $cle => $valeur) {
203
			if (is_null($prefixe) || (!is_null($prefixe) && stristr($cle, $prefixe.'_'))) {
204
				$sortie[0] .= "$cle, ";
205
				$sortie[1] .= "$valeur, ";
206
			}
207
		}
208
		// Suppression de la virgule finale
209
		$sortie[0] = rtrim($sortie[0], ', ');
210
		$sortie[1] = rtrim($sortie[1], ', ');
211
		return $sortie;
212
	}
213
 
214
 
215
	protected function traiterParametresUrl($params_attendu, $params, $pourBDD = true) {
216
		$sortie = array();
217
		foreach ($params_attendu as $num => $nom) {
218
			if (isset($params[$num]) && $params[$num] != '*') {
219
				if ($pourBDD) {
220
					$params[$num] = $this->bdd->quote($params[$num]);
221
				}
222
				$sortie[$nom] = $params[$num];
223
			}
224
		}
225
		return $sortie;
226
	}
227
 
228
	protected function traiterBddClauseIn($chaine) {
229
		$sortie = '';
230
		$chaine = trim($chaine, " '");
231
		if ($chaine != '') {
232
			$valeurs = explode(',', $chaine);
233
			foreach ($valeurs as $id => $valeur) {
234
				$valeurs[$id] = $this->bdd->quote($valeur);
235
			}
236
			$sortie = implode(',', $valeurs);
237
		}
238
		return $sortie;
239
	}
240
 
241
	protected function traiterParametresPost($params) {
242
		$sortie = array();
243
		foreach ($params as $cle => $valeur) {
244
			$sortie[$cle] = $this->bdd->quote($valeur);
245
		}
246
		return $sortie;
247
	}
248
 
249
	protected function getIdentification(&$params) {
250
		// Initialisation des variables
251
		$utilisateur = array(0, session_id());
252
 
253
		// L'id utilisateur est soit passé par le POST soit dans l'url
254
		if (is_array($params) && isset($params['cmhl_ce_modifier_par'])) {
255
		   	$utilisateur[0] = $params['cmhl_ce_modifier_par'];
256
			unset($params['cmhl_ce_modifier_par']);
257
		} else if (is_string($params)) {
258
			$utilisateur[0] = $params;
259
		}
260
 
261
		return $utilisateur;
262
	}
263
 
264
	protected function etreAutorise($id_utilisateur) {
265
		$autorisation = false;
266
		if (($_SESSION['coel_utilisateur'] != '') && $_SESSION['coel_utilisateur']['id'] != $id_utilisateur) {
267
			$this->messages[] = 'Accès interdit.';
268
		} else if ($_SESSION['coel_utilisateur'] == '') {
269
			$this->messages[] = 'Veuillez vous identifiez pour accéder à cette fonction.';
270
		} else {
271
			$autorisation = true;
272
		}
273
		return $autorisation;
274
	}
275
 
276
	protected function recupererCle($table) {
277
		$cle = null;
278
		if (isset($table['champs_valeurs_id'])) {
279
			$identifiants = array();
280
			// Trie des clés primaire pour avoir toujours le même ordre dans la table historique pour les clés multiples
281
			ksort($table['champs_valeurs_id']);
282
		   	foreach ($table['champs_valeurs_id'] as $id) {
283
		   		$identifiants[] = $id;
284
		   	}
285
		   	$cle = implode('-', $identifiants);
286
		}
287
		return $cle;
288
	}
289
 
290
	protected function avoirCleComplete($table) {
291
		$cle_complete = false;
292
		if (isset($table['champs_valeurs_id'])) {
293
		   	$ok = true;
294
			foreach ($table['id'] as $id) {
295
		   		if (!isset($table['champs_valeurs_id'][$id]) || $table['champs_valeurs_id'][$id] == '') {
296
		   			$ok = false;
297
		   			break;
298
		   		}
299
		   	}
300
		   	$cle_complete = $ok;
301
		}
302
		return $cle_complete;
303
	}
304
 
305
	protected function recupererEtat($table) {
306
		$etat = 1;// Ajout
307
		if ($this->avoirEnregistrement($table) === true) {
308
			$etat = 2;// Modification
309
		}
310
		return $etat;
311
	}
312
 
313
	protected function avoirEnregistrement($table) {
314
		$avoir_enregistrement = false;
315
   		$requete = 	'SELECT * '.
316
					"FROM {$table['nom']} ".
317
					"WHERE %s ";
318
 
319
   		$where = $this->construireWhere($table['champs_valeurs_id']);
320
   		$requete = sprintf($requete, $where);
321
 
322
	   	// Exécution de la requêtre SQL et test d'éventuelles erreurs
323
		$resultat = $this->bdd->query($requete, PDO::FETCH_ASSOC)->fetch();
324
 
325
		if ($resultat !== false) {
326
			$avoir_enregistrement = true;
327
		}
328
		return $avoir_enregistrement;
329
	}
330
 
331
	protected function construireWhere($table) {
332
		$where = '1';
333
	   	if (is_array($table) && count($table) > 0) {
334
			$table_where = array();
335
	   		foreach ($table as $chp => $id) {
336
	   			$table_where[] = "$chp = '$id'";
337
	   		}
338
	   		$where = implode(' AND ', $table_where);
339
	   	}
340
	   	return $where;
341
	}
342
 
343
	protected function recupererTablesAModifier($parametres) {
344
		$tables_a_modifier = $this->tables;
345
   		foreach ($this->tables as $table_id => $table) {
346
   			$tables_a_modifier[$table_id]['champs'] = null;
347
   			foreach ($parametres as $cle => $valeur) {
348
   				if (preg_match('/^'.$table['prefixe'].'_/', $cle)) {
349
   					// Contient les noms des champs seulements
350
   					$tables_a_modifier[$table_id]['champs'][] = $cle;
351
   					// Contient un tableau de résultats protégé pour l'inclusion en bdd
352
   					$tables_a_modifier[$table_id]['champs_valeurs_protege'][$cle] = $this->bdd->quote($valeur);
353
   					// Contient un tableau de résultats non protégé
354
   					$tables_a_modifier[$table_id]['champs_valeurs_brut'][$cle] = $valeur;
355
   					if (preg_match('/_id_/', $cle)) {
356
   						$tables_a_modifier[$table_id]['champs_valeurs_id'][$cle] = $valeur;
357
   					}
358
   				}
359
   			}
360
   		}
361
   		return $tables_a_modifier;
362
	}
363
 
364
 
365
	protected function mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table) {
366
		if (!is_null($table['champs'])) {
367
	   		// Historisation (Ajout des méta-données)
368
	   		$cle = $this->recupererCle($table);
369
	   		$etat = $this->recupererEtat($table);
370
	   		$info = $this->creerXmlHisto($table['champs_valeurs_brut']);
371
			$id_meta = $this->historiser($table_id, $cle, $info, $id_utilisateur, $etat, $id_session);
372
			$champ_meta = "{$table['prefixe']}_ce_meta";
373
			$table['champs_valeurs_protege'][$champ_meta] = $this->bdd->quote($id_meta);
374
 
375
			// Mise à jour des données ou ajout en fonction de l'état
376
			if ($etat == 1) { // Ajout
377
				$this->ajouter($table);
378
			} else if ($etat == 2) { // Modif
379
				$this->modifier($table);
380
			}
381
   		}
382
	}
383
 
384
	protected function ajouter($table) {
385
		$requete = 	"INSERT INTO {$table['nom']} ".
386
   					' (%s) '.
387
					' VALUES (%s) ';
388
 
389
		$champs = $valeurs = '';
390
		foreach ($table['champs_valeurs_protege'] as $chp => $val) {
391
			$champs .= "$chp, ";
392
			$valeurs .= "$val, ";
393
		}
394
		$requete = sprintf($requete, rtrim($champs, ', '), rtrim($valeurs, ', '));
395
 
396
		$resultat = $this->bdd->exec($requete);
397
		$dernier_id = false;
398
		if ($resultat === false) {
399
			$cle = $this->recupererCle($table);
400
			$this->log[] = "L'enregistrement '$cle' de la table {$table['nom']} n'a pas été ajouté car la requête a échouée.";
401
		} else {
402
			$dernier_id = $this->bdd->lastInsertId();
403
		}
404
		return $dernier_id;
405
	}
406
 
407
	protected function modifier($table) {
408
		$requete = 	"UPDATE {$table['nom']} ".
409
   					'SET %s '.
410
   					'WHERE %s ';
411
 
412
		$champs_requete = '';
413
		foreach ($table['champs_valeurs_protege'] as $chp => $val) {
414
			$champs_requete .= "$chp = $val, ";
415
		}
416
		$where = $this->construireWhere($table['champs_valeurs_id']);
417
		$requete = sprintf($requete, rtrim($champs_requete, ', '), $where);
418
		$resultat = $this->bdd->exec($requete);
419
		if ($resultat === false) {
420
			$cle = $this->recupererCle($table);
421
			$this->log[] = "L'enregistrement '$cle' de la table {$table['nom']} n'a pas été mis à jour car la requête a échouée.";
422
		} else {
423
			$resultat = true;
424
		}
425
		return $resultat;
426
	}
427
 
428
	protected function supprimer($table) {
429
		$requete = 	"DELETE FROM {$table['nom']} ".
430
					'WHERE %s ';
431
 
432
		$where = $this->construireWhere($table['champs_valeurs_id']);
433
		$requete = sprintf($requete, $where);
434
 
435
		$resultat = $this->bdd->exec($requete);
436
		if ($resultat === false) {
437
			$cle = $this->recupererCle($table);
438
			$this->messages[] = "L'enregistrement '$cle' de la table {$table['nom']} n'a pas été supprimé car la requête a échouée.";
439
		} else {
440
			$resultat = true;
441
		}
442
		return $resultat;
443
	}
444
 
445
	private function gererSession($demarrage) {
446
		session_name($this->sessionName);
447
 
448
		// Configuration du cookie de session
449
		// Détermination du chemin pour les cookies nécessaire à Jrest
450
		/// ATTENTION : comme les cookies sont passés à Jrest, il faut utiliser l'url de Jrest pour établir le chemin
451
		$url_morceaux = parse_url($this->config['coel']['urlBaseJrest']);
452
		$this->cookieChemin = $this->reparerCheminCookie($url_morceaux['path']);
453
		unset($url_morceaux);
454
		session_set_cookie_params($this->sessionExpireTime, $this->cookieChemin);
455
 
456
		// Démarrage de la session
457
		if ($demarrage) {
458
			session_start();
459
		}
460
	}
461
 
462
	private function reparerCheminCookie($chemin) {
463
		// dirname renvoit / si le chemin vaut seulement /dossier/, cela renvoit /dossier si le chemin vaut /dossier//.
464
		$chemin = dirname($chemin.'/.');
465
		// Fixe la gestion des chemins pour les cookies sous les OS utilisant le \ comme séparteur de chemin
466
		$chemin = str_replace('\\', '/', $chemin);
467
		// Ajoute un '/' terminal sauf si on est à la racine web
468
		$chemin = ($chemin != '/' ? $chemin.'/' : '');
469
		return $chemin;
470
	}
471
 
472
	private function gererIdentificationPermanente() {
473
		// Pour maintenir l'utilisateur tjrs réellement identifié nous sommes obligé de recréer une SESSION et de le recharger depuis la bdd
474
		if ($this->getUtilisateur() == ''
475
				&& isset($_COOKIE['coel_login'])
476
				&& ($utilisateur = $this->chargerUtilisateur($_COOKIE['coel_login'], $_COOKIE['coel_mot_de_passe']))) {
477
			$this->setUtilisateur($utilisateur, $_COOKIE['coel_permanence']);
478
		}
479
	}
480
 
481
	protected function getUtilisateur() {
482
		return (isset($_SESSION['coel_utilisateur']) ? $_SESSION['coel_utilisateur'] : '');
483
	}
484
 
485
	protected function chargerUtilisateur($login, $mot_de_passe = null) {
486
		$sortie = false;
487
 
488
		$requete =	'SELECT cp_id_personne AS id, cp_fmt_nom_complet AS nom_complet, cp_prenom AS prenom, '.
489
					'	cp_nom AS nom, cp_login AS login, cp_mot_de_passe AS mot_de_passe, cp_parametre AS parametre, '.
490
					'	cp_ville AS ville, cp_code_postal AS code_postal, '.
491
					'	cp_mark_licence AS licence '.
492
					'FROM coel_personne '.
493
					"WHERE cp_login = {$this->bdd->quote($login)} ".
494
					((!is_null($mot_de_passe)) ? "AND cp_mot_de_passe = {$this->bdd->quote($mot_de_passe)} " : '');
495
		try {
496
			$resultat = $this->bdd->query($requete)->fetch();
497
			if ($resultat === false) {
498
				$this->debug[] = "La requête a retournée aucun résultat.";
499
			} else {
500
				$sortie = array('id' => $resultat['id'],
501
					'login' => $login,
502
					'mot_de_passe' => $resultat['mot_de_passe'],
503
					'nom_complet' => $resultat['nom_complet'],
504
					'nom' => $resultat['nom'],
505
					'prenom' => $resultat['prenom'],
506
					'parametre' => $resultat['parametre'],
507
					'ville' => $resultat['ville'],
508
					'code_postal' => $resultat['code_postal'],
509
					'licence' => $resultat['licence']);
510
			}
511
		} catch (PDOException $e) {
512
			$this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage());
513
		}
514
 
515
		return $sortie;
516
	}
517
 
518
	protected function setUtilisateur($utilisateur, $permanence = 1) {
519
		$_SESSION['coel_utilisateur'] = $utilisateur;
520
		$this->debug[] = $_SESSION['coel_utilisateur'];
521
		$this->setCookiePersistant('coel_login', $utilisateur['login'], $permanence);
522
		$this->setCookiePersistant('coel_mot_de_passe', $utilisateur['mot_de_passe'], $permanence);
523
		$this->setCookiePersistant('coel_licence', $utilisateur['licence'], $permanence);
524
		$this->setCookiePersistant('coel_permanence', $permanence, $permanence);
525
	}
526
 
527
	protected function setCookiePersistant($cookie_nom, $valeur, $permanence = 1) {
528
		setCookie($cookie_nom, $valeur, time() + ($permanence ? 100*24*60*60 : 60*60), $this->cookieChemin);
529
		$_COOKIE[$cookie_nom] = $valeur;
530
	}
531
 
532
	protected function supprimerCookie($cookie_nom) {
533
		setCookie($cookie_nom, '', 1, $this->cookieChemin);
534
		$_COOKIE[$cookie_nom] = '';
535
	}
536
 
537
	/**
538
	 * Méthode prenant en paramètre un chemin de fichier squelette et un tableau associatif de données,
539
	 * en extrait les variables, charge le squelette et retourne le résultat des deux combinés.
540
	 *
541
	 * @param String $fichier	le chemin du fichier du squelette
542
	 * @param Array  $donnees	un tableau associatif contenant les variables a injecter dans le squelette.
543
	 *
544
	 * @return boolean false si le squelette n'existe pas, sinon la chaine résultat.
545
	 */
546
	public static function traiterSquelettePhp($fichier, Array $donnees = array()) {
547
		$sortie = false;
548
		if (file_exists($fichier)) {
549
			// Extraction des variables du tableau de données
550
			extract($donnees);
551
			// Démarage de la bufferisation de sortie
552
			ob_start();
553
			// Si les tags courts sont activés
554
			if ((bool) @ini_get('short_open_tag') === true) {
555
				// Simple inclusion du squelette
556
				include $fichier;
557
			} else {
558
				// Sinon, remplacement des tags courts par la syntaxe classique avec echo
559
				$html_et_code_php = self::traiterTagsCourts($fichier);
560
				// Pour évaluer du php mélangé dans du html il est nécessaire de fermer la balise php ouverte par eval
561
				$html_et_code_php = '?>'.$html_et_code_php;
562
				// Interprétation du html et du php dans le buffer
563
				echo eval($html_et_code_php);
564
			}
565
			// Récupèration du contenu du buffer
566
			$sortie = ob_get_contents();
567
			// Suppression du buffer
568
			@ob_end_clean();
569
		} else {
570
			$msg = "Le fichier du squelette '$fichier' n'existe pas.";
571
			trigger_error($msg, E_USER_WARNING);
572
		}
573
		// Retourne le contenu
574
		return $sortie;
575
	}
576
 
577
	/**
578
	 * Fonction chargeant le contenu du squelette et remplaçant les tags court php (<?= ...) par un tag long avec echo.
579
	 *
580
	 * @param String $chemin_squelette le chemin du fichier du squelette
581
	 *
582
	 * @return string le contenu du fichier du squelette php avec les tags courts remplacés.
583
	 */
584
	private static function traiterTagsCourts($chemin_squelette) {
585
		$contenu = file_get_contents($chemin_squelette);
586
		// Remplacement de tags courts par un tag long avec echo
587
		$contenu = str_replace('<?=', '<?php echo ',  $contenu);
588
		// Ajout systématique d'un point virgule avant la fermeture php
589
		$contenu = preg_replace("/;*\s*\?>/", "; ?>", $contenu);
590
		return $contenu;
591
	}
592
}
593
?>