Applications.referentielApplications.annuaireApplications.bazarApplications.dictionnaireApplications.frameworkApplications.galerieApplications.gttApplications.papyrusApplications.projetApplications.reseauApplications.wikinieFlore/Applications.bibliobotaeFlore/Applications.celeFlore/Applications.cel-consultationeFlore/Applications.coeleFlore/Applications.coel-consultationeFlore/Applications.deleFlore/Applications.eflore-consultationeFlore/Applications.moissonnageeFlore/Archives.cel-v1eFlore/Archives.cel-v2eFlore/Archives.chorologieeFlore/Archives.eflore-consultation-v1eFlore/Archives.eflore-consultation-v2eFlore/Archives.eflore-xuleFlore/Archives.herbierseFlore/Projets.communeseFlore/Projets.eflore-projetsSites.gentiana.orgSites.obs-saisons.frSites.outils-naturalistes.frSites.tela-botanica.org

BlueGreycalmElegant

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /branches/v2.0-betulales/scripts/modules @ 337

  → /branches/v2.0-betulales/scripts/modules @ 344

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

Ignore whitespace Rev 337 → Rev 344

/branches/v2.0-betulales/scripts/modules/versionnage/squelettes/bdnt_ligne.tpl.tsv
New file
0,0 → 1,2
<?=implode("\t", $nom_infos)?>

/branches/v2.0-betulales/scripts/modules/versionnage/squelettes/bdnt_partiel_ligne.tpl.tsv
New file
0,0 → 1,6
<?php if (!isset($nom_infos['exclure_taxref']) || $nom_infos['exclure_taxref'] != '1') :
foreach ($champs_partiel as $champ) :
echo $nom_infos[$champ];
echo ($dernier_champ == $champ) ? "\n" : "\t";
endforeach;
endif; ?>

/branches/v2.0-betulales/scripts/modules/versionnage/squelettes/meta.tpl.tsv
New file
0,0 → 1,45
titre <?=$titre?>
code <?=$acronyme?>
domaine_taxo <?=implode(', ', $dom_tax)?>
domaine_geo <?=implode(', ', $dom_geo)?>
domaine_nom <?=implode(', ', $dom_code)?>
classification <?=$classification?>
version <?=$version?>
auteur <?=$auteur_principal?>
coordinateur <?=$coordinateur?>
contributeur <?=$contributeur?>
date_production <?=$date_prod?>
source <?=$source?>
contact <?=$contact?>
editeur <?=$editeur?>
droit <?=$copyright?>
licence <?=$licence?>
referencement <?=$referencement?>
stat_combinaison <?=$stats['combinaison']?>
stat_taxon <?=$stats['taxon']?>
stat_modification <?=$stats['modification']?>
signature <?=$signature?>
errata <?=$errata?>
notes <?=$notes?>

/branches/v2.0-betulales/scripts/modules/versionnage/squelettes/diff.tpl.tsv
New file
0,0 → 1,6
<?=implode("\t", $champs)?>
<?php foreach ($diff as $nom_infos) : ?>
<?=implode("\t", $nom_infos)?>
<?php endforeach; ?>

/branches/v2.0-betulales/scripts/modules/versionnage/squelettes/diff_partiel.tpl.tsv
New file
0,0 → 1,8
<?=implode("\t", $champs_partiel_diff)?>
<?php foreach ($diff_partiel as $id => $nom_infos) :
foreach ($champs_partiel_diff as $champ) :
echo $nom_infos[$champ];
echo ($dernier_champ == $champ) ? "\n" : "\t";
endforeach;
endforeach; ?>

/branches/v2.0-betulales/scripts/modules/versionnage/squelettes/bdnt_entete.tpl.tsv
New file
0,0 → 1,2
<?=implode("\t", $champs)?>

/branches/v2.0-betulales/scripts/modules/versionnage/squelettes/bdnt_partiel_entete.tpl.tsv
New file
0,0 → 1,2
<?=implode("\t", $champs_partiel)?>

/branches/v2.0-betulales/scripts/modules/versionnage/Versionnage.php
New file
0,0 → 1,765
<?php
// Encodage : UTF-8
// +-------------------------------------------------------------------------------------------------------------------+
/**
* Versionnage de référentiels de nomenclature et taxonomie
*
* Description : classe permettant de versionner les référentiels selon le manuel technique
* Utilisation : php script.php versionnage -p bdnff -a tout
*
//Auteur original :
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Tela-Botanica 1999-2010
* @link http://www.tela-botanica.org/wikini/RTaxMethodo/wakka.php?wiki=MaNuel
* @licence GPL v3 & CeCILL v2
* @version $Id$
*/
// +-------------------------------------------------------------------------------------------------------------------+
// TODO : lors de la génération de la version 2 de la BDTFX tester les diff! Il se peut que la mémoire soit dépassée.
class Versionnage extends ScriptCommande {
const SCRIPT_NOM = 'versionnage';
const MANUEL_VERSION = '4.4';
private $projet = null;
private $traitement = null;
private $meta = null;
private $version_courante = null;
private $messages = null;
private $manuel = null;
private $manuel_nom = null;
private $manuel_chemin = null;
private $zip_chemin_dossier = null;
private $zip_chemin_fichier = null;
private $zip_chemin_dossier_partiel = null;
private $zip_chemin_fichier_partiel = null;
private $noms = null;
private $noms_precedents = null;
private $noms_supprimes = null;
private $noms_stat = null;
private $noms_stat_partiel = null;
private $champs_ordre = null;
private $champs_nom = null;
private $champs_nom_partiel = null;
private $champs_courants = null;
private $champs_diff = null;
private $diff_champs_nom = null;
private $diff_modif_types = null;
private $signature_md5 = null;
private $signature_md5_partiel = null;
private $derniere_meta = null;
private $rangs_bdnt_taxref = null;
private $statuts_bdnt_taxref = null;
private $resultatDao = null;
private $traitementDao = null;
private $metaDao = null;
private $tableStructureDao = null;
private $referentielDao = null;
public function executer() {
// Récupération du dernier traitement demandé
$this->traitementDao = new TraitementDao();
$this->traitement = $this->traitementDao->getDernierTraitement('tout', self::SCRIPT_NOM);
if (isset($this->traitement)) {
$this->projet = $this->traitement['referentiel_code']; // Récupération du nom de projet
Debug::printr($this->traitement);
// Écriture de la date de début du traitement
Debug::printr('Debute:'.$this->traitementDao->debuterTraitement($this->traitement['id_traitement']));
// Nettoyage des traitements obsolètes
$traitements_obsoletes = $this->traitementDao->getTraitementsObsoletes($this->projet, self::SCRIPT_NOM);
if (isset($traitements_obsoletes)) {
Debug::printr('Supp. obsoletes:'.$this->traitementDao->supprimer($traitements_obsoletes));
}
// Lancement du test demandé
$cmd = $this->getParam('a');
switch ($cmd) {
case 'tout' :
$this->initialiserScript();
Debug::printr('Départ lancement versionnage:');
$this->lancerVersionnage();
break;
default :
$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
}
// Écriture de la date de fin du traitement
Debug::printr('Termine:'.$this->traitementDao->terminerTraitement($this->traitement['id_traitement']));
}
}
private function initialiserScript() {
$this->metaDao = new MetaDao();
$this->resultatDao = new ResultatDao();
$this->referentielDao = new ReferentielDao();
$this->manuel_nom = 'mtpr_v'.str_replace('.', '_', self::MANUEL_VERSION).'.pdf';
$this->manuel_chemin = Config::get('chemin_appli').DS.'..'.DS.'configurations'.DS;
$manuel_config_nom = 'referentiel_v'.self::MANUEL_VERSION.'.ini';
$this->manuel = parse_ini_file($this->manuel_chemin.$manuel_config_nom);
}
public function lancerVersionnage() {
$this->chargerTraitementParametre();
$this->initialiserNomVersionCOurante();
$this->initialiserCheminsZip();
$this->creerDossiersZip();
$this->archiver();
$this->chargerNomsATraiter();
$this->analyserNomsATraiter();
$this->creerFichiers();
$this->nettoyerFichiers();
$this->traiterMessages();
}
private function chargerTraitementParametre() {
$this->meta = unserialize($this->traitement['script_parametres']);
}
private function archiver() {
$ok = $this->referentielDao->archiver($this->projet, $this->meta['version']);
if ($ok) {
$m = "L'archivage de la version '{$this->meta['version']}' du référentiel '{$this->projet}' a réussi";
$this->ajouterMessage($m);
} else {
$m = "L'archivage de la version '{$this->meta['version']}' du référentiel '{$this->projet}' a échoué";
$this->ajouterMessage($m);
}
}
private function initialiserNomVersionCOurante() {
$this->version_courante = strtolower($this->projet).'_v'.str_replace('.', '_', $this->meta['version']);
Debug::printr("Nom archive courante :".$this->version_courante);
}
private function initialiserCheminsZip() {
$this->zip_chemin_dossier = Config::get('chemin_referentiel_zip').$this->version_courante.DIRECTORY_SEPARATOR;
$this->zip_chemin_fichier = Config::get('chemin_referentiel_zip').$this->version_courante.'.zip';
$this->zip_chemin_dossier_partiel = Config::get('chemin_referentiel_zip').$this->version_courante.$this->manuel['suffixe_partiel'].DIRECTORY_SEPARATOR;
$this->zip_chemin_fichier_partiel = Config::get('chemin_referentiel_zip').$this->version_courante.$this->manuel['suffixe_partiel'].'.zip';
}
private function creerDossiersZip() {
$recursivite = true;
if (mkdir($this->zip_chemin_dossier, 0777, $recursivite) === false) {
$this->ajouterMessage("La création du dossier '$this->zip_chemin_dossier' devant contenir les fichiers a échouée.");
}
if (mkdir($this->zip_chemin_dossier_partiel, 0777, $recursivite) === false) {
$this->ajouterMessage("La création du dossier '$this->zip_chemin_dossier_partiel' devant contenir les fichiers partiels a échouée.");
}
}
private function chargerNomsATraiter() {
$this->noms = $this->referentielDao->getTout($this->version_courante);
}
private function analyserNomsATraiter() {
$this->noms_stat['combinaison'] = $this->getNombreCombinaison();
$this->noms_stat['taxon'] = $this->getNombreTaxon();
Debug::printr("Stats :".print_r($this->noms_stat, true));
$this->noms_stat_partiel = $this->getStatsPartiel();
Debug::printr("Stats partiel:".print_r($this->noms_stat_partiel, true));
}
private function getNombreCombinaison() {
return count($this->noms);
}
private function getNombreTaxon() {
$nbre = 0;
foreach ($this->noms as $nom) {
if ($nom['num_nom_retenu'] == $nom['num_nom']) {
$nbre++;
}
}
return $nbre;
}
private function getStatsPartiel() {
$stat['combinaison'] = 0;
$stat['taxon'] = 0;
foreach ($this->noms as $nom) {
if ($nom['exclure_taxref'] != '1') {
$stat['combinaison']++;
if ($nom['num_nom_retenu'] == $nom['num_nom']) {
$stat['taxon']++;
}
}
}
return $stat;
}
private function creerFichiers() {
// Respecter l'ordre de traitement : BDNT puis DIFF puis META
$donnees =& $this->creerFichierBdnt();
$this->creerFichierBdntPartiel($donnees);
$donnees = null;
$donnees =& $this->creerFichierDiff();
$this->creerFichierDiffPartiel($donnees);
$donnees = null;
$donnees =& $this->creerFichierMeta();
$this->creerFichierMetaPartiel($donnees);
$donnees = null;
$this->nettoyerMemoire();
$this->copierManuel();
$this->creerFichiersZip();
}
private function creerFichierBdnt() {
reset($this->noms);
Debug::printr("Element courrant du tableau des noms : ".count($this->noms).'-'.print_r(current($this->noms),true));
$this->determinerOrdreDesChamps();
$this->definirNomDesChamps();
$this->definirNomDesChampsDiff();
$donnees = array();
$donnees['champs'] = $this->champs_nom;
$fichier_nom = $this->getBaseNomFichier().$this->manuel['suffixe_bdnt'].$this->manuel['ext_fichier'];
$fichier_chemin = $this->zip_chemin_dossier.$fichier_nom;
$bdnt_tsv_entete = $this->getVue('versionnage/squelettes/bdnt_entete', array('champs' => $donnees['champs']), '.tpl.tsv');
$this->ecrireFichier($fichier_chemin, $bdnt_tsv_entete);
foreach ($this->noms as $id => &$nom) {
$infos = array();
foreach ($this->champs_ordre as $champ => $ordre) {
if (array_key_exists($champ, $nom)) {
$infos[$champ] = trim($nom[$champ]);
} else {
$e = "Le champ '$champ' n'a pas été trouvé dans les données du nom : $id.";
$this->ajouterMessage($e);
}
}
$infos = $this->remplacerTabulation($infos);
$infos = $this->remplacerSautsDeLigne($infos);
$this->noms[$id] = $infos;
$bdnt_tsv_ligne = $this->getVue('versionnage/squelettes/bdnt_ligne', array('nom_infos' => $infos), '.tpl.tsv');
$this->ajouterAuFichier($fichier_chemin, $bdnt_tsv_ligne);
}
$this->ecrireComplementFichierBdnt($fichier_chemin);
return $donnees;
}
private function determinerOrdreDesChamps() {
$champs_ordre = explode(',', $this->manuel['champs']);
$champs_ordre = array_flip($champs_ordre);
$nom_courant = current($this->noms);
$champs_ordre = $this->attribuerOrdreChampsSupplémentaires($champs_ordre, $nom_courant);
asort($champs_ordre);
$this->champs_ordre = $champs_ordre;
Debug::printr("Ordre des champs : ".print_r($this->champs_ordre,true));
}
private function attribuerOrdreChampsSupplémentaires($champs_ordre, $nom) {
foreach ($nom as $champ => $info) {
if (!isset($champs_ordre[$champ])) {
$champs_ordre[$champ] = count($champs_ordre);
}
}
return $champs_ordre;
}
private function definirNomDesChamps() {
$this->champs_nom = array_flip($this->champs_ordre);
}
private function definirNomDesChampsDiff() {
$this->champs_diff = explode(',', $this->manuel['champs_diff']);
$this->diff_champs_nom = array_merge($this->champs_nom, $this->champs_diff);
}
private function ajouterMessage($message) {
$titre = self::SCRIPT_NOM.' #'.$this->traitement['id_traitement'];
$this->messages[] = array('message' => $message, 'resultat' => true);
}
private function remplacerTabulation($doc) {
if (is_string($doc)) {
$doc = str_replace("\t", ' ', $doc);
} else if (is_array($doc) && count($doc) > 0) {
foreach ($doc as $cle => $valeur) {
$doc[$cle] = $this->remplacerTabulation($valeur);
}
}
return $doc;
}
private function remplacerSautsDeLigne($doc) {
if (is_string($doc)) {
$a_remplacer = array("\r", "\n");
$doc = str_replace($a_remplacer, ' ', $doc);
} else if (is_array($doc) && count($doc) > 0) {
foreach ($doc as $cle => $valeur) {
$doc[$cle] = $this->remplacerSautsDeLigne($valeur);
}
}
return $doc;
}
private function ecrireComplementFichierBdnt($fichier_chemin) {
if (file_exists($fichier_chemin)) {
$this->ajouterMessage("Écriture du fichier bdnt réussie.");
$this->signature_md5 = md5_file($fichier_chemin);
$this->ajouterMessage("Signature MD5 du fichier bdnt :".$this->signature_md5);
$this->ajouterMessage("Nombre de combinaisons traitées : ".$this->noms_stat['combinaison']);
}
}
private function getBaseNomFichier() {
return strtolower($this->meta['acronyme'].'_v'.str_replace('.', '_', $this->meta['version']));
}
private function creerFichierBdntPartiel(&$donnees) {
$this->definirChampsPartiel();
$this->creerCorrespondanceRangBdntTaxref();
$this->creerCorrespondanceStatutBdntTaxref();
Debug::printr(current($donnees['noms']));
$donnees['champs_partiel'] = $this->champs_nom_partiel;
$donnees['dernier_champ'] = end($this->champs_nom_partiel);
$this->ecrireFichierBdntPartielle($donnees);
}
private function definirChampsPartiel() {
$this->champs_nom_partiel = explode(',', $this->manuel['champs_partiel']);
$champs_taxref = explode(',', $this->manuel['champs_taxref']);
$this->champs_nom_partiel = array_merge($this->champs_nom_partiel, $champs_taxref);
Debug::printr("Champs partiels : ".print_r($this->champs_nom_partiel,true));
}
private function creerCorrespondanceRangBdntTaxref() {
$rangs = explode(',', $this->manuel['rangs_bdnt_taxref']);
foreach ($rangs as $rang) {
list($id_bdnt, $code_taxref) = explode(':', trim($rang));
$this->rangs_bdnt_taxref[$id_bdnt] = $code_taxref;
}
}
private function creerCorrespondanceStatutBdntTaxref() {
$statuts = explode(',', $this->manuel['statuts_bdnt_taxref']);
foreach ($statuts as $statut) {
list($code_taxref, $champ_et_code_bdnt) = explode('=', trim($statut));
list($nom_champ_bdnt, $code_bdnt) = explode(':', trim($champ_et_code_bdnt));
$this->statuts_bdnt_taxref[$nom_champ_bdnt][$code_bdnt] = $code_taxref;
}
Debug::printr($this->statuts_bdnt_taxref);
}
private function ecrireFichierBdntPartielle(&$donnees) {
$fichier_nom = $this->getBaseNomFichier().$this->manuel['suffixe_bdnt'].$this->manuel['suffixe_partiel'].$this->manuel['ext_fichier'];
$fichier_chemin = $this->zip_chemin_dossier_partiel.$fichier_nom;
$bdnt_tsv_entete = $this->getVue('versionnage/squelettes/bdnt_partiel_entete', array('champs_partiel' => $donnees['champs_partiel']), '.tpl.tsv');
$this->ecrireFichier($fichier_chemin, $bdnt_tsv_entete);
foreach ($this->noms as $id => &$nom) {
$donnees['nom_infos'] = $nom;
// Ajout de champs spécifique à Taxref généré depuis les données BDNT
$donnees['nom_infos']['taxref_rang'] = $this->attribuerRangTaxref($nom['rang']);
$donnees['nom_infos']['taxref_statut'] = $this->attribuerStatutTaxref($nom);
$bdnt_tsv_ligne = $this->getVue('versionnage/squelettes/bdnt_partiel_ligne', $donnees, '.tpl.tsv');
if ($bdnt_tsv_ligne != '') {
$this->ajouterAuFichier($fichier_chemin, $bdnt_tsv_ligne);
}
}
if (file_exists($fichier_chemin)) {
$this->ajouterMessage("Écriture du fichier de la bdnt partielle réussie.");
$this->signature_md5_partiel = md5_file($fichier_chemin);
$this->ajouterMessage("Signature MD5 du fichier bdnt partiel :".$this->signature_md5_partiel);
$this->ajouterMessage("Nombre de combinaisons traitées : ".$this->noms_stat['combinaison']);
}
}
private function attribuerRangTaxref($rang) {
$rang_taxref = '';
if (isset($this->rangs_bdnt_taxref[$rang])) {
$rang_taxref = $this->rangs_bdnt_taxref[$rang];
}
return $rang_taxref;
}
private function attribuerStatutTaxref($nom) {
$statut_taxref = '';
$champs_statuts = array('presence', 'statut_origine', 'statut_introduction', 'statut_culture');
foreach ($champs_statuts as $champ) {
$valeur = trim($nom[$champ]);
if (isset($this->statuts_bdnt_taxref[$champ][$valeur])) {
$statut_taxref = $this->statuts_bdnt_taxref[$champ][$valeur];
}
}
return $statut_taxref;
}
private function ecrireFichier($fichier_chemin, &$contenu) {
$retour = true;
if (file_put_contents($fichier_chemin, $contenu) == false) {
$e = "Une erreur est survenu lors de l'écriture du fichier : $fichier_chemin";
$this->ajouterMessage($e);
$retour = false;
}
$contenu = null;
return $retour;
}
private function ajouterAuFichier($fichier_chemin, &$contenu) {
$retour = true;
if (file_put_contents($fichier_chemin, $contenu, FILE_APPEND) == false) {
$e = "Une erreur est survenu lors de l'ajout de données dans le fichier : $fichier_chemin";
$this->ajouterMessage($e);
$retour = false;
}
$contenu = null;
return $retour;
}
private function creerFichierDiff() {
$donnees = array();
$this->derniere_meta = $this->metaDao->getDerniere($this->projet);
if (is_null($this->derniere_meta === false)) {
$this->ajouterMessage("Un problème est survenu lors de la récupération des métadonnées précédentes.");
} else if (is_null($this->derniere_meta)) {
$this->ajouterMessage("Premier versionnage pour ce projet, aucun fichier différentiel ne sera créé.");
} else {
$code_projet_precedent = strtolower($this->derniere_meta['code']).'_v'.str_replace('.', '_', $this->derniere_meta['version']);
if ($code_projet_precedent == $this->version_courante) {
$e = "La code de la version préalablement versionnée ($code_projet_precedent) est le même que celui ".
"de la demande actuel ({$this->version_courante}) pour ce projet, aucun fichier différentiel ne sera créé.";
$this->ajouterMessage($e);
} else {
$this->noms_precedents = $this->referentielDao->getTout($code_projet_precedent);
$donnees['diff'] = $this->realiserDiff();
$donnees['champs'] = $this->diff_champs_nom;
$diff_tsv =& $this->getVue('versionnage/squelettes/diff', &$donnees, '.tpl.tsv');
$this->ecrireFichierDiff($diff_tsv);
}
}
return $donnees;
}
private function realiserDiff() {
$this->chargerTableauChampsModifTypes();
$this->noms_stat['modification'] = 0;
$this->verifierNomsSupprimes();
$this->champs_courants = $this->champs_nom;
$diff = array();
foreach ($this->noms as $id => $nom) {
$this->supprimerNomAExclurePartiel($this->noms, $id);
$infos = array();
if ($this->etreSupprime($id)) {
$infos = $this->traiterDiffSuppression($nom);
} else if ($this->etreAjoute($id)) {
$infos = $this->traiterDiffAjout($nom);
} else {
$nom_precedent = $this->noms_precedents[$id];
$this->supprimerNomAExclurePartiel($this->noms_precedents, $id);
$nom_precedent = $this->nettoyerEspacesTableau($nom_precedent);
$infos = $this->traiterDiffModif($nom, $nom_precedent);
}
if (count($infos) > 0) {
$this->noms_stat['modification']++;
$infos = $this->remplacerTabulation($infos);
$infos = $this->remplacerSautsDeLigne($infos);
$diff[$id] = $infos;
}
}
return $diff;
}
private function verifierNomsSupprimes($edition = '«Complète»') {
$this->noms_supprimes = array_diff_key($this->noms_precedents, $this->noms);
$e = count($this->noms_supprimes)." lignes ont été supprimées vis à vis de la version ".
"précédentes pour l'édition $edition. Cela concerne les noms : ".implode(', ', array_keys($this->noms_supprimes));
Debug::printr($e);
$this->ajouterMessage($e);
}
private function supprimerNomAExclurePartiel(&$tableau, $id) {
if ($tableau[$id]['exclure_taxref'] == '1') {
unset($tableau[$id]);
}
}
private function nettoyerNomAExclurePartiel($nom) {
foreach ($nom as $champ => $valeur) {
if (! in_array($champ, $this->champs_nom_partiel)) {
unset($nom[$champ]);
}
}
return $nom;
}
private function etreSupprime($id) {
$supprime = false;
if (array_key_exists($id, $this->noms_supprimes)) {
$supprime = true;
}
return $supprime;
}
private function traiterDiffSuppression(&$nom) {
$infos = $nom;
$infos['modification_type'] = 'S';
$infos['modification_type_1'] = '0';
$infos['modification_type_2'] = '0';
$infos['modification_type_3'] = '0';
return $infos;
}
private function etreAjoute($id) {
$ajoute = false;
if (! array_key_exists($id, $this->noms_precedents)) {
$ajoute = true;
}
return $ajoute;
}
private function nettoyerEspacesTableau($tableau) {
array_walk($tableau, create_function('&$val', '$val = trim($val);'));
return $tableau;
}
private function traiterDiffAjout(&$nom) {
$infos = $nom;
$infos['modification_type'] = 'A';
$infos['modification_type_1'] = '0';
$infos['modification_type_2'] = '0';
$infos['modification_type_3'] = '0';
return $infos;
}
private function traiterDiffModif(&$nom, &$nom_precedent) {
$infos = array();
$nom_diff = array_diff_assoc($nom, $nom_precedent);
if (count($nom_diff) > 0) {
$modif['modification_type'] = 'M';
$modif['modification_type_1'] = '0';
$modif['modification_type_2'] = '0';
$modif['modification_type_3'] = '0';
foreach ($this->champs_courants as $champ) {
if (isset($nom_diff[$champ])) {
// Si le champ modifié est vide nous retournons le mot clé "NULL" pour identifier le champ modifié
$infos[$champ] = ($nom_diff[$champ] != '') ? $nom_diff[$champ] : 'NULL';
$type = $this->getDiffType($champ);
$modif['modification_type_'.$type] = '1';
} else {
if ($champ == 'num_nom') {
$infos[$champ] = $nom[$champ];
} else {
$infos[$champ] = '';
}
}
}
foreach ($modif as $cle => $val) {
$infos[$cle] = $val;
}
}
return $infos;
}
private function chargerTableauChampsModifTypes() {
$champs = explode(',', $this->manuel['champs_diff_type']);
foreach ($champs as $champ) {
list($champ_nom, $type) = explode('=', trim($champ));
$this->diff_modif_types[$champ_nom] = $type;
}
}
private function getDiffType($champ_nom) {
$type = isset($this->diff_modif_types[$champ_nom]) ? $this->diff_modif_types[$champ_nom] : '3';
return $type;
}
private function ecrireFichierDiff(&$contenu) {
$fichier_nom = $this->getBaseNomFichier().$this->manuel['suffixe_diff'].$this->manuel['ext_fichier'];
$fichier_chemin = $this->zip_chemin_dossier.$fichier_nom;
if ($this->ecrireFichier($fichier_chemin, $contenu)) {
$this->ajouterMessage("Écriture du fichier diff réussie.");
}
}
private function creerFichierDiffPartiel(&$donnees) {
$this->noms_stat_partiel['modification'] = 0;
if (! is_null($this->derniere_meta) && $this->derniere_meta !== false) {
$donnees['diff_partiel'] = $this->realiserDiffPartiel();
$donnees['champs_partiel_diff'] = array_merge($this->champs_nom_partiel, $this->champs_diff);
$donnees['dernier_champ'] = end($donnees['champs_partiel_diff']);
$diff_tsv_partiel =& $this->getVue('versionnage/squelettes/diff_partiel', &$donnees, '.tpl.tsv');
$this->ecrireFichierDiffPartiel($diff_tsv_partiel);
} else {
$this->ajouterMessage("Aucun fichier différentiel pour l'édition «Partielle» ne sera créé.");
}
}
private function realiserDiffPartiel() {
$this->noms_stat_partiel['modification'] = 0;
$this->champs_courants = $this->champs_nom_partiel;
$this->verifierNomsSupprimes('«Partielle»');
$diff = array();
foreach ($this->noms as $id => $nom) {
unset($this->noms[$id]);
// Ajout de champs spécifique à Taxref généré depuis les données BDNT
$nom['taxref_rang'] = $this->attribuerRangTaxref($nom['rang']);
$nom['taxref_statut'] = $this->attribuerStatutTaxref($nom);
$nom = $this->nettoyerNomAExclurePartiel($nom);
$infos = array();
if ($this->etreSupprime($id)) {
$infos = $this->traiterDiffSuppression($nom);
} elseif ($this->etreAjoute($id)) {
$infos = $this->traiterDiffAjout($nom);
} else {
$nom_precedent = $this->noms_precedents[$id];
unset($this->noms_precedents[$id]);
// Ajout de champs spécifique à Taxref généré depuis les données BDNT
$nom_precedent['taxref_rang'] = $this->attribuerRangTaxref($nom_precedent['rang']);
$nom_precedent['taxref_statut'] = $this->attribuerStatutTaxref($nom_precedent);
$nom_precedent = $this->nettoyerNomAExclurePartiel($nom_precedent);
$nom_precedent = $this->nettoyerEspacesTableau($nom_precedent);
$infos = $this->traiterDiffModif($nom, $nom_precedent);
}
if (count($infos) > 0) {
$this->noms_stat_partiel['modification']++;
$infos = $this->remplacerTabulation($infos);
$infos = $this->remplacerSautsDeLigne($infos);
$diff[$id] = $infos;
}
}
return $diff;
}
private function ecrireFichierDiffPartiel(&$contenu) {
$fichier_nom = $this->getBaseNomFichier().$this->manuel['suffixe_diff'].$this->manuel['suffixe_partiel'].$this->manuel['ext_fichier'];
$fichier_chemin = $this->zip_chemin_dossier_partiel.$fichier_nom;
if ($this->ecrireFichier($fichier_chemin, $contenu)) {
$this->ajouterMessage("Écriture du fichier diff partiel réussie.");
}
}
private function creerFichierMeta() {
$donnees = array();
$donnees = $this->meta;
$donnees['stats'] = $this->noms_stat;
$donnees['signature'] = $this->signature_md5;
$donnees = $this->remplacerTabulation($donnees);
$donnees = $this->remplacerSautsDeLigne($donnees);
$meta_tsv =& $this->getVue('versionnage/squelettes/meta', &$donnees, '.tpl.tsv');
$this->ecrireFichierMeta($meta_tsv);
return $donnees;
}
private function ecrireFichierMeta(&$contenu) {
$fichier_nom = $this->getBaseNomFichier().$this->manuel['suffixe_meta'].$this->manuel['ext_fichier'];
$fichier_chemin = $this->zip_chemin_dossier.$fichier_nom;
if ($this->ecrireFichier($fichier_chemin, $contenu)) {
$this->ajouterMessage("Écriture du fichier meta réussie.");
$this->archiverMetadonnees();
}
}
private function creerFichierMetaPartiel(&$donnees) {
$donnees['signature'] = $this->signature_md5_partiel;
$donnees['stats'] = $this->noms_stat_partiel;
$donnees['notes'] = trim($this->manuel['notes_partiel'].' '.$donnees['notes']);
$meta_tsv_partiel =& $this->getVue('versionnage/squelettes/meta', &$donnees, '.tpl.tsv');
$this->ecrireFichierMetaPartiel($meta_tsv_partiel);
}
private function ecrireFichierMetaPartiel(&$contenu) {
$fichier_nom = $this->getBaseNomFichier().$this->manuel['suffixe_meta'].$this->manuel['suffixe_partiel'].$this->manuel['ext_fichier'];
$fichier_chemin = $this->zip_chemin_dossier_partiel.$fichier_nom;
if ($this->ecrireFichier($fichier_chemin, $contenu)) {
$this->ajouterMessage("Écriture du fichier meta partiel réussie.");
}
}
private function archiverMetadonnees() {
$metadonnees = $this->meta;
$metadonnees['code'] = $this->meta['acronyme'];
unset($metadonnees['acronyme']);
$metadonnees['domaine_taxo'] = $this->meta['dom_tax'];
unset($metadonnees['dom_tax']);
$metadonnees['domaine_geo'] = $this->meta['dom_geo'];
unset($metadonnees['dom_geo']);
$metadonnees['domaine_nom'] = $this->meta['dom_code'];
unset($metadonnees['dom_code']);
$metadonnees['auteur'] = $this->meta['auteur_principal'];
unset($metadonnees['auteur_principal']);
$metadonnees['date_production'] = $this->meta['date_prod'];
unset($metadonnees['date_prod']);
$metadonnees['droit'] = $this->meta['copyright'];
unset($metadonnees['copyright']);
$ok = $this->metaDao->ajouter($metadonnees);
if ($ok === false) {
$this->ajouterMessage("L'archivage des métadonnées a échoué.");
}
}
private function nettoyerMemoire() {
$this->noms = null;
$this->noms_precedents = null;
$this->noms_stat = null;
}
private function copierManuel() {
$fichier_source = $this->manuel_chemin.$this->manuel_nom;
$fichiers_destination[] = $this->zip_chemin_dossier.$this->manuel_nom;
$fichiers_destination[] = $this->zip_chemin_dossier_partiel.$this->manuel_nom;
foreach ($fichiers_destination as $destination) {
if (copy($fichier_source, $destination) === false) {
$this->ajouterMessage("La copie du manuel vers '$destination' a échouée.");
}
}
}
private function creerFichiersZip() {
$this->zipper($this->zip_chemin_fichier, $this->zip_chemin_dossier);
$this->zipper($this->zip_chemin_fichier_partiel, $this->zip_chemin_dossier_partiel);
}
private function zipper($fichier_zip, $dossier_a_zipper) {
$zip = new PclZip($fichier_zip);
if ($zip->add($dossier_a_zipper, PCLZIP_OPT_REMOVE_ALL_PATH) == 0) {
$e = "La création du fichier zip '$fichier_zip' a échoué avec l'erreur : ".$zip->errorInfo(true);
$this->ajouterMessage($e);
}
}
private function nettoyerFichiers() {
Fichier::supprimerDossier($this->zip_chemin_dossier);
Fichier::supprimerDossier($this->zip_chemin_dossier_partiel);
}
private function traiterMessages() {
if (isset($this->messages)) {
$num_message = 1;
foreach ($this->messages as $message) {
$message['nom'] = 'Message #'.$num_message++;
$this->resultatDao->ajouter($this->traitement['id_traitement'], $message);
}
}
}
}
?>

/branches/v2.0-betulales/scripts/modules/tests/Tests.php
New file
0,0 → 1,2095
<?php
// Encodage : UTF-8
// +-------------------------------------------------------------------------------------------------------------------+
/**
* Tests de référentiels de nomenclature et taxonomie
*
* Description : classe permettant de tester les référentiels selon le manuel technique
* Utilisation : php script.php tests -p bdnff -a tout
*
//Auteur original :
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Tela-Botanica 1999-2010
* @link http://www.tela-botanica.org/wikini/RTaxMethodo/wakka.php?wiki=MaNuel
* @licence GPL v3 & CeCILL v2
* @version $Id$
*/
// +-------------------------------------------------------------------------------------------------------------------+
// TODO : supprimer l'utilisation du paramêtres 'p' et chercher les infos depuis la bdd
class Tests extends ScriptCommande {
const SCRIPT_NOM = 'tests';
const MANUEL_VERSION = '4.4';
private $projet = null;
private $traitement = null;
private $manuel = null;
private $manuel_nom = null;
private $manuel_chemin = null;
private $tests = null;
private $colonnes = null;
private $analyses = null;
private $noms = null;
private $erreurs = array();
private $resultatDao = null;
private $traitementDao = null;
private $tableStructureDao = null;
private $referentielDao = null;
public function executer() {
$this->manuel_nom = 'mtpr_v'.str_replace('.', '_', self::MANUEL_VERSION).'.pdf';
$this->manuel_chemin = Config::get('chemin_appli').DS.'..'.DS.'configurations'.DS;
$manuel_config_nom = 'referentiel_v'.self::MANUEL_VERSION.'.ini';
$this->manuel = parse_ini_file($this->manuel_chemin.$manuel_config_nom);
$this->definirConstantes();
$this->tests = parse_ini_file($this->getModuleChemin().DS.'configurations'.DS.'tests.ini', true);
$this->resultatDao = new ResultatDao();
$this->traitementDao = new TraitementDao();
Debug::printr('Dans le script test');
// Récupération du dernier traitement demandé
$this->traitement = $this->traitementDao->getDernierTraitement('tout', self::SCRIPT_NOM);
if (isset($this->traitement)) {
$this->projet = $this->traitement['referentiel_code']; // Récupération du nom de projet
Debug::printr($this->traitement);
// Écriture de la date de début du traitement
Debug::printr('Debute:'.$this->traitementDao->debuterTraitement($this->traitement['id_traitement']));
// Nettoyage des traitements obsolètes
$traitements_obsoletes = $this->traitementDao->getTraitementsObsoletes($this->projet, self::SCRIPT_NOM);
if (isset($traitements_obsoletes)) {
Debug::printr('Supp. obsoletes:'.$this->traitementDao->supprimer($traitements_obsoletes));
}
$this->tableStructureDao = new TableStructureDao();
$this->referentielDao = new ReferentielDao();
// Lancement du test demandé
$cmd = $this->getParam('a');
switch ($cmd) {
case 'tout' :
Debug::printr('Départ lancement test:');
$this->recupererDonnees();
$this->lancerTestsAuto();
break;
case 'test14' :
$this->recupererDonnees();
Debug::printr('Départ lancement test 14 :');
$this->testerClassificationRang();
break;
default :
$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
}
// Écriture de la date de fin du traitement
Debug::printr('Termine:'.$this->traitementDao->terminerTraitement($this->traitement['id_traitement']));
} else {
Debug::printr("Aucun dernier traitement trouvé pour le script '".self::SCRIPT_NOM."' !");
}
}
/**
* Cette méthode définie des constantes qui peuvent ensuite être utilisée dans les fichier ini.
* Surtout utile pour le fichier tests.ini
*/
private function definirConstantes() {
define('RANG_GENRE', $this->manuel['rang_genre']);
define('RANG_SP', $this->manuel['rang_sp']);
date_default_timezone_set('Europe/Berlin');
define('ANNEE_EN_COURS', date('Y'));
define('ANNEE_MINIMUM', 1753);
}
public function recupererDonnees() {
// Récupération des données à tester
$this->colonnes = $this->tableStructureDao->getColonnes($this->projet);
$this->analyses = $this->tableStructureDao->getAnalyse($this->projet);
$this->noms = $this->referentielDao->getTout($this->projet);
Debug::printr('Nbre noms :'.count($this->noms));
}
public function lancerTestsAuto() {
$resultats = array();
// Lancement des tests unitaires
Debug::printr('Lancement des tests unitaires');
$tests_numeros = array_keys($this->tests);
Debug::printr($tests_numeros);
foreach ($tests_numeros as &$numero) {
$info = $this->getInfosTest($numero);
if ($numero < 5) {
// Tests spéciaux vérifiant la structure de la table
$resultats[] = $this->lancerTestUnitaire($info);
} else if ($numero >= 5 && $this->verifierResultats($resultats)) {
// Si la structure est bonne nous lançons les autres tests
$this->lancerTestUnitaire($info);
}
}
$info = $this->construireTotalErreur();
$this->traiterResultatTest($info);
}
private function getInfosTest($numero) {
$info = $this->tests[$numero];
$info['methode'] = 'tester'.implode('', explode(' ', ucwords($info['abr'])));
$info['numero'] = $numero;
$info['nom'] = '#'.$numero.' - '.$info['nom'];
$info['resultat'] = false;
return $info;
}
public function lancerTestUnitaire($info) {
Debug::printr($info['numero'].'::'.$info['methode']);
$methodeDeTest = $info['methode'];
$erreurs = $this->$methodeDeTest();
// Analyse des résultats
if (isset($erreurs['special'])) {
$info = $erreurs;
} else {
$info = $this->construireResultatErreur($erreurs, $info);
}
$this->traiterResultatTest($info);
if ($info['numero'] < 5) {
return ($info['resultat'] ? '1' : '0');
}
}
private function ajouterNumNomErreursTest($num_nom) {
if (count($this->erreurs) < 1000) {
if (isset($this->erreurs[$num_nom])) {
$this->erreurs[$num_nom] += 1;
} else {
$this->erreurs[$num_nom] = 1;
}
}
}
private function construireResultatErreur($erreurs, $info) {
if (count($erreurs) > 0) {
$info['message']['entete'] = explode(',', $info['entete']);
if (isset($info['title'])) {
$info['message']['title'] = explode(';', $info['title']);
}
$info['message']['lignes'] = $erreurs;
unset($erreurs);
} else {
$info['resultat'] = true;
}
return $info;
}
private function construireTotalErreur() {
if (count($this->erreurs) > 0) {
arsort($this->erreurs);
$info['abr'] = "erreurs par num_nom";
$info['nom'] = "erreurs -> num_nom";
$info['description'] = "nombre d'erreurs détecté par num_nom";
$info['numero'] = "0";
$info['message']['entete'] = array('num_nom', "nombre d'erreurs");
foreach ($this->erreurs as $num_nom=>$nombre) {
$erreurs[] = array(0 => $num_nom, 1 => $nombre);
}
$info['message']['lignes'] = $erreurs;
unset($this->erreurs);
} else {
$info['resultat'] = true;
}
return $info;
}
private function verifierResultats(&$resultats) {
$ok = true;
foreach ($resultats as $resultat) {
if ($resultat == '0') {
$ok = false;
break;
}
}
return $ok;
}
private function traiterResultatTest($info) {
if (isset($info['message'])) {
if (is_array($info['message'])) {
$erreurs_nbre = count($info['message']['lignes']);
$erreurs_max = 1000;
if ($erreurs_nbre > $erreurs_max) {
$info['message']['lignes'] = array_slice($info['message']['lignes'], 0, $erreurs_max);
$info['erreur'] = "$erreurs_nbre erreurs ont été détectées seules les $erreurs_max premières sont affichées";
}
$info['message'] = $this->getVue('tests/squelettes/message_table', $info);
} else {
$info['message'] = $this->getVue('tests/squelettes/message_p', $info);
}
}
Debug::printr($this->resultatDao->ajouter($this->traitement['id_traitement'], $info));
$info = null;
}
//+--------------------------------------------------------------------------------------------------------------+//
// TESTS
/**
* Test #01
*/
private function testerNombreDeChamps() {
$info = $this->getInfosTest(1);
$info['special'] = true;
$nbre_colonnes = count($this->colonnes);
$info['message'] = $nbre_colonnes;
if ($nbre_colonnes >= 37) {
$info['resultat'] = true;
}
return $info;
}
/**
* Test #02
*/
private function testerNomDesChamps() {
$info = $this->getInfosTest(2);
$info['special'] = true;
$champs_attendus = explode(',', $this->manuel['champs']);
$champs_presents = array();
foreach ($this->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'] = sprintf($info['message'], implode(', ', $champs_manquant));
}
return $info;
}
/**
* Test #03
*/
private function testerTypeDesChamps() {
$champs_attendus = explode(',', $this->manuel['champs_type']);
$champs_presents = array();
foreach ($this->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_taille) = explode('=', trim($champ_attendu));
list($champ_attendu_type, $champ_attendu_taille) = explode('|', trim($champ_attendu_type_taille));
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[] = array($champ_attendu, $champ_attendu_type, $champs_present_type);
}
}
}
return $champs_erreur;
}
/**
* Test #04
*/
private function testerNumNomClePrimaire() {
$info = $this->getInfosTest(4);
$info['special'] = true;
foreach ($this->colonnes as &$colonne) {
if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') {
$info['resultat'] = true;
break;
}
}
return $info;
}
/**
* Test #05
*/
private function testerTailleDesChamps() {
$tailles_champs_maxi = array();
foreach ($this->colonnes as &$colonne) {
if (preg_match('/^varchar\(([0-9]+)\)$/', $colonne['Type'], $match)) {
$tailles_champs_maxi[$colonne['Field']] = $match[1];
}
}
$tailles_trouvees = array();
foreach ($this->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[] = array($champ_attendu, $tailles_champs_maxi[$champ_attendu], $tailles_trouvees[$champ_attendu]);
}
}
}
return $champs_erreur;
}
/**
* Test #06
*/
private function testerNumNomSuperieurAZero() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_nom'] <= 0) {
$noms_erreur[] = array($nom['num_nom']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
return $noms_erreur;
}
/**
* Test #07
*/
private function testerNumNomRetenuSuperieurAZero() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_nom_retenu'] != '' && $nom['num_nom_retenu'] <= 0) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
return $noms_erreur;
}
/**
* Test #08
*/
private function testerExistenceNumNomRetenu() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_nom_retenu'] != '' && $nom['num_nom_retenu'] != $nom['num_nom']) {
if ($nom['num_nom_retenu'] != 0 && !isset($this->noms[$nom['num_nom_retenu']])) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #09
*/
private function testerTransmissionNumNomRetenu() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_nom_retenu'] != $nom['num_nom'] && $nom['exclure_taxref'] == 0) {
if ($nom['num_nom_retenu'] != 0 && isset($this->noms[$nom['num_nom_retenu']])) {
if ($this->noms[$nom['num_nom_retenu']]['exclure_taxref'] != 0) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $this->noms[$nom['num_nom_retenu']]['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
}
return $noms_erreur;
}
/**
* Test #10
*/
private function testerSynonymeNumNomRetenu() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_nom_retenu'] != $nom['num_nom']) {
if ($nom['num_nom_retenu'] != 0 && isset($this->noms[$nom['num_nom_retenu']])) {
if ($this->noms[$nom['num_nom_retenu']]['num_nom'] != $this->noms[$nom['num_nom_retenu']]['num_nom_retenu']) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $this->noms[$nom['num_nom_retenu']]['num_nom_retenu']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
}
return $noms_erreur;
}
/**
* Test #11
*/
private function testerDoublonsNomSci() {
$noms_erreur = array();
$noms_complets = array();
foreach ($this->noms as &$nom) {
$a = $nom['nom_sci']." ".$nom['auteur']." ".$nom['nom_addendum']." ".$nom['biblio_origine'];
if (isset($noms_complets[$a])) {
$noms_erreur[] = array($nom['num_nom'], $a, $noms_complets[$a], $nom['exclure_taxref'], $nom['homonyme']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
} else {
$noms_complets[$a] = $nom['num_nom'];
}
}
return $noms_erreur;
}
/**
* Test #12
*/
private function testerNumTaxSupEgalZeroUnique() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if (preg_match('/^0$/', $nom['num_tax_sup'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
// Ce test est spécial car le nombre de noms en erreurs doit être supérieur à 1 et non à 0 pour être KO.
if (count($noms_erreur) == 1) {
$noms_erreur = array();
}
return $noms_erreur;
}
/**
* Test #13
*/
private function testerTaxSupPourTaxon() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_nom_retenu'] != $nom['num_nom'] && $nom['num_tax_sup'] != '') {
$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
return $noms_erreur;
}
/**
* Test #14
*/
private function testerExistenceTaxonSuperieur() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_nom_retenu'] == $nom['num_nom']) {
if ($nom['num_tax_sup'] != 0 && !isset($this->noms[$nom['num_tax_sup']])) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #15
*/
private function testerClassificationEspece() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['rang'] == 290) {
if (isset($this->noms[$nom['num_tax_sup']])) {
$nom_sup = $this->noms[$nom['num_tax_sup']];
if ($nom_sup['rang'] != 220 ) {
$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom_sup['num_nom'], $nom_sup['rang'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
}
return $noms_erreur;
}
/**
* Test #16
*/
private function testerTransmissionTaxonSuperieur() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0) {
if ($nom['num_tax_sup'] != 0 && isset($this->noms[$nom['num_tax_sup']])) {
if ($this->noms[$nom['num_tax_sup']]['exclure_taxref'] != 0) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $this->noms[$nom['num_tax_sup']]['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
}
return $noms_erreur;
}
/**
* Test #17
*/
private function testerClassificationRang() {
$noms_erreur = array();
//$rangs = explode(',', $this->manuel['rangs']);
foreach ($this->noms as &$nom) {
if ($nom['num_nom_retenu'] == $nom['num_nom']) {
if (isset($this->noms[$nom['num_tax_sup']])) {
$nom_sup = $this->noms[$nom['num_tax_sup']];
//$num_rang = array_search($nom['rang'], $rangs);
if ($nom_sup['rang'] >= $nom['rang']) {
//if ($nom_sup['rang'] != $rangs[$num_rang-1] ) {
// Prise en compte de l'exception des clades
if (! ($nom_sup['rang'] == 70 && $nom['rang'] == 70)) {
$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom_sup['num_nom'], $nom_sup['rang'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
}
}
return $noms_erreur;
}
/**
* Test #18
*/
private function testerClassification() {
$noms_erreur = array();
$this->noms_ok = array();
foreach ($this->noms as &$nom) {
if ($nom['num_nom_retenu'] == $nom['num_nom']) {
if (isset($this->noms_ok[$nom['num_tax_sup']])) {
$this->noms_ok[$nom['num_nom']] = true;
} else {
$this->detection_boucle_infini = array();
$classif_ok = $this->remonterClassif($nom);
unset($this->detection_boucle_infini);
if ($classif_ok === true) {
$this->noms_ok[$nom['num_nom']] = $classif_ok;
} else {
$noms_erreur[] = array($nom['num_nom'], $classif_ok, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
}
unset($this->noms_ok);
return $noms_erreur;
}
private function remonterClassif(&$nom) {
$this->detection_boucle_infini[$nom['num_nom']] = true;
if (preg_match('/^[0-9]*$/', $nom['num_tax_sup'])) {
if (isset($this->noms_ok[$nom['num_tax_sup']])) {
$this->noms_ok[$nom['num_nom']] = true;
return true;
} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') {
$this->noms_ok[$nom['num_nom']] = true;
return true;
} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') {
return 'Hiérarchie avec le taxon #'.$nom['num_nom'].' ayant un taxon superieur #'.$nom['num_tax_sup'].' inexistant';
} else if (isset($this->detection_boucle_infini[$nom['num_tax_sup']])) {
return 'Boucle infinie pour le taxon #'.$nom['num_tax_sup'];
} else {
$retour = $this->remonterClassif($this->noms[$nom['num_tax_sup']]);
if ($retour === true) {
$this->noms_ok[$nom['num_tax_sup']] = true;
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
return $retour;
}
} else {
return 'Valeur num_tax_sup incorrecte : '.$nom['num_tax_sup'];
}
}
/**
* Test #19
*/
private function testerRang() {
$rangs = array_flip(explode(',', $this->manuel['rangs']));
// Réalisation du test
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if (!isset($rangs[$nom['rang']])) {
$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
return $noms_erreur;
}
/**
* Test #20
*/
private function testerNomCompletSupraGenerique() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['rang'] < $this->manuel['rang_genre']) {
$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
$nom_sci_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']);
$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
if ($nom['nom_sci'] != $nom_sci_ideal) {
$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #21
*/
private function testerNomCompletGenre() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['rang'] == $this->manuel['rang_genre']) {
$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
if ($nom['nom_sci'] != $nom_sci_ideal) {
$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #22
*/
private function testerNomCompletInfraGenre() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) {
$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
$nom_sci_ideal = '';
if ($nom['type_epithete'] == 'agg.') {
$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '.
$this->formaterStyleNomGenre($nom['epithete_infra_generique']).' '.
$nom['type_epithete'];
} else {
$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '.
$nom['type_epithete'].' '.
$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
}
$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
if ($nom['nom_sci'] != $nom_sci_ideal) {
$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #23
*/
private function testerNomCompletEspece() {
$noms_erreur = array();
$erreur = '';
foreach ($this->noms as &$nom) {
if ($nom['rang'] == $this->manuel['rang_sp']) {
$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' ';
if (strstr($nom['nom_sci'] , ' x ') != false) {
list($nom_sci_ideal, $erreur) = $this->formaterStyleEpitheteSpHybride($nom_sci_ideal, $nom['epithete_sp']);
} else {
$nom_sci_ideal .= utf8_encode(strtolower(utf8_decode($nom['epithete_sp'])));
}
$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
$nom_sci_ideal = trim($nom_sci_ideal);
if ($nom['nom_sci'] != $nom_sci_ideal) {
$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $erreur, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #24
*/
private function testerNomCompletInfraSpecifique() {
$noms_erreur = array();
$erreur = null;
foreach ($this->noms as &$nom) {
if ($nom['rang'] > $this->manuel['rang_sp']) {
$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '.
utf8_encode(strtolower(utf8_decode($nom['epithete_sp']))).' '.
utf8_encode(strtolower(utf8_decode($nom['type_epithete']))).' ';
$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
if (strstr($nom['nom_sci'] , ' x ') != false) {
list($nom_sci_ideal, $erreur) = $this->formaterStyleEpitheteInfraSpHybride($nom_sci_ideal, $nom['epithete_infra_sp'], $nom['genre']);
} else {
$nom_sci_ideal .= utf8_encode(strtolower(utf8_decode($nom['epithete_infra_sp'])));
}
$nom_sci_ideal = trim($nom_sci_ideal);
$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
if ($nom['nom_sci'] != $nom_sci_ideal) {
$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $erreur, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #25
*/
private function testerNomSupraGeneriqueEspaces() {
$noms_erreur = array();
foreach ($this->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, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #26
*/
private function testerNomSupraGeneriqueSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['nom_supra_generique'] != '') {
if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) {
$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #27
*/
private function testerNomSupraGeneriqueRang() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['nom_supra_generique'] != '') {
if ($nom['rang'] >= $this->manuel['rang_genre']) {
$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #28
*/
private function testerGenreEspaces() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['genre'] != '') {
if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) {
$nom_traite = $this->repererEspace($nom['genre']);
$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #29
*/
private function testerGenreSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['genre'] != '') {
$mots = explode(' ', $nom['genre']);
foreach ($mots as $mot) {
if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) {
$nom_traite = $this->repererEspace($nom['genre']);
$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
break;
}
}
}
}
return $noms_erreur;
}
/**
* Test #30
*/
private function testerGenreRang() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['genre'] != '') {
if ($nom['rang'] < $this->manuel['rang_genre']) {
$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #31
*/
private function testerEpitheteInfraGeneriqueSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['epithete_infra_generique'] != '') {
if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) {
$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #32
*/
private function testerEpitheteInfraGeneriqueRang() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['epithete_infra_generique'] != '') {
if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) {
$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #33
*/
private function testerEpitheteInfraGeneriqueEspaces() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['epithete_infra_generique'] != '') {
if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) {
$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #34
*/
private function testerEpitheteSpEspaces() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['epithete_sp'] != '') {
if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) {
$epithete_traite = $this->repererEspace($nom['epithete_sp']);
$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #35
*/
private function testerEpitheteSpSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['epithete_sp'] != '') {
$formule_hybridite = (strpos($nom['epithete_sp'], ' x ') !== false);
$mots = explode(' ', $nom['epithete_sp']);
foreach ($mots as $mot) {
// TODO: créer un test qui vérifie la formule d'hybridité en la reconstruisant à partir des parents
// afin que seuls des formules valides parviennent à la fonction
if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot) ||
($formule_hybridite && $this->verifierEpitheteGenre($mot) && !$this->verifierEstAbbreviationInfraSp($mot)))) {
$epithete_traite = $this->repererEspace($nom['epithete_sp']);
$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
break;
}
}
}
}
return $noms_erreur;
}
/**
* Test #36
*/
private function testerEpitheteSpRang() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['epithete_sp'] != '') {
if ($nom['rang'] < $this->manuel['rang_sp']) {
$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #37
*/
private function testerTypeEpitheteEspaces() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['type_epithete'] != '') {
if (preg_match('/\s+/', $nom['type_epithete'])) {
$valeur_traitee = $this->repererEspace($nom['epithete_sp']);
$noms_erreur[] = array($nom['num_nom'], $valeur_traitee, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #38
*/
private function testerTypeEpitheteSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['type_epithete'] != '') {
if (!$this->verifierTypeEpithete($nom['type_epithete'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #39
*/
private function testerTypeEpitheteHybridite() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['type_epithete'] != '') {
if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #40
*/
private function testerEpitheteInfraSpEspaces() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['epithete_infra_sp'] != '') {
if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) {
$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #41
*/
private function testerEpitheteInfraSpSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['epithete_infra_sp'] != '') {
$mots = explode(' ', $nom['epithete_infra_sp']);
$hybride_contient_abbreviation_infra_sp = false;
$formule_hybridite = (strpos($nom['epithete_infra_sp'], ' x ') !== false);
foreach ($mots as $mot) {
if($formule_hybridite && $this->verifierEstAbbreviationInfraSp($mot)) {
$hybride_contient_abbreviation_infra_sp = true;
}
$formule_hybridite_valide = $this->verifierEpitheteGenre($mot) || $this->verifierEpitheteSp($mot) || $hybride_contient_abbreviation_infra_sp;
if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot) || $this->verifierEpitheteSp($mot) ||
$formule_hybridite_valide)) {
$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
break;
}
}
if($formule_hybridite && !$hybride_contient_abbreviation_infra_sp) {
$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #42
*/
private function testerEpitheteInfraSpRang() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['epithete_infra_sp'] != '') {
if ($nom['rang'] < $this->manuel['rang_sp']) {
$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #43
*/
private function testerGroupeCultivarSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['cultivar_groupe'] != '') {
if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #44
*/
private function testerGroupeCultivarRang() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['cultivar_groupe'] != '') {
if ($nom['rang'] < $this->manuel['rang_genre']) {
$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #45
*/
private function testerCultivarSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['cultivar'] != '') {
if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
$epithete_traite = $this->repererEspace($nom['cultivar']);
$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #46
*/
private function testerCultivarRang() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['cultivar'] != '') {
if ($nom['rang'] < $this->manuel['rang_genre']) {
$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #47
*/
private function testerNomCommercialSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['nom_commercial'] != '') {
if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
$epithete_traite = $this->repererEspace($nom['nom_commercial']);
$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #48
*/
private function testerNomCommercialPresenceCultivar() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ((isset($nom['nom_commercial']) && $nom['nom_commercial'] != '') && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
return $noms_erreur;
}
/**
* Test #49
*/
private function testerAuteurSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['auteur'] != '') {
if (!$this->verifierAuteur($nom['auteur'])) {
$intitule_traite = $this->repererEspace($nom['auteur']);
$noms_erreur[] = array($nom['num_nom'], $intitule_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #50
*/
private function testerAnneeSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['annee'] != '') {
if (!$this->verifierAnnee($nom['annee'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['annee'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #51
*/
private function testerBiblioOrigineSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['biblio_origine'] != '') {
if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
$biblio_traite = $this->repererEspace($nom['biblio_origine']);
$noms_erreur[] = array($nom['num_nom'], $biblio_traite, $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #52
*/
private function testerHomonymieSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['homonyme'] != '') {
if (!$this->verifierBooleen($nom['homonyme'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['homonyme'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #53
*/
private function testerHomonymieExistence() {
$noms_homonymie = $this->classerNomsParNomComplet();
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
if ($noms_homonymie[$nom['nom_sci']] <= 1) {
$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
$noms_homonymie = null;
return $noms_erreur;
}
/**
* Test #54
*/
private function testerBasionymeSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_basionyme'] != '') {
if (!$this->verifierNombre($nom['num_basionyme'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_basionyme'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #55
*/
private function testerBasionymeExistence() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_basionyme'] != '') {
if (!isset($this->noms[$nom['num_basionyme']])) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_basionyme'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #56
*/
private function testerSynonymeProparteSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['synonyme_proparte'] != '') {
if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #57
*/
private function testerSynonymeProparteExistence() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['synonyme_proparte'] != '') {
$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
$num_nom_en_erreur = array();
foreach ($num_nom_a_verifier as $num_nom) {
if (!isset($this->noms[$num_nom])) {
$num_nom_en_erreur[] = $num_nom;
}
}
if (count($num_nom_en_erreur) > 0) {
$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur), $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #58
*/
private function testerSynonymeDouteuxSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['synonyme_douteux'] != '') {
if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #59
*/
private function testerSynonymeDouteuxNumNomRetenu() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['synonyme_douteux'] == 1 && !$this->verifierNombre($nom['num_nom_retenu'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
return $noms_erreur;
}
/**
* Test #60
*/
private function testerSynonymeDouteuxSynonyme() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['synonyme_douteux'] == 1 && $nom['num_nom'] == $nom['num_nom_retenu']) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
return $noms_erreur;
}
/**
* Test #61
*/
private function testerSynonymeMalAppliqueSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['synonyme_mal_applique'] != '') {
if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #62
*/
private function testerSynonymeMalAppliqueChampsAnnexe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['synonyme_mal_applique'] == 1) {
$erreur = true;
$erreur = ($nom['annee'] == "") ? false : $erreur;
$erreur = ($nom['biblio_origine'] == "") ? false : $erreur;
$erreur = (strpos($nom['auteur'], "sensu") === 0) ? $erreur : false;
if ($erreur == false) {
$noms_erreur[] = array($nom['num_nom'], $nom['auteur'], $nom['annee'], $nom['biblio_origine'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #63
*/
private function testerSynonymeMalAppliqueSynonyme() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['synonyme_mal_applique'] == 1 && $nom['num_nom'] == $nom['num_nom_retenu']) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
return $noms_erreur;
}
/**
* Test #64
*/
private function testerSynonymeOrthographiqueSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as $nom) {
if ($nom['synonyme_orthographique'] != '') {
if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #65
*/
private function testerSynonymeOrthographiqueExistence() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['synonyme_orthographique'] != '') {
if (!isset($this->noms[$nom['synonyme_orthographique']])) {
$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #66
*/
private function testerHybrideParent01Syntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['hybride_parent_01'] != '') {
if (!$this->verifierNombre($nom['hybride_parent_01'])) {
$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #67
*/
private function testerHybrideParent01Existence() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
if (!isset($this->noms[$nom['hybride_parent_01']])) {
$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #68
*/
private function testerHybrideParent02Syntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['hybride_parent_02'] != '') {
if (!$this->verifierNombre($nom['hybride_parent_02'])) {
$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #69
*/
private function testerHybrideParent02Existence() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['hybride_parent_02'] != '') {
if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #70
*/
private function testerNumTypeSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_type'] != '') {
if (!$this->verifierNombre($nom['num_type'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_type'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #71
*/
private function testerNumTypeExistence() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_type'] != '') {
if (!isset($this->noms[$nom['num_type']])) {
$noms_erreur[] = array($nom['num_nom'], $nom['num_type'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #72
*/
private function testerPresenceSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['presence'] != '') {
if (!$this->verifierPresence($nom['presence'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['presence'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #73
*/
private function testerPresenceExistence() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0) {
if ($nom['presence'] == "") {
$noms_erreur[] = array($nom['num_nom'],$nom['num_nom_retenu'], $nom['presence'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #74
*/
private function testerStatutOrigineSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['statut_origine'] != '') {
if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #75
*/
private function testerStatutIntroductionSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['statut_introduction'] != '') {
if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #76
*/
private function testerStatutCultureSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['statut_culture'] != '') {
if (!$this->verifierStatutCulture($nom['statut_culture'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #77
*/
private function testerExclureTaxRefSyntaxe() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['exclure_taxref'] != '' && $nom['exclure_taxref'] != null) {
if (!preg_match('/^(?:0|1|9)$/', $nom['exclure_taxref'])) {
$noms_erreur[] = array($nom['num_nom'], $nom['exclure_taxref']);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #78
*/
private function testerNomFrancaisUnique() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
if ($nom['nom_francais'] != '' && $nom['nom_francais'] != null) {
if (strpbrk($nom['nom_francais'],',;')) {
$noms_erreur[] = array($nom['num_nom'], $this->repererCaracteresInvalidesNomFrancais($nom['nom_francais']));
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
return $noms_erreur;
}
/**
* Test #79
*/
private function testerExclureTaxRefPresence() {
$noms_erreur = array();
foreach ($this->noms as &$nom) {
// On vérifie tous les noms retenu nom exclus de taxref de rang inférieur ou égal à l'espèce
if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0 && $nom['rang'] >= 240) {
if($nom['presence'] == '' || !$this->verifierPresence($nom['presence'])) {
if(($nom['statut_origine'] == '' || !$this->verifierStatutOrigine($nom['statut_origine'])) &&
($nom['statut_introduction'] == '' || !$this->verifierStatutIntroduction($nom['statut_introduction'])) &&
($nom['statut_culture'] == '' || !$this->verifierStatutCulture($nom['statut_culture'])))
{
$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'],
$this->mettreEnValeurAvertissement($nom['presence']),
$this->mettreEnValeurAvertissement($nom['statut_origine']),
$this->mettreEnValeurAvertissement($nom['statut_introduction']),
$this->mettreEnValeurAvertissement($nom['statut_culture'])
);
$this->ajouterNumNomErreursTest($nom['num_nom']);
} else {
//TODO: le comportement est identique mais il faudrait pouvoir afficher un avertissement
// si le champ présence n'est pas rempli mais que l'une des colonne de statut l'est
$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'],
$nom['presence'],
$this->mettreEnValeurAvertissement($nom['statut_origine']),
$this->mettreEnValeurAvertissement($nom['statut_introduction']),
$this->mettreEnValeurAvertissement($nom['statut_culture'])
);
$this->ajouterNumNomErreursTest($nom['num_nom']);
}
}
}
}
return $noms_erreur;
}
//+--------------------------------------------------------------------------------------------------------------+//
// MÉTHODES COMMUNES aux TESTS
private function verifierPresence(&$valeur) {
$codes = $this->manuel['codes_presence'];
$ok = $this->verifierStatuts($valeur, $codes);
return $ok;
}
private function verifierStatutOrigine(&$valeur) {
$codes = $this->manuel['codes_statuts_origine'];
$ok = $this->verifierStatuts($valeur, $codes);
return $ok;
}
private function verifierStatutIntroduction(&$valeur) {
$codes = $this->manuel['codes_statuts_introduction'];
$ok = $this->verifierStatuts($valeur, $codes);
return $ok;
}
private function verifierStatutCulture(&$valeur) {
$codes = $this->manuel['codes_statuts_culture'];
$ok = $this->verifierStatuts($valeur, $codes);
return $ok;
}
private function verifierStatuts(&$valeur, &$codes) {
$ok = true;
if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
$ok = false;
}
return $ok;
}
private function verifierBooleen(&$valeur) {
$ok = true;
if (!preg_match('/^1$/', $valeur)) {
$ok = false;
}
return $ok;
}
private function verifierNombre(&$valeur) {
$ok = true;
if (!preg_match('/^[0-9]+$/', $valeur)) {
$ok = false;
}
return $ok;
}
private function verifierNombreSuite(&$valeur) {
$ok = true;
if (!preg_match('/^(?:[0-9]+, ?)*[0-9]+$/', $valeur)) {
$ok = false;
}
return $ok;
}
private function verifierTypeEpithete(&$type) {
$ok = false;
$rejetes = $this->manuel['type_epithete_rejetes'];
if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
$ok = false;
} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
$ok = true;
}
return $ok;
}
private function verifierBiblioOrigine(&$intitule) {
$ok = true;
if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
$ok = false;// Contient des espaces en trop
} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
$ok = false;
} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
$ok = false;// Contient une mauvaise suite de caractères
}
return $ok;
}
private function verifierAnnee(&$annee) {
$ok = true;
if (!preg_match('/^[0-9]{4}$/', $annee)) {
$ok = false;
} else if ($annee < ANNEE_MINIMUM) {
$ok = false;
} else if ($annee > ANNEE_EN_COURS) {
$ok = false;
}
return $ok;
}
private function verifierAuteur(&$intitule) {
$ok = true;
$acceptes = $this->manuel['auteur_acceptes'];
if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
$ok = false;// Contient des espaces en trop
} else {
$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
$mots = explode(' ', $intitule);
foreach ($mots as $position => $mot) {
if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
$ok = false;// Mot rejeté
} else if (preg_match("/^(?:(?:\p{L}|[.'\(\),-])+|[&])$/u", $mot)) {
continue;// Mot de l'intitulé auteur
} else {
$ok = false;
}
}
}
}
return $ok;
}
private function verifierNomCommercial(&$epithete) {
$ok = false;
if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
$ok = true;
}
return $ok;
}
private function verifierEpitheteCultivar(&$epithete) {
$ok = true;
$acceptes = $this->manuel['cultivar_acceptes'];
if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
$ok = false;// Contient des espaces en trop
} else {
$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
$mots_mineurs = $this->manuel['mots_mineurs'];
$mots = explode(' ', $epithete);
foreach ($mots as $position => $mot) {
if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
$ok = false;// Mot rejeté
} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
continue;// Mot mineur en minuscule qui n'est pas en 1ère position
} else {
$mots_tiret = explode('-', $mot);
foreach ($mots_tiret as $position_tiret => $mot_tiret) {
if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
} else {
$ok = false;
}
}
}
}
}
}
return $ok;
}
private function verifierEpitheteGroupeCultivar(&$epithete) {
$ok = true;
$acceptes = $this->manuel['cultivar_gp_acceptes'];
if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
$ok = false;// Contient des espaces en trop
} else {
$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
$mots_mineurs = $this->manuel['mots_mineurs'];
$mots = explode(' ', $epithete);
foreach ($mots as $position => $mot) {
if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
continue;// Mot accepté
} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
$ok = false;// Mot rejeté
} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
continue;// Mot mineur en minuscule qui n'est pas en 1ère position
} else {
$mots_tiret = explode('-', $mot);
foreach ($mots_tiret as $position_tiret => $mot_tiret) {
if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
} else {
$ok = false;
}
}
}
}
}
}
return $ok;
}
private function verifierEpitheteSp(&$epithete) {
$ok = false;
if (preg_match('/^[a-zäëḧïöẗüẅẍÿ][-a-zäëḧïöẗüẅẍÿ]+$/', $epithete)) {
$ok = true;
} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
$ok = true;
}
return $ok;
}
private function verifierEpitheteGenre(&$epithete) {
$ok = false;
if (preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ](?:[-a-zäëḧïöẗüẅẍÿ]+|[a-zäëḧïöẗüẅẍÿ]+-[A-ZÄËḦÏÖÜẄẌŸ][a-zäëḧïöẗüẅẍÿ]+)$/', $epithete)) {
$ok = true;
}
return $ok;
}
private function verifierEstAbbreviationInfraSp($mot) {
$ok = false;
if(preg_match($this->manuel['abbr_rangs_infra_specifique'], $mot)) {
$ok = true;
}
return $ok;
}
private function formaterStyleNomGenre(&$genre) {
$genre_fmt = '';
if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
$genre_fmt = utf8_encode(strtolower(utf8_decode($match[1]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[2]))));
} elseif (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $genre, $match)) {
$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.
utf8_encode(strtolower(utf8_decode($match[2]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[3]))));
} else {
$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($genre))));
}
return $genre_fmt;
}
private function formaterStyleEpitheteSpHybride(&$genre, &$epithete) {
$nom_fmt = '';
$erreur = '';
if (trim($genre) == '') {
if ($epithete != '') {
$nom_fmt = $this->formaterFormuleHybridite($epithete);
} else {
$erreur = "Formule d'hybridité sans épithéte spécifique";
}
} else {
$nom_fmt = $this->formaterNomHybride($genre, $epithete);
}
return array($nom_fmt, $erreur);
}
private function formaterStyleEpitheteInfraSpHybride(&$nom_sci, &$infra, &$genre = null) {
$nom_fmt = '';
$erreur = '';
if (trim($genre) == '') {
if (trim($nom_sci) == '') {
if (trim($infra) != '') {
$nom_fmt = $this->formaterFormuleHybridite($infra);
} else {
$erreur = "Formule d'hybridité sans épithéte infraspécifique";
}
} else {
$erreur = "Formule d'hybridité avec épithéte spécifique";
}
} else {
$nom_fmt = $this->formaterNomHybride($nom_sci, $infra);
}
return array($nom_fmt, $erreur);
}
private function formaterNomHybride(&$nom_sci, &$epithete) {
if (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $epithete, $match) != '') {
$nom_fmt = $nom_sci.utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.
utf8_encode(strtolower(utf8_decode($match[2]))).' '.
utf8_encode(ucfirst(strtolower(utf8_decode($match[3]))));
} elseif (preg_match('/^([x+])\s+(.+)$/i', $epithete, $match) != '') {
$nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($match[1]))).' '.
utf8_encode(strtolower(utf8_decode($match[2])));
} else {
$nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($epithete)));
}
return $nom_fmt;
}
private function formaterFormuleHybridite(&$epithete) {
$liste_parents = explode(' x ', $epithete);
if (count($liste_parents) == 2) {
$nom_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[0])))).' x '.
utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[1]))));
} else {
for ($i=0; $i<count($liste_parents); $i++) {
if (strstr(trim($liste_parents[$i]), ' ') == false) {
$nom[] = utf8_encode(ucfirst(strtolower(utf8_decode(trim($liste_parents[$i]))))).' x '.
utf8_encode(strtolower(utf8_decode(trim($liste_parents[$i+1]))));
$i++;
} else {
$nom[] = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[$i]))));
}
}
$nom_fmt = implode(' x ', $nom);
}
return $nom_fmt;
}
private function repererEspace($nom_sci) {
$nom_sci = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_sci);
return $nom_sci;
}
private function repererCaracteresInvalidesNomFrancais($nom_verna) {
$nom_verna = str_replace(',', '<span class="espace">,</span>', $nom_verna);
$nom_verna = str_replace(';', '<span class="espace">;</span>', $nom_verna);
return $nom_verna;
}
private function mettreEnValeurAvertissement($chaine) {
$chaine = '<span class="espace">'.$chaine.'</span>';
return $chaine;
}
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;
}
private function classerNomsParNomComplet() {
$noms_classes = array();
foreach ($this->noms as &$nom) {
if (!isset($noms_classes[$nom['nom_sci']])) {
$noms_classes[$nom['nom_sci']] = 1;
} else {
$noms_classes[$nom['nom_sci']]++;
}
}
return $noms_classes;
}
}
?>

/branches/v2.0-betulales/scripts/modules/tests/configurations/tests.ini
New file
0,0 → 1,570
[1]
abr = "Nombre De Champs"
nom = "Structure -> nombre de champs"
description = "Le nombre de champs présent dans la table contenant le référentiel doit être supérieur ou égal à 37."
message = "Le nombre de colonnes est de %s alors qu'il doit être supérieur ou égal à 37."
[2]
abr = "Nom Des Champs"
nom = "Structure -> noms des champs"
description = "Les noms des champs de la table contenant le référentiel doivent être conformes à ceux définis par le manuel technique."
message = "Champs manquants : %s."
[3]
abr = "Type Des Champs"
nom = "Structure -> types des champs"
description = "Les types des champs (text, varchar, int) de la table contenant le référentiel doivent être conformes à ceux définis par le manuel technique."
entete = "Champ,Type attendu,Type présent"
[4]
abr = "Num Nom Cle Primaire"
nom = "Structure -> num_nom est clé primaire"
description = "Le champ num_nom doit être clé primaire de la table."
[5]
abr = "Taille Des Champs"
nom = "Structure -> champs tronqués"
description = "Les champs indiqués en erreur ont atteint leur taille limite de remplissage (ex: varchar(4) pour le champ annee). Un résultat de type KO attire l'attention du coordinateur sur la possibilité que la valeur du champ d'origine ait été tronquée lors de son dépôt dans phpmyadmin."
entete="Champ,Taille attendu,Taille présente"
[6]
abr = "Num Nom Superieur A Zero"
nom = "num_nom -> supérieur à 0"
description = "Le champ num_nom doit contenir des nombres entiers supérieurs à 0."
entete="num_nom"
[7]
abr = "Num Nom Retenu Superieur A Zero"
nom = "num_nom_retenu -> supérieur à 0"
description = "Le champ num_nom_retenu doit contenir des nombres entiers supérieurs à 0 ou être vide."
entete="num_nom,num_nom_retenu"
[8]
abr = "Existence Num Nom Retenu"
nom = "num_nom_retenu -> existence"
description = "Les valeurs du champ num_nom_retenu doivent correspondre à un num_nom."
entete = "num_nom,num_nom_retenu,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[9]
abr = "Transmission Num Nom Retenu"
nom = "num_nom_retenu -> num_nom_retenu transmis au MNHN"
description = "Les valeurs du champ num_nom_retenu doivent correspondre à un num_nom dont la valeur du champ exclure_taxref est égale à 0."
entete = "num_nom,num_nom_retenu,Exclusion de Taxref num_nom_retenu"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[10]
abr = "Synonyme Num Nom Retenu"
nom = "num_nom_retenu -> renvoie à un nom retenu"
description = "Un synonyme doit être rattaché à un nom retenu. Son champ num_nom_retenu ne doit pas correspondre à un synonyme, soit num_nom = num_nom_retenu."
entete = "num_nom,num_nom_retenu,num_nom_retenu du num_nom_retenu"
[11]
abr = "Doublons Nom Sci"
nom = "nom_sci -> détection des doublons"
description = "La combinaison 'nom scientifique + auteur + année + nom addendum + biblio' existe en double."
entete = "num_nom,nom_sci,num_nom du doublon, exclusion de Taxref, homonyme"
[12]
abr = "Num Tax Sup Egal Zero Unique"
nom = "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."
entete = "num_nom,num_tax_sup"
[13]
abr = "Tax Sup Pour Taxon"
nom = "Classification -> uniquement pour les taxons"
description = "Seuls les noms retenus doivent posséder une valeur dans le champ num_tax_sup.
Si num_nom_retenu est différent de num_nom (cas des synonymes) alors num_tax_sup doit être vide."
entete = "num_nom,num_tax_sup,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[14]
abr = "Existence Taxon Superieur"
nom = "Classification -> existence du taxon supérieur"
description = "Tous les noms retenus doivent posséder un taxon supérieur existant dans la base (sauf la racine de la classification).
Si num_nom_retenu est égal à num_nom alors num_tax_sup doit être rempli et correspondre à un num_nom."
entete = "num_nom,num_tax_sup,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[15]
abr = "Classification Espece"
nom = "Classification -> espèce rattachée à genre"
description = "Pour chaque enregistrement représentant un taxon de rang 290, le taxon supérieur doit avoir un code de rang 220."
entete = "num_nom,rang,Taxon supérieur num_nom,Taxon supérieur rang,Exclusion de Taxref"
title=";;;;0 = non, 1 = oui, 9 = indéterminée"
[16]
abr = "Transmission Taxon Superieur"
nom = "Classification -> taxon supérieur transmis au MNHN"
description = "Chaque enregistrement transmis (exclure_taxref = 0) doit posséder un taxon supérieur transmis."
entete = "num_nom,num_tax_sup,Exclusion de Taxref num_tax_sup"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[17]
abr = "Classification Rang"
nom = "Classification -> taxon supérieur avec rang supérieur"
description = "Pour chaque enregistrement représentant un taxon, le taxon supérieur doit avoir un code de rang inférieur au code de rang du taxon courant (à l'exception des noms ayant le rang de Clade)."
entete = "num_nom,rang,Taxon supérieur num_nom,Taxon supérieur rang,Exclusion de Taxref"
title=";;;;0 = non, 1 = oui, 9 = indéterminée"
[18]
abr = "Classification"
nom = "Classification -> racine liée à chaque noeud"
description = "Pour chaque nom retenu, la classification doit pouvoir être remontée jusqu'à un nom unique possédant une valeur num_tax_sup de 0."
entete = "num_nom,Message du problème,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[19]
abr = "Rang"
nom = "rang"
description = "Le rang doit correspondre à une valeur numérique définie dans le manuel."
entete = "num_nom,Rang,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[20]
abr = "Nom Complet Supra Generique"
nom = "nom_sci -> noms supra-génériques"
description = "Si le rang est < à "RANG_GENRE" (> genre), le nom_sci doit correspondre à la valeur du champ nom_supra_generique. Les valeurs des champs cultivar_groupe, cultivar et
nom_commercial peuvent s'y ajouter."
entete = "num_nom,nom_sci,nom_sci corrigé,Exclusion de Taxref"
title=";;Proposition de correction. N'est pas obligatoirement correcte;0 = non, 1 = oui, 9 = indéterminée"
[21]
abr = "Nom Complet Genre"
nom = "nom_sci -> noms de genres"
description = "Si le rang est = à "RANG_GENRE" (= genre), le nom_sci doit correspondre à la valeur du champ genre. Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter."
entete = "num_nom,nom_sci,nom_sci corrigé,Exclusion de Taxref"
title=";;Proposition de correction. N'est pas obligatoirement correcte;0 = non, 1 = oui, 9 = indéterminée"
[22]
abr = "Nom Complet Infra Genre"
nom = "nom_sci -> noms infra-génériques"
description = "Si le rang est > à "RANG_GENRE" (< genre) et < à "RANG_SP" (> espèce), le nom_sci doit correspondre à une des formules suivantes :
genre + ' ' + type_epithete + ' ' + epithete_infra_generique
genre + ' ' + epithete_infra_generique + ' ' + type_epithete=agg.
Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter."
entete = "num_nom,nom_sci,nom_sci corrigé,Exclusion de Taxref"
title=";;Proposition de correction. N'est pas obligatoirement correcte;0 = non, 1 = oui, 9 = indéterminée"
[23]
abr = "Nom Complet Espece"
nom = "nom_sci -> noms d'espèce"
description = "Si le rang est = à "RANG_SP" (= espèce), le nom_sci doit correspondre à la formule :
genre + ' ' + epithete_sp
Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.
Des erreurs peuvent être générées lors de la reconstruction des formules d'hybridité à partir des champs cités ci-dessus. Pour les éviter, ne remplir que le champ concernant le rang de l'hybride)."
entete = "num_nom,nom_sci,nom_sci corrigé,Proposition d'erreur,Exclusion de Taxref"
title=";;Proposition de correction. N'est pas obligatoirement correcte;;0 = non, 1 = oui, 9 = indéterminée"
[24]
abr = "Nom Complet Infra Specifique"
nom = "nom_sci -> noms infra-spécifiques"
description = "Si le rang est > à "RANG_SP" (< espèce), le nom_sci doit correspondre à la formule :
genre + ' ' + epithete_sp + ' ' + type_epithete + ' ' + epithete_infra_specifique
Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.
Des erreurs peuvent être générées lors de la reconstruction des formules d'hybridité à partir des champs cités ci-dessus. Pour les éviter, ne remplir que le champ concernant le rang de l'hybride."
entete = "num_nom,nom_sci,nom_sci corrigé,Proposition d'erreur,Exclusion de Taxref"
title=";;Proposition de correction. N'est pas obligatoirement correcte;;0 = non, 1 = oui, 9 = indéterminée"
[25]
abr = "Nom Supra Generique Espaces"
nom = "nom_supra_generique -> espaces en trop"
description = "Le champ nom_supra_generique ne doit pas contenir d'espace avant ou après le nom."
entete = "num_nom,nom_supra_generique erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[26]
abr = "Nom Supra Generique Syntaxe"
nom = "nom_supra_generique -> syntaxe"
description = "Le champ nom_supra_generique contient un mot composé de lettres minuscules, avec ou sans tréma (¨), et de tirets (-).
La première lettre (avec ou sans tréma) du mot doit être en majuscule."
entete = "num_nom,nom_supra_generique erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[27]
abr = "Nom Supra Generique Rang"
nom = "nom_supra_generique -> rang < "RANG_GENRE
description = "Si le champ nom_supra_generique n'est pas vide alors le rang du nom doit être inférieur à "RANG_GENRE" (> genre)."
entete = "num_nom,nom_sci,rang erroné,Exclusion de Taxref"
title=";;;0 = non, 1 = oui, 9 = indéterminée"
[28]
abr = "Genre Espaces"
nom = "genre -> espaces en trop"
description = "Le champ genre ne doit pas contenir d'espace avant ou après le nom.
Si des espaces sont compris dans la valeur du champ, il ne doit pas en avoir plusieurs consécutifs."
entete = "num_nom,genre erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[29]
abr = "Genre Syntaxe"
nom = "genre -> syntaxe"
description = "Le champ genre peut contenir :
- un mot unique composé de lettres minuscules, avec ou sans tréma (¨), et de tirets (-).
Il commence par une lettre majuscule (avec ou sans tréma) et peut être précédé par le signe + ou la lettre x suivi d'un espace.
- une formule d'hybridité composée d'une série de noms de genre (au moins 2) séparés
entre eux par la lettre x entourée de caractères espaces."
entete = "num_nom,genre erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[30]
abr = "Genre Rang"
nom = "genre -> rang >= "RANG_GENRE
description = "Si le champ genre n'est pas vide alors le rang du nom doit être supérieur ou égal à "RANG_GENRE" (< ou = genre)."
entete = "num_nom,nom_sci,rang erroné,Exclusion de Taxref"
title=";;;0 = non, 1 = oui, 9 = indéterminée"
[31]
abr = "Epithete Infra Generique Syntaxe"
nom = "epithete_infra_generique -> syntaxe"
description = "Le champ epithete_infra_generique est composé de lettres minuscules, avec ou sans tréma (¨), et de tirets (-).
La première lettre (avec ou sans tréma) doit être en majuscule."
entete = "num_nom,epithete_infra_generique erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[32]
abr = "Epithete Infra Generique Rang"
nom = "epithete_infra_generique -> "RANG_GENRE" < rang < "RANG_SP
description = "Si le champ epithete_infra_generique n'est pas vide alors le rang du nom doit être compris entre "RANG_GENRE" (< genre) et "RANG_SP" (> espèce)."
entete = "num_nom,nom_sci,rang erroné,Exclusion de Taxref"
title=";;;0 = non, 1 = oui, 9 = indéterminée"
[33]
abr = "Epithete Infra Generique Espaces"
nom = "epithete_infra_generique -> espaces en trop"
description = "Le champ epithete_infra_generique ne doit pas contenir d'espace avant ou après sa valeur."
entete = "num_nom,epithete_infra_generique erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[34]
abr = "Epithete Sp Espaces"
nom = "epithete_sp -> espaces en trop"
description = "Le champ epithete_sp ne doit pas contenir d'espace avant ou après le nom.
Si des espaces sont compris dans la valeur du champ, il ne doit pas en avoir plusieurs consécutifs."
entete = "num_nom,epithete_sp erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[35]
abr = "Epithete Sp Syntaxe"
nom = "epithete_sp -> syntaxe"
description = "Le champ epithete_sp peut contenir :
- un mot unique composé de lettres minuscules [a-z] incluant les caractères [ëï-].
Il commence par une lettre minuscule [a-zëï].
Il peut être précédé par le signe + ou la lettre x suivi d'un espace.
- un mot contenant sp. suivi d'un ou plusieurs caractères numériques (1-9)
ou d'un seul caractère majuscule (A-Z)
- une formule d'hybridité composée d'une série de noms d'espèce (au moins 2)
séparés entre eux par la lettre x entourée de caractères espaces."
entete = "num_nom,epithete_sp erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[36]
abr = "Epithete Sp Rang"
nom = "epithete_sp -> rang >= "RANG_SP
description = "Si le champ epithete_sp n'est pas vide alors le rang du nom doit être supérieur ou égal à "RANG_SP" (< ou = espèce)."
entete = "num_nom,nom_sci,rang erroné,Exclusion de Taxref"
title=";;;0 = non, 1 = oui, 9 = indéterminée"
[37]
abr = "Type Epithete Espaces"
nom = "type_epithete -> espaces en trop"
description = "Le champ type_epithete ne doit pas contenir d'espace."
entete = "num_nom,type_epithete erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[38]
abr = "Type Epithete Syntaxe"
nom = "type_epithete -> syntaxe"
description = "Le champ type_epithete doit contenir un mot unique composé de lettres minuscules, sans accent, et de tirets (-). Il commence par une lettre minuscule sans accent et se termine, ou pas, par un point."
entete = "num_nom,type_epithete erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[39]
abr = "Type Epithete Hybridite"
nom = "type_epithete -> hybridité"
description = "Le champ type_epithete ne doit pas contenir de préfixe indiquant l'hybridité comme :
- «n-»
- «notho-»"
entete = "num_nom,type_epithete erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[40]
abr = "Epithete Infra Sp Espaces"
nom = "epithete_infra_sp -> espaces en trop"
description = "Le champ epithete_infra_sp ne doit pas contenir d'espace avant ou après le nom.
Si des espaces sont compris dans la valeur du champ, il ne doit pas y en avoir plusieurs consécutifs."
entete = "num_nom,epithete_infra_sp erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[41]
abr = "Epithete Infra Sp Syntaxe"
nom = "epithete_infra_sp -> syntaxe"
description = "Le champ epithete_infra_sp peut contenir :
- un mot unique composé de lettres minuscules, avec ou sans tréma (¨), et de tirets (-).
Il commence par une lettre minuscule (avec ou sans tréma).
Il peut être précédé par le signe + ou la lettre x suivi d'un espace.
- une formule d'hybridité composée d'une série de noms d'espèce ou d'infra espèce
(au moins 2) séparés entre eux par la lettre x entourée de caractères espaces."
entete = "num_nom,epithete_infra_sp erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[42]
abr = "Epithete Infra Sp Rang"
nom = "epithete_infra_sp -> rang > "RANG_SP
description = "Si le champ epithete_infra_sp n'est pas vide alors le rang du nom doit être supérieur à "RANG_SP" (< espèce)."
entete = "num_nom,nom_sci,rang erroné,Exclusion de Taxref"
title=";;;0 = non, 1 = oui, 9 = indéterminée"
[43]
abr = "Groupe Cultivar Syntaxe"
nom = "cultivar_groupe -> syntaxe"
description = "Le champ cultivar_groupe doit contenir un nom de groupe de cultivar conforme aux règles du code des plantes cultivées, c-à-d composer de caractères alphanumériques (A-Z,a-z et 0-9) incluant signes diacritiques et marques de ponctuations.
Il ne doit pas contenir le mot Groupe, l'abbréviation «gp» ou des parenthèses.
Il peut se terminer par l'abréviation «gx» pour distinguer les groupes des grex."
entete = "num_nom,cultivar_groupe erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[44]
abr = "Groupe Cultivar Rang"
nom = "cultivar_groupe -> rang >= "RANG_GENRE
description = "Si le champ cultivar_groupe n'est pas vide alors le rang du nom doit être supérieur ou égal à "RANG_GENRE" (< ou = genre)."
entete = "num_nom,nom_sci,rang erroné,Exclusion de Taxref"
title=";;;0 = non, 1 = oui, 9 = indéterminée"
[45]
abr = "Cultivar Syntaxe"
nom = "cultivar -> syntaxe"
description = "Le champ cultivar_groupe doit contenir :
- un nom de cultivar conforme aux règles du Code Internationnal de Nomenclature
des Plantes Cultivées (CINPC), c.-à-d. composer de caractères alphanumériques
(A-Z,a-z et 0-9) incluant signes diacritiques et marques de ponctuations.
- un nom en alphabet latin, ce qui implique une translittération des noms d'alphabet
cyrillique, arabe, chinois...
- une lettre majuscule obligatoire pour le premier caractère du premier mot et pour
les autres mots importants mais pas pour les mots mineurs.
Ne doit pas contenir :
- cv., convar. ou de guillemets simples (')."
entete = "num_nom,cultivar erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[46]
abr = "Cultivar Rang"
nom = "cultivar -> rang >= "RANG_GENRE
description = "Si le champ cultivar n'est pas vide alors le rang du nom doit être supérieur ou égal à "RANG_GENRE" (< ou = genre)."
entete = "num_nom,nom_sci,rang erroné,Exclusion de Taxref"
title=";;;0 = non, 1 = oui, 9 = indéterminée"
[47]
abr = "Nom Commercial Syntaxe"
nom = "nom_commercial -> syntaxe"
description = "Le champ nom_commercial doit contenir un nom commercial conforme aux règles du Code Internationnal de Nomenclature des Plantes Cultivées (CINPC) qui se compose de caractères majuscules (A-Z) incluant des signes diacritiques et des espaces."
entete = "num_nom,cultivar erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[48]
abr = "Nom Commercial Presence Cultivar"
nom = "nom_commercial -> groupe_cultivar OU cultivar non vide"
description = "Si le champ nom_commercial contient un nom commercial alors le champ cultivar OU cultivar_groupe ne doit pas être vide."
entete = "num_nom,nom_commercial sans cultivar ou cultivar_groupe,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[49]
abr = "Auteur Syntaxe"
nom = "auteur -> syntaxe"
description = "Le champ auteur doit :
- contenir les abréviations du(es) nom(s) de l'auteur (des auteurs) ayant publié à l'origine la combinaison latine courante et respectant les standards.
- OU débuter par le mot « sensu » et contenir l'intitulé complet des noms de l'auteur, ou des auteurs, ayant publié un nom dont la description ne correspond pas à celle de l'auteur, ou des auteurs, d'origine.
- se composer de caractères alphabétiques (A-Z, a-z), incluant les signes diacritiques, le symbole point (.), les paires de parenthèses ( () ), les apostrophes, l'esperluette (&) et l'espace ( ).
- contenir une translittération des noms d'alphabet cyrillique, arabe, chinois... en alphabet latin.
- inclure entre parenthèses l'intitulé des noms de l'auteur ou des auteurs ayant publié le basionyme.
- toujours utiliser l'esperluette (&) à la place du mot « et » pour séparer les noms d'auteurs.
- si une citation comprend plus de deux auteurs, citer tous les auteurs (contrairement à la recommandation 46C.2 du CINB).
- pas d'espace entre le point de la dernière initiale du prénom et le nom.
- peut rester vide si le nom est un autonyme (epithete_sp = epithete_infra_sp)."
entete = "num_nom,auteur erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[50]
abr = "Annee Syntaxe"
nom = "annee -> syntaxe"
description = "Le champ annee doit :
- contenir un nombre de 4 chiffres,
- être supérieur ou égal à 1753,
- être inférieur ou égal à l'année courante."
entete = "num_nom, annee erronée,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[51]
abr = "Biblio Origine Syntaxe"
nom = "biblio_origine -> syntaxe"
description = "Le champ biblio_origine se compose de plusieurs parties séparées par des caractères précis qui sont dans l'ordre de gauche à droite :
- éventuellement, le mot « in » suivi d'un intitulé auteur (utilisé pour indiquer l'intitulé auteur de l'ouvrage dans lequel la publication est parue),
- point-virgule « ; » (si l'info précédent a été renseignée),
- abréviation, ou nom, de l'ouvrage ou de la revue selon le standard en vigueur dans le code du nom.
Cette information ne doit pas contenir de caractère virgule « , »,
- virgule « , »,
- informations permettant d'identifier plus précisément le document contenant le nom...
(par exemple, l'éditeur, le tome, le numéro d'édition, le volume...) séparées par des virgules ou d'autres caractères sauf deux points « : ».
- deux points « : »,
- numéro(s) de la page contenant la publication du nom ou de l'ensemble de pages (première et dernière
pages de l'ensemble séparées par un tiret « - »). Quelques fois des numéros ou d'autres informations indiquant
la position du nom dans le document. Le tiret « - » doit toujours servir à séparer un ensemble."
entete = "num_nom,biblio_origine erronée,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[52]
abr = "Homonymie Syntaxe"
nom = "homonyme -> syntaxe"
description = "Le champ homonyme contient :
- une valeur vide,
- le chiffre 1."
entete = "num_nom,homonyme erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[53]
abr = "Homonymie Existence"
nom = "homonyme -> existence"
description = "Si le champ homonyme contient «1» alors plusieurs noms doivent posséder la même valeur dans le champ nom_sci."
entete = "num_nom,homonyme introuvable,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[54]
abr = "Basionyme Syntaxe"
nom = "basionyme -> syntaxe"
description = "Le champ basionyme contient :
- une valeur vide,
- un nombre."
entete = "num_nom,basionyme erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[55]
abr = "Basionyme Existence"
nom = "basionyme -> existence"
description = "Si le champ basionyme contient un nombre alors il doit correspondre à une valeur du champ num_nom."
entete = "num_nom,basionyme introuvable,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[56]
abr = "Synonyme Proparte Syntaxe"
nom = "synonyme_proparte -> syntaxe"
description = "Le champ synonyme_proparte contient soit :
- une valeur vide,
- un nombre,
- une suite de nombres séparés par des virgules."
entete = "num_nom,synonyme_proparte erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[57]
abr = "Synonyme Proparte Existence"
nom = "synonyme_proparte -> existence"
description = "Si le champ synonyme_proparte contient un ou plusieurs nombres alors chacun d'entre eux doit correspondre à une valeur du champ num_nom."
entete = "num_nom, synonyme_proparte introuvable,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[58]
abr = "Synonyme Douteux Syntaxe"
nom = "synonyme_douteux -> syntaxe"
description = "Le champ synonyme_douteux contient soit :
- une valeur vide,
- le chiffre 1."
entete = "num_nom,synonyme_douteux erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[59]
abr = "Synonyme Douteux Num Nom Retenu"
nom = "synonyme_douteux -> existence num_nom_retenu"
description = "Si le nom est un synonyme douteux, le champ num_nom_retenu doit être rempli."
entete = "num_nom,synonyme_douteux,Exclusion de Taxref"
title=";;;0 = non, 1 = oui, 9 = indéterminée"
[60]
abr = "Synonyme Douteux Synonyme"
nom = "synonyme_douteux -> synonyme"
description = "Si le nom est un synonyme douteux, le champ num_nom_retenu doit être différent du champ num_nom."
entete = "num_nom,num_nom_retenu,synonyme_douteux,Exclusion de Taxref"
title=";;;0 = non, 1 = oui, 9 = indéterminée"
[61]
abr = "Synonyme Mal Applique Syntaxe"
nom = "synonyme_mal_applique -> syntaxe"
description = "Le champ synonyme_mal_applique contient soit :
- une valeur vide,
- le chiffre 1."
entete = "num_nom,synonyme_mal_applique erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[62]
abr = "Synonyme Mal Applique Champs Annexe"
nom = "synonyme_mal_applique -> autres champs"
description = "Si le nom est un synonyme_mal_applique, le champ auteur commence par sensu et les champs annee et auteur sont remplis."
entete = "num_nom,auteur,annee, biblio_origine,Exclusion de Taxref"
title=";;;;0 = non, 1 = oui, 9 = indéterminée"
[63]
abr = "Synonyme Mal Applique Synonyme"
nom = "synonyme_mal_applique -> synonyme"
description = "Si le nom est un synonyme_mal_applique, le champ num_nom_retenu doit être différent du champ num_nom.."
entete = "num_nom,année,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[64]
abr = "Synonyme Orthographique Syntaxe"
nom = "synonyme_orthographique -> syntaxe"
description = "Le champ synonyme_orthographique contient soit :
- une valeur vide,
- un nombre."
entete = "num_nom,synonyme_orthographique erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[65]
abr = "Synonyme Orthographique Existence"
nom = "synonyme_orthographique -> existence"
description = "Si le champ synonyme_orthographique contient un nombre alors il doit correspondre à une valeur du champ num_nom."
entete = "num_nom,synonyme_orthographique introuvable,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[66]
abr = "Hybride Parent01 Syntaxe"
nom = "hybride_parent_01 -> syntaxe"
description = "Le champ hybride_parent_01 contient soit :
- une valeur vide,
- un nombre."
entete = "num_nom,hybride_parent_01 erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[67]
abr = "Hybride Parent01 Existence"
nom = "hybride_parent_01 -> existence"
description = "Si le champ hybride_parent_01 contient un nombre alors il doit correspondre à une valeur du champ num_nom."
entete = "num_nom,hybride_parent_01 introuvable,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[68]
abr = "Hybride Parent02 Syntaxe"
nom = "hybride_parent_02 -> syntaxe"
description = "Le champ hybride_parent_02 contient soit :
- une valeur vide,
- un nombre."
entete = "num_nom,hybride_parent_02 erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[69]
abr = "Hybride Parent02 Existence"
nom = "hybride_parent_02 -> existence"
description = "Si le champ hybride_parent_02 contient un nombre alors il doit correspondre à une valeur du champ num_nom."
entete = "num_nom,hybride_parent_02 introuvable,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[70]
abr = "Num Type Syntaxe"
nom = "num_type -> syntaxe"
description = "Le champ num_type contient :
- une valeur vide,
- un nombre."
entete = "num_nom,num_type erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[71]
abr = "Num Type Existence"
nom = "num_type -> existence"
description = "Si le champ num_type contient un nombre alors il doit correspondre à une valeur du champ num_nom."
entete = "num_nom,num_type introuvable,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[72]
abr = "Presence Syntaxe"
nom = "presence -> syntaxe"
description = "Le champ presence contient soit :
- le symbole tiret «-» précédant une autre information non référencée...
- une première lettre en majuscule indiquant le code standard attribué à ce taxon,
- éventuellement suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant un code de présence spécifique au référentiel."
entete = "num_nom,presence erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[73]
abr = "Presence Existence"
nom = "presence -> existence"
description = "Pour chaque enregistrement représentant un taxon, le champ présence doit être rempli."
entete = "num_nom,num_nom_retenu,presence,Exclusion de Taxref"
title=";;;;"
[74]
abr = "Statut Origine Syntaxe"
nom = "statut_origine -> syntaxe"
description = "Le champ statut_origine peut contenir :
- le symbole tiret «-» précédant une autre information non référencée...
- une première lettre en majuscule indiquant le code standard attribué à ce taxon.
- éventuellement suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant un code de présence spécifique au référentiel."
entete = "num_nom,statut_origine erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[75]
abr = "Statut Introduction Syntaxe"
nom = "statut_introduction -> syntaxe"
description = "Le champ statut_introduction peut contenir :
- le symbole tiret «-» précédant une autre information non référencée...
- une première lettre en majuscule indiquant le code standard attribué à ce taxon,
- éventuellement suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant un code de présence spécifique au référentiel."
entete = "num_nom,statut_introduction erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[76]
abr = "Statut Culture Syntaxe"
nom = "statut_culture -> syntaxe"
description = "Le champ statut_culture peut contenir :
- le symbole tiret «-» précédant une autre information non référencée...
- une première lettre en majuscule indiquant le code standard attribué à ce taxon,
- éventuellement suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant un code de présence spécifique au référentiel."
entete = "num_nom,statut_culture erroné,Exclusion de Taxref"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[77]
abr = "Exclure Tax Ref Syntaxe"
nom = "exclure_taxref -> syntaxe"
description = "Le champ exclure_taxref contient soit :
- une valeur vide ou NULL.
- le chiffre 0 : si le nom n'a pas à être exclu de TaxRef.
- le chiffre 1 : pour exclure le nom de TaxRef
- le chiffre 9 : quand la décision sur l'exclusion reste à prendre (le nom sera malgré tout exclu)."
entete = "num_nom,exclure_taxref erroné"
[78]
abr = "Nom francais Unique"
nom = "nom_francais -> unique"
description = "Le champ nom français peut contenir :
- une valeur vide ou NULL.
- un seul nom vernaculaire, ne contenant ni virgules, ni point-virgule"
entete = "num_nom, nom_francais"
title=";;0 = non, 1 = oui, 9 = indéterminée"
[79]
abr = "Exclure Tax Ref Presence"
nom = "exclure_taxref -> presence"
description = "Un nom retenu non-exclu de taxref doit contenir :
- une valeur correcte dans la colonne présence.
- si possible, une valeur correcte dans au moins une des colonnes de statut"
entete = "num_nom, nom_sci, presence, statut_origine, statut_introduction, statut_culture"
title=";;;;;;;"

/branches/v2.0-betulales/scripts/modules/tests/squelettes/message_p.tpl.html
New file
0,0 → 1,0
<p><?=$message?></p>

/branches/v2.0-betulales/scripts/modules/tests/squelettes/message_table.tpl.html
New file
0,0 → 1,28
<?php if (isset($erreur)) : ?>
<p class="attention"><?=$erreur?></p>
<?php endif; ?>
<table>
<caption><?=count($message['lignes'])?> lignes en erreur</caption>
<thead>
<tr>
<?php foreach ($message['entete'] as $num => $entete) : ?>
<th<?=(isset($message['title'][$num]) && !empty($message['title'][$num])) ? ' title="'.$message['title'][$num].'"' : ''?>><?=$entete?></th>
<?php endforeach; ?>
</tr>
</thead>
<tbody>
<?php foreach ($message['lignes'] as $num => $ligne) : ?>
<tr>
<?php foreach ($ligne as $num => $info) : ?>
<td>
<?php $entete = explode(" ",$message['entete'][$num]) ; if (preg_match('/^(num_nom|num_nom_retenu|num_tax_sup)$/', $entete[0])) : ?>
<a href="{numNom::<?=$info?>}" title="Voir la fiche du nom"><?=$info?></a>
<?php else : ?>
<?=$info?>
<?php endif; ?>
</td>
<?php endforeach; ?>
</tr>
<?php endforeach; ?>
</tbody>
</table>

/branches/v2.0-betulales/scripts/modules/importation/Importation.php
New file
0,0 → 1,407
<?php
// Encodage : UTF-8
// +-------------------------------------------------------------------------------------------------------------------+
/**
* Importation d'un fichier ref-tax dans une bdnt
*
* Description : classe permettant de versionner les référentiels selon le manuel technique
* Utilisation : php script.php comparaison -r bdnff -a tout -f fichier.txt
*
//Auteur original :
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Tela-Botanica 1999-2010
* @link http://www.tela-botanica.org/wikini/RTaxMethodo/wakka.php?wiki=MaNuel
* @licence GPL v3 & CeCILL v2
* @version $Id$
*/
// +-------------------------------------------------------------------------------------------------------------------+
class Importation extends ScriptCommande {
const SCRIPT_NOM = 'importation';
const MANUEL_VERSION = '4.3';
private $referentiel = null;
/*public $parametres = array(
'-r' => array(true, true, 'referentiel de base'),
'-f' => array(true, true, 'fichier à comparer'));*/
private $noms_supprimes = null;
private $noms_colonnes = array();
private $rangs_bdnt_taxref = null;
private $statuts_bdnt_taxref = null;
private $correspondance_colonnes = array("CD_NOM" => "", "CD_SUP" => "", "CD_REF" => "",
"RANG" => "rang", "LB_NOM" => "nom_sci", "LB_AUTEUR" => array("auteur","annee"),
"FR" => "presence",
"FR-FRA" => "presence_Ga", "FR-COR" => "presence_Co", "REU" => "presence",
"GUA" => "presence_Guadeloupe", "SMSB" => array("presence_Saint_Martin", "presence_Saint_Barthelemy"),
"SM" => "presence_Saint_Martin", "SB" => "presence_Saint_Barthelemy", "MAR" => "presence_Martinique",
"GF" => "presence", "MAY" => "presence_Mayotte", "TAAF" => "presence_Taaf",
"SPM" => "presence_Guadeloupe", "PF" => "presence_Polynesie", "NC" => "presence_Nouvelle_Caledonie",
"BIBLIO" => "biblio_origine", "BDNGM" => "num_nom", "NUM_NOM" => "num_nom", "NOM_VERN" => "nom_francais");
private $sans_correspondance = array(
"FG_VALIDITE", "habitat", "WF", "CLI", "EPA",
"EU", "WLD", "ORACLE",
"DATE_CREA", "ORIGINE_CREA",
"NOM_COMPLET", "NOM_COMPLET_HTML",
"GENRE", "ESPECE", "SOUS_ESPECE", "ANNEE");
/*public function executer() {
$this->referentiel = $this->getParam('r');
// Lancement du test demandé
$fichier = $this->getParam('f');
if (file_exists($fichier)) {
$manuel_chemin = Config::get('chemin_appli').DS.'..'.DS.'configurations'.DS;
$manuel_config_nom = 'referentiel_v'.self::MANUEL_VERSION.'.ini';
$this->manuel = parse_ini_file($manuel_chemin.$manuel_config_nom);
$this->creerCorrespondanceRangBdntTaxref();
$donnees = $this->traiterFichierTaxref($fichier);
Debug::printr("Fin du traitement du fichier.");
$this->connecterPDO();
$this->creerTableTaxref();
$this->ajouterColonneCDNOM();
Debug::printr("Fin de la création de la table.");
$this->ajouterDonneesTaxRef($donnees);
Debug::printr("Fin de l'insertion des données.");
$this->creerTableComparaison();
Debug::printr("Fin de la création de la table comparaison.");
}
}*/
public function executer() {
// Récupération du dernier traitement demandé
$this->traitementDao = new TraitementDao();
$this->traitement = $this->traitementDao->getDernierTraitement('tout', self::SCRIPT_NOM);
if (isset($this->traitement)) {
$this->referentiel = $this->traitement['referentiel_code']; // Récupération du nom de projet
$fichier = $this->traitement['script_parametres'];
if (file_exists($fichier)) {
Debug::printr('Debute:'.$this->traitementDao->debuterTraitement($this->traitement['id_traitement']));
// Nettoyage des traitements obsolètes
$traitements_obsoletes = $this->traitementDao->getTraitementsObsoletes($this->referentiel, self::SCRIPT_NOM);
if (isset($traitements_obsoletes)) {
Debug::printr('Supp. obsoletes:'.$this->traitementDao->supprimer($traitements_obsoletes));
}
Debug::printr("Début du traitement du fichier.");
$manuel_chemin = Config::get('chemin_appli').DS.'..'.DS.'configurations'.DS;
$manuel_config_nom = 'referentiel_v'.self::MANUEL_VERSION.'.ini';
$this->manuel = parse_ini_file($manuel_chemin.$manuel_config_nom);
$this->creerCorrespondanceRangBdntTaxref();
$donnees = $this->traiterFichierTaxref($fichier);
Debug::printr("Fin du traitement du fichier.");
$this->connecterPDO();
$this->creerTableTaxref();
$this->ajouterColonneCDNOM();
Debug::printr("Fin de la création de la table.");
$this->ajouterDonneesTaxRef($donnees);
Debug::printr("Fin de l'insertion des données.");
$this->decouperNomSciTaxRef();
$this->creerTableComparaison();
Debug::printr("Fin de la création de la table comparaison.");
Debug::printr('Termine:'.$this->traitementDao->terminerTraitement($this->traitement['id_traitement']));
} else {
Debug::printr("Fichier introuvable".$fichier);
Debug::printr('Termine:'.$this->traitementDao->terminerTraitement($this->traitement['id_traitement']));
}
} else {
Debug::printr("Pas de traitement");
}
}
// +-------------------------------------------------------------------------------------------------------------------+
private function creerTableTaxref() {
$requete = "DROP TABLE IF EXISTS {$this->referentiel}_taxref; ".
"CREATE TABLE {$this->referentiel}_taxref AS SELECT * FROM {$this->referentiel};".
"ALTER TABLE {$this->referentiel}_taxref ADD PRIMARY KEY (num_nom);";
$resultat = $this->executerRequeter($requete);
}
private function ajouterColonneCDNOM() {
$requete = "ALTER TABLE {$this->referentiel}_taxref ADD ".
"`CD_NOM` INT( 15 ) NULL DEFAULT NULL COMMENT 'numéro correspondant dans la base taxref.';";
$resultat = $this->executerRequeter($requete);
}
private function ajouterDonneesTaxRef($liste_noms) {
$i = 0; $j = 0; $requete = "";
foreach ($liste_noms as $nom) { $i++;
$requete .= "UPDATE {$this->referentiel}_taxref SET ".implode(' , ', $nom).
" WHERE {$nom['num_nom']} ;";//echo $requete;
if ($i == 1000 || ($j*1000+$i) == count($liste_noms) ) { $j++;
$resultat = $this->executerRequeter($requete.'commit;');
if ($resultat == null) {
$resultat = $this->executerRequeter($requete.'commit;');
}
$i = 0; $requete = "";
}
}
}
private function creerTableComparaison() {
foreach ($this->noms_colonnes as $colonne) {
if (isset($this->correspondance_colonnes[$colonne]) && $this->correspondance_colonnes[$colonne] != "") {
$nom_champ = $this->correspondance_colonnes[$colonne];
if (is_array($nom_champ)) {
foreach ($nom_champ as $nom) {
$champs_tax[] = "t.{$nom} AS tax_{$nom}";
$champs_tax[] = "b.{$nom} AS {$nom}";
$concat[] = "IF(t.{$nom} != b.{$nom}, '{$nom}, ', '')";
}
} else {
$champs_tax[] = "t.{$nom_champ} AS tax_{$nom_champ}";
$champs_tax[] = "b.{$nom_champ} AS {$nom_champ}";
$concat[] = "IF(t.{$nom_champ} != b.{$nom_champ}, '{$nom_champ}, ', '')";
}
}
}
date_default_timezone_set('Europe/London');
$requete = "CREATE TABLE {$this->referentiel}_comparaison_".date("Y_m_d_H_i_s")." AS".
" SELECT CONCAT(".implode(', ', $concat).") AS difference, ".implode(', ', $champs_tax).
" FROM {$this->referentiel} b, {$this->referentiel}_taxref t".
" WHERE b.num_nom = t.num_nom AND (b.nom_sci != t.nom_sci or b.auteur != t.auteur or b.annee != t.annee);";
//echo $requete;
$resultat = $this->executerRequeter($requete);
}
// +-------------------------------------------------------------------------------------------------------------------+
private function traiterFichierTaxref($fichier) {
$donnees = array();
if (($pointeur = fopen($fichier, "r")) !== FALSE) {
$this->noms_colonnes = fgetcsv($pointeur, 1000, chr(9));
$num_nom = 0;//print_r($this->noms_colonnes);
while (($ligne = fgetcsv($pointeur, 1000, chr(9))) !== FALSE) {
$nombreChamps = count($ligne);
$taxref[$ligne[0]] = $ligne;//print_r($ligne);
for ($c=0; $c < $nombreChamps; $c++) {
if (isset($this->correspondance_colonnes[$this->noms_colonnes[$c]])) {
if (is_array($this->correspondance_colonnes[$this->noms_colonnes[$c]])) {
if ($this->noms_colonnes[$c] == 'LB_AUTEUR') {
if (preg_match('/(.*), +([0-9]{4})/', utf8_encode($ligne[$c]), $matches) == 1) {
$nom['auteur'] = 'auteur="'.$matches[1].'"';
$nom['annee'] = 'annee="'.trim($matches[2]).'"';
} else {
$nom['auteur'] = 'auteur="'.utf8_encode($ligne[$c]).'"';
$nom['annee'] = 'annee=""';
}
} else {
foreach ($this->correspondance_colonnes[$this->noms_colonnes[$c]] as $a=>$nom_colonne) {
$nom[$nom_colonne] = $nom_colonne.'="'.$ligne[$c].'"';
}
}
} elseif ($this->correspondance_colonnes[$this->noms_colonnes[$c]] == "") {
$nom[$this->noms_colonnes[$c]] = $ligne[$c];
} else {
if ($this->correspondance_colonnes[$this->noms_colonnes[$c]] == "rang") {
$rang = $this->rangs_bdnt_taxref[$ligne[$c]];
// à remettre si on décide de prendre les rangs taxref
//$nom[$this->correspondance_colonnes[$this->noms_colonnes[$c]]] =
//$this->correspondance_colonnes[$this->noms_colonnes[$c]].'="'.$this->rangs_bdnt_taxref[$ligne[$c]].'"';
} elseif ($this->correspondance_colonnes[$this->noms_colonnes[$c]] == "num_nom") {
$num_nom = $ligne[$c];
$nom[$this->correspondance_colonnes[$this->noms_colonnes[$c]]] =
$this->correspondance_colonnes[$this->noms_colonnes[$c]].'="'.$ligne[$c].'"';
} elseif ($this->correspondance_colonnes[$this->noms_colonnes[$c]] == "nom_sci") {
$nom_sci = $ligne[$c];
$nom[$this->correspondance_colonnes[$this->noms_colonnes[$c]]] =
$this->correspondance_colonnes[$this->noms_colonnes[$c]].'="'.trim($ligne[$c]).'"';
} else {
$nom[$this->correspondance_colonnes[$this->noms_colonnes[$c]]] =
$this->correspondance_colonnes[$this->noms_colonnes[$c]].'="'.trim(utf8_encode($ligne[$c])).'"';
}
}
}
}
$nom['exclure_taxref'] = 'exclure_taxref="0"';
$donnees[$num_nom] = $nom;
$correspondance_taxref_bdnt[$nom['CD_NOM']] = $num_nom;
}
fclose($pointeur);
$donnees = $this->changerNumerotation($donnees, $correspondance_taxref_bdnt, $taxref);
}
return $donnees;
}
private function changerNumerotation($donnees, $correspondance, $taxref) {
$i=0;$j=0;$k=0;
foreach ($donnees as $num_nom=>$infos) {
if (isset($correspondance[$infos['CD_SUP']])) {
$donnees[$num_nom]['num_tax_sup'] = "num_tax_sup=".$correspondance[$infos['CD_SUP']];
$i++;
} elseif ($infos['CD_SUP'] != '') {
$donnees[$num_nom]['num_tax_sup'] = "num_tax_sup=''";
//$sup[$infos['CD_NOM']] = $taxref[$infos['CD_NOM']];
$sup[$infos['CD_SUP']] = $infos['CD_SUP'];
}
unset($donnees[$num_nom]['CD_SUP']);
if (isset($correspondance[$infos['CD_REF']])) {
$donnees[$num_nom]['num_nom_retenu'] = "num_nom_retenu=".$correspondance[$infos['CD_REF']];
$j++;
} elseif ($infos['CD_REF'] != '') {$k++;
$donnees[$num_nom]['num_nom_retenu'] = "num_nom_retenu=''";
//$ref[$infos['CD_NOM']] = $taxref[$infos['CD_NOM']];
$ref[$infos['CD_REF']] = $infos['CD_REF'];
} else {
Debug::printr($infos['CD_NOM']."n'a pas de valeur pour CD_REF");
}
unset($donnees[$num_nom]['CD_REF']);
$donnees[$num_nom]['CD_NOM'] = 'CD_NOM='.$donnees[$num_nom]['CD_NOM'];
}echo "les ".count($sup)." taxons supérieurs manquants :".implode(" ,", $sup)." \nles "."retenus ".implode(" ,", $ref);
//$this->ecrireFichierCsv($ref, './retenu_absent.csv');
//$this->ajouterTaxonAbsent($abs);
//$this->ecrireFichierCsv($sup, './superieur_absent.csv');
echo "$j correspondance pour nom retenu $i correspondance pour nom sup $k non pas de correspondance retenu";
return $donnees;
}
// rechercher dans reftax les numéros absent dans la base
// modifier les tableaux ref et sup pour modifier $donnees (ajout + modif)
private function ajouterTaxonAbsent($abs) {
$requete = "SELECT ".implode(",", $this->noms_colonnes)." FROM taxref_v5 where CD_NOM IN (".implode(",", $abs).")";
echo $requete;
}
private function creerCorrespondanceRangBdntTaxref() {
$rangs = explode(',', $this->manuel['rangs_bdnt_taxref']);
foreach ($rangs as $rang) {
list($id_bdnt, $code_taxref) = explode(':', trim($rang));
$this->rangs_bdnt_taxref[$code_taxref] = $id_bdnt;
}
}
// +-------------------------------------------------------------------------------------------------------------------+
private function decouperNomSciTaxRef() {
$requete = "SELECT num_nom, nom_sci, rang, type_epithete FROM {$this->referentiel}_taxref WHERE CD_NOM != ''";
$resultats = $this->executerRequeter($requete);
foreach ($resultats as $nom) {
extract($nom);
$nomen =array('nom_supra_generique' => 'nom_supra_generique=""', 'genre' => 'genre=""',
'epithete_infra_generique' => 'epithete_infra_generique=""', 'epithete_sp' => 'epithete_sp=""',
'type_epithete' => 'type_epithete=""', 'epithete_infra_sp' => 'epithete_infra_sp=""',
'cultivar_groupe' => 'cultivar_groupe=""', 'cultivar' => 'cultivar=""', 'nom_commercial' => 'nom_commercial=""');
$parties_noms = explode(' ', $nom_sci);
if ($rang < 220) {
$nomen['nom_supra_generique'] = 'nom_supra_generique="'.$nom_sci.'"';
} elseif ($rang == 220) {
$nomen['genre'] = 'genre="'.trim($nom_sci).'"';
} elseif ($rang < 290) {
$nomen['genre'] = 'genre="'.$parties_noms[0].'"';
$nomen['epithete_infra_generique'] = 'epithete_infra_generique="'.$parties_noms[1].'"';
} else {
$nomen = array_merge($nomen, $this->decouperEspece($parties_noms));
$hybride = $this->etreHybride($parties_noms);
if (isset($parties_noms[2]) && ($hybride === false || $hybride > 2)) {
$nomen = array_merge($nomen, $this->decouperSousEspece($parties_noms));
}
}
$update = "UPDATE {$this->referentiel}_taxref SET ".implode(' , ', $nomen)." WHERE num_nom = ".$num_nom;
$resultat = $this->executerRequeter($update);
}
return $nomen;
}
private function decouperSousEspece($parties_noms) {
if ($this->etreTypeSousEpithete($parties_noms[2]) == true) {
$nomen['type_epithete'] = 'type_epithete="'.$parties_noms[2].'"';
$nomen['epithete_infra_sp'] = 'epithete_infra_sp="'.$parties_noms[3].'"';
} elseif (strpos($parties_noms[2], '(') === 0) {
$nomen['cultivar_groupe'] = 'cultivar_groupe="'.trim($parties_noms[2], "(").'"';
} elseif (strpos($parties_noms[2], "'") === 0) {
$nomen['cultivar'] = 'cultivar="'.trim($parties_noms[2], "'").'"';
} elseif (ctype_upper($parties_noms[2]) === true) {
$nomen['nom_commercial'] = 'nom_commercial="'.$parties_noms[2].'"';
} else {
$nomen['epithete_infra_sp'] = 'epithete_infra_sp="'.$parties_noms[2].'"';
}
return $nomen;
}
private function etreTypeSousEpithete($chaine) {
$type = false;
$types_epithete = array('subsp.', 'infra-sp.', 'var.', 'subvar.', 'f.', 'subf.', 'f. sp.', 'race', 'proles');
if (in_array(utf8_encode($chaine), $types_epithete)) {
$type = true;
}
return $type;
}
private function decouperEspece($parties_noms) {
$nomen['genre'] = 'genre="'.$parties_noms[0].'"';
$nomen['epithete_sp'] = 'epithete_sp="'.$parties_noms[1].'"';
$hybride = $this->etreHybride($parties_noms);
$chimere = array_search('+', $parties_noms);
if ($hybride != false || $hybride===0) {
$nomen = $this->decouperEspeceHybride($hybride, $parties_noms);
}
return $nomen;
}
private function etreHybride($parties_noms) {
$hybride = array_search('x', $parties_noms);
return $hybride;
}
private function decouperEspeceHybride($hybride, $parties_noms) {
if ($hybride == 0) {
$nomen['genre'] = 'genre="'.$parties_noms[0].' '.$parties_noms[1].'"';
$nomen['epithete_sp'] = 'epithete_sp="'.$parties_noms[2].'"';
} elseif ($hybride == 1 && count($parties_noms) == 4) {
$nomen['genre'] = 'genre="'.$parties_noms[0].' '.$parties_noms[1].' '.$parties_noms[2].'"';
$nomen['epithete_sp'] = 'epithete_sp="'.$parties_noms[3].'"';
} elseif ($hybride == 1 && count($parties_noms) == 3) {
$nomen['genre'] = 'genre="'.$parties_noms[0].'"';
$nomen['epithete_sp'] = 'epithete_sp="'.$parties_noms[1].' '.$parties_noms[2].'"';
} elseif ($hybride == 2) {
$nomen['genre'] = 'genre="'.$parties_noms[0].'"';
$nomen['epithete_sp'] = 'epithete_sp="'.$parties_noms[1].' '.$parties_noms[2].' '.$parties_noms[3].'"';
}
return $nomen;
}
// +-------------------------------------------------------------------------------------------------------------------+
private function ecrireFichierCsv(&$contenu, $fichier) {
$retour = true;
$fichier = fopen($fichier, "w");
fputcsv($fichier, $this->noms_colonnes, chr('9'));
foreach ($contenu as $ligne) {
if (fputcsv($fichier, $ligne, chr('9')) == false) {
$e = "Une erreur est survenu lors de l'écriture du fichier : $fichier";
Debug::printr($e);
$retour = false;
}
}
$contenu = null;
return $retour;
}
private function connecterPDO() {
Config::charger('./configurations/bdd.ini');
try {
$dsn = Config::get('bdd_type').':dbname='.Config::get('bdd_nom').';host='.
Config::get('bdd_hote');
//$dsn = "mysql:dbname=referentiels;host=localhost";
$this->bdd = new PDO($dsn, Config::get('bdd_utilisateur'), Config::get('bdd_mot_de_passe'));
} catch (PDOException $e) {
print_r($e);
echo 'La connexion à la base de donnée via PDO a échouée : ' . $e->getMessage();
}
// Passe en UTF-8 la connexion à la BDD
$this->bdd->exec("SET NAMES 'utf8'");
// Affiche les erreurs détectées par PDO (sinon mode silencieux => aucune erreur affiché)
$this->bdd->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
protected function executerRequeter($requete) {
$infos = null;
try {
$infos = $this->bdd->query($requete);
if ($infos === false) {
echo $requete;
}
} catch (PDOException $e) {
echo sprintf($e->getFile(), $e->getLine(), $e->getMessage(), $e->getCode(), $requete);
}
return $infos;
}
}
?>

/branches/v2.0-betulales/scripts/modules/famille/Famille.php
New file
0,0 → 1,109
<?php
// Encodage : UTF-8
// +-------------------------------------------------------------------------------------------------------------------+
/**
* Versionnage de référentiels de nomenclature et taxonomie
*
* Description : classe permettant de versionner les référentiels selon le manuel technique
* Utilisation : php script.php famille -r bdtfx_v2_00
*
//Auteur original :
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Tela-Botanica 1999-2010
* @link http://www.tela-botanica.org/wikini/RTaxMethodo/wakka.php?wiki=MaNuel
* @licence GPL v3 & CeCILL v2
* @version $Id$
*/
// +-------------------------------------------------------------------------------------------------------------------+
// TODO : lors de la génération de la version 2 de la BDTFX tester les diff! Il se peut que la mémoire soit dépassée.
class Famille extends ScriptCommande {
const SCRIPT_NOM = 'famille';
private $referentielDao = null;
public $parametres = array(
'-r' => array(true, true, 'referentiel'));
public function executer() {
$this->referentielDao = new ReferentielDao();
// Récupération du dernier traitement demandé
$referentiel = $this->getParam('r');
$resultats = $this->referentielDao->preparerTablePrChpFamille($referentiel);
$noms = array();
$introuvables = array();
$introuvablesSyno = array();
$i = 1;
while(true) {
printf("passe n°%d:\n", $i);
$this->traiterResultatsFamille($resultats, $noms, $introuvables, $introuvablesSyno);
echo "\n\n";
// printf("noms: %d, introuvables: %d, introuvablesSyno: %d\n", count($noms), count($introuvables), count($introuvablesSyno));
// XXX, au 22/07/2013, 3 passes sont suffisantes
// TODO: MySQL procédure stockée !
if($i++ == 3) break;
$resultats = array_merge($resultats, $introuvables, $introuvablesSyno);
$introuvables = $introuvablesSyno = array();
}
foreach ($introuvablesSyno as $id => $nom) {
$nn = $nom['num_nom'];
$nnr = $nom['num_nom_retenu'];
if (isset($noms[$nnr])) {
$noms[$nn] = $noms[$nnr];
} else {
$introuvables[] = $nn;
}
unset($introuvablesSyno[$id]);
}
echo "\n";
/*$msg = 'Plusieurs familles sont introuvables';
$this->creerFichierLog($msg, $introuvables, 'famille_introuvable');*/
$this->referentielDao->remplirChpFamille($referentiel, $noms);
}
private function traiterResultatsFamille(&$resultats, &$noms, &$introuvables, &$introuvablesSyno) {
foreach ($resultats as $id => $nom) {
$nn = $nom['num_nom'];
$nnr = $nom['num_nom_retenu'];
$nts = $nom['num_tax_sup'];
$rg = $nom['rang'];
if ($nnr != '') {
if ($rg == '180') {
$noms[$nn] = $nom['nom_sci'];
} else {
if ($nn == $nnr) {
// nom retenu
if (isset($noms[$nts])) {
// signifie que recupererTuplesPrChpFamille() devrait
// récupérer ce record *avant*
$noms[$nn] = $noms[$nts];
} else {
$introuvables[] = $nn;
}
} else {// nom synonyme
if (isset($noms[$nnr])) {
// signifie que recupererTuplesPrChpFamille() devrait
// récupérer ce record *avant*
$noms[$nn] = $noms[$nnr];
} else {
$introuvablesSyno[] = $nom;
}
}
}
}
unset($resultats[$id]);
}
}
}
?>