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