Subversion Repositories Applications.referentiel

Rev

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