1: <?php
  2: // declare(encoding='UTF-8');
  3: /**
  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.
 12:  *
 13:  * @category    PHP 5.2
 14:  * @package Framework
 15:  * @author      Jean-Pascal MILCENT <jpm@tela-botanica.org>
 16:  * @copyright   Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
 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
 19:  * @version $Id: Framework.php 391 2011-11-09 16:55:53Z jpm $
 20:  * @since       0.3
 21:  * @link        /doc/framework/
 22:  */
 23: class Framework {
 24: 
 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: 
 28:     /** Tableau d'informations sur l'application */
 29:     private static $info = null;
 30: 
 31:     /** Chemin de base de l'application */
 32:     private static $chemin = null;
 33: 
 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:         'url_arg_separateur_entree', 'url_arg_separateur_sortie',
 37:         'encodage_sortie', 'encodage_appli');
 38: 
 39:     /**
 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:     /**
 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:      */
 54:     private static function initialiserFramework() {
 55:         GestionnaireException::configurer();
 56:         //Log::configurer();
 57:         self::verifierEtReencoderTableauRequete();
 58:     }
 59: 
 60:     /**
 61:      * Redéfinit des constantes globales utiles pour le Framework et les applis.
 62:      */
 63:     private static function definirConstantesGlobales() {
 64:         if (!defined('DS')) {
 65:             /** Redéfinition de la constante DIRECTORY_SEPARATOR en version abrégée DS */
 66:             define('DS', DIRECTORY_SEPARATOR);
 67:         }
 68:         if (!defined('PS')) {
 69:             /** Redéfinition de la constante PATH_SEPARATOR en version abrégée PS */
 70:             define('PS', PATH_SEPARATOR);
 71:         }
 72:     }
 73: 
 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: 
 84:     private static function enregistrerMethodesAutoload() {
 85:         spl_autoload_register(array(get_class(), 'autoloadFw'));
 86: 
 87:         // Vérification des paramètres de configuration obligatoire pour assurer le fonctionnement du Framework
 88:         Config::verifierPresenceParametres(self::$parametres_obligatoires);
 89: 
 90:         // Initialisation du gestionnaire d'erreur avant toute chose
 91:         GestionnaireException::initialiser();
 92: 
 93:         spl_autoload_register(array(get_class(), 'autoloadAppliDefaut'));
 94: 
 95:         // Autoload défini par l'application
 96:         if (function_exists('__autoload')) {
 97:             spl_autoload_register('__autoload');
 98:         }
 99:     }
100: 
101:     /**
102:      * Autoload pour le Framework.
103:      */
104:     private static function autoloadFw($nom_classe_fw) {
105:         $dossiers_classes = array(  dirname(__FILE__).DS,
106:                                     dirname(__FILE__).DS.'utilitaires'.DS);
107:         foreach ($dossiers_classes as $chemin) {
108:             $fichier_a_tester = $chemin.$nom_classe_fw.'.php';
109:             if (file_exists($fichier_a_tester)) {
110:                 include_once $fichier_a_tester;
111:                 return null;
112:             }
113:         }
114:     }
115: 
116:     /**
117:      * Autoload par défaut pour l'application
118:      */
119:     private static function autoloadAppliDefaut($nom_classe) {
120:         $dossiers_classes = array(  Config::get('chemin_controleurs'),
121:                                     Config::get('chemin_modeles'),
122:                                     Config::get('chemin_bibliotheque'));
123: 
124:         foreach ($dossiers_classes as $chemin) {
125:             $fichier_a_tester = $chemin.$nom_classe.'.php';
126:             if (file_exists($fichier_a_tester)) {
127:                 include_once $fichier_a_tester;
128:                 return null;
129:             }
130:         }
131:     }
132: 
133:     /**
134:      * Initialise le format des urls.
135:      */
136:     private static function initialiserUrl() {
137:         ini_set('arg_separator.input', Config::get('furl_arg_separateur_entree'));
138:         ini_set('arg_separator.output', Config::get('url_arg_separateur_sortie'));
139:     }
140: 
141:     /**
142:      * Permet d'indiquer le chemin de base de l'Application.
143:      * Cette méthode doit obligatoirement être utilisée par l'application pour que le Framework fonctionne correctement.
144:      * @param string $chemin_fichier_principal chemin de base
145:      */
146:     public static function setCheminAppli($chemin_fichier_principal) {
147:         if (self::$chemin === null) {
148:             if (!file_exists($chemin_fichier_principal)) {
149:                 trigger_error("Le fichier indiqué n'existe pas. Utilisez __FILE__ dans la méthode setCheminAppli().", E_USER_ERROR);
150:             } else {
151:                 self::definirConstantesGlobales();
152:                 self::definirCheminAppli($chemin_fichier_principal);
153:                 self::initialiserEnvironnement();
154:                 self::initialiserFramework();
155:             }
156:         } else {
157:             trigger_error("Le chemin de l'application a déjà été enregistré auprès du Framework", E_USER_WARNING);
158:         }
159:     }
160: 
161:     /**
162:      * accesseur pour le chemin
163:      * @return string le chemin
164:      */
165:     public static function getCheminAppli() {
166:         return self::$chemin;
167:     }
168: 
169:     /** Le tableau des informations sur l'application possède les clés suivantes :
170:      * - nom : nom de l'application
171:      * - abr : abréviation de l'application
172:      * - encodage : encodage de l'application (ISO-8859-15, UTF-8...)
173:      *
174:      * @param array $info tableau fournissant des informations sur l'application
175:      * @return void
176:      */
177:     public static function setInfoAppli($info) {
178:         if (self::$info === null) {
179:             self::$info = $info;
180:         } else {
181:             trigger_error("Le informations de l'application ont déjà été enregistrées auprès du Framework", E_USER_WARNING);
182:         }
183:     }
184: 
185:     /**
186:      * Accesseur pour le tableau d'infos sur l'application.
187:      * @param string $cle la clé à laquelle on veut accéder
188:      */
189:     public static function getInfoAppli($cle = null) {
190:         if ($cle !== null) {
191:             if (isset(self::$info[$cle])) {
192:                 return self::$info[$cle];
193:             }
194:         } else {
195:             return self::$info;
196:         }
197:     }
198: 
199:     /**
200:      * Procédure vérifiant l'encodage des tableaux $_GET et $_POST et les transcodant dans l'encodage de l'application
201:      */
202:     protected static function verifierEtReencoderTableauRequete() {
203:         if (self::$encodage == false && Config::get('encodage_sortie') != Config::get('encodage_appli')) {
204:             $_POST = self::encoderTableau($_POST, Config::get('encodage_appli'), Config::get('encodage_sortie'));
205:             $_GET = self::encoderTableau($_GET, Config::get('encodage_appli'), Config::get('encodage_sortie'));
206: 
207:             // Traitement des magic quotes
208:             self::verifierEtTraiterSlashTableauRequete();
209: 
210:             self::$encodage = true;
211:         }
212:     }
213: 
214:     /**
215:      * Procédure vérifiant l'activation des magic quotes et remplacant les slash dans les tableaux de requete
216:      */
217:     private static function verifierEtTraiterSlashTableauRequete() {
218:         if (get_magic_quotes_gpc()) {
219:             if (!function_exists('nettoyerSlashProfond')) {
220:                 function nettoyerSlashProfond($valeur) {
221:                     return ( is_array($valeur) ) ? array_map('nettoyerSlashProfond', $valeur) : stripslashes($valeur);
222:                 }
223:             }
224:             $_GET = array_map('nettoyerSlashProfond', $_GET);
225:             $_POST = array_map('nettoyerSlashProfond', $_POST);
226:             $_COOKIE = array_map('nettoyerSlashProfond', $_COOKIE);
227:         }
228:     }
229: 
230:     /**
231:      * Fonction récursive transcodant toutes les valeurs d'un tableau de leur encodage d'entrée vers un encodage de sortie donné
232:      * @param $tableau Array Un tableau de données à encoder
233:      * @param $encodage_sortie String l'encodage vers lequel on doit transcoder
234:      * @param $encodage_entree String l'encodage original des chaines du tableau (optionnel)
235:      * @return Array Le tableau encodé dans l'encodage de sortie
236:      *
237:      */
238:     final static protected function encoderTableau($tableau, $encodage_sortie, $encodage_entree = null) {
239:         if (is_array($tableau)) {
240:             foreach ($tableau as $cle => $valeur) {
241:                 if (is_array($valeur)) {
242:                     $tableau[$cle] = self::encoderTableau($valeur, $encodage_sortie, $encodage_entree);
243:                 } else {
244:                     $tableau[$cle] = mb_convert_encoding($valeur, $encodage_sortie, $encodage_entree);
245:                 }
246:             }
247:         }
248:         return $tableau;
249:     }
250: }
251: ?>