Subversion Repositories Applications.referentiel

Rev

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

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