Subversion Repositories Applications.referentiel

Rev

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