Subversion Repositories Applications.referentiel

Rev

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