Subversion Repositories Applications.referentiel

Rev

Rev 64 | Rev 146 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
20 jpm 1
<?php
2
// Encodage : UTF-8
3
// +-------------------------------------------------------------------------------------------------------------------+
4
/**
5
* Tests de référentiels de nomenclature et taxonomie
6
*
7
* Description : classe permettant de tester les référentiels selon le manuel technique
8
* Utilisation : php script.php tests -p bdnff -a tout
9
*
10
//Auteur original :
11
* @author       Jean-Pascal MILCENT <jpm@tela-botanica.org>
12
* @copyright	Tela-Botanica 1999-2010
13
* @link			http://www.tela-botanica.org/wikini/RTaxMethodo/wakka.php?wiki=MaNuel
14
* @licence		GPL v3 & CeCILL v2
15
* @version		$Id$
16
*/
17
// +-------------------------------------------------------------------------------------------------------------------+
38 jpm 18
// TODO : supprimer l'utilisation du paramêtres 'p' et chercher les infos depuis la bdd
20 jpm 19
class Tests extends ScriptCommande {
20
 
42 jpm 21
	const SCRIPT_NOM = 'tests';
22
 
20 jpm 23
	private $projet = null;
30 jpm 24
	private $traitement = null;
20 jpm 25
 
26
	private $manuel = null;
64 jpm 27
	private $noms = null;
20 jpm 28
 
30 jpm 29
	private $resultatDao = null;
30
	private $traitementDao = null;
31
	private $tableStructureDao = null;
32
	private $referentielDao = null;
33
 
20 jpm 34
	public function executer() {
35
		// Récupération de paramêtres
36
		$this->projet = $this->getParam('p');
38 jpm 37
		$this->manuel = parse_ini_file(Config::get('chemin_appli').DS.'..'.DS.'configurations'.DS.'referentiel_v2.1.ini');
20 jpm 38
 
30 jpm 39
		$this->resultatDao = new ResultatDao();
40
		$this->traitementDao = new TraitementDao();
97 jpm 41
		Debug::printr('Dans le script test');
30 jpm 42
		// Récupération du dernier traitement demandé
42 jpm 43
		$this->traitement = $this->traitementDao->getDernierTraitement($this->projet, self::SCRIPT_NOM);
44
		if (isset($this->traitement)) {
38 jpm 45
			Debug::printr($this->traitement);
46
			// Écriture de la date de début du traitement
47
			Debug::printr('Debute:'.$this->traitementDao->debuterTraitement($this->traitement['id_traitement']));
48
 
49
			// Nettoyage des traitements obsolètes
42 jpm 50
			$traitements_obsoletes = $this->traitementDao->getTraitementsObsoletes($this->projet, self::SCRIPT_NOM);
51
			if (isset($traitements_obsoletes)) {
52
				Debug::printr('Supp. obsoletes:'.$this->traitementDao->supprimer($traitements_obsoletes));
53
			}
38 jpm 54
 
55
			// Lancement du test demandé
56
			$cmd = $this->getParam('a');
57
	    	switch ($cmd) {
58
				case 'tout' :
59
					$this->tableStructureDao = new TableStructureDao();
60
					$this->referentielDao = new ReferentielDao();
61
					Debug::printr('Départ lancement test:');
62
					$this->lancerTests();
63
					break;
64
				default :
65
					$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
66
			}
67
			// Écriture de la date de fin du traitement
68
			Debug::printr('Termine:'.$this->traitementDao->terminerTraitement($this->traitement['id_traitement']));
97 jpm 69
		} else {
70
			Debug::printr("Aucun dernier traitement trouvé pour le projet '{$this->projet}' et le script '".self::SCRIPT_NOM."' !");
20 jpm 71
		}
72
    }
73
 
74
    public function lancerTests() {
75
		$donnees = array();
76
		$donnees['tests'] = array();
26 jpm 77
 
20 jpm 78
		// Récupération des données à tester
79
		$colonnes = $this->tableStructureDao->getColonnes($this->projet);
80
		$analyses = $this->tableStructureDao->getAnalyse($this->projet);
64 jpm 81
		$this->noms = $this->referentielDao->getTout($this->projet);
82
		Debug::printr('Nbre noms :'.count($this->noms));
20 jpm 83
 
84
		// Lancement des tests unitaires
64 jpm 85
		$resultats = array();
86
		$resultats[] = $this->testerNombreDeChamps($colonnes);
87
		$resultats[] = $this->testerNomDesChamps($colonnes);
88
		$resultats[] = $this->testerTypeDesChamps($colonnes);
89
		$resultats[] = $this->testerNumNomClePrimaire($colonnes);
20 jpm 90
 
64 jpm 91
		// Si la structure est bonne nous lançons les autres tests
92
		Debug::printr($resultats);
93
		if ($this->verifierResultats($resultats)) {
94
			$this->testerTailleDesChamps($colonnes, $analyses);
95
 
96
			$this->testerNumNomSuperieurAZero();
97
 
98
			$this->testerNumNomRetenuSuperieurAZero();
99
			$this->testerNumTaxSupEgalZeroUnique();
100
			$this->testerTaxSupPourTaxon();
101
			$this->testerExitenceTaxonSuperieur();
102
			$this->testerClassificationRang();
103
			$this->testerClassification();
104
 
105
			$this->testerRang();
106
 
107
			$this->testerNomCompletSupraGenerique();
108
			$this->testerNomCompletGenre();
109
			$this->testerNomCompletInfraGenre();
110
			$this->testerNomCompletEspece();
111
			$this->testerNomCompletInfraSpecifique();
112
 
113
			$this->testerNomSupraGeneriqueEspaces();
114
			$this->testerNomSupraGeneriqueSyntaxe();
115
			$this->testerNomSupraGeneriqueRang();
116
 
117
			$this->testerGenreEspaces();
118
			$this->testerGenreSyntaxe();
119
			$this->testerGenreRang();
120
 
121
			$this->testerEpitheteInfraGeneriqueEspaces();
122
			$this->testerEpitheteInfraGeneriqueSyntaxe();
123
			$this->testerEpitheteInfraGeneriqueRang();
124
 
125
			$this->testerEpitheteSpEspaces();
126
			$this->testerEpitheteSpSyntaxe();
127
			$this->testerEpitheteSpRang();
128
 
129
			$this->testerTypeEpitheteEspaces();
130
			$this->testerTypeEpitheteSyntaxe();
131
			$this->testerTypeEpitheteHybridite();
132
 
133
			$this->testerEpitheteInfraSpEspaces();
134
			$this->testerEpitheteInfraSpSyntaxe();
135
			$this->testerEpitheteInfraSpRang();
136
 
137
			$this->testerGroupeCultivarSyntaxe();
138
			$this->testerGroupeCultivarRang();
139
 
140
			$this->testerCultivarSyntaxe();
141
			$this->testerCultivarRang();
142
 
143
			$this->testerNomCommercialSyntaxe();
144
			$this->testerNomCommercialPresenceCultivar();
145
 
146
			$this->testerAuteurSyntaxe();
147
 
148
			$this->testerAnneeSyntaxe();
149
 
150
			$this->testerBiblioOrigineSyntaxe();
151
 
152
			$this->testerHomonymieSyntaxe();
153
			$this->testerHomonymieExistence();
154
 
155
			$this->testerBasionymeSyntaxe();
156
			$this->testerBasionymeExistence();
157
 
158
			$this->testerSynonymeProparteSyntaxe();
159
			$this->testerSynonymeProparteExistence();
160
 
161
			$this->testerSynonymeDouteuxSyntaxe();
162
 
163
			$this->testerSynonymeMalAppliqueSyntaxe();
164
 
165
			$this->testerSynonymeOrthographiqueSyntaxe();
166
			$this->testerSynonymeOrthographiqueExistence();
167
 
168
			$this->testerHybrideParent01Syntaxe();
169
			$this->testerHybrideParent01Existence();
170
			$this->testerHybrideParent02Syntaxe();
171
			$this->testerHybrideParent02Existence();
172
 
173
			$this->testerPresenceSyntaxe();
174
			$this->testerStatutOrigineSyntaxe();
175
			$this->testerStatutIntroductionSyntaxe();
176
			$this->testerStatutCultureSyntaxe();
177
		}
20 jpm 178
	}
64 jpm 179
	private function verifierResultats($resultats) {
180
		$ok = true;
181
		foreach ($resultats as $resultat) {
182
			if ($resultat == '0') {
183
				$ok = false;
184
				break;
185
			}
186
		}
187
		return $ok;
188
	}
20 jpm 189
 
190
	//+--------------------------------------------------------------------------------------------------------------+//
30 jpm 191
	// Enregistrement des résultats
192
	private function traiterResultatTest($info) {
64 jpm 193
		Debug::printr($info['nom']);
30 jpm 194
		if (isset($info['message'])) {
195
			if (is_array($info['message'])) {
31 jpm 196
				$info['message'] = $this->getVue('tests/squelettes/message_table', $info);
197
			} else {
198
				$info['message'] = $this->getVue('tests/squelettes/message_p', $info);
30 jpm 199
			}
200
		}
201
		$this->resultatDao->ajouter($this->traitement['id_traitement'], $info);
64 jpm 202
		$info = null;
30 jpm 203
	}
204
 
205
	//+--------------------------------------------------------------------------------------------------------------+//
20 jpm 206
	// TESTS
207
 
64 jpm 208
	private function testerStatutCultureSyntaxe() {
30 jpm 209
		$info = array('nom' => 'statut_culture -> syntaxe',
20 jpm 210
			'description' => "Le champ statut_culture peut contenir :\n".
211
			" - le symbole tiret «-» une autre information non référencée...\n".
212
			" - une première lettre en majuscule indiquant le code standard attribué à ce taxon.\n".
213
			" - Cette première lettre peut être suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant ".
214
			"un code de présence spécifique au référentiel.",
215
			'resultat' => false);
216
 
217
		// Réalisation du test
218
		$noms_erreur = array();
64 jpm 219
		foreach ($this->noms as &$nom) {
20 jpm 220
			if ($nom['statut_culture'] != '') {
221
				if (!$this->verifierStatutCulture($nom['statut_culture'])) {
222
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture']);
223
				}
224
			}
225
		}
226
 
227
		// Analyse des résultats
228
		if (count($noms_erreur) > 0) {
229
			$info['message']['entete'] = array('num_nom', 'statut_culture erroné');
230
			$info['message']['lignes'] = $noms_erreur;
231
		} else {
232
			$info['resultat'] = true;
233
		}
64 jpm 234
		$noms_erreur = null;
20 jpm 235
 
30 jpm 236
		$this->traiterResultatTest($info);
20 jpm 237
	}
238
 
64 jpm 239
	private function testerStatutIntroductionSyntaxe() {
30 jpm 240
		$info = array('nom' => 'statut_introduction -> syntaxe',
20 jpm 241
			'description' => "Le champ statut_introduction peut contenir :\n".
242
			" - le symbole tiret «-» une autre information non référencée...\n".
243
			" - une première lettre en majuscule indiquant le code standard attribué à ce taxon.\n".
244
			" - Cette première lettre peut être suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant ".
245
			"un code de présence spécifique au référentiel.",
246
			'resultat' => false);
247
 
248
		// Réalisation du test
249
		$noms_erreur = array();
64 jpm 250
		foreach ($this->noms as &$nom) {
20 jpm 251
			if ($nom['statut_introduction'] != '') {
252
				if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
253
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction']);
254
				}
255
			}
256
		}
257
 
258
		// Analyse des résultats
259
		if (count($noms_erreur) > 0) {
260
			$info['message']['entete'] = array('num_nom', 'statut_introduction erroné');
261
			$info['message']['lignes'] = $noms_erreur;
262
		} else {
263
			$info['resultat'] = true;
264
		}
64 jpm 265
		$noms_erreur = null;
20 jpm 266
 
30 jpm 267
		$this->traiterResultatTest($info);
20 jpm 268
	}
269
 
64 jpm 270
	private function testerStatutOrigineSyntaxe() {
30 jpm 271
		$info = array('nom' => 'statut_origine -> syntaxe',
20 jpm 272
			'description' => "Le champ statut_origine peut contenir :\n".
273
			" - le symbole tiret «-» une autre information non référencée...\n".
274
			" - une première lettre en majuscule indiquant le code standard attribué à ce taxon.\n".
275
			" - Cette première lettre peut être suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant ".
276
			"un code de présence spécifique au référentiel.",
277
			'resultat' => false);
278
 
279
		// Réalisation du test
280
		$noms_erreur = array();
64 jpm 281
		foreach ($this->noms as &$nom) {
20 jpm 282
			if ($nom['statut_origine'] != '') {
283
				if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
284
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine']);
285
				}
286
			}
287
		}
288
 
289
		// Analyse des résultats
290
		if (count($noms_erreur) > 0) {
291
			$info['message']['entete'] = array('num_nom', 'statut_origine erroné');
292
			$info['message']['lignes'] = $noms_erreur;
293
		} else {
294
			$info['resultat'] = true;
295
		}
64 jpm 296
		$noms_erreur = null;
20 jpm 297
 
30 jpm 298
		$this->traiterResultatTest($info);
20 jpm 299
	}
300
 
64 jpm 301
	private function testerPresenceSyntaxe() {
30 jpm 302
		$info = array('nom' => 'presence -> syntaxe',
20 jpm 303
			'description' => "Le champ presence contient soit :\n".
304
			" - le symbole tiret «-» une autre information non référencée...\n".
305
			" - une première lettre en majuscule indiquant le code standard attribué à ce taxon.\n".
306
			" - Cette première lettre peut être suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant ".
307
			"un code de présence spécifique au référentiel.",
308
			'resultat' => false);
309
 
310
		// Réalisation du test
311
		$noms_erreur = array();
64 jpm 312
		foreach ($this->noms as &$nom) {
20 jpm 313
			if ($nom['presence'] != '') {
314
				if (!$this->verifierPresence($nom['presence'])) {
315
					$noms_erreur[] = array($nom['num_nom'], $nom['presence']);
316
				}
317
			}
318
		}
319
 
320
		// Analyse des résultats
321
		if (count($noms_erreur) > 0) {
322
			$info['message']['entete'] = array('num_nom', 'presence erroné');
323
			$info['message']['lignes'] = $noms_erreur;
324
		} else {
325
			$info['resultat'] = true;
326
		}
64 jpm 327
		$noms_erreur = null;
20 jpm 328
 
30 jpm 329
		$this->traiterResultatTest($info);
20 jpm 330
	}
331
 
64 jpm 332
	private function testerHybrideParent02Existence() {
30 jpm 333
		$info = array('nom' => 'hybride_parent_02 -> existence',
20 jpm 334
			'description' => "Si le champ hybride_parent_02 contient un nombre alors il doit correspondre à une valeur du champ ".
335
			"num_nom.",
336
			'resultat' => false);
337
 
338
		// Réalisation du test
339
		$noms_erreur = array();
64 jpm 340
		foreach ($this->noms as &$nom) {
20 jpm 341
			if ($nom['hybride_parent_02'] != '') {
64 jpm 342
				if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
42 jpm 343
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']));
20 jpm 344
				}
345
			}
346
		}
347
 
348
		// Analyse des résultats
349
		if (count($noms_erreur) > 0) {
350
			$info['message']['entete'] = array('num_nom', 'hybride_parent_02 introuvable');
351
			$info['message']['lignes'] = $noms_erreur;
352
		} else {
353
			$info['resultat'] = true;
354
		}
64 jpm 355
		$noms_erreur = null;
20 jpm 356
 
30 jpm 357
		$this->traiterResultatTest($info);
20 jpm 358
	}
359
 
64 jpm 360
	private function testerHybrideParent02Syntaxe() {
30 jpm 361
		$info = array('nom' => 'hybride_parent_02 -> syntaxe',
20 jpm 362
			'description' => "Le champ hybride_parent_02 contient soit :\n".
363
			" - une valeur vide.\n".
364
			" - un nombre",
365
			'resultat' => false);
366
 
367
		// Réalisation du test
368
		$noms_erreur = array();
64 jpm 369
		foreach ($this->noms as &$nom) {
20 jpm 370
			if ($nom['hybride_parent_02'] != '') {
371
				if (!$this->verifierNombre($nom['hybride_parent_02'])) {
42 jpm 372
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']));
20 jpm 373
				}
374
			}
375
		}
376
 
377
		// Analyse des résultats
378
		if (count($noms_erreur) > 0) {
379
			$info['message']['entete'] = array('num_nom', 'hybride_parent_02 erroné');
380
			$info['message']['lignes'] = $noms_erreur;
381
		} else {
382
			$info['resultat'] = true;
383
		}
64 jpm 384
		$noms_erreur = null;
20 jpm 385
 
30 jpm 386
		$this->traiterResultatTest($info);
20 jpm 387
	}
388
 
389
 
64 jpm 390
	private function testerHybrideParent01Existence() {
30 jpm 391
		$info = array('nom' => 'hybride_parent_01 -> existence',
20 jpm 392
			'description' => "Si le champ hybride_parent_01 contient un nombre alors il doit correspondre à une valeur du champ ".
393
			"num_nom.",
394
			'resultat' => false);
395
 
396
		// Réalisation du test
397
		$noms_erreur = array();
64 jpm 398
		foreach ($this->noms as &$nom) {
20 jpm 399
			if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
64 jpm 400
				if (!isset($this->noms[$nom['hybride_parent_01']])) {
42 jpm 401
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']));
20 jpm 402
				}
403
			}
404
		}
405
 
406
		// Analyse des résultats
407
		if (count($noms_erreur) > 0) {
408
			$info['message']['entete'] = array('num_nom', 'hybride_parent_01 introuvable');
409
			$info['message']['lignes'] = $noms_erreur;
410
		} else {
411
			$info['resultat'] = true;
412
		}
64 jpm 413
		$noms_erreur = null;
20 jpm 414
 
30 jpm 415
		$this->traiterResultatTest($info);
20 jpm 416
	}
417
 
64 jpm 418
	private function testerHybrideParent01Syntaxe() {
30 jpm 419
		$info = array('nom' => 'hybride_parent_01 -> syntaxe',
20 jpm 420
			'description' => "Le champ hybride_parent_01 contient soit :\n".
421
			" - une valeur vide.\n".
422
			" - un nombre",
423
			'resultat' => false);
424
 
425
		// Réalisation du test
426
		$noms_erreur = array();
64 jpm 427
		foreach ($this->noms as &$nom) {
20 jpm 428
			if ($nom['hybride_parent_01'] != '') {
429
				if (!$this->verifierNombre($nom['hybride_parent_01'])) {
42 jpm 430
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']));
20 jpm 431
				}
432
			}
433
		}
434
 
435
		// Analyse des résultats
436
		if (count($noms_erreur) > 0) {
437
			$info['message']['entete'] = array('num_nom', 'hybride_parent_01 erroné');
438
			$info['message']['lignes'] = $noms_erreur;
439
		} else {
440
			$info['resultat'] = true;
441
		}
64 jpm 442
		$noms_erreur = null;
20 jpm 443
 
30 jpm 444
		$this->traiterResultatTest($info);
20 jpm 445
	}
446
 
64 jpm 447
	private function testerSynonymeOrthographiqueExistence() {
30 jpm 448
		$info = array('nom' => 'synonyme_orthographique -> existence',
20 jpm 449
			'description' => "Si le champ synonyme_orthographique contient un nombre alors il doit correspondre à une valeur du champ ".
450
			"num_nom.",
451
			'resultat' => false);
452
 
453
		// Réalisation du test
454
		$noms_erreur = array();
64 jpm 455
		foreach ($this->noms as &$nom) {
20 jpm 456
			if ($nom['synonyme_orthographique'] != '') {
64 jpm 457
				if (!isset($this->noms[$nom['synonyme_orthographique']])) {
20 jpm 458
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique']);
459
				}
460
			}
461
		}
462
 
463
		// Analyse des résultats
464
		if (count($noms_erreur) > 0) {
465
			$info['message']['entete'] = array('num_nom', 'synonyme_orthographique introuvable');
466
			$info['message']['lignes'] = $noms_erreur;
467
		} else {
468
			$info['resultat'] = true;
469
		}
64 jpm 470
		$noms_erreur = null;
20 jpm 471
 
30 jpm 472
		$this->traiterResultatTest($info);
20 jpm 473
	}
474
 
64 jpm 475
	private function testerSynonymeOrthographiqueSyntaxe() {
30 jpm 476
		$info = array('nom' => 'synonyme_orthographique -> syntaxe',
20 jpm 477
			'description' => "Le champ synonyme_orthographique contient soit :\n".
478
			" - une valeur vide.\n".
479
			" - un nombre",
480
			'resultat' => false);
481
 
482
		// Réalisation du test
483
		$noms_erreur = array();
64 jpm 484
		foreach ($this->noms as $nom) {
20 jpm 485
			if ($nom['synonyme_orthographique'] != '') {
486
				if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
487
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique']);
488
				}
489
			}
490
		}
491
 
492
		// Analyse des résultats
493
		if (count($noms_erreur) > 0) {
494
			$info['message']['entete'] = array('num_nom', 'synonyme_orthographique erroné');
495
			$info['message']['lignes'] = $noms_erreur;
496
		} else {
497
			$info['resultat'] = true;
498
		}
64 jpm 499
		$noms_erreur = null;
20 jpm 500
 
30 jpm 501
		$this->traiterResultatTest($info);
20 jpm 502
	}
503
 
64 jpm 504
	private function testerSynonymeMalAppliqueSyntaxe() {
30 jpm 505
		$info = array('nom' => 'synonyme_mal_applique -> syntaxe',
20 jpm 506
			'description' => "Le champ synonyme_mal_applique contient soit :\n".
507
			" - une valeur vide.\n".
508
			" - le chiffre 1",
509
			'resultat' => false);
510
 
511
		// Réalisation du test
512
		$noms_erreur = array();
64 jpm 513
		foreach ($this->noms as &$nom) {
20 jpm 514
			if ($nom['synonyme_mal_applique'] != '') {
515
				if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
516
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique']);
517
				}
518
			}
519
		}
520
 
521
		// Analyse des résultats
522
		if (count($noms_erreur) > 0) {
523
			$info['message']['entete'] = array('num_nom', 'synonyme_mal_applique erroné');
524
			$info['message']['lignes'] = $noms_erreur;
525
		} else {
526
			$info['resultat'] = true;
527
		}
64 jpm 528
		$noms_erreur = null;
20 jpm 529
 
30 jpm 530
		$this->traiterResultatTest($info);
20 jpm 531
	}
532
 
64 jpm 533
	private function testerSynonymeDouteuxSyntaxe() {
30 jpm 534
		$info = array('nom' => 'synonyme_douteux -> syntaxe',
20 jpm 535
			'description' => "Le champ synonyme_douteux contient soit :\n".
536
			" - une valeur vide.\n".
537
			" - le chiffre 1",
538
			'resultat' => false);
539
 
540
		// Réalisation du test
541
		$noms_erreur = array();
64 jpm 542
		foreach ($this->noms as &$nom) {
20 jpm 543
			if ($nom['synonyme_douteux'] != '') {
544
				if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
545
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux']);
546
				}
547
			}
548
		}
549
 
550
		// Analyse des résultats
551
		if (count($noms_erreur) > 0) {
552
			$info['message']['entete'] = array('num_nom', 'synonyme_douteux erroné');
553
			$info['message']['lignes'] = $noms_erreur;
554
		} else {
555
			$info['resultat'] = true;
556
		}
64 jpm 557
		$noms_erreur = null;
20 jpm 558
 
30 jpm 559
		$this->traiterResultatTest($info);
20 jpm 560
	}
561
 
64 jpm 562
	private function testerSynonymeProparteExistence() {
30 jpm 563
		$info = array('nom' => 'synonyme_proparte -> existence',
20 jpm 564
			'description' => "Si le champ synonyme_proparte contient un ou plusieurs nombres alors chacun d'entre eux ".
565
			"doit correspondre à une valeur du champ num_nom.",
566
			'resultat' => false);
567
 
568
		// Réalisation du test
569
		$noms_erreur = array();
64 jpm 570
		foreach ($this->noms as &$nom) {
20 jpm 571
			if ($nom['synonyme_proparte'] != '') {
572
				$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
573
				$num_nom_en_erreur = array();
574
				foreach ($num_nom_a_verifier as $num_nom) {
64 jpm 575
					if (!isset($this->noms[$num_nom])) {
20 jpm 576
						$num_nom_en_erreur[] = $num_nom;
577
					}
578
				}
579
				if (count($nbre_en_erreur) > 0) {
580
					$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur));
581
				}
582
			}
583
		}
584
 
585
		// Analyse des résultats
586
		if (count($noms_erreur) > 0) {
587
			$info['message']['entete'] = array('num_nom', 'synonyme_proparte introuvable');
588
			$info['message']['lignes'] = $noms_erreur;
589
		} else {
590
			$info['resultat'] = true;
591
		}
64 jpm 592
		$noms_erreur = null;
20 jpm 593
 
30 jpm 594
		$this->traiterResultatTest($info);
20 jpm 595
	}
596
 
64 jpm 597
	private function testerSynonymeProparteSyntaxe() {
30 jpm 598
		$info = array('nom' => 'synonyme_proparte -> syntaxe',
20 jpm 599
			'description' => "Le champ synonyme_proparte contient soit :\n".
600
			" - une valeur vide.\n".
601
			" - un nombre.\n".
602
			" - une suite de nombre séparés par des virgules.",
603
			'resultat' => false);
604
 
605
		// Réalisation du test
606
		$noms_erreur = array();
64 jpm 607
		foreach ($this->noms as &$nom) {
20 jpm 608
			if ($nom['synonyme_proparte'] != '') {
609
				if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
610
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte']);
611
				}
612
			}
613
		}
614
 
615
		// Analyse des résultats
616
		if (count($noms_erreur) > 0) {
617
			$info['message']['entete'] = array('num_nom', 'synonyme_proparte erroné');
618
			$info['message']['lignes'] = $noms_erreur;
619
		} else {
620
			$info['resultat'] = true;
621
		}
64 jpm 622
		$noms_erreur = null;
20 jpm 623
 
30 jpm 624
		$this->traiterResultatTest($info);
20 jpm 625
	}
626
 
64 jpm 627
	private function testerBasionymeExistence() {
30 jpm 628
		$info = array('nom' => 'basionyme -> existence',
20 jpm 629
			'description' => "Si le champ basionyme contient un nombre alors il doit correspondre à une valeur du champ ".
630
			"num_nom.",
631
			'resultat' => false);
632
 
633
		// Réalisation du test
634
		$noms_erreur = array();
64 jpm 635
		foreach ($this->noms as &$nom) {
20 jpm 636
			if ($nom['basionyme'] != '') {
64 jpm 637
				if (!isset($this->noms[$nom['basionyme']])) {
20 jpm 638
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme']);
639
				}
640
			}
641
		}
642
 
643
		// Analyse des résultats
644
		if (count($noms_erreur) > 0) {
645
			$info['message']['entete'] = array('num_nom', 'basionyme introuvable');
646
			$info['message']['lignes'] = $noms_erreur;
647
		} else {
648
			$info['resultat'] = true;
649
		}
64 jpm 650
		$noms_erreur = null;
20 jpm 651
 
30 jpm 652
		$this->traiterResultatTest($info);
20 jpm 653
	}
654
 
64 jpm 655
	private function testerBasionymeSyntaxe() {
30 jpm 656
		$info = array('nom' => 'basionyme -> syntaxe',
20 jpm 657
			'description' => "Le champ basionyme contient :\n".
658
			" - un nombre ou une valeur vide.\n",
659
			'resultat' => false);
660
 
661
		// Réalisation du test
662
		$noms_erreur = array();
64 jpm 663
		foreach ($this->noms as &$nom) {
20 jpm 664
			if ($nom['basionyme'] != '') {
665
				if (!$this->verifierNombre($nom['basionyme'])) {
666
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme']);
667
				}
668
			}
669
		}
670
 
671
		// Analyse des résultats
672
		if (count($noms_erreur) > 0) {
673
			$info['message']['entete'] = array('num_nom', 'basionyme erroné');
674
			$info['message']['lignes'] = $noms_erreur;
675
		} else {
676
			$info['resultat'] = true;
677
		}
64 jpm 678
		$noms_erreur = null;
20 jpm 679
 
30 jpm 680
		$this->traiterResultatTest($info);
20 jpm 681
	}
682
 
64 jpm 683
	private function testerHomonymieExistence() {
30 jpm 684
		$info = array('nom' => 'homonyme -> existence',
20 jpm 685
			'description' => "Si le champ homonyme contient «1» alors plusieurs noms doivent posséder la même valeur ".
686
			"dans le champ nom_complet.",
687
			'resultat' => false);
688
 
64 jpm 689
		$noms_homonymie = $this->classerNomsParNomComplet();
690
 
20 jpm 691
		// Réalisation du test
692
		$noms_erreur = array();
64 jpm 693
		foreach ($this->noms as &$nom) {
20 jpm 694
			if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
695
				if ($noms_homonymie[$nom['nom_complet']] <= 1) {
696
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet']);
697
				}
698
			}
699
		}
64 jpm 700
		$noms_homonymie = null;
20 jpm 701
 
702
		// Analyse des résultats
703
		if (count($noms_erreur) > 0) {
704
			$info['message']['entete'] = array('num_nom', 'homonyme introuvable');
705
			$info['message']['lignes'] = $noms_erreur;
706
		} else {
707
			$info['resultat'] = true;
708
		}
64 jpm 709
		$noms_erreur = null;
20 jpm 710
 
30 jpm 711
		$this->traiterResultatTest($info);
20 jpm 712
	}
713
 
64 jpm 714
	private function testerHomonymieSyntaxe() {
30 jpm 715
		$info = array('nom' => 'homonyme -> syntaxe',
20 jpm 716
			'description' => "Le champ homonyme contient :\n".
717
			" - le chiffre 1 ou une valeur vide.\n",
718
			'resultat' => false);
719
 
720
		// Réalisation du test
721
		$noms_erreur = array();
64 jpm 722
		foreach ($this->noms as &$nom) {
20 jpm 723
			if ($nom['homonyme'] != '') {
724
				if (!$this->verifierBooleen($nom['homonyme'])) {
725
					$noms_erreur[] = array($nom['num_nom'], $nom['homonyme']);
726
				}
727
			}
728
		}
729
 
730
		// Analyse des résultats
731
		if (count($noms_erreur) > 0) {
732
			$info['message']['entete'] = array('num_nom', 'homonyme erroné');
733
			$info['message']['lignes'] = $noms_erreur;
734
		} else {
735
			$info['resultat'] = true;
736
		}
64 jpm 737
		$noms_erreur = null;
20 jpm 738
 
30 jpm 739
		$this->traiterResultatTest($info);
20 jpm 740
	}
741
 
64 jpm 742
	private function testerBiblioOrigineSyntaxe() {
30 jpm 743
		$info = array('nom' => 'biblio_origine -> syntaxe',
20 jpm 744
			'description' => "Le champ biblio_origine se compose de plusieurs parties séparées par des caractères ".
745
			"précis qui sont dans l'ordre de gauche à droite :\n".
746
			" - Éventuellement le mot « in » suivi d'un intitulé auteur (utilisé pour indiquer l'intitulé auteur de ".
747
			"l'ouvrage global dans lequel la publication est parue).\n".
748
			" - point-virgule « ; » (si l'info précédent a été renseignée)\n".
749
			" - Abréviation ou nom de l'ouvrage ou de la revue selon le standard en vigueur dans le code du nom. ".
750
			"Cette information ne doit pas contenir de caractère virgule « , ».\n".
751
			" - virgule « , »\n".
752
			" - Les informations permettant d'identifier plus précisément le document contenant le nom... ".
753
			"Par exemple, l'éditeur, le tome, le numéro d'édition, le volume... séparées par des virgules ou d'autres ".
754
			"caractères sauf deux points « : ».\n".
755
			" - deux points « : »\n".
756
			" - la page contenant la publication du nom ou un ensemble de page (première et dernière page de ".
757
			"l'ensemble séparées par un tiret « - »). Quelques fois des numéros ou d'autres informations indiquant ".
758
			"dans le document la position du nom. Le tiret « - » doit toujours servir à séparer un ensemble.",
759
			'resultat' => false);
760
 
761
		// Réalisation du test
762
		$noms_erreur = array();
64 jpm 763
		foreach ($this->noms as &$nom) {
20 jpm 764
			if ($nom['biblio_origine'] != '') {
765
				if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
766
					$biblio_traite = $this->repererEspace($nom['biblio_origine']);
767
					$noms_erreur[] = array($nom['num_nom'], $biblio_traite);
768
				}
769
			}
770
		}
771
 
772
		// Analyse des résultats
773
		if (count($noms_erreur) > 0) {
774
			$info['message']['entete'] = array('num_nom', 'biblio_origine erroné');
775
			$info['message']['lignes'] = $noms_erreur;
776
		} else {
777
			$info['resultat'] = true;
778
		}
64 jpm 779
		$noms_erreur = null;
20 jpm 780
 
30 jpm 781
		$this->traiterResultatTest($info);
20 jpm 782
	}
783
 
64 jpm 784
	private function testerAnneeSyntaxe() {
30 jpm 785
		$info = array('nom' => 'annee -> syntaxe',
20 jpm 786
			'description' => "Le champ annee doit :\n".
787
			" - contenir un nombre de 4 chiffre\n".
788
			" - être supérieur ou égal à 1753 ",
789
			'resultat' => false);
790
 
791
		// Réalisation du test
792
		$noms_erreur = array();
64 jpm 793
		foreach ($this->noms as &$nom) {
20 jpm 794
			if ($nom['annee'] != '') {
795
				if (!$this->verifierAnnee($nom['annee'])) {
796
					$noms_erreur[] = array($nom['num_nom'], $nom['annee']);
797
				}
798
			}
799
		}
800
 
801
		// Analyse des résultats
802
		if (count($noms_erreur) > 0) {
803
			$info['message']['entete'] = array('num_nom', 'annee erroné');
804
			$info['message']['lignes'] = $noms_erreur;
805
		} else {
806
			$info['resultat'] = true;
807
		}
64 jpm 808
		$noms_erreur = null;
20 jpm 809
 
30 jpm 810
		$this->traiterResultatTest($info);
20 jpm 811
	}
812
 
64 jpm 813
	private function testerAuteurSyntaxe() {
30 jpm 814
		$info = array('nom' => 'auteur -> syntaxe',
20 jpm 815
			'description' => "Le champ auteur doit :\n".
816
			" - contenir l'intitulé complet des noms de l'auteur ou des auteurs ayant publiés à l'origine la combinaison latine courante.\n".
817
    		" - ou débuter par le mot « sensu » et contient l'intitulé complet des noms de l'auteur ou des auteurs ayant publiés un nom dont la description ne correspond pas à celle de l'auteur ou des auteurs d'origine.\n".
818
			" - 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 ( ).\n".
819
			" - contenir, si nécessaire, des abréviations de noms d'auteurs respectant les standards.\n".
820
			" - contenir une translittération des noms d'alphabet cyrillique, arabe, chinois... en alphabet latin.\n".
821
			" - inclure entre parenthèses l'intitulé des noms de l'auteur ou des auteurs ayant publié le basionyme.\n".
822
			" - toujours utiliser l'esperluette (&) à la place du mot « et » pour séparer les noms d'auteurs.\n".
823
			" - conformément à la recommandation 46C.2 du CINB, si une un citation comprend plus de deux auteurs, ".
824
			"elle devrait être limitée au nom du premier, suivi de « & al.».\n",
825
			'resultat' => false);
826
 
827
		// Réalisation du test
828
		$noms_erreur = array();
64 jpm 829
		foreach ($this->noms as &$nom) {
20 jpm 830
			if ($nom['auteur'] != '') {
831
				if (!$this->verifierAuteur($nom['auteur'])) {
832
					$intitule_traite = $this->repererEspace($nom['auteur']);
833
					$noms_erreur[] = array($nom['num_nom'], $intitule_traite);
834
				}
835
			}
836
		}
837
 
838
		// Analyse des résultats
839
		if (count($noms_erreur) > 0) {
840
			$info['message']['entete'] = array('num_nom', 'auteur erroné');
841
			$info['message']['lignes'] = $noms_erreur;
842
		} else {
843
			$info['resultat'] = true;
844
		}
64 jpm 845
		$noms_erreur = null;
20 jpm 846
 
30 jpm 847
		$this->traiterResultatTest($info);
20 jpm 848
	}
849
 
64 jpm 850
	private function testerNomCommercialSyntaxe() {
30 jpm 851
		$info = array('nom' => 'nom_commercial -> syntaxe',
20 jpm 852
			'description' => "Le champ nom_commercial doit contenir un nom commercial conforme aux règles du ".
853
				"Code Internationnal de Nomenclature des Plantes Cultivées (CINPC) ".
854
				"qui se compose de caractères majuscules (A-Z) incluant des signes diacritiques et des espaces.\n",
855
			'resultat' => false);
856
 
857
		// Réalisation du test
858
		$noms_erreur = array();
64 jpm 859
		foreach ($this->noms as &$nom) {
20 jpm 860
			if ($nom['nom_commercial'] != '') {
861
				if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
862
					$epithete_traite = $this->repererEspace($nom['nom_commercial']);
863
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
864
				}
865
			}
866
		}
867
 
868
		// Analyse des résultats
869
		if (count($noms_erreur) > 0) {
870
			$info['message']['entete'] = array('num_nom', 'cultivar erroné');
871
			$info['message']['lignes'] = $noms_erreur;
872
		} else {
873
			$info['resultat'] = true;
874
		}
64 jpm 875
		$noms_erreur = null;
20 jpm 876
 
30 jpm 877
		$this->traiterResultatTest($info);
20 jpm 878
	}
879
 
64 jpm 880
	private function testerNomCommercialPresenceCultivar() {
30 jpm 881
		$info = array('nom' => 'nom_commercial -> groupe_cultivar OU cultivar non vide',
20 jpm 882
			'description' => "Si le champ nom_commercial contier un nom commercial alors le champ cultivar OU ".
883
				"cultivar_groupe ne doit pas être vide.",
884
			'resultat' => false);
885
 
886
		// Réalisation du test
887
		$noms_erreur = array();
64 jpm 888
		foreach ($this->noms as &$nom) {
889
			if ((isset($nom['nom_commercial']) && $nom['nom_commercial'] != '') && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
20 jpm 890
				$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet']);
891
			}
892
		}
893
 
894
		// Analyse des résultats
895
		if (count($noms_erreur) > 0) {
896
			$info['message']['entete'] = array('num_nom', 'nom_commercial sans cultivar ou cultivar_groupe');
897
			$info['message']['lignes'] = $noms_erreur;
898
		} else {
899
			$info['resultat'] = true;
900
		}
64 jpm 901
		$noms_erreur = null;
20 jpm 902
 
30 jpm 903
		$this->traiterResultatTest($info);
20 jpm 904
	}
905
 
64 jpm 906
	private function testerCultivarSyntaxe() {
30 jpm 907
		$info = array('nom' => 'cultivar -> syntaxe',
20 jpm 908
			'description' => "Le champ cultivar_groupe doit contenir :\n".
909
				" - un nom de cultivar conforme aux règles du Code Internationnal de Nomenclature des Plantes ".
910
				"Cultivées (CINPC) qui se compose de caractères alphanumériques (A-Z,a-z et 0-9) incluant ".
911
				"signes diacritiques et marques de ponctuations.\n".
912
				" - un nom en alphabet latin ce qui implique une translittération des noms d'alphabet cyrillique, ".
913
				"arabe, chinois...\n".
914
				" - une lettre majuscule obligatoire pour le premier caractère du premier mot et pour les autres mots ".
915
				"importants mais pas pour les mots mineurs.\n".
916
				"Ne doit pas contenir :\n".
917
				" - cv., convar. ou de guillemets simples (').\n",
918
			'resultat' => false);
919
 
920
		// Réalisation du test
921
		$noms_erreur = array();
64 jpm 922
		foreach ($this->noms as &$nom) {
20 jpm 923
			if ($nom['cultivar'] != '') {
924
				if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
925
					$epithete_traite = $this->repererEspace($nom['cultivar']);
926
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
927
				}
928
			}
929
		}
930
 
931
		// Analyse des résultats
932
		if (count($noms_erreur) > 0) {
933
			$info['message']['entete'] = array('num_nom', 'cultivar erroné');
934
			$info['message']['lignes'] = $noms_erreur;
935
		} else {
936
			$info['resultat'] = true;
937
		}
64 jpm 938
		$noms_erreur = null;
20 jpm 939
 
30 jpm 940
		$this->traiterResultatTest($info);
20 jpm 941
	}
942
 
64 jpm 943
	private function testerCultivarRang() {
30 jpm 944
		$info = array('nom' => "cultivar -> rang >= {$this->manuel['rang_genre']}",
20 jpm 945
			'description' => "Si le champ cultivar n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.",
946
			'resultat' => false);
947
 
948
		// Réalisation du test
949
		$noms_erreur = array();
64 jpm 950
		foreach ($this->noms as &$nom) {
20 jpm 951
			if ($nom['cultivar'] != '') {
952
				if ($nom['rang'] < $this->manuel['rang_genre']) {
953
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
954
				}
955
			}
956
		}
957
 
958
		// Analyse des résultats
959
		if (count($noms_erreur) > 0) {
960
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
961
			$info['message']['lignes'] = $noms_erreur;
962
		} else {
963
			$info['resultat'] = true;
964
		}
64 jpm 965
		$noms_erreur = null;
20 jpm 966
 
30 jpm 967
		$this->traiterResultatTest($info);
20 jpm 968
	}
969
 
64 jpm 970
	private function testerGroupeCultivarSyntaxe() {
30 jpm 971
		$info = array('nom' => 'cultivar_groupe -> syntaxe',
20 jpm 972
			'description' => "Le champ cultivar_groupe doit contenir un nom de groupe de cultivar conforme aux règles ".
973
				"du code des plantes cultivées qui se compose de caractères alphanumériques (A-Z,a-z et 0-9) incluant ".
974
				"signes diacritiques et marques de ponctuations.\n".
975
				"Il ne doit pas contenir le mot Groupe, l'abbréviation «gp» ou des parenthèses.\n".
976
				"Il peut contir à la fin l'abréviation «gx» pour distinguer les groupes des grex.",
977
			'resultat' => false);
978
 
979
		// Réalisation du test
980
		$noms_erreur = array();
64 jpm 981
		foreach ($this->noms as &$nom) {
20 jpm 982
			if ($nom['cultivar_groupe'] != '') {
983
				if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
984
					$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
985
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
986
				}
987
			}
988
		}
989
 
990
		// Analyse des résultats
991
		if (count($noms_erreur) > 0) {
992
			$info['message']['entete'] = array('num_nom', 'cultivar_groupe erroné');
993
			$info['message']['lignes'] = $noms_erreur;
994
		} else {
995
			$info['resultat'] = true;
996
		}
64 jpm 997
		$noms_erreur = null;
20 jpm 998
 
30 jpm 999
		$this->traiterResultatTest($info);
20 jpm 1000
	}
1001
 
64 jpm 1002
	private function testerGroupeCultivarRang() {
30 jpm 1003
		$info = array('nom' => "cultivar_groupe -> rang >= {$this->manuel['rang_genre']}",
20 jpm 1004
			'description' => "Si le champ cultivar_groupe n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.",
1005
			'resultat' => false);
1006
 
1007
		// Réalisation du test
1008
		$noms_erreur = array();
64 jpm 1009
		foreach ($this->noms as &$nom) {
20 jpm 1010
			if ($nom['cultivar_groupe'] != '') {
1011
				if ($nom['rang'] < $this->manuel['rang_genre']) {
1012
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
1013
				}
1014
			}
1015
		}
1016
 
1017
		// Analyse des résultats
1018
		if (count($noms_erreur) > 0) {
1019
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
1020
			$info['message']['lignes'] = $noms_erreur;
1021
		} else {
1022
			$info['resultat'] = true;
1023
		}
64 jpm 1024
		$noms_erreur = null;
20 jpm 1025
 
30 jpm 1026
		$this->traiterResultatTest($info);
20 jpm 1027
	}
1028
 
64 jpm 1029
	private function testerEpitheteInfraSpEspaces() {
30 jpm 1030
		$info = array('nom' => 'epithete_infra_sp -> espaces en trop',
20 jpm 1031
			'description' => "Le champ epithete_infra_sp ne doit pas contenir d'espace avant ou aprés le nom.\n".
1032
				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
1033
			'resultat' => false);
1034
 
1035
		// Réalisation du test
1036
		$noms_erreur = array();
64 jpm 1037
		foreach ($this->noms as &$nom) {
20 jpm 1038
			if ($nom['epithete_infra_sp'] != '') {
1039
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) {
1040
					$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
1041
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
1042
				}
1043
			}
1044
		}
1045
 
1046
		// Analyse des résultats
1047
		if (count($noms_erreur) > 0) {
1048
			$info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné');
1049
			$info['message']['lignes'] = $noms_erreur;
1050
		} else {
1051
			$info['resultat'] = true;
1052
		}
64 jpm 1053
		$noms_erreur = null;
20 jpm 1054
 
30 jpm 1055
		$this->traiterResultatTest($info);
20 jpm 1056
	}
1057
 
64 jpm 1058
	private function testerEpitheteInfraSpSyntaxe() {
30 jpm 1059
		$info = array('nom' => 'epithete_infra_sp -> syntaxe',
20 jpm 1060
			'description' => "Le champ epithete_infra_sp peut contenir :\n".
1061
			 	" - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
1062
				"	Il commence par une lettre minuscule (avec ou sans tréma).\n".
1063
				"	Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n".
1064
				" - 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 \n".
1065
				"	par la lettre x entourée de caractères espaces.",
1066
			'resultat' => false);
1067
 
1068
		// Réalisation du test
1069
		$noms_erreur = array();
64 jpm 1070
		foreach ($this->noms as &$nom) {
20 jpm 1071
			if ($nom['epithete_infra_sp'] != '') {
1072
				$mots = explode(' ', $nom['epithete_infra_sp']);
1073
				foreach ($mots as $mot) {
1074
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpitheteSp($mot))) {
1075
						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
1076
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
1077
					}
1078
				}
1079
			}
1080
		}
1081
 
1082
		// Analyse des résultats
1083
		if (count($noms_erreur) > 0) {
1084
			$info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné');
1085
			$info['message']['lignes'] = $noms_erreur;
1086
		} else {
1087
			$info['resultat'] = true;
1088
		}
64 jpm 1089
		$noms_erreur = null;
20 jpm 1090
 
30 jpm 1091
		$this->traiterResultatTest($info);
20 jpm 1092
	}
1093
 
64 jpm 1094
	private function testerEpitheteInfraSpRang() {
30 jpm 1095
		$info = array('nom' => "epithete_infra_sp -> rang > {$this->manuel['rang_sp']}",
20 jpm 1096
			'description' => "Si le champ epithete_infra_sp n'est pas vide alors le rang du nom doit être supérieur à {$this->manuel['rang_sp']}.",
1097
			'resultat' => false);
1098
 
1099
		// Réalisation du test
1100
		$noms_erreur = array();
64 jpm 1101
		foreach ($this->noms as &$nom) {
20 jpm 1102
			if ($nom['epithete_infra_sp'] != '') {
1103
				if ($nom['rang'] < $this->manuel['rang_sp']) {
1104
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
1105
				}
1106
			}
1107
		}
1108
 
1109
		// Analyse des résultats
1110
		if (count($noms_erreur) > 0) {
1111
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
1112
			$info['message']['lignes'] = $noms_erreur;
1113
		} else {
1114
			$info['resultat'] = true;
1115
		}
64 jpm 1116
		$noms_erreur = null;
20 jpm 1117
 
30 jpm 1118
		$this->traiterResultatTest($info);
20 jpm 1119
	}
1120
 
64 jpm 1121
	private function testerTypeEpitheteEspaces() {
30 jpm 1122
		$info = array('nom' => 'type_epithete -> espaces en trop',
20 jpm 1123
			'description' => "Le champ type_epithete ne doit pas contenir d'espace.",
1124
			'resultat' => false);
1125
 
1126
		// Réalisation du test
1127
		$noms_erreur = array();
64 jpm 1128
		foreach ($this->noms as &$nom) {
20 jpm 1129
			if ($nom['type_epithete'] != '') {
1130
				if (preg_match('/\s+/', $nom['type_epithete'])) {
1131
					$valeur_traitee = $this->repererEspace($nom['epithete_sp']);
1132
					$noms_erreur[] = array($nom['num_nom'], $valeur_traitee);
1133
				}
1134
			}
1135
		}
1136
 
1137
		// Analyse des résultats
1138
		if (count($noms_erreur) > 0) {
1139
			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
1140
			$info['message']['lignes'] = $noms_erreur;
1141
		} else {
1142
			$info['resultat'] = true;
1143
		}
1144
 
30 jpm 1145
		$this->traiterResultatTest($info);
20 jpm 1146
	}
1147
 
64 jpm 1148
	private function testerTypeEpitheteSyntaxe() {
30 jpm 1149
		$info = array('nom' => 'type_epithete -> syntaxe',
20 jpm 1150
			'description' => "Le champ type_epithete doit contenir un mot unique composé de lettres minuscules sans ".
1151
				" accents et de tirets (-). Il commence par une lettre minuscule sans accent.",
1152
			'resultat' => false);
1153
 
1154
		// Réalisation du test
1155
		$noms_erreur = array();
64 jpm 1156
		foreach ($this->noms as &$nom) {
20 jpm 1157
			if ($nom['type_epithete'] != '') {
1158
				if (!$this->verifierTypeEpithete($nom['type_epithete'])) {
1159
					$noms_erreur[] = array($nom['num_nom'],  $nom['type_epithete']);
1160
				}
1161
			}
1162
		}
1163
 
1164
		// Analyse des résultats
1165
		if (count($noms_erreur) > 0) {
1166
			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
1167
			$info['message']['lignes'] = $noms_erreur;
1168
		} else {
1169
			$info['resultat'] = true;
1170
		}
1171
 
30 jpm 1172
		$this->traiterResultatTest($info);
20 jpm 1173
	}
1174
 
64 jpm 1175
	private function testerTypeEpitheteHybridite() {
30 jpm 1176
		$info = array('nom' => 'type_epithete -> hybridité',
20 jpm 1177
			'description' => "Le champ type_epithete ne doit pas contenir de préfixe indiquant l'hybridité comme : \n".
1178
				" - «n-» \n".
1179
				" - «notho-» \n",
1180
			'resultat' => false);
1181
 
1182
		// Réalisation du test
1183
		$noms_erreur = array();
64 jpm 1184
		foreach ($this->noms as &$nom) {
20 jpm 1185
			if ($nom['type_epithete'] != '') {
1186
				if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) {
1187
					$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete']);
1188
				}
1189
			}
1190
		}
1191
 
1192
		// Analyse des résultats
1193
		if (count($noms_erreur) > 0) {
1194
			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
1195
			$info['message']['lignes'] = $noms_erreur;
1196
		} else {
1197
			$info['resultat'] = true;
1198
		}
1199
 
30 jpm 1200
		$this->traiterResultatTest($info);
20 jpm 1201
	}
1202
 
1203
	private function testerNombreDeChamps($colonnes) {
30 jpm 1204
		$info = array('nom' => 'Structure -> nombre de champs',
20 jpm 1205
			'description' => 'Le nombre de champs présent dans la table doit être supérieur ou égal à 35.',
1206
			'resultat' => false);
1207
 
1208
		$nbre_colonnes = count($colonnes);
30 jpm 1209
		$info['message'] = $nbre_colonnes;
20 jpm 1210
		if ($nbre_colonnes >= 35) {
1211
			$info['resultat'] = true;
1212
		}
30 jpm 1213
		$this->traiterResultatTest($info);
64 jpm 1214
		return ($info['resultat'] ? '1' : '0');
20 jpm 1215
	}
1216
 
1217
	private function testerNomDesChamps($colonnes) {
30 jpm 1218
		$info = array('nom' => 'Structure -> noms des champs',
20 jpm 1219
			'description' => 'Les champs de la table contenant le référentiel doivent être conforme à ceux définit par le manuel technique.',
1220
			'resultat' => false);
1221
 
1222
		$champs_attendus = explode(',', $this->manuel['champs']);
1223
		$champs_presents = array();
1224
		foreach ($colonnes as $colonne) {
1225
			$champs_presents[$colonne['Field']] = $colonne;
1226
		}
1227
 
1228
		$ok = true;
1229
		$champs_manquant = array();
1230
		foreach ($champs_attendus as $champ_attendu) {
1231
			if (!isset($champs_presents[$champ_attendu])) {
1232
				$champs_manquant[] = $champ_attendu;
1233
				$ok = false;
1234
			}
1235
		}
1236
		$info['resultat'] = $ok;
1237
		if (!$ok) {
1238
			$info['message'] = 'Champs manquant : '.implode(', ', $champs_manquant).'.';
1239
		}
1240
 
30 jpm 1241
		$this->traiterResultatTest($info);
64 jpm 1242
		return ($info['resultat'] ? '1' : '0');
20 jpm 1243
	}
1244
 
1245
	private function testerTypeDesChamps($colonnes) {
30 jpm 1246
		$info = array('nom' => 'Structure -> types des champs',
20 jpm 1247
			'description' => 'Les types des champs de la table contenant le référentiel doivent être conforme à ceux définit par le manuel technique.',
1248
			'resultat' => false);
1249
 
1250
		$champs_attendus = explode(',', $this->manuel['champs_type']);
1251
		$champs_presents = array();
1252
		foreach ($colonnes as $colonne) {
1253
			$champs_presents[$colonne['Field']] = $colonne['Type'];
1254
		}
1255
 
1256
		// Recercherche des erreurs
1257
		$champs_erreur = array();
1258
		foreach ($champs_attendus as $champ_attendu) {
51 jpm 1259
			list($champ_attendu_nom, $champ_attendu_type_taille) = explode('=', trim($champ_attendu));
1260
			list($champ_attendu_type, $champ_attendu_taille) = explode('|', trim($champ_attendu_type_taille));
1261
 
20 jpm 1262
			if (isset($champs_presents[$champ_attendu_nom])) {
1263
				$champs_present_type = $champs_presents[$champ_attendu_nom];
1264
 
1265
				if (($champ_attendu_type == 'VARCHAR' && strstr($champs_present_type, 'varchar') === false)
1266
					|| ($champ_attendu_type == 'TEXT' && strstr($champs_present_type, 'text') === false)
1267
					|| ($champ_attendu_type == 'INT' && strstr($champs_present_type, 'int') === false)
1268
					|| ($champ_attendu_type == 'BOOL' && preg_match('/(?:bool|boolean|tinyint\(1\))/i', $champs_present_type) === false)) {
1269
					$champs_erreur[] = $champ_attendu." vaut ".$champs_present_type;
1270
				}
1271
			}
1272
		}
1273
 
1274
		// Analyse des résultats
1275
		if (count($champs_erreur) > 0) {
1276
			$info['message'] = "Champs n'ayant pas un bon type : ".implode(', ', $champs_erreur).'.';
1277
		} else {
1278
			$info['resultat'] = true;
1279
		}
1280
 
30 jpm 1281
		$this->traiterResultatTest($info);
64 jpm 1282
		return ($info['resultat'] ? '1' : '0');
20 jpm 1283
	}
1284
 
1285
	private function testerTailleDesChamps($colonnes, $analyses) {
30 jpm 1286
		$info = array('nom' => 'Structure -> champs tronqués',
45 jpm 1287
			'description' => "Vérifie que le risque éventuel que des données de type texte insérées ".
1288
				"dans la table aient pu être tronquées lors de leur insertion.\n".
1289
				"Un résultat de type KO ne signifie pas forcément un problème à résoudre mais attire l'attention du coordinateur ".
1290
				"sur un problème éventuel.",
20 jpm 1291
			'resultat' => false);
1292
 
1293
		$tailles_champs_maxi = array();
1294
		foreach ($colonnes as $colonne) {
1295
			if (preg_match('/^varchar\(([0-9]+)\)$/', $colonne['Type'], $match)) {
1296
				$tailles_champs_maxi[$colonne['Field']] = $match[1];
1297
			}
1298
		}
1299
 
1300
		$tailles_trouvees = array();
1301
		foreach ($analyses as $analyse) {
1302
			if (preg_match('/\.([^.]+)$/', $analyse['Field_name'], $match)) {
1303
				$tailles_trouvees[$match[1]] = $analyse['Max_length'];
1304
			}
1305
		}
1306
 
1307
		$champs_erreur = array();
1308
		$champs_attendus = explode(',', $this->manuel['champs']);
1309
		foreach ($champs_attendus as $champ_attendu) {
1310
			if (isset($tailles_champs_maxi[$champ_attendu]) && isset($tailles_trouvees[$champ_attendu])) {
1311
				if ($tailles_champs_maxi[$champ_attendu] == $tailles_trouvees[$champ_attendu]) {
1312
					$champs_erreur[] = $champ_attendu;
1313
				}
1314
			}
1315
		}
1316
 
1317
		// Analyse des résultats
1318
		if (count($champs_erreur) > 0) {
1319
			$info['message'] = "Champs possédant des enregistrements avec une taille maximum : ".implode(', ', $champs_erreur).'.';
1320
		} else {
1321
			$info['resultat'] = true;
1322
		}
1323
 
30 jpm 1324
		$this->traiterResultatTest($info);
20 jpm 1325
	}
1326
 
1327
	private function testerNumNomClePrimaire($colonnes) {
30 jpm 1328
		$info = array('nom' => 'Structure -> num_nom est clé primaire',
20 jpm 1329
			'description' => "Vérifie que le champ num_nom est bien la clé primaire de la table.",
1330
			'resultat' => false);
1331
 
1332
		foreach ($colonnes as $colonne) {
1333
			if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') {
1334
				$info['resultat'] = true;
1335
			}
1336
		}
1337
 
30 jpm 1338
		$this->traiterResultatTest($info);
64 jpm 1339
		return ($info['resultat'] ? '1' : '0');
20 jpm 1340
	}
1341
 
64 jpm 1342
	private function testerNumNomSuperieurAZero() {
30 jpm 1343
		$info = array('nom' => 'num_nom -> supérieur à 0',
20 jpm 1344
			'description' => "Le champ num_nom doit contenir des nombres entiers supérieurs à 0.",
1345
			'resultat' => false);
1346
 
1347
		// Réalisation du test
1348
		$noms_erreur = array();
64 jpm 1349
		foreach ($this->noms as &$nom) {
20 jpm 1350
			if ($nom['num_nom'] <= 0) {
1351
				$noms_erreur[] = $nom['num_nom'];
1352
			}
1353
		}
1354
 
1355
		// Analyse des résultats
1356
		if (count($noms_erreur) > 0) {
1357
			$info['message'] = count($noms_erreur)." enregistrements contiennent dans le champ num_nom une valeur inférieure ou égale à 0.";
1358
		} else {
1359
			$info['resultat'] = true;
1360
		}
1361
 
30 jpm 1362
		$this->traiterResultatTest($info);
20 jpm 1363
	}
1364
 
64 jpm 1365
	private function testerNumNomRetenuSuperieurAZero() {
30 jpm 1366
		$info = array('nom' => 'num_nom_retenu -> supérieur à 0',
42 jpm 1367
			'description' => "Le champ num_nom_retenu doit contenir des nombres entiers supérieurs à 0 ou être vide.",
20 jpm 1368
			'resultat' => false);
1369
 
1370
		// Réalisation du test
1371
		$noms_erreur = array();
64 jpm 1372
		foreach ($this->noms as &$nom) {
42 jpm 1373
			if ($nom['num_nom_retenu'] != '' && $nom['num_nom_retenu'] <= 0) {
20 jpm 1374
				$noms_erreur[] = $nom['num_nom'];
1375
			}
1376
		}
1377
 
1378
		// Analyse des résultats
1379
		if (count($noms_erreur) > 0) {
1380
			$info['message'] = count($noms_erreur)." enregistrements dont le champ num_nom_retenu est inférieur ou égal à 0 : ".implode(', ', $noms_erreur).'.';
1381
		} else {
1382
			$info['resultat'] = true;
1383
		}
1384
 
30 jpm 1385
		$this->traiterResultatTest($info);
20 jpm 1386
	}
1387
 
64 jpm 1388
	private function testerNumTaxSupEgalZeroUnique() {
30 jpm 1389
		$info = array('nom' => 'num_tax_sup -> égal à 0 unique',
20 jpm 1390
			'description' => "Un seul enregistrement doit posséder la valeur 0 dans le champ num_tax_sup. Il correspond au premier taxon de la classification.",
1391
			'resultat' => false);
1392
 
1393
		// Réalisation du test
1394
		$noms_erreur = array();
64 jpm 1395
		foreach ($this->noms as &$nom) {
20 jpm 1396
			if (preg_match('/^0$/', $nom['num_tax_sup'])) {
1397
				$noms_erreur[] = $nom['num_nom'];
1398
			}
1399
		}
1400
 
1401
		// Analyse des résultats
1402
		if (count($noms_erreur) > 1) {
1403
			$info['message'] = count($noms_erreur)." enregistrements ont une valeur de 0 dans le champ num_tax_sup : ".implode(', ', $noms_erreur).'.';
1404
		} else {
1405
			$info['resultat'] = true;
1406
		}
1407
 
30 jpm 1408
		$this->traiterResultatTest($info);
20 jpm 1409
	}
1410
 
64 jpm 1411
	private function testerTaxSupPourTaxon() {
30 jpm 1412
		$info = array('nom' => 'Classification -> uniquement pour les taxons',
43 jpm 1413
			'description' => "Seul les enregistrements représentant un taxon doivent posséder une valeur dans le champ num_tax_sup.\n".
1414
				"Si num_nom_retenu est différent de num_nom (= nom synonyme) alors num_tax_sup doit être vide.",
20 jpm 1415
			'resultat' => false);
1416
 
1417
		// Réalisation du test
1418
		$noms_erreur = array();
64 jpm 1419
		foreach ($this->noms as &$nom) {
43 jpm 1420
			if ($nom['num_nom_retenu'] != $nom['num_nom'] && $nom['num_tax_sup'] != '') {
20 jpm 1421
				$noms_erreur[] = $nom['num_nom'];
1422
			}
1423
		}
1424
 
1425
		// Analyse des résultats
1426
		if (count($noms_erreur) > 0) {
1427
			$info['message'] = count($noms_erreur)." enregistrements qui n'est pas un taxon et qui possède une valeur dans num_tax_sup : ".implode(', ', $noms_erreur).'.';
1428
		} else {
1429
			$info['resultat'] = true;
1430
		}
1431
 
30 jpm 1432
		$this->traiterResultatTest($info);
20 jpm 1433
	}
1434
 
64 jpm 1435
	private function testerExitenceTaxonSuperieur() {
30 jpm 1436
		$info = array('nom' => 'Classification -> existence du taxon supérieur',
20 jpm 1437
			'description' => "Pour chaque enregistrement représentant un taxon doit posséder un taxon supérieur sauf la racine de la classification.",
1438
			'resultat' => false);
1439
 
1440
		// Réalisation du test
1441
		$noms_erreur = array();
64 jpm 1442
		foreach ($this->noms as &$nom) {
20 jpm 1443
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
64 jpm 1444
				if ($nom['num_tax_sup'] != 0 && !isset($this->noms[$nom['num_tax_sup']])) {
20 jpm 1445
					$noms_erreur[] = $nom['num_nom'];
1446
				}
1447
			}
1448
		}
1449
 
1450
		// Analyse des résultats
1451
		if (count($noms_erreur) > 0) {
1452
			$info['message'] = count($noms_erreur)." enregistrements dont le taxon supérieur n'existe pas : ".implode(', ', $noms_erreur).'.';
1453
		} else {
1454
			$info['resultat'] = true;
1455
		}
1456
 
30 jpm 1457
		$this->traiterResultatTest($info);
20 jpm 1458
	}
1459
 
64 jpm 1460
	private function testerClassificationRang() {
30 jpm 1461
		$info = array('nom' => 'Classification -> taxon supérieur avec rang inférieur',
20 jpm 1462
			'description' => "Pour chaque enregistrement représentant un taxon, chaque taxon supérieur doit avoir un rang inférieur au taxon courant.",
1463
			'resultat' => false);
1464
 
1465
		// Réalisation du test
1466
		$noms_erreur = array();
64 jpm 1467
		foreach ($this->noms as &$nom) {
20 jpm 1468
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
64 jpm 1469
				if (isset($this->noms[$nom['num_tax_sup']])) {
1470
					$nom_sup = $this->noms[$nom['num_tax_sup']];
20 jpm 1471
					if ($nom_sup['rang'] > $nom['rang']) {
1472
						$noms_erreur[] = $nom['num_nom'];
1473
					}
1474
				}
1475
			}
1476
		}
1477
 
1478
		// Analyse des résultats
1479
		if (count($noms_erreur) > 0) {
1480
			$info['message'] = count($noms_erreur)." enregistrements avec un problème : ".implode(', ', $noms_erreur).'.';
1481
		} else {
1482
			$info['resultat'] = true;
1483
		}
1484
 
30 jpm 1485
		$this->traiterResultatTest($info);
20 jpm 1486
	}
1487
 
64 jpm 1488
	private function testerClassification() {
30 jpm 1489
		$info = array('nom' => 'Classification -> racine liée à chaque noeud',
20 jpm 1490
			'description' => "Pour chaque enregistrement, la classification doit pouvoir être remonté jusqu'à un même nom unique possédant une valeur num_tax_sup de 0.",
1491
			'resultat' => false);
1492
 
1493
		// Réalisation du test
1494
		$noms_erreur = array();
64 jpm 1495
		foreach ($this->noms as &$nom) {
20 jpm 1496
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
64 jpm 1497
				$classif_ok = $this->remonterClassif($nom);
20 jpm 1498
				if ($classif_ok === false) {
1499
					$noms_erreur[] = $nom['num_nom'];
1500
				}
1501
			}
1502
		}
1503
 
1504
		// Analyse des résultats
1505
		if (count($noms_erreur) > 0) {
1506
			$info['message'] = count($noms_erreur)." taxons dont la classification n'est pas bonne : ".implode(', ', $noms_erreur).'.';
1507
		} else {
1508
			$info['resultat'] = true;
1509
		}
1510
 
30 jpm 1511
		$this->traiterResultatTest($info);
20 jpm 1512
	}
1513
 
64 jpm 1514
	private function remonterClassif($nom) {
1515
		if (is_int($nom['num_tax_sup'])) {
1516
			if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') {
1517
				return true;
1518
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') {
1519
				return false;
1520
			} else {
1521
				return $this->remonterClassif($this->noms[$nom['num_tax_sup']]);
1522
			}
1523
		} else {
20 jpm 1524
			return false;
1525
		}
1526
	}
1527
 
64 jpm 1528
	private function testerRang() {
30 jpm 1529
		$info = array('nom' => 'rang',
20 jpm 1530
			'description' => "Le rang doit correspondre à un valeur numérique définit dans le manuel.",
1531
			'resultat' => false);
1532
 
1533
		$rangs = array_flip(explode(',', $this->manuel['rangs']));
1534
 
1535
		// Réalisation du test
1536
		$noms_erreur = array();
64 jpm 1537
		foreach ($this->noms as &$nom) {
20 jpm 1538
			if (!isset($rangs[$nom['rang']])) {
1539
				$noms_erreur[] = $nom['num_nom'];
1540
			}
1541
		}
1542
 
1543
		// Analyse des résultats
1544
		if (count($noms_erreur) > 0) {
1545
			$info['message'] = count($noms_erreur)." noms dont le rang n'est pas bon : ".implode(', ', $noms_erreur).'.';
1546
		} else {
1547
			$info['resultat'] = true;
1548
		}
1549
 
30 jpm 1550
		$this->traiterResultatTest($info);
20 jpm 1551
	}
1552
 
64 jpm 1553
	private function testerNomCompletSupraGenerique() {
30 jpm 1554
		$info = array('nom' => 'nom_complet -> noms supra-génériques',
20 jpm 1555
			'description' => "Si le rang est < à {$this->manuel['rang_genre']} le nom_complet doit correspondre à la valeur du champ nom_supra_generique. ".
1556
				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
1557
			'resultat' => false);
1558
 
1559
		// Réalisation du test
1560
		$noms_erreur = array();
64 jpm 1561
		foreach ($this->noms as &$nom) {
20 jpm 1562
			if ($nom['rang'] < $this->manuel['rang_genre']) {
1563
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
1564
				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']);
1565
				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
1566
				if ($nom['nom_complet'] != $nom_complet_ideal) {
1567
					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
1568
					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
1569
				}
1570
			}
1571
		}
1572
 
1573
		// Analyse des résultats
1574
		if (count($noms_erreur) > 0) {
1575
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
1576
			$info['message']['lignes'] = $noms_erreur;
1577
		} else {
1578
			$info['resultat'] = true;
1579
		}
1580
 
30 jpm 1581
		$this->traiterResultatTest($info);
20 jpm 1582
	}
1583
 
64 jpm 1584
	private function testerNomCompletGenre() {
30 jpm 1585
		$info = array('nom' => 'nom_complet -> noms de genres',
20 jpm 1586
			'description' => "Si le rang est = à {$this->manuel['rang_genre']} le nom_complet doit correspondre à la valeur du champ genre. ".
1587
				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
1588
			'resultat' => false);
1589
 
1590
		// Réalisation du test
1591
		$noms_erreur = array();
64 jpm 1592
		foreach ($this->noms as &$nom) {
20 jpm 1593
			if ($nom['rang'] == $this->manuel['rang_genre']) {
1594
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
1595
				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
1596
				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
1597
				if ($nom['nom_complet'] != $nom_complet_ideal) {
1598
					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
1599
					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
1600
				}
1601
			}
1602
		}
1603
 
1604
		// Analyse des résultats
1605
		if (count($noms_erreur) > 0) {
1606
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
1607
			$info['message']['lignes'] = $noms_erreur;
1608
		} else {
1609
			$info['resultat'] = true;
1610
		}
1611
 
30 jpm 1612
		$this->traiterResultatTest($info);
20 jpm 1613
	}
1614
 
64 jpm 1615
	private function testerNomCompletInfraGenre() {
30 jpm 1616
		$info = array('nom' => 'nom_complet -> noms infra-génériques',
20 jpm 1617
			'description' => "Si le rang est > à {$this->manuel['rang_genre']} et < à {$this->manuel['rang_sp']} le nom_complet doit correspondre à une des formules suivantes : \n".
1618
			" genre + ' ' + type_epithete + ' ' + epithete_infra_generique \n".
1619
			" genre + ' ' + epithete_infra_generique + ' ' + type_epithete=agg. \n".
1620
			"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
1621
			'resultat' => false);
1622
 
1623
		// Réalisation du test
1624
		$noms_erreur = array();
64 jpm 1625
		foreach ($this->noms as &$nom) {
20 jpm 1626
			if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) {
1627
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
1628
				$nom_complet_ideal = '';
1629
				if ($nom['type_epithete'] == 'agg.') {
1630
					$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
1631
					$nom_complet_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
1632
					$nom_complet_ideal .= ' '.$nom['type_epithete'];
1633
				} else {
1634
					$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
1635
					$nom_complet_ideal .= ' '.$nom['type_epithete'];
1636
					$nom_complet_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
1637
				}
1638
				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
1639
				if ($nom['nom_complet'] != $nom_complet_ideal) {
1640
					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
1641
					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
1642
				}
1643
			}
1644
		}
1645
 
1646
		// Analyse des résultats
1647
		if (count($noms_erreur) > 0) {
1648
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
1649
			$info['message']['lignes'] = $noms_erreur;
1650
		} else {
1651
			$info['resultat'] = true;
1652
		}
64 jpm 1653
		$noms_erreur = null;
20 jpm 1654
 
30 jpm 1655
		$this->traiterResultatTest($info);
20 jpm 1656
	}
1657
 
64 jpm 1658
	private function testerNomCompletEspece() {
30 jpm 1659
		$info = array('nom' => "nom_complet -> noms d'espèce",
20 jpm 1660
			'description' => "Si le rang est = à {$this->manuel['rang_sp']} le nom_complet doit correspondre à la formule : \n".
1661
				" genre + ' ' + epithete_sp \n".
1662
				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
1663
			'resultat' => false);
1664
 
1665
		// Réalisation du test
1666
		$noms_erreur = array();
64 jpm 1667
		foreach ($this->noms as &$nom) {
20 jpm 1668
			if ($nom['rang'] == $this->manuel['rang_sp']) {
1669
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
1670
				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
1671
				$nom_complet_ideal .= ' '.strtolower($nom['epithete_sp']);
1672
				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
1673
				if ($nom['nom_complet'] != $nom_complet_ideal) {
1674
					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
1675
					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
1676
				}
1677
			}
1678
		}
1679
 
1680
		// Analyse des résultats
1681
		if (count($noms_erreur) > 0) {
1682
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
1683
			$info['message']['lignes'] = $noms_erreur;
1684
		} else {
1685
			$info['resultat'] = true;
1686
		}
64 jpm 1687
		$noms_erreur = null;
20 jpm 1688
 
30 jpm 1689
		$this->traiterResultatTest($info);
20 jpm 1690
	}
1691
 
64 jpm 1692
	private function testerNomCompletInfraSpecifique() {
30 jpm 1693
		$info = array('nom' => 'nom_complet -> noms infra-spécifiques',
20 jpm 1694
			'description' => "Si le rang est > à {$this->manuel['rang_sp']} le nom_complet doit correspondre à la formule : \n".
1695
				" genre + ' ' + epithete_sp + ' ' + type_epithete + ' ' + epithete_infra_generique\n".
1696
				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
1697
			'resultat' => false);
1698
 
1699
		// Réalisation du test
1700
		$noms_erreur = array();
64 jpm 1701
		foreach ($this->noms as &$nom) {
20 jpm 1702
			if ($nom['rang'] > $this->manuel['rang_sp']) {
1703
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
1704
				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
1705
				$nom_complet_ideal .= ' '.strtolower($nom['epithete_sp']);
1706
				$nom_complet_ideal .= ' '.strtolower($nom['type_epithete']);
1707
				$nom_complet_ideal .= ' '.strtolower($nom['epithete_infra_sp']);
1708
				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
1709
				if ($nom['nom_complet'] != $nom_complet_ideal) {
1710
					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
1711
					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
1712
				}
1713
			}
1714
		}
1715
 
1716
		// Analyse des résultats
1717
		if (count($noms_erreur) > 0) {
1718
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
1719
			$info['message']['lignes'] = $noms_erreur;
1720
		} else {
1721
			$info['resultat'] = true;
1722
		}
64 jpm 1723
		$noms_erreur = null;
20 jpm 1724
 
30 jpm 1725
		$this->traiterResultatTest($info);
20 jpm 1726
	}
1727
 
64 jpm 1728
	private function testerNomSupraGeneriqueEspaces() {
30 jpm 1729
		$info = array('nom' => 'nom_supra_generique -> espaces en trop',
20 jpm 1730
			'description' => "Le champ nom_supra_generique ne doit pas contenir d'espace avant ou aprés le nom.",
1731
			'resultat' => false);
1732
 
1733
		// Réalisation du test
1734
		$noms_erreur = array();
64 jpm 1735
		foreach ($this->noms as &$nom) {
20 jpm 1736
			if ($nom['nom_supra_generique'] != '') {
1737
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
1738
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
1739
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
1740
				}
1741
			}
1742
		}
1743
 
1744
		// Analyse des résultats
1745
		if (count($noms_erreur) > 0) {
1746
			$info['message']['entete'] = array('num_nom', 'nom_supra_generique erroné');
1747
			$info['message']['lignes'] = $noms_erreur;
1748
		} else {
1749
			$info['resultat'] = true;
1750
		}
64 jpm 1751
		$noms_erreur = null;
20 jpm 1752
 
30 jpm 1753
		$this->traiterResultatTest($info);
20 jpm 1754
	}
1755
 
64 jpm 1756
	private function testerNomSupraGeneriqueSyntaxe() {
30 jpm 1757
		$info = array('nom' => 'nom_supra_generique -> syntaxe',
20 jpm 1758
			'description' => "Le champ nom_supra_generique contient un mot composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
1759
				"La première lettre (avec ou sans tréma) du mot doit être en majuscule.",
1760
			'resultat' => false);
1761
 
1762
		// Réalisation du test
1763
		$noms_erreur = array();
64 jpm 1764
		foreach ($this->noms as &$nom) {
20 jpm 1765
			if ($nom['nom_supra_generique'] != '') {
1766
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) {
1767
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
1768
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
1769
				}
1770
			}
1771
		}
1772
 
1773
		// Analyse des résultats
1774
		if (count($noms_erreur) > 0) {
1775
			$info['message']['entete'] = array('num_nom', 'nom_supra_generique erroné');
1776
			$info['message']['lignes'] = $noms_erreur;
1777
		} else {
1778
			$info['resultat'] = true;
1779
		}
64 jpm 1780
		$noms_erreur = null;
20 jpm 1781
 
30 jpm 1782
		$this->traiterResultatTest($info);
20 jpm 1783
	}
1784
 
64 jpm 1785
	private function testerNomSupraGeneriqueRang() {
30 jpm 1786
		$info = array('nom' => "nom_supra_generique -> rang < {$this->manuel['rang_genre']}",
20 jpm 1787
			'description' => "Si le champ nom_supra_generique n'est pas vide alors le rang du nom doit être inférieur à {$this->manuel['rang_genre']}.",
1788
			'resultat' => false);
1789
 
1790
		// Réalisation du test
1791
		$noms_erreur = array();
64 jpm 1792
		foreach ($this->noms as &$nom) {
20 jpm 1793
			if ($nom['nom_supra_generique'] != '') {
1794
				if ($nom['rang'] >= $this->manuel['rang_genre']) {
1795
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
1796
				}
1797
			}
1798
		}
1799
 
1800
		// Analyse des résultats
1801
		if (count($noms_erreur) > 0) {
1802
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
1803
			$info['message']['lignes'] = $noms_erreur;
1804
		} else {
1805
			$info['resultat'] = true;
1806
		}
64 jpm 1807
		$noms_erreur = null;
20 jpm 1808
 
30 jpm 1809
		$this->traiterResultatTest($info);
20 jpm 1810
	}
1811
 
64 jpm 1812
	private function testerGenreEspaces() {
30 jpm 1813
		$info = array('nom' => 'genre -> espaces en trop',
20 jpm 1814
			'description' => "Le champ genre ne doit pas contenir d'espace avant ou aprés le nom.\n".
1815
				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
1816
			'resultat' => false);
1817
 
1818
		// Réalisation du test
1819
		$noms_erreur = array();
64 jpm 1820
		foreach ($this->noms as &$nom) {
20 jpm 1821
			if ($nom['genre'] != '') {
1822
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) {
1823
					$nom_traite = $this->repererEspace($nom['genre']);
1824
					$noms_erreur[] = array($nom['num_nom'], $nom_traite);
1825
				}
1826
			}
1827
		}
1828
 
1829
		// Analyse des résultats
1830
		if (count($noms_erreur) > 0) {
1831
			$info['message']['entete'] = array('num_nom', 'genre erroné');
1832
			$info['message']['lignes'] = $noms_erreur;
1833
		} else {
1834
			$info['resultat'] = true;
1835
		}
64 jpm 1836
		$noms_erreur = null;
20 jpm 1837
 
30 jpm 1838
		$this->traiterResultatTest($info);
20 jpm 1839
	}
1840
 
64 jpm 1841
	private function testerGenreSyntaxe() {
30 jpm 1842
		$info = array('nom' => 'genre -> syntaxe',
20 jpm 1843
			'description' => "Le champ genre peut contenir :\n".
1844
			 	" - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
1845
				"	Il commence par une lettre majuscule (avec ou sans tréma).".
1846
				"	Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n".
1847
				" - une formule d'hybridité composée d'une série de noms de genre (au moins 2) séparés entre eux \n".
1848
				"	par la lettre x entourée de caractères espaces.",
1849
			'resultat' => false);
1850
 
1851
		// Réalisation du test
1852
		$noms_erreur = array();
64 jpm 1853
		foreach ($this->noms as &$nom) {
20 jpm 1854
			if ($nom['genre'] != '') {
1855
				$mots = explode(' ', $nom['genre']);
1856
				foreach ($mots as $mot) {
1857
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) {
1858
						$nom_traite = $this->repererEspace($nom['genre']);
1859
						$noms_erreur[] = array($nom['num_nom'], $nom_traite);
1860
					}
1861
				}
1862
			}
1863
		}
1864
 
1865
		// Analyse des résultats
1866
		if (count($noms_erreur) > 0) {
1867
			$info['message']['entete'] = array('num_nom', 'genre erroné');
1868
			$info['message']['lignes'] = $noms_erreur;
1869
		} else {
1870
			$info['resultat'] = true;
1871
		}
64 jpm 1872
		$noms_erreur = null;
20 jpm 1873
 
30 jpm 1874
		$this->traiterResultatTest($info);
20 jpm 1875
	}
1876
 
64 jpm 1877
	private function testerGenreRang() {
30 jpm 1878
		$info = array('nom' => "genre -> rang >= {$this->manuel['rang_genre']}",
20 jpm 1879
			'description' => "Si le champ genre n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.",
1880
			'resultat' => false);
1881
 
1882
		// Réalisation du test
1883
		$noms_erreur = array();
64 jpm 1884
		foreach ($this->noms as &$nom) {
20 jpm 1885
			if ($nom['genre'] != '') {
1886
				if ($nom['rang'] < $this->manuel['rang_genre']) {
1887
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
1888
				}
1889
			}
1890
		}
1891
 
1892
		// Analyse des résultats
1893
		if (count($noms_erreur) > 0) {
1894
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
1895
			$info['message']['lignes'] = $noms_erreur;
1896
		} else {
1897
			$info['resultat'] = true;
1898
		}
64 jpm 1899
		$noms_erreur = null;
20 jpm 1900
 
30 jpm 1901
		$this->traiterResultatTest($info);
20 jpm 1902
	}
1903
 
64 jpm 1904
	private function testerEpitheteInfraGeneriqueSyntaxe() {
30 jpm 1905
		$info = array('nom' => 'epithete_infra_generique -> syntaxe',
20 jpm 1906
			'description' => "Le champ epithete_infra_generique est composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
1907
				"La première lettre (avec ou sans tréma) doit être en majuscule.",
1908
			'resultat' => false);
1909
 
1910
		// Réalisation du test
1911
		$noms_erreur = array();
64 jpm 1912
		foreach ($this->noms as &$nom) {
20 jpm 1913
			if ($nom['epithete_infra_generique'] != '') {
1914
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) {
1915
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
1916
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
1917
				}
1918
			}
1919
		}
1920
 
1921
		// Analyse des résultats
1922
		if (count($noms_erreur) > 0) {
1923
			$info['message']['entete'] = array('num_nom', 'epithete_infra_generique erroné');
1924
			$info['message']['lignes'] = $noms_erreur;
1925
		} else {
1926
			$info['resultat'] = true;
1927
		}
64 jpm 1928
		$noms_erreur = null;
20 jpm 1929
 
30 jpm 1930
		$this->traiterResultatTest($info);
20 jpm 1931
	}
1932
 
64 jpm 1933
	private function testerEpitheteInfraGeneriqueRang() {
30 jpm 1934
		$info = array('nom' => "epithete_infra_generique -> {$this->manuel['rang_genre']} < rang < {$this->manuel['rang_sp']}",
20 jpm 1935
			'description' => "Si le champ epithete_infra_generique n'est pas vide alors le rang du nom doit être compris \n".
1936
				"entre {$this->manuel['rang_genre']} et {$this->manuel['rang_sp']}.",
1937
			'resultat' => false);
1938
 
1939
		// Réalisation du test
1940
		$noms_erreur = array();
64 jpm 1941
		foreach ($this->noms as &$nom) {
20 jpm 1942
			if ($nom['epithete_infra_generique'] != '') {
1943
				if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) {
1944
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
1945
				}
1946
			}
1947
		}
1948
 
1949
		// Analyse des résultats
1950
		if (count($noms_erreur) > 0) {
1951
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
1952
			$info['message']['lignes'] = $noms_erreur;
1953
		} else {
1954
			$info['resultat'] = true;
1955
		}
64 jpm 1956
		$noms_erreur = null;
20 jpm 1957
 
30 jpm 1958
		$this->traiterResultatTest($info);
20 jpm 1959
	}
1960
 
64 jpm 1961
	private function testerEpitheteInfraGeneriqueEspaces() {
30 jpm 1962
		$info = array('nom' => 'epithete_infra_generique -> espaces en trop',
20 jpm 1963
			'description' => "Le champ epithete_infra_generique ne doit pas contenir d'espace avant ou aprés sa valeur.",
1964
			'resultat' => false);
1965
 
1966
		// Réalisation du test
1967
		$noms_erreur = array();
64 jpm 1968
		foreach ($this->noms as &$nom) {
20 jpm 1969
			if ($nom['epithete_infra_generique'] != '') {
1970
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) {
1971
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
1972
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
1973
				}
1974
			}
1975
		}
1976
 
1977
		// Analyse des résultats
1978
		if (count($noms_erreur) > 0) {
1979
			$info['message']['entete'] = array('num_nom', 'epithete_infra_generique erroné');
1980
			$info['message']['lignes'] = $noms_erreur;
1981
		} else {
1982
			$info['resultat'] = true;
1983
		}
64 jpm 1984
		$noms_erreur = null;
20 jpm 1985
 
30 jpm 1986
		$this->traiterResultatTest($info);
20 jpm 1987
	}
1988
 
64 jpm 1989
	private function testerEpitheteSpEspaces() {
30 jpm 1990
		$info = array('nom' => 'epithete_sp -> espaces en trop',
20 jpm 1991
			'description' => "Le champ epithete_sp ne doit pas contenir d'espace avant ou aprés le nom.\n".
1992
				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
1993
			'resultat' => false);
1994
 
1995
		// Réalisation du test
1996
		$noms_erreur = array();
64 jpm 1997
		foreach ($this->noms as &$nom) {
20 jpm 1998
			if ($nom['epithete_sp'] != '') {
1999
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) {
2000
					$epithete_traite = $this->repererEspace($nom['epithete_sp']);
2001
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
2002
				}
2003
			}
2004
		}
2005
 
2006
		// Analyse des résultats
2007
		if (count($noms_erreur) > 0) {
2008
			$info['message']['entete'] = array('num_nom', 'epithete_sp erroné');
2009
			$info['message']['lignes'] = $noms_erreur;
2010
		} else {
2011
			$info['resultat'] = true;
2012
		}
64 jpm 2013
		$noms_erreur = null;
20 jpm 2014
 
30 jpm 2015
		$this->traiterResultatTest($info);
20 jpm 2016
	}
2017
 
64 jpm 2018
	private function testerEpitheteSpSyntaxe() {
30 jpm 2019
		$info = array('nom' => 'epithete_sp -> syntaxe',
20 jpm 2020
			'description' => "Le champ epithete_sp peut contenir :\n".
2021
			 	" - un mot unique composé de lettres minuscules [a-z] incluant les caractères [ëï-]. \n".
2022
				"	Il commence par une lettre minuscule [a-zëï].\n".
2023
				"	Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n".
2024
				" - un mot contenant sp. suivi d'un ou plusieurs caractères numériques (1-9) ou d'un seul caractère majuscule (A-Z) \n".
2025
				" - une formule d'hybridité composée d'une série de noms d'espèce (au moins 2) séparés entre eux \n".
2026
				"	par la lettre x entourée de caractères espaces.",
2027
			'resultat' => false);
2028
 
2029
		// Réalisation du test
2030
		$noms_erreur = array();
64 jpm 2031
		foreach ($this->noms as &$nom) {
20 jpm 2032
			if ($nom['epithete_sp'] != '') {
2033
				$mots = explode(' ', $nom['epithete_sp']);
2034
				foreach ($mots as $mot) {
2035
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot))) {
2036
						$epithete_traite = $this->repererEspace($nom['epithete_sp']);
2037
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
2038
					}
2039
				}
2040
			}
2041
		}
2042
 
2043
		// Analyse des résultats
2044
		if (count($noms_erreur) > 0) {
2045
			$info['message']['entete'] = array('num_nom', 'epithete_sp erroné');
2046
			$info['message']['lignes'] = $noms_erreur;
2047
		} else {
2048
			$info['resultat'] = true;
2049
		}
64 jpm 2050
		$noms_erreur = null;
20 jpm 2051
 
30 jpm 2052
		$this->traiterResultatTest($info);
20 jpm 2053
	}
2054
 
64 jpm 2055
	private function testerEpitheteSpRang() {
30 jpm 2056
		$info = array('nom' => "epithete_sp -> rang >= {$this->manuel['rang_sp']}",
20 jpm 2057
			'description' => "Si le champ epithete_sp n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_sp']}.",
2058
			'resultat' => false);
2059
 
2060
		// Réalisation du test
2061
		$noms_erreur = array();
64 jpm 2062
		foreach ($this->noms as &$nom) {
20 jpm 2063
			if ($nom['epithete_sp'] != '') {
2064
				if ($nom['rang'] < $this->manuel['rang_sp']) {
2065
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
2066
				}
2067
			}
2068
		}
2069
 
2070
		// Analyse des résultats
2071
		if (count($noms_erreur) > 0) {
2072
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
2073
			$info['message']['lignes'] = $noms_erreur;
2074
		} else {
2075
			$info['resultat'] = true;
2076
		}
64 jpm 2077
		$noms_erreur = null;
20 jpm 2078
 
30 jpm 2079
		$this->traiterResultatTest($info);
20 jpm 2080
	}
2081
 
2082
	//+--------------------------------------------------------------------------------------------------------------+//
2083
	// MÉTHODES COMMUNES aux TESTS
2084
 
64 jpm 2085
	private function verifierPresence(&$valeur) {
20 jpm 2086
		$codes = $this->manuel['codes_presence'];
2087
		$ok = $this->verifierStatuts($valeur, $codes);
2088
		return $ok;
2089
	}
2090
 
64 jpm 2091
	private function verifierStatutOrigine(&$valeur) {
20 jpm 2092
		$codes = $this->manuel['codes_statuts_origine'];
2093
		$ok = $this->verifierStatuts($valeur, $codes);
2094
		return $ok;
2095
	}
2096
 
64 jpm 2097
	private function verifierStatutIntroduction(&$valeur) {
20 jpm 2098
		$codes = $this->manuel['codes_statuts_introduction'];
2099
		$ok = $this->verifierStatuts($valeur, $codes);
2100
		return $ok;
2101
	}
2102
 
64 jpm 2103
	private function verifierStatutCulture(&$valeur) {
20 jpm 2104
		$codes = $this->manuel['codes_statuts_culture'];
2105
		$ok = $this->verifierStatuts($valeur, $codes);
2106
		return $ok;
2107
	}
2108
 
64 jpm 2109
	private function verifierStatuts(&$valeur, &$codes) {
20 jpm 2110
		$ok = true;
2111
		if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
2112
			$ok = false;
2113
		}
2114
		return $ok;
2115
	}
2116
 
64 jpm 2117
	private function verifierBooleen(&$valeur) {
20 jpm 2118
		$ok = true;
2119
		if (!preg_match('/^1$/', $valeur)) {
2120
			$ok = false;
2121
		}
2122
		return $ok;
2123
	}
2124
 
64 jpm 2125
	private function verifierNombre(&$valeur) {
20 jpm 2126
		$ok = true;
2127
		if (!preg_match('/^[0-9]+$/', $valeur)) {
2128
			$ok = false;
2129
		}
2130
		return $ok;
2131
	}
2132
 
64 jpm 2133
	private function verifierNombreSuite(&$valeur) {
20 jpm 2134
		$ok = true;
2135
		if (!preg_match('/^(?:[0-9]+,)*[0-9]+$/', $valeur)) {
2136
			$ok = false;
2137
		}
2138
		return $ok;
2139
	}
2140
 
64 jpm 2141
	private function verifierTypeEpithete(&$type) {
20 jpm 2142
		$ok = false;
2143
		$rejetes = $this->manuel['type_epithete_rejetes'];
2144
		if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
2145
			$ok = false;
2146
		} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
2147
			$ok = true;
2148
		}
2149
		return $ok;
2150
	}
2151
 
64 jpm 2152
	private function verifierBiblioOrigine(&$intitule) {
20 jpm 2153
		$ok = true;
2154
		if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
2155
			$ok = false;// Contient des espaces en trop
2156
		} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
2157
			$ok = false;
2158
		} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
2159
			$ok = false;// Contient une mauvaise suite de caractères
2160
		}
2161
		return $ok;
2162
	}
2163
 
64 jpm 2164
	private function verifierAnnee(&$annee) {
20 jpm 2165
		$ok = true;
2166
		if (!preg_match('/^[0-9]{4}$/', $annee)) {
2167
			$ok = false;
2168
		} else if ($annee < 1753) {
2169
			$ok = false;
2170
		}
2171
		return $ok;
2172
	}
2173
 
64 jpm 2174
	private function verifierAuteur(&$intitule) {
20 jpm 2175
		$ok = true;
2176
		$acceptes = $this->manuel['auteur_acceptes'];
2177
		if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
2178
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
2179
				$ok = false;// Contient des espaces en trop
2180
			} else {
2181
				$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
2182
				$mots = explode(' ', $intitule);
2183
				foreach ($mots as $position => $mot) {
2184
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
2185
						$ok = false;// Mot rejeté
2186
					} else if (preg_match("/^(?:(?:\p{L}|[.'\(\)-])+|[&])$/u", $mot)) {
2187
						continue;// Mot de l'intitulé auteur
2188
					} else {
2189
						$ok = false;
2190
					}
2191
				}
2192
			}
2193
		}
2194
		return $ok;
2195
	}
2196
 
64 jpm 2197
	private function verifierNomCommercial(&$epithete) {
20 jpm 2198
		$ok = false;
2199
		if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
2200
			$ok = true;
2201
		}
2202
		return $ok;
2203
	}
2204
 
64 jpm 2205
	private function verifierEpitheteCultivar(&$epithete) {
20 jpm 2206
		$ok = true;
2207
		$acceptes = $this->manuel['cultivar_acceptes'];
2208
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
2209
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
2210
				$ok = false;// Contient des espaces en trop
2211
			} else {
2212
				$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
2213
				$mots_mineurs = $this->manuel['mots_mineurs'];
2214
				$mots = explode(' ', $epithete);
2215
				foreach ($mots as $position => $mot) {
2216
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
2217
						$ok = false;// Mot rejeté
2218
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
2219
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
2220
					} else {
2221
						$mots_tiret = explode('-', $mot);
2222
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
2223
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
2224
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
2225
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
2226
								continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
2227
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
2228
								continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
2229
							} else {
2230
								$ok = false;
2231
							}
2232
						}
2233
					}
2234
				}
2235
			}
2236
		}
2237
		return $ok;
2238
	}
2239
 
64 jpm 2240
	private function verifierEpitheteGroupeCultivar(&$epithete) {
20 jpm 2241
		$ok = true;
2242
		$acceptes = $this->manuel['cultivar_gp_acceptes'];
2243
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
2244
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
2245
				$ok = false;// Contient des espaces en trop
2246
			} else {
2247
				$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
2248
				$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
2249
				$mots_mineurs = $this->manuel['mots_mineurs'];
2250
				$mots = explode(' ', $epithete);
2251
				foreach ($mots as $position => $mot) {
2252
					if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
2253
						continue;// Mot accepté
2254
					} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
2255
						$ok = false;// Mot rejeté
2256
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
2257
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
2258
					} else {
2259
						$mots_tiret = explode('-', $mot);
2260
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
2261
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
2262
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
2263
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
2264
								continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
2265
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
2266
								continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
2267
							} else {
2268
								$ok = false;
2269
							}
2270
						}
2271
					}
2272
				}
2273
			}
2274
		}
2275
		return $ok;
2276
	}
2277
 
64 jpm 2278
	private function verifierEpitheteSp(&$epithete) {
20 jpm 2279
		$ok = false;
2280
		if (preg_match('/^[a-zëï][-a-zëï]+$/', $epithete)) {
2281
			$ok = true;
2282
		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
2283
			$ok = true;
2284
		}
2285
		return $ok;
2286
	}
2287
 
64 jpm 2288
	private function verifierEpitheteGenre(&$epithete) {
20 jpm 2289
		$ok = false;
2290
		if (preg_match('/^[A-ZËÏ](?:[-a-zëï]+|[a-zëï]+-[A-ZËÏ][a-zëï]+)$/', $epithete)) {
2291
			$ok = true;
2292
		}
2293
		return $ok;
2294
	}
2295
 
64 jpm 2296
	private function formaterStyleNomGenre(&$genre) {
20 jpm 2297
		$genre_fmt = '';
2298
		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
2299
			$genre_fmt = strtolower($match[1]).' '.ucfirst(strtolower($match[2]));
2300
		} else {
2301
			$genre_fmt = ucfirst(strtolower($genre));
2302
		}
2303
		return $genre_fmt;
2304
	}
2305
 
2306
	private function repererEspace($nom_complet) {
2307
		$nom_complet = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_complet);
2308
		return $nom_complet;
2309
	}
2310
 
64 jpm 2311
	private function construireSuffixeNomPltCultivee(&$nom) {
20 jpm 2312
		$suffixe = array();
2313
		$suffixe[] = $this->construireNomCultivarGroupe($nom);
2314
		$suffixe[] = $this->construireNomCommercial($nom);
2315
		$suffixe[] = $this->construireNomCultivar($nom);
2316
		$suffixe = array_filter($suffixe);
2317
		return implode(' ', $suffixe);
2318
	}
2319
 
64 jpm 2320
	private function construireNomCultivarGroupe(&$nom) {
20 jpm 2321
		$nom_groupe_cultivar = '';
2322
		if ($nom['cultivar_groupe'] != '') {
2323
			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
2324
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
2325
			} else {
2326
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
2327
			}
2328
		}
2329
		return $nom_groupe_cultivar;
2330
	}
2331
 
64 jpm 2332
	private function construireNomCommercial(&$nom) {
20 jpm 2333
		$nom_commercial = '';
2334
		if ($nom['nom_commercial'] != '') {
2335
			$nom_commercial =  strtoupper($nom['nom_commercial']);
2336
		}
2337
		return $nom_commercial;
2338
	}
2339
 
64 jpm 2340
	private function construireNomCultivar(&$nom) {
20 jpm 2341
		$nom_cultivar = '';
2342
		if ($nom['cultivar'] != '') {
2343
			$nom_cultivar =  "'".$nom['cultivar']."'";
2344
		}
2345
		return $nom_cultivar;
2346
	}
2347
 
64 jpm 2348
	private function classerNomsParNomComplet() {
20 jpm 2349
		$noms_classes = array();
64 jpm 2350
		foreach ($this->noms as &$nom) {
20 jpm 2351
			if (!isset($noms_classes[$nom['nom_complet']])) {
2352
				$noms_classes[$nom['nom_complet']] = 1;
2353
			} else {
2354
				$noms_classes[$nom['nom_complet']]++;
2355
			}
2356
		}
2357
		return $noms_classes;
2358
	}
2359
 
2360
}
2361
?>