| /trunk/bibliotheque/noyau/Registre.class.php |
|---|
| New file |
| 0,0 → 1,129 |
| <?php |
| class Registre { |
| private $aso_stock = array(); |
| private static $registre = null; |
| private $suivant; |
| private $titre; |
| private $espaces = array(); |
| private $donnees = array(); |
| private $squelettes; |
| public static function getRegistre() |
| { |
| if (is_null(Registre::$registre)) { |
| Registre::$registre = new Registre; |
| } |
| return Registre::$registre; |
| } |
| function set($intitule, $objet) |
| { |
| if (is_array($objet) && isset($this->aso_stock[$intitule])) { |
| $this->aso_stock[$intitule] = array_merge((array)$this->aso_stock[$intitule], (array)$objet); |
| $message = "Le tableau $intitule présent dans le registre a été fusionné avec un nouveau tableau de même intitulé !"; |
| trigger_error($message, E_USER_WARNING); |
| } else { |
| $this->aso_stock[$intitule] = $objet; |
| } |
| } |
| function get($intitule) |
| { |
| if (isset($this->aso_stock[$intitule])) { |
| return $this->aso_stock[$intitule]; |
| } |
| return false; |
| } |
| function detruire($intitule) |
| { |
| if (isset($this->aso_stock[$intitule])) { |
| unset($this->aso_stock[$intitule]); |
| } |
| } |
| public function etrePresent($intitule) |
| { |
| if(isset($this->aso_stock[$intitule])){ |
| return true; |
| } |
| return false; |
| } |
| // Titre |
| public function getTitre() |
| { |
| return $this->titre; |
| } |
| public function setTitre($t) |
| { |
| $this->titre = $t; |
| } |
| // Espaces De Nomage |
| public function setEspaces($e) |
| { |
| $this->espaces = $e; |
| } |
| public function ajouterEspace($cle, $val) |
| { |
| $this->espaces[$cle] = $val; |
| } |
| public function getEspaces($cle = null) |
| { |
| if ($cle != null) { |
| if (isset($this->espaces[$cle])) { |
| return $this->espaces[$cle]; |
| } |
| } else { |
| return $this->espaces; |
| } |
| } |
| // Donnees |
| public function setDonnees($d) |
| { |
| $this->donnees = $d; |
| } |
| public function ajouterDonnee($cle, $val) |
| { |
| if (is_array($val) && isset($this->donnees[$cle])) { |
| $this->donnees[$cle] = array_merge((array)$this->donnees[$cle], $val); |
| trigger_error('Fusion de données pour la clé : '. $cle, E_USER_NOTICE); |
| } else { |
| $this->donnees[$cle] = $val; |
| } |
| } |
| public function getDonnees($cle = null) |
| { |
| if (!is_null($cle)) { |
| if (isset($this->donnees[$cle])) { |
| return $this->donnees[$cle]; |
| } |
| } else { |
| return $this->donnees; |
| } |
| } |
| // Squelettes |
| public function setSquelettes($s) |
| { |
| $this->squelettes = $s; |
| } |
| public function ajouterSquelette($cle, $val) |
| { |
| $this->squelettes[$cle] = $val; |
| } |
| public function getSquelettes($cle = null) |
| { |
| if ($cle != null) { |
| if (isset($this->squelettes[$cle])) { |
| return $this->squelettes[$cle]; |
| } |
| } else { |
| return $this->squelettes; |
| } |
| } |
| } |
| ?> |
| /trunk/bibliotheque/noyau/aControlleurAction.class.php |
|---|
| New file |
| 0,0 → 1,95 |
| <?php |
| abstract class aControlleurAction { |
| private $suivant; |
| public function getRegistre() |
| { |
| return Registre::getRegistre(); |
| } |
| // Suivant |
| public function getSuivant() |
| { |
| return $this->suivant; |
| } |
| public function setSuivant($s, $position = null) |
| { |
| if (is_array($s)){ |
| $this->suivant = $s; |
| } else { |
| if (!is_null($position)) { |
| $tab_fin = array_slice($this->suivant, $position); |
| $tab_deb = array_slice($this->suivant, 0, $position); |
| $this->suivant = array_merge($tab_deb, array($s), $tab_fin); |
| } else { |
| $this->suivant[] = $s; |
| } |
| } |
| } |
| public function demarrer() |
| { |
| if (!is_null($this->getSuivant())) { |
| // ATTENTION : |
| // Il est important de laisser "count($this->getSuivant())" $this->getSuivant() peut varier de taille |
| for ($i = 0; $i < count($this->getSuivant()) ; $i++) { |
| //echo '<pre>'.print_r($this->getSuivant(), true).'</pre>'; |
| if ($this->getRegistre()->get('action_finale')) { |
| // Si l'action met fin au script prématurément nous arrétons |
| break; |
| } else { |
| $liste_actions = $this->getSuivant(); |
| //echo '<pre>'.print_r($liste_actions[$i], true).'</pre>'; |
| if ($liste_actions[$i] instanceof aControlleurAction) { |
| $liste_actions[$i]->demarrer(); |
| } else { |
| if (isset($_POST) || isset($_GET)) { |
| // Méthode "vérifier" générale présente dans aControlleurAction |
| $this->verifier(); |
| $methode_verif = 'verifier'.$liste_actions[$i]; |
| if (method_exists($this, $methode_verif)) { |
| // Méthode "vérifier" spécifique à une action |
| $this->$methode_verif(); |
| } |
| } |
| if ($liste_actions[$i] == '__defaut__') { |
| $methode = 'executer'; |
| } else { |
| $methode = 'executer'.$liste_actions[$i]; |
| } |
| if (method_exists($this, $methode)) { |
| $this->$methode(); |
| } else { |
| $m = "La méthode $methode de la classe ".get_class($this)." est introuvable!"; |
| trigger_error($m, E_USER_ERROR); |
| } |
| } |
| } |
| } |
| } else { |
| $m = "Le registre ne contient aucune action!"; |
| trigger_error($m, E_USER_ERROR); |
| } |
| } |
| public function verifier() |
| { |
| // Nous rassemblons les valeurs du tableau _POST contenant des : dans des sous-tableau de _POST. |
| foreach ($_POST as $cle => $val) { |
| $morceau = array(); |
| if (preg_match('/^(.+?)(:.+)+$/', $cle, $morceau)) { |
| $table = ''; |
| foreach (explode(':', trim($morceau[2], ':')) as $c) { |
| $table .= '['.$c.']'; |
| } |
| eval('$_POST[$morceau[1]]'.$table.' = $val;'); |
| unset($_POST[$cle]); |
| } |
| } |
| } |
| abstract protected function executer(); |
| } |
| ?> |
| /trunk/bibliotheque/noyau/Calendrier.class.php |
|---|
| New file |
| 0,0 → 1,232 |
| <?php |
| // +------------------------------------------------------------------------------------------------------+ |
| // | PHP version 5.1.1 | |
| // +------------------------------------------------------------------------------------------------------+ |
| // | Copyright (C) 2006 Tela Botanica (accueil@tela-botanica.org) | |
| // +------------------------------------------------------------------------------------------------------+ |
| // | This file is part of eFlore. | |
| // | | |
| // | Foobar is free software; you can redistribute it and/or modify | |
| // | it under the terms of the GNU General Public License as published by | |
| // | the Free Software Foundation; either version 2 of the License, or | |
| // | (at your option) any later version. | |
| // | | |
| // | Foobar is distributed in the hope that it will be useful, | |
| // | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| // | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| // | GNU General Public License for more details. | |
| // | | |
| // | You should have received a copy of the GNU General Public License | |
| // | along with Foobar; if not, write to the Free Software | |
| // | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| // +------------------------------------------------------------------------------------------------------+ |
| // CVS : $Id$ |
| /** |
| * Classe Calendrier |
| * |
| * Description |
| * |
| *@package Calendrier |
| //Auteur original : |
| *@version 1 |
| *@author Dorian BANNIER <dbannier@aol.com> |
| //Autres auteurs : |
| *@version 3 |
| *@author Shaheen ABDOOL RAHEEM <shaheenar50@hotmail.com> |
| *@version 4 |
| *@author Jean-Pascal MILCENT <jpm@clapas.org> |
| *@author aucun |
| *@copyright Tela-Botanica 2000-2006 |
| *@version $Revision$ $Date$ |
| // +------------------------------------------------------------------------------------------------------+ |
| */ |
| /** |
| * Classe calendrier pour gerer le calendrier pour un mois et une annee |
| * |
| *@param annee |
| *@param mois |
| *@param premier jour du mois |
| *@param semaine |
| *@param l'url du resultat affiche |
| *@param liste de noms des jours |
| *@param liste de noms des mois |
| *@param liste des jours feries du mois |
| */ |
| class Calendrier |
| { |
| private $annee; |
| private $mois; |
| private $semaine; |
| private $jour; |
| private $nom_jours = array(); |
| private $nom_mois = array(); |
| private $liste_feries = array(); |
| /** |
| *constructeur de la classe calendrier |
| *toutes les variables sont initialises avec les donnees |
| *de la date du jour si on ne passe aucune date en parametre |
| *sinon on initialise le calendrier avec |
| *@param semaine |
| *@param annee |
| */ |
| public function __construct($jour = null, $semaine = null, $mois = null, $annee = null) |
| { |
| if (is_null($jour)) { |
| $jour = date('d', time()); |
| } |
| $this->jour = $jour; |
| if (is_null($semaine)) { |
| $semaine = date('W', time()); |
| } |
| $this->semaine = $semaine; |
| if (is_null($mois)) { |
| $mois = date('m', time()); |
| } |
| $this->mois = $mois; |
| if (is_null($annee)) { |
| // TODO : vérifier le standard ISO-8601 |
| $annee = date('Y', time()); |
| } |
| $this->annee = $annee; |
| $this->nom_jours = array (1 => GESTION_LUN_L, GESTION_MAR_L, GESTION_MER_L, GESTION_JEU_L, GESTION_VEN_L, GESTION_SAM_L ,GESTION_DIM_L); |
| $this->nom_mois = array(1 => "Janvier", "Février", "Mars", "Avril", "Mai", "Juin", "Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"); |
| $this->liste_feries = $this->calculerJoursFeries($this->annee); |
| } |
| public function getAnnee() |
| { |
| return $this->annee; |
| } |
| public function getMois() |
| { |
| return $this->mois; |
| } |
| public function getSemaine() |
| { |
| return $this->semaine; |
| } |
| public function getJour() |
| { |
| return $this->jour; |
| } |
| public function getNomJours($j = null) |
| { |
| if (is_null($j)) { |
| return $this->nom_jours; |
| } |
| return $this->nom_jours[$j]; |
| } |
| public function getNomMois($m = null) |
| { |
| if (is_null($m)) { |
| return $this->nom_mois; |
| } |
| return $this->nom_mois[$m]; |
| } |
| public function getListeFeries() |
| { |
| return $this->liste_feries; |
| } |
| /** |
| *Calcule les dates des jours fériés pour la france. |
| *Renvoie un tableau contenant la liste de dates par mois. |
| *Les dates sont de la forme timestamp unix. |
| * |
| *@param integer l'année pour laquelle on veut les jours fériés. |
| *@return array tableau des dates fériées. |
| */ |
| public function calculerJoursFeries($annee) |
| { |
| $tab = array( mktime(0,0,0,1,1,$annee), |
| $this->donnerDatePaques($annee), |
| mktime(0,0,0,5,1,$annee), |
| mktime(0,0,0,5,8,$annee), |
| $this->donnerDateAscension($annee), |
| $this->donnerDatePentecote($annee), |
| mktime(0,0,0,7,14,$annee), |
| mktime(0,0,0,8,15,$annee), |
| mktime(0,0,0,11,1,$annee), |
| mktime(0,0,0,11,11,$annee), |
| mktime(0,0,0,12,25,$annee)); |
| return $tab; |
| } |
| /** |
| *Calcule la date du lundi de Pâques. |
| * |
| *@param integer l'année pour laquelle on veut connaître la date de Pâques |
| *@return integer le timestamp du lundi de Pâques |
| */ |
| public function donnerDatePaques($annee) |
| { |
| $date_paques = easter_date($annee); |
| $lundi_paques = mktime( date("H", $date_paques), |
| date("i", $date_paques), |
| date("s", $date_paques), |
| date("m", $date_paques), |
| date("d", $date_paques) + 1, |
| date("Y", $date_paques)); |
| return $lundi_paques; |
| } |
| /** |
| *Calcule la date de l'ascension. |
| * |
| *@param integer l'année pour laquelle on veut connaître la date de l'ascencion |
| *@return integer le timestamp de l'ascencion |
| */ |
| public function donnerDateAscension($annee) |
| { |
| $date_paques = easter_date($annee); |
| $date_ascension = mktime( date("H", $date_paques), |
| date("i", $date_paques), |
| date("s", $date_paques), |
| date("m", $date_paques), |
| date("d", $date_paques) + 39, |
| date("Y", $date_paques)); |
| return $date_ascension; |
| } |
| /** |
| *Calcule la date du lundi de la pentecote |
| *Renvoie un timestamp |
| *renvoie cette derniere |
| */ |
| public function donnerDatePentecote($annee) |
| { |
| $date_paques = easter_date($annee); |
| $date_ascension = $this->donnerDateAscension($annee); |
| $date_pentecote = mktime( date("H", $date_ascension), |
| date("i", $date_ascension), |
| date("s", $date_ascension), |
| date("m", $date_ascension), |
| date("d", $date_ascension) + 11, |
| date("Y", $date_ascension)); |
| return $date_pentecote; |
| } |
| /** |
| *Indique si une date est fériée ou non |
| *renvoie 1 si férié |
| *0 sinon |
| */ |
| function etreFerie($date) |
| { |
| if (in_array($date, $this->liste_feries)) { |
| return 1; |
| } else { |
| return 0; |
| } |
| } |
| } |
| ?> |
| /trunk/bibliotheque/noyau/GestionnaireErreur.class.php |
|---|
| New file |
| 0,0 → 1,384 |
| <?php |
| /*vim: set expandtab tabstop=4 shiftwidth=4: */ |
| // +------------------------------------------------------------------------------------------------------+ |
| // | PHP version 5.0.4 | |
| // +------------------------------------------------------------------------------------------------------+ |
| // | Copyright (C) 2005 Tela Botanica (accueil@tela-botanica.org) | |
| // +------------------------------------------------------------------------------------------------------+ |
| // | This file is part of eFlore-Debogage. | |
| // | | |
| // | Foobar is free software; you can redistribute it and/or modify | |
| // | it under the terms of the GNU General Public License as published by | |
| // | the Free Software Foundation; either version 2 of the License, or | |
| // | (at your option) any later version. | |
| // | | |
| // | Foobar is distributed in the hope that it will be useful, | |
| // | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| // | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| // | GNU General Public License for more details. | |
| // | | |
| // | You should have received a copy of the GNU General Public License | |
| // | along with Foobar; if not, write to the Free Software | |
| // | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| // +------------------------------------------------------------------------------------------------------+ |
| // CVS : $Id: GestionnaireErreur.class.php,v 1.1 2005/11/15 17:33:49 jp_milcent Exp $ |
| /** |
| * Classe de gestion des erreurs. |
| * |
| * |
| * |
| *@package eFlore |
| *@subpackage Debogage |
| //Auteur original : |
| *@author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| //Autres auteurs : |
| *@author aucun |
| *@copyright Tela-Botanica 2000-2005 |
| *@version $Revision: 1.1 $ $Date: 2005/11/15 17:33:49 $ |
| // +------------------------------------------------------------------------------------------------------+ |
| */ |
| // +------------------------------------------------------------------------------------------------------+ |
| // | ENTETE du PROGRAMME | |
| // +------------------------------------------------------------------------------------------------------+ |
| // +------------------------------------------------------------------------------------------------------+ |
| // | CORPS du PROGRAMME | |
| // +------------------------------------------------------------------------------------------------------+ |
| /** |
| * Classe GestionnaireErreur |
| * |
| * Gérer les erreurs PHP et SQL. |
| */ |
| class GestionnaireErreur { |
| /*** Attributes: ***/ |
| /** |
| * Contient la liste des erreurs. |
| * @access private |
| */ |
| private $erreurs; |
| /** |
| * Permet de savoir si on veut faire apparaître ou pas le contexte de l'erreur, |
| * c'est à dire le contenu des variables. |
| * @access private |
| */ |
| private $contexte; |
| /** |
| * Permet de savoir si on veut faire apparaître ou pas les erreurs Pear. |
| * @access private |
| */ |
| private $pear; |
| /** |
| * Chaine de caractères permettant d'identifier les erreurs de la bibliothèque Pear. |
| * @access private |
| */ |
| private $pear_chaine; |
| /** |
| * Contient le niveau d'erreur courrant. Celui que l'on donne à la fonction |
| * error_reporting(). |
| * @access private |
| */ |
| private $niveau_erreur_courrant; |
| /*** Constructeur: ***/ |
| /** |
| * Construit le gestionnaire d'erreur. |
| * |
| * @return void |
| * @access public |
| */ |
| public function __construct($bool_contexte = false, $int_niveau = 2048, $bool_pear = false, $str_pear = '') |
| { |
| $this->erreurs = array(); |
| $this->setContexte($bool_contexte); |
| $this->setNiveauErreurCourrant($int_niveau); |
| $this->setPear($bool_pear); |
| $this->setPearChaine($str_pear); |
| set_error_handler(array($this, 'gererErreur')); |
| } // end of member function __construct |
| /*** Destructeur: ***/ |
| public function __destruct() |
| { |
| echo $this->retournerErreur(); |
| } |
| /*** Accesseurs: ***/ |
| /** |
| * Récupère le tableau des erreurs. |
| * |
| * @return array |
| * @access public |
| */ |
| public function getErreur() |
| { |
| return $this->erreurs; |
| } |
| /** |
| * Ajoute une erreur à la liste. |
| * |
| * @param array une_erreur |
| * @return void |
| * @access public |
| */ |
| public function setErreur($une_erreur) |
| { |
| $this->erreurs[] = $une_erreur; |
| } |
| /** |
| * Récupère la valeur du contexte. |
| * |
| * @return boolean |
| * @access public |
| */ |
| public function getContexte() |
| { |
| return $this->contexte; |
| } |
| /** |
| * Définit si oui ou non le contexte sera affiché. |
| * |
| * @param boolean un_contexte |
| * @return void |
| * @access public |
| */ |
| public function setContexte( $un_contexte ) |
| { |
| $this->contexte = $un_contexte; |
| } |
| /** |
| * Récupère la valeur de l'attribut Pear. |
| * |
| * @return boolean true pour afficher les erreurs Pear sinon false. |
| * @access public |
| */ |
| public function getPear() |
| { |
| return $this->pear; |
| } |
| /** |
| * Définit si oui ou non les erreurs Pear seront affichées. |
| * |
| * @param boolean true pour afficher les erreurs Pear sinon false. |
| * @return void |
| * @access public |
| */ |
| public function setPear( $p ) |
| { |
| $this->pear = $p; |
| } |
| /** |
| * Récupère la valeur de l'attribut pear_chaine. |
| * |
| * @return string la chaine de caractère identifiant les erreurs Pear. |
| * @access public |
| */ |
| public function getPearChaine() |
| { |
| return $this->pear_chaine; |
| } |
| /** |
| * Définit la chaine de caractère identifiant les erreurs Pear. |
| * |
| * @param string la chaine de caractère identifiant les erreurs Pear. |
| * @return void |
| * @access public |
| */ |
| public function setPearChaine( $pc ) |
| { |
| $this->pear_chaine = $pc; |
| } |
| /** |
| * Récupère le niveau d'erreur courrant. |
| * |
| * @return int le niveau d'erreur courrant. |
| * @access public |
| */ |
| public function getNiveauErreurCourrant() |
| { |
| return (int)$this->niveau_erreur_courrant; |
| } |
| /** |
| * Définit le niveau d'erreur courrant. |
| * |
| * @param int un niveau d'erreur. |
| * @return void |
| * @access public |
| */ |
| public function setNiveauErreurCourrant($niveau) |
| { |
| $this->niveau_erreur_courrant = $niveau; |
| } |
| /*** Méthodes : ***/ |
| /** |
| * |
| * @param int niveau |
| * @param string message |
| * @param string fichier |
| * @param int ligne |
| * @param boolean contexte |
| * @return void |
| * @access public |
| */ |
| public function gererErreur( $niveau, $message, $fichier, $ligne, $contexte ) |
| { |
| $aso_erreur = array(); |
| // Nous vérifions si nous affichons ou pas l'erreur en fonction du niveau demandé |
| if ( $niveau <= $this->getNiveauErreurCourrant() ) { |
| $aso_erreur['niveau'] = $niveau; |
| $aso_erreur['message'] = $message; |
| $aso_erreur['fichier'] = $fichier; |
| $aso_erreur['ligne'] = $ligne; |
| if ($this->getContexte()) { |
| $aso_erreur['contexte'] = $contexte; |
| } |
| $this->setErreur($aso_erreur); |
| } |
| // Si nous avons à faire à une erreur et non à un warning ou une notice, nous arrêtons l'exécution du script |
| if ($niveau == E_USER_ERROR) { |
| echo $this->retournerErreur(); |
| exit(1); |
| } |
| } // end of member function gererErreur |
| /** |
| * Retourne l'erreur PHP formatée en XHTML. |
| * |
| * @return string |
| * @access public |
| */ |
| public function retournerErreur() |
| { |
| $retour = ''; |
| $erreur_pear_nbre = 0; |
| foreach($this->getErreur() as $aso_erreur) { |
| if ('<!-- BEGIN sql -->' == substr($aso_erreur['message'], 0, 18)) { |
| $retour .= $aso_erreur['message']; |
| continue; |
| } |
| // Nous testons les erreurs PEAR pour ne pas en tenir compte |
| if (!$this->getPear() && stristr($aso_erreur['fichier'], $this->getPearChaine())) { |
| $erreur_pear_nbre++; |
| } else { |
| $retour .= '<p class="attention">'."\n"; |
| $retour .= '<strong>ERREUR</strong><br />'."\n"; |
| $retour .= '<strong>Niveau : </strong>'.$aso_erreur['niveau'].'<br />'."\n"; |
| $retour .= '<strong>Message : </strong>'.$aso_erreur['message'].'<br />'."\n"; |
| $retour .= '<strong>Fichier : </strong>'.$aso_erreur['fichier'].'<br />'."\n"; |
| $retour .= '<strong>Ligne : </strong>'.$aso_erreur['ligne'].'<br />'."\n"; |
| if ($this->getContexte()) { |
| $retour .= '<pre>'."\n"; |
| $retour .= '<stong>Contexte : </stong>'."\n".print_r($aso_erreur['contexte'], true)."\n"; |
| $retour .= '</pre>'."\n"; |
| } |
| $retour .= '</p>'."\n"; |
| } |
| } |
| if ($erreur_pear_nbre != 0) { |
| $retour .= '<p class="attention"><strong>Nombre d\'erreurs PEAR : </strong>'.$erreur_pear_nbre.'</p>'."\n"; |
| } |
| return $retour; |
| } // end of member function retournerErreur |
| /** |
| * Retourne l'erreur SQL formatée. |
| * |
| * @param string fichier |
| * @param int ligne |
| * @param string message |
| * @param string requete |
| * @param string autres |
| * @return string |
| * @static |
| * @access public |
| */ |
| public static function retournerErreurSql( $fichier, $methode, $message, $requete = NULL, $autres = NULL ) |
| { |
| $retour = '<!-- BEGIN sql -->'; |
| $retour .= '<div id="zone_erreur">'."\n"; |
| $retour .= '<h1 > ERREUR SQL </h1><br />'."\n"; |
| $retour .= '<dl>'."\n"; |
| $retour .= '<dt> Fichier : </dt> '; |
| $retour .= '<dd> '.$fichier.'</dd>'."\n"; |
| $retour .= '<dt> Méthode : </dt> '; |
| $retour .= '<dd> '.$methode.'</dd>'."\n"; |
| $retour .= '<dt> Message erreur : </dt> '; |
| $retour .= '<dd> '.$message.'</dd>'."\n"; |
| if (!is_null($requete)) { |
| $retour .= '<dt> Requete : </dt> '; |
| $retour .= '<dd> '.$requete.' </dd>'."\n"; |
| } |
| if (!is_null($autres)) { |
| $retour .= '<dt> Autres infos : </dt> '; |
| $retour .= '<dd> '.$autres.' </dd>'."\n"; |
| } |
| $retour .= '</dl>'."\n"; |
| $retour .= '</div>'."\n"; |
| $retour .= '<!-- END sql -->'."\n"; |
| return $retour; |
| } // end of member function retournerErreurSql |
| /** |
| * Retourne l'erreur SQL formatée selon le format demandé. |
| * |
| * @param string fichier |
| * @param int ligne |
| * @param string message |
| * @param string format : txt. |
| * @return string |
| * @static |
| * @access public |
| */ |
| public static function formaterMessageErreur( $message, $fichier = null, $ligne = null, $format = 'txt' ) |
| { |
| $retour = ''; |
| if ($format == 'txt') { |
| $retour .= "\n"; |
| if (!is_null($fichier)) { |
| $retour .= "\t".'Fichier : '.$fichier."\n"; |
| } |
| if (!is_null($ligne)) { |
| $retour .= "\t".'Ligne : '.$ligne."\n"; |
| } |
| $retour .= "\t".'Message : '.$message."\n"; |
| } |
| return $retour; |
| } |
| } |
| /* +--Fin du code ----------------------------------------------------------------------------------------+ |
| * |
| * $Log$ |
| * |
| * +-- Fin du code ----------------------------------------------------------------------------------------+ |
| */ |
| ?> |
| /trunk/bibliotheque/noyau/ControlleurFrontal.class.php |
|---|
| New file |
| 0,0 → 1,117 |
| <?php |
| class ControlleurFrontal { |
| public function getRegistre() |
| { |
| return Registre::getRegistre(); |
| } |
| public function parserAction($url) |
| { |
| if (preg_match('/^(.+?)(?:_(.+)|)$/', $url, $match)) { |
| $aso_compo_classe = explode('-', $match[1]); |
| $retour['classe_action'] = 'GttCtrlAction'; |
| foreach ($aso_compo_classe as $mot) { |
| $retour['classe_action'] .= ucfirst($mot); |
| } |
| } |
| $retour['tab_actions'] = array('__defaut__'); |
| if (isset($match[2])) { |
| preg_match_all('/(.+)(?:_|$)/', $match[2], $match_actions); |
| //echo '<pre>'.print_r($match_actions[1], true).'</pre>'; |
| foreach ($match_actions[1] as $action) { |
| $aso_compo_action = explode('-', $action); |
| $action = ''; |
| foreach ($aso_compo_action as $mot_action) { |
| $action .= ucfirst($mot_action); |
| } |
| $retour['tab_actions'][] = $action; |
| } |
| } |
| return $retour; |
| } |
| private function chargerActionGenerique(&$tab_actions) |
| { |
| // Gestion de l'identification |
| $GttCtrlActionIdentification = new GttCtrlActionIdentification($this->getRegistre()); |
| $GttCtrlActionIdentification->setSuivant('__defaut__'); |
| array_unshift($tab_actions, $GttCtrlActionIdentification); |
| // Gestion des menus |
| $GttCtrlActionMenu = new GttCtrlActionMenu($this->getRegistre()); |
| $GttCtrlActionMenu->setSuivant('__defaut__'); |
| $tab_actions[] = $GttCtrlActionMenu; |
| } |
| public function executer($url_action) |
| { |
| $tab_info_url = $this->parserAction($url_action); |
| //echo '<pre>'.print_r($tab_info_url, true).'</pre>'; |
| $classe_action = $tab_info_url['classe_action']; |
| $fichier_action = GTT_CHEMIN_ACTION.$classe_action.'.class.php'; |
| if (file_exists($fichier_action)) { |
| require_once $fichier_action; |
| $Action = new $classe_action($this->getRegistre()); |
| $this->chargerActionGenerique(&$tab_info_url['tab_actions']); |
| $Action->setSuivant($tab_info_url['tab_actions']); |
| $Action->demarrer(); |
| $aso_principal['principal'] = $this->rendre(); |
| //echo '<pre>'.print_r($aso_principal, true).'</pre>'; |
| $aso_principal['principal']['titre'] = $this->getRegistre()->getTitre(); |
| $this->getRegistre()->setEspaces(array()); |
| $this->getRegistre()->setSquelettes(array()); |
| $this->getRegistre()->setDonnees(array()); |
| $this->getRegistre()->ajouterEspace('Principal', 'principal'); |
| $this->getRegistre()->ajouterSquelette('principal', 'principal.tpl.html'); |
| $this->getRegistre()->ajouterDonnee('principal', $aso_principal['principal']); |
| return $this->rendre(); |
| } else { |
| $m = "Le fichier $fichier_action contenant l'action est introuvable!"; |
| trigger_error($m, E_USER_ERROR); |
| } |
| } |
| public function rendre() |
| { |
| $contenu_principal = null; |
| $aso_contenu = array('zone_contenu' => '', 'zone_menu' => '', 'zone_identification' => ''); |
| foreach ($this->getRegistre()->getEspaces() as $espace_de_nom) { |
| if (is_array($this->getRegistre()->getDonnees($espace_de_nom))) { |
| $fichier_squelette = GTT_CHEMIN_PRESENTATION.$this->getRegistre()->getSquelettes($espace_de_nom); |
| if (file_exists($fichier_squelette)) { |
| ob_start(); |
| extract($GLOBALS['_GTT_']['i18n']['general'], EXTR_PREFIX_ALL, 'i18n_general'); |
| extract($this->getRegistre()->getDonnees($espace_de_nom)); |
| include_once $fichier_squelette; |
| // Répartition dans des zones |
| switch($espace_de_nom) { |
| case 'principal' : |
| $contenu_principal .= ob_get_contents(); |
| break; |
| case 'identification' : |
| $aso_contenu['zone_identification'] .= ob_get_contents(); |
| break; |
| case 'zone_menu' : |
| $aso_contenu['zone_menu'] .= ob_get_contents(); |
| break; |
| default: |
| $aso_contenu['zone_contenu'] .= ob_get_contents(); |
| } |
| ob_end_clean(); |
| } else { |
| trigger_error("Absence du fichier de squelette : $fichier_squelette", E_USER_ERROR); |
| } |
| } |
| } |
| if (!is_null($contenu_principal)) { |
| return $contenu_principal; |
| } |
| return $aso_contenu; |
| } |
| } |
| ?> |