Subversion Repositories Applications.referentiel

Rev

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