Subversion Repositories Applications.framework

<?php

// declare(encoding='UTF-8');

/**

 * Classe de gestion des exceptions.

 * C'est un Singleton.

 *

 * @category	PHP 5.2

 * @package	Framework

 * @author		Aurélien PERONNET <aurelien@tela-botanica.org>

 * @author		Jean-Pascal MILCENT <jmp@tela-botanica.org>

 * @copyright	Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)

 * @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	$Id: GestionnaireException.php 498 2019-11-15 09:15:41Z killian $$

 * @link		/doc/framework/

 *

 */

class GestionnaireException {

	const MODE_CLI = 'cli';

	/** Liste des exceptions enregistrées */

	private static $exceptions = array();

	/** 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;

	/** Détermine si l'affichage des erreurs est forcé (true) ou pas (false) à la destruction de la classe */

	private static $afficher = false;

	/** Definit si php est lancé en ligne de commande ou en mode serveur */

	private static $mode = null ;

	/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/

	private static $parametres_obligatoires = array('debogage', 'debogage_contexte', 'log_debogage');

	/** Initialise le Gestionnaire d'exceptions et d'erreur sans tenir comptes des paramêtres de config. */

	public static function initialiser() {

		self::$mode = php_sapi_name();

		// Désactivation des balises HTML dans les messages d'erreur de PHP en mode ligne de commande

		if (self::$mode == self::MODE_CLI) {

			ini_set('html_errors', 0);

		}

		//set_exception_handler(array(get_class(),'gererException'));

		//set_error_handler(array(get_class(),'gererErreur'));

	}

	/** Configure le Gestionnaire d'exceptions et d'erreur à partir des paramêtres de config. */

	public static function configurer() {

		Config::verifierPresenceParametres(self::$parametres_obligatoires);

		self::$contexte = Config::get('debogage_contexte');

		self::$logger = Config::get('log_debogage');

		self::$afficher = Config::get('debogage');

	}

	/**

	 * Renvoie le nombre d'exceptions et d'erreurs levées.

	 * @see getExceptions() pour obtenir les exceptions formatées.

	 * @since 0.3

	 * @return int le nombre d'exception actuellement levées

	 */

	public static function getExceptionsNbre() {

		return count(self::$exceptions);

	}

	/**

	 * Renvoie le booleen définissant si l'on affiche le contexte ou non

	 * @return bool true si on affiche le contexte sinon false.

	 */

	public static function getContexte() {

		return self::$contexte;

	}

	/**

	 * Definit si l'on veut afficher le contexte ou non

	 * @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false

	 */

	public static function setContexte($contexte) {

		self::$contexte = $contexte;

	}

	/**

	 * Fonction de gestion des exceptions, remplace le handler par défaut.

	 * Si une boucle génère de multiple exception (ou erreur) identique une seule sera stockée.

	 * @param Exception $e l'exception à traiter

	 */

	public static function gererException(Throwable $e) {

		$cle = hash('md5', $e->getMessage().'-'.$e->getFile().'-'.$e->getLine());

		if (!isset(self::$exceptions[$cle])) {

			self::$exceptions[$cle] = $e;

			self::loggerException($e);

		}

	}

	/**

	 * 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 un rapport d'erreur existe, création d'une exception

		if (error_reporting() != 0) {

			$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);

			self::gererException($e);

		}

		return null;

	}

	/**

	 * Renvoie les exceptions au format (X)HTML ou bien au format texte suivant le mode d'utilisation de PHP.

	 * @since 0.3

	 * @deprecated

	 * @see getExceptionsFormatees()

	 * @return string les exceptions formatées en texte ou (X)HTML.

	 */

	public static function getExceptions() {

		return self::getExceptionsFormatees();

	}

	/**

	 * Renvoie les exceptions au format (X)HTML ou bien au format texte suivant le mode d'utilisation de PHP.

	 * @since 0.3

	 * @return string les exceptions formatées en texte ou (X)HTML.

	 */

	public static function getExceptionsFormatees() {

		$retour = '';

		if (self::getExceptionsNbre() > 0) {

			foreach (self::$exceptions as $cle => $e) {

				switch (self::$mode) {

					case self::MODE_CLI :

						$retour .= self::formaterExceptionTxt($e);

						break;

					default:

						$retour .= self::formaterExceptionXhtml($e);

				}

				// Nous vidons le tableau des exceptions au fur et à mesure pour éviter le réaffichage avec le destructeur.

				unset(self::$exceptions[$cle]);

			}

		}

		return $retour;

	}

	/**

	 * Renvoie le tableau d'objets Exception générées par le script PHP triées du niveau de sévérité le plus élevé au moins élevé.

	 * Format du tableau :

	 * array{sévérité_1 = array{Exception1, Exception2, Exception3,...}, sévérité_1 =  array{Exception1, Exception2, ...}, ...};

	 * ATTENTION : si vous utilisez cette méthode, c'est à vous de gérer l'affichage des Exceptions. Le gestionnaire d'exception

	 * n'enverra plus rien au navigateur ou à la console.

	 * @since 0.3

	 * @return array le tableau trié d'objet Exception.

	 */

	public static function getExceptionsTriees() {

		$retour = array();

		if (self::getExceptionsNbre() > 0) {

			foreach (self::$exceptions as $cle => $e) {

				$retour[$e->getSeverity()][] = $e;

				// Nous vidons le tableau des exceptions au fur et à mesure pour éviter le réaffichage avec le destructeur.

				unset(self::$exceptions[$cle]);

			}

			ksort($retour);

		}

		return $retour;

	}

	/**

	 * Logue une exception donnée sous une forme lisible si self::logger vaut true.

	 * @param Exception	$e l'exception à logger

	 */

	private static function loggerException(Throwable $e) {

		if (self::$logger) {

			$message = self::formaterExceptionTxt($e);

			Log::ajouterEntree('erreurs', $message);

		}

	}

	/**

	 * Formate en texte une exception passée en paramètre.

	 * @since 0.3

	 * @param Exception l'exception à formater.

	 */

	public static function formaterExceptionDebug(Throwable $e) {

		$txt = '';

		if ($e->getSeverity() == E_USER_NOTICE) {

			$txt = $e->getMessage();

		} else {

			$txt = self::formaterExceptionTxt($e);

		}

		return $txt;

	}

	/**

	 * Formate en texte une exception passée en paramètre.

	 * @since 0.3

	 * @param Exception l'exception à formater.

	 */

	public static function formaterExceptionTxt(Throwable $e) {

		$message = '';

		$message .= $e->getMessage()."\n";

		$message .= 'Fichier : '.$e->getFile()."\n";

		$message .= 'Ligne : '.$e->getLine()."\n";

		if (self::getContexte()) {

			$message .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";

		}

		$message .= "\n";

		return $message;

	}

	/**

	 * Formate en (X)HTML une exception passée en paramètre.

	 * @since 0.3

	 * @param Exception l'exception à formater.

	 */

	public static function formaterExceptionXhtml(Throwable $e) {

		$message = '';

		$message .= '<div class="debogage">'."\n";

		$message .= $e->getMessage()."\n";

		$message .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";

		$message .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";

		if (self::getContexte()) {

			$message .= '<pre>'."\n";

			$message .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";

			$message .= '</pre>'."\n";

		}

		$message .= '</div>'."\n";

		return $message;

	}

	/**

	 * Lors de la destruction de la classe si des exceptions n'ont pas été affichées, et si le débogage est à true, elles sont

	 * affichées.

	 */

	public function __destruct() {

		// Si des erreurs n'ont pas été affichée nous forçons leur affichage

		if (self::$afficher && self::getExceptionsNbre() > 0) {

			echo self::getExceptionsFormatees();

		}

	}

}

?>