/tags/v4.0/scripts/bibliotheque/noyau/SquelettePhp.class.php |
---|
New file |
0,0 → 1,48 |
<?php |
// Auteur d'origine : Brian Lozier |
// Source : http://www.massassi.com/php/articles/template_engines/ |
class SquelettePhp { |
private $vars; // Contient toutes les variables à insérer dans le squelette |
/** |
* Constructeur |
* |
* @param $fichier string le nom du fichier de template à charger. |
*/ |
public function __construct($fichier_tpl = null) |
{ |
$this->fichier = $fichier_tpl; |
} |
/** |
* Ajout une variable pour le squelette. |
*/ |
public function set($nom, $valeur = null) |
{ |
if (is_null($valeur) && is_array($nom)) { |
$this->vars = $nom; |
} else if ($valeur instanceof SquelettePhp) { |
$this->vars[$nom] = $valeur->analyser(); |
} else { |
$this->vars[$nom] = $valeur; |
} |
} |
/** |
* Ouvre, parse, and retourne le squelette. |
* |
* @param $fichier string le nom du fichier squelette. |
*/ |
public function analyser($fichier = null) |
{ |
if(!$fichier) $fichier = $this->fichier; |
extract($this->vars); // Extrait les variables et les ajoutes à l'espace de noms local |
ob_start(); // Démarre le buffer |
include($fichier); // Inclusion du fichier |
$contenu = ob_get_contents(); // Récupérer le contenu du buffer |
ob_end_clean(); // Arrête et détruit le buffer |
return $contenu; // Retourne le contenu |
} |
} |
?> |
/tags/v4.0/scripts/bibliotheque/noyau/Registre.class.php |
---|
New file |
0,0 → 1,56 |
<?php |
class Registre { |
private $aso_stock = array(); |
private static $registre; |
public function __construct() |
{ |
} |
public static function getInstance() |
{ |
if (self::$registre instanceof Registre) { |
return self::$registre; |
} |
self::$registre = new Registre; |
return self::$registre; |
} |
function set($intitule, $objet) |
{ |
if (is_array($objet) && isset($this->aso_stock[$intitule])) { |
$this->aso_stock[$intitule] = array_merge((array)$this->aso_stock[$intitule], (array)$objet); |
$message = "Le tableau $intitule présent dans le registre a été fusionné avec un nouveau tableau de même intitulé !"; |
trigger_error($message, E_USER_WARNING); |
} else { |
$this->aso_stock[$intitule] = $objet; |
} |
} |
function get($intitule) |
{ |
if (isset($this->aso_stock[$intitule])) { |
return $this->aso_stock[$intitule]; |
} |
return null; |
} |
function detruire($intitule) |
{ |
if (isset($this->aso_stock[$intitule])) { |
unset($this->aso_stock[$intitule]); |
} |
} |
public function etrePresent($intitule) |
{ |
if(isset($this->aso_stock[$intitule])){ |
return true; |
} |
return false; |
} |
} |
?> |
/tags/v4.0/scripts/bibliotheque/noyau/Chronometre.class.php |
---|
New file |
0,0 → 1,185 |
<?php |
/*vim: set expandtab tabstop=4 shiftwidth=4: */ |
// +------------------------------------------------------------------------------------------------------+ |
// | PHP version 5.0.4 | |
// +------------------------------------------------------------------------------------------------------+ |
// | Copyright (C) 2005 Tela Botanica (accueil@tela-botanica.org) | |
// +------------------------------------------------------------------------------------------------------+ |
// | This file is part of eFlore-Debogage. | |
// | | |
// | Foobar is free software; you can redistribute it and/or modify | |
// | it under the terms of the GNU General Public License as published by | |
// | the Free Software Foundation; either version 2 of the License, or | |
// | (at your option) any later version. | |
// | | |
// | Foobar is distributed in the hope that it will be useful, | |
// | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
// | GNU General Public License for more details. | |
// | | |
// | You should have received a copy of the GNU General Public License | |
// | along with Foobar; if not, write to the Free Software | |
// | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
// +------------------------------------------------------------------------------------------------------+ |
// CVS : $Id: Chronometre.class.php,v 1.1 2007-01-12 13:16:09 jp_milcent Exp $ |
/** |
* Classe permettant de mesurer le temps d'execution d'un script. |
* |
* Contient des méthodes permettant d'évaluer la vitesse d'exécution d'un script. |
* |
*@package eFlore |
*@subpackage Debogage |
//Auteur original : |
*@author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
//Autres auteurs : |
*@author aucun |
*@copyright Tela-Botanica 2000-2005 |
*@version $Revision: 1.1 $ $Date: 2007-01-12 13:16:09 $ |
// +------------------------------------------------------------------------------------------------------+ |
*/ |
// +------------------------------------------------------------------------------------------------------+ |
// | ENTETE du PROGRAMME | |
// +------------------------------------------------------------------------------------------------------+ |
// +------------------------------------------------------------------------------------------------------+ |
// | CORPS du PROGRAMME | |
// +------------------------------------------------------------------------------------------------------+ |
/**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. |
* |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
*/ |
class Chronometre |
{ |
/*** Attributs : ***/ |
private $temps = array(); |
/*** Constructeur : ***/ |
public function __construct() { |
$this->setTemps(array('depart' => microtime())); |
} |
/*** Accesseurs : ***/ |
public function getTemps($cle = NULL) { |
if (!is_null($cle)) { |
return $this->temps[$cle]; |
} else { |
return $this->temps; |
} |
} |
public function setTemps($moment = array()) { |
array_push($this->temps, $moment); |
} |
/*** Méthodes : ***/ |
/**Méthode afficherChrono() - Permet d'afficher les temps d'éxécution de différentes parties d'un script. |
* |
* Cette fonction permet d'afficher un ensemble de mesure de temps prises à différents endroits d'un script. |
* Ces mesures sont affichées au sein d'un tableau XHTML dont on peut controler l'indentation des balises. |
* Pour un site en production, il suffit d'ajouter un style #chrono {display:none;} dans la css. De cette façon, |
* le tableau ne s'affichera pas. Le webmaster lui pourra rajouter sa propre feuille de style affichant le tableau. |
* Le développeur initial de cette fonction est Loic d'Anterroches. Elle a été modifiée par Jean-Pascal Milcent. |
* Elle utilise une variable gobale : $_CHRONO_ |
* |
* @author Loic d'Anterroches |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
* @param int l'indentation de base pour le code html du tableau. |
* @param int le pas d'indentation pour le code html du tableau. |
* @return string la chaine XHTML de mesure des temps. |
*/ |
function afficherChrono($indentation_origine = 8, $indentation = 4) { |
// Création du chrono de fin |
$GLOBALS['_SCRIPT_']['chrono']->setTemps(array('fin' => microtime())); |
// Début création de l'affichage |
$sortie = str_repeat(' ', $indentation_origine). |
'<table id="chrono" lang="fr" summary="Résultat du chronométrage du programme affichant la page actuelle.">'."\n"; |
$sortie .= str_repeat(' ', ($indentation_origine + ($indentation * 1))). |
'<caption>Chronométrage</caption>'."\n"; |
$sortie .= str_repeat(' ', ($indentation_origine + ($indentation * 1))). |
'<thead>'."\n"; |
$sortie .= str_repeat(' ', ($indentation_origine + ($indentation * 2))). |
'<tr><th>Action</th><th>Temps écoulé (en s.)</th><th>Cumul du temps écoulé (en s.)</th></tr>'."\n"; |
$sortie .= str_repeat(' ', ($indentation_origine + ($indentation * 1))). |
'</thead>'."\n"; |
$tbody = str_repeat(' ', ($indentation_origine + ($indentation * 1))). |
'<tbody>'."\n"; |
$total_tps_ecoule = 0; |
// Récupération de la première mesure |
$tab_depart =& $this->getTemps(0); |
list($usec, $sec) = explode(' ', $tab_depart['depart']); |
// Ce temps correspond à tps_fin |
$tps_debut = ((float)$usec + (float)$sec); |
foreach ($this->getTemps() as $tab_temps) { |
foreach ($tab_temps as $cle => $valeur) { |
list($usec, $sec) = explode(' ', $valeur); |
$tps_fin = ((float)$usec + (float)$sec); |
$tps_ecoule = abs($tps_fin - $tps_debut); |
$total_tps_ecoule += $tps_ecoule; |
$tbody .= str_repeat(' ', ($indentation_origine + ($indentation * 2))). |
'<tr>'. |
'<th>'.$cle.'</th>'. |
'<td>'.number_format($tps_ecoule, 3, ',', ' ').'</td>'. |
'<td>'.number_format($total_tps_ecoule, 3, ',', ' ').'</td>'. |
'</tr>'."\n"; |
$tps_debut = $tps_fin; |
} |
} |
$tbody .= str_repeat(' ', ($indentation_origine + ($indentation * 1))). |
'</tbody>'."\n"; |
$sortie .= str_repeat(' ', ($indentation_origine + ($indentation * 1))). |
'<tfoot>'."\n"; |
$sortie .= str_repeat(' ', ($indentation_origine + ($indentation * 2))). |
'<tr>'. |
'<th>'.'Total du temps écoulé (en s.)'.'</th>'. |
'<td colspan="2">'.number_format($total_tps_ecoule,3, ',', ' ').'</td>'. |
'</tr>'."\n"; |
$sortie .= str_repeat(' ', ($indentation_origine + ($indentation * 1))). |
'</tfoot>'."\n"; |
$sortie .= $tbody; |
$sortie .= str_repeat(' ', $indentation_origine). |
'</table>'."\n"; |
return $sortie; |
} |
} |
/* +--Fin du code ----------------------------------------------------------------------------------------+ |
* |
* $Log: Chronometre.class.php,v $ |
* Revision 1.1 2007-01-12 13:16:09 jp_milcent |
* Déplacement des classes de débogage et d'optimisation dans le dossier noyau. |
* |
* Revision 1.1 2005/08/04 15:51:45 jp_milcent |
* Implémentation de la gestion via DAO. |
* Fin page d'accueil. |
* Fin formulaire recherche taxonomique. |
* |
* Revision 1.2 2005/08/03 15:52:31 jp_milcent |
* Fin gestion des résultats recherche nomenclaturale. |
* Début gestion formulaire taxonomique. |
* |
* Revision 1.1 2005/08/02 16:19:33 jp_milcent |
* Amélioration des requetes de recherche de noms. |
* |
* |
* +-- Fin du code ----------------------------------------------------------------------------------------+ |
*/ |
?> |
/tags/v4.0/scripts/bibliotheque/noyau/aModule.class.php |
---|
New file |
0,0 → 1,405 |
<?php |
abstract class aModule { |
/*** Constantes : ***/ |
const TPL_NULL = 'NULL'; |
const TPL_PHP = 'PHP'; |
const TPL_PHP_MAIL = 'PHP_MAIL'; |
const TPL_IT = 'IT'; |
const TPL_FPDI = 'FPDI'; |
const SORTIE_NULL = 'NULL'; |
const SORTIE_EXIT = 'EXIT'; |
const SORTIE_MAIL_SMTP = 'email'; |
const SORTIE_HTML = 'html'; |
const SORTIE_EXIT_HTML = 'exit.html'; |
const SORTIE_XML = 'xml'; |
const SORTIE_PDF = 'pdf'; |
/*** Attributs : ***/ |
private $registre; |
private $cache; |
private $actions_chainees = null; |
/*** Constructeur : ***/ |
public function __construct() |
{ |
$this->registre = Registre::getInstance(); |
$this->registre->set('squelette_moteur', aModule::TPL_PHP); |
$this->registre->set('format', aModule::SORTIE_HTML); |
$applette_dossier = preg_replace('/([a-z])([A-Z])/', '$1_$2', get_class($this)); |
// Nous créons automatiquement les chemins vers les différents dossier de l'application |
$this->registre->set('chemin_module', SC_CHEMIN_MODULE.strtolower($applette_dossier).DIRECTORY_SEPARATOR); |
$this->registre->set('chemin_module_config', $this->registre->get('chemin_module').'configuration'.DIRECTORY_SEPARATOR); |
$this->registre->set('chemin_module_squelette', $this->registre->get('chemin_module').'squelettes'.DIRECTORY_SEPARATOR); |
// Nous définissons si oui ou non le cache sera utilisé |
if (defined('SC_BOOL_STOCKAGE_CACHE')) { |
$this->cache_bool = SC_BOOL_STOCKAGE_CACHE; |
} else { |
$this->cache_bool = false; |
$e = 'La constante SC_BOOL_STOCKAGE_CACHE est indéfinie. Le cache a été désactivé!'; |
trigger_error($e, E_USER_WARNING); |
} |
// Nous chargeons le fichier de config de l'appli s'il existe |
if ($this->getConfigFichier()) { |
require_once $this->getConfigFichier(); |
} |
} |
/*** Accesseurs : ***/ |
public function getRegistre() |
{ |
return $this->registre; |
} |
public function setCacheBool($cb) |
{ |
return $this->cache_bool = $cb; |
} |
/*** Méthodes : ***/ |
public function getCacheId() |
{ |
if ($this->getActionNom() != null) { |
$methode_cache_id = 'getCacheId'.$this->getActionNom(); |
if (method_exists($this, $methode_cache_id) && !is_null($this->$methode_cache_id())) { |
return call_user_func(array($this, $methode_cache_id)); |
} |
} |
return null; |
} |
public function getCacheFichier() |
{ |
$fichier_cache = EF_CHEMIN_STOCKAGE_CACHE.$this->getCacheId(); |
if (!is_null($this->getCacheDuree())) { |
$fichier_cache .= '_['.$this->getCacheDuree().']'; |
} |
$fichier_cache .= '.cache.'.$this->getRegistre()->get('format'); |
return $fichier_cache; |
} |
public function getCacheDuree() |
{ |
$dlc = null; |
$methode_cache_dlc = 'getCacheDlc'.$this->getActionNom(); |
if (method_exists($this, $methode_cache_dlc) && !is_null($this->$methode_cache_dlc())) { |
$dlc = call_user_func(array($this, $methode_cache_dlc)); // dlc en seconde |
} |
return $dlc; |
} |
public function getActionNom() |
{ |
if ($this->getRegistre()->get('action') != null) { |
return $action = str_replace(' ', '', ucwords(str_replace('_', ' ', $this->getRegistre()->get('action')))); |
} |
return null; |
} |
public function setDebogage($d, $e = E_USER_NOTICE) |
{ |
if (is_array($d) || is_object($d)) { |
trigger_error(print_r($d, true), $e); |
} else { |
trigger_error($d, $e); |
} |
} |
public function setChrono($balise) |
{ |
// Mesure du temps d'éxecution |
$class = new ReflectionClass($this); |
$GLOBALS['_SCRIPT_']['chrono']->setTemps(array($class->getName().'-'.$balise => microtime())); |
} |
public function getSqueletteFichier() |
{ |
// Par défaut le nom du fichier de squelette est construit à partir du nom de l'action. |
if (is_null($this->getRegistre()->get('squelette_fichier'))) { |
$this->getRegistre()->set('squelette_fichier', $this->getRegistre()->get('action')); |
} |
// Nous recherchons s'il existe un squelette spécifique à la distribution |
$fichier_tpl_defaut = $this->getRegistre()->get('chemin_module_squelette'). |
$this->getRegistre()->get('squelette_fichier').'.tpl.'.$this->registre->get('format'); |
if (defined('SC_DISTRIBUTION') && SC_DISTRIBUTION != ''&& !is_null(SC_DISTRIBUTION)) { |
$fichier_tpl_projet = $this->getRegistre()->get('chemin_module_squelette'). |
strtolower(SC_DISTRIBUTION).DIRECTORY_SEPARATOR. |
$this->getRegistre()->get('squelette_fichier').'.tpl.'.$this->getRegistre()->get('format'); |
if (file_exists($fichier_tpl_projet)) { |
return $fichier_tpl_projet; |
} |
} |
if (file_exists($fichier_tpl_defaut)) { |
return $fichier_tpl_defaut; |
} |
return false; |
} |
public function getConfigFichier() |
{ |
$fichier_conf_defaut = $this->getRegistre()->get('chemin_module_config').'config.inc.php'; |
if (defined('SC_DISTRIBUTION') && SC_DISTRIBUTION != '') { |
$fichier_conf_projet = $this->getRegistre()->get('chemin_module_config'). |
'config.'.strtolower(SC_DISTRIBUTION).'.inc.php'; |
if (file_exists($fichier_conf_projet)) { |
return $fichier_conf_projet; |
} |
} |
if (file_exists($fichier_conf_defaut)) { |
return $fichier_conf_defaut; |
} |
return false; |
} |
public function getActionsChainees() |
{ |
// Création du tableau si nécessaire |
if (is_null($this->actions_chainees)) { |
$this->actions_chainees = array(); |
$this->actions_chainees[] = $this->getRegistre()->get('action'); |
} |
return $this->actions_chainees; |
} |
public function poursuivreVers($action) |
{ |
// Ajout de l'action suivante |
$this->actions_chainees[] = $action; |
} |
public function traiterAction() |
{ |
// Gestion des actions chainées si nécessaire |
$sortie = ''; |
$module_nom = strtolower(get_class($this)); |
$i = 0; |
while ($i < count($this->getActionsChainees())) { |
// Initialisation de variables |
$actions = $this->getActionsChainees(); |
$action = $actions[$i++]; |
// Remise à défaut des valeurs du Registre pour la prochaine action |
$this->getRegistre()->set('action', $action); |
$this->getRegistre()->set('format', aModule::SORTIE_HTML); |
$this->getRegistre()->set('squelette_fichier', null); |
$this->getRegistre()->set('squelette_moteur', aModule::TPL_PHP); |
// Gestion du multilinguisme |
/* |
if (isset($GLOBALS['_EF_']['i18n'][$module_nom][$action]) || isset($GLOBALS['_EF_']['i18n']['_defaut_'][$action])) { |
$this->getRegistre()->set('module_i18n', $GLOBALS['_EF_']['i18n']['_defaut_']['general']); |
if (isset($GLOBALS['_EF_']['i18n']['_defaut_'][$action])) { |
$this->getRegistre()->set('module_i18n', $GLOBALS['_EF_']['i18n']['_defaut_'][$action]); |
} |
if (isset($GLOBALS['_EF_']['i18n'][$module_nom][$action])) { |
$this->getRegistre()->set('module_i18n', $GLOBALS['_EF_']['i18n'][$module_nom][$action]); |
} |
$aso_donnees = $this->getRegistre()->get('squelette_donnees'); |
$aso_donnees['i18n'] = $this->getRegistre()->get('module_i18n'); |
$this->getRegistre()->set('squelette_donnees', $aso_donnees); |
} |
*/ |
// Exécution du rendu de l'action |
$sortie .= $this->traiterRendu($action); |
} |
// Gestion de la sortie finale |
return $sortie; |
} |
private function traiterRendu() |
{ |
// Gestion du cache : avant toute chose, retour du cache s'il existe |
if ($this->cache_bool) { |
//$this->setDebogage($this->getCacheId()); |
if (!is_null($this->getCacheId())) { |
if (file_exists($this->getCacheFichier())) { |
// Gestion de la DLC |
if ( (is_null($this->getCacheDuree())) || |
(!is_null($this->getCacheDuree()) && (time() < (filemtime($this->getCacheFichier()) + $this->getCacheDuree())))) { |
$this->registre->set('sortie', file_get_contents($this->getCacheFichier())); |
return $this->traiterSortie(); |
} |
} |
} |
} |
// Attribution si nécessaire de l'encodage de sortie |
if (!$this->registre->get('charset')) { |
$this->registre->set('charset', 'ISO-8859-1'); |
} |
// Execution de l'action |
$methode_action = 'executer'; |
if ($this->getActionNom() != null) { |
$methode_action .= $this->getActionNom(); |
} |
if (method_exists($this, $methode_action)) { |
call_user_func(array($this, $methode_action)); |
} else if (!$this->getSqueletteFichier()) { |
// Tentative de recherche de l'action dans le module des Communs |
$fichier_communs = SC_CHEMIN_MODULE.'communs'.DIRECTORY_SEPARATOR.'Communs.class.php'; |
if (file_exists($fichier_communs)) { |
include_once $fichier_communs; |
$Commun = new Communs(); |
$sortie_commun = $Commun->traiterAction(); |
} |
if (isset($sortie_commun)) { |
return $sortie_commun; |
} else { |
$e = 'Aucun squelette ou méthode "'.$methode_action.'" n\'existe pour l\'action '.$this->registre->get('action'); |
trigger_error($e, E_USER_WARNING); |
return null; |
} |
} |
// Gestion du rendu en fonction du type de template |
switch($this->registre->get('squelette_moteur')) { |
case aModule::TPL_PHP_MAIL : |
case aModule::TPL_PHP : |
$Squelette = new SquelettePhp(); |
$Squelette->set($this->getRegistre()->get('squelette_donnees')); |
if ($this->getSqueletteFichier()) { |
$sortie = $Squelette->analyser($this->getSqueletteFichier()); |
if ($this->registre->get('squelette_moteur') == aModule::TPL_PHP_MAIL) { |
// Traitement spécial pour les mails |
if (preg_match_all('/<(html|txt|file)(?:>(.*?)<\/\\1>|\s+src="(.*)"\s+type="(.*)"\s*\/>\s*$)/ism', $sortie, $decoupage, PREG_SET_ORDER)) { |
$this->registre->set('sortie_mail_mime', $decoupage); |
} |
} else { |
$this->registre->set('sortie', $sortie); |
} |
} else { |
$e = 'Action : '.$this->getRegistre()->get('action').' fichier de squelette introuvable !'; |
trigger_error($e, E_USER_WARNING); |
return null; |
} |
break; |
case aModule::TPL_NULL : |
// Nous ne faisons rien, nous passons à la gestion du type de sortie |
break; |
default : |
trigger_error('Moteur de squelette inconnu', E_USER_WARNING); |
return null; |
} |
// Gestion du cache : écriture du fichier |
if ($this->cache_bool) { |
if (!is_null($this->getCacheId())) { |
if (!file_put_contents($this->getCacheFichier(), $this->getRegistre()->get('sortie'))) { |
$e = 'Écriture du fichier de cache impossible : '.$this->getCacheFichier(); |
trigger_error($e, E_USER_WARNING); |
} |
} |
} |
// Gestion du format de sortie |
return $this->traiterSortie(); |
} |
private function traiterSortie() |
{ |
switch($this->getRegistre()->get('format')) { |
case aModule::SORTIE_HTML : |
// +--------------------------------------------------------------------------------------------------+ |
// A FAIRE : Gestion des statistiques |
// +--------------------------------------------------------------------------------------------------+ |
// Gestion du cache : affichage de la date du cache |
if ($this->cache_bool) { |
if (!is_null($this->getCacheId())) { |
$e = 'Cache, généré le '.date('D d M Y à H:i:s', filemtime($this->getCacheFichier())). |
' sera généré à nouveau le '. |
date('D d M Y à H:i:s', (filemtime($this->getCacheFichier()) + $this->getCacheDuree()))." \n"; |
trigger_error($e, E_USER_NOTICE); |
} |
} |
return $this->getRegistre()->get('sortie'); |
break; |
case aModule::SORTIE_EXIT_HTML : |
echo $this->getRegistre()->get('sortie'); |
exit(); |
break; |
case aModule::SORTIE_XML : |
header('Content-Type: application/xhtml+xml; charset='.$this->registre->get('charset')); |
echo $this->registre->get('sortie'); |
exit(); |
break; |
case aModule::SORTIE_PDF : |
header('Content-type: application/pdf'); |
header('Content-Length: '.strlen($this->getRegistre()->get('sortie'))); |
header('Content-Disposition: inline; filename='.str_replace(' ', '_', $GLOBALS['_SCRIPT_']['titre_fichier']).'.pdf');// |
echo $this->registre->get('sortie'); |
break; |
case aModule::SORTIE_MAIL_SMTP : |
//trigger_error(print_r($this->getRegistre()->get('sortie_mail_mime'), true), E_USER_NOTICE); |
// TODO : réseoudre le problème de l'autoload pour les fichiers PEAR ci-dessous |
include_once 'Mail.php'; |
include_once 'Mail/smtp.php'; |
$sortie_mail = ''; |
// Nous vérifions si nous avons à faire à un mail mime ou pas |
if (is_null($this->getRegistre()->get('sortie_mail_mime'))) { |
$sortie_mail = $this->getRegistre()->get('sortie'); |
} else { |
// Pour l'instant supporte du html et son alternative en txt plus des fichiers attachés |
// TODO : Les mails multiparts contenant des imbrications de html et de txt ne sont pas encore pris en compte... |
include_once 'Mail/mime.php'; |
$MailMime = new Mail_mime("\n"); |
foreach ($this->getRegistre()->get('sortie_mail_mime') as $valeur) { |
switch (strtolower($valeur[1])) { |
case 'txt' : |
// Syntaxe multiligne: <txt>mettre ici du texte brute</txt> |
$MailMime->setTXTBody($valeur[2]); |
break; |
case 'html' : |
// Syntaxe multiligne: <html>mettre ici votre html</html> |
$MailMime->setHTMLBody($valeur[2]); |
break; |
case 'file' : |
// Syntaxe sur une ligne: <file src="/tmp/un_test.txt" type="text/plain" /> |
$e = $MailMime->addAttachment($valeur[3], $valeur[4]); |
if ($e instanceof PEAR_Error) { |
trigger_error($e->getMessage(), E_USER_NOTICE); |
} |
break; |
default : |
trigger_error('Type de balise inconnue :'.$valeur[1], E_USER_WARNING); |
} |
} |
//do not ever try to call these lines in reverse order |
$sortie_mail = $MailMime->get(); |
$this->getRegistre()->set('sortie_mail_smtp_entete', $MailMime->headers($this->getRegistre()->get('sortie_mail_smtp_entete'))); |
} |
$mail_object = new Mail_smtp($this->getRegistre()->get('sortie_mail_smtp_params')); |
$message = $mail_object->send( $this->getRegistre()->get('sortie_mail_smtp_destinataire'), |
$this->getRegistre()->get('sortie_mail_smtp_entete'), |
$sortie_mail); |
$this->getRegistre()->set('sortie_mail_smtp_info', $message); |
return null; |
break; |
case aModule::SORTIE_EXIT : |
// Nous ne faisons rien, nous terminons seulement le programme ici |
exit(); |
break; |
case aModule::SORTIE_NULL : |
// Nous ne faisons rien, nous retournons null |
return null; |
break; |
default : |
trigger_error('Type de sortie inconnu', E_USER_ERROR); |
} |
} |
} |
?> |
/tags/v4.0/scripts/bibliotheque/noyau/GestionnaireErreur.class.php |
---|
New file |
0,0 → 1,423 |
<?php |
/*vim: set expandtab tabstop=4 shiftwidth=4: */ |
// +------------------------------------------------------------------------------------------------------+ |
// | PHP version 5.0.4 | |
// +------------------------------------------------------------------------------------------------------+ |
// | Copyright (C) 2005 Tela Botanica (accueil@tela-botanica.org) | |
// +------------------------------------------------------------------------------------------------------+ |
// | This file is part of eFlore-Debogage. | |
// | | |
// | Foobar is free software; you can redistribute it and/or modify | |
// | it under the terms of the GNU General Public License as published by | |
// | the Free Software Foundation; either version 2 of the License, or | |
// | (at your option) any later version. | |
// | | |
// | Foobar is distributed in the hope that it will be useful, | |
// | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
// | GNU General Public License for more details. | |
// | | |
// | You should have received a copy of the GNU General Public License | |
// | along with Foobar; if not, write to the Free Software | |
// | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
// +------------------------------------------------------------------------------------------------------+ |
// CVS : $Id: GestionnaireErreur.class.php,v 1.6 2007-07-09 18:54:43 jp_milcent Exp $ |
/** |
* Classe de gestion des erreurs. |
* |
* |
* |
*@package eFlore |
*@subpackage Debogage |
//Auteur original : |
*@author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
//Autres auteurs : |
*@author aucun |
*@copyright Tela-Botanica 2000-2005 |
*@version $Revision: 1.6 $ $Date: 2007-07-09 18:54:43 $ |
// +------------------------------------------------------------------------------------------------------+ |
*/ |
// +------------------------------------------------------------------------------------------------------+ |
// | ENTETE du PROGRAMME | |
// +------------------------------------------------------------------------------------------------------+ |
// +------------------------------------------------------------------------------------------------------+ |
// | CORPS du PROGRAMME | |
// +------------------------------------------------------------------------------------------------------+ |
/** |
* Classe GestionnaireErreur |
* |
* Gérer les erreurs PHP et SQL. |
*/ |
class GestionnaireErreur |
{ |
/*** Attributes: ***/ |
/** |
* Permet de savoir si on utilise PHP en ligne de commande dans une console (PHP-CLI) ou en mode module de serveur. |
* @access private |
*/ |
private $mode; |
/** |
* Contient la liste des erreurs. |
* @access private |
*/ |
private $erreurs; |
/** |
* Permet de savoir si on veut faire apparaître ou pas le contexte de l'erreur, |
* c'est à dire le contenu des variables. |
* @access private |
*/ |
private $contexte; |
/** |
* Contient le niveau d'erreur courrant. Celui que l'on donne à la fonction |
* error_reporting(). |
* @access private |
*/ |
private $niveau_erreur_courrant; |
/*** Constructeur: ***/ |
/** |
* Construit le gestionnaire d'erreur. |
* |
* @return void |
* @access public |
*/ |
public function __construct( $contexte = false ) |
{ |
$this->mode = php_sapi_name(); |
$this->erreurs = array(); |
$this->setContexte($contexte); |
set_error_handler(array(&$this, 'gererErreur')); |
} |
/*** Accesseurs: ***/ |
// end of member function __construct |
/** |
* Récupère le tableau des erreurs. |
* |
* @return array |
* @access public |
*/ |
public function getErreur( ) { |
return $this->erreurs; |
} |
/** |
* Ajoute une erreur à la liste. |
* |
* @param array une_erreur |
* @return void |
* @access public |
*/ |
public function setErreur( $une_erreur ) { |
$this->erreurs[] = $une_erreur; |
} |
/** |
* Récupère la valeur du contexte. |
* |
* @return boolean |
* @access public |
*/ |
public function getContexte( ) { |
return $this->contexte; |
} |
/** |
* Définit si oui ou non le contexte sera affiché. |
* |
* @param boolean un_contexte |
* @return void |
* @access public |
*/ |
public function setContexte( $un_contexte ) { |
$this->contexte = $un_contexte; |
} |
/** |
* Récupère le niveau d'erreur courrant. |
* |
* @return int le niveau d'erreur courrant. |
* @access public |
*/ |
public function getNiveauErreurCourrant( ) { |
return (int)$this->niveau_erreur_courrant; |
} |
/** |
* Définit le niveau d'erreur courrant. |
* |
* @param int un niveau d'erreur. |
* @return void |
* @access public |
*/ |
public function setNiveauErreurCourrant( $niveau = 2048 ) { |
$this->niveau_erreur_courrant = $niveau; |
} |
/** |
* Définit le niveau d'erreur courrant (synonyme fonction precedente) |
* |
* @param int un niveau d'erreur. |
* @return void |
* @access public |
*/ |
public function setActive ($niveau) { |
$this->niveau_erreur_courrant = $niveau; |
} |
/*** Méthodes : ***/ |
/** |
* |
* @param int niveau |
* @param string message |
* @param string fichier |
* @param int ligne |
* @param boolean contexte |
* @return void |
* @access public |
*/ |
public function gererErreur($niveau, $message, $fichier, $ligne, $contexte) |
{ |
$aso_erreur = array(); |
// Nous vérifions si nous affichons ou pas l'erreur en fonction du niveau demandé |
if ( $niveau <= $this->getNiveauErreurCourrant() ) { |
$aso_erreur['niveau'] = $niveau; |
$aso_erreur['message'] = $message; |
$aso_erreur['fichier'] = $fichier; |
$aso_erreur['ligne'] = $ligne; |
if ($this->getContexte()) { |
$aso_erreur['contexte'] = $contexte; |
} |
$this->setErreur($aso_erreur); |
} |
// Si nous avons à faire à une erreur et non à un warning ou une notice, nous arrêtons l'exécution du script |
switch ($niveau) { |
case E_ERROR : |
case E_USER_ERROR : |
die($this->retournerErreur()); |
break; |
} |
} |
/** |
* Retourne l'erreur PHP formatée en XHTML. |
* |
* @return string |
* @access public |
*/ |
public function retournerErreur() |
{ |
$retour = ''; |
$erreur_pear_nbre = 0; |
$erreur_pear_fichier_nbre = 0; |
$erreur_pear_message_nbre = 0; |
foreach($this->getErreur() as $aso_erreur) { |
if ('<!-- BEGIN sql -->' == substr($aso_erreur['message'], 0, 18)) { |
$retour .= $aso_erreur['message']; |
continue; |
} |
// Nous testons les erreurs PEAR pour ne pas en tenir compte |
if (!SC_DEBOGAGE_PEAR && stristr($aso_erreur['fichier'], SC_DEBOGAGE_PEAR_CHAINE)) { |
$erreur_pear_fichier_nbre++; |
} else if (!SC_DEBOGAGE_PEAR && preg_match(SC_DEBOGAGE_PEAR_REGEXP_MESSAGE, $aso_erreur['message'])) { |
$erreur_pear_message_nbre++; |
} else { |
switch ($this->mode) { |
case 'cli' : |
if ($aso_erreur['niveau'] == E_USER_NOTICE) { |
$retour .= $aso_erreur['message']."\n"; |
$retour .= 'Fichier : '.$aso_erreur['fichier']."\n"; |
$retour .= 'Ligne : '.$aso_erreur['ligne']."\n"; |
} else if ($aso_erreur['niveau'] <= 512) { |
$retour .= 'INFO : Niveau '.$aso_erreur['niveau']."\n"; |
} else { |
$retour .= 'ERREUR : Niveau '.$aso_erreur['niveau']."\n"; |
} |
$retour .= 'Niveau : '.$aso_erreur['niveau']."\n"; |
$retour .= 'Message : '.$aso_erreur['message']."\n"; |
$retour .= 'Fichier : '.$aso_erreur['fichier']."\n"; |
$retour .= 'Ligne : '.$aso_erreur['ligne']."\n"; |
if ($this->getContexte()) { |
$retour .= 'Contexte : '."\n".print_r($aso_erreur['contexte'], true)."\n"; |
} |
break; |
default: |
if ($aso_erreur['niveau'] == E_USER_NOTICE) { |
$retour .= '<pre class="debogage">'."\n"; |
$retour .= htmlentities($aso_erreur['message'])."\n"; |
$retour .= '<span class="debogage_fichier">'.'Fichier : '.$aso_erreur['fichier'].'</span>'."\n"; |
$retour .= '<span class="debogage_ligne">'.'Ligne : '.$aso_erreur['ligne'].'</span>'."\n"; |
$retour .= '</pre>'."\n"; |
continue; |
} else if ($aso_erreur['niveau'] <= 512) { |
$retour .= '<p class="information">'."\n"; |
$retour .= '<strong>INFO : Niveau '.$aso_erreur['niveau'].'</strong><br />'."\n"; |
} else { |
$retour .= '<p class="attention">'."\n"; |
$retour .= '<strong>ERREUR : Niveau '.$aso_erreur['niveau'].'</strong><br />'."\n"; |
} |
$retour .= '<strong>Niveau : </strong>'.$aso_erreur['niveau'].'<br />'."\n"; |
$retour .= '<strong>Message : </strong>'.$aso_erreur['message'].'<br />'."\n"; |
$retour .= '<strong>Fichier : </strong>'.$aso_erreur['fichier'].'<br />'."\n"; |
$retour .= '<strong>Ligne : </strong>'.$aso_erreur['ligne'].'<br />'."\n"; |
if ($this->getContexte()) { |
$retour .= '<pre>'."\n"; |
$retour .= '<stong>Contexte : </stong>'."\n".print_r($aso_erreur['contexte'], true)."\n"; |
$retour .= '</pre>'."\n"; |
} |
$retour .= '</p>'."\n"; |
} |
} |
} |
$erreur_pear_nbre = $erreur_pear_fichier_nbre + $erreur_pear_message_nbre; |
if ($erreur_pear_nbre != 0) { |
$retour .= '<p class="attention">'. |
'<strong>Nombre d\'erreurs PEAR totales : </strong>'.$erreur_pear_nbre.'<br />'."\n". |
'<strong> - éliminées car le "fichier" contené '.SC_DEBOGAGE_PEAR_CHAINE.' : </strong>'.$erreur_pear_fichier_nbre.'<br />'."\n". |
'<strong> - éliminées car le "message" correspondé à '.SC_DEBOGAGE_PEAR_REGEXP_MESSAGE.' : </strong>'.$erreur_pear_message_nbre.'<br />'."\n". |
'</p>'."\n"; |
} |
return $retour; |
} |
/** |
* Retourne l'erreur SQL formatée en XHTML. |
* |
* @param string fichier |
* @param int ligne |
* @param string message |
* @param string requete |
* @param string autres |
* @return string |
* @static |
* @access public |
*/ |
public static function retournerErreurSql( $fichier, $methode, $message, $requete = null, $autres = null ) |
{ |
$retour = ''; |
switch (php_sapi_name()) { |
case 'cli' : |
$retour .= 'ERREUR SQL '."\n"; |
$retour .= 'Fichier : '.$fichier."\n"; |
$retour .= 'Méthode : '.$methode."\n"; |
$retour .= 'Message : '.$message."\n"; |
if (!is_null($requete)) { |
$retour .= 'Requete : '."\n"; |
$retour .= $requete."\n"; |
} |
if (!is_null($autres)) { |
$retour .= 'Autres infos : '."\n"; |
$retour .= $autres."\n"; |
} |
break; |
default: |
$retour .= '<!-- BEGIN sql -->'; |
$retour .= '<div id="zone_erreur">'."\n"; |
$retour .= '<h1 > ERREUR SQL </h1><br />'."\n"; |
$retour .= '<dl>'."\n"; |
$retour .= '<dt> Fichier : </dt> '; |
$retour .= '<dd> '.$fichier.'</dd>'."\n"; |
$retour .= '<dt> Méthode : </dt> '; |
$retour .= '<dd> '.$methode.'</dd>'."\n"; |
$retour .= '<dt> Message erreur : </dt> '; |
$retour .= '<dd> '.$message.'</dd>'."\n"; |
if (!is_null($requete)) { |
$retour .= '<dt> Requete : </dt> '; |
$retour .= '<dd> '.$requete.' </dd>'."\n"; |
} |
if (!is_null($autres)) { |
$retour .= '<dt> Autres infos : </dt> '; |
$retour .= '<dd> '.$autres.' </dd>'."\n"; |
} |
$retour .= '</dl>'."\n"; |
$retour .= '</div>'."\n"; |
$retour .= '<!-- END sql -->'."\n"; |
} |
return $retour; |
} |
} |
/* +--Fin du code ----------------------------------------------------------------------------------------+ |
* |
* $Log: GestionnaireErreur.class.php,v $ |
* Revision 1.6 2007-07-09 18:54:43 jp_milcent |
* Remplacement des balises html par des entités pour le message des E_USER_NOTICE. |
* |
* Revision 1.5 2007-07-02 15:31:53 jp_milcent |
* Initialisation d'une variable. |
* |
* Revision 1.4 2007-07-02 12:43:09 jp_milcent |
* Gestion de php-cli ou cgi... |
* |
* Revision 1.3 2007-07-02 10:50:06 jp_milcent |
* Ajout de la gestion du mode d'affichage (xhtml ou txt). |
* |
* Revision 1.2 2007-01-15 15:30:03 jp_milcent |
* Amélioration du gestionnaire d'erreur pour qu'il prenne en compte les erreurs Pear des méthodes "non static"... |
* |
* Revision 1.1 2007/01/12 13:16:09 jp_milcent |
* Déplacement des classes de débogage et d'optimisation dans le dossier noyau. |
* |
* Revision 1.9 2006/10/25 08:15:23 jp_milcent |
* Fusion avec la livraison Decaisne. |
* |
* Revision 1.8.2.1 2006/08/29 09:22:37 jp_milcent |
* Correction et amélioration du gestionnaire d'erreurs. |
* |
* Revision 1.8 2006/07/20 13:33:46 jp_milcent |
* Légère modif affichage. |
* |
* Revision 1.7 2006/07/20 13:33:03 jp_milcent |
* Amélioration du gestionnaire d'erreur. |
* |
* Revision 1.6 2006/07/20 13:27:07 jp_milcent |
* Ajout du type information. |
* |
* Revision 1.5 2006/05/29 13:52:41 ddelon |
* Integration wiki dans eflore |
* |
* Revision 1.4 2005/12/09 10:47:05 jp_milcent |
* Amélioration du Gestionnaire de Bogues. |
* |
* Revision 1.3 2005/10/10 07:28:07 jp_milcent |
* Utilisation du webservice Yahoo-Image. |
* |
* Revision 1.2 2005/10/04 16:34:03 jp_milcent |
* Début gestion de la chorologie. |
* Ajout de la bibliothèque de cartographie (à améliorer!). |
* |
* Revision 1.1 2005/08/04 15:51:45 jp_milcent |
* Implémentation de la gestion via DAO. |
* Fin page d'accueil. |
* Fin formulaire recherche taxonomique. |
* |
* Revision 1.3 2005/08/02 16:19:33 jp_milcent |
* Amélioration des requetes de recherche de noms. |
* |
* Revision 1.2 2005/08/01 16:18:39 jp_milcent |
* Début gestion résultat de la recherche par nom. |
* |
* Revision 1.1 2005/07/28 15:37:56 jp_milcent |
* Début gestion des squelettes et de l'API eFlore. |
* |
* |
* +-- Fin du code ----------------------------------------------------------------------------------------+ |
*/ |
?> |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/tags/v4.0/scripts/bibliotheque/js/ValiderFormulaire.js |
---|
New file |
0,0 → 1,136 |
/* |
Origine du script : http://actuel.fr.selfhtml.org/articles/javascript/controle_formulaire/index.htm |
Auteur : Dieter RABER <d.raber@gmx.net> |
*/ |
function validate(sender, myarray, err_hd) { |
var message_erreur = !err_hd?new Array('Les erreurs suivantes sont survenues:\n'):new Array(err_hd+'\n'); |
var error = false; |
if (!sender.name) { |
alert('Le formulaire doit comporter un attribut name'); |
return false; |
} |
for (i = 0; i < myarray.length; i++) { |
field = document.forms[sender.name].elements[myarray[i][0]]; |
/* Bloc 1 vérifie les champs qui doivent être renseignés */ |
if (myarray[i][1].indexOf('e') > -1) { |
if (!field.value) { |
error = true; |
message_erreur.push(myarray[i][2]); |
} |
} |
/* Bloc 2 vérifie si l'adresse électronique est correcte dans la forme */ |
else if (myarray[i][1].indexOf('m')>-1) { |
if (field.value) { |
var usr = "([a-zA-Z0-9][a-zA-Z0-9_.-]*|\"([^\\\\\x80-\xff\015\012\"]|\\\\[^\x80-\xff])+\")"; |
var domain = "([a-zA-Z0-9][a-zA-Z0-9._-]*\\.)*[a-zA-Z0-9][a-zA-Z0-9._-]*\\.[a-zA-Z]{2,5}"; |
var regex = "^"+usr+"\@"+domain+"$"; |
var myrxp = new RegExp(regex); |
var check = (myrxp.test(field.value)); |
if (check!=true) { |
error = true; |
message_erreur.push(field.value+" "+myarray[i][2]); |
} |
} |
} |
/* Bloc 3 vérifie les champs dont la valeur doit être numérique */ |
else if (myarray[i][1].indexOf('n')>-1) { |
var num_error = false; |
if(field.value) { |
var myvalue = field.value; |
var num = myvalue.match(/[^0-9,\.]/gi) |
var dot = myvalue.match(/\./g); |
var com = myvalue.match(/,/g); |
if (num!=null) { |
num_error = true; |
} |
else if ((dot!=null)&&(dot.length>1)) { |
num_error = true; |
} |
else if ((com!=null)&&(com.length>1)) { |
num_error = true; |
} |
else if ((com!=null)&&(dot!=null)) { |
num_error = true; |
} |
} |
if (num_error==true) { |
error = true; |
message_erreur.push(myvalue+" "+myarray[i][2]); |
} |
} |
/* Bloc 4 vérifie la valeur à l'aide d'une expression régulière sur un modèle déterminé */ |
else if (myarray[i][1].indexOf('r')>-1) { |
var regexp = myarray[i][3]; |
if (field.value) { |
if (!regexp.test(field.value)) { |
error = true; |
message_erreur.push(field.value+" "+myarray[i][2]); |
} |
} |
} |
/* Bloc 5 vérifie les champs qui doivent être formatés comme des prix et modifie éventuellement le formatage */ |
else if (myarray[i][1].indexOf('p')>-1) { |
var myvalue = field.value; |
var reg = /,-{1,}|\.-{1,}/; |
var nantest_value = myvalue.replace(reg,""); |
var num = nantest_value.match(/[^0-9,\.]/gi) |
sep = myarray[i][1].substr(1,1)?myarray[i][1].substr(1,1):','; |
if (field.value) { |
var myvalue = field.value.replace(/\./,','); |
if (myvalue.indexOf(',')==-1) { |
field.value = myvalue+sep+'00'; |
} |
else if (myvalue.indexOf(",--")>-1) { |
field.value = myvalue.replace(/,--/,sep+'00'); |
} |
else if (myvalue.indexOf(",-")>-1) { |
field.value = myvalue.replace(/,-/,sep+'00'); |
} |
else if (!myvalue.substring(myvalue.indexOf(',') + 2)) { |
error=true; |
message_erreur.push(field.value+" "+myarray[i][2]); |
} |
else if (myvalue.substring(myvalue.indexOf(',') + 3)!='') { |
error=true; |
message_erreur.push(field.value+" "+myarray[i][2]); |
} else if (num!=null) { |
error = true; |
message_erreur.push(field.value+" "+myarray[i][2]); |
} |
} |
} |
/* Bloc 6 vérifie les champs de nom et rectifie éventuellement la casse */ |
else if (myarray[i][1].indexOf('c')>-1) { |
var noble = new Array(" d\'", "de","von","van","der","d","la","da","of"); |
var newvalue=''; |
var myvalue = field.value.split(/\b/); |
for (k=0;k<myvalue.length;k++) { |
newvalue+= myvalue[k].substr(0,1).toUpperCase()+myvalue[k].substring(1); |
} |
for(k = 0; k < noble.length; k++){ |
var reg = new RegExp ("\\b"+noble[k]+"\\b","gi"); |
newvalue = newvalue.replace(reg,noble[k]); |
} |
field.value = newvalue; |
} |
} |
/* En cas d'erreur, les messages d'erreur récoltés sont exploités ici puis affichés. |
Si le formulaire est correctement rempli, il est transmis */ |
if (error) { |
message_erreur = message_erreur.join('\n\xB7 '); |
alert(message_erreur); |
return false; |
} else { |
return true; |
} |
} |