Subversion Repositories Applications.framework

Compare Revisions

Ignore whitespace Rev 121 → Rev 122

/trunk/framework/autoload.inc.php
39,6 → 39,8
 
//instanciation du gestionnaire d'exception
GestionnaireException::getInstance();
//instanciation du gestionnaire de logs
Log::getInstance();
 
// Autoload par défaut pour l'application
function autoloadAppliDefaut($nom_classe) {
/trunk/framework/Log.php
New file
0,0 → 1,121
<?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/
*/
 
class Log {
 
/**
* Tableau associatif stockant les descripteurs de fichiers
*/
private static $fichiersLog = array();
 
/**
* Chemin de base du dossier log de l'application
*/
private static $cheminLogs = '';
 
/**
* Booleen indiquant si l'on peut correctement écrire dans les fichiers de logs
*/
private static $droitLogger = true;
 
/**
* Zone horaire (pour éviter des avertissements dans les dates)
*/
private static $timeZone = '';
 
/**
* séparateur de chemin
*/
private static $sd = DIRECTORY_SEPARATOR;
 
/**
* La classe registre se contient elle-même, (pour le pattern singleton)
*/
private static $log;
 
/**
* 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');
 
// 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);
}
}
 
/**
* 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
*/
public static function getInstance() {
if (self::$log instanceof Log) {
return self::$log;
}
self::$log = new Log();
return self::$log;
}
 
public static function ajouterEntree($nomFichier,$entree,$mode='a+') {
if(self::$droitLogger) {
$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::$fichiersLog[$nomFichier])) {
fwrite(self::$fichiersLog[$nomFichier],$date.$entree);
} else {
self::desactiverEcriture();
}
} else {
if($fp = fopen(self::$cheminLogs.$nomFichier,'a+') && is_writable($fp)) {
self::$fichiersLog[$nomFichier] = $fp;
fwrite(self::$fichiersLog[$nomFichier],$date.$entree);
} else {
self::desactiverEcriture();
}
}
}
}
 
public static function viderLog($nomFichier) {
if(self::verifierPresenceFichier($nomFichier)) {
ajouterEntree($nomFichier,'','w');
}
}
 
public static function verifierPresenceFichier($nomFichier) {
if(in_array($nomFichier,self::$fichiersLog)) {
return true;
}
return false;
}
 
private static function desactiverEcriture() {
self::$droitLogger = false;
$message = 'Impossible d\'écrire dans le fichier de log spécifié, Vérifiez les droits du dossier de logs et du fichier';
$e = new ErrorException($message,0,E_USER_WARNING,__FILE__,__LINE__);
GestionnaireException::gererException($e);
}
 
public function __destruct() {
foreach(self::$fichiersLog as $nomFichier => $fp) {
fclose($fp);
}
}
}
?>
/trunk/framework/config.defaut.ini
17,6 → 17,12
; Niveau d'erreur à employer pour le code PHP. Voir le manuel de PHP pour les différents niveaux disponibles.
fw_debogage_niveau = 2048
 
; 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.
fw_timezone = Europe/Paris
 
; +------------------------------------------------------------------------------------------------------+
; Benchmark
; Indique si oui ou nom on veut afficher le tableau de chronométrage de l'application.
43,6 → 49,8
dossier_modeles = modeles
; Nom du dossier des squelettes de l'application.
dossier_squelettes = squelettes
; Nom du dossier des logs de l'application.
dossier_logs = logs
 
; Chemin vers le dossier de l'appli.
chemin_appli = "php:Application::getChemin()"
60,6 → 68,8
chemin_modeles = "{ref:chemin_appli}{ref:dossier_modeles}{ref:ds}"
; Chemin vers le dossier des squelettes de l'application.
chemin_squelettes = "{ref:chemin_appli}{ref:dossier_squelettes}{ref:ds}"
; Chemin vers le dossier des logs de l'application.
chemin_logs = "{ref:chemin_appli}{ref:dossier_logs}{ref:ds}"
 
; +------------------------------------------------------------------------------------------------------+
; Paramètrage de la base de données.
/trunk/framework/Chronometre.php
44,9 → 44,9
 
/** Accesseurs :
*
* @param string $cle la cle associ�e � un chronom�tre particulier
* @param string $cle la cle associée à un chronomètre particulier
*
* @return int le temps �coul�
* @return int le temps écoulé
*/
public function getTemps($cle = null) {
$temps = '';
60,7 → 60,7
 
/** Setteur pour la variable temps
*
* @param array() $moment ajoute des points de chronom�trage au tableau _temps
* @param array() $moment ajoute des points de chronométrage au tableau _temps
*
* @return null
*/
/trunk/framework/Config.php
34,9 → 34,9
// Chargement du fichier config.ini par défaut de l'application
$chemin_config_defaut_appli = self::$parametres['chemin_configurations'].sprintf(self::$parametres['fw_fichier_config'], '');
self::parserFichierIni($chemin_config_defaut_appli);
 
// Chargement des fichiers config.ini contextuels
 
if (PHP_SAPI == 'cli') {// mode console
foreach ($_SERVER['argv'] as $cle => $valeur) {
if ($valeur == '-contexte') {
53,12 → 53,12
if (Config::existeValeur('info.contexte', self::$parametres)) {
chargerFichierContexte(Config::get('info.contexte'));
}
 
// Chargement du contexte présent dans le GET
if (isset($_GET['contexte'])) {
chargerFichierContexte($_GET['contexte']);
}
 
// Chargement du contexte présent dans le POST
if (isset($_POST['contexte'])) {
chargerFichierContexte($_POST['contexte']);
108,7 → 108,7
return null;
}
}
 
private static function existeValeur($param, $config) {
$retour = false;
if (self::getValeur($param, $config) !== null) {
174,7 → 174,7
eval('$config["'.$cle.'"] = '.$correspondances[1].';');
}
}
 
public static function charger($fichier_ini) {
self::verifierCreationInstance();
return self::parserFichierIni($fichier_ini);
182,9 → 182,9
 
public static function get($param = null) {
self::verifierCreationInstance();
return self::getValeur($param, self::$parametres);;
return self::getValeur($param, self::$parametres);
}
 
public static function existe($param) {
self::verifierCreationInstance();
return self::existeValeur($param, self::$parametres);
/trunk/framework/Modele.php
97,6 → 97,7
*/
final private function connecter() {
 
trigger_error('oh oh oh o une erreur ',E_USER_WARNING);
$this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass);
if($this->encodage != null) {
$this->requete("SET names '".$this->encodage."'");
/trunk/framework/GestionnaireException.php
23,10 → 23,15
private static $exceptions = array();
 
/**
* Détermine si l'on affiche ou nom le contexte
* Détermine si l'on affiche ou non le contexte
*/
private static $contexte = 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
*/
42,9 → 47,10
* Constructeur avec paramètres optionnel
* @param bool indique si l'on veut afficher ou non le contexte des exceptions (i.e. la trace)
*/
public function __construct($contexte = false) {
public function __construct() {
self::$exceptions = array();
self::$mode = $contexte;
self::$mode = 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'));
86,8 → 92,11
// pour le moment on se contente de l'ajouter au tableau et de les afficher
self::$exceptions[] = $e;
 
if($e->getCode() == 0 || $e->getCode() >= error_reporting()) {
echo $e->getCode().' '.error_reporting();
if(self::$logger) {
self::loggerException($e);
}
 
if($e->getCode() != 0 && $e->getCode() <= error_reporting()) {
echo self::getExceptions();
return;
}
94,7 → 103,7
}
 
public static function gererErreur($niveau, $message, $fichier, $ligne, $contexte){
// si aucun rapport d'error, on sort directement
// si aucun rapport d'erreur, on sort directement
if (error_reporting() == 0)
{
return;
104,6 → 113,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;
}
 
/**
142,5 → 156,22
return $retour;
}
 
private static function loggerException($e) {
 
$erreur = '';
$erreur .= $e->getMessage()."\n";
$erreur .= 'Fichier : '.$e->getFile()."\n";
$erreur .= 'Ligne : '.$e->getLine()."\n";
$erreur .= 'Message : '.$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);
}
 
}
?>
/trunk/exemple/controleurs/AdminAdministrateur.php
160,7 → 160,7
}
 
/**
* Renvoie la t�te de page de l'application
* Renvoie la tête de page de l'application
* @return string la tete de page de l'application
*/
public function adminTete() {