Subversion Repositories Applications.framework

Rev

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

Rev Author Line No. Line
95 jpm 1
<?php
96 jpm 2
// declare(encoding='UTF-8');
3
/**
221 jpm 4
 * Classe de base du Framework :
5
 *  - fournissant des infos sur l'application,
6
 *  - paramétrant l'environnement de l'appli et du framework,
7
 *  - réalisant des traitements sur les variables globales ($_GET, $_POST, $_COOKIE...)
8
 *
9
 * Cette classe contient la fonction de chargement automatique de classes.
10
 * Ce fichier doit toujours rester à la racine du framework car il initialise le chemin
11
 * de l'application en se basant sur son propre emplacement.
129 aurelien 12
 *
186 jpm 13
 * @category	PHP 5.2
221 jpm 14
 * @package	Framework
186 jpm 15
 * @author		Jean-Pascal MILCENT <jpm@tela-botanica.org>
241 jpm 16
 * @copyright	Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
221 jpm 17
 * @license	http://www.gnu.org/licenses/gpl.html Licence GNU-GPL-v3
18
 * @license	http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL-v2
232 jpm 19
 * @version	$Id: Framework.php 268 2010-12-25 17:06:01Z jpm $
20
 * @since		0.3
186 jpm 21
 * @link		/doc/framework/
129 aurelien 22
 */
221 jpm 23
class Framework {
96 jpm 24
 
206 aurelien 25
	/** Variable statique indiquant que les tableaux _GET et _POST ont déjà été encodé au format de l'appli. */
26
	private static $encodage = false;
27
 
221 jpm 28
	/** Tableau d'informations sur l'application */
96 jpm 29
	private static $info = null;
221 jpm 30
 
31
	/** Chemin de base de l'application */
95 jpm 32
	private static $chemin = null;
96 jpm 33
 
241 jpm 34
	/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
35
	private static $parametres_obligatoires = array('chemin_controleurs', 'chemin_modeles', 'chemin_bibliotheque',
36
		'fw_url_arg_separateur_entree', 'fw_url_arg_separateur_sortie',
37
		'sortie_encodage', 'appli_encodage');
38
 
129 aurelien 39
	/**
221 jpm 40
	 * Initialise l'environnement nécessaire au Framework : constantes globales, méthodeles autoload, séparateur d'arguments
41
	 * d'url.
42
	 * Cette méthode est appelée automatiquement suite à la définition du chemin de l'application via Application::setChemin().
43
	 */
44
	private static function initialiserEnvironnement() {
45
		self::enregistrerMethodesAutoload();
46
		self::initialiserUrl();
47
	}
48
 
49
	/**
186 jpm 50
	 * Initialise différentes classes du Framework nécessaires pour le fonctionnement de l'application.
51
	 * Ces classes sont ensuites controlées via les fichiers de config.ini.
52
	 * Elle est appelée automatiquement suite à la définition du chemin de l'application via Application::setChemin().
53
	 */
221 jpm 54
	private static function initialiserFramework() {
189 jpm 55
		GestionnaireException::configurer();
206 aurelien 56
		//Log::configurer();
57
		self::verifierEtReencoderTableauRequete();
186 jpm 58
	}
221 jpm 59
 
186 jpm 60
	/**
221 jpm 61
	 * Redéfinit des constantes globales utiles pour le Framework et les applis.
62
	 */
63
	private static function definirConstantesGlobales() {
64
		/** Redéfinition de la constante DIRECTORY_SEPARATOR en version abrégée DS */
65
		if (!defined('DS')) {
66
			define('DS', DIRECTORY_SEPARATOR);
67
		}
68
		/** Redéfinition de la constante PATH_SEPARATOR en version abrégée PS */
69
		if (!defined('PS')) {
70
			define('PS', PATH_SEPARATOR);
71
		}
72
	}
73
 
74
	private static function enregistrerMethodesAutoload() {
75
		spl_autoload_register(array(get_class(), 'autoloadFw'));
241 jpm 76
 
77
		// Vérification des paramètres de configuration obligatoire pour assurer le fonctionnement du Framework
78
		Config::verifierPresenceParametres(self::$parametres_obligatoires);
79
 
221 jpm 80
		// Initialisation du gestionnaire d'erreur avant toute chose
81
		GestionnaireException::initialiser();
82
 
83
		spl_autoload_register(array(get_class(), 'autoloadAppliDefaut'));
84
 
85
		// Autoload défini par l'application
86
		if (function_exists('__autoload')) {
87
			spl_autoload_register('__autoload');
88
		}
89
	}
90
 
91
	/**
92
	 * Autoload pour le Framework.
93
	 */
94
	private static function autoloadFw($nom_classe_fw) {
95
		$dossiers_classes = array(	dirname(__FILE__).DS,
96
									dirname(__FILE__).DS.'utilitaires'.DS);
97
		foreach ($dossiers_classes as $chemin) {
98
			$fichier_a_tester = $chemin.$nom_classe_fw.'.php';
99
			if (file_exists($fichier_a_tester)) {
100
				include_once $fichier_a_tester;
101
				return null;
102
			}
103
		}
104
	}
105
 
106
	/**
107
	 * Autoload par défaut pour l'application
108
	 */
109
	private static function autoloadAppliDefaut($nom_classe) {
110
		$dossiers_classes = array(	Config::get('chemin_controleurs'),
111
									Config::get('chemin_modeles'),
112
									Config::get('chemin_bibliotheque'));
113
 
114
		foreach ($dossiers_classes as $chemin) {
115
			$fichier_a_tester = $chemin.$nom_classe.'.php';
116
			if (file_exists($fichier_a_tester)) {
117
				include_once $fichier_a_tester;
118
				return null;
119
			}
120
		}
121
	}
122
 
123
	/**
199 jpm 124
	 * Initialise le format des urls.
125
	 */
126
	private static function initialiserUrl() {
127
		ini_set('arg_separator.input', Config::get('fw_url_arg_separateur_entree'));
128
		ini_set('arg_separator.output', Config::get('fw_url_arg_separateur_sortie'));
129
	}
130
 
131
	/**
186 jpm 132
	 * Permet d'indiquer le chemin de base de l'Application.
133
	 * Cette méthode doit obligatoirement être utilisée par l'application pour que le Framework fonctionne correctement.
129 aurelien 134
	 * @param string $chemin_fichier_principal chemin de base
135
	 */
221 jpm 136
	public static function setCheminAppli($chemin_fichier_principal) {
95 jpm 137
		if (self::$chemin === null) {
138
			if (!file_exists($chemin_fichier_principal)) {
221 jpm 139
				trigger_error("Le fichier indiqué n'existe pas. Utilisez __FILE__ dans la méthode setCheminAppli().", E_USER_ERROR);
95 jpm 140
			} else {
268 jpm 141
				self::definirConstantesGlobales();
142
				self::$chemin = dirname($chemin_fichier_principal).DS;
221 jpm 143
				self::initialiserEnvironnement();
144
				self::initialiserFramework();
95 jpm 145
			}
146
		} else {
98 jpm 147
			trigger_error("Le chemin de l'application a déjà été enregistré auprès du Framework", E_USER_WARNING);
95 jpm 148
		}
149
	}
150
 
129 aurelien 151
	/**
152
	 * accesseur pour le chemin
153
	 * @return string le chemin
154
	 */
221 jpm 155
	public static function getCheminAppli() {
95 jpm 156
		return self::$chemin;
157
	}
96 jpm 158
 
98 jpm 159
	/** Le tableau des informations sur l'application possède les clés suivantes :
160
	 * - nom : nom de l'application
161
	 * - abr : abréviation de l'application
162
	 * - encodage : encodage de l'application (ISO-8859-15, UTF-8...)
163
	 *
164
	 * @param array $info tableau fournissant des informations sur l'application
165
	 * @return void
166
	 */
221 jpm 167
	public static function setInfoAppli($info) {
98 jpm 168
		if (self::$info === null) {
169
			self::$info = $info;
170
		} else {
171
			trigger_error("Le informations de l'application ont déjà été enregistrées auprès du Framework", E_USER_WARNING);
172
		}
173
	}
174
 
129 aurelien 175
	/**
221 jpm 176
	 * Accesseur pour le tableau d'infos sur l'application.
129 aurelien 177
	 * @param string $cle la clé à laquelle on veut accéder
178
	 */
221 jpm 179
	public static function getInfoAppli($cle = null) {
96 jpm 180
		if ($cle !== null) {
181
			if (isset(self::$info[$cle])) {
182
				return self::$info[$cle];
183
			}
184
		} else {
185
			return self::$info;
186
		}
95 jpm 187
	}
206 aurelien 188
 
221 jpm 189
	/**
206 aurelien 190
	 * Procédure vérifiant l'encodage des tableaux $_GET et $_POST et les transcodant dans l'encodage de l'application
191
	 */
192
	protected static function verifierEtReencoderTableauRequete() {
193
		if (self::$encodage == false && Config::get('sortie_encodage') != Config::get('appli_encodage')) {
194
			$_POST = self::encoderTableau($_POST, Config::get('appli_encodage'), Config::get('sortie_encodage'));
195
			$_GET = self::encoderTableau($_GET, Config::get('appli_encodage'), Config::get('sortie_encodage'));
196
 
221 jpm 197
			// Traitement des magic quotes
206 aurelien 198
			self::verifierEtTraiterSlashTableauRequete();
199
 
200
			self::$encodage = true;
201
		}
202
	}
203
 
204
	/**
205
	 * Procédure vérifiant l'activation des magic quotes et remplacant les slash dans les tableaux de requete
206
	 */
207
	private static function verifierEtTraiterSlashTableauRequete() {
221 jpm 208
		if (get_magic_quotes_gpc()) {
209
			if (!function_exists('nettoyerSlashProfond')) {
210
				function nettoyerSlashProfond($valeur) {
211
					return ( is_array($valeur) ) ? array_map('nettoyerSlashProfond', $valeur) : stripslashes($valeur);
212
				}
206 aurelien 213
			}
221 jpm 214
			$_GET = array_map('nettoyerSlashProfond', $_GET);
215
			$_POST = array_map('nettoyerSlashProfond', $_POST);
216
			$_COOKIE = array_map('nettoyerSlashProfond', $_COOKIE);
206 aurelien 217
		}
218
	}
219
 
220
	/**
221
	 * Fonction récursive transcodant toutes les valeurs d'un tableau de leur encodage d'entrée vers un encodage de sortie donné
222
	 * @param $tableau Array Un tableau de données à encoder
223
	 * @param $encodage_sortie String l'encodage vers lequel on doit transcoder
224
	 * @param $encodage_entree String l'encodage original des chaines du tableau (optionnel)
225
	 * @return Array Le tableau encodé dans l'encodage de sortie
226
	 *
227
	 */
228
	final static protected function encoderTableau($tableau, $encodage_sortie, $encodage_entree = null) {
229
		if (is_array($tableau)) {
230
			foreach ($tableau as $cle => $valeur) {
231
				if (is_array($valeur)) {
232
				 	$tableau[$cle] = self::encoderTableau($valeur, $encodage_sortie, $encodage_entree);
233
				} else {
234
					$tableau[$cle] = mb_convert_encoding($valeur, $encodage_sortie, $encodage_entree);
235
				}
236
			}
237
		}
238
		return $tableau;
239
	}
208 gduche 240
}
230 jpm 241
?>