Subversion Repositories Applications.referentiel

Rev

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