Subversion Repositories Applications.framework

Rev

Rev 392 | 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 
/**
392 jpm 4 
 * Classe de base du Framework :
5 
 *  - fournissant des infos sur l'application,
221 jpm 6 
 *  - paramétrant l'environnement de l'appli et du framework,
7 
 *  - réalisant des traitements sur les variables globales ($_GET, $_POST, $_COOKIE...)
392 jpm 8 
 *
221 jpm 9 
 * Cette classe contient la fonction de chargement automatique de classes.
392 jpm 10 
 * Ce fichier doit toujours rester à la racine du framework car il initialise le chemin
221 jpm 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 393 2011-11-10 13:36:48Z 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;
392 jpm 27 
 
221 jpm 28 
	/** Tableau d'informations sur l'application */
96 jpm 29 
	private static $info = null;
392 jpm 30 
 
221 jpm 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.*/
392 jpm 35 
	private static $parametres_obligatoires = array('chemin_controleurs', 'chemin_modeles', 'chemin_bibliotheque',
274 jpm 36 
		'url_arg_separateur_entree', 'url_arg_separateur_sortie',
37 
		'encodage_sortie', 'encodage_appli');
392 jpm 38 
 
129 aurelien 39 
	/**
392 jpm 40 
	 * Initialise l'environnement nécessaire au Framework : constantes globales, méthodeles autoload, séparateur d'arguments
221 jpm 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 
	}
392 jpm 48 
 
221 jpm 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();
392 jpm 56 
		//Log::configurer();
206 aurelien 57 
		self::verifierEtReencoderTableauRequete();
186 jpm 58 
	}
392 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 
		if (!defined('DS')) {
392 jpm 65 
			/** Redéfinition de la constante DIRECTORY_SEPARATOR en version abrégée DS */
221 jpm 66 
			define('DS', DIRECTORY_SEPARATOR);
67 
		}
68 
		if (!defined('PS')) {
392 jpm 69 
			/** Redéfinition de la constante PATH_SEPARATOR en version abrégée PS */
221 jpm 70 
			define('PS', PATH_SEPARATOR);
71 
		}
72 
	}
392 jpm 73 
 
393 jpm 74 
	private static function definirCheminAppli($chemin) {
75 
		if (is_file($chemin)) {
76 
			self::$chemin = dirname($chemin).DS;
77 
		} else if (is_dir($chemin)) {
78 
			self::$chemin = $chemin;
79 
		} else {
80 
			throw new Exception("Le chemin indiqué '$chemin' n'est ni un fichier ni un dossier.");
81 
		}
82 
	}
83 
 
221 jpm 84 
	private static function enregistrerMethodesAutoload() {
85 
		spl_autoload_register(array(get_class(), 'autoloadFw'));
392 jpm 86 
 
241 jpm 87 
		// Vérification des paramètres de configuration obligatoire pour assurer le fonctionnement du Framework
88 
		Config::verifierPresenceParametres(self::$parametres_obligatoires);
392 jpm 89 
 
221 jpm 90 
		// Initialisation du gestionnaire d'erreur avant toute chose
91 
		GestionnaireException::initialiser();
392 jpm 92 
 
221 jpm 93 
		spl_autoload_register(array(get_class(), 'autoloadAppliDefaut'));
392 jpm 94 
 
221 jpm 95 
		// Autoload défini par l'application
96 
		if (function_exists('__autoload')) {
97 
			spl_autoload_register('__autoload');
98 
		}
99 
	}
392 jpm 100 
 
221 jpm 101 
	/**
102 
	 * Autoload pour le Framework.
103 
	 */
104 
	private static function autoloadFw($nom_classe_fw) {
377 jpm 105 
		$racine_fw = dirname(__FILE__).DS;
106 
		$dossiers_classes = array(	$racine_fw,
107 
									$racine_fw.'utilitaires'.DS,
108 
									$racine_fw.'brouillons'.DS);
221 jpm 109 
		foreach ($dossiers_classes as $chemin) {
110 
			$fichier_a_tester = $chemin.$nom_classe_fw.'.php';
111 
			if (file_exists($fichier_a_tester)) {
112 
				include_once $fichier_a_tester;
113 
				return null;
114 
			}
115 
		}
116 
	}
392 jpm 117 
 
221 jpm 118 
	/**
119 
	 * Autoload par défaut pour l'application
120 
	 */
121 
	private static function autoloadAppliDefaut($nom_classe) {
122 
		$dossiers_classes = array(	Config::get('chemin_controleurs'),
123 
									Config::get('chemin_modeles'),
124 
									Config::get('chemin_bibliotheque'));
392 jpm 125 
 
221 jpm 126 
		foreach ($dossiers_classes as $chemin) {
127 
			$fichier_a_tester = $chemin.$nom_classe.'.php';
128 
			if (file_exists($fichier_a_tester)) {
129 
				include_once $fichier_a_tester;
130 
				return null;
131 
			}
132 
		}
133 
	}
392 jpm 134 
 
221 jpm 135 
	/**
199 jpm 136 
	 * Initialise le format des urls.
137 
	 */
138 
	private static function initialiserUrl() {
274 jpm 139 
		ini_set('arg_separator.input', Config::get('furl_arg_separateur_entree'));
140 
		ini_set('arg_separator.output', Config::get('url_arg_separateur_sortie'));
199 jpm 141 
	}
392 jpm 142 
 
199 jpm 143 
	/**
186 jpm 144 
	 * Permet d'indiquer le chemin de base de l'Application.
145 
	 * Cette méthode doit obligatoirement être utilisée par l'application pour que le Framework fonctionne correctement.
129 aurelien 146 
	 * @param string $chemin_fichier_principal chemin de base
147 
	 */
221 jpm 148 
	public static function setCheminAppli($chemin_fichier_principal) {
95 jpm 149 
		if (self::$chemin === null) {
150 
			if (!file_exists($chemin_fichier_principal)) {
221 jpm 151 
				trigger_error("Le fichier indiqué n'existe pas. Utilisez __FILE__ dans la méthode setCheminAppli().", E_USER_ERROR);
95 jpm 152 
			} else {
268 jpm 153 
				self::definirConstantesGlobales();
393 jpm 154 
				self::definirCheminAppli($chemin_fichier_principal);
221 jpm 155 
				self::initialiserEnvironnement();
156 
				self::initialiserFramework();
95 jpm 157 
			}
158 
		} else {
98 jpm 159 
			trigger_error("Le chemin de l'application a déjà été enregistré auprès du Framework", E_USER_WARNING);
95 jpm 160 
		}
161 
	}
162 
 
129 aurelien 163 
	/**
164 
	 * accesseur pour le chemin
165 
	 * @return string le chemin
166 
	 */
221 jpm 167 
	public static function getCheminAppli() {
95 jpm 168 
		return self::$chemin;
169 
	}
96 jpm 170 
 
98 jpm 171 
	/** Le tableau des informations sur l'application possède les clés suivantes :
172 
	 * - nom : nom de l'application
173 
	 * - abr : abréviation de l'application
174 
	 * - encodage : encodage de l'application (ISO-8859-15, UTF-8...)
175 
	 *
176 
	 * @param array $info tableau fournissant des informations sur l'application
177 
	 * @return void
178 
	 */
221 jpm 179 
	public static function setInfoAppli($info) {
98 jpm 180 
		if (self::$info === null) {
181 
			self::$info = $info;
182 
		} else {
183 
			trigger_error("Le informations de l'application ont déjà été enregistrées auprès du Framework", E_USER_WARNING);
184 
		}
185 
	}
186 
 
129 aurelien 187 
	/**
221 jpm 188 
	 * Accesseur pour le tableau d'infos sur l'application.
129 aurelien 189 
	 * @param string $cle la clé à laquelle on veut accéder
190 
	 */
221 jpm 191 
	public static function getInfoAppli($cle = null) {
96 jpm 192 
		if ($cle !== null) {
193 
			if (isset(self::$info[$cle])) {
194 
				return self::$info[$cle];
195 
			}
196 
		} else {
197 
			return self::$info;
198 
		}
95 jpm 199 
	}
392 jpm 200 
 
221 jpm 201 
	/**
206 aurelien 202 
	 * Procédure vérifiant l'encodage des tableaux $_GET et $_POST et les transcodant dans l'encodage de l'application
203 
	 */
204 
	protected static function verifierEtReencoderTableauRequete() {
274 jpm 205 
		if (self::$encodage == false && Config::get('encodage_sortie') != Config::get('encodage_appli')) {
206 
			$_POST = self::encoderTableau($_POST, Config::get('encodage_appli'), Config::get('encodage_sortie'));
207 
			$_GET = self::encoderTableau($_GET, Config::get('encodage_appli'), Config::get('encodage_sortie'));
392 jpm 208 
 
221 jpm 209 
			// Traitement des magic quotes
206 aurelien 210 
			self::verifierEtTraiterSlashTableauRequete();
392 jpm 211 
 
206 aurelien 212 
			self::$encodage = true;
213 
		}
214 
	}
392 jpm 215 
 
206 aurelien 216 
	/**
217 
	 * Procédure vérifiant l'activation des magic quotes et remplacant les slash dans les tableaux de requete
218 
	 */
219 
	private static function verifierEtTraiterSlashTableauRequete() {
221 jpm 220 
		if (get_magic_quotes_gpc()) {
221 
			if (!function_exists('nettoyerSlashProfond')) {
222 
				function nettoyerSlashProfond($valeur) {
223 
					return ( is_array($valeur) ) ? array_map('nettoyerSlashProfond', $valeur) : stripslashes($valeur);
224 
				}
206 aurelien 225 
			}
221 jpm 226 
			$_GET = array_map('nettoyerSlashProfond', $_GET);
227 
			$_POST = array_map('nettoyerSlashProfond', $_POST);
228 
			$_COOKIE = array_map('nettoyerSlashProfond', $_COOKIE);
206 aurelien 229 
		}
230 
	}
231 
 
232 
	/**
233 
	 * Fonction récursive transcodant toutes les valeurs d'un tableau de leur encodage d'entrée vers un encodage de sortie donné
234 
	 * @param $tableau Array Un tableau de données à encoder
235 
	 * @param $encodage_sortie String l'encodage vers lequel on doit transcoder
236 
	 * @param $encodage_entree String l'encodage original des chaines du tableau (optionnel)
237 
	 * @return Array Le tableau encodé dans l'encodage de sortie
238 
	 *
239 
	 */
240 
	final static protected function encoderTableau($tableau, $encodage_sortie, $encodage_entree = null) {
241 
		if (is_array($tableau)) {
242 
			foreach ($tableau as $cle => $valeur) {
243 
				if (is_array($valeur)) {
244 
				 	$tableau[$cle] = self::encoderTableau($valeur, $encodage_sortie, $encodage_entree);
245 
				} else {
246 
					$tableau[$cle] = mb_convert_encoding($valeur, $encodage_sortie, $encodage_entree);
247 
				}
248 
			}
249 
		}
250 
		return $tableau;
251 
	}
208 gduche 252 
}
230 jpm 253 
?>