| /branches/v2.0-betulales/interfaces/controleurs/Test.php |
|---|
| New file |
| 0,0 → 1,119 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur du module Test. |
| * |
| * TODO : refactoriser l'ensemble des tests! |
| * |
| * @package Referentiel |
| * @category Php5.2 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 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$ |
| */ |
| class Test extends AppliControleur { |
| const SCRIPT_A_LANCER = 'tests'; |
| private $referentiel = null; |
| private $referentielDao = null; |
| private $traitementDao = null; |
| public function __construct() { |
| parent::__construct(); |
| // Récupération de paramêtres |
| if (isset($_GET['ref'])) { // code du projet courrant |
| $this->referentiel = strtolower($_GET['ref']); |
| } |
| // Chargement des DAO nécessaires |
| $this->referentielDao = new ReferentielDao(); |
| $this->traitementDao = new TraitementDao(); |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut, elle appelle la liste des administrateurs |
| */ |
| public function executerActionParDefaut() { |
| return $this->afficherInterface(); |
| } |
| /** |
| * Affiche le formulaire de demande de traitement |
| */ |
| public function afficherInterface() { |
| if ($this->authentifierCoordinateur()) { |
| $donnees = array(); |
| $this->definirCommeModulePrincipal(get_class($this)); |
| $this->url->unsetVariablesRequete(array('module', 'action', 'ref')); |
| $donnees['url_form'] = $this->url->getUrl(); |
| $donnees['url_module'] = 'Test'; |
| $donnees['url_action_demande'] = 'demanderTraitement'; |
| $donnees['url_action_rafraichir'] = 'afficherInterface'; |
| $donnees['url_action_importer'] = 'importerReferentiel'; |
| $donnees['url_importation'] = $donnees['url_form']. |
| '?module='.$donnees['url_module'].'&action='.$donnees['url_action_importer'].'&ref='.$this->referentiel; |
| // Traitement de l'info sur le code du référentiel |
| if (isset($this->referentiel)) { |
| // Récupération du nom du référentiel courrant |
| $donnees['nom_referentiel'] = $this->referentielDao->getNom($this->referentiel); |
| // Récupération du référentiel courrant |
| $donnees['ref'] = $this->referentiel; |
| // Recherche des traitements en attente |
| $donnees['traitements_en_attente'] = $this->traitementDao->getTraitementsEnAttente($this->referentiel, self::SCRIPT_A_LANCER); |
| // Recherche des traitements en cours d'éxecution |
| $donnees['traitements_en_cours'] = $this->traitementDao->getTraitementsEnCours($this->referentiel, self::SCRIPT_A_LANCER); |
| // Recherche des traitements déjà effectué |
| $resultat = $this->traitementDao->getTraitementsTermines($this->referentiel, self::SCRIPT_A_LANCER); |
| if (is_array($resultat)) { |
| // Ajout de l'url vers la fiche du traitement |
| foreach ($resultat as &$traitement) { |
| $traitement['url'] = $this->obtenirUrlFicheTraitement($this->referentiel, $traitement['id_traitement']); |
| } |
| $donnees['traitements_termines'] = $resultat; |
| } |
| } else { |
| $this->addMessage("Aucun code de projet de référentiel n'est indiqué (Ex. bdtfx)."); |
| } |
| $donnees['messages'] = $this->getMessages(); |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('form_tests', $donnees), false); |
| $this->construireMenu($this->referentiel); |
| $this->construireFilAriane($this->referentiel); |
| } |
| } |
| /** |
| * Lance l'ajout d'un traitement |
| */ |
| public function demanderTraitement() { |
| $this->ajouterTraitement($this->referentiel, self::SCRIPT_A_LANCER); |
| $this->afficherInterface(); |
| } |
| /** |
| * Lance l'importation d'un référentiel au format taxref dans une table bdnt_taxref |
| */ |
| public function importerReferentiel() { |
| if (isset($_FILES['nom_fichier']) && $_FILES['nom_fichier']['name'] != '') { |
| $destination = Config::get('chemin_tmp').$_FILES['nom_fichier']['name']; |
| move_uploaded_file($_FILES['nom_fichier']['tmp_name'], $destination); |
| $this->ajouterTraitementParametre($this->referentiel, $destination, 'importation'); |
| } else { |
| $this->addMessage("Aucun fichier n'a été précisé."); |
| } |
| $this->afficherInterface(); |
| } |
| } |
| ?> |
| /branches/v2.0-betulales/interfaces/controleurs/Versionnage.php |
|---|
| New file |
| 0,0 → 1,273 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur du module Versionnage. |
| * Permet de publier une nouvelle version d'un référentiel de travail. |
| * |
| * @package Referentiel |
| * @category Php5.2 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 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$ |
| */ |
| class Versionnage extends AppliControleur { |
| const SCRIPT_A_LANCER = 'versionnage'; |
| private $version = array('titre', 'acronyme', 'version', 'date_prod', |
| 'auteur_principal', 'coordinateur', 'editeur', 'contact', |
| 'contributeur', |
| 'classification', 'dom_tax', 'dom_geo', 'dom_code', |
| 'source', 'copyright', 'licence', 'referencement', |
| 'errata', 'notes'); |
| private $referentiel = null; |
| private $referentielDao = null; |
| private $traitementDao = null; |
| public function __construct() { |
| parent::__construct(); |
| // Récupération de paramêtres |
| if (isset($_GET['ref'])) { // code du projet courrant |
| $this->referentiel = strtolower($_GET['ref']); |
| } |
| // Chargement des DAO nécessaires |
| $this->referentielDao = new ReferentielDao(); |
| $this->traitementDao = new TraitementDao(); |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| return $this->afficherInterface(); |
| } |
| /** |
| * Affiche le formulaire de demande de versionnage |
| */ |
| public function afficherInterface() { |
| if ($this->authentifierCoordinateur()) { |
| $donnees = array(); |
| $this->definirCommeModulePrincipal(get_class($this)); |
| // Paramêtres pour l'url du formulaire |
| $this->url->unsetVariablesRequete(array('module', 'action', 'ref')); |
| $donnees['url_form'] = $this->obtenirUrlDemandeVersionnage($this->referentiel); |
| $donnees['url_module'] = 'Versionnage'; |
| $donnees['url_action_rafraichir'] = 'afficherInterface'; |
| $donnees['version'] = $this->instancierChampsVersionnage(); |
| $donnees['version'] = $this->traiterCasesACocher($donnees['version']); |
| // Récupération des paramètres de configuration du manuel des référentiels |
| $donnees['domaine_geo'] = explode(';', $this->manuel['domaine_geo']); |
| $donnees['domaine_taxo'] = explode(';', $this->manuel['domaine_taxo']); |
| $donnees['domaine_code'] = explode(';', $this->manuel['domaine_code']); |
| // Traitement de l'info sur le code du référentiel |
| if (isset($this->referentiel)) { |
| // Récupération du nom du référentiel courrant |
| $donnees['nom_referentiel'] = $this->referentielDao->getNom($this->referentiel); |
| // Récupération du référentiel courrant |
| $donnees['ref'] = $this->referentiel; |
| // Recherche des traitements en attente |
| $donnees['traitements_en_attente'] = $this->traitementDao->getTraitementsEnAttente($this->referentiel, self::SCRIPT_A_LANCER); |
| // Recherche des traitements en cours d'éxecution |
| $donnees['traitements_en_cours'] = $this->traitementDao->getTraitementsEnCours($this->referentiel, self::SCRIPT_A_LANCER); |
| // Recherche des traitements déjà effectué |
| $resultat = $this->traitementDao->getTraitementsTermines($this->referentiel, self::SCRIPT_A_LANCER); |
| if (is_array($resultat)) { |
| // Ajout de l'url vers la fiche du traitement |
| foreach ($resultat as &$traitement) { |
| $traitement['url'] = $this->obtenirUrlFicheTraitement($this->referentiel, $traitement['id_traitement']); |
| } |
| $donnees['traitements_termines'] = $resultat; |
| } |
| } else { |
| $this->addMessage("Aucun code de projet de référentiel n'est indiqué (Ex. bdtfx)."); |
| } |
| $donnees['messages'] = $this->getMessages(); |
| $this->traiterEsperluette($donnees); |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('form_version', $donnees), false); |
| $this->construireMenu($this->referentiel); |
| $this->construireFilAriane($this->referentiel); |
| } |
| } |
| public function instancierChampsVersionnage() { |
| $version = array(); |
| foreach ($this->version as $champ) { |
| if (isset($_POST[$champ])) { |
| $version[$champ] = $this->supprimerSlash($_POST[$champ]); |
| } else { |
| $version[$champ] = $this->getValeurParDefaut($champ); |
| } |
| } |
| return $version; |
| } |
| public function getValeurParDefaut($champ) { |
| $valeur = ''; |
| if ('date_prod' == $champ) { |
| $valeur = date('Y-m-d'); |
| } |
| return $valeur; |
| } |
| private function traiterCasesACocher(Array $donnees) { |
| foreach ($donnees as $cle => $valeur) { |
| if (is_array($valeur)) { |
| $this->traiterEsperluette($valeur); |
| $donnees[$cle] = array_flip($valeur); |
| } |
| } |
| return $donnees; |
| } |
| /** |
| * Lance l'ajout d'un traitement |
| */ |
| public function demanderTraitement() { |
| if ($this->verifierMetadonnees()) { |
| $parametres = $this->instancierChampsVersionnage(); |
| $parametres_serialises = serialize($parametres); |
| $this->ajouterTraitementParametre($this->referentiel, $parametres_serialises, self::SCRIPT_A_LANCER); |
| } |
| $this->afficherInterface(); |
| } |
| /** |
| * Vérifie les données du formulaire |
| */ |
| public function verifierMetadonnees() { |
| $ok = true; |
| if (! $this->verifierChampsObligatoires()) { |
| $ok = false; |
| } |
| if (! $this->verifierChampsMajuscule()) { |
| $ok = false; |
| } |
| if (! $this->verifierChampsContact()) { |
| $ok = false; |
| } |
| if (! $this->verifierChampsCourriel()) { |
| $ok = false; |
| } |
| return $ok; |
| } |
| public function verifierChampsObligatoires() { |
| $ok = true; |
| $champs_obligatoires = array('titre' => 'Titre', |
| 'acronyme' => 'Acronyme', |
| 'version' => 'Version', |
| 'auteur_principal' => 'Auteur Principal', |
| 'coordinateur' => 'coordinateur', |
| 'contact' => 'Courriel de contact', |
| 'classification' => 'Classification par défaut', |
| 'dom_tax' => 'Domaine taxonomique', |
| 'dom_geo' => 'Domaine géographique', |
| 'dom_code' => 'Codes botaniques utilisés', |
| 'referencement' => 'Comment citer ce référentiel?', |
| 'errata' => 'Errata (URL)'); |
| foreach ($champs_obligatoires as $champ_id => $champ_nom) { |
| if (!isset($_POST[$champ_id]) || empty($_POST[$champ_id])) { |
| $this->addMessage("Le champ '$champ_nom' doit être obligatoirement rempli."); |
| $ok = false; |
| } |
| } |
| return $ok; |
| } |
| public function verifierChampsMajuscule() { |
| $ok = true; |
| $champs_en_majuscule = array('acronyme' => 'Acronyme'); |
| foreach ($champs_en_majuscule as $champ_id => $champ_nom) { |
| if (isset($_POST[$champ_id]) && ! $this->verifierMajusculeSansAccent($_POST[$champ_id])) { |
| $this->addMessage("Le champ '$champ_nom' doit être obligatoirement composé de majuscules non accentuées."); |
| $ok = false; |
| } |
| } |
| return $ok; |
| } |
| /** |
| * Vérifie la mise en majuscule |
| */ |
| public function verifierMajusculeSansAccent($txt) { |
| $ok = (preg_match('/^[A-Z]+$/', $txt)) ? true : false; |
| return $ok; |
| } |
| public function verifierChampsContact() { |
| $ok = true; |
| $champs_contact = array('auteur_principal' => 'Auteur Principal', |
| 'coordinateur' => 'coordinateur', |
| 'contributeur' => 'Auteurs/Contributeurs'); |
| foreach ($champs_contact as $champ_id => $champ_nom) { |
| if (isset($_POST[$champ_id]) && ! $this->verifierContact($_POST[$champ_id])) { |
| $this->addMessage("Le champ '$champ_nom' n'est pas au format : Prénom1 NOM1 (Organisation1) [courriel1], Prénom2 NOM2 (Organisation2) [courriel2]."); |
| $ok = false; |
| } |
| } |
| return $ok; |
| } |
| /** |
| * Vérifie que le texte est au format : |
| * Prénom1 NOM1 (Organisation1) <courriel1>, |
| * Prénom2 NOM2 (Organisation2) <courriel2>. |
| */ |
| public function verifierContact($txt) { |
| $ok = true; |
| if ($txt != '') { |
| $pp = Pattern::PRENOM; |
| $pn = Pattern::NOM; |
| $po = "\([^\)]+\)";// Pattern organisation |
| $pc = Pattern::COURRIEL; |
| $contacts = explode(',', $txt); |
| foreach ($contacts as $contact) { |
| $contact = trim($contact); |
| if (! preg_match("/^$pp $pn $po \[$pc\](?:|.)$/u", $contact)) { |
| $ok = false; |
| } |
| } |
| } |
| return $ok; |
| } |
| public function verifierChampsCourriel() { |
| $ok = true; |
| $champs_courriel = array('contact' => 'Courriel de contact'); |
| foreach ($champs_courriel as $champ_id => $champ_nom) { |
| if (isset($_POST[$champ_id]) && ! $this->verifierCourriel($_POST[$champ_id])) { |
| $this->addMessage("Le champ '$champ_nom' ne comptient pas une adresse de courriel valide."); |
| $ok = false; |
| } |
| } |
| return $ok; |
| } |
| /** |
| * Vérifie que le texte est une adresse de courriel valide. |
| */ |
| public function verifierCourriel($txt) { |
| $pattern_courriel = Pattern::COURRIEL; |
| $ok = (preg_match('/^'.$pattern_courriel.'+$/', $txt)) ? true : false; |
| return $ok; |
| } |
| } |
| ?> |
| /branches/v2.0-betulales/interfaces/controleurs/AppliControleur.php |
|---|
| New file |
| 0,0 → 1,603 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur générale partagée par les différents modules de l'application. |
| * |
| * @package Referentiel |
| * @category Php5.2 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 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$ |
| */ |
| abstract class AppliControleur extends Controleur { |
| const RENDU_TETE = 'tete'; |
| const RENDU_CORPS = 'corps'; |
| const RENDU_PIED = 'pied'; |
| const RENDU_NAVIGATION = 'navigation'; |
| const RENDU_MENU = 'menu'; |
| // FIXME : voir s'il est plus intéressant d'utiliser une méthode dans les classes filles |
| protected $url = null; |
| private $parametres = array(); |
| protected $manuel = null; |
| private $sortie = array(); |
| private $messages = null; |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Constructeur |
| public function __construct() { |
| $registre = Registre::getInstance(); |
| $this->parametres = $registre->get('parametres'); |
| $this->url = $this->parametres['url']; |
| // Chargement des infos du manuel technique des référentiels |
| $this->manuel = parse_ini_file(Config::get('chemin_appli').DS.'..'.DS.'configurations'.DS.Config::get('manuel')); |
| parent::__construct(); |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Accesseurs |
| /** |
| * Retourne le tableau de sortie à utiliser dans le controleur principal de l'application. |
| */ |
| public function getSortie() { |
| return $this->sortie; |
| } |
| /** |
| * Attribue à la bonne position de sortie un contenu. |
| */ |
| protected function setSortie($position, $contenu, $fusionner = false) { |
| if ($this->verifierExistencePosition($position)) { |
| if ($fusionner) { |
| $this->sortie[$position] .= $contenu; |
| } else { |
| $this->sortie[$position] = $contenu; |
| } |
| } |
| } |
| /** |
| * Retourne le tableau des messages |
| */ |
| protected function getMessages() { |
| return $this->messages; |
| } |
| /** |
| * Ajoute un message |
| */ |
| protected function addMessage($message) { |
| if ('' != $message) { |
| $this->messages[] = $message; |
| } |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Vérifie l'existence de la position indiquée pour son utilisation dans le tableau de sortie. |
| * @param string la position à tester. |
| * @return bool true si la position est valide, sinon false. |
| */ |
| private function verifierExistencePosition($position) { |
| $existe = true; |
| if ($position != self::RENDU_TETE && |
| $position != self::RENDU_CORPS && |
| $position != self::RENDU_PIED && |
| $position != self::RENDU_NAVIGATION && |
| $position != self::RENDU_MENU) { |
| trigger_error("La position '$position' n'est pas une valeur prédéfinie.", E_USER_WARNING); |
| $existe = false; |
| } |
| return $existe; |
| } |
| /** |
| * Execute l'action d'un module donnée et fusionne le résultat avec le tableau de sortie. |
| */ |
| protected function executerAction($ClasseModule, $action) { |
| $module = new $ClasseModule(); |
| $module->$action(); |
| $this->fusionnerSortie($module->getSortie()); |
| } |
| protected function executerActionReferentiel($ClasseModule, $action, $referentiel, $afficheMoteur = null) { |
| $module = new $ClasseModule(); |
| $module->$action($referentiel, $afficheMoteur); |
| $this->fusionnerSortie($module->getSortie()); |
| } |
| /** |
| * Fusionne un tableau de sortie par défaut avec le tableau passé en paramêtre. |
| * @param array le tableau à fusionner |
| */ |
| private function fusionnerSortie($sortie) { |
| $this->sortie = array_merge($this->sortie, $sortie); |
| } |
| protected function postraiterDonnees(&$tableau) { |
| if (count($tableau) > 0) { |
| foreach ($tableau as $cle => &$valeur) { |
| if ($valeur == '') { |
| $valeur = ' '; |
| } else if (is_string($valeur)) { |
| $valeur = $this->remplacerEsperluette($valeur); |
| } else if (is_array($valeur)) { |
| $this->postraiterDonnees($valeur); |
| } |
| } |
| } |
| } |
| protected function traiterEsperluette(&$tableau) { |
| if (count($tableau) > 0) { |
| foreach ($tableau as $cle => &$valeur) { |
| if (is_string($valeur)) { |
| $valeur = $this->remplacerEsperluette($valeur); |
| } else if (is_array($valeur)) { |
| $this->traiterEsperluette($valeur); |
| } |
| } |
| } |
| } |
| protected function remplacerEsperluette($txt) { |
| $txt = preg_replace('/&(?!([a-z]+|#[0-9]+|#x[0-9a-f]+);)/i', '&', $txt, -1); |
| return $txt; |
| } |
| protected function supprimerSlash($doc) { |
| if (is_string($doc)) { |
| $doc = stripslashes($doc); |
| } else if (is_array($doc) && count($doc) > 0) { |
| foreach ($doc as $cle => $valeur) { |
| $doc[$cle] = $this->supprimerSlash($valeur); |
| } |
| } |
| return $doc; |
| } |
| protected function initialiserModulePrincipal() { |
| $_SESSION['module_principal'] = null; |
| } |
| protected function definirCommeModulePrincipal($module_nom) { |
| $_SESSION['module_principal'] = $module_nom; |
| } |
| private function getModulePrincipalCourant() { |
| return $_SESSION['module_principal']; |
| } |
| /** |
| * Construction du menu et stockage dans le conteneur de sortie RENDU_MENU. |
| * |
| * @param string $referentiel code du référentiel. |
| */ |
| protected function construireMenu($referentiel) { |
| $menu['nom'] = 'Accueil'; |
| $menu['url'] = $this->obtenirUrlMenuAccueil(); |
| $menu['activite'] = (($this->getModulePrincipalCourant() == 'Accueil') ? 'actif' : 'inactif'); |
| $menu['title'] = "Liste des référentiels consultables."; |
| $donnees['menus'][] = $menu; |
| $menu['nom'] = 'Consultation'; |
| $menu['url'] = $this->obtenirUrlMenuConsultation($referentiel); |
| $menu['activite'] = ((preg_match('/^(?:Consultation|Recherche|FicheTaxon)$/', $this->getModulePrincipalCourant())) ? 'actif' : 'inactif'); |
| $menu['title'] = "Interroger la base en cours de travail."; |
| $donnees['menus'][] = $menu; |
| $menu['nom'] = 'Arbre taxo'; |
| $menu['url'] = $this->obtenirUrlMenuArbre($referentiel); |
| $menu['activite'] = (($this->getModulePrincipalCourant() == 'Arbre') ? 'actif' : 'inactif'); |
| $menu['title'] = "Consulter l'aborescence du référentiel"; |
| $donnees['menus'][] = $menu; |
| $menu['nom'] = 'Tests'; |
| $menu['url'] = $this->obtenirUrlMenuTest($referentiel); |
| $menu['activite'] = (($this->getModulePrincipalCourant() == 'Test') ? 'actif' : 'inactif securise'); |
| $menu['title'] = "Réservé aux coordinateurs. Contrôler les données saisies."; |
| $donnees['menus'][] = $menu; |
| $menu['nom'] = 'Versionnage'; |
| $menu['url'] = $this->obtenirUrlMenuVersionnage($referentiel); |
| $menu['activite'] = (($this->getModulePrincipalCourant() == 'Versionnage') ? 'actif' : 'inactif securise'); |
| $menu['title'] = "Réservé aux coordinateurs. Générer une version de la base."; |
| $donnees['menus'][] = $menu; |
| $menu['nom'] = 'Informations et téléchargements'; |
| $menu['url'] = $this->obtenirUrlMenuInformations($referentiel); |
| $menu['activite'] = (($this->getModulePrincipalCourant() == 'Informations') ? 'actif' : 'inactif'); |
| $menu['title'] = "Informations sur le projet et téléchargements."; |
| $donnees['menus'][] = $menu; |
| $this->setSortie(self::RENDU_MENU, $this->getVue('menu', $donnees), false); |
| } |
| /** |
| * Construction du fil d'ariane et stockage dans le conteneur de sortie RENDU_NAVIGATION. |
| * |
| * @param $referentiel code du référentiel |
| * @param $id_traitement id du traitement |
| * @param $id_resultat id du résultat |
| */ |
| protected function construireFilAriane($referentiel = null, $id_traitement = null, $id_resultat = null) { |
| $entree['nom'] = 'Accueil'; |
| $entree['url'] = $this->obtenirUrlMenuAccueil(); |
| $donnees['entrees'][] = $entree; |
| if (isset($referentiel)) { |
| $entree['nom'] = 'Informations '.strtoupper($referentiel); |
| $entree['url'] = $this->obtenirUrlDetailReferentiel($referentiel); |
| $donnees['entrees'][] = $entree; |
| $module_principal = $this->getModulePrincipalCourant(); |
| if (isset($module_principal)) { |
| $entree['nom'] = $module_principal; |
| $entree['url'] = $this->obtenirUrlMenu($module_principal, $referentiel); |
| $donnees['entrees'][] = $entree; |
| } |
| if (isset($id_traitement)) { |
| $entree['nom'] = "Traitement #$id_traitement"; |
| $entree['url'] = $this->obtenirUrlFicheTraitement($referentiel, $id_traitement); |
| $donnees['entrees'][] = $entree; |
| } |
| if (isset($id_resultat)) { |
| $entree['nom'] = "Résultat #$id_resultat"; |
| $entree['url'] = $this->obtenirUrlFicheResultat($referentiel, $id_resultat); |
| $donnees['entrees'][] = $entree; |
| } |
| } |
| $this->setSortie(self::RENDU_NAVIGATION, $this->getVue('fil_ariane', $donnees), false); |
| } |
| protected function obtenirUrlDetailReferentiel($referentiel) { |
| $this->url->setRequete(false); |
| $this->url->setVariableRequete('module', 'Informations'); |
| $this->url->setVariableRequete('ref', $referentiel); |
| $url = $this->url->getURL(); |
| $this->url->unsetVariablesRequete(array('module', 'action', 'ref')); |
| return $url; |
| } |
| protected function obtenirUrlDetailReferentielTelechargement($referentiel) { |
| $this->url->setRequete(false); |
| $this->url->setVariableRequete('module', 'Informations'); |
| $this->url->setVariableRequete('action', 'telecharger'); |
| $this->url->setVariableRequete('ref', $referentiel); |
| $url = $this->url->getURL(); |
| $this->url->unsetVariablesRequete(array('module', 'action', 'ref')); |
| return $url; |
| } |
| protected function obtenirUrlMenuInformations($referentiel) { |
| return $this->obtenirUrlMenu('Informations', $referentiel); |
| } |
| protected function obtenirUrlMenuAccueil() { |
| return $this->obtenirUrlMenu('Accueil'); |
| } |
| protected function obtenirUrlMenuTest($referentiel) { |
| return $this->obtenirUrlMenu('Test', $referentiel); |
| } |
| protected function obtenirUrlMenuVersionnage($referentiel) { |
| return $this->obtenirUrlMenu('Versionnage', $referentiel); |
| } |
| protected function obtenirUrlDemandeVersionnage($referentiel) { |
| $this->url->setRequete(false); |
| $this->url->setVariableRequete('module', 'Versionnage'); |
| $this->url->setVariableRequete('action', 'demanderTraitement'); |
| $this->url->setVariableRequete('ref', $referentiel); |
| $url = $this->url->getURL(); |
| $this->url->unsetVariablesRequete(array('module', 'action', 'ref')); |
| return $url; |
| } |
| protected function obtenirUrlMenuConsultation($referentiel) { |
| return $this->obtenirUrlMenu('Consultation', $referentiel); |
| } |
| protected function obtenirUrlMenuArbre($referentiel) { |
| return $this->obtenirUrlMenu('Arbre', $referentiel); |
| } |
| protected function obtenirUrlMenuBranche($referentiel, $num_nom) { |
| $this->url->setRequete(false); |
| $this->url->setVariableRequete('module', 'Arbre'); |
| $this->url->setVariableRequete('action', 'afficherBranche'); |
| $this->url->setVariableRequete('ref', $referentiel); |
| $this->url->setVariableRequete('num_nom', $num_nom); |
| $url = $this->url->getURL(); |
| $this->url->unsetVariablesRequete(array('module', 'action', 'ref', 'num_nom')); |
| return $url; |
| } |
| protected function obtenirUrlMenuBrancheSynonyme($referentiel, $num_nom) { |
| $this->url->setRequete(false); |
| $this->url->setVariableRequete('module', 'Arbre'); |
| $this->url->setVariableRequete('action', 'afficherBrancheSynonyme'); |
| $this->url->setVariableRequete('ref', $referentiel); |
| $this->url->setVariableRequete('num_nom', $num_nom); |
| $url = $this->url->getURL(); |
| $this->url->unsetVariablesRequete(array('module', 'action', 'ref', 'num_nom')); |
| return $url; |
| } |
| private function obtenirUrlMenu($menu, $referentiel = null) { |
| $this->url->setRequete(false); |
| $this->url->setVariableRequete('module', $menu); |
| if (isset($referentiel)) { |
| $this->url->setVariableRequete('ref', $referentiel); |
| } |
| $url = $this->url->getURL(); |
| $this->url->unsetVariablesRequete(array('module', 'ref')); |
| return $url; |
| } |
| protected function obtenirUrlFicheTraitement($referentiel, $id_traitement) { |
| $this->url->setRequete(false); |
| $this->url->setVariableRequete('module', 'Traitement'); |
| $this->url->setVariableRequete('id-t', $id_traitement); |
| $this->url->setVariableRequete('ref', $referentiel); |
| $url = $this->url->getURL(); |
| $this->url->unsetVariablesRequete(array('module', 'id-t', 'ref')); |
| return $url; |
| } |
| protected function obtenirUrlFicheResultat($referentiel, $id_resultat) { |
| $this->url->setRequete(false); |
| $this->url->setVariableRequete('module', 'Resultat'); |
| $this->url->setVariableRequete('id-r', $id_resultat); |
| $this->url->setVariableRequete('ref', $referentiel); |
| $url = $this->url->getURL(); |
| $this->url->unsetVariablesRequete(array('module', 'id-r', 'ref')); |
| return $url; |
| } |
| protected function obtenirUrlRecherche($referentiel = null, $txt = null) { |
| $this->url->setRequete(false); |
| if (!is_null($referentiel)) { |
| $this->url->setVariableRequete('ref', $referentiel); |
| } |
| $this->url->setVariableRequete('module', 'Recherche'); |
| $this->url->setVariableRequete('action', 'rechercher'); |
| if (!is_null($txt)) { |
| $this->url->setVariableRequete('recherche', $txt); |
| } |
| $url = $this->url->getURL(); |
| $this->url->unsetVariablesRequete(array('ref', 'module', 'action', 'recherche')); |
| return $url; |
| } |
| protected function obtenirUrlFicheTaxon($referentiel, $num_nom = null) { |
| $this->url->setRequete(false); |
| $this->url->setVariableRequete('ref', $referentiel); |
| $this->url->setVariableRequete('module', 'FicheTaxon'); |
| if (!is_null($num_nom)) { |
| $this->url->setVariableRequete('num_nom', $num_nom); |
| } |
| $url = clone $this->url; |
| $this->url->unsetVariablesRequete(array('module', 'id')); |
| return $url->getURL(); |
| } |
| /** |
| * Lance l'ajout d'un traitement |
| */ |
| protected function ajouterTraitement($referentiel_code, $script_nom) { |
| $this->ajouterTraitementParametre($referentiel_code, null, $script_nom); |
| } |
| /** |
| * Lance l'ajout d'un traitement |
| */ |
| protected function ajouterTraitementParametre($referentiel_code, $parametres_serialises, $script_nom) { |
| if (is_null($referentiel_code)) { |
| $this->addMessage("Aucun code de projet de référentiel n'est indiqué (Ex. bdtfx)."); |
| } else { |
| $traitements_a_supprimer = null; |
| $traitementDao = new TraitementDao(); |
| $resultat_traitement_en_attente = $traitementDao->getTraitementsEnAttente($referentiel_code, $script_nom); |
| if ($resultat_traitement_en_attente) { |
| foreach ($resultat_traitement_en_attente as $traitement) { |
| $difference = $this->differenceEnSecondeEntreDeuxDates($traitement['meta_date_creation'], date ("Y-m-d H:i:s")); |
| Debug::printr("Différence attente : $difference > ".Config::get('ddv_traitement_attente')); |
| if ($difference > Config::get('ddv_traitement_attente')) { |
| $traitements_a_supprimer[] = $traitement['id_traitement']; |
| $this->addMessage("Le traitement #{$traitement['id_traitement']} était en attente depuis plus de 5mn, il a été supprimé."); |
| } else { |
| $this->addMessage("Un traitement est déjà en attente..."); |
| } |
| } |
| } else { |
| $resultat_traitement_en_cours = $traitementDao->getTraitementsEnCours($referentiel_code, $script_nom); |
| if ($resultat_traitement_en_cours) { |
| foreach ($resultat_traitement_en_cours as $traitement) { |
| $difference = $this->differenceEnSecondeEntreDeuxDates($traitement['date_debut'], date ("Y-m-d H:i:s")); |
| Debug::printr("Différence en cours : $difference > ".Config::get('ddv_traitement_en_cours')); |
| if ($difference > Config::get('ddv_traitement_en_cours')) { |
| $traitements_a_supprimer[] = $traitement['id_traitement']; |
| $this->addMessage("Le traitement #{$traitement['id_traitement']} était en cours depuis plus de 5mn, il a été supprimé."); |
| } else { |
| $this->addMessage("Un traitement est déjà en cours..."); |
| } |
| } |
| } else { |
| $resultat = $traitementDao->ajouterTraitementParametre($referentiel_code, $parametres_serialises, $script_nom); |
| if ($resultat != false) { |
| $this->addMessage("Le traitement #'$resultat' a été ajouté."); |
| $this->lancerScript($referentiel_code, $script_nom); |
| } else { |
| $this->addMessage("Un problème est survenu lors de la tentative d'ajout du traitement."); |
| } |
| } |
| } |
| // Suppression des traitements posant problème |
| if (count($traitements_a_supprimer) > 0) { |
| $traitementDao->supprimer($traitements_a_supprimer); |
| } |
| } |
| } |
| private function differenceEnSecondeEntreDeuxDates($date_01, $date_02) { |
| if (floatval(phpversion()) >= 5.3 ) { |
| $d1 = new DateTime($date_01); |
| $d2 = new DateTime($date_02); |
| $difference_absolue = true; |
| $diff = $d1->diff($d2, $difference_absolue); |
| $nbre_secondes = $diff->format('s'); |
| } else { |
| $nbre_secondes = abs(round((strtotime($date_01) - strtotime($date_02)))); |
| } |
| return $nbre_secondes; |
| } |
| /** |
| * Lance le script d'execution des traitements |
| */ |
| protected function lancerScript($referentiel_code, $script_nom) { |
| $php = Config::get('chemin_bin_php'); |
| $exe = Config::get('chemin_script'); |
| $action = 'tout'; |
| $log = Config::get('chemin_script_log'); |
| $limite_memoire = Config::get('script_limite_memoire'); |
| $commande = "$php -d memory_limit=$limite_memoire -f $exe $script_nom -p $referentiel_code -a $action > $log &"; |
| if ($this->verifierSafeModeOff() === false) { |
| $e = "Le safe_mode est actif sur ce serveur."; |
| } else if ($this->verifierAccesFonctionExec() === false) { |
| $e = "La fonction 'exec()' fait partie des fonctions désactivées sur ce serveur (voir disable_functions)."; |
| } else { |
| $this->addMessage("Lancement du script effectuant les traitements."); |
| exec($commande); |
| } |
| // Affichage des message de paramêtrage du serveur si nécessaire |
| if (Config::get('script_messages') == true) { |
| $message_erreur_tpl = "%s\n.". |
| "Il est nécessaire de configurer le lancement du script via une tache dans le cron.\n". |
| "La commande à lancer est : <code>$commande</code>"; |
| $this->addMessage(sprintf($message_erreur_tpl, $e)); |
| } |
| } |
| private function verifierSafeModeOff() { |
| return ('1' == ini_get('safe_mode')) ? false : true; |
| } |
| private function verifierAccesFonctionExec() { |
| $disabled = explode(', ', ini_get('disable_functions')); |
| return !in_array('exec', $disabled); |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION DES FICHIERS A TELECHARGER |
| /** |
| * Crée la liste d'url des fichiers à télécharger pour un traitement donné |
| * @param Array $infos_traitement tableau contenant les informations du traitement |
| * |
| * @return Array un tableau contenant la liste des urls des fichiers à télécharger |
| */ |
| protected function obtenirUrlsZipPourTraitement($infos_traitement) { |
| $urls_zip = array(); |
| if (isset($infos_traitement['script']) && $infos_traitement['script'] == 'versionnage') { |
| $meta = unserialize($infos_traitement['script_parametres']); |
| $projet = strtolower($infos_traitement['referentiel_code']); |
| $version = str_replace('.', '_', $meta['version']); |
| $fichier_zip_bdnt = $projet.'_v'.$version.'.zip'; |
| $url_zip_bdnt = sprintf(Config::get('url_zip_tpl'), $fichier_zip_bdnt); |
| if ($this->testerUrl($url_zip_bdnt)) { |
| $urls_zip[$fichier_zip_bdnt] = $url_zip_bdnt; |
| } |
| } |
| return $urls_zip; |
| } |
| /** |
| * Teste une url donnée, en tentant de l'ouvrir et de la fermer |
| * |
| * @return boolean un booléen indiquant le succès ou non de l'opération |
| */ |
| protected function testerUrl($url) { |
| //TODO: voir si on peut inclure cette fonction dans le framework |
| ini_set('allow_url_fopen', '1'); |
| return (@fclose(@fopen($url, 'r'))) ? true : false; |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION DU CLIENT REST |
| protected function getRestClient() { |
| if (! isset($this->restClient)) { |
| $this->restClient = new RestClient(); |
| } |
| return $this->restClient; |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION DE L'IDENTIFICATION |
| protected function getAuthIdentifiant() { |
| $id = (isset($_SERVER['PHP_AUTH_USER'])) ? $_SERVER['PHP_AUTH_USER'] : null; |
| return $id; |
| } |
| protected function getAuthMotDePasse() { |
| $mdp = (isset($_SERVER['PHP_AUTH_PW'])) ? $_SERVER['PHP_AUTH_PW'] : null; |
| return $mdp; |
| } |
| public function authentifierCoordinateur() { |
| $message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica."; |
| $message_echec = "Accès limité aux coordinateurs du projet.\n". |
| "Votre tentative d'identification a échoué.\n". |
| "Actualiser la page pour essayer à nouveau si vous êtes bien inscrit comme coordinateur."; |
| return $this->authentifier($message_accueil, $message_echec); |
| } |
| private function authentifier($message_accueil, $message_echec) { |
| $id = $this->getAuthIdentifiant(); |
| if (!isset($id)) { |
| $this->envoyerAuth($message_accueil, $message_echec); |
| } else { |
| $autorisation = $this->etreCoordinateurAutorise(); |
| if ($autorisation == false) { |
| $this->envoyerAuth($message_accueil, $message_echec); |
| } |
| } |
| return true; |
| } |
| public function etreCoordinateurAutorise($identifiant) { |
| $identifiant = $this->getAuthIdentifiant(); |
| $mdp = md5($this->getAuthMotDePasse()); |
| $url = sprintf(Config::get('authentification.serviceUrlTpl'), $identifiant, $mdp); |
| $json = $this->getRestClient()->envoyerRequeteConsultation($url); |
| $existe = json_decode($json); |
| $admin = $this->etreCoordinateur($identifiant) ? true : false; |
| $autorisation = ($existe && $admin) ? true : false; |
| return $autorisation; |
| } |
| public function etreCoordinateur($courriel) { |
| $coordinateurs = Config::get('authentification.coordinateurs'); |
| $courriels_autorises = explode(',', $coordinateurs); |
| $autorisation = (in_array($courriel, $courriels_autorises)) ? true : false ; |
| return $autorisation; |
| } |
| private function envoyerAuth($message_accueil, $message_echec) { |
| header('HTTP/1.0 401 Unauthorized'); |
| header('WWW-Authenticate: Basic realm="'.mb_convert_encoding($message_accueil, 'ISO-8859-1', 'UTF-8').'"'); |
| header('Content-type: text/plain; charset=UTF-8'); |
| print $message_echec; |
| exit(0); |
| } |
| } |
| /branches/v2.0-betulales/interfaces/controleurs/Consultation.php |
|---|
| New file |
| 0,0 → 1,43 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur du module Consultation. |
| * Permet de consultation la version de travail d'un référentiel. |
| * |
| * @package Referentiel |
| * @category Php5.2 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 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$ |
| */ |
| class Consultation extends AppliControleur { |
| private $referentiel = null; |
| public function __construct() { |
| parent::__construct(); |
| // Récupération de paramêtres |
| if (isset($_GET['ref'])) { // code du projet courrant |
| $this->referentiel = strtolower($_GET['ref']); |
| } |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| $this->definirCommeModulePrincipal(get_class($this)); |
| $this->construireMenu($this->referentiel); |
| $this->construireFilAriane($this->referentiel); |
| $_GET['recherche'] = "#"; |
| $this->executerActionReferentiel('Recherche', 'rechercher', $this->referentiel, 20); |
| } |
| } |
| ?> |
| /branches/v2.0-betulales/interfaces/controleurs/Resultat.php |
|---|
| New file |
| 0,0 → 1,86 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur du module Resultat. |
| * Affichage des infos sur un résultat de traitement. |
| * |
| * @package Referentiel |
| * @category Php5.2 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 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$ |
| */ |
| class Resultat extends AppliControleur { |
| private $referentiel = null; |
| private $traitementId = null; |
| private $resultatId = null; |
| private $resultatDao = null; |
| public function __construct() { |
| parent::__construct(); |
| // Récupération de paramêtres |
| if (isset($_GET['id-r'])) { // id du resultat courant |
| $this->resultatId = strtolower($_GET['id-r']); |
| } |
| if (isset($_GET['ref'])) { // code du projet courrant |
| $this->referentiel = strtolower($_GET['ref']); |
| } |
| // Chargement des DAO nécessaires |
| if (isset($this->resultatId)) { |
| $this->resultatDao = new ResultatDao(); |
| } |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| return $this->afficherResultat(); |
| } |
| /** |
| * Affiche le formulaire de demande de traitement |
| */ |
| public function afficherResultat() { |
| $donnees = array(); |
| // Traitement de l'info sur le code du référentiel |
| if (isset($this->resultatId)) { |
| // Recherche d'info sur le résultat |
| $infos = $this->resultatDao->getInfos($this->resultatId); |
| if ($infos != false) { |
| $infos['message'] = $this->remplacerParametres($infos['message']); |
| $donnees['resultat'] = $infos; |
| $this->traitementId = $infos['ce_traitement']; |
| } else { |
| $this->addMessage("L'identifiant de résultat n'est pas indexé dans la base de données."); |
| } |
| } else { |
| $this->addMessage("Aucun identifiant de résultat n'a été indiqué."); |
| } |
| $donnees['messages'] = $this->getMessages(); |
| $this->traiterEsperluette($donnees); |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('resultat', $donnees), false); |
| $this->construireMenu($this->referentiel); |
| $this->construireFilAriane($this->referentiel, $this->traitementId, $this->resultatId); |
| } |
| /** |
| * Les tests génèrent des messages au format HTML qui peuvent contenir des paramètres à remplacer au moment de l'affichage. |
| * |
| * @param String $txt |
| */ |
| private function remplacerParametres($txt) { |
| return preg_replace('/{numNom::([0-9]+)}/', $this->obtenirUrlFicheTaxon($this->referentiel, "$1"), $txt); |
| } |
| } |
| ?> |
| /branches/v2.0-betulales/interfaces/controleurs/Referentiel.php |
|---|
| New file |
| 0,0 → 1,207 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Referentiel est le controlleur principal de l'application. |
| * Il repartit les demandes utilisateurs dans les différents modules, execute les actions et redistribue le code |
| * html dans les différentes fonctions d'affichage. |
| * C'est une Singleton. |
| * |
| * @package Referentiel |
| * @category Php5 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 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$ |
| */ |
| class Referentiel extends Controleur { |
| /** |
| * Instance de la classe pointant sur elle même (pour le pattern singleton) |
| */ |
| private static $instance = null; |
| /** |
| * Paramètres pour les collections |
| */ |
| private static $parametres = array(); |
| /** |
| * Constructeur vide |
| */ |
| public function __construct() { |
| $meta = array('titre' => '', 'description' => '', 'tags' => ''); |
| $sortie = array('metadonnees' => $meta, 'corps' => '', 'tete' => '', 'pied' => '', 'navigation' => '', 'menu' => ''); |
| $url = new Url(Config::get('url_base_index')); |
| self::$parametres = array( 'module' => 'Accueil', |
| 'action' => 'executerActionParDefaut', |
| 'sortie' => $sortie, |
| 'url' => $url); |
| parent::__construct(); |
| } |
| /** |
| * Initialisation du controleur principal en fonction des paramêtres de l'url. |
| */ |
| public static function initialiser() { |
| self::verifierCreationInstance(); |
| self::gererSession(); |
| restore_error_handler(); |
| restore_exception_handler(); |
| ini_set("display_errors", "1"); |
| error_reporting(E_ALL); |
| if (isset($_GET['module'])) { |
| self::$parametres['module'] = $_GET['module']; |
| } |
| self::$parametres['url']->setVariableRequete('module', self::$parametres['module']); |
| if (isset($_GET['action'])) { |
| self::$parametres['action'] = $_GET['action']; |
| } |
| self::$parametres['url']->setVariableRequete('action', self::$parametres['action']); |
| $registre = Registre::getInstance(); |
| $registre->set('parametres', self::$parametres); |
| $ClasseModule = self::$parametres['module']; |
| $action = self::$parametres['action']; |
| $module = new $ClasseModule(); |
| $module->$action(); |
| self::fusionnerSortie($module->getSortie()); |
| } |
| private static function gererSession() { |
| if (Config::get('session_demarrage')) { |
| // Attribution d'un nom à la session |
| session_name(Config::get('session_nom')); |
| // Démarrage de la session |
| session_start(); |
| } |
| } |
| /** |
| * Fusionne un tableau de sortie par défaut avec le tableau renvoyé par l'action du module. |
| * @param array le tableau à fusionner |
| */ |
| private static function fusionnerSortie($sortie) { |
| self::$parametres['sortie'] = array_merge(self::$parametres['sortie'], $sortie); |
| } |
| /** |
| * Vérifie si l'instance de classe à été crée, si non la crée. |
| */ |
| private static function verifierCreationInstance() { |
| if (empty(self::$instance)) { |
| self::$instance = new Referentiel(); |
| } |
| } |
| /** |
| * Retourne le module courrant. |
| */ |
| public static function getModule() { |
| return self::$parametres['module']; |
| } |
| /** |
| * Retourne le titre du contenu de l'application. |
| */ |
| public static function getMetaTitre() { |
| return self::$parametres['sortie']['metadonnees']['titre']; |
| } |
| /** |
| * Retourne la description du contenu de l'application. |
| */ |
| public static function getMetaDescription() { |
| return self::$parametres['sortie']['metadonnees']['description']; |
| } |
| /** |
| * Retourne les mots-clés (tags) du contenu de l'application. |
| */ |
| public static function getMetaTags() { |
| return self::$parametres['sortie']['metadonnees']['tags']; |
| } |
| /** |
| * Retourne le contenu du corps de l'application. |
| */ |
| public static function getContenuCorps() { |
| $sortie = self::$parametres['sortie']['corps']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne le contenu de la tête de l'application. |
| */ |
| public static function getContenuTete() { |
| $sortie = self::$parametres['sortie']['tete']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne le contenu du pied de l'application. |
| */ |
| public static function getContenuPied() { |
| $sortie = self::$parametres['sortie']['pied']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne les éléments de navigation de l'application. |
| */ |
| public static function getContenuNavigation() { |
| $sortie = self::$parametres['sortie']['navigation']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne le menu de l'application. |
| */ |
| public static function getContenuMenu() { |
| $sortie = self::$parametres['sortie']['menu']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne les chronos pris dans l'appli |
| */ |
| public static function getChrono() { |
| $sortie = ''; |
| if (Config::get('chronometrage')) { |
| $chrono = Chronometre::afficherChrono(); |
| $sortie = mb_convert_encoding($chrono, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne les messages d'exceptions et d'erreurs. |
| */ |
| public static function getExceptions() { |
| $sortie = (Config::get('fw_debogage')) ? GestionnaireException::getExceptions() : ''; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| } |
| ?> |
| /branches/v2.0-betulales/interfaces/controleurs/Accueil.php |
|---|
| New file |
| 0,0 → 1,71 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur du module Accueil. |
| * Affichage les infos sur l'ensemble des référentiels disponibles. |
| * |
| * @package Referentiel |
| * @category Php5.2 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 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$ |
| */ |
| class Accueil extends AppliControleur { |
| private $referentiel = null; |
| private $referentielDao = null; |
| public function __construct() { |
| parent::__construct(); |
| // Récupération de paramêtres |
| if (isset($_GET['ref'])) { // code du projet courrant |
| $this->referentiel = strtolower(strip_tags($_GET['ref'])); |
| } |
| // Chargement des DAO nécessaires |
| $this->referentielDao = new ReferentielDao(); |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| return $this->afficherAccueil(); |
| } |
| /** |
| * Affiche la liste des référentiels |
| */ |
| public function afficherAccueil() { |
| $donnees = array(); |
| $this->initialiserModulePrincipal(); |
| $infos = $this->referentielDao->getReferentielsDispo(); |
| if ($infos != false) { |
| $referentiel = array(); |
| foreach ($infos as $info) { |
| $referentiel['nom'] = $info; |
| $referentiel['titre'] = $this->referentielDao->getNom($info); |
| $referentiel['url'] = $this->obtenirUrlMenuConsultation($info); |
| $referentiel['date'] = $this->referentielDao->getDateMiseAJour($info); |
| $donnees['referentiels'][] = $referentiel; |
| } |
| } else { |
| $this->addMessage("Aucun référentiel n'est disponible."); |
| } |
| $donnees['messages'] = $this->getMessages(); |
| $this->traiterEsperluette($donnees); |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('accueil', $donnees), false); |
| $this->construireFilAriane(); |
| } |
| } |
| ?> |
| /branches/v2.0-betulales/interfaces/controleurs/FicheTaxon.php |
|---|
| New file |
| 0,0 → 1,256 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur du module Fiche Taxon. |
| * |
| * @category Php 5.2 |
| * @package Taxon |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 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: Fiche.php 96 2010-06-21 16:46:31Z jpm $ |
| */ |
| class FicheTaxon extends AppliControleur { |
| private $donnees = array(); |
| protected $taxonDao = null; |
| private $tableau_manuel = null; |
| private $num_taxon = array(0=>0,1=>0,2=>0); |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| return $this->afficherTaxon(); |
| } |
| // +---------------------------------------------------------------------------------------------------------------+ |
| // FICHE CONSULTATION TAXON |
| public function afficherTaxon() { |
| // Récupération du référentiel |
| if (isset($_GET['ref'])) { |
| $this->referentiel = strtolower($_GET['ref']); |
| } |
| // Gestion des actions par défaut |
| $this->taxonDao = new TaxonDao(); |
| $this->definirCommeModulePrincipal(get_class($this)); |
| $this->construireMenu($this->referentiel); |
| $this->construireFilAriane($this->referentiel); |
| $this->executerActionReferentiel('Recherche', 'chargerMoteurRecherche', $this->referentiel, 10); |
| // Gestion des données de la requête |
| if (!isset($_GET['num_nom'])) { |
| } else { |
| // Récupération des données |
| $this->donnees['referentiel'] = $this->referentiel; |
| $this->donnees['num_nom'] = $_GET['num_nom']; |
| $this->donnees['info'] = $this->taxonDao->getTaxon($this->referentiel, $this->donnees['num_nom']); |
| $this->donnees['num_nom_retenu'] = $this->donnees['info']['num_nom_retenu']; |
| $this->donnees['nom'] = $this->donnees['info']['nom_sci']; |
| $this->donnees['exclu_taxref'] = $this->donnees['info']['exclure_taxref']; |
| if ($this->donnees['info'] != '') { |
| // Chargement des données des onglets |
| $this->chargerNomenclature(); |
| $this->chargerSynonymie(); |
| $this->chargerClassification(); |
| $this->chargerChorologie(); |
| $this->chargerComplements(); |
| } |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('fiche_taxon', $this->donnees)); |
| } |
| } |
| private function chargerNomenclature() { |
| $this->donnees['selectionne'] = $this->taxonDao->getNomenclature($this->referentiel, $this->donnees['num_nom']); |
| if ($this->donnees['num_nom'] != $this->donnees['num_nom_retenu'] && $this->donnees['num_nom_retenu'] != '') { |
| $this->donnees['retenu'] = $this->taxonDao->getNomenclature($this->referentiel, $this->donnees['num_nom_retenu']); |
| } |
| if ($this->donnees['info']['hybride_parent_01'] != '' && $this->donnees['info']['hybride_parent_02'] != '') { |
| $this->donnees['parents'] = $this->taxonDao->getParentsHybride($this->referentiel, $this->donnees['num_nom']); |
| } elseif ($this->donnees['info']['hybride_parent_01'] != '' || $this->donnees['info']['hybride_parent_02'] != ''){ |
| $this->donnees['parents'] = $this->taxonDao->getParentsHybride($this->referentiel, $this->donnees['num_nom']); |
| } |
| } |
| // recherche les synonymes (à compléter) |
| private function chargerSynonymie() { |
| $rechercheDao = new RechercheDao(); |
| // recherche des synonymes nomenclaturaux et taxonomiques |
| $parametres = $this->parserChaineDeRecherche('nn:'.$this->donnees['num_nom'].' tax:1'); |
| $parametres['ref']= $this->referentiel; |
| $synonymes = $rechercheDao->chercher('ParTaxon', $parametres); |
| if ($synonymes != '') { |
| $this->donnees['syn'] = $synonymes; |
| } |
| // synonyme proparte |
| if ($this->donnees['info']['synonyme_proparte'] != ''){ |
| $propartes = explode(',', $this->donnees['info']['synonyme_proparte']); |
| foreach ($propartes as $proparte) { |
| $this->donnees['pp'][] = $this->taxonDao->getTaxonAffichage($this->referentiel, trim($proparte)); |
| } |
| } |
| // homonymie |
| $nom = $this->encodeChaine($this->donnees['info']['nom_sci']); |
| $homonymes = $this->taxonDao->getHomonyme($this->referentiel, $nom); |
| if (count($homonymes) > 1) { |
| foreach ($homonymes as $id => &$homonyme) { |
| $homonyme['statut'] = $homonyme['homonyme']; |
| } |
| $this->donnees['h'] = $homonymes; |
| } |
| } |
| private function chargerChorologie() { |
| $this->chargerTableauManuel('presence'); |
| $this->chargerTableauManuel('statuts_origine'); |
| $this->chargerTableauManuel('statuts_introduction'); |
| $this->chargerTableauManuel('statuts_culture'); |
| foreach ($this->donnees['info'] as $param => $valeur) { |
| if ($param == 'presence') { |
| $this->donnees['chorologie']['Présence']['France']['code'] = $valeur; |
| $this->donnees['chorologie']['Présence']['France']['valeur'] = $this->tableau_manuel['presence'][$valeur]; |
| } elseif (preg_match('/presence_(.*)/', $param, $lieu)) { |
| $this->donnees['chorologie']['Présence'][$lieu['1']]['code'] = $valeur; |
| $this->donnees['chorologie']['Présence'][$lieu['1']]['valeur'] = $this->tableau_manuel['presence'][$valeur]; |
| } elseif ($param == 'statut_origine') { |
| $this->donnees['chorologie']['Statut d\'origine']['France']['code'] = $valeur; |
| $this->donnees['chorologie']['Statut d\'origine']['France']['valeur'] = |
| $this->tableau_manuel['statuts_origine'][$valeur]; |
| } elseif (preg_match('/statut_origine_(.*)/', $param, $lieu)) { |
| $this->donnees['chorologie']['Statut d\'origine'][$lieu['1']]['code'] = $valeur; |
| $this->donnees['chorologie']['Statut d\'origine'][$lieu['1']]['valeur'] = |
| $this->tableau_manuel['statuts_origine'][$valeur]; |
| } elseif ($param == 'statut_introduction') { |
| $this->donnees['chorologie']['Statut d\'introduction']['France']['code'] = $valeur; |
| $this->donnees['chorologie']['Statut d\'introduction']['France']['valeur'] = |
| $this->tableau_manuel['statuts_introduction'][$valeur]; |
| } elseif (preg_match('/statut_introduction_(.*)/', $param, $lieu)) { |
| $this->donnees['chorologie']['Statut d\'introduction'][$lieu['1']]['code'] = $valeur; |
| $this->donnees['chorologie']['Statut d\'introduction'][$lieu['1']]['valeur'] = |
| $this->tableau_manuel['statuts_introduction'][$valeur]; |
| } elseif ($param == 'statut_culture') { |
| $this->donnees['chorologie']['Statut de culture']['France']['code'] = $valeur; |
| $this->donnees['chorologie']['Statut de culture']['France']['valeur'] = |
| $this->tableau_manuel['statuts_culture'][$valeur]; |
| } elseif (preg_match('/statut_culture_(.*)/', $param, $lieu)) { |
| $this->donnees['chorologie']['Statut de culture'][$lieu['1']]['code'] = $valeur; |
| $this->donnees['chorologie']['Statut de culture'][$lieu['1']]['valeur'] = |
| $this->tableau_manuel['statuts_culture'][$valeur]; |
| } |
| } |
| foreach ($this->donnees['chorologie']['Présence'] as $lieu => $valeur) { |
| if (!isset($this->donnees['chorologie']['Statut d\'origine'][$lieu])) { |
| $this->donnees['chorologie']['Statut d\'origine'][$lieu]['code'] = ''; |
| } |
| if (!isset($this->donnees['chorologie']['Statut d\'introduction'][$lieu])) { |
| $this->donnees['chorologie']['Statut d\'introduction'][$lieu]['code'] = ''; |
| } |
| if (!isset($this->donnees['chorologie']['Statut de culture'][$lieu])) { |
| $this->donnees['chorologie']['Statut de culture'][$lieu]['code'] = ''; |
| } |
| } |
| } |
| private function chargerClassification() { |
| $this->chargerTableauManuel('signification_rang'); |
| $this->chargerTableauManuel('presence'); |
| $this->donnees['valeur_rang'] = $this->tableau_manuel['signification_rang']; |
| $this->donnees['valeur_presence'] = $this->tableau_manuel['presence']; |
| if ($this->donnees['info']['num_tax_sup'] != '' && $this->donnees['info']['num_tax_sup'] !== "0") { |
| $this->donnees['classification']['supérieurs'] = array_reverse($this->taxonDao->getClassification |
| ('Superieur', $this->referentiel, $this->donnees['info']['num_tax_sup'])); |
| } elseif (isset($this->donnees['retenu']['num_tax_sup']) && ($this->donnees['retenu']['num_tax_sup'] != '')) { |
| $this->donnees['classification']['supérieurs'] = array_reverse($this->taxonDao->getClassification |
| ('Superieur', $this->referentiel, $this->donnees['retenu']['num_tax_sup'])); |
| } |
| if ($this->donnees['num_nom_retenu'] != '') { |
| $class_inf = $this->taxonDao->getClassification |
| ('Inferieur', $this->referentiel, $this->donnees['num_nom_retenu']); |
| if ($class_inf != '') { |
| $this->donnees['classification']['inférieurs'] = $class_inf['inf']; |
| $this->donnees['niveau'] = $class_inf['niveau']; |
| arsort($class_inf['nb_par_rang']); |
| $this->donnees['noms_rang'] = $class_inf['nb_par_rang']; |
| } |
| } |
| } |
| private function chargerComplements() { |
| $champs_manuel_technique = explode(',', $this->manuel['champs']); |
| $champs_base_donnees = key($this->donnees['info']); |
| $champs_supp_base = array_diff_key($this->donnees['info'], array_flip($champs_manuel_technique)); |
| foreach ($champs_supp_base as $champ=>$valeur) { |
| if (!(preg_match('/presence_(.*)/',$champ) || preg_match('/statut_origine_(.*)/', $champ) || |
| preg_match('/statut_introduction_(.*)/', $champ) || preg_match('/statut_culture_(.*)/', $champ))) { |
| $this->donnees['complement'][$champ] = $valeur; |
| } |
| } |
| } |
| private function parserChaineDeRecherche($chaine) { |
| $mots = preg_split('/ /i', $chaine, -1, PREG_SPLIT_NO_EMPTY); |
| $parametres = array('mots' => ''); |
| $cle_precedente = null; |
| foreach ($mots as $mot) { |
| if (preg_match('/^(sg|gen|sp|ssp|au|an|nn|bib|nr|tax):(.*)$/', $mot, $match)) { |
| $cle = $match[1]; |
| $cle_precedente = $cle; |
| $valeur = $match[2]; |
| $parametres[$cle] = $valeur; |
| } else if (!is_null($cle_precedente)) { |
| $parametres[$cle_precedente] .= ' '.$mot; |
| } else if (is_null($cle_precedente)) { |
| if (empty($parametres['mots'])) { |
| $parametres['mots'] = $mot; |
| } else { |
| $parametres['mots'] .= ' '.$mot; |
| } |
| } |
| } |
| return $parametres; |
| } |
| public function encodeChaine($chaine) { |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $chaine = mb_convert_encoding($chaine, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| $chaine = urlencode($chaine); |
| return $chaine; |
| } |
| // retourne l'url de la fiche taxon pour les liens |
| public static function getUrlFicheTaxon($params, $type = '') { |
| $taxon = null; |
| switch ($type) { |
| case 'bas' : |
| $taxon['num_nom'] = $params['bas_num']; |
| break; |
| case 'p1' : |
| $taxon['num_nom'] = $params['p1_num']; |
| break; |
| case 'p2' : |
| $taxon['num_nom'] = $params['p2_num']; |
| break; |
| default : $taxon['num_nom'] = $params; |
| break; |
| } |
| return Recherche::getUrlFicheTaxon($taxon); |
| } |
| // charger tableau de $this->manuel |
| private function chargerTableauManuel($titreTableau) { |
| $champs = explode(',', $this->manuel[$titreTableau]); |
| foreach ($champs as $champ) { |
| list($champ_nom, $type) = explode('=', trim($champ)); |
| $this->tableau_manuel[$titreTableau][$champ_nom] = $type; |
| } |
| } |
| } |
| /branches/v2.0-betulales/interfaces/controleurs/Informations.php |
|---|
| New file |
| 0,0 → 1,231 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur du module Accueil. |
| * Affichage les infos sur l'ensemble des référentiels disponibles. |
| * |
| * @package Referentiel |
| * @category Php5.2 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 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$ |
| */ |
| class Informations extends AppliControleur { |
| private $referentiel = null; |
| private $referentielDao = null; |
| private $traitementDao = null; |
| private $resultatDao = null; |
| private $metaDao = null; |
| private $colonnesOrdonnees = array(); |
| public function __construct() { |
| parent::__construct(); |
| // Récupération de paramêtres |
| if (isset($_GET['ref'])) { // code du projet courrant |
| $this->referentiel = strtolower(strip_tags($_GET['ref'])); |
| } |
| // Chargement des DAO nécessaires |
| $this->resultatDao = new ResultatDao(); |
| $this->traitementDao = new TraitementDao(); |
| $this->referentielDao = new ReferentielDao(); |
| $this->metaDao = new MetaDao(); |
| // tableau colonnesOrdonnees à modifier aussi dans service/Recherche.php |
| $this->colonnesOrdonnees = array("nn" => array("Numéro nomenclatural","checked","Identifiant numérique du nom scientifique"), |
| "nr" => array("Numéro nomenclatural du nom retenu","checked","Identifiant numérique du nom scientifique (num_nom) retenu pour désigner le taxon"), |
| "nt" => array("Numéro taxonomique","checked","Identifiant numérique du taxon auquel est rattaché le nom"), |
| "cd" => array("Numéro INPN","checked","Identifiant numérique unique du nom scientifique attribué par l’INPN"), |
| "rg" => array("Code rang","checked","Code numérique indiquant le rang du nom scientifique (voir tableau 7 du manuel technique)"), |
| "fam" => array("Famille (APG III)","checked","Nom de la famille dans APG III"), |
| "nsc" => array("Nom avec auteur","checked","Nom scientifique avec auteur(s)"), |
| "bibc" => array("Année et bibliographie","checked","Format à étudier celui de Tela : 1868, Brev. Pl. Nov., 2 : 70 ou celui de Kew : Brev. Pl. Nov., 2 : 70 (1868)"), |
| "nsrc" => array("Nom retenu avec auteur","checked","Nom retenu pour tous les taxons (identique si le nom est édjà le nom retenu)"), |
| "nf" => array("Nom français normalisé","checked","Nom français conseillé pour ce taxon (à venir)"), |
| "extax" => array("Présent dans Taxref","checked",""), |
| "lien" => array("Permalien","checked","Lien http vers la fiche nomenclaturale"), |
| "ntsup" => array("Numéro nomenclatural rang supérieur","","Identifiant numérique du nom (num_nom) de rang supérieur dans la classification par défaut de l'index"), |
| "pre" => array("Répartition géographique","","Code indiquant si le taxon est présent dans la zone géographique définie par le référentiel (tableau 9)"), |
| "ns" => array("Nom sans auteur","","Nom scientifique sans auteur"), |
| "aut" => array("Auteur","","Intitulé de(s) l'auteur(s) du nom (abréviations standards de Brummitt et Powell)"), |
| "ann" => array("Année publication","","Année de la publication effective du support papier"), |
| "bib" => array("Bibliographie","","Référence bibliographique de la publication d'origine du nom"), |
| "ntype" => array("Numéro du type","","Identifiant numérique (num_nom) du 1er basionyme appliqué à la planche d'herbier"), |
| "nbas" => array("Numéro du basionyme","","Identifiant numérique (num_nom) du basionyme du nom"), |
| "genre" => array("Genre","","Nom d'un genre dans le cas d'un monôme du rang genre ou d'une combinaison"), |
| "esp" => array("Epithète espèce","","Épithète de l'espèce"), |
| "eing" => array("Epithète infragénérique","","Épithète infra-générique d'une combinaison dont le rang est situé entre le genre et l'espèce"), |
| "te" => array("Type d'épithète infraspécifique","","Abréviation indiquant le type de l'épithète infra-spécifique"), |
| "einsp" => array("Epithète infraspécifique","","Épithète infra-spécifique d'une combinaison"), |
| "hybp01" => array("Hybride parent 1","","Identifiant du nom (num_nom) du parent numéro 1 (dans le cas d'un hybride)"), |
| "nomsupgen" => array("Nom supra générique","","Monôme dont le rang est supérieur au genre"), |
| "hybp02" => array("Hybride parent 2","","Identifiant du nom (num_nom) du parent numéro 2 (dans le cas d'un hybride)"), |
| "stori" => array("Statut d'origine","","Code indiquant le statut d'origine du taxon dans la zone géographique définie par le référentiel (tableau 10)"), |
| "stint" => array("Statut d'introduction","","Code indiquant le statut d'introduction du taxon dans la zone géographique définie par le référentiel (tableau 11)"), |
| "stcult" => array("Statut de culture","","Code indiquant le statut de culture du taxon dans la zone géographique définie par le référentiel (tableau 12)"), |
| "notes" => array("Remarques","","Notes complémentaires"), |
| "nomadd" => array("Commentaires nomenclaturaux","","Commentaires nomenclaturaux pouvant être associés à un nom (voir tableau 8 du manuel technique)"), |
| "nsr" => array("Nom retenu sans auteur","","Nom scientifique du nom retenu sans auteur"), |
| "hom" => array("Homonymie","","Contient la valeur 1 si le nom possède un homonyme ou si le nom est un homonyme. Dans le cas contraire"), |
| "synprop" => array("Synonyme proprate","","Contient plusieurs identifiants numériques (num_nom) dans le cas d'un nom obtenu suite à la division d'un taxon. Contient un seul identifiant numérique (num_nom) dans le cas d'un nom obtenu suite à la fusion de plusieurs taxons."), |
| "syndout" => array("Synonyme douteux","","Contient la valeur 1 si le nom est un synonyme douteux. Dans le cas contraire"), |
| "synmapp" => array("Synonyme mal appliqué","","Contient la valeur 1 si le nom est un synonyme mal appliqué (cas des sensu). Dans le cas contraire"), |
| "synorth" => array("Synonyme orthographique","","Contient l'identifiant numérique du nom (num_nom) correctement orthographié"), |
| "orthori" => array("Orthographe originelle","","Contient la graphie originelle d'un nom non-conforme faisant l'objet d'une correction orthographique obligatoire"), |
| "hybp01n" => array("Hybride parent 1 notes","","Notes éventuelles sur l'hybridité et le parent numéro 1"), |
| "hybp02n" => array("Hybride parent 2 notes","","Notes éventuelles sur l'hybridité et le parent numéro 2"), |
| "cultgp" => array("Groupe de cultivar","","Nom d'un groupe de cultivar (sansl'abréviation « Gp »)"), |
| "cult" => array("Nom cultivar","","Nom d'un cultivar (sans les guillemets simple ou abréviation « cv. »)"), |
| "nomcomm" => array("Nom commercial","","Nom commercial d'une plante (en majuscule"), |
| "autres" => array("Autres","","colonnes spécifiques au référentiel")); |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| return $this->afficherDetail(); |
| } |
| /** |
| * Affiche le détail d'un référentiel et la liste des actions possibles |
| */ |
| public function afficherDetail() { |
| $this->definirCommeModulePrincipal('Informations'); |
| $donnees = $this->preparerPagePourDetailReferentielEtTelechargement(); |
| $donnees['messages'] = $this->getMessages(); |
| $this->traiterEsperluette($donnees); |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('detail_referentiel', $donnees), false); |
| } |
| public function telecharger() { |
| $dossier = Config::get('chemin_tmp'); |
| $parametres['ref'] = $this->referentiel; |
| $parametres['version'] = $_POST["version"]; |
| $parametres['version'] = str_replace(".", "_", $parametres['version']); |
| if (isset($_POST["champs"])) $parametres['champs'] = implode(",",$_POST["champs"]); |
| if (isset($_POST["filtres"])) $parametres['filtres'] = implode(",",$_POST["filtres"]); |
| $this->supprimerAncienExport($dossier); |
| $ref = $this->referentielDao->exporter($parametres); |
| $meta = $this->metaDao->exporter($parametres); |
| $dossierDateEtNomDeFichier = date('Y_m_d').'/'.$this->referentiel.time().'.zip'; |
| $cheminZip = $dossier.$dossierDateEtNomDeFichier; |
| $zip = new ZipArchive(); |
| if($zip->open($cheminZip, ZipArchive::CREATE) === true) { |
| // Ajout des fichiers métadonnées, référentiel et manuel technique |
| $meta = str_replace("\\/", "/", $meta); |
| if (file_exists($meta)) { |
| $metazip = $zip->addFile($meta, "informations.csv"); |
| } |
| if (file_exists($ref)) { |
| $refzip = $zip->addFile($ref, "referentiel.csv"); |
| } |
| if (file_exists($dossier.'mtpr_V4_4.pdf')) { |
| $zip->addFile($dossier.'mtpr_V4_4.pdf', 'manuel_technique.pdf'); |
| } |
| // Et on referme l'archive |
| $zip->close(); |
| } else { |
| echo "Erreur : impossible d'ouvrir le fichier [$cheminZip]<br/>"; |
| } |
| // on revient à la page de détail, avec un lien de téléchargement en prime |
| $donnees = $this->preparerPagePourDetailReferentielEtTelechargement(); |
| if (file_exists($cheminZip)) { |
| $urlLien = Config::get("base_url_telechargements") . $dossierDateEtNomDeFichier; |
| $donnees['url_telechargement_zip'] = $urlLien; |
| } |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('detail_referentiel', $donnees), false); |
| } |
| // exécute la partie commune entre l'action "detail" et l'action "telecharger" |
| protected function preparerPagePourDetailReferentielEtTelechargement() { |
| $donnees = array(); |
| // Traitement de l'info sur le code du référentiel |
| if (isset($this->referentiel)) { |
| $this->construireMenu($this->referentiel); |
| $this->construireFilAriane($this->referentiel); |
| $donnees['referentiel'] = $this->referentiel; |
| $donnees['nom_referentiel'] = $this->referentielDao->getNom($this->referentiel); |
| $donnees['url_menu_test'] = $this->obtenirUrlMenuTest($this->referentiel); |
| $donnees['url_menu_versionnage'] = $this->obtenirUrlMenuVersionnage($this->referentiel); |
| $donnees['url_menu_consultation'] = $this->obtenirUrlMenuConsultation($this->referentiel); |
| $donnees['url_form_telech'] = $this->obtenirUrlDetailReferentielTelechargement($this->referentiel); |
| // suppression du téléchargement pour bdbfx |
| if ($this->referentiel != 'bdbfx') { |
| $donnees['versions'] = $this->afficherFormulaireTelechargementsReferentiels(); |
| $donnees['infos_telechargements'] = $this->afficherTelechargementsReferentiels(); |
| $donnees['colonnesOrdonnees'] = $this->colonnesOrdonnees; |
| } |
| } else { |
| $this->addMessage("Aucun code de projet de référentiel n'est indiqué (Ex. bdtfx)."); |
| } |
| return $donnees; |
| } |
| private function supprimerAncienExport($dossier) { |
| $pointeur = opendir($dossier); |
| // si pas d'erreur d'ouverture du dossier on lance le scan |
| if( $pointeur != false ) { |
| // Parcours du repertoire |
| while( $ss_dossier = readdir($pointeur)) { |
| if($ss_dossier != "." && $ss_dossier != "..") { |
| $chemin_complet = $dossier . $ss_dossier; |
| if (is_dir($chemin_complet) && $ss_dossier < date('Y_m_d')) { |
| $fichiers = scandir($chemin_complet); |
| foreach ($fichiers as $fichier) { |
| if($fichier != "." && $fichier != "..") { |
| unlink($chemin_complet."/".$fichier); |
| } |
| } |
| rmdir($chemin_complet); |
| } |
| } |
| } |
| closedir($pointeur); |
| } |
| } |
| private function afficherFormulaireTelechargementsReferentiels() { |
| $versions = $this->traitementDao->getTraitementsTermines($this->referentiel, 'versionnage'); |
| if ($versions != null) { |
| foreach ($versions as $id => $version) { |
| $versions[$id] = (unserialize($versions[$id]["script_parametres"])); |
| } |
| } |
| return $versions; |
| } |
| private function afficherTelechargementsReferentiels() { |
| $infos_telechargements = array(); |
| // Recherche des traitements déjà effectué |
| $resultat = $this->traitementDao->getTraitementsTermines($this->referentiel, 'versionnage'); |
| if (is_array($resultat)) { |
| foreach ($resultat as &$traitement) { |
| $infos_traitement = $this->traitementDao->getInfos($traitement['id_traitement']); |
| if ($infos_traitement != false) { |
| // Recherche des fichiers disponibles |
| $infos_zip = $this->obtenirUrlsZipPourTraitement($infos_traitement); |
| $infos_telechargements[] = array( |
| 'infos_traitement' => $traitement, |
| 'description' => $this->creerDescriptionTelechargement($traitement), |
| 'urls_zip' => $infos_zip); |
| } |
| } |
| } |
| return $infos_telechargements; |
| } |
| private function creerDescriptionTelechargement($traitement) { |
| return strftime('%e %B %Y', strtotime($traitement['meta_date_creation'])).' ('.$this->referentielDao->getNom($this->referentiel).') '; |
| } |
| } |
| ?> |
| /branches/v2.0-betulales/interfaces/controleurs/Recherche.php |
|---|
| New file |
| 0,0 → 1,232 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * classe Controleur du module Recherche. |
| * |
| * @package Referentiel |
| * @category Php5 |
| * @author Delphine CAUQUIL <delphine@tela-botanica.org> |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 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: Recherche.php 147 2010-09-06 09:37:22Z jpm $ |
| */ |
| class Recherche extends AppliControleur { |
| private $chaine_recherche = null; |
| private static $url_recherche = null; |
| private static $url_fiche_taxon = null; |
| private $referentiel = null; |
| private $donnees_par_page; |
| private $donnees_par_page_choix; |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| return $this->rechercher(); |
| } |
| /** |
| * Charge le moteur de recherche et l'envoie à la vue. |
| */ |
| public function chargerMoteurRecherche($ref = null, $affiche_rech_avancee = null) { |
| $donnees = array(); |
| $this->referentiel = $ref; |
| // Gestion des données de la requête |
| $donnees['recherche'] = htmlspecialchars($this->obtenirChaineRecherche()); |
| // Gestion des urls |
| $donnees['url_form'] = $this->obtenirUrlRecherche($this->referentiel); |
| $donnees['url_referentiel'] = $this->referentiel; |
| $referentielDao = new ReferentielDao(); |
| $donnees['nom_referentiel'] = strtolower($referentielDao->getNom($this->referentiel)); |
| $donnees['code_referentiel'] = strtoupper($this->referentiel); |
| $donnees['date_miseajour'] = $referentielDao->getDateMiseAJour($this->referentiel); |
| $donnees['forum_referentiel'] = Config::get('forum.'.$this->referentiel); |
| $donnees['site_referentiel'] = Config::get('site.'.$this->referentiel); |
| $donnees['url_module'] = 'Recherche'; |
| $donnees['url_action'] = 'rechercher'; |
| $donnees['affiche_moteur'] = $affiche_rech_avancee; |
| self::$url_recherche = $this->obtenirUrlRecherche('%s','%s'); |
| self::$url_fiche_taxon = $this->obtenirUrlFicheTaxon($this->referentiel, '%s'); |
| // Gestion du squelette et de la sortie |
| $this->setSortie(self::RENDU_TETE, $this->getVue('moteur', $donnees)); |
| } |
| private function obtenirChaineRecherche() { |
| $chaine = ''; |
| if (!is_null($this->chaine_recherche)) { |
| $chaine = $this->chaine_recherche; |
| } else if (isset($_GET['recherche'])) { |
| // Pré-traitement de la chaine de recherche |
| $chaine = $_GET['recherche']; |
| // Suppression des slash ajouté automatiquement par PHP devant les guillemets |
| $chaine = stripslashes($chaine); |
| // Mémorisation de la chaine |
| $this->memoriserChaineRecherche($chaine); |
| // Stockage dans la classe pour éviter d'effectuer à nouveau le traitement ci-dessus |
| $this->chaine_recherche = $chaine; |
| } else if (isset($_SESSION['ref']['recherche'])) { |
| $chaine = $_SESSION['ref']['recherche']; |
| } |
| return $chaine; |
| } |
| private function memoriserChaineRecherche($chaine) { |
| $_SESSION['ref']['recherche'] = $chaine; |
| } |
| // url pour les exemples du moteur de recherche |
| public static function getUrlRecherche($chaine, $referentiel = null) { |
| $url = ''; |
| if ($referentiel == null) $referentiel = $this->referentiel; |
| if (!is_null(self::$url_recherche)) { |
| // L'utilisation d'urlencode nécessiate de pré-encodé la chaine dans le format de sortie si nécessaire |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $chaine = mb_convert_encoding($chaine, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| $chaine = urlencode($chaine); |
| $url = sprintf(self::$url_recherche, $referentiel, $chaine); |
| } |
| return $url; |
| } |
| public static function getUrlFicheTaxon($taxon) { |
| $url = ''; |
| if (!is_null(self::$url_fiche_taxon)) { |
| $url = sprintf(self::$url_fiche_taxon, $taxon['num_nom']); |
| } |
| return $url; |
| } |
| /** |
| * Recherche sur référentiel. |
| * @return string la vue correspondante |
| */ |
| public function rechercher() { |
| // Paramétres de pagination par défault |
| $this->donnees_par_page = Config::get('resultat_par_page_defaut'); |
| $this->donnees_par_page_choix = Config::get('resultat_par_page_choix'); |
| $donnees = array(); |
| $rechercheDao = new RechercheDao(); |
| $parametres = array('mots' => '*'); |
| // code du référentiel courant |
| if (isset($_GET['ref'])) { |
| $this->referentiel = strtolower($_GET['ref']); |
| } |
| // Gestion des squelettes |
| $this->definirCommeModulePrincipal(get_class($this)); |
| $this->construireMenu($this->referentiel); |
| $this->construireFilAriane($this->referentiel); |
| $this->chargerMoteurRecherche($this->referentiel, 10); |
| // Récupération des paramètres de l'url |
| $chaine_de_recherche = $this->obtenirChaineRecherche(); |
| if (!empty($chaine_de_recherche)) { |
| $this->url->setVariablesRequete(array('module' => 'Recherche', |
| 'action' => 'rechercher', |
| 'ref' => $this->referentiel, |
| 'recherche' => $chaine_de_recherche)); |
| } |
| $parametres = $this->parserChaineDeRecherche($chaine_de_recherche); |
| $parametres['ref'] = $this->referentiel; |
| // requête spéciale de recherche de tous les synonymes et du nom retenu d'un paramétre |
| if (isset($parametres['tax']) && ($parametres['tax'] == 1)) { |
| $resultat = $this->chercherSynonymes($rechercheDao, $parametres); |
| } else if (isset($parametres['classif'])) { |
| $this->chargerTableauManuel('presence'); |
| $donnees['valeur_presence'] = $this->tableau_manuel['presence']; |
| $donnees['referentiel'] = $this->referentiel; |
| $donnees['fragmenteur'] = $this->gererFragmenteur($rechercheDao, $parametres, 'NombreClassif'); |
| $donnees['resultats'] = $rechercheDao->chercher('Classification', $parametres); |
| $resultat = $this->getVue('resultat_recherche', $donnees); |
| } else { |
| $this->chargerTableauManuel('presence'); |
| $donnees['valeur_presence'] = $this->tableau_manuel['presence']; |
| $donnees['referentiel'] = $this->referentiel; |
| $donnees['fragmenteur'] = $this->gererFragmenteur($rechercheDao, $parametres); |
| $donnees['resultats'] = $rechercheDao->chercher('ParDefaut', $parametres); |
| $resultat = $this->getVue('resultat_recherche', $donnees); |
| } |
| $this->setSortie(self::RENDU_CORPS, $resultat); |
| } |
| private function chercherSynonymes($rechercheDao, $parametres){ |
| $this->donnees_par_page = 2; |
| $this->donnees_par_page_choix = '1,2,5,10'; |
| $donnees['referentiel'] = $this->referentiel; |
| $donnees['fragmenteur'] = $this->gererFragmenteur($rechercheDao, $parametres, 'NombreTaxon'); |
| $resultats = $rechercheDao->chercher('ParTaxon', $parametres); |
| foreach ($resultats as $res) { |
| if ($res['num_nom'] == $res['num_nom_retenu']) { |
| $donnees['resultats']['nom_retenu'][$res['num_nom_retenu']] = $res; |
| } else { |
| $donnees['resultats'][$res['num_nom_retenu']][$res['num_nom']] = $res; |
| } |
| } |
| $resultat = $this->getVue('resultat_recherche_taxon', $donnees); |
| return $resultat; |
| } |
| private function gererFragmenteur($rechercheDao, $parametres, $type = 'Nombre') { |
| // Gestion du nombre de résultats |
| $donnees_total = $rechercheDao->chercherStructureNbre($type, $parametres); |
| // Gestion du fragmenteur |
| $options = array( |
| 'url' => $this->url, |
| 'donnees_total' => $donnees_total, |
| 'donnees_par_page' => $this->donnees_par_page, |
| 'donnees_par_page_choix' => $this->donnees_par_page_choix); |
| $fragmenteur = Composant::fabrique('fragmenteur', $options); |
| $donnees['fragmenteur'] = $fragmenteur->executer(); |
| list($de, $a) = $fragmenteur->getDeplacementParPageId(); |
| $this->url->unsetVariablesRequete(array('recherche', 'page')); |
| // Gestion de l'accès aux données |
| $rechercheDao->setLimitation(($de - 1), $fragmenteur->getDonneesParPage()); |
| $rechercheDao->setDistinction(1); |
| return $donnees['fragmenteur']; |
| } |
| private function parserChaineDeRecherche($chaine) { |
| $mots = preg_split('/ /i', $chaine, -1, PREG_SPLIT_NO_EMPTY); |
| $parametres = array('mots' => ''); |
| $cle_precedente = null; |
| foreach ($mots as $mot) { |
| if (preg_match('/^(sg|gen|sp|ssp|au|an|nn|bib|nr|tax|pre|taxref|classif|rg):(.*)$/', $mot, $match)) { |
| $cle = $match[1]; |
| $cle_precedente = $cle; |
| $valeur = $match[2]; |
| $parametres[$cle] = $valeur; |
| } else if (!is_null($cle_precedente)) { |
| $parametres[$cle_precedente] .= ' '.$mot; |
| } else if (is_null($cle_precedente)) { |
| if (empty($parametres['mots'])) { |
| $parametres['mots'] = $mot; |
| } else { |
| $parametres['mots'] .= ' '.$mot; |
| } |
| } |
| } |
| return $parametres; |
| } |
| // charger tableau de $this->manuel |
| private function chargerTableauManuel($titreTableau) { |
| $champs = explode(',', $this->manuel[$titreTableau]); |
| foreach ($champs as $champ) { |
| list($champ_nom, $type) = explode('=', trim($champ)); |
| $this->tableau_manuel[$titreTableau][$champ_nom] = $type; |
| } |
| } |
| } |
| /branches/v2.0-betulales/interfaces/controleurs/Arbre.php |
|---|
| New file |
| 0,0 → 1,141 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Arbre du module Consultation. |
| * Permet de consultater un référentiel sous forme d'arbre |
| * |
| * @package Referentiel |
| * @category Php5.2 |
| * @author Aurélien PERONNET <aurelien@tela-botanica.org> |
| * @copyright 2010 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$ |
| */ |
| class Arbre extends AppliControleur { |
| private $referentiel = null; |
| private $rechercheDao = null; |
| public function __construct() { |
| parent::__construct(); |
| // Récupération de paramètres |
| if (isset($_GET['ref'])) { // code du projet courant |
| $this->referentiel = strtolower($_GET['ref']); |
| } |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| $this->definirCommeModulePrincipal(get_class($this)); |
| $this->construireMenu($this->referentiel); |
| $this->construireFilAriane($this->referentiel); |
| $this->executerActionReferentiel('Arbre', 'afficherArbre', $this->referentiel, false); |
| } |
| public function afficherArbre() { |
| $donnees = array(); |
| $donnees['resultats'] = $this->chercherFamilles(); |
| $nns = array(); |
| foreach($donnees['resultats'] as $resultat) { |
| $nns[] = $resultat['num_nom']; |
| } |
| $donnees['resultats_nb_infra'] = $this->chercherNombreInfras($nns); |
| $donnees['resultats_nb_syn'] = $this->chercherNombreSynonymes($nns); |
| $donnees['url_service_tpl'] = Config::get('url_jrest'); |
| $donnees['url_sous_taxons_tpl'] = $this->obtenirUrlMenuBranche($this->referentiel, ''); |
| $donnees['url_synonymes_tpl'] = $this->obtenirUrlMenuBrancheSynonyme($this->referentiel, ''); |
| $donnees['url_fiche_taxon_tpl'] = $this->obtenirUrlFicheTaxon($this->referentiel, '%s'); |
| $donnees['referentiel'] = $this->referentiel; |
| $resultat = $this->getVue('arbre_taxon', $donnees); |
| $this->setSortie(self::RENDU_CORPS, $resultat); |
| } |
| public function afficherBranche() { |
| $donnees = array(); |
| $donnees['resultats_infra'] = $this->chercherInfras($_GET['num_nom']); |
| foreach($donnees['resultats_infra'] as $resultat) { |
| $nns[] = $resultat['num_nom']; |
| } |
| $donnees['resultats_nb_infra'] = $this->chercherNombreInfras($nns); |
| $donnees['resultats_nb_syn'] = $this->chercherNombreSynonymes($nns); |
| $resultat = json_encode($donnees); |
| header('Content-type: application/json'); |
| echo $resultat; |
| exit; |
| } |
| public function afficherBrancheSynonyme() { |
| $donnees['resultats_syn'] = $this->chercherSynonymes($_GET['num_nom']); |
| $resultat = json_encode($donnees); |
| header('Content-type: application/json'); |
| echo $resultat; |
| exit; |
| } |
| private function getDao() { |
| if($this->rechercheDao == null) { |
| $this->rechercheDao = new RechercheDao(); |
| } |
| return $this->rechercheDao; |
| } |
| private function chercherFamilles() { |
| $rechercheDao = $this->getDao(); |
| $rechercheDao->setLimitation(0,10000); |
| $parametres = array('mots' => '*', |
| 'ref' => $this->referentiel, |
| 'rg' => 180); |
| $resultats = $rechercheDao->chercher('ParDefaut', $parametres); |
| return $resultats; |
| } |
| private function chercherNombreSynonymes($tableau_nn) { |
| $rechercheDao = $this->getDao(); |
| $parametres_syn = array('mots' => '*', |
| 'ref' => $this->referentiel, |
| 'nn' => implode(',', $tableau_nn)); |
| $resultats_nb_syn = $rechercheDao->chercher('NombreSynonymeParTaxon', $parametres_syn); |
| return $resultats_nb_syn; |
| } |
| private function chercherSynonymes($num_nom) { |
| $rechercheDao = $this->getDao(); |
| $parametres_syn = array('mots' => '*', |
| 'ref' => $this->referentiel, |
| 'nn' => $num_nom); |
| $resultats_syn = $rechercheDao->chercher('ParTaxon', $parametres_syn); |
| return $resultats_syn; |
| } |
| private function chercherNombreInfras($tableau_nn) { |
| $rechercheDao = $this->getDao(); |
| $parametres_infra = array('mots' => '*', |
| 'ref' => $this->referentiel, |
| 'classif' => 'infra', |
| 'nn' => implode(',', $tableau_nn)); |
| $resultats_nb_infra = $rechercheDao->chercher('NombreClassifParTaxon', $parametres_infra); |
| return $resultats_nb_infra; |
| } |
| private function chercherInfras($num_nom) { |
| $rechercheDao = $this->getDao(); |
| $parametres = array('mots' => '*', |
| 'ref' => $this->referentiel, |
| 'classif' => 'infra', |
| 'nn' => $num_nom); |
| $resultats_infra = $rechercheDao->chercher('Classification', $parametres); |
| return $resultats_infra; |
| } |
| } |
| ?> |
| /branches/v2.0-betulales/interfaces/controleurs/Traitement.php |
|---|
| New file |
| 0,0 → 1,90 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur du module Traitement. |
| * Affichage les infos sur l'ensemble des résultats d'un traitement. |
| * |
| * @package Referentiel |
| * @category Php5.2 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 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$ |
| */ |
| class Traitement extends AppliControleur { |
| private $referentiel = null; |
| private $traitement = null; |
| private $traitementId = null; |
| private $traitementDao = null; |
| private $resultatDao = null; |
| public function __construct() { |
| parent::__construct(); |
| // Récupération de paramêtres |
| if (isset($_GET['id-t'])) { // id du traitement courant |
| $this->traitementId = strtolower($_GET['id-t']); |
| } |
| if (isset($_GET['ref'])) { // code du projet courrant |
| $this->referentiel = strtolower($_GET['ref']); |
| } |
| // Chargement des DAO nécessaires |
| if (isset($this->traitementId)) { |
| $this->traitementDao = new TraitementDao(); |
| $this->resultatDao = new ResultatDao(); |
| } |
| } |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut, elle appelle la liste des administrateurs |
| */ |
| public function executerActionParDefaut() { |
| return $this->afficherTraitement(); |
| } |
| /** |
| * Affiche le formulaire de demande de traitement |
| */ |
| public function afficherTraitement() { |
| $donnees = array(); |
| // Traitement de l'info sur le code du référentiel |
| if (isset($this->traitementId)) { |
| // Recherche d'info sur le traitement |
| $infos = $this->traitementDao->getInfos($this->traitementId); |
| if ($infos != false) { |
| $this->traitement = $infos; |
| $donnees['traitement'] = $this->traitement; |
| } else { |
| $this->addMessage("L'identifiant de traitement n'est pas indexé dans la base de données."); |
| } |
| // Spécificité du script de versionnage |
| $donnees['urls_zip'] = $this->obtenirUrlsZipPourTraitement($this->traitement); |
| // Recherche des résultats du traitement |
| $infos = $this->resultatDao->getResultatsTraitement($this->traitementId); |
| if ($infos != false) { |
| // Ajout de l'url vers la fiche du resultat |
| foreach ($infos as &$resultat) { |
| $resultat['url'] = $this->obtenirUrlFicheResultat($this->referentiel, $resultat['id_resultat']); |
| } |
| $donnees['resultats'] = $infos; |
| } |
| } else { |
| $this->addMessage("Aucun identifiant de traitement n'a été indiqué."); |
| } |
| $donnees['messages'] = $this->getMessages(); |
| $this->traiterEsperluette($donnees); |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('traitement', $donnees), false); |
| $this->construireMenu($this->referentiel); |
| $this->construireFilAriane($this->referentiel, $this->traitementId); |
| } |
| } |
| ?> |