Subversion Repositories Applications.framework

Compare Revisions

Ignore whitespace Rev 128 → Rev 129

/trunk/framework/GestionnaireErreur.php
File deleted
\ No newline at end of file
/trunk/framework/autoload.inc.php
41,6 → 41,8
GestionnaireException::getInstance();
//instanciation du gestionnaire de logs
Log::getInstance();
// encodage de l'application (défini ici car on peut avoir des sorties d'erreurs dès le début)
mb_internal_encoding(Config::get('appli_encodage'));
 
// Autoload par défaut pour l'application
function autoloadAppliDefaut($nom_classe) {
/trunk/framework/Log.php
1,16 → 1,18
<?php
//declare(encoding='UTF-8');
/**
* PHP Version 5
*
* @category PHP
* @package framework
* @author aurelien <aurelien@tela-botanica.org>
* @copyright 2009 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @version SVN: <svn_id>
* @link /doc/framework/
*/
* Classe permettant de logger des messages dans les fichier situés dans le dossier de log
*
* PHP Version 5
*
* @category PHP
* @package framework
* @author aurelien <aurelien@tela-botanica.org>
* @copyright 2009 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @version SVN: <svn_id>
* @link /doc/framework/
*/
 
class Log {
 
35,11 → 37,21
private static $timeZone = '';
 
/**
* Taille maximum d'un fichier de log avant que celui ne soit archivé (en octets)
*/
private static $tailleMax = 10000;
 
/**
* séparateur de chemin
*/
private static $sd = DIRECTORY_SEPARATOR;
 
/**
* Extension des fichiers de log
*/
private static $ext = '.log';
 
/**
* La classe registre se contient elle-même, (pour le pattern singleton)
*/
private static $log;
48,19 → 60,25
* Constructeur par défaut, privé, car on accède à la classe par le getInstance
*/
private function __construct() {
self::$sd = Config::get('ds');
self::$cheminLogs = Config::get('chemin_logs');
self::$timeZone = Config::get('fw_timezone');
self::$sd = Config::get('ds');
self::$cheminLogs = Config::get('chemin_logs');
self::$timeZone = Config::get('fw_timezone');
self::$tailleMax = Config::get('fw_taille_max_logs');
 
// gestion de la timezone pour éviter des erreurs
if(function_exists("date_default_timezone_set") and function_exists("date_default_timezone_get")) {
date_default_timezone_set(self::$timeZone);
}
// gestion de la timezone pour éviter des erreurs
if(function_exists("date_default_timezone_set") and function_exists("date_default_timezone_get")) {
date_default_timezone_set(self::$timeZone);
}
 
if(!is_dir(self::$cheminLogs) || !is_writable(self::$cheminLogs)) {
self::desactiverEcriture();
}
}
 
/**
* Fonction qui renvoie l'instance de classe en assurant son unicité, c'est l'unique méthode qui doit être
* utilisée pour récupérer l'objet Registre
* @return Log le gestionnaire de log en cours
*/
public static function getInstance() {
if (self::$log instanceof Log) {
79,24 → 97,14
$date = "\n"."\n".date('d m Y H:i')."\n" ;
 
// si le fichier est déjà dans le tableau et qu'on peut y écrire
if(in_array($nomFichier,self::$fichiersLog)) {
if(is_writable(self::$cheminLogs.$nomFichier)) {
if(self::verifierOuvrirFichier($nomFichier,$mode)) {
// on y écrit le message de log
fwrite(self::$fichiersLog[$nomFichier],$date.$entree);
} else {
self::desactiverEcriture($nomFichier);
}
// on vérifie si le fichier ne dépasse pas la taille maximale
self::verifierTailleFichierOuArchiver($nomFichier);
} else {
$fp = fopen(self::$cheminLogs.$nomFichier,$mode);
if($fp) {
if(is_writable(self::$cheminLogs.$nomFichier)) {
self::$fichiersLog[$nomFichier] = $fp;
fwrite(self::$fichiersLog[$nomFichier],$date.$entree);
} else {
self::desactiverEcriture($nomFichier);
}
} else {
self::desactiverEcriture($nomFichier);
}
// sinon on interdit l'écriture
self::desactiverEcriture($nomFichier);
}
}
}
106,31 → 114,61
* @param string $nomFichier le nom du fichier à vider
*/
public static function viderLog($nomFichier) {
if(self::verifierPresenceFichier($nomFichier)) {
ajouterEntree($nomFichier,'','w');
}
ajouterEntree($nomFichier,'','w');
}
 
/**
* Vérifie la présence d'un fichier dans le tableau (et bientot plein
* d'autres choses).
* Vérifie la présence d'un fichier dans le tableau, ses droits d'écriture,
* l'ouvre si nécessaire
* @param string $nomFichier le nom du fichier dont on doit vérifier la présence
* @return boolean vrai si le fichier est dans le tableau, faux sinon
* @return boolean true si le fichier est ouvert ou maintenant accessible, false sinon
*/
public static function verifierPresenceFichier($nomFichier) {
public static function verifierOuvrirFichier($nomFichier,$mode) {
// le fichier est il déjà ouvert ?
if(in_array($nomFichier,self::$fichiersLog)) {
return true;
// si oui peut on y écrire ?
if(is_writable(self::$cheminLogs.$nomFichier.self::$ext)) {
// si oui on renvoie le descripteur
return true;
}
return false;
} else {
// sinon on l'ouvre
$fp = @fopen(self::$cheminLogs.$nomFichier.self::$ext,$mode);
// si l'ouverture a réussi et si le fichier a les droits d'écriture
if($fp && is_writable(self::$cheminLogs.$nomFichier.self::$ext)) {
// si oui on renvoie le descripteur qu'on ajoute au tableau
self::$fichiersLog[$nomFichier] = $fp;
return true;
}
return false;
}
return false;
}
 
/**
* Vérifie la taille d'un fichier donné et si celle ci est trop importante
* archive le fichier de log
* @param string $nomFichier nom du fichier à vérifier
*/
private static function verifierTailleFichierOuArchiver($nomFichier) {
if(filesize(self::$cheminLogs.$nomFichier.self::$ext) > self::$tailleMax) {
rename(self::$cheminLogs.$nomFichier.self::$ext,self::$cheminLogs.$nomFichier.date('d_m_Y_H:i').self::$ext);
ajouterEntree($nomFichier,'');
}
}
 
/**
* Désactive l'écriture du log et envoie un message au gestionnaire d'erreurs
* @param string $nomFichier le nom du fichier qui a causé l'erreur
*/
private static function desactiverEcriture($nomFichier) {
private static function desactiverEcriture($nomFichier = '') {
self::$droitLogger = false;
$message = 'Ecriture impossible dans le fichier '.$nomFichier.', Assurez-vous des droits du dossier de logs et du fichier';
if($nomFichier != '') {
$fichierDossier = 'fichier '.$nomFichier ;
} else {
$fichierDossier = 'dossier des logs';
}
$message = 'Ecriture impossible dans le '.$fichierDossier.', Assurez-vous des droits du dossier et des fichiers';
$e = new ErrorException($message,0,E_USER_WARNING,__FILE__,__LINE__);
GestionnaireException::gererException($e);
}
/trunk/framework/Application.php
1,23 → 1,35
<?php
// declare(encoding='UTF-8');
/**
* Classe fournissant des informations au Framework sur l'application.
*
* @package Framework
* @category Debogage
// Auteur principal :
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
// Autres auteurs :
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $$Id$$
* @copyright 1999-2009 Tela Botanica (accueil@tela-botanica.org)
*/
* Classe fournissant des informations au Framework sur l'application.
*
* PHP version 5
*
* @category Debogage
* @package Framework
// Auteur principal :
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
// Autres auteurs :
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $$Id$$
* @copyright 1999-2009 Tela Botanica (accueil@tela-botanica.org)
*/
class Application {
 
/**
* tableau d'informations sur l'application
*/
private static $info = null;
/**
* chemin de base de l'application
*/
private static $chemin = null;
 
/**
* Modificateur pour le chemin de base
* @param string $chemin_fichier_principal chemin de base
*/
public static function setChemin($chemin_fichier_principal) {
if (self::$chemin === null) {
if (!file_exists($chemin_fichier_principal)) {
30,6 → 42,10
}
}
 
/**
* accesseur pour le chemin
* @return string le chemin
*/
public static function getChemin() {
return self::$chemin;
}
50,6 → 66,10
}
}
 
/**
* accesseur pour le tableau d'infos
* @param string $cle la clé à laquelle on veut accéder
*/
public static function getInfo($cle = null) {
if ($cle !== null) {
if (isset(self::$info[$cle])) {
/trunk/framework/config.defaut.ini
20,9 → 20,12
; Indique si oui ou non on veut activer la journalisation des erreurs.
fw_log_debogage = true
 
; Indique si oui ou non on veut activer la journalisation des erreurs.
; Indique le fuseau horaire pour le datage des logs.
fw_timezone = Europe/Paris
 
; Indique la taille max d'un fichier log (en octets)
fw_taille_max_logs = 1000000
 
; +------------------------------------------------------------------------------------------------------+
; Benchmark
; Indique si oui ou nom on veut afficher le tableau de chronométrage de l'application.
/trunk/framework/Chronometre.php
1,38 → 1,25
<?php
// declare(encoding='UTF-8');
/** Fichier de la classe Chronometre
*
* PHP Version 5
*
* @category PHP
* @package Framework
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright 2009 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @version SVN: <svn_id>
* @link /doc/framework/
*/
 
/** Classe Chronometre() - Permet de stocker et d'afficher
* les temps d'éxécution de script.
*
* Cette classe permet de réaliser un ensemble
* de mesure de temps prises à
* différents endroits d'un script.
* Ces mesures peuvent ensuite être affichées au
* sein d'un tableau XHTML.
*
*
* PHP Version 5
*
* @category PHP
* @package Framework
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright 2009 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @version Release: <package_version>
* @link /doc/framework/
*/
* les temps d'éxécution de script.
*
* Cette classe permet de réaliser un ensemble
* de mesure de temps prises à
* différents endroits d'un script.
* Ces mesures peuvent ensuite être affichées au
* sein d'un tableau XHTML.
*
*
* PHP Version 5
*
* @category PHP
* @package Framework
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright 2009 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @version Release: <package_version>
* @link /doc/framework/
*/
class Chronometre {
/*** Attributs : ***/
private $_temps = array();
/trunk/framework/Config.php
18,9 → 18,19
 
class Config {
 
/**
* instance de la classe pointant sur elle même (pour le pattern singleton)
*/
private static $instance = null;
 
/**
* paramètres de configuration
*/
private static $parametres = array();
 
/**
* Constructeur vide
*/
private function __construct() {
// Définition de paramètres avant chargement du config.ini
self::$parametres = array(
66,6 → 76,10
}
}
 
/**
* Charge le fichier de config correspondant au contexte
* @param string $contexte le contexte
*/
private static function chargerFichierContexte($contexte) {
$chemin_config_appli_contextuel = self::$parametres['chemin_configurations'];
$chemin_config_appli_contextuel .= sprintf(self::$parametres['fw_fichier_config'], '_'.$contexte);
72,6 → 86,11
self::parserFichierIni($chemin_config_appli_contextuel);
}
 
/**
* Parse le fichier ini donné en paramètre
* @param string $fichier_ini nom du fichier ini à parser
* @return array tableau contenant les paramètres du fichier ini
*/
private static function parserFichierIni($fichier_ini) {
$retour = false;
if (file_exists($fichier_ini)) {
83,10 → 102,20
return $retour;
}
 
/**
* fusionne un tableau de paramètres avec le tableau de paramètres global
* @param array $ini le tableau à fusionner
*/
private static function fusionner(array $ini) {
self::$parametres = array_merge(self::$parametres, $ini);
}
 
/**
* renvoie la valeur demandé grâce une chaine de paramètres
* @param string $param la chaine de paramètres
* @param array $config le tableau de paramètre
* @return string la valeur de la chaine demandée
*/
private static function getValeur($param, $config) {
if ($param === null) {
return null;
109,6 → 138,11
}
}
 
/**
* Teste si param existe dans le tableau config
* @param string $param nom du paramètre
* @param array tableau de configuration
*/
private static function existeValeur($param, $config) {
$retour = false;
if (self::getValeur($param, $config) !== null) {
117,6 → 151,9
return $retour;
}
 
/**
* Vérifie si l'instance de classe à été crée, si non la crée
*/
private static function verifierCreationInstance() {
if (empty(self::$instance)) {
self::$instance = new Config();
123,6 → 160,11
}
}
 
/**
* analyse un tableau de paramètres
* @param array $config le tableau de paramètres
* @return array le tableau analysé
*/
private static function analyserTableauIni($config = array()) {
foreach ($config as $cle => $valeur) {
if (is_array($valeur)) {
136,6 → 178,13
return $config;
}
 
/**
* dans le cas des chaine de configuration à sous clé (ex.: cle.souscle)
* evalue les valeurs correspondantes et crée les sous tableaux associés
* @param array $config tableau de configuration (par référence)
* @param string $cle la cle dans le tableau
* @param string $valeur la valeur à affecter
*/
private static function evaluerCle(&$config, $cle, $valeur) {
if (strpos($cle, '.') !== false) {
unset($config[$cle]);
161,6 → 210,11
return $config;
}
 
/**
* Evalue les valeurs de références à une clé dans le tableau config (cas du ref:cle)
* @param array $config tableau de configuration
* @param string $cle la clé dont il faut évaluer les références
*/
private static function evaluerReferences(&$config, $cle) {
if (preg_match_all('/{ref:([A-Za-z0-9_-]+)}/', $config[$cle], $correspondances, PREG_SET_ORDER)) {
foreach ($correspondances as $ref) {
169,6 → 223,11
}
}
 
/**
* Evalue le code php contenu dans un clé tu tableau config
* @param array $config tableau de configuration (par référence)
* @param string $cle le clé du tableau dont il faut évaluer la valeur
*/
private static function evaluerPhp(&$config, $cle) {
if (preg_match('/^php:(.+)$/', $config[$cle], $correspondances)) {
eval('$config["'.$cle.'"] = '.$correspondances[1].';');
175,16 → 234,31
}
}
 
/**
* Charge un fichier ini dans le tableau des paramètres de l'appli
* @param string $fichier_ini le nom du fichier à charger
* @return array le fichier ini parsé
*/
public static function charger($fichier_ini) {
self::verifierCreationInstance();
return self::parserFichierIni($fichier_ini);
}
 
/**
* Acesseur pour la valeur d'un paramètre
* @param string $param le nom du paramètre
* @return string la valeur du paramètre
*/
public static function get($param = null) {
self::verifierCreationInstance();
return self::getValeur($param, self::$parametres);
}
 
/**
* Vérifie si la valeur d'un paramètre existe
* @param string $param le nom du paramètre
* @return boolean vrai si le paramètre existe, false sinon
*/
public static function existe($param) {
self::verifierCreationInstance();
return self::existeValeur($param, self::$parametres);
/trunk/framework/Debug.php
1,24 → 1,33
<?php
// declare(encoding='UTF-8');
/**
* Classe fournissant des fonctions de débogage équivalante à var_dump et print_r.
* L'affichage et l'utilisation de ces fonctions sont améliorés via cette classe.
* Cette classe est inspirée de la classe Zend_Debug.
*
* @package Framework
* @category Debogage
// Auteur principal :
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
// Autres auteurs :
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $$Id$$
* @copyright 1999-2009 Tela Botanica (accueil@tela-botanica.org)
*/
* Classe fournissant des fonctions de débogage équivalante à var_dump et print_r.
* L'affichage et l'utilisation de ces fonctions sont améliorés via cette classe.
* Cette classe est inspirée de la classe Zend_Debug.
*
* PHP version 5
*
* @category Debogage
* @package Framework
// Auteur principal :
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
// Autres auteurs :
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $$Id$$
* @copyright 1999-2009 Tela Botanica (accueil@tela-botanica.org)
*/
class Debug {
 
/**
* mode de php (cli ou sapi)
*/
protected static $mode = null;
 
/**
* Accesseur pour le mode
* @return string le mode de php
*/
public static function getMode() {
if (self::$mode === null) {
self::$mode = PHP_SAPI;
26,6 → 35,13
return self::$mode;
}
 
/**
* Equivalent de var_dump
* @param mixed $variable la variable à dumper
* @param string $mot_cle le mot cle à associer à la variable
* @param boolean $echo si true on affiche le résultat, si false on ne renvoie que la chaine sans l'afficher
* @return string la chaine à afficher representant le dump ou null si echo
*/
public static function dump($variable, $mot_cle = null, $echo = true) {
// var_dump de la variable dans un buffer et récupération de la sortie
ob_start();
39,6 → 55,13
return self::traiterDebogage($mot_cle, $sortie, $echo);
}
 
/**
* Equivalent de print_r
* @param mixed $variable la variable à afficher
* @param string $mot_cle le mot cle à associer
* @param boolean $echo faire un echo ou non
* @return string la chaine contenant la variable printée ou null si echo
*/
public static function printr($variable, $mot_cle = null, $echo = true) {
// Récupération de la sortie
$sortie = print_r($variable, true);
47,6 → 70,13
return self::traiterDebogage($mot_cle, $sortie, $echo);
}
 
/**
* Traite une chaine de débogage et les mots clés associés
* @param string $mot_cle le mot à associer à la chaine
* @param string $sortie le chaine de debogage
* @param boolean $echo faire un echo du resultat ou non
* @return string la chaine de debogage formatée ou bien null si echo
*/
private static function traiterDebogage($mot_cle, $sortie, $echo) {
// Formate le mot-clé
$mot_cle = self::formaterMotCle($mot_cle);
63,10 → 93,21
}
}
 
/**
* formate un mot clé donné
* @param string $mot_cle le mot clé à formaté
* @return string le mot clé formaté ou bien un chaine vide le mot clé est null ou vide
*/
private static function formaterMotCle($mot_cle) {
return ($mot_cle === null) ? '' : rtrim($mot_cle).' ';
}
 
/**
* traite la sortie de la chaine de débogage suivant le mode de php
* @param string $mot_cle le mot clé associé à la chaine
* @param string $sortie la chaine de débogage
* @return string la sortie formatée pour le mode en cours
*/
private static function traiterSortieSuivantMode($mot_cle, $sortie) {
$corps = $mot_cle.PHP_EOL.$sortie;
if (self::getMode() == 'cli') {
/trunk/framework/GestionnaireException.php
1,20 → 1,20
<?php
// declare(encoding='UTF-8');
/**
* classe de gestion des exceptions.
*
* PHP Version 5
*
* @category Class
* @package Framework
* @author aurelien <aurelien@tela-botanica.org>
* @copyright 2009 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version SVN: $$Id$$
* @link /doc/framework/
*
*/
* classe de gestion des exceptions.
*
* PHP Version 5
*
* @category Class
* @package Framework
* @author aurelien <aurelien@tela-botanica.org>
* @copyright 2009 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version SVN: $$Id$$
* @link /doc/framework/
*
*/
class GestionnaireException {
 
/**
27,10 → 27,10
*/
private static $contexte = false;
 
/**
* Détermine si l'on loggue ou non les erreurs
*/
private static $logger = false;
/**
* Détermine si l'on loggue ou non les erreurs
*/
private static $logger = false;
 
/**
* Definit si php est lancé en ligne de commande ou en mode serveur
49,8 → 49,8
*/
public function __construct() {
self::$exceptions = array();
self::$mode = Config::get('fw_debogage_contexte');
self::$logger = Config::get('fw_log_debogage');
self::$contexte = Config::get('fw_debogage_contexte');
self::$logger = Config::get('fw_log_debogage');
self::$mode = php_sapi_name();
 
set_exception_handler(array(get_class($this),'gererException'));
61,7 → 61,7
* Renvoie le booleen définissant si l'on affiche le contexte ou non
*/
public static function getContexte() {
return self::$mode;
return self::$contexte;
}
 
/**
69,7 → 69,7
* @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false
*/
public function setContexte($contexte) {
self::$mode = $contexte;
self::$contexte = $contexte;
}
 
/** Fonction d'accès au singleton
86,6 → 86,7
 
/**
* Fonction de gestion des exceptions, remplace le handler par défaut
* @param Exception $e l'exception à traiter
*/
public static function gererException(Exception $e) {
 
92,10 → 93,12
// pour le moment on se contente de l'ajouter au tableau et de les afficher
self::$exceptions[] = $e;
 
if(self::$logger) {
self::loggerException($e);
}
// si on doit logger on envoie l'exception au loggeur
if(self::$logger) {
self::loggerException($e);
}
 
// si l'exception n'est pas permise par error reporting, on affiche les exceptions
if($e->getCode() != 0 && $e->getCode() <= error_reporting()) {
echo self::getExceptions();
return;
102,6 → 105,14
}
}
 
/**
* Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php)
* @param int $niveau le niveau de l'erreur
* @param string $message le message associé à l'erreur
* @param string $fichier le nom du fichier où l'erreur s'est produite
* @param int $ligne la ligne où l'erreur s'est produite
* @param string $contexte le contexte associé à l'erreur
*/
public static function gererErreur($niveau, $message, $fichier, $ligne, $contexte){
// si aucun rapport d'erreur, on sort directement
if (error_reporting() == 0)
113,11 → 124,11
$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);
// que l'on donne au tableau d'exceptions
self::$exceptions[] = $e;
// on la logge si nécéssaire
if(self::$logger) {
self::loggerException($e);
}
return;
// on la logge si nécéssaire
if(self::$logger) {
self::loggerException($e);
}
return;
}
 
/**
132,9 → 143,6
$retour .= $e->getMessage()."\n";
$retour .= 'Fichier : '.$e->getFile()."\n";
$retour .= 'Ligne : '.$e->getLine()."\n";
$retour .= 'Message : '.$e->getMessage()."\n";
$retour .= 'Fichier : '.$e->getFile()."\n";
$retour .= 'Ligne : '.$e->getLine()."\n";
if (self::getContexte()) {
$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
}
156,19 → 164,22
return $retour;
}
 
private static function loggerException($e) {
/**
* logge une exception donnée sous une forme lisible
* @param Exception $e l'exception à logger
*/
private static function loggerException($e) {
 
$erreur = '';
$erreur .= 'Fichier : '.$e->getFile()."\n";
$erreur .= 'Ligne : '.$e->getLine()."\n";
$erreur .= 'Message : '.$e->getMessage()."\n";
if (self::getContexte()) {
$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
}
$erreur .= "\n";
$erreur = '';
$erreur .= $e->getMessage()."\n";
$erreur .= 'Fichier : '.$e->getFile()."\n";
$erreur .= 'Ligne : '.$e->getLine()."\n";
if (self::getContexte()) {
$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
}
$erreur .= "\n";
Log::ajouterEntree('erreurs',$erreur);
}
 
Log::ajouterEntree('erreurs',$erreur);
}
 
}
?>
/trunk/framework/Controleur.php
1,35 → 1,27
<?php
// declare(encoding='UTF-8');
/**
* classe Controlleur, coeur d'une application, c'est normalement la seule classe d'une application
* qui devrait être appelée de l'extérieur.
* Elle est abstraite donc doit obligatoirement être étendue
*
* PHP Version 5
*
* @category Class
* @package Framework
* @author aurelien <aurelien@tela-botanica.org>
* @copyright 2009 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version SVN: $$Id$$
* @link /doc/framework/
*
*/
* classe Controleur, coeur d'une application, c'est normalement la seule classe d'une application
* qui devrait être appelée de l'extérieur.
* Elle est abstraite donc doit obligatoirement être étendue
*
* PHP Version 5
*
* @category Class
* @package Framework
* @author aurelien <aurelien@tela-botanica.org>
* @copyright 2009 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version SVN: $$Id$$
* @link /doc/framework/
*
*/
abstract class Controleur {
/**
* Registre global, normalement accessible partout
*/
private $registre;
/**
* Gestionnaire d'exceptions php
*/
private $gestionnaire_exception;
/**
* Gestionnaire d'erreurs php
*/
private $gestionnaire_erreur;
 
/**
* Constructeur par défaut
44,8 → 36,6
$this->registre->set('base_chemin_squelette', Config::get('chemin_squelettes'));
$this->registre->set('base_chemin_controleur', Config::get('chemin_controleurs'));
$this->registre->set('base_url_application', new Url(Config::get('url_base')));
$this->gestionnaire_exception = GestionnaireException::getInstance();
$this->gestionnaire_erreur = GestionnaireErreur::getInstance();
}
 
/**
114,8 → 104,11
$this->$nom_squelette = $tampon;
}
 
/**
* Destructeur de classe, renvoie les exceptions s'il y en a
*/
public function __destruct() {
$this->gestionnaire_exception->getExceptions();
GestionnaireException::getExceptions();
}
}
?>