| /trunk/framework/Controleur.php |
|---|
| 4,118 → 4,118 |
| * 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 |
| * |
| * |
| * PHP Version 5 |
| * |
| * @category Class |
| * @package Framework |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @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/ |
| * |
| * @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 |
| */ |
| final public function __construct() { |
| if (Config::existe('fw_html_errors')) { |
| ini_set('html_errors', Config::get('fw_html_errors')); |
| } |
| $this->registre = Registre::getInstance(); |
| $this->registre->set('base_chemin_modele', Config::get('chemin_modeles')); |
| $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(); |
| } |
| /** |
| * Charge un modele donné et le rend disponible sous la forme $this->nom_modele |
| * |
| * @param string $nom_modele le nom du modèle à charger |
| * |
| * @return boolean false si le chargement a échoué, rien sinon |
| */ |
| final protected function chargerModele($nom_modele) { |
| $chemin_modele = ($this->registre->get('base_chemin_modele')).$nom_modele.'.php'; |
| if (!file_exists($chemin_modele)) { |
| return false; |
| } |
| include_once $chemin_modele; |
| if (!class_exists($nom_modele)) { |
| return false; |
| } |
| $this->$nom_modele = new $nom_modele; |
| } |
| /** |
| * Fonction prenant en paramètre le nom d'un squelette et un tableau associatif de données, |
| * en extrait les variables, charge le squelette |
| * et cree une variable de classe contenant les deux combinés. |
| * |
| * @param String $nom_squelette le nom du squelette |
| * @param Array $donnees un tableau associatif contenant les variables a injecter dans la vue |
| * |
| * @return boolean false si la vue n'existe pas, rien sinon |
| */ |
| final protected function chargerVue($nom_squelette,$donnees) { |
| $chemin_squelette = ($this->registre->get('base_chemin_squelette')).$nom_squelette.'.tpl.html'; |
| if (!file_exists($chemin_squelette)) { |
| return false ; |
| } |
| $donnees['base_url'] = $this->registre->get('base_url_application'); |
| // on extrait les variables du tableau de données |
| extract($donnees); |
| // et on enclenche la bufferisation de sortie |
| ob_start(); |
| // si les tags courts sont désactivés |
| if ((bool) @ini_get('short_open_tag') === false) { |
| // on remplace les tags par la syntaxe classique avec echo |
| echo eval('?>'.preg_replace("/;*\s*\?>/", "; ?>", str_replace('<?=', '<?php echo ', file_get_contents($chemin_squelette)))); |
| } else { |
| // sinon, on se contente d'inclure le squelette |
| include $chemin_squelette; |
| } |
| // on récupère le buffer et on le vide |
| $tampon = ob_get_contents(); |
| @ob_end_clean(); |
| // enfin on renvoie le contenu |
| $this->$nom_squelette = $tampon; |
| } |
| public function __destruct() { |
| $this->gestionnaire_exception->getExceptions(); |
| } |
| /** |
| * 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 |
| */ |
| final public function __construct() { |
| if (Config::existe('fw_html_errors')) { |
| ini_set('html_errors', Config::get('fw_html_errors')); |
| } |
| $this->registre = Registre::getInstance(); |
| $this->registre->set('base_chemin_modele', Config::get('chemin_modeles')); |
| $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(); |
| } |
| /** |
| * Charge un modele donné et le rend disponible sous la forme $this->nom_modele |
| * |
| * @param string $nom_modele le nom du modèle à charger |
| * |
| * @return boolean false si le chargement a échoué, rien sinon |
| */ |
| final protected function chargerModele($nom_modele) { |
| $chemin_modele = ($this->registre->get('base_chemin_modele')).$nom_modele.'.php'; |
| if (!file_exists($chemin_modele)) { |
| return false; |
| } |
| include_once $chemin_modele; |
| if (!class_exists($nom_modele)) { |
| return false; |
| } |
| $this->$nom_modele = new $nom_modele; |
| } |
| /** |
| * Fonction prenant en paramètre le nom d'un squelette et un tableau associatif de données, |
| * en extrait les variables, charge le squelette |
| * et cree une variable de classe contenant les deux combinés. |
| * |
| * @param String $nom_squelette le nom du squelette |
| * @param Array $donnees un tableau associatif contenant les variables a injecter dans la vue |
| * |
| * @return boolean false si la vue n'existe pas, rien sinon |
| */ |
| final protected function chargerVue($nom_squelette,$donnees) { |
| $chemin_squelette = ($this->registre->get('base_chemin_squelette')).$nom_squelette.'.tpl.html'; |
| if (!file_exists($chemin_squelette)) { |
| return false ; |
| } |
| $donnees['base_url'] = $this->registre->get('base_url_application'); |
| // on extrait les variables du tableau de données |
| extract($donnees); |
| // et on enclenche la bufferisation de sortie |
| ob_start(); |
| // si les tags courts sont désactivés |
| if ((bool) @ini_get('short_open_tag') === false) { |
| // on remplace les tags par la syntaxe classique avec echo |
| echo eval('?>'.preg_replace("/;*\s*\?>/", "; ?>", str_replace('<?=', '<?php echo ', file_get_contents($chemin_squelette)))); |
| } else { |
| // sinon, on se contente d'inclure le squelette |
| include $chemin_squelette; |
| } |
| // on récupère le buffer et on le vide |
| $tampon = ob_get_contents(); |
| @ob_end_clean(); |
| // enfin on renvoie le contenu |
| $this->$nom_squelette = $tampon; |
| } |
| public function __destruct() { |
| $this->gestionnaire_exception->getExceptions(); |
| } |
| } |
| ?> |
| /trunk/framework/GestionnaireErreur.php |
|---|
| 2,18 → 2,18 |
| // declare(encoding='UTF-8'); |
| /** |
| * classe de gestion des erreurs. |
| * |
| * PHP Version 5 |
| * |
| * |
| * PHP Version 5 |
| * |
| * @category Class |
| * @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 |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version SVN: $$Id$$ |
| * @link /doc/framework/ |
| * |
| * @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 GestionnaireErreur |
| { |
| 37,7 → 37,7 |
| * @access private |
| */ |
| private $contexte; |
| /** |
| * Contient le niveau d'erreur courant. Celui que l'on donne à la fonction |
| * error_reporting(). |
| 44,14 → 44,14 |
| * @access private |
| */ |
| private $niveau_erreur_courant; |
| /** |
| * Le gestionnaire d'erreur est un singleton |
| */ |
| private static $gestionnaire_erreurs; |
| /*** Constructeur: ***/ |
| /** |
| * Construit le gestionnaire d'erreur. |
| * |
| 64,9 → 64,9 |
| $this->erreurs = array(); |
| $this->setContexte($contexte); |
| $this->niveau_erreur_courant = 2048 ; |
| set_error_handler(array(&$this, 'gererErreur')); |
| //set_error_handler(array(&$this, 'gererErreur')); |
| } |
| /** |
| * Fonction d'accès au singleton |
| * @return GestionnaireErreur le gestionnaire d'erreurs courant |
| 79,7 → 79,7 |
| self::$gestionnaire_erreurs = new GestionnaireErreur ; |
| return self::$gestionnaire_erreurs; |
| } |
| /*** Accesseurs: ***/ |
| /** |
| * Récupère le tableau des erreurs. |
| 94,7 → 94,7 |
| /** |
| * Ajoute une erreur à la liste. |
| * |
| * @param array une_erreur |
| * @param array une_erreur |
| * @return void |
| * @access public |
| */ |
| 122,7 → 122,7 |
| public function setContexte( $un_contexte ) { |
| $this->contexte = $un_contexte; |
| } |
| /** |
| * Récupère le niveau d'erreur courrant. |
| * |
| 143,7 → 143,7 |
| public function setNiveauErreurCourant( $niveau = 2048 ) { |
| $this->niveau_erreur_courant = $niveau; |
| } |
| /** |
| * Définit le niveau d'erreur courrant (synonyme fonction precedente) |
| * |
| 154,10 → 154,10 |
| public function setActive ($niveau) { |
| $this->niveau_erreur_courant = $niveau; |
| } |
| /*** Méthodes : ***/ |
| /** |
| * |
| * @param int niveau |
| 185,7 → 185,7 |
| default: |
| $aso_erreur['message'] = $message; |
| } |
| $aso_erreur['fichier'] = $fichier; |
| $aso_erreur['ligne'] = $ligne; |
| if ($this->getContexte()) { |
| 193,7 → 193,7 |
| } |
| $this->setErreur($aso_erreur); |
| } |
| echo print_r($this->erreurs,true) ; |
| exit() ; |
| // Si nous avons affaire à une erreur et non à un warning ou une notice, nous arrêtons l'exécution du script |
| 225,7 → 225,7 |
| if ($aso_erreur['niveau'] == E_USER_NOTICE) { |
| $retour .= $aso_erreur['message']."\n"; |
| $retour .= 'Fichier : '.$aso_erreur['fichier']."\n"; |
| $retour .= 'Ligne : '.$aso_erreur['ligne']."\n"; |
| $retour .= 'Ligne : '.$aso_erreur['ligne']."\n"; |
| } else if ($aso_erreur['niveau'] <= 512) { |
| $retour .= 'INFO : Niveau '.$aso_erreur['niveau']."\n"; |
| } else { |
| 265,8 → 265,8 |
| } |
| $retour .= '</p>'."\n"; |
| } |
| } |
| } |
| return $retour; |
| } |
| 295,7 → 295,7 |
| $retour .= 'Requete : '."\n"; |
| $retour .= $requete."\n"; |
| } |
| if (!is_null($autres)) { |
| $retour .= 'Autres infos : '."\n"; |
| $retour .= $autres."\n"; |
| 308,18 → 308,18 |
| $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"; |
| 329,6 → 329,6 |
| $retour .= '<!-- END sql -->'."\n"; |
| } |
| return $retour; |
| } |
| } |
| } |
| ?> |
| /trunk/framework/autoload.inc.php |
|---|
| 3,15 → 3,15 |
| /** |
| * Fichier contenant la fonction de chargement automatique de classes, il doit toujours rester à la racine |
| * du framework car il initialise le chemin de l'application en se basant sur son propre emplacement. |
| * |
| * |
| * PHP Version 5.1.2 |
| * |
| * |
| * @category Fichier_De_Fonctions |
| * @package Framework |
| // Auteur principal : |
| // Auteur principal : |
| * @author Aurelien PERONNET <aurelien@tela-botanica.org> |
| // Autres auteurs : |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @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$$ |
| 19,12 → 19,12 |
| */ |
| // Redéfinition de la constante DIRECTORY_SEPARATOR |
| if (!defined('DS')) { |
| define('DS', DIRECTORY_SEPARATOR); |
| if (!defined('DS')) { |
| define('DS', DIRECTORY_SEPARATOR); |
| } |
| // Redéfinition de la constante PATH_SEPARATOR |
| if (!defined('PS')) { |
| define('PS', PATH_SEPARATOR); |
| if (!defined('PS')) { |
| define('PS', PATH_SEPARATOR); |
| } |
| // Autoload pour le Framework |
| 37,12 → 37,15 |
| } |
| spl_autoload_register('autoloadFw'); |
| //instanciation du gestionnaire d'exception |
| GestionnaireException::getInstance(); |
| // Autoload par défaut pour l'application |
| function autoloadAppliDefaut($nom_classe) { |
| $dossiers_classes = array( Config::get('chemin_controleurs'), |
| Config::get('chemin_modeles'), |
| Config::get('chemin_bibliotheque')); |
| foreach ($dossiers_classes as $chemin) { |
| $fichier_a_tester = $chemin.$nom_classe.'.php'; |
| if (file_exists($fichier_a_tester)) { |
| /trunk/framework/Url.php |
|---|
| 3,793 → 3,793 |
| /** |
| * classe Url, gérant le découpage des paramètres, leurs modification etc... |
| * Traduction et conversion d'une classe (NET_Url2) issue de Pear |
| * |
| * PHP Version 5 |
| * |
| * |
| * PHP Version 5 |
| * |
| * @category Class |
| * @package Framework |
| // auteur principal |
| * @author Christian Schmidt <schmidt@php.net> |
| * @author Christian Schmidt <schmidt@php.net> |
| // autre auteurs |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @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/ |
| * |
| * @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 Url |
| { |
| /** |
| * Parsing strict dans resoudre() (voir RFC 3986, section 5.2.2). Par défaut |
| * à true. |
| */ |
| const OPTION_STRICTE = 'strict'; |
| /** |
| * Parsing strict dans resoudre() (voir RFC 3986, section 5.2.2). Par défaut |
| * à true. |
| */ |
| const OPTION_STRICTE = 'strict'; |
| /** |
| * Répresenter les tableaux dans les requêtes en utilisant la notation php []. Par défaut à true. |
| */ |
| const OPTION_UTILISER_CROCHETS = 'use_brackets'; |
| /** |
| * Répresenter les tableaux dans les requêtes en utilisant la notation php []. Par défaut à true. |
| */ |
| const OPTION_UTILISER_CROCHETS = 'use_brackets'; |
| /** |
| * URL-encoder les clés des variables dans les requêtes. Par défaut à true. |
| */ |
| const OPTION_ENCODER_CLES = 'encode_keys'; |
| /** |
| * URL-encoder les clés des variables dans les requêtes. Par défaut à true. |
| */ |
| const OPTION_ENCODER_CLES = 'encode_keys'; |
| /** |
| * Séparateurs de variables lors du parsing de la requête. Chaque caractère |
| * est considéré comme un séparateur. Par défaut, spécifié par le paramêtre |
| * arg_separator.input dans php.ini (par défaut "&"). |
| */ |
| const OPTION_SEPARATEUR_ENTREE = 'input_separator'; |
| /** |
| * Séparateurs de variables lors du parsing de la requête. Chaque caractère |
| * est considéré comme un séparateur. Par défaut, spécifié par le paramêtre |
| * arg_separator.input dans php.ini (par défaut "&"). |
| */ |
| const OPTION_SEPARATEUR_ENTREE = 'input_separator'; |
| /** |
| * Séparateur de variables lors de la génération de la requête. Par défaut, spécifié |
| * par le paramètre arg_separator.output dans php.ini (par défaut "&"). |
| */ |
| const OPTION_SEPARATEUR_SORTIE = 'output_separator'; |
| /** |
| * Séparateur de variables lors de la génération de la requête. Par défaut, spécifié |
| * par le paramètre arg_separator.output dans php.ini (par défaut "&"). |
| */ |
| const OPTION_SEPARATEUR_SORTIE = 'output_separator'; |
| /** |
| * Options par défaut correspondant au comportement de php |
| * vis à vis de $_GET |
| */ |
| private $options = array( |
| self::OPTION_STRICTE => true, |
| self::OPTION_UTILISER_CROCHETS => true, |
| self::OPTION_ENCODER_CLES => true, |
| self::OPTION_SEPARATEUR_ENTREE => 'x&', |
| self::OPTION_SEPARATEUR_SORTIE => 'x&', |
| ); |
| /** |
| * Options par défaut correspondant au comportement de php |
| * vis à vis de $_GET |
| */ |
| private $options = array( |
| self::OPTION_STRICTE => true, |
| self::OPTION_UTILISER_CROCHETS => true, |
| self::OPTION_ENCODER_CLES => true, |
| self::OPTION_SEPARATEUR_ENTREE => 'x&', |
| self::OPTION_SEPARATEUR_SORTIE => 'x&', |
| ); |
| /** |
| * @var string|bool |
| */ |
| private $schema = false; |
| /** |
| * @var string|bool |
| */ |
| private $schema = false; |
| /** |
| * @var string|bool |
| */ |
| private $infoUtilisateur = false; |
| /** |
| * @var string|bool |
| */ |
| private $infoUtilisateur = false; |
| /** |
| * @var string|bool |
| */ |
| private $hote = false; |
| /** |
| * @var string|bool |
| */ |
| private $hote = false; |
| /** |
| * @var int|bool |
| */ |
| private $port = false; |
| /** |
| * @var int|bool |
| */ |
| private $port = false; |
| /** |
| * @var string |
| */ |
| private $chemin = ''; |
| /** |
| * @var string |
| */ |
| private $chemin = ''; |
| /** |
| * @var string|bool |
| */ |
| private $requete = false; |
| /** |
| * @var string|bool |
| */ |
| private $requete = false; |
| /** |
| * @var string|bool |
| */ |
| private $fragment = false; |
| /** |
| * @var string|bool |
| */ |
| private $fragment = false; |
| /** |
| * @param string $url une URL relative ou absolue |
| * @param array $options |
| */ |
| public function __construct($url, $options = null) |
| { |
| $this->setOption(self::OPTION_SEPARATEUR_ENTREE, |
| ini_get('arg_separator.input')); |
| $this->setOption(self::OPTION_SEPARATEUR_SORTIE, |
| ini_get('arg_separator.output')); |
| if (is_array($options)) { |
| foreach ($options as $nomOption => $valeur) { |
| $this->setOption($nomOption); |
| } |
| } |
| /** |
| * @param string $url une URL relative ou absolue |
| * @param array $options |
| */ |
| public function __construct($url, $options = null) |
| { |
| $this->setOption(self::OPTION_SEPARATEUR_ENTREE, |
| ini_get('arg_separator.input')); |
| $this->setOption(self::OPTION_SEPARATEUR_SORTIE, |
| ini_get('arg_separator.output')); |
| if (is_array($options)) { |
| foreach ($options as $nomOption => $valeur) { |
| $this->setOption($nomOption); |
| } |
| } |
| if (preg_match('@^([a-z][a-z0-9.+-]*):@i', $url, $reg)) { |
| $this->schema = $reg[1]; |
| $url = substr($url, strlen($reg[0])); |
| } |
| if (preg_match('@^([a-z][a-z0-9.+-]*):@i', $url, $reg)) { |
| $this->schema = $reg[1]; |
| $url = substr($url, strlen($reg[0])); |
| } |
| if (preg_match('@^//([^/#?]+)@', $url, $reg)) { |
| $this->setAutorite($reg[1]); |
| $url = substr($url, strlen($reg[0])); |
| } |
| if (preg_match('@^//([^/#?]+)@', $url, $reg)) { |
| $this->setAutorite($reg[1]); |
| $url = substr($url, strlen($reg[0])); |
| } |
| $i = strcspn($url, '?#'); |
| $this->chemin = substr($url, 0, $i); |
| $url = substr($url, $i); |
| $i = strcspn($url, '?#'); |
| $this->chemin = substr($url, 0, $i); |
| $url = substr($url, $i); |
| if (preg_match('@^\?([^#]*)@', $url, $reg)) { |
| $this->requete = $reg[1]; |
| $url = substr($url, strlen($reg[0])); |
| } |
| if (preg_match('@^\?([^#]*)@', $url, $reg)) { |
| $this->requete = $reg[1]; |
| $url = substr($url, strlen($reg[0])); |
| } |
| if ($url) { |
| $this->fragment = substr($url, 1); |
| } |
| } |
| if ($url) { |
| $this->fragment = substr($url, 1); |
| } |
| } |
| /** |
| * Retourne le schéma, c.a.d. "http" ou "urn", ou false si aucun schéma n'est |
| * spécifié, i.e. l'url est une url relative |
| * |
| * @return string|bool |
| */ |
| public function getSchema() |
| { |
| return $this->schema; |
| } |
| /** |
| * Retourne le schéma, c.a.d. "http" ou "urn", ou false si aucun schéma n'est |
| * spécifié, i.e. l'url est une url relative |
| * |
| * @return string|bool |
| */ |
| public function getSchema() |
| { |
| return $this->schema; |
| } |
| /** |
| * @param string|bool $schema |
| * |
| * @return void |
| * @see getSchema() |
| */ |
| public function setSchema($schema) |
| { |
| $this->schema = $schema; |
| } |
| /** |
| * @param string|bool $schema |
| * |
| * @return void |
| * @see getSchema() |
| */ |
| public function setSchema($schema) |
| { |
| $this->schema = $schema; |
| } |
| /** |
| * renvoie la partie user de la partie infoUtilisateur (partie précédant le premier |
| * ":"), ou false si aucune partie infoUtilisateur n'est définie. |
| * |
| * @return string|bool |
| */ |
| public function getUtilisateur() |
| { |
| return $this->infoUtilisateur !== false ? preg_replace('@:.*$@', '', $this->infoUtilisateur) : false; |
| } |
| /** |
| * renvoie la partie user de la partie infoUtilisateur (partie précédant le premier |
| * ":"), ou false si aucune partie infoUtilisateur n'est définie. |
| * |
| * @return string|bool |
| */ |
| public function getUtilisateur() |
| { |
| return $this->infoUtilisateur !== false ? preg_replace('@:.*$@', '', $this->infoUtilisateur) : false; |
| } |
| /** |
| * renvoie la partie mot de passe de la partie infoUtilisateur (partie après le premier |
| * ":"), , ou false si aucune partie infoUtilisateur n'est définie (i.e. l'URL ne contient |
| * pas de "@" en face du nom d'hôte) ou si la partie infoUtilisateur ne contient pas de ":". |
| * |
| * @return string|bool |
| */ |
| public function getMotDePasse() |
| { |
| return $this->infoUtilisateur !== false ? substr(strstr($this->infoUtilisateur, ':'), 1) : false; |
| } |
| /** |
| * renvoie la partie mot de passe de la partie infoUtilisateur (partie après le premier |
| * ":"), , ou false si aucune partie infoUtilisateur n'est définie (i.e. l'URL ne contient |
| * pas de "@" en face du nom d'hôte) ou si la partie infoUtilisateur ne contient pas de ":". |
| * |
| * @return string|bool |
| */ |
| public function getMotDePasse() |
| { |
| return $this->infoUtilisateur !== false ? substr(strstr($this->infoUtilisateur, ':'), 1) : false; |
| } |
| /** |
| * Renvoie la partie userinfio, ou false si celle-ci n'existe pas, i.e. si la partie |
| * autorité ne contient pas de "@" |
| * |
| * @return string|bool |
| */ |
| public function getInfoUtilisateur() |
| { |
| return $this->infoUtilisateur; |
| } |
| /** |
| * Renvoie la partie userinfio, ou false si celle-ci n'existe pas, i.e. si la partie |
| * autorité ne contient pas de "@" |
| * |
| * @return string|bool |
| */ |
| public function getInfoUtilisateur() |
| { |
| return $this->infoUtilisateur; |
| } |
| /** |
| * Setteur pour la partie infoUtilisateur. Si deux argument sont passé, ils sont combinés |
| * dans la partie infoUtilisateur de cette manière username ":" password. |
| * |
| * @param string|bool $infoUtilisateur infoUtilisateur ou username |
| * @param string|bool $motDePasse |
| * |
| * @return void |
| */ |
| public function setInfoUtilisateur($infoUtilisateur, $motDePasse = false) |
| { |
| $this->infoUtilisateur = $infoUtilisateur; |
| if ($motDePasse !== false) { |
| $this->infoUtilisateur .= ':' . $motDePasse; |
| } |
| } |
| /** |
| * Setteur pour la partie infoUtilisateur. Si deux argument sont passé, ils sont combinés |
| * dans la partie infoUtilisateur de cette manière username ":" password. |
| * |
| * @param string|bool $infoUtilisateur infoUtilisateur ou username |
| * @param string|bool $motDePasse |
| * |
| * @return void |
| */ |
| public function setInfoUtilisateur($infoUtilisateur, $motDePasse = false) |
| { |
| $this->infoUtilisateur = $infoUtilisateur; |
| if ($motDePasse !== false) { |
| $this->infoUtilisateur .= ':' . $motDePasse; |
| } |
| } |
| /** |
| * Renvoie la partie hôte, ou false s'il n'y a pas de partie autorité, c.a.d. |
| * l'URL est relative. |
| * |
| * @return string|bool |
| */ |
| public function getHote() |
| { |
| return $this->hote; |
| } |
| /** |
| * Renvoie la partie hôte, ou false s'il n'y a pas de partie autorité, c.a.d. |
| * l'URL est relative. |
| * |
| * @return string|bool |
| */ |
| public function getHote() |
| { |
| return $this->hote; |
| } |
| /** |
| * @param string|bool $hote |
| * |
| * @return void |
| */ |
| public function setHote($hote) |
| { |
| $this->hote = $hote; |
| } |
| /** |
| * @param string|bool $hote |
| * |
| * @return void |
| */ |
| public function setHote($hote) |
| { |
| $this->hote = $hote; |
| } |
| /** |
| * Renvoie le numéro de port, ou false si aucun numéro de port n'est spécifié, |
| * i.e. le port par défaut doit utilisé. |
| * |
| * @return int|bool |
| */ |
| public function getPort() |
| { |
| return $this->port; |
| } |
| /** |
| * Renvoie le numéro de port, ou false si aucun numéro de port n'est spécifié, |
| * i.e. le port par défaut doit utilisé. |
| * |
| * @return int|bool |
| */ |
| public function getPort() |
| { |
| return $this->port; |
| } |
| /** |
| * @param int|bool $port |
| * |
| * @return void |
| */ |
| public function setPort($port) |
| { |
| $this->port = intval($port); |
| } |
| /** |
| * @param int|bool $port |
| * |
| * @return void |
| */ |
| public function setPort($port) |
| { |
| $this->port = intval($port); |
| } |
| /** |
| * Renvoie la partie autorité, i.e. [ infoUtilisateur "@" ] hote [ ":" port ], ou |
| * false si celle-ci est absente. |
| * |
| * @return string|bool |
| */ |
| public function getAutorite() |
| { |
| if (!$this->hote) { |
| return false; |
| } |
| /** |
| * Renvoie la partie autorité, i.e. [ infoUtilisateur "@" ] hote [ ":" port ], ou |
| * false si celle-ci est absente. |
| * |
| * @return string|bool |
| */ |
| public function getAutorite() |
| { |
| if (!$this->hote) { |
| return false; |
| } |
| $autorite = ''; |
| $autorite = ''; |
| if ($this->infoUtilisateur !== false) { |
| $autorite .= $this->infoUtilisateur . '@'; |
| } |
| if ($this->infoUtilisateur !== false) { |
| $autorite .= $this->infoUtilisateur . '@'; |
| } |
| $autorite .= $this->hote; |
| $autorite .= $this->hote; |
| if ($this->port !== false) { |
| $autorite .= ':' . $this->port; |
| } |
| if ($this->port !== false) { |
| $autorite .= ':' . $this->port; |
| } |
| return $autorite; |
| } |
| return $autorite; |
| } |
| /** |
| * @param string|false $autorite |
| * |
| * @return void |
| */ |
| public function setAutorite($autorite) |
| { |
| $this->user = false; |
| $this->pass = false; |
| $this->hote = false; |
| $this->port = false; |
| if (preg_match('@^(([^\@]+)\@)?([^:]+)(:(\d*))?$@', $autorite, $reg)) { |
| if ($reg[1]) { |
| $this->infoUtilisateur = $reg[2]; |
| } |
| /** |
| * @param string|false $autorite |
| * |
| * @return void |
| */ |
| public function setAutorite($autorite) |
| { |
| $this->user = false; |
| $this->pass = false; |
| $this->hote = false; |
| $this->port = false; |
| if (preg_match('@^(([^\@]+)\@)?([^:]+)(:(\d*))?$@', $autorite, $reg)) { |
| if ($reg[1]) { |
| $this->infoUtilisateur = $reg[2]; |
| } |
| $this->hote = $reg[3]; |
| if (isset($reg[5])) { |
| $this->port = intval($reg[5]); |
| } |
| } |
| } |
| $this->hote = $reg[3]; |
| if (isset($reg[5])) { |
| $this->port = intval($reg[5]); |
| } |
| } |
| } |
| /** |
| * Renvoie la partie chemin (chemin) (éventuellement vide). |
| * |
| * @return string |
| */ |
| public function getChemin() |
| { |
| return $this->chemin; |
| } |
| /** |
| * Renvoie la partie chemin (chemin) (éventuellement vide). |
| * |
| * @return string |
| */ |
| public function getChemin() |
| { |
| return $this->chemin; |
| } |
| /** |
| * @param string $chemin |
| * |
| * @return void |
| */ |
| public function setChemin($chemin) |
| { |
| $this->chemin = $chemin; |
| } |
| /** |
| * @param string $chemin |
| * |
| * @return void |
| */ |
| public function setChemin($chemin) |
| { |
| $this->chemin = $chemin; |
| } |
| /** |
| * renvoie la chaine de requête (requete string) (sans le premier "?"), ou false si "?" |
| * n'est pas présent dans l'url. |
| * |
| * @return string|bool |
| * @see self::getVariablesRequete() |
| */ |
| public function getRequete() |
| { |
| return $this->requete; |
| } |
| /** |
| * renvoie la chaine de requête (requete string) (sans le premier "?"), ou false si "?" |
| * n'est pas présent dans l'url. |
| * |
| * @return string|bool |
| * @see self::getVariablesRequete() |
| */ |
| public function getRequete() |
| { |
| return $this->requete; |
| } |
| /** |
| * @param string|bool $requete |
| * |
| * @return void |
| * @see self::setVariablesRequete() |
| */ |
| public function setRequete($requete) |
| { |
| $this->requete = $requete; |
| } |
| /** |
| * @param string|bool $requete |
| * |
| * @return void |
| * @see self::setVariablesRequete() |
| */ |
| public function setRequete($requete) |
| { |
| $this->requete = $requete; |
| } |
| /** |
| * Renvoie le nom du fragment, ou false si "#" n'est pas present dans l'URL. |
| * |
| * @return string|bool |
| */ |
| public function getFragment() |
| { |
| return $this->fragment; |
| } |
| /** |
| * Renvoie le nom du fragment, ou false si "#" n'est pas present dans l'URL. |
| * |
| * @return string|bool |
| */ |
| public function getFragment() |
| { |
| return $this->fragment; |
| } |
| /** |
| * @param string|bool $fragment |
| * |
| * @return void |
| */ |
| public function setFragment($fragment) |
| { |
| $this->fragment = $fragment; |
| } |
| /** |
| * @param string|bool $fragment |
| * |
| * @return void |
| */ |
| public function setFragment($fragment) |
| { |
| $this->fragment = $fragment; |
| } |
| /** |
| * Renvoie la requete string sous forme d'un tableau de variables telles qu'elles apparaitraient |
| * dans le $_GET d'un script PHP |
| * |
| * @return array |
| */ |
| public function getVariablesRequete() |
| { |
| $pattern = '/[' . |
| preg_quote($this->getOption(self::OPTION_SEPARATEUR_ENTREE), '/') . |
| ']/'; |
| $parties = preg_split($pattern, $this->requete, -1, PREG_SPLIT_NO_EMPTY); |
| $retour = array(); |
| /** |
| * Renvoie la requete string sous forme d'un tableau de variables telles qu'elles apparaitraient |
| * dans le $_GET d'un script PHP |
| * |
| * @return array |
| */ |
| public function getVariablesRequete() |
| { |
| $pattern = '/[' . |
| preg_quote($this->getOption(self::OPTION_SEPARATEUR_ENTREE), '/') . |
| ']/'; |
| $parties = preg_split($pattern, $this->requete, -1, PREG_SPLIT_NO_EMPTY); |
| $retour = array(); |
| foreach ($parties as $partie) { |
| if (strpos($partie, '=') !== false) { |
| list($cle, $valeur) = explode('=', $partie, 2); |
| } else { |
| $cle = $partie; |
| $valeur = null; |
| } |
| foreach ($parties as $partie) { |
| if (strpos($partie, '=') !== false) { |
| list($cle, $valeur) = explode('=', $partie, 2); |
| } else { |
| $cle = $partie; |
| $valeur = null; |
| } |
| if ($this->getOption(self::OPTION_ENCODER_CLES)) { |
| $cle = rawurldecode($cle); |
| } |
| $valeur = rawurldecode($valeur); |
| if ($this->getOption(self::OPTION_ENCODER_CLES)) { |
| $cle = rawurldecode($cle); |
| } |
| $valeur = rawurldecode($valeur); |
| if ($this->getOption(self::OPTION_UTILISER_CROCHETS) && |
| preg_match('#^(.*)\[([0-9a-z_-]*)\]#i', $cle, $matches)) { |
| if ($this->getOption(self::OPTION_UTILISER_CROCHETS) && |
| preg_match('#^(.*)\[([0-9a-z_-]*)\]#i', $cle, $matches)) { |
| $cle = $matches[1]; |
| $idx = $matches[2]; |
| $cle = $matches[1]; |
| $idx = $matches[2]; |
| // On s'assure que c'est bien un tableau |
| if (empty($retour[$cle]) || !is_array($retour[$cle])) { |
| $retour[$cle] = array(); |
| } |
| // On s'assure que c'est bien un tableau |
| if (empty($retour[$cle]) || !is_array($retour[$cle])) { |
| $retour[$cle] = array(); |
| } |
| // Ajout des données |
| if ($idx === '') { |
| $retour[$cle][] = $valeur; |
| } else { |
| $retour[$cle][$idx] = $valeur; |
| } |
| } elseif (!$this->getOption(self::OPTION_UTILISER_CROCHETS) |
| && !empty($retour[$cle]) |
| ) { |
| $retour[$cle] = (array) $retour[$cle]; |
| $retour[$cle][] = $valeur; |
| } else { |
| $retour[$cle] = $valeur; |
| } |
| } |
| // Ajout des données |
| if ($idx === '') { |
| $retour[$cle][] = $valeur; |
| } else { |
| $retour[$cle][$idx] = $valeur; |
| } |
| } elseif (!$this->getOption(self::OPTION_UTILISER_CROCHETS) |
| && !empty($retour[$cle]) |
| ) { |
| $retour[$cle] = (array) $retour[$cle]; |
| $retour[$cle][] = $valeur; |
| } else { |
| $retour[$cle] = $valeur; |
| } |
| } |
| return $retour; |
| } |
| return $retour; |
| } |
| /** |
| * @param array $tableau (nom => valeur) tableau |
| * |
| * @return void |
| */ |
| public function setVariablesRequete(array $tableau) |
| { |
| if (!$tableau) { |
| $this->requete = false; |
| } else { |
| foreach ($tableau as $nom => $valeur) { |
| if ($this->getOption(self::OPTION_ENCODER_CLES)) { |
| $nom = rawurlencode($nom); |
| } |
| /** |
| * @param array $tableau (nom => valeur) tableau |
| * |
| * @return void |
| */ |
| public function setVariablesRequete(array $tableau) |
| { |
| if (!$tableau) { |
| $this->requete = false; |
| } else { |
| foreach ($tableau as $nom => $valeur) { |
| if ($this->getOption(self::OPTION_ENCODER_CLES)) { |
| $nom = rawurlencode($nom); |
| } |
| if (is_array($valeur)) { |
| foreach ($valeur as $k => $v) { |
| $parties[] = $this->getOption(self::OPTION_UTILISER_CROCHETS) |
| ? sprintf('%s[%s]=%s', $nom, $k, $v) |
| : ($nom . '=' . $v); |
| } |
| } elseif (!is_null($valeur)) { |
| $parties[] = $nom . '=' . $valeur; |
| } else { |
| $parties[] = $nom; |
| } |
| } |
| $this->requete = implode($this->getOption(self::OPTION_SEPARATEUR_SORTIE), |
| $parties); |
| } |
| } |
| if (is_array($valeur)) { |
| foreach ($valeur as $k => $v) { |
| $parties[] = $this->getOption(self::OPTION_UTILISER_CROCHETS) |
| ? sprintf('%s[%s]=%s', $nom, $k, $v) |
| : ($nom . '=' . $v); |
| } |
| } elseif (!is_null($valeur)) { |
| $parties[] = $nom . '=' . $valeur; |
| } else { |
| $parties[] = $nom; |
| } |
| } |
| $this->requete = implode($this->getOption(self::OPTION_SEPARATEUR_SORTIE), |
| $parties); |
| } |
| } |
| /** |
| * @param string $nom |
| * @param mixed $valeur |
| * |
| * @return array |
| */ |
| public function setVariableRequete($nom, $valeur) |
| { |
| $tableau = $this->getVariablesRequete(); |
| $tableau[$nom] = $valeur; |
| $this->setVariablesRequete($tableau); |
| } |
| /** |
| * @param string $nom |
| * @param mixed $valeur |
| * |
| * @return array |
| */ |
| public function setVariableRequete($nom, $valeur) |
| { |
| $tableau = $this->getVariablesRequete(); |
| $tableau[$nom] = $valeur; |
| $this->setVariablesRequete($tableau); |
| } |
| /** |
| * @param string $nom |
| * |
| * @return void |
| */ |
| public function unsetVariableRequete($nom) |
| { |
| $tableau = $this->getVariablesRequete(); |
| unset($tableau[$nom]); |
| $this->setVariablesRequete($tableau); |
| } |
| /** |
| * @param string $nom |
| * |
| * @return void |
| */ |
| public function unsetVariableRequete($nom) |
| { |
| $tableau = $this->getVariablesRequete(); |
| unset($tableau[$nom]); |
| $this->setVariablesRequete($tableau); |
| } |
| /** |
| * Renvoie un représentation sous forme de chaine de l'URL |
| * |
| * @return string |
| */ |
| public function getURL() |
| { |
| // Voir RFC 3986, section 5.3 |
| $url = ""; |
| /** |
| * Renvoie un représentation sous forme de chaine de l'URL |
| * |
| * @return string |
| */ |
| public function getURL() |
| { |
| // Voir RFC 3986, section 5.3 |
| $url = ""; |
| if ($this->schema !== false) { |
| $url .= $this->schema . ':'; |
| } |
| if ($this->schema !== false) { |
| $url .= $this->schema . ':'; |
| } |
| $autorite = $this->getAutorite(); |
| if ($autorite !== false) { |
| $url .= '//' . $autorite; |
| } |
| $url .= $this->chemin; |
| $autorite = $this->getAutorite(); |
| if ($autorite !== false) { |
| $url .= '//' . $autorite; |
| } |
| $url .= $this->chemin; |
| if ($this->requete !== false) { |
| $url .= '?' . $this->requete; |
| } |
| if ($this->requete !== false) { |
| $url .= '?' . $this->requete; |
| } |
| if ($this->fragment !== false) { |
| $url .= '#' . $this->fragment; |
| } |
| return $url; |
| } |
| if ($this->fragment !== false) { |
| $url .= '#' . $this->fragment; |
| } |
| /** |
| * Renvoie une représentation de cette URL sous forme de chaine normalisée. Utile pour la |
| * comparaison d'URLs |
| * |
| * @return string |
| */ |
| public function getURLNormalisee() |
| { |
| $url = clone $this; |
| $url->normaliser(); |
| return $url->getUrl(); |
| } |
| return $url; |
| } |
| /** |
| * Renvoie une instance normalisée de Url |
| * |
| * @return Url |
| */ |
| public function normaliser() |
| { |
| // See RFC 3886, section 6 |
| /** |
| * Renvoie une représentation de cette URL sous forme de chaine normalisée. Utile pour la |
| * comparaison d'URLs |
| * |
| * @return string |
| */ |
| public function getURLNormalisee() |
| { |
| $url = clone $this; |
| $url->normaliser(); |
| return $url->getUrl(); |
| } |
| // les cchémas sont insesibles à la casse |
| if ($this->schema) { |
| $this->schema = strtolower($this->schema); |
| } |
| /** |
| * Renvoie une instance normalisée de Url |
| * |
| * @return Url |
| */ |
| public function normaliser() |
| { |
| // See RFC 3886, section 6 |
| // les noms d'hotes sont insensibles à la casse |
| if ($this->hote) { |
| $this->hote = strtolower($this->hote); |
| } |
| // les cchémas sont insesibles à la casse |
| if ($this->schema) { |
| $this->schema = strtolower($this->schema); |
| } |
| // Supprimer le numéro de port par défaut pour les schemas connus (RFC 3986, section 6.2.3) |
| if ($this->port && |
| $this->schema && |
| $this->port == getservbyname($this->schema, 'tcp')) { |
| // les noms d'hotes sont insensibles à la casse |
| if ($this->hote) { |
| $this->hote = strtolower($this->hote); |
| } |
| $this->port = false; |
| } |
| // Supprimer le numéro de port par défaut pour les schemas connus (RFC 3986, section 6.2.3) |
| if ($this->port && |
| $this->schema && |
| $this->port == getservbyname($this->schema, 'tcp')) { |
| // normalisation dans le cas d'un encodage avec %XX pourcentage (RFC 3986, section 6.2.2.1) |
| foreach (array('infoUtilisateur', 'hote', 'chemin') as $partie) { |
| if ($this->$partie) { |
| $this->$partie = preg_replace('/%[0-9a-f]{2}/ie', 'strtoupper("\0")', $this->$partie); |
| } |
| } |
| $this->port = false; |
| } |
| // normalisation des segments du chemin (RFC 3986, section 6.2.2.3) |
| $this->chemin = self::supprimerSegmentsAPoints($this->chemin); |
| // normalisation dans le cas d'un encodage avec %XX pourcentage (RFC 3986, section 6.2.2.1) |
| foreach (array('infoUtilisateur', 'hote', 'chemin') as $partie) { |
| if ($this->$partie) { |
| $this->$partie = preg_replace('/%[0-9a-f]{2}/ie', 'strtoupper("\0")', $this->$partie); |
| } |
| } |
| // normalisation basée sur le schéma (RFC 3986, section 6.2.3) |
| if ($this->hote && !$this->chemin) { |
| $this->chemin = '/'; |
| } |
| } |
| // normalisation des segments du chemin (RFC 3986, section 6.2.2.3) |
| $this->chemin = self::supprimerSegmentsAPoints($this->chemin); |
| /** |
| * Renvoie vrai ou faux suivant que l'instance en cours représente une URL relative ou absolue. |
| * |
| * @return bool |
| */ |
| public function etreAbsolue() |
| { |
| return (bool) $this->schema; |
| } |
| // normalisation basée sur le schéma (RFC 3986, section 6.2.3) |
| if ($this->hote && !$this->chemin) { |
| $this->chemin = '/'; |
| } |
| } |
| /** |
| * Renvoie une instance de Url représentant une URL absolue relative à |
| * cette URL. |
| * |
| * @param Url|string $reference URL relative |
| * |
| * @return Url |
| */ |
| public function resoudre($reference) |
| { |
| if (is_string($reference)) { |
| $reference = new self($reference); |
| } |
| if (!$this->etreAbsolue()) { |
| throw new Exception('L\'URL de base doit être absolue !'); |
| } |
| /** |
| * Renvoie vrai ou faux suivant que l'instance en cours représente une URL relative ou absolue. |
| * |
| * @return bool |
| */ |
| public function etreAbsolue() |
| { |
| return (bool) $this->schema; |
| } |
| // Un parseur non strict peut choisir d'ignorer un schema dans la référence |
| // si celui ci est identique au schéma de base de l'URI. |
| if (!$this->getOption(self::OPTION_STRICTE) && $reference->schema == $this->schema) { |
| $reference->schema = false; |
| } |
| /** |
| * Renvoie une instance de Url représentant une URL absolue relative à |
| * cette URL. |
| * |
| * @param Url|string $reference URL relative |
| * |
| * @return Url |
| */ |
| public function resoudre($reference) |
| { |
| if (is_string($reference)) { |
| $reference = new self($reference); |
| } |
| if (!$this->etreAbsolue()) { |
| throw new Exception('L\'URL de base doit être absolue !'); |
| } |
| $cible = new self(''); |
| if ($reference->schema !== false) { |
| $cible->schema = $reference->schema; |
| $cible->setAutorite($reference->getAutorite()); |
| $cible->chemin = self::supprimerSegmentsAPoints($reference->chemin); |
| $cible->requete = $reference->requete; |
| } else { |
| $autorite = $reference->getAutorite(); |
| if ($autorite !== false) { |
| $cible->setAutorite($autorite); |
| $cible->chemin = self::supprimerSegmentsAPoints($reference->chemin); |
| $cible->requete = $reference->requete; |
| } else { |
| if ($reference->chemin == '') { |
| $cible->chemin = $this->chemin; |
| if ($reference->requete !== false) { |
| $cible->requete = $reference->requete; |
| } else { |
| $cible->requete = $this->requete; |
| } |
| } else { |
| if (substr($reference->chemin, 0, 1) == '/') { |
| $cible->chemin = self::supprimerSegmentsAPoints($reference->chemin); |
| } else { |
| // Concaténation chemins (RFC 3986, section 5.2.3) |
| if ($this->hote !== false && $this->chemin == '') { |
| $cible->chemin = '/' . $this->chemin; |
| } else { |
| $i = strrpos($this->chemin, '/'); |
| if ($i !== false) { |
| $cible->chemin = substr($this->chemin, 0, $i + 1); |
| } |
| $cible->chemin .= $reference->chemin; |
| } |
| $cible->chemin = self::supprimerSegmentsAPoints($cible->chemin); |
| } |
| $cible->requete = $reference->requete; |
| } |
| $cible->setAutorite($this->getAutorite()); |
| } |
| $cible->schema = $this->schema; |
| } |
| // Un parseur non strict peut choisir d'ignorer un schema dans la référence |
| // si celui ci est identique au schéma de base de l'URI. |
| if (!$this->getOption(self::OPTION_STRICTE) && $reference->schema == $this->schema) { |
| $reference->schema = false; |
| } |
| $cible->fragment = $reference->fragment; |
| $cible = new self(''); |
| if ($reference->schema !== false) { |
| $cible->schema = $reference->schema; |
| $cible->setAutorite($reference->getAutorite()); |
| $cible->chemin = self::supprimerSegmentsAPoints($reference->chemin); |
| $cible->requete = $reference->requete; |
| } else { |
| $autorite = $reference->getAutorite(); |
| if ($autorite !== false) { |
| $cible->setAutorite($autorite); |
| $cible->chemin = self::supprimerSegmentsAPoints($reference->chemin); |
| $cible->requete = $reference->requete; |
| } else { |
| if ($reference->chemin == '') { |
| $cible->chemin = $this->chemin; |
| if ($reference->requete !== false) { |
| $cible->requete = $reference->requete; |
| } else { |
| $cible->requete = $this->requete; |
| } |
| } else { |
| if (substr($reference->chemin, 0, 1) == '/') { |
| $cible->chemin = self::supprimerSegmentsAPoints($reference->chemin); |
| } else { |
| // Concaténation chemins (RFC 3986, section 5.2.3) |
| if ($this->hote !== false && $this->chemin == '') { |
| $cible->chemin = '/' . $this->chemin; |
| } else { |
| $i = strrpos($this->chemin, '/'); |
| if ($i !== false) { |
| $cible->chemin = substr($this->chemin, 0, $i + 1); |
| } |
| $cible->chemin .= $reference->chemin; |
| } |
| $cible->chemin = self::supprimerSegmentsAPoints($cible->chemin); |
| } |
| $cible->requete = $reference->requete; |
| } |
| $cible->setAutorite($this->getAutorite()); |
| } |
| $cible->schema = $this->schema; |
| } |
| return $cible; |
| } |
| $cible->fragment = $reference->fragment; |
| /** |
| * La suppression des segments à points est décrite dans la RFC 3986, section 5.2.4, e.g. |
| * "/foo/../bar/baz" => "/bar/baz" |
| * |
| * @param string $chemin un chemin |
| * |
| * @return string un chemin |
| */ |
| private static function supprimerSegmentsAPoints($chemin) |
| { |
| $sortie = ''; |
| return $cible; |
| } |
| // Assurons de ne pas nous retrouver piégés dans une boucle infinie due à un bug de |
| // cette méthode |
| $j = 0; |
| while ($chemin && $j++ < 100) { |
| // Étape A |
| if (substr($chemin, 0, 2) == './') { |
| $chemin = substr($chemin, 2); |
| } elseif (substr($chemin, 0, 3) == '../') { |
| $chemin = substr($chemin, 3); |
| /** |
| * La suppression des segments à points est décrite dans la RFC 3986, section 5.2.4, e.g. |
| * "/foo/../bar/baz" => "/bar/baz" |
| * |
| * @param string $chemin un chemin |
| * |
| * @return string un chemin |
| */ |
| private static function supprimerSegmentsAPoints($chemin) |
| { |
| $sortie = ''; |
| // Étape B |
| } elseif (substr($chemin, 0, 3) == '/./' || $chemin == '/.') { |
| $chemin = '/' . substr($chemin, 3); |
| // Assurons de ne pas nous retrouver piégés dans une boucle infinie due à un bug de |
| // cette méthode |
| $j = 0; |
| while ($chemin && $j++ < 100) { |
| // Étape A |
| if (substr($chemin, 0, 2) == './') { |
| $chemin = substr($chemin, 2); |
| } elseif (substr($chemin, 0, 3) == '../') { |
| $chemin = substr($chemin, 3); |
| // Étape C |
| } elseif (substr($chemin, 0, 4) == '/../' || $chemin == '/..') { |
| $chemin = '/' . substr($chemin, 4); |
| $i = strrpos($sortie, '/'); |
| $sortie = $i === false ? '' : substr($sortie, 0, $i); |
| // Étape B |
| } elseif (substr($chemin, 0, 3) == '/./' || $chemin == '/.') { |
| $chemin = '/' . substr($chemin, 3); |
| // Étape D |
| } elseif ($chemin == '.' || $chemin == '..') { |
| $chemin = ''; |
| // Étape C |
| } elseif (substr($chemin, 0, 4) == '/../' || $chemin == '/..') { |
| $chemin = '/' . substr($chemin, 4); |
| $i = strrpos($sortie, '/'); |
| $sortie = $i === false ? '' : substr($sortie, 0, $i); |
| // Étape E |
| } else { |
| $i = strpos($chemin, '/'); |
| if ($i === 0) { |
| $i = strpos($chemin, '/', 1); |
| } |
| if ($i === false) { |
| $i = strlen($chemin); |
| } |
| $sortie .= substr($chemin, 0, $i); |
| $chemin = substr($chemin, $i); |
| } |
| } |
| // Étape D |
| } elseif ($chemin == '.' || $chemin == '..') { |
| $chemin = ''; |
| return $sortie; |
| } |
| // Étape E |
| } else { |
| $i = strpos($chemin, '/'); |
| if ($i === 0) { |
| $i = strpos($chemin, '/', 1); |
| } |
| if ($i === false) { |
| $i = strlen($chemin); |
| } |
| $sortie .= substr($chemin, 0, $i); |
| $chemin = substr($chemin, $i); |
| } |
| } |
| /** |
| * Renvoie une instance de Url representant l'URL canonique du script PHP |
| * en cours d'éxécution |
| * |
| * @return string |
| */ |
| public static function getCanonique() |
| { |
| if (!isset($_SERVER['REQUEST_METHOD'])) { |
| // ALERT - pas d'URL en cours |
| throw new Exception('Le script n\'a pas été appellé à travers un serveur web'); |
| } |
| return $sortie; |
| } |
| // on part d'une URL relative |
| $url = new self($_SERVER['PHP_SELF']); |
| $url->schema = isset($_SERVER['HTTPS']) ? 'https' : 'http'; |
| $url->hote = $_SERVER['SERVER_NAME']; |
| $port = intval($_SERVER['SERVER_PORT']); |
| if ($url->schema == 'http' && $port != 80 || |
| $url->schema == 'https' && $port != 443) { |
| /** |
| * Renvoie une instance de Url representant l'URL canonique du script PHP |
| * en cours d'éxécution |
| * |
| * @return string |
| */ |
| public static function getCanonique() |
| { |
| if (!isset($_SERVER['REQUEST_METHOD'])) { |
| // ALERT - pas d'URL en cours |
| throw new Exception('Le script n\'a pas été appellé à travers un serveur web'); |
| } |
| $url->port = $port; |
| } |
| return $url; |
| } |
| // on part d'une URL relative |
| $url = new self($_SERVER['PHP_SELF']); |
| $url->schema = isset($_SERVER['HTTPS']) ? 'https' : 'http'; |
| $url->hote = $_SERVER['SERVER_NAME']; |
| $port = intval($_SERVER['SERVER_PORT']); |
| if ($url->schema == 'http' && $port != 80 || |
| $url->schema == 'https' && $port != 443) { |
| /** |
| * Renvoie l'URL utilisée pour récupérer la requête en cours |
| * |
| * @return string |
| */ |
| public static function getURLDemande() |
| { |
| return self::getDemande()->getUrl(); |
| } |
| $url->port = $port; |
| } |
| return $url; |
| } |
| /** |
| * Renvoie une instance de Url representant l'URL utilisée pour |
| * récupérer la requête en cours |
| * |
| * @return Url |
| */ |
| public static function getDemande() |
| { |
| if (!isset($_SERVER['REQUEST_METHOD'])) { |
| // ALERTE - pas d'URL en cours |
| throw new Exception('Le script n\'a pas été appellé à travers un serveur web'); |
| } |
| /** |
| * Renvoie l'URL utilisée pour récupérer la requête en cours |
| * |
| * @return string |
| */ |
| public static function getURLDemande() |
| { |
| return self::getDemande()->getUrl(); |
| } |
| // On part d'une URL relative |
| $url = new self($_SERVER['REQUEST_URI']); |
| $url->schema = isset($_SERVER['HTTPS']) ? 'https' : 'http'; |
| // On met à jour les valeurs de l'hote et si possible du port |
| $url->setAutorite($_SERVER['HTTP_hote']); |
| return $url; |
| } |
| /** |
| * Renvoie une instance de Url representant l'URL utilisée pour |
| * récupérer la requête en cours |
| * |
| * @return Url |
| */ |
| public static function getDemande() |
| { |
| if (!isset($_SERVER['REQUEST_METHOD'])) { |
| // ALERTE - pas d'URL en cours |
| throw new Exception('Le script n\'a pas été appellé à travers un serveur web'); |
| } |
| /** |
| * Met à jour la valeur de l'option spécifiée. |
| * |
| * @param string $nomOption une des constantes commençant par self::OPTION_ |
| * @param mixed $valeur valeur de l'option |
| * |
| * @return void |
| * @see self::OPTION_STRICTE |
| * @see self::OPTION_UTILISER_CROCHETS |
| * @see self::OPTION_ENCODER_CLES |
| */ |
| function setOption($nomOption, $valeur) |
| { |
| if (!array_key_exists($nomOption, $this->options)) { |
| return false; |
| } |
| $this->options[$nomOption] = $valeur; |
| } |
| // On part d'une URL relative |
| $url = new self($_SERVER['REQUEST_URI']); |
| $url->schema = isset($_SERVER['HTTPS']) ? 'https' : 'http'; |
| // On met à jour les valeurs de l'hote et si possible du port |
| $url->setAutorite($_SERVER['HTTP_hote']); |
| return $url; |
| } |
| /** |
| * Renvoie la valeur de l'option specifiée. |
| * |
| * @param string $nomOption Nom de l'option demandée |
| * |
| * @return mixed |
| */ |
| function getOption($nomOption) |
| { |
| return isset($this->options[$nomOption]) |
| ? $this->options[$nomOption] : false; |
| } |
| public function __toString() { |
| return $this->getURL(); |
| } |
| /** |
| * Met à jour la valeur de l'option spécifiée. |
| * |
| * @param string $nomOption une des constantes commençant par self::OPTION_ |
| * @param mixed $valeur valeur de l'option |
| * |
| * @return void |
| * @see self::OPTION_STRICTE |
| * @see self::OPTION_UTILISER_CROCHETS |
| * @see self::OPTION_ENCODER_CLES |
| */ |
| function setOption($nomOption, $valeur) |
| { |
| if (!array_key_exists($nomOption, $this->options)) { |
| return false; |
| } |
| $this->options[$nomOption] = $valeur; |
| } |
| /** |
| * Renvoie la valeur de l'option specifiée. |
| * |
| * @param string $nomOption Nom de l'option demandée |
| * |
| * @return mixed |
| */ |
| function getOption($nomOption) |
| { |
| return isset($this->options[$nomOption]) |
| ? $this->options[$nomOption] : false; |
| } |
| public function __toString() { |
| return $this->getURL(); |
| } |
| } |
| /trunk/framework/Registre.php |
|---|
| 3,18 → 3,18 |
| /** |
| * Classe registre, qui permet un accès à différentes variables à travers les autres classes. |
| * C'est un singleton |
| * |
| * PHP Version 5 |
| * |
| * |
| * PHP Version 5 |
| * |
| * @category Class |
| * @package Framework |
| * @author Jean-Pascal Milcent <jmp@tela-botanica.org> |
| * @author Jean-Pascal Milcent <jmp@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/ |
| * |
| * @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 Registre { |
| 42,7 → 42,7 |
| return self::$registre; |
| } |
| self::$registre = new Registre; |
| return self::$registre; |
| return self::$registre; |
| } |
| /** |
| /trunk/framework/Chronometre.php |
|---|
| 1,165 → 1,165 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** Fichier de la classe Chronometre |
| * |
| * PHP Version 5 |
| * |
| * |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package Framework |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @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/ |
| * @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 |
| /** Classe Chronometre() - Permet de stocker et d'afficher |
| * les temps d'éxécution de script. |
| * |
| * Cette classe permet de réaliser un ensemble |
| * 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 |
| * |
| * |
| * |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package Framework |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @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/ |
| * @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(); |
| /*** Attributs : ***/ |
| private $_temps = array(); |
| /** Constructeur : **/ |
| public function __construct() { |
| $this->setTemps(array('depart' => microtime())); |
| } |
| /** Constructeur : **/ |
| public function __construct() { |
| $this->setTemps(array('depart' => microtime())); |
| } |
| /** Accesseurs : |
| * |
| * @param string $cle la cle associ�e � un chronom�tre particulier |
| * |
| * @return int le temps �coul� |
| */ |
| public function getTemps($cle = null) { |
| $temps = ''; |
| if (!is_null($cle)) { |
| $temps = $this->_temps[$cle]; |
| } else { |
| $temps = $this->_temps; |
| } |
| return $temps; |
| } |
| /** Accesseurs : |
| * |
| * @param string $cle la cle associ�e � un chronom�tre particulier |
| * |
| * @return int le temps �coul� |
| */ |
| public function getTemps($cle = null) { |
| $temps = ''; |
| if (!is_null($cle)) { |
| $temps = $this->_temps[$cle]; |
| } else { |
| $temps = $this->_temps; |
| } |
| return $temps; |
| } |
| /** Setteur pour la variable temps |
| * |
| * @param array() $moment ajoute des points de chronom�trage au tableau _temps |
| * |
| * @return null |
| */ |
| public function setTemps($moment = array ()) { |
| array_push($this->_temps, $moment); |
| } |
| /** Setteur pour la variable temps |
| * |
| * @param array() $moment ajoute des points de chronom�trage au tableau _temps |
| * |
| * @return null |
| */ |
| public function setTemps($moment = array ()) { |
| array_push($this->_temps, $moment); |
| } |
| /*** Méthodes : ***/ |
| /*** 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 $indentation_origine l'indentation de base. |
| * @param int $indentation le pas d'indentation. |
| * @return string la chaine XHTML de mesure des temps. |
| */ |
| public function afficherChrono($indentation_origine = 8, $indentation = 4) { |
| // Création du chrono de fin |
| $GLOBALS['_SCRIPT_']['chrono']->setTemps(array ( |
| 'fin' => microtime() |
| )); |
| /** 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 $indentation_origine l'indentation de base. |
| * @param int $indentation le pas d'indentation. |
| * @return string la chaine XHTML de mesure des temps. |
| */ |
| public 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"; |
| // 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"; |
| $tbody = str_repeat(' ', ($indentation_origine + ($indentation * 1))) . |
| '<tbody>' . "\n"; |
| $total_tps_ecoule = 0; |
| $total_tps_ecoule = 0; |
| // Récupération de la premiére mesure |
| $tab_depart = & $this->getTemps(0); |
| list ($usec, $sec) = explode(' ', $tab_depart['depart']); |
| // 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); |
| // 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); |
| 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; |
| $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"; |
| $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"; |
| $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; |
| } |
| return $sortie; |
| } |
| } |
| ?> |
| /trunk/framework/Config.php |
|---|
| 9,11 → 9,11 |
| * |
| * @category PHP |
| * @package Framework |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2009 Tela-Botanica |
| * @license GPL-v3 et CECILL-v2 |
| * @version SVN: <svn_id> |
| * @link /doc/framework/ |
| * @link /doc/framework/ |
| */ |
| class Config { |
| 73,14 → 73,14 |
| } |
| private static function parserFichierIni($fichier_ini) { |
| $retour = false; |
| $retour = false; |
| if (file_exists($fichier_ini)) { |
| $ini = parse_ini_file($fichier_ini, true); |
| $ini = self::analyserTableauIni($ini); |
| self::fusionner($ini); |
| $retour = true; |
| } |
| return $retour; |
| $retour = true; |
| } |
| return $retour; |
| } |
| private static function fusionner(array $ini) { |
| 93,19 → 93,19 |
| } else { |
| if (strpos($param, '.') !== false) { |
| $pieces = explode('.', $param, 2); |
| if (strlen($pieces[0]) && strlen($pieces[1])) { |
| if (isset($config[$pieces[0]])) { |
| if (is_array($config[$pieces[0]])) { |
| return self::getValeur($pieces[1], $config[$pieces[0]]); |
| } |
| } |
| } |
| } else { |
| if (isset($config[$param])) { |
| return $config[$param]; |
| } |
| } |
| return null; |
| if (strlen($pieces[0]) && strlen($pieces[1])) { |
| if (isset($config[$pieces[0]])) { |
| if (is_array($config[$pieces[0]])) { |
| return self::getValeur($pieces[1], $config[$pieces[0]]); |
| } |
| } |
| } |
| } else { |
| if (isset($config[$param])) { |
| return $config[$param]; |
| } |
| } |
| return null; |
| } |
| } |
| 125,14 → 125,14 |
| private static function analyserTableauIni($config = array()) { |
| foreach ($config as $cle => $valeur) { |
| if (is_array($valeur)) { |
| $config[$cle] = self::analyserTableauIni($valeur); |
| } else { |
| if (is_array($valeur)) { |
| $config[$cle] = self::analyserTableauIni($valeur); |
| } else { |
| self::evaluerReferences($config, $cle); |
| self::evaluerPhp($config, $cle); |
| self::evaluerCle($config, $cle, $config[$cle]); |
| } |
| } |
| self::evaluerPhp($config, $cle); |
| self::evaluerCle($config, $cle, $config[$cle]); |
| } |
| } |
| return $config; |
| } |
| 140,39 → 140,39 |
| if (strpos($cle, '.') !== false) { |
| unset($config[$cle]); |
| $pieces = explode('.', $cle, 2); |
| if (strlen($pieces[0]) && strlen($pieces[1])) { |
| if (!isset($config[$pieces[0]])) { |
| if ($pieces[0] === '0' && !empty($config)) { |
| // convert the current values in $config into an array |
| $config = array($pieces[0] => $config); |
| } else { |
| $config[$pieces[0]] = array(); |
| } |
| } elseif (!is_array($config[$pieces[0]])) { |
| throw new ErrorException("Ne peut pas créer de sous-clé pour '{$pieces[0]}' car la clé existe déjà"); |
| } |
| $config[$pieces[0]] = self::evaluerCle($config[$pieces[0]], $pieces[1], $valeur); |
| } else { |
| throw new ErrorException("Clé invalide '$cle'"); |
| } |
| } else { |
| $config[$cle] = $valeur; |
| } |
| return $config; |
| if (strlen($pieces[0]) && strlen($pieces[1])) { |
| if (!isset($config[$pieces[0]])) { |
| if ($pieces[0] === '0' && !empty($config)) { |
| // convert the current values in $config into an array |
| $config = array($pieces[0] => $config); |
| } else { |
| $config[$pieces[0]] = array(); |
| } |
| } elseif (!is_array($config[$pieces[0]])) { |
| throw new ErrorException("Ne peut pas créer de sous-clé pour '{$pieces[0]}' car la clé existe déjà"); |
| } |
| $config[$pieces[0]] = self::evaluerCle($config[$pieces[0]], $pieces[1], $valeur); |
| } else { |
| throw new ErrorException("Clé invalide '$cle'"); |
| } |
| } else { |
| $config[$cle] = $valeur; |
| } |
| return $config; |
| } |
| 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) { |
| $config[$cle] = str_replace($ref[0], self::getValeur($ref[1], $config), $config[$cle]); |
| } |
| } |
| foreach ($correspondances as $ref) { |
| $config[$cle] = str_replace($ref[0], self::getValeur($ref[1], $config), $config[$cle]); |
| } |
| } |
| } |
| private static function evaluerPhp(&$config, $cle) { |
| if (preg_match('/^php:(.+)$/', $config[$cle], $correspondances)) { |
| eval('$config["'.$cle.'"] = '.$correspondances[1].';'); |
| } |
| eval('$config["'.$cle.'"] = '.$correspondances[1].';'); |
| } |
| } |
| public static function charger($fichier_ini) { |
| /trunk/framework/Modele.php |
|---|
| 2,21 → 2,21 |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe modèle, donc d'accés au données, elle ne devrait pas être appelée de l'extérieur. |
| * Elle fait office d'abstraction légère de base de données en utilisant les objects PDO natifs |
| * Elle fait office d'abstraction légère de base de données en utilisant les objects PDO natifs |
| * de PHP |
| * Elle est abstraite donc doit obligatoirement être étendue. |
| * |
| * PHP Version 5 |
| * |
| * |
| * PHP Version 5 |
| * |
| * @category Class |
| * @package Framework |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @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/ |
| * |
| * @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 Modele { |
| 48,12 → 48,12 |
| * Mot de passe |
| */ |
| private $pass; |
| /** |
| * Encodage de la base de données |
| */ |
| private $encodage = null; |
| /** |
| * Encodage de la base de données |
| */ |
| private $encodage = null; |
| /** |
| * Connexion à la base de données |
| */ |
| private $connexion = null; |
| 61,70 → 61,66 |
| /** |
| * Constructeur par défaut, appelé à l'initialisation. |
| */ |
| final public function __construct() { |
| // les différents paramètres nécessaires sont lus à partir du registre |
| $this->registre = Registre::getInstance(); |
| $this->type = Config::get('bdd_protocole'); |
| $this->hote = Config::get('bdd_serveur'); |
| $this->bdd_nom = Config::get('bdd_nom'); |
| $this->utilisateur = Config::get('bdd_utilisateur'); |
| $this->pass = Config::get('bdd_mot_de_passe'); |
| $this->encodage = Config::get('bdd_encodage'); |
| $this->dsn = $this->type.':dbname='.$this->bdd_nom.';host='.$this->hote; |
| } |
| /** |
| * Fonction qui appelle la bonne fonction de requete suivant le type de bdd. |
| * |
| * @param string la requete à effectuer |
| * @return PDOStatement un objet contenant le résultat de la requête |
| */ |
| final protected function requete($requete) { |
| // on ne se connecte que lors du premier appel à une requete (lazy connexion) |
| if ($this->connexion == null) { |
| $this->connecter(); |
| } |
| final public function __construct() { |
| // les différents paramètres nécessaires sont lus à partir du registre |
| $this->registre = Registre::getInstance(); |
| $this->type = Config::get('bdd_protocole'); |
| $this->hote = Config::get('bdd_serveur'); |
| $this->bdd_nom = Config::get('bdd_nom'); |
| $this->utilisateur = Config::get('bdd_utilisateur'); |
| $this->pass = Config::get('bdd_mot_de_passe'); |
| $this->encodage = Config::get('bdd_encodage'); |
| $this->dsn = $this->type.':dbname='.$this->bdd_nom.';host='.$this->hote; |
| } |
| /** |
| * Fonction qui appelle la bonne fonction de requete suivant le type de bdd. |
| * |
| * @param string la requete à effectuer |
| * @return PDOStatement un objet contenant le résultat de la requête |
| */ |
| final protected function requete($requete) { |
| // on ne se connecte que lors du premier appel à une requete (lazy connexion) |
| if ($this->connexion == null) { |
| $this->connecter(); |
| } |
| return $this->connexion->query($requete); |
| } |
| /** |
| * Connection à la base de données en utilisant les informations fournies par |
| * le fichier de configuration. |
| * private et final car n'a pas vocation a être appelée par l'utilisateur. |
| * |
| * @throws PDOException une exception dans le cas ou là connexion échoue |
| */ |
| final private function connecter() { |
| // TODO: retirer le try catch et laisser le problème au gestionnaire d'exceptions |
| try { |
| $this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass); |
| if($this->encodage != null) { |
| $this->requete("SET names '".$this->encodage."'"); |
| } |
| } catch (PDOException $e) { |
| echo $e->getMessage(); |
| } |
| /** |
| * Connection à la base de données en utilisant les informations fournies par |
| * le fichier de configuration. |
| * private et final car n'a pas vocation a être appelée par l'utilisateur. |
| * |
| * @throws PDOException une exception dans le cas ou là connexion échoue |
| */ |
| final private function connecter() { |
| $this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass); |
| if($this->encodage != null) { |
| $this->requete("SET names '".$this->encodage."'"); |
| } |
| } |
| /** |
| * protège une chaine de caractères avant l'insertion dans la base de données |
| */ |
| final protected function proteger($chaine) { |
| // on ne se connecte que lors du premier appel à une requete |
| if ($this->connexion == null) { |
| $this->connecter(); |
| } |
| } |
| /** |
| * protège une chaine de caractères avant l'insertion dans la base de données |
| */ |
| final protected function proteger($chaine) { |
| // on ne se connecte que lors du premier appel à une requete |
| if ($this->connexion == null) { |
| $this->connecter(); |
| } |
| return $this->connexion->quote($chaine); |
| } |
| /** |
| * Destructeur de classe, se contente de fermer explicitement la connexion |
| */ |
| final public function __destruct() { |
| if ($this->connexion != null) { |
| $this->connexion = null ; |
| } |
| } |
| return $this->connexion->quote($chaine); |
| } |
| /** |
| * Destructeur de classe, se contente de fermer explicitement la connexion |
| */ |
| final public function __destruct() { |
| if ($this->connexion != null) { |
| $this->connexion = null ; |
| } |
| } |
| } |
| ?> |
| /trunk/framework/GestionnaireException.php |
|---|
| 2,42 → 2,42 |
| // declare(encoding='UTF-8'); |
| /** |
| * classe de gestion des exceptions. |
| * |
| * PHP Version 5 |
| * |
| * |
| * PHP Version 5 |
| * |
| * @category Class |
| * @package Framework |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @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/ |
| * |
| * @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 { |
| /** |
| * Liste des exceptions enregistrées |
| */ |
| private static $exceptions; |
| private static $exceptions = array(); |
| /** |
| * Détermine si l'on affiche ou nom le contexte |
| */ |
| private $contexte; |
| private static $contexte = false; |
| /** |
| * Definit si php est lancé en ligne de commande ou en mode serveur |
| */ |
| private $mode; |
| private static $mode = php_sapi_name ; |
| /** |
| * le gestionnaire d'exception est un singleton |
| * et possède donc un "pointeur statique sur lui-même" |
| */ |
| private static $gestionnaireException; |
| /** |
| * Constructeur avec paramètres optionnel |
| * @param bool indique si l'on veut afficher ou non le contexte des exceptions (i.e. la trace) |
| 44,26 → 44,28 |
| */ |
| public function __construct($contexte = false) { |
| self::$exceptions = array(); |
| $this->contexte = $contexte; |
| $this->mode = php_sapi_name(); |
| set_exception_handler(array($this,'gererException')); |
| self::$mode = $contexte; |
| self::$mode = php_sapi_name(); |
| set_exception_handler(array(get_class($this),'gererException')); |
| set_error_handler(array(get_class($this),'gererErreur')); |
| } |
| /** |
| * Renvoie le booleen définissant si l'on affiche le contexte ou non |
| */ |
| public function getContexte() { |
| return $this->contexte; |
| public static function getContexte() { |
| return self::$mode; |
| } |
| /** |
| * 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 function setContexte($contexte) { |
| $this->contexte = $contexte; |
| self::$mode = $contexte; |
| } |
| /** Fonction d'accès au singleton |
| * @return GestionnaireErreur le gestionnaire d'exceptions courant |
| */ |
| 72,33 → 74,54 |
| return self::$gestionnaireException; |
| } |
| self::$gestionnaireException = new GestionnaireException; |
| return self::$gestionnaireException; |
| return self::$gestionnaireException; |
| } |
| /** |
| * Fonction de gestion des exceptions, remplace le handler par défaut |
| */ |
| public static function gererException(Exception $e) { |
| // pour le moment on se contente de l'ajouter au tableau |
| self::$exceptions[] = $e; |
| // 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(); |
| echo self::getExceptions(); |
| return; |
| } |
| } |
| public static function gererErreur($niveau, $message, $fichier, $ligne, $contexte){ |
| // si aucun rapport d'error, on sort directement |
| if (error_reporting() == 0) |
| { |
| return; |
| } |
| // sinon on crée une exception |
| $e = new ErrorException($message, 0, $niveau, $fichier, $ligne); |
| // que l'on donne au tableau d'exceptions |
| self::$exceptions[] = $e; |
| } |
| /** |
| * Renvoie les exceptions au format (X)HTML |
| * ou bien au format texte suivant le mode d'utilisation de PHP |
| */ |
| public function getExceptions() { |
| public static function getExceptions() { |
| $retour = ''; |
| foreach (self::$exceptions as $e) { |
| switch($this->mode) { |
| case 'cli' : |
| foreach (self::$exceptions as $e) { |
| switch(self::$mode) { |
| case 'cli' : |
| $retour .= $e->getMessage()."\n"; |
| $retour .= 'Fichier : '.$e->getFile()."\n"; |
| $retour .= 'Ligne : '.$e->getLine()."\n"; |
| $retour .= 'Ligne : '.$e->getLine()."\n"; |
| $retour .= 'Message : '.$e->getMessage()."\n"; |
| $retour .= 'Fichier : '.$e->getFile()."\n"; |
| $retour .= 'Ligne : '.$e->getLine()."\n"; |
| if ($this->getContexte()) { |
| if (self::getContexte()) { |
| $retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n"; |
| } |
| break; |
| 108,8 → 131,8 |
| $retour .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n"; |
| $retour .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n"; |
| $retour .= '</pre>'."\n"; |
| if ($this->getContexte()) { |
| if (self::getContexte()) { |
| $retour .= '<pre>'."\n"; |
| $retour .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n"; |
| $retour .= '</pre>'."\n"; |
| 119,5 → 142,5 |
| return $retour; |
| } |
| } |
| } |
| ?> |
| /trunk/.settings/org.eclipse.core.resources.prefs |
|---|
| 1,3 → 1,7 |
| #Tue Sep 01 10:42:29 CEST 2009 |
| #Mon Aug 31 15:31:39 CEST 2009 |
| eclipse.preferences.version=1 |
| encoding//exemple/squelettes/ajout_admin.tpl.html=UTF-8 |
| encoding//exemple/squelettes/ident_admin.tpl.html=UTF-8 |
| encoding//exemple/squelettes/liste_admin.tpl.html=UTF-8 |
| encoding//exemple/squelettes/modif_admin.tpl.html=UTF-8 |
| encoding/<project>=UTF-8 |
| /trunk/exemple/modeles/ListeAdmin.php |
|---|
| 1,244 → 1,244 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Modèle d'accès à la base de données des administrateurs |
| * Modèle d'accès à la base de données des administrateurs |
| * de papyrus |
| */ |
| class listeAdmin extends Modele { |
| private $config = array(); |
| /** |
| * Charge la liste complète des administrateurs |
| * return array un tableau contenant des objets d'informations sur les administrateurs |
| * @return array un tableau d'objets contenant la liste des administrateurs |
| */ |
| class listeAdmin extends Modele { |
| private $config = array(); |
| /** |
| * Charge la liste complète des administrateurs |
| * return array un tableau contenant des objets d'informations sur les administrateurs |
| * @return array un tableau d'objets contenant la liste des administrateurs |
| */ |
| public function chargerAdmin() { |
| $requete = 'SELECT * '. |
| 'FROM gen_annuaire '. |
| 'ORDER BY ga_id_administrateur'; |
| $resultat = $this->requete($requete); |
| $admin = array(); |
| foreach ($resultat->fetchAll() as $ligne) { |
| if ($ligne['ga_id_administrateur'] != 0) { |
| $admin[] = $ligne; |
| } |
| } |
| return $admin; |
| } |
| /** |
| * Charge les informations liées à un administrateur |
| * grâce à son id |
| * @param int l'identifiant de l'administrateur. |
| * @return object un object contenant les informations de l'administrateur demandé |
| */ |
| public function loadDetailsAdmin($id) { |
| $requete = 'SELECT * '. |
| 'FROM gen_annuaire '. |
| "WHERE ga_id_administrateur = '$id' "; |
| $resultat = $this->requete($requete); |
| $admin = array(); |
| foreach ($resultat->fetchAll() as $ligne) { |
| $admin = $ligne; |
| } |
| return $admin; |
| } |
| /** |
| * Modifie les informations liées à un administrateur dans la base de données |
| * Si le mot de passe n'est pas renseigné, il n'est pas changé |
| * @param int identifiant de l'admiistrateur |
| * @param string nom |
| * @param string prenom |
| * @param string le mail |
| * @param string le code de langue |
| * @param string le mot de passe (optionnel) |
| * @param string la confirmation du mot de passe (optionnel) |
| * @return array un tableau contenant les erreurs s'il y en a, vide sinon |
| */ |
| function modifDetailsAdmin($id, $nom, $prenom, $mail, $lang, $pass = '', $pass_conf = '') { |
| $res = array(); |
| $nb_admin = 0; |
| if (!$this->validerMail($mail)) { |
| $res['mail'] = 'Adresse mail invalide'; |
| } |
| $query_verif_mail = 'SELECT COUNT(*) AS nb_admin '. |
| 'FROM gen_annuaire '. |
| "WHERE ga_mail = '{$this->proteger($mail)}'". |
| " AND ga_id_administrateur != $id "; |
| if ($res_nb = $this->requete($query_verif_mail)) { |
| $ligne = $res_nb->fetch(); |
| $nb_admin = $ligne['nb_admin'] ; |
| } else { |
| $res['bdd'] = 'Erreur dans la base de données' ; |
| return $res; |
| } |
| if($nb_admin != 0) { |
| $res['mail'] = 'Cet email est déjà utilisé par un autre utilisateur' ; |
| } |
| $query = 'UPDATE gen_annuaire SET ga_ce_i18n='.$this->proteger($lang).', ga_nom='.$this->proteger($nom).',ga_prenom='. |
| $this->proteger($prenom).',ga_mail='.$this->proteger($mail) ; |
| // si on a entré quelque chose dans les deux champs de mot de passe |
| if($pass != '' || $pass_conf != '') { |
| // on vérifie si les deux concordent |
| if($pass == $pass_conf) { |
| // si oui, on les modifie |
| $query .= ',ga_mot_de_passe='.$this->proteger(md5($pass)) ; |
| } else { |
| // si non, on notifiera l'utilisateur |
| $res['pass'] = 'mot de passe invalide' ; |
| } |
| } |
| $requete = 'SELECT * '. |
| 'FROM gen_annuaire '. |
| 'ORDER BY ga_id_administrateur'; |
| $resultat = $this->requete($requete); |
| $admin = array(); |
| foreach ($resultat->fetchAll() as $ligne) { |
| if ($ligne['ga_id_administrateur'] != 0) { |
| $admin[] = $ligne; |
| } |
| } |
| return $admin; |
| } |
| $query .= ' WHERE ga_id_administrateur='.$id ; |
| if(count($res) != 0) { |
| return $res ; |
| } |
| if($req_maj = $this->requete($query)) { |
| } else { |
| $res['bdd'] = 'Erreur de la requête dans la base de données' ; |
| } |
| return $res; |
| } |
| /** |
| * Supprime un administrateur ayant un id donné |
| * @param int l'identifiant de l'administrateur |
| * @return array un tableau contenant les erreurs s'il y en a, vide sinon |
| */ |
| function suppAdmin($id) { |
| $nb_admin = 0 ; |
| $res = '' ; |
| $query_verif = 'SELECT COUNT(*) AS nb_admin FROM gen_annuaire' ; |
| if($res_nb = $this->requete($query_verif)) { |
| $ligne = $res_nb->fetch(); |
| $nb_admin = $ligne['nb_admin'] ; |
| } else { |
| $res = 'Erreur dans la base de donn�es' ; |
| return $res ; |
| } |
| if($nb_admin == 2) { |
| $res = 'Impossible de supprimer le dernier administrateur' ; |
| return $res ; |
| } |
| $query = 'DELETE FROM gen_annuaire WHERE ga_id_administrateur='.$id ; |
| if($res_supp = $this->requete($query)) { |
| return $res ; |
| } else { |
| $res = 'Erreur dans la base de données' ; |
| return $res ; |
| } |
| } |
| /** |
| * Ajoute un administrateur dans la base de données |
| * @param string nom |
| * @param string prenom |
| * @param string le mail |
| * @param string le code de langue |
| * @param string le mot de passe |
| * @param string la confirmation du mot de passe |
| * @return array un tableau contenant les erreurs s'il y en a, vide sinon |
| */ |
| function ajoutAdmin($nom,$prenom,$mail,$lang,$pass,$pass_conf) { |
| $nouvel_id = 0 ; |
| $nb_admin = 0 ; |
| $res = array() ; |
| if(!$this->validerMail($mail)) { |
| $res['mail'] = 'adresse mail invalide' ; |
| } |
| $query_verif_mail = 'SELECT COUNT(*) AS nb_admin FROM gen_annuaire WHERE ga_mail = '.$this->proteger($mail) ; |
| if($res_nb = $this->requete($query_verif_mail)) { |
| $ligne = $res_nb->fetch() ; |
| $nb_admin = $ligne['nb_admin'] ; |
| } else { |
| $res['bdd'] = 'Erreur dans la base de données' ; |
| return $res ; |
| } |
| if($nb_admin != 0) { |
| $res['mail'] = 'Cet email est déjà utilisé par un autre utilisateur' ; |
| } |
| if($pass != '' || $pass_conf != '') { |
| // on vérifie si les deux concordent |
| if($pass == $pass_conf) { |
| } else { |
| // si non, on notifiera l'utilisateur |
| $res['pass'] = 'mot de passe invalide' ; |
| } |
| } |
| $query = 'SELECT MAX(ga_id_administrateur) as nouvel_id FROM gen_annuaire' ; |
| if($res_requete_id = $this->requete($query)) { |
| $ligne = $res_requete_id->fetch() ; |
| $nouvel_id = $ligne['nouvel_id'] + 1 ; |
| } else { |
| return $res ; |
| } |
| $query = 'INSERT INTO gen_annuaire VALUES ('.$nouvel_id.','.$this->proteger($lang).','. |
| $this->proteger($nom).','.$this->proteger($prenom).','.$this->proteger(md5($pass)).','. |
| $this->proteger($mail).')' ; |
| if(count($res) != 0) { |
| return $res ; |
| } |
| if($res_ajout = $this->requete($query)) { |
| } else { |
| $res['bdd'] = 'Erreur de la requête dans la base de données' ; |
| } |
| return $res ; |
| } |
| /** |
| * Fonction qui prend une chaine en paramètre et renvoie vrai |
| * si elle constitue un email syntaxiquement valide, faux sinon. |
| * @param string le mail à valider |
| * @return bool true si le mail est valide, false sinon |
| */ |
| function validerMail($mail) { |
| $atom = '[-a-z0-9!#$%&\'*+\\/=?^_`{|}~]'; // Caractères autorisés avant l'arobase |
| $domain = '([a-z0-9]([-a-z0-9]*[a-z0-9]+)?)'; // Caractères autorisés après l'arobase (nom de domaine) |
| $regex = '/^'.$atom.'+'. // Une ou plusieurs fois les caractères autorisés avant l'arobase |
| '(\.'.$atom.'+)*'. // Suivis par zéro point ou plus, séparés par des caractères autorisés avant l'arobase |
| '@'.// Suivis d'un arobase |
| '('.$domain .'{1,63}\.)+'.// Suivis par 1 à 63 caractères autorisés pour le nom de domaine, séparés par des points |
| $domain.'{2,63}$/i';// Suivi de 2 à 63 caractères autorisés pour le nom de domaine |
| // Test de l'adresse e-mail |
| if (preg_match($regex, $mail)) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| /** |
| * Charge les informations liées à un administrateur |
| * grâce à son id |
| * @param int l'identifiant de l'administrateur. |
| * @return object un object contenant les informations de l'administrateur demandé |
| */ |
| public function loadDetailsAdmin($id) { |
| $requete = 'SELECT * '. |
| 'FROM gen_annuaire '. |
| "WHERE ga_id_administrateur = '$id' "; |
| $resultat = $this->requete($requete); |
| $admin = array(); |
| foreach ($resultat->fetchAll() as $ligne) { |
| $admin = $ligne; |
| } |
| return $admin; |
| } |
| /** |
| * Modifie les informations liées à un administrateur dans la base de données |
| * Si le mot de passe n'est pas renseigné, il n'est pas changé |
| * @param int identifiant de l'admiistrateur |
| * @param string nom |
| * @param string prenom |
| * @param string le mail |
| * @param string le code de langue |
| * @param string le mot de passe (optionnel) |
| * @param string la confirmation du mot de passe (optionnel) |
| * @return array un tableau contenant les erreurs s'il y en a, vide sinon |
| */ |
| function modifDetailsAdmin($id, $nom, $prenom, $mail, $lang, $pass = '', $pass_conf = '') { |
| $res = array(); |
| $nb_admin = 0; |
| if (!$this->validerMail($mail)) { |
| $res['mail'] = 'Adresse mail invalide'; |
| } |
| $query_verif_mail = 'SELECT COUNT(*) AS nb_admin '. |
| 'FROM gen_annuaire '. |
| "WHERE ga_mail = '{$this->proteger($mail)}'". |
| " AND ga_id_administrateur != $id "; |
| if ($res_nb = $this->requete($query_verif_mail)) { |
| $ligne = $res_nb->fetch(); |
| $nb_admin = $ligne['nb_admin'] ; |
| } else { |
| $res['bdd'] = 'Erreur dans la base de données' ; |
| return $res; |
| } |
| if($nb_admin != 0) { |
| $res['mail'] = 'Cet email est déjà utilisé par un autre utilisateur' ; |
| } |
| $query = 'UPDATE gen_annuaire SET ga_ce_i18n='.$this->proteger($lang).', ga_nom='.$this->proteger($nom).',ga_prenom='. |
| $this->proteger($prenom).',ga_mail='.$this->proteger($mail) ; |
| // si on a entré quelque chose dans les deux champs de mot de passe |
| if($pass != '' || $pass_conf != '') { |
| // on vérifie si les deux concordent |
| if($pass == $pass_conf) { |
| // si oui, on les modifie |
| $query .= ',ga_mot_de_passe='.$this->proteger(md5($pass)) ; |
| } else { |
| // si non, on notifiera l'utilisateur |
| $res['pass'] = 'mot de passe invalide' ; |
| } |
| } |
| $query .= ' WHERE ga_id_administrateur='.$id ; |
| if(count($res) != 0) { |
| return $res ; |
| } |
| if($req_maj = $this->requete($query)) { |
| } else { |
| $res['bdd'] = 'Erreur de la requête dans la base de données' ; |
| } |
| return $res; |
| } |
| /** |
| * Supprime un administrateur ayant un id donné |
| * @param int l'identifiant de l'administrateur |
| * @return array un tableau contenant les erreurs s'il y en a, vide sinon |
| */ |
| function suppAdmin($id) { |
| $nb_admin = 0 ; |
| $res = '' ; |
| $query_verif = 'SELECT COUNT(*) AS nb_admin FROM gen_annuaire' ; |
| if($res_nb = $this->requete($query_verif)) { |
| $ligne = $res_nb->fetch(); |
| $nb_admin = $ligne['nb_admin'] ; |
| } else { |
| $res = 'Erreur dans la base de donn�es' ; |
| return $res ; |
| } |
| if($nb_admin == 2) { |
| $res = 'Impossible de supprimer le dernier administrateur' ; |
| return $res ; |
| } |
| $query = 'DELETE FROM gen_annuaire WHERE ga_id_administrateur='.$id ; |
| if($res_supp = $this->requete($query)) { |
| return $res ; |
| } else { |
| $res = 'Erreur dans la base de données' ; |
| return $res ; |
| } |
| } |
| /** |
| * Ajoute un administrateur dans la base de données |
| * @param string nom |
| * @param string prenom |
| * @param string le mail |
| * @param string le code de langue |
| * @param string le mot de passe |
| * @param string la confirmation du mot de passe |
| * @return array un tableau contenant les erreurs s'il y en a, vide sinon |
| */ |
| function ajoutAdmin($nom,$prenom,$mail,$lang,$pass,$pass_conf) { |
| $nouvel_id = 0 ; |
| $nb_admin = 0 ; |
| $res = array() ; |
| if(!$this->validerMail($mail)) { |
| $res['mail'] = 'adresse mail invalide' ; |
| } |
| $query_verif_mail = 'SELECT COUNT(*) AS nb_admin FROM gen_annuaire WHERE ga_mail = '.$this->proteger($mail) ; |
| if($res_nb = $this->requete($query_verif_mail)) { |
| $ligne = $res_nb->fetch() ; |
| $nb_admin = $ligne['nb_admin'] ; |
| } else { |
| $res['bdd'] = 'Erreur dans la base de données' ; |
| return $res ; |
| } |
| if($nb_admin != 0) { |
| $res['mail'] = 'Cet email est déjà utilisé par un autre utilisateur' ; |
| } |
| if($pass != '' || $pass_conf != '') { |
| // on vérifie si les deux concordent |
| if($pass == $pass_conf) { |
| } else { |
| // si non, on notifiera l'utilisateur |
| $res['pass'] = 'mot de passe invalide' ; |
| } |
| } |
| $query = 'SELECT MAX(ga_id_administrateur) as nouvel_id FROM gen_annuaire' ; |
| if($res_requete_id = $this->requete($query)) { |
| $ligne = $res_requete_id->fetch() ; |
| $nouvel_id = $ligne['nouvel_id'] + 1 ; |
| } else { |
| return $res ; |
| } |
| $query = 'INSERT INTO gen_annuaire VALUES ('.$nouvel_id.','.$this->proteger($lang).','. |
| $this->proteger($nom).','.$this->proteger($prenom).','.$this->proteger(md5($pass)).','. |
| $this->proteger($mail).')' ; |
| if(count($res) != 0) { |
| return $res ; |
| } |
| if($res_ajout = $this->requete($query)) { |
| } else { |
| $res['bdd'] = 'Erreur de la requête dans la base de données' ; |
| } |
| return $res ; |
| } |
| /** |
| * Fonction qui prend une chaine en paramètre et renvoie vrai |
| * si elle constitue un email syntaxiquement valide, faux sinon. |
| * @param string le mail à valider |
| * @return bool true si le mail est valide, false sinon |
| */ |
| function validerMail($mail) { |
| $atom = '[-a-z0-9!#$%&\'*+\\/=?^_`{|}~]'; // Caractères autorisés avant l'arobase |
| $domain = '([a-z0-9]([-a-z0-9]*[a-z0-9]+)?)'; // Caractères autorisés après l'arobase (nom de domaine) |
| $regex = '/^'.$atom.'+'. // Une ou plusieurs fois les caractères autorisés avant l'arobase |
| '(\.'.$atom.'+)*'. // Suivis par zéro point ou plus, séparés par des caractères autorisés avant l'arobase |
| '@'.// Suivis d'un arobase |
| '('.$domain .'{1,63}\.)+'.// Suivis par 1 à 63 caractères autorisés pour le nom de domaine, séparés par des points |
| $domain.'{2,63}$/i';// Suivi de 2 à 63 caractères autorisés pour le nom de domaine |
| // Test de l'adresse e-mail |
| if (preg_match($regex, $mail)) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| } |
| ?> |
| /trunk/exemple/admin_administrateur.php |
|---|
| 23,11 → 23,11 |
| if (Config::get('identification')) { |
| // on renvoie la vue principale de l'application |
| $methode = '' ; |
| if (isset($_GET['m'])) { |
| $methode = $_GET['m']; |
| } |
| $controlleur = new AdminAdministrateur(); |
| switch ($methode) { |
| case 'ajout_admin': |
| return $controlleur->ajoutAdmin(); |
| 54,7 → 54,7 |
| $pass = $_POST['admin_pass']; |
| $pass_conf = $_POST['admin_pass_confirm']; |
| return $controlleur->modifAdminVa($id, $nom, $prenom, $mail, $lang, $pass, $pass_conf); |
| break; |
| break; |
| case 'suppr_admin': |
| $id = $_GET['id_admin']; |
| return $controlleur->supprAdmin($id); |
| 82,11 → 82,11 |
| } |
| function afficherContenuNavigation() { |
| return ''; |
| return ''; |
| } |
| function afficherContenuMenu() { |
| return ''; |
| return ''; |
| } |
| ?> |
| /trunk/exemple/index.php |
|---|
| 7,93 → 7,97 |
| $titre = ""; |
| $contenu_pied = afficherContenuPied(); |
| $contenu_menu = afficherContenuMenu(); |
| $erreurs = GestionnaireException::getExceptions(); |
| ?> |
| <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> |
| <html xmlns="http://www.w3.org/1999/xhtml" > |
| <head xml:lang="fr" lang="fr"> |
| <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> |
| <meta http-equiv="Content-style-type" content="text/css" /> |
| <meta http-equiv="Content-script-type" content="text/javascript" /> |
| <meta http-equiv="Content-language" content="fr" /> |
| <title><?php echo $titre; ?></title> |
| <meta name="revisit-after" content="15 days" /> |
| <meta name="robots" content="index,follow" /> |
| <meta name="author" content="Tela Botanica" /> |
| <style type="text/css" media="screen"> |
| /*--------------------------------------------------------------------------------------------------------------*/ |
| /* Tableau du chronométrage du programme */ |
| #pied_texte #chrono { |
| text-align: center; |
| margin:0 auto;} |
| #chrono table { |
| display:block; |
| border:3px solid #6495ed; |
| border-collapse:collapse;} |
| #chrono thead, tfoot { |
| background-color:#D0E3FA; |
| border:1px solid #6495ed;} |
| #chrono tbody { |
| background-color:#FFFFFF; |
| border:1px solid #6495ed;} |
| #chrono th { |
| font-family:monospace; |
| border:1px dotted #6495ed; |
| padding:5px; |
| background-color:#EFF6FF; |
| width:25%;} |
| #chrono td { |
| font-family:sans-serif; |
| font-size:80%; |
| border:1px solid #6495ed; |
| padding:5px; |
| text-align:center;} |
| #chrono caption { |
| font-family:sans-serif; |
| text-align: center; |
| width:90%; |
| margin:auto;} |
| .debogage{ |
| color:black; |
| border:3px solid #6495ed;} |
| .debogage_fichier, .debogage_ligne{ |
| font-size:10px; |
| color:#A9A9A9;} |
| </style> |
| <link rel="shortcut icon" type="image/x-icon" href="http://www.tela-botanica.org/favicon.ico" /> |
| <link rel="icon" type="image/png" href="http://www.tela-botanica.org/sites/commun/generique/images/favicones/tela_botanica.png" /> |
| </head> |
| <body xml:lang="fr" lang="fr"> |
| <div id="reducteur"> |
| <div id="logo_tela"> |
| <a href="/" title="Retour à l'accueil du site"> |
| <img src="http://www.tela-botanica.org/sites/reseau/generique/images/graphisme/logo_jaune.gif" alt="le logo de Tela Botanica"/> |
| </a> |
| </div> |
| <div id="droite"> |
| <div id="onglets"> |
| <?php echo $contenu_navigation; ?> |
| </div> |
| <div id="contenu"> |
| <div id="entete"> |
| <?php echo $contenu_tete; ?> |
| </div> |
| <div id="texte"> |
| <?php echo $contenu_corps; ?> |
| </div> |
| <div id="pied_texte"> |
| <?php |
| echo $contenu_pied; |
| ?> |
| </div> |
| </div> |
| </div> |
| <div id="pied"> |
| <p> ©<a href="http://www.tela-botanica.org/" accesskey="1">Tela Botanica</a> / 2000-2004 - Le réseau des Botanistes Francophones</p> |
| </div> |
| </div> |
| </body> |
| <head xml:lang="fr" lang="fr"> |
| <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> |
| <meta http-equiv="Content-style-type" content="text/css" /> |
| <meta http-equiv="Content-script-type" content="text/javascript" /> |
| <meta http-equiv="Content-language" content="fr" /> |
| <title><?php echo $titre; ?></title> |
| <meta name="revisit-after" content="15 days" /> |
| <meta name="robots" content="index,follow" /> |
| <meta name="author" content="Tela Botanica" /> |
| <style type="text/css" media="screen"> |
| /*--------------------------------------------------------------------------------------------------------------*/ |
| /* Tableau du chronométrage du programme */ |
| #pied_texte #chrono { |
| text-align: center; |
| margin:0 auto;} |
| #chrono table { |
| display:block; |
| border:3px solid #6495ed; |
| border-collapse:collapse;} |
| #chrono thead, tfoot { |
| background-color:#D0E3FA; |
| border:1px solid #6495ed;} |
| #chrono tbody { |
| background-color:#FFFFFF; |
| border:1px solid #6495ed;} |
| #chrono th { |
| font-family:monospace; |
| border:1px dotted #6495ed; |
| padding:5px; |
| background-color:#EFF6FF; |
| width:25%;} |
| #chrono td { |
| font-family:sans-serif; |
| font-size:80%; |
| border:1px solid #6495ed; |
| padding:5px; |
| text-align:center;} |
| #chrono caption { |
| font-family:sans-serif; |
| text-align: center; |
| width:90%; |
| margin:auto;} |
| .debogage{ |
| color:black; |
| border:3px solid #6495ed;} |
| .debogage_fichier, .debogage_ligne{ |
| font-size:10px; |
| color:#A9A9A9;} |
| </style> |
| <link rel="shortcut icon" type="image/x-icon" href="http://www.tela-botanica.org/favicon.ico" /> |
| <link rel="icon" type="image/png" href="http://www.tela-botanica.org/sites/commun/generique/images/favicones/tela_botanica.png" /> |
| </head> |
| <body xml:lang="fr" lang="fr"> |
| <div id="reducteur"> |
| <div id="logo_tela"> |
| <a href="/" title="Retour à l'accueil du site"> |
| <img src="http://www.tela-botanica.org/sites/reseau/generique/images/graphisme/logo_jaune.gif" alt="le logo de Tela Botanica"/> |
| </a> |
| </div> |
| <div id="droite"> |
| <div id="onglets"> |
| <?php echo $contenu_navigation; ?> |
| </div> |
| <div id="contenu"> |
| <div id="entete"> |
| <?php echo $contenu_tete; ?> |
| </div> |
| <div id="texte"> |
| <?php echo $contenu_corps; ?> |
| </div> |
| <div id="pied_texte"> |
| <?php |
| echo $contenu_pied; |
| ?> |
| </div> |
| </div> |
| </div> |
| <div> |
| <?php echo $erreurs; ?> |
| </div> |
| <div id="pied"> |
| <p> ©<a href="http://www.tela-botanica.org/" accesskey="1">Tela Botanica</a> / 2000-2004 - Le réseau des Botanistes Francophones</p> |
| </div> |
| </div> |
| </body> |
| </html> |
| /trunk/exemple/controleurs/AdminAdministrateur.php |
|---|
| 21,7 → 21,7 |
| $this->chargerModele('ListeAdmin'); |
| $data['erreurs'] = $erreurs; |
| $data['admin'] = $this->ListeAdmin->chargerAdmin(); |
| $this->chargerVue('liste_admin', $data); |
| return $this->liste_admin; |