Subversion Repositories Applications.referentiel

Rev

Rev 12 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

<?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;
        }
        
}
?>