Subversion Repositories Applications.referentiel

Compare Revisions

Ignore whitespace Rev 5 → Rev 6

/trunk/controleurs/Test.php
New file
0,0 → 1,705
<?php
// declare(encoding='UTF-8');
/**
* Classe Controleur du module Test.
*
* @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 {
private $projet = null;
private $tableStructureDao = null;
private $referentielDao = null;
private $manuel = null;
public function __construct() {
parent::__construct();
// Récupération de paramêtres
if (isset($_GET['projet'])) { // code du projet courrant
$this->projet = $_GET['projet'];
}
// Parser le fichier ini contenant certains règles liées à la version du manuel
$this->manuel = parse_ini_file(Config::get('dossier_configurations').DS.Config::get('manuel'));
// Chargement des DAO nécessaires
$this->tableStructureDao = $this->getModele('TableStructureDao');
$this->referentielDao = $this->getModele('ReferentielDao');
}
//+----------------------------------------------------------------------------------------------------------------+
// Méthodes
/**
* Fonction d'affichage par défaut, elle appelle la liste des administrateurs
*/
public function executerActionParDefaut() {
return $this->lancerTest();
}
public function lancerTest() {
$donnees = array();
// Récupération des données à tester
$colonnes = $this->tableStructureDao->getColonnes($this->projet);
$analyses = $this->tableStructureDao->getAnalyse($this->projet);
$noms = $this->referentielDao->getTout($this->projet);
$noms = $this->classerNoms($noms);
// Lancement des tests unitaires
$donnees['tests'][] = $this->testerNombreDeChamps($colonnes);
$donnees['tests'][] = $this->testerNomDesChamps($colonnes);
$donnees['tests'][] = $this->testerTypeDesChamps($colonnes);
$donnees['tests'][] = $this->testerTailleDesChamps($colonnes, $analyses);
$donnees['tests'][] = $this->testerNumNomClePrimaire($colonnes);
$donnees['tests'][] = $this->testerNumNomSuperieurAZero($noms);
$donnees['tests'][] = $this->testerNumNomRetenuSuperieurAZero($noms);
$donnees['tests'][] = $this->testerNumTaxSupEgalZeroUnique($noms);
$donnees['tests'][] = $this->testerTaxSupPourTaxon($noms);
$donnees['tests'][] = $this->testerExitenceTaxonSuperieur($noms);
$donnees['tests'][] = $this->testerClassificationRang($noms);
$donnees['tests'][] = $this->testerClassification($noms);
$donnees['tests'][] = $this->testerRang($noms);
$donnees['tests'][] = $this->testerNomCompletSupraGenerique($noms);
$donnees['tests'][] = $this->testerNomCompletGenre($noms);
$donnees['tests'][] = $this->testerNomCompletInfraGenre($noms);
$donnees['tests'][] = $this->testerNomCompletEspece($noms);
$donnees['tests'][] = $this->testerNomCompletInfraSpecifique($noms);
$donnees['tests'][] = $this->testerNomSupraGeneriqueMotUnique($noms);
$donnees['tests'][] = $this->testerNomSupraGeneriqueEspaces($noms);
//Debug::printr($this->manuel);
$this->setSortie(self::RENDU_CORPS, $this->getVue('test', $donnees));
}
private function classerNoms($noms) {
$noms_classes = array();
foreach ($noms as $nom) {
$noms_classes[$nom['num_nom']] = $nom;
}
return $noms_classes;
}
private function testerNombreDeChamps($colonnes) {
$info = array('titre' => 'Structure -> nombre de champs : %s',
'description' => 'Le nombre de champs présent dans la table doit être supérieur ou égal à 35.',
'resultat' => false);
$nbre_colonnes = count($colonnes);
$info['titre'] = sprintf($info['titre'], $nbre_colonnes);
if ($nbre_colonnes >= 35) {
$info['resultat'] = true;
}
return $info;
}
private function testerNomDesChamps($colonnes) {
$info = array('titre' => 'Structure -> noms des champs',
'description' => 'Les champs de la table contenant le référentiel doivent être conforme à ceux définit par le manuel technique.',
'resultat' => false);
$champs_attendus = explode(',', $this->manuel['champs']);
$champs_presents = array();
foreach ($colonnes as $colonne) {
$champs_presents[$colonne['Field']] = $colonne;
}
$ok = true;
$champs_manquant = array();
foreach ($champs_attendus as $champ_attendu) {
if (!isset($champs_presents[$champ_attendu])) {
$champs_manquant[] = $champ_attendu;
$ok = false;
}
}
$info['resultat'] = $ok;
if (!$ok) {
$info['message'] = 'Champs manquant : '.implode(', ', $champs_manquant).'.';
}
return $info;
}
private function testerTypeDesChamps($colonnes) {
$info = array('titre' => 'Structure -> types des champs',
'description' => 'Les types des champs de la table contenant le référentiel doivent être conforme à ceux définit par le manuel technique.',
'resultat' => false);
$champs_attendus = explode(',', $this->manuel['champs_type']);
$champs_presents = array();
foreach ($colonnes as $colonne) {
$champs_presents[$colonne['Field']] = $colonne['Type'];
}
// Recercherche des erreurs
$champs_erreur = array();
foreach ($champs_attendus as $champ_attendu) {
list($champ_attendu_nom, $champ_attendu_type) = explode('=', trim($champ_attendu));
 
if (isset($champs_presents[$champ_attendu_nom])) {
$champs_present_type = $champs_presents[$champ_attendu_nom];
if (($champ_attendu_type == 'VARCHAR' && strstr($champs_present_type, 'varchar') === false)
|| ($champ_attendu_type == 'TEXT' && strstr($champs_present_type, 'text') === false)
|| ($champ_attendu_type == 'INT' && strstr($champs_present_type, 'int') === false)
|| ($champ_attendu_type == 'BOOL' && preg_match('/(?:bool|boolean|tinyint\(1\))/i', $champs_present_type) === false)) {
$champs_erreur[] = $champ_attendu." vaut ".$champs_present_type;
}
}
}
// Analyse des résultats
if (count($champs_erreur) > 0) {
$info['message'] = "Champs n'ayant pas un bon type : ".implode(', ', $champs_erreur).'.';
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerTailleDesChamps($colonnes, $analyses) {
$info = array('titre' => 'Structure -> champs tronqués',
'description' => "Vérifie que les données de type texte insérées dans la table n'ont pas été tronquées lors de leur insertion.",
'resultat' => false);
$tailles_champs_maxi = array();
foreach ($colonnes as $colonne) {
if (preg_match('/^varchar\(([0-9]+)\)$/', $colonne['Type'], $match)) {
$tailles_champs_maxi[$colonne['Field']] = $match[1];
}
}
$tailles_trouvees = array();
foreach ($analyses as $analyse) {
if (preg_match('/\.([^.]+)$/', $analyse['Field_name'], $match)) {
$tailles_trouvees[$match[1]] = $analyse['Max_length'];
}
}
$champs_erreur = array();
$champs_attendus = explode(',', $this->manuel['champs']);
foreach ($champs_attendus as $champ_attendu) {
if (isset($tailles_champs_maxi[$champ_attendu]) && isset($tailles_trouvees[$champ_attendu])) {
if ($tailles_champs_maxi[$champ_attendu] == $tailles_trouvees[$champ_attendu]) {
$champs_erreur[] = $champ_attendu;
}
}
}
// Analyse des résultats
if (count($champs_erreur) > 0) {
$info['message'] = "Champs possédant des enregistrements avec une taille maximum : ".implode(', ', $champs_erreur).'.';
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerNumNomClePrimaire($colonnes) {
$info = array('titre' => 'Structure -> num_nom est clé primaire',
'description' => "Vérifie que le champ num_nom est bien la clé primaire de la table.",
'resultat' => false);
foreach ($colonnes as $colonne) {
if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') {
$info['resultat'] = true;
}
}
return $info;
}
private function testerNumNomSuperieurAZero($noms) {
$info = array('titre' => 'num_nom -> supérieur à 0',
'description' => "Le champ num_nom doit contenir des nombres entiers supérieurs à 0.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['num_nom'] <= 0) {
$noms_erreur[] = $nom['num_nom'];
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message'] = count($noms_erreur)." enregistrements contiennent dans le champ num_nom une valeur inférieure ou égale à 0.";
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerNumNomRetenuSuperieurAZero($noms) {
$info = array('titre' => 'num_nom_retenu -> supérieur à 0',
'description' => "Le champ num_nom_retenu doit contenir des nombres entiers supérieurs à 0.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['num_nom_retenu'] <= 0) {
$noms_erreur[] = $nom['num_nom'];
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message'] = count($noms_erreur)." enregistrements dont le champ num_nom_retenu est inférieur ou égal à 0 : ".implode(', ', $noms_erreur).'.';
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerNumTaxSupEgalZeroUnique($noms) {
$info = array('titre' => 'num_tax_sup -> égal à 0 unique',
'description' => "Un seul enregistrement doit posséder la valeur 0 dans le champ num_tax_sup. Il correspond au premier taxon de la classification.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if (preg_match('/^0$/', $nom['num_tax_sup'])) {
$noms_erreur[] = $nom['num_nom'];
}
}
// Analyse des résultats
if (count($noms_erreur) > 1) {
$info['message'] = count($noms_erreur)." enregistrements ont une valeur de 0 dans le champ num_tax_sup : ".implode(', ', $noms_erreur).'.';
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerTaxSupPourTaxon($noms) {
$info = array('titre' => 'Classification -> uniquement pour les taxons',
'description' => "Seul les enregistrements représentant un taxon doivent posséder une valeur dans le champ num_tax_sup.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['num_nom_retenu'] == $nom['num_nom'] && preg_match('/^[0-9]+$/', $nom['num_tax_sup'])) {
$noms_erreur[] = $nom['num_nom'];
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message'] = count($noms_erreur)." enregistrements qui n'est pas un taxon et qui possède une valeur dans num_tax_sup : ".implode(', ', $noms_erreur).'.';
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerExitenceTaxonSuperieur($noms) {
$info = array('titre' => 'Classification -> existence du taxon supérieur',
'description' => "Pour chaque enregistrement représentant un taxon doit posséder un taxon supérieur sauf la racine de la classification.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['num_nom_retenu'] == $nom['num_nom']) {
if ($nom['num_tax_sup'] != 0 && !isset($noms[$nom['num_tax_sup']])) {
$noms_erreur[] = $nom['num_nom'];
}
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message'] = count($noms_erreur)." enregistrements dont le taxon supérieur n'existe pas : ".implode(', ', $noms_erreur).'.';
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerClassificationRang($noms) {
$info = array('titre' => 'Classification -> taxon supérieur avec rang inférieur',
'description' => "Pour chaque enregistrement représentant un taxon, chaque taxon supérieur doit avoir un rang inférieur au taxon courant.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['num_nom_retenu'] == $nom['num_nom']) {
if (isset($noms[$nom['num_tax_sup']])) {
$nom_sup = $noms[$nom['num_tax_sup']];
if ($nom_sup['rang'] > $nom['rang']) {
$noms_erreur[] = $nom['num_nom'];
}
}
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message'] = count($noms_erreur)." enregistrements avec un problème : ".implode(', ', $noms_erreur).'.';
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerClassification($noms) {
$info = array('titre' => 'Classification -> racine liée à chaque noeud',
'description' => "Pour chaque enregistrement, la classification doit pouvoir être remonté jusqu'à un même nom unique possédant une valeur num_tax_sup de 0.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['num_nom_retenu'] == $nom['num_nom']) {
$classif_ok = $this->remonterClassif($noms, $nom);
if ($classif_ok === false) {
$noms_erreur[] = $nom['num_nom'];
}
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message'] = count($noms_erreur)." taxons dont la classification n'est pas bonne : ".implode(', ', $noms_erreur).'.';
} else {
$info['resultat'] = true;
}
return $info;
}
private function remonterClassif(&$noms, $nom) {
if (!isset($noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') {
return true;
} else if (!isset($noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') {
return false;
} else {
return $this->remonterClassif($noms, $noms[$nom['num_tax_sup']]);
}
}
private function testerRang($noms) {
$info = array('titre' => 'rang',
'description' => "Le rang doit correspondre à un valeur numérique définit dans le manuel.",
'resultat' => false);
$rangs = array_flip(explode(',', $this->manuel['rangs']));
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if (!isset($rangs[$nom['rang']])) {
$noms_erreur[] = $nom['num_nom'];
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message'] = count($noms_erreur)." noms dont le rang n'est pas bon : ".implode(', ', $noms_erreur).'.';
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerNomCompletSupraGenerique($noms) {
$info = array('titre' => 'nom_complet -> noms supra-génériques',
'description' => "Si le rang est < à {$this->manuel['rang_genre']} le nom_complet doit correspondre à la valeur du champ nom_supra_generique. ".
"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['rang'] < $this->manuel['rang_genre']) {
$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
$nom_complet_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']);
$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
if ($nom['nom_complet'] != $nom_complet_ideal) {
$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
}
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
$info['message']['lignes'] = $noms_erreur;
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerNomCompletGenre($noms) {
$info = array('titre' => 'nom_complet -> noms de genres',
'description' => "Si le rang est = à {$this->manuel['rang_genre']} le nom_complet doit correspondre à la valeur du champ genre. ".
"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['rang'] == $this->manuel['rang_genre']) {
$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
if ($nom['nom_complet'] != $nom_complet_ideal) {
$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
}
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
$info['message']['lignes'] = $noms_erreur;
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerNomCompletInfraGenre($noms) {
$info = array('titre' => 'nom_complet -> noms infra-génériques',
'description' => "Si le rang est > à {$this->manuel['rang_genre']} et < à {$this->manuel['rang_sp']} le nom_complet doit correspondre à une des formules suivantes : \n".
" genre + ' ' + type_epithete + ' ' + epithete_infra_generique \n".
" genre + ' ' + epithete_infra_generique + ' ' + type_epithete=agg. \n".
"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) {
$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
$nom_complet_ideal = '';
if ($nom['type_epithete'] == 'agg.') {
$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
$nom_complet_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
$nom_complet_ideal .= ' '.$nom['type_epithete'];
} else {
$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
$nom_complet_ideal .= ' '.$nom['type_epithete'];
$nom_complet_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
}
$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
if ($nom['nom_complet'] != $nom_complet_ideal) {
$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
}
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
$info['message']['lignes'] = $noms_erreur;
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerNomCompletEspece($noms) {
$info = array('titre' => "nom_complet -> noms d'espèce",
'description' => "Si le rang est = à {$this->manuel['rang_sp']} le nom_complet doit correspondre à la formule : \n".
" genre + ' ' + epithete_sp \n".
"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['rang'] == $this->manuel['rang_sp']) {
$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
$nom_complet_ideal .= ' '.strtolower($nom['epithete_sp']);
$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
if ($nom['nom_complet'] != $nom_complet_ideal) {
$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
}
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
$info['message']['lignes'] = $noms_erreur;
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerNomCompletInfraSpecifique($noms) {
$info = array('titre' => 'nom_complet -> noms infra-spécifiques',
'description' => "Si le rang est > à {$this->manuel['rang_sp']} le nom_complet doit correspondre à la formule : \n".
" genre + ' ' + epithete_sp + ' ' + type_epithete + ' ' + epithete_infra_generique\n".
"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['rang'] > $this->manuel['rang_sp']) {
$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
$nom_complet_ideal .= ' '.strtolower($nom['epithete_sp']);
$nom_complet_ideal .= ' '.strtolower($nom['type_epithete']);
$nom_complet_ideal .= ' '.strtolower($nom['epithete_infra_sp']);
$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
if ($nom['nom_complet'] != $nom_complet_ideal) {
$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
}
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
$info['message']['lignes'] = $noms_erreur;
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerNomSupraGeneriqueMotUnique($noms) {
$info = array('titre' => 'nom_supra_generique -> plusieurs mots',
'description' => "Le champ nom_supra_generique doit contenir un seul mot.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['nom_supra_generique'] != '') {
$mots = explode(' ', trim($nom['nom_supra_generique']));
if (count($mots) > 1) {
$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
}
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message']['entete'] = array('num_nom', 'nom_supra_generique erroné');
$info['message']['lignes'] = $noms_erreur;
} else {
$info['resultat'] = true;
}
return $info;
}
private function testerNomSupraGeneriqueEspaces($noms) {
$info = array('titre' => 'nom_supra_generique -> espaces en trop',
'description' => "Le champ nom_supra_generique ne doit pas contenir d'espace avant ou aprés le nom.",
'resultat' => false);
// Réalisation du test
$noms_erreur = array();
foreach ($noms as $nom) {
if ($nom['nom_supra_generique'] != '') {
if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
}
}
}
// Analyse des résultats
if (count($noms_erreur) > 0) {
$info['message']['entete'] = array('num_nom', 'nom_supra_generique erroné');
$info['message']['lignes'] = $noms_erreur;
} else {
$info['resultat'] = true;
}
return $info;
}
private function formaterStyleNomGenre($genre) {
$genre_fmt = '';
if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
$genre_fmt = strtolower($match[1]).' '.ucfirst(strtolower($match[2]));
} else {
$genre_fmt = ucfirst(strtolower($genre));
}
return $genre_fmt;
}
private function repererEspace($nom_complet) {
$nom_complet = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_complet);
return $nom_complet;
}
private function construireSuffixeNomPltCultivee($nom) {
$suffixe = array();
$suffixe[] = $this->construireNomCultivarGroupe($nom);
$suffixe[] = $this->construireNomCommercial($nom);
$suffixe[] = $this->construireNomCultivar($nom);
$suffixe = array_filter($suffixe);
return implode(' ', $suffixe);
}
private function construireNomCultivarGroupe($nom) {
$nom_groupe_cultivar = '';
if ($nom['cultivar_groupe'] != '') {
if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
$nom_groupe_cultivar = '('.$nom['cultivar_groupe'].')';
} else {
$nom_groupe_cultivar = '('.$nom['cultivar_groupe'].' Gp)';
}
}
return $nom_groupe_cultivar;
}
private function construireNomCommercial($nom) {
$nom_commercial = '';
if ($nom['nom_commercial'] != '') {
$nom_commercial = strtoupper($nom['nom_commercial']);
}
return $nom_commercial;
}
private function construireNomCultivar($nom) {
$nom_cultivar = '';
if ($nom['cultivar'] != '') {
$nom_cultivar = "'".$nom['cultivar']."'";
}
return $nom_cultivar;
}
}
?>
/trunk/controleurs/AppliControleur.php
New file
0,0 → 1,99
<?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';
private $sortie = array();
private $parametres = array();
// FIXME : voir s'il est plus intéressant d'utiliser une méthode dans les classes filles
protected $url = null;
public function __construct() {
$registre = Registre::getInstance();
$this->parametres = $registre->get('parametres');
$this->url = $this->parametres['url'];
parent::__construct();
}
/**
* 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;
}
}
}
/**
* 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) {
trigger_error("La position '$position' n'est pas une valeur prédéfinie.", E_USER_WARNING);
$existe = false;
}
return $existe;
}
/**
* Retourne le tableau de sortie à utiliser dans le controleur principal de l'application.
*/
public function getSortie() {
return $this->sortie;
}
 
/**
* 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());
}
/**
* 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 = '&nbsp;';
} else if (is_string($valeur)) {
$valeur = preg_replace('/&(?!amp;)/i', '&amp;', $valeur, -1);
} else if (is_array($valeur)) {
$this->postraiterDonnees($valeur);
}
}
}
}
}
/trunk/controleurs/Referentiel.php
New file
0,0 → 1,185
<?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' => '');
$url = new Url(Config::get('url_base'));
self::$parametres = array( 'module' => 'Test',
'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();
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 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 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 = 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;
}
}
?>