Subversion Repositories Applications.referentiel

Rev

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

Rev Author Line No. Line
20 jpm 1
<?php
2
// Encodage : UTF-8
3
// +-------------------------------------------------------------------------------------------------------------------+
4
/**
5
* Tests de référentiels de nomenclature et taxonomie
6
*
7
* Description : classe permettant de tester les référentiels selon le manuel technique
8
* Utilisation : php script.php tests -p bdnff -a tout
9
*
10
//Auteur original :
11
* @author       Jean-Pascal MILCENT <jpm@tela-botanica.org>
12
* @copyright	Tela-Botanica 1999-2010
13
* @link			http://www.tela-botanica.org/wikini/RTaxMethodo/wakka.php?wiki=MaNuel
14
* @licence		GPL v3 & CeCILL v2
15
* @version		$Id$
16
*/
17
// +-------------------------------------------------------------------------------------------------------------------+
38 jpm 18
// TODO : supprimer l'utilisation du paramêtres 'p' et chercher les infos depuis la bdd
20 jpm 19
class Tests extends ScriptCommande {
20
 
42 jpm 21
	const SCRIPT_NOM = 'tests';
212 jpm 22
	const MANUEL_VERSION = '4.2';
42 jpm 23
 
20 jpm 24
	private $projet = null;
30 jpm 25
	private $traitement = null;
20 jpm 26
 
27
	private $manuel = null;
212 jpm 28
	private $manuel_nom = null;
29
	private $manuel_chemin = null;
171 jpm 30
	private $tests = null;
167 jpm 31
	private $colonnes = null;
32
	private $analyses = null;
64 jpm 33
	private $noms = null;
20 jpm 34
 
30 jpm 35
	private $resultatDao = null;
36
	private $traitementDao = null;
37
	private $tableStructureDao = null;
38
	private $referentielDao = null;
39
 
20 jpm 40
	public function executer() {
212 jpm 41
		$this->manuel_nom = 'mtpr_v'.str_replace('.', '_', self::MANUEL_VERSION).'.pdf';
42
		$this->manuel_chemin = Config::get('chemin_appli').DS.'..'.DS.'configurations'.DS;
43
 
44
		$manuel_config_nom = 'referentiel_v'.self::MANUEL_VERSION.'.ini';
45
		$this->manuel = parse_ini_file($this->manuel_chemin.$manuel_config_nom);
46
 
176 jpm 47
		$this->definirConstantes();
171 jpm 48
		$this->tests = parse_ini_file($this->getModuleChemin().DS.'configurations'.DS.'tests.ini', true);
20 jpm 49
 
30 jpm 50
		$this->resultatDao = new ResultatDao();
51
		$this->traitementDao = new TraitementDao();
97 jpm 52
		Debug::printr('Dans le script test');
30 jpm 53
		// Récupération du dernier traitement demandé
142 delphine 54
		$this->traitement = $this->traitementDao->getDernierTraitement('tout', self::SCRIPT_NOM);
42 jpm 55
		if (isset($this->traitement)) {
142 delphine 56
			$this->projet = $this->traitement['referentiel_code']; // Récupération du nom de projet
38 jpm 57
			Debug::printr($this->traitement);
58
			// Écriture de la date de début du traitement
59
			Debug::printr('Debute:'.$this->traitementDao->debuterTraitement($this->traitement['id_traitement']));
60
 
61
			// Nettoyage des traitements obsolètes
42 jpm 62
			$traitements_obsoletes = $this->traitementDao->getTraitementsObsoletes($this->projet, self::SCRIPT_NOM);
63
			if (isset($traitements_obsoletes)) {
64
				Debug::printr('Supp. obsoletes:'.$this->traitementDao->supprimer($traitements_obsoletes));
65
			}
38 jpm 66
 
165 delphine 67
			$this->tableStructureDao = new TableStructureDao();
68
			$this->referentielDao = new ReferentielDao();
69
 
38 jpm 70
			// Lancement du test demandé
71
			$cmd = $this->getParam('a');
72
	    	switch ($cmd) {
73
				case 'tout' :
74
					Debug::printr('Départ lancement test:');
165 delphine 75
					$this->recupererDonnees();
177 jpm 76
					$this->lancerTestsAuto();
38 jpm 77
					break;
165 delphine 78
				case 'test11' :
79
					$this->recupererDonnees();
80
					Debug::printr('Départ lancement test 11 :');
199 delphine 81
					$this->testerExitenceTaxonSuperieurTransmis();
165 delphine 82
					break;
38 jpm 83
				default :
84
					$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
85
			}
86
			// Écriture de la date de fin du traitement
87
			Debug::printr('Termine:'.$this->traitementDao->terminerTraitement($this->traitement['id_traitement']));
97 jpm 88
		} else {
142 delphine 89
			Debug::printr("Aucun dernier traitement trouvé pour le script '".self::SCRIPT_NOM."' !");
20 jpm 90
		}
91
    }
165 delphine 92
 
176 jpm 93
    /**
94
     * Cette méthode définie des constantes qui peuvent ensuite être utilisée dans les fichier ini.
95
     * Surtout utile pour le fichier tests.ini
96
     */
97
    private function definirConstantes() {
98
    	define('RANG_GENRE', $this->manuel['rang_genre']);
99
    	define('RANG_SP', $this->manuel['rang_sp']);
188 delphine 100
    	date_default_timezone_set('Europe/Berlin');
101
    	define('ANNEE_EN_COURS', date('Y'));
102
    	define('ANNEE_MINIMUM', 1753);
176 jpm 103
    }
104
 
165 delphine 105
    public function recupererDonnees() {
20 jpm 106
		// Récupération des données à tester
167 jpm 107
		$this->colonnes = $this->tableStructureDao->getColonnes($this->projet);
108
		$this->analyses = $this->tableStructureDao->getAnalyse($this->projet);
64 jpm 109
		$this->noms = $this->referentielDao->getTout($this->projet);
110
		Debug::printr('Nbre noms :'.count($this->noms));
165 delphine 111
    }
112
 
175 jpm 113
    public function lancerTestsAuto() {
114
		$resultats = array();
115
 
116
		// Lancement des tests unitaires
177 jpm 117
		Debug::printr('Lancement des tests unitaires');
183 jpm 118
		$tests_numeros = array_keys($this->tests);
119
		Debug::printr($tests_numeros);
192 delphine 120
    	foreach ($tests_numeros as &$numero) {
175 jpm 121
			$info = $this->getInfosTest($numero);
122
 
123
    		if ($numero < 5) {
124
    			// Tests spéciaux vérifiant la structure de la table
125
    			$resultats[] = $this->lancerTestUnitaire($info);
126
    		} else if ($numero >= 5 && $this->verifierResultats($resultats)) {
127
				// Si la structure est bonne nous lançons les autres tests
177 jpm 128
				$this->lancerTestUnitaire($info);
175 jpm 129
    		}
130
		}
131
    }
183 jpm 132
 
133
    private function getInfosTest($numero) {
134
		$info = $this->tests[$numero];
135
		$info['methode'] = 'tester'.implode('', explode(' ', ucwords($info['abr'])));
136
		$info['numero'] = $numero;
137
		$info['nom'] = '#'.$numero.' - '.$info['nom'];
138
		$info['resultat'] = false;
139
		return $info;
140
	}
175 jpm 141
 
142
    public function lancerTestUnitaire($info) {
177 jpm 143
		Debug::printr($info['numero'].'::'.$info['methode']);
144
    	$methodeDeTest = $info['methode'];
145
    	$erreurs = $this->$methodeDeTest();
175 jpm 146
 
147
    	// Analyse des résultats
148
    	if (isset($erreurs['special'])) {
149
    		$info = $erreurs;
150
    	} else {
176 jpm 151
    		if (count($erreurs) > 0) {
175 jpm 152
				$info['message']['entete'] = explode(',', $info['entete']);
183 jpm 153
				if (isset($info['title'])) {
154
					$info['message']['title'] = explode(';', $info['title']);
155
				}
175 jpm 156
				$info['message']['lignes'] = $erreurs;
176 jpm 157
				unset($erreurs);
175 jpm 158
			} else {
159
				$info['resultat'] = true;
160
			}
161
    	}
162
 
163
		$this->traiterResultatTest($info);
164
 
165
		if ($info['numero'] < 5) {
166
			return ($info['resultat'] ? '1' : '0');
167
		}
168
    }
64 jpm 169
 
192 delphine 170
	private function verifierResultats(&$resultats) {
64 jpm 171
		$ok = true;
172
		foreach ($resultats as $resultat) {
173
			if ($resultat == '0') {
174
				$ok = false;
175
				break;
176
			}
177
		}
178
		return $ok;
179
	}
20 jpm 180
 
30 jpm 181
	private function traiterResultatTest($info) {
182
		if (isset($info['message'])) {
183
			if (is_array($info['message'])) {
183 jpm 184
				$erreurs_nbre = count($info['message']['lignes']);
185
				$erreurs_max = 1000;
186
				if ($erreurs_nbre > $erreurs_max) {
187
					$info['message']['lignes'] = array_slice($info['message']['lignes'], 0, $erreurs_max);
188
					$info['erreur'] = "$erreurs_nbre erreurs ont été détectées seules les $erreurs_max premières sont affichées";
189
				}
31 jpm 190
				$info['message'] = $this->getVue('tests/squelettes/message_table', $info);
191
			} else {
192
				$info['message'] = $this->getVue('tests/squelettes/message_p', $info);
30 jpm 193
			}
194
		}
183 jpm 195
		Debug::printr($this->resultatDao->ajouter($this->traitement['id_traitement'], $info));
64 jpm 196
		$info = null;
30 jpm 197
	}
198
 
199
	//+--------------------------------------------------------------------------------------------------------------+//
20 jpm 200
	// TESTS
201
 
171 jpm 202
	/**
203
	 * Test #01
204
	 */
175 jpm 205
	private function testerNombreDeChamps() {
171 jpm 206
		$info = $this->getInfosTest(1);
175 jpm 207
		$info['special'] = true;
20 jpm 208
 
175 jpm 209
		$nbre_colonnes = count($this->colonnes);
171 jpm 210
		$info['message'] = $nbre_colonnes;
211
		if ($nbre_colonnes >= 35) {
212
			$info['resultat'] = true;
213
		}
175 jpm 214
 
215
		return $info;
171 jpm 216
	}
217
 
218
	/**
219
	 * Test #02
220
	 */
175 jpm 221
	private function testerNomDesChamps() {
171 jpm 222
		$info = $this->getInfosTest(2);
175 jpm 223
		$info['special'] = true;
171 jpm 224
 
225
		$champs_attendus = explode(',', $this->manuel['champs']);
226
		$champs_presents = array();
192 delphine 227
		foreach ($this->colonnes as &$colonne) {
171 jpm 228
			$champs_presents[$colonne['Field']] = $colonne;
229
		}
230
 
231
		$ok = true;
232
		$champs_manquant = array();
192 delphine 233
		foreach ($champs_attendus as &$champ_attendu) {
171 jpm 234
			if (!isset($champs_presents[$champ_attendu])) {
235
				$champs_manquant[] = $champ_attendu;
236
				$ok = false;
237
			}
238
		}
175 jpm 239
 
171 jpm 240
		$info['resultat'] = $ok;
241
		if (!$ok) {
242
			$info['message'] = sprintf($info['message'], implode(', ', $champs_manquant));
243
		}
244
 
175 jpm 245
		return $info;
171 jpm 246
	}
247
 
248
	/**
249
	 * Test #03
250
	 */
175 jpm 251
	private function testerTypeDesChamps() {
171 jpm 252
		$champs_attendus = explode(',', $this->manuel['champs_type']);
253
		$champs_presents = array();
192 delphine 254
		foreach ($this->colonnes as &$colonne) {
171 jpm 255
			$champs_presents[$colonne['Field']] = $colonne['Type'];
256
		}
257
 
258
		// Recercherche des erreurs
259
		$champs_erreur = array();
192 delphine 260
		foreach ($champs_attendus as &$champ_attendu) {
171 jpm 261
			list($champ_attendu_nom, $champ_attendu_type_taille) = explode('=', trim($champ_attendu));
262
			list($champ_attendu_type, $champ_attendu_taille) = explode('|', trim($champ_attendu_type_taille));
263
 
264
			if (isset($champs_presents[$champ_attendu_nom])) {
265
				$champs_present_type = $champs_presents[$champ_attendu_nom];
266
 
267
				if (($champ_attendu_type == 'VARCHAR' && strstr($champs_present_type, 'varchar') === false)
268
					|| ($champ_attendu_type == 'TEXT' && strstr($champs_present_type, 'text') === false)
269
					|| ($champ_attendu_type == 'INT' && strstr($champs_present_type, 'int') === false)
270
					|| ($champ_attendu_type == 'BOOL' && preg_match('/(?:bool|boolean|tinyint\(1\))/i', $champs_present_type) === false)) {
175 jpm 271
					$champs_erreur[] = array($champ_attendu, $champ_attendu_type, $champs_present_type);
171 jpm 272
				}
273
			}
274
		}
175 jpm 275
		return $champs_erreur;
171 jpm 276
	}
277
 
278
	/**
279
	 * Test #04
280
	 */
175 jpm 281
	private function testerNumNomClePrimaire() {
171 jpm 282
		$info = $this->getInfosTest(4);
175 jpm 283
		$info['special'] = true;
171 jpm 284
 
192 delphine 285
		foreach ($this->colonnes as &$colonne) {
171 jpm 286
			if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') {
287
				$info['resultat'] = true;
192 delphine 288
				break;
171 jpm 289
			}
290
		}
175 jpm 291
		return $info;
171 jpm 292
	}
293
 
294
 
295
	/**
296
	 * Test #05
297
	 */
175 jpm 298
	private function testerTailleDesChamps() {
171 jpm 299
		$tailles_champs_maxi = array();
192 delphine 300
		foreach ($this->colonnes as &$colonne) {
171 jpm 301
			if (preg_match('/^varchar\(([0-9]+)\)$/', $colonne['Type'], $match)) {
302
				$tailles_champs_maxi[$colonne['Field']] = $match[1];
303
			}
304
		}
305
 
306
		$tailles_trouvees = array();
192 delphine 307
		foreach ($this->analyses as &$analyse) {
171 jpm 308
			if (preg_match('/\.([^.]+)$/', $analyse['Field_name'], $match)) {
309
				$tailles_trouvees[$match[1]] = $analyse['Max_length'];
310
			}
311
		}
312
 
313
		$champs_erreur = array();
314
		$champs_attendus = explode(',', $this->manuel['champs']);
192 delphine 315
		foreach ($champs_attendus as &$champ_attendu) {
171 jpm 316
			if (isset($tailles_champs_maxi[$champ_attendu]) && isset($tailles_trouvees[$champ_attendu])) {
317
				if ($tailles_champs_maxi[$champ_attendu] == $tailles_trouvees[$champ_attendu]) {
175 jpm 318
					$champs_erreur[] = array($champ_attendu, $tailles_champs_maxi[$champ_attendu], $tailles_trouvees[$champ_attendu]);
171 jpm 319
				}
320
			}
321
		}
175 jpm 322
		return $champs_erreur;
171 jpm 323
	}
324
 
325
	/**
326
	 * Test #06
327
	 */
328
	private function testerNumNomSuperieurAZero() {
20 jpm 329
		$noms_erreur = array();
64 jpm 330
		foreach ($this->noms as &$nom) {
171 jpm 331
			if ($nom['num_nom'] <= 0) {
175 jpm 332
				$noms_erreur[] = array($nom['num_nom']);
20 jpm 333
			}
334
		}
175 jpm 335
		return $noms_erreur;
20 jpm 336
	}
337
 
171 jpm 338
	/**
339
	 * Test #07
340
	 */
341
	private function testerNumNomRetenuSuperieurAZero() {
20 jpm 342
		$noms_erreur = array();
64 jpm 343
		foreach ($this->noms as &$nom) {
171 jpm 344
			if ($nom['num_nom_retenu'] != '' && $nom['num_nom_retenu'] <= 0) {
175 jpm 345
				$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu']);
20 jpm 346
			}
347
		}
176 jpm 348
		return $noms_erreur;
20 jpm 349
	}
350
 
171 jpm 351
	/**
352
	 * Test #08
353
	 */
199 delphine 354
	private function testerExistenceNumNomRetenu() {
355
		$noms_erreur = array();
356
		foreach ($this->noms as &$nom) {
357
			if ($nom['num_nom_retenu'] != '' && $nom['num_nom_retenu'] != $nom['num_nom']) {
358
				if ($nom['num_nom_retenu'] != 0 && !isset($this->noms[$nom['num_nom_retenu']])) {
359
					$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $nom['exclure_taxref']);
360
				}
361
			}
362
		}
363
		return $noms_erreur;
364
	}
365
 
366
	/**
367
	 * Test #09
368
	 */
369
	private function testerTransmissionNumNomRetenu() {
370
		$noms_erreur = array();
371
		foreach ($this->noms as &$nom) {
372
			if ($nom['num_nom_retenu'] != $nom['num_nom'] && $nom['exclure_taxref'] == 0) {
373
				if ($nom['num_nom_retenu'] != 0 && isset($this->noms[$nom['num_nom_retenu']])) {
374
					if ($this->noms[$nom['num_nom_retenu']]['exclure_taxref'] != 0) {
375
						$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $this->noms[$nom['num_nom_retenu']]['exclure_taxref']);
376
					}
377
				}
378
			}
379
		}
380
		return $noms_erreur;
381
	}
382
 
383
	/**
384
	 * Test #10
385
	 */
386
	private function testerSynonymeNumNomRetenu() {
387
		$noms_erreur = array();
388
		foreach ($this->noms as &$nom) {
389
			if ($nom['num_nom_retenu'] != $nom['num_nom']) {
390
				if ($nom['num_nom_retenu'] != 0 && isset($this->noms[$nom['num_nom_retenu']])) {
391
					if ($this->noms[$nom['num_nom_retenu']]['num_nom'] != $this->noms[$nom['num_nom_retenu']]['num_nom_retenu']) {
392
						$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $this->noms[$nom['num_nom_retenu']]['num_nom_retenu']);
393
					}
394
				}
395
			}
396
		}
397
		return $noms_erreur;
398
	}
399
 
400
 
401
	/**
402
	 * Test #11
403
	 */
171 jpm 404
	private function testerNumTaxSupEgalZeroUnique() {
20 jpm 405
		$noms_erreur = array();
64 jpm 406
		foreach ($this->noms as &$nom) {
171 jpm 407
			if (preg_match('/^0$/', $nom['num_tax_sup'])) {
175 jpm 408
				$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup']);
20 jpm 409
			}
410
		}
176 jpm 411
		// Ce test est spécial car le nombre de noms en erreurs doit être supérieur à 1 et non à 0 pour être KO.
412
		if (count($noms_erreur) == 1) {
177 jpm 413
			$noms_erreur = array();
20 jpm 414
		}
176 jpm 415
		return $noms_erreur;
20 jpm 416
	}
417
 
171 jpm 418
	/**
199 delphine 419
	 * Test #12
171 jpm 420
	 */
421
	private function testerTaxSupPourTaxon() {
20 jpm 422
		$noms_erreur = array();
64 jpm 423
		foreach ($this->noms as &$nom) {
171 jpm 424
			if ($nom['num_nom_retenu'] != $nom['num_nom'] && $nom['num_tax_sup'] != '') {
183 jpm 425
				$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $nom['exclure_taxref']);
20 jpm 426
			}
427
		}
176 jpm 428
		return $noms_erreur;
20 jpm 429
	}
430
 
171 jpm 431
	/**
199 delphine 432
	 * Test #13
171 jpm 433
	 */
199 delphine 434
	private function testerExistenceTaxonSuperieur() {
20 jpm 435
		$noms_erreur = array();
64 jpm 436
		foreach ($this->noms as &$nom) {
171 jpm 437
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
438
				if ($nom['num_tax_sup'] != 0 && !isset($this->noms[$nom['num_tax_sup']])) {
183 jpm 439
					$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $nom['exclure_taxref']);
171 jpm 440
				}
20 jpm 441
			}
442
		}
176 jpm 443
		return $noms_erreur;
20 jpm 444
	}
445
 
171 jpm 446
	/**
199 delphine 447
	 * Test #14
171 jpm 448
	 */
199 delphine 449
	private function testerTransmissionTaxonSuperieur() {
450
		$noms_erreur = array();
451
		foreach ($this->noms as &$nom) {
452
			if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0) {
453
				if ($nom['num_tax_sup'] != 0 && isset($this->noms[$nom['num_tax_sup']])) {
454
					if ($this->noms[$nom['num_tax_sup']]['exclure_taxref'] != 0) {
455
						$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $this->noms[$nom['num_tax_sup']]['exclure_taxref']);
456
					}
457
				}
458
			}
459
		}
460
		return $noms_erreur;
461
	}
462
 
463
 
464
	/**
465
	 * Test #15
466
	 */
171 jpm 467
	private function testerClassificationRang() {
20 jpm 468
		$noms_erreur = array();
64 jpm 469
		foreach ($this->noms as &$nom) {
171 jpm 470
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
471
				if (isset($this->noms[$nom['num_tax_sup']])) {
472
					$nom_sup = $this->noms[$nom['num_tax_sup']];
473
					if ($nom_sup['rang'] >= $nom['rang']) {
474
						// Prise en compte de l'exception des clades
475
						if (! ($nom_sup['rang'] == 70 && $nom['rang'] == 70)) {
183 jpm 476
							$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom_sup['num_nom'], $nom_sup['rang'], $nom['exclure_taxref']);
171 jpm 477
						}
478
					}
20 jpm 479
				}
480
			}
481
		}
176 jpm 482
		return $noms_erreur;
20 jpm 483
	}
484
 
171 jpm 485
	/**
199 delphine 486
	 * Test #16
171 jpm 487
	 */
488
	private function testerClassification() {
20 jpm 489
		$noms_erreur = array();
171 jpm 490
		$this->noms_ok = array();
64 jpm 491
		foreach ($this->noms as &$nom) {
171 jpm 492
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
493
				if (isset($this->noms_ok[$nom['num_tax_sup']])) {
494
					$this->noms_ok[$nom['num_nom']] = true;
495
				} else {
496
					$this->detection_boucle_infini = array();
497
					$classif_ok = $this->remonterClassif($nom);
498
					unset($this->detection_boucle_infini);
499
 
175 jpm 500
					if ($classif_ok === true) {
501
						$this->noms_ok[$nom['num_nom']] = $classif_ok;
171 jpm 502
					} else {
183 jpm 503
						$noms_erreur[] = array($nom['num_nom'], $classif_ok, $nom['exclure_taxref']);
171 jpm 504
					}
20 jpm 505
				}
506
			}
507
		}
171 jpm 508
		unset($this->noms_ok);
176 jpm 509
		return $noms_erreur;
20 jpm 510
	}
511
 
171 jpm 512
	private function remonterClassif(&$nom) {
513
		$this->detection_boucle_infini[$nom['num_nom']] = true;
514
		if (preg_match('/^[0-9]*$/', $nom['num_tax_sup'])) {
515
			if (isset($this->noms_ok[$nom['num_tax_sup']])) {
516
				$this->noms_ok[$nom['num_nom']] = true;
517
				return true;
518
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') {
519
				$this->noms_ok[$nom['num_nom']] = true;
520
				return true;
521
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') {
175 jpm 522
				return 'Hiérarchie avec le taxon #'.$nom['num_nom'].' ayant un taxon superieur #'.$nom['num_tax_sup'].' inexistant';
171 jpm 523
			} else if (isset($this->detection_boucle_infini[$nom['num_tax_sup']])) {
175 jpm 524
				return 'Boucle infinie pour le taxon #'.$nom['num_tax_sup'];
171 jpm 525
			} else {
526
				$retour = $this->remonterClassif($this->noms[$nom['num_tax_sup']]);
527
				if ($retour === true) {
528
					$this->noms_ok[$nom['num_tax_sup']] = true;
529
				}
530
				return $retour;
531
			}
532
		} else {
175 jpm 533
			return 'Valeur num_tax_sup incorrecte : '.$nom['num_tax_sup'];
171 jpm 534
		}
535
	}
536
 
537
	/**
199 delphine 538
	 * Test #17
171 jpm 539
	 */
540
	private function testerRang() {
541
		$rangs = array_flip(explode(',', $this->manuel['rangs']));
542
 
20 jpm 543
		// Réalisation du test
544
		$noms_erreur = array();
64 jpm 545
		foreach ($this->noms as &$nom) {
171 jpm 546
			if (!isset($rangs[$nom['rang']])) {
183 jpm 547
				$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 548
			}
549
		}
176 jpm 550
		return $noms_erreur;
20 jpm 551
	}
552
 
171 jpm 553
	/**
199 delphine 554
	 * Test #18
171 jpm 555
	 */
556
	private function testerNomCompletSupraGenerique() {
20 jpm 557
		$noms_erreur = array();
64 jpm 558
		foreach ($this->noms as &$nom) {
171 jpm 559
			if ($nom['rang'] < $this->manuel['rang_genre']) {
560
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
561
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']);
562
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
563
				if ($nom['nom_sci'] != $nom_sci_ideal) {
564
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 565
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
20 jpm 566
				}
567
			}
568
		}
176 jpm 569
		return $noms_erreur;
20 jpm 570
	}
571
 
171 jpm 572
	/**
199 delphine 573
	 * Test #19
171 jpm 574
	 */
575
	private function testerNomCompletGenre() {
20 jpm 576
		$noms_erreur = array();
171 jpm 577
		foreach ($this->noms as &$nom) {
578
			if ($nom['rang'] == $this->manuel['rang_genre']) {
579
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
580
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
581
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
582
				if ($nom['nom_sci'] != $nom_sci_ideal) {
583
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 584
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
20 jpm 585
				}
586
			}
587
		}
176 jpm 588
		return $noms_erreur;
20 jpm 589
	}
590
 
171 jpm 591
	/**
199 delphine 592
	 * Test #20
171 jpm 593
	 */
594
	private function testerNomCompletInfraGenre() {
20 jpm 595
		$noms_erreur = array();
64 jpm 596
		foreach ($this->noms as &$nom) {
171 jpm 597
			if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) {
598
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
599
				$nom_sci_ideal = '';
600
				if ($nom['type_epithete'] == 'agg.') {
601
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
602
					$nom_sci_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
603
					$nom_sci_ideal .= ' '.$nom['type_epithete'];
604
				} else {
605
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
606
					$nom_sci_ideal .= ' '.$nom['type_epithete'];
607
					$nom_sci_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
20 jpm 608
				}
171 jpm 609
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
610
				if ($nom['nom_sci'] != $nom_sci_ideal) {
611
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 612
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
171 jpm 613
				}
20 jpm 614
			}
615
		}
176 jpm 616
		return $noms_erreur;
20 jpm 617
	}
618
 
171 jpm 619
	/**
199 delphine 620
	 * Test #21
171 jpm 621
	 */
622
	private function testerNomCompletEspece() {
20 jpm 623
		$noms_erreur = array();
64 jpm 624
		foreach ($this->noms as &$nom) {
171 jpm 625
			if ($nom['rang'] == $this->manuel['rang_sp']) {
626
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
627
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
194 delphine 628
				$nom_sci_ideal .= (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $nom['epithete_sp'], $match) != '' ?
629
					' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.utf8_encode(strtolower(utf8_decode($match[2]))).
630
					' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[3])))) :
631
					' '.utf8_encode(strtolower(utf8_decode($nom['epithete_sp']))));
171 jpm 632
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
194 delphine 633
				$nom_sci_ideal = trim($nom_sci_ideal);
171 jpm 634
				if ($nom['nom_sci'] != $nom_sci_ideal) {
635
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 636
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
20 jpm 637
				}
638
			}
639
		}
176 jpm 640
		return $noms_erreur;
20 jpm 641
	}
642
 
171 jpm 643
	/**
199 delphine 644
	 * Test #22
171 jpm 645
	 */
646
	private function testerNomCompletInfraSpecifique() {
158 delphine 647
		$noms_erreur = array();
648
		foreach ($this->noms as &$nom) {
171 jpm 649
			if ($nom['rang'] > $this->manuel['rang_sp']) {
650
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
651
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
192 delphine 652
				$nom_sci_ideal .= ' '.utf8_encode(strtolower(utf8_decode($nom['epithete_sp'])));
653
				$nom_sci_ideal .= ' '.utf8_encode(strtolower(utf8_decode($nom['type_epithete'])));
194 delphine 654
				$nom_sci_ideal .= (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $nom['epithete_infra_sp'], $match) != '' ?
655
					' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.utf8_encode(strtolower(utf8_decode($match[2]))).
656
					' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[3])))) :
657
					' '.utf8_encode(strtolower(utf8_decode($nom['epithete_infra_sp']))));
171 jpm 658
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
194 delphine 659
				$nom_sci_ideal = trim($nom_sci_ideal);
171 jpm 660
				if ($nom['nom_sci'] != $nom_sci_ideal) {
661
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 662
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
171 jpm 663
				}
158 delphine 664
			}
665
		}
176 jpm 666
		return $noms_erreur;
158 delphine 667
	}
668
 
171 jpm 669
	/**
199 delphine 670
	 * Test #23
171 jpm 671
	 */
672
	private function testerNomSupraGeneriqueEspaces() {
20 jpm 673
		$noms_erreur = array();
64 jpm 674
		foreach ($this->noms as &$nom) {
171 jpm 675
			if ($nom['nom_supra_generique'] != '') {
676
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
677
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
183 jpm 678
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']);
20 jpm 679
				}
680
			}
681
		}
176 jpm 682
		return $noms_erreur;
20 jpm 683
	}
684
 
171 jpm 685
	/**
199 delphine 686
	 * Test #24
171 jpm 687
	 */
688
	private function testerNomSupraGeneriqueSyntaxe() {
20 jpm 689
		$noms_erreur = array();
64 jpm 690
		foreach ($this->noms as &$nom) {
171 jpm 691
			if ($nom['nom_supra_generique'] != '') {
692
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) {
693
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
183 jpm 694
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']);
20 jpm 695
				}
696
			}
697
		}
177 jpm 698
		return $noms_erreur;
20 jpm 699
	}
700
 
171 jpm 701
	/**
199 delphine 702
	 * Test #25
171 jpm 703
	 */
704
	private function testerNomSupraGeneriqueRang() {
20 jpm 705
		$noms_erreur = array();
64 jpm 706
		foreach ($this->noms as &$nom) {
171 jpm 707
			if ($nom['nom_supra_generique'] != '') {
708
				if ($nom['rang'] >= $this->manuel['rang_genre']) {
183 jpm 709
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 710
				}
711
			}
712
		}
177 jpm 713
		return $noms_erreur;
20 jpm 714
	}
715
 
171 jpm 716
	/**
199 delphine 717
	 * Test #26
171 jpm 718
	 */
719
	private function testerGenreEspaces() {
20 jpm 720
		$noms_erreur = array();
64 jpm 721
		foreach ($this->noms as &$nom) {
171 jpm 722
			if ($nom['genre'] != '') {
723
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) {
724
					$nom_traite = $this->repererEspace($nom['genre']);
183 jpm 725
					$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
20 jpm 726
				}
727
			}
728
		}
177 jpm 729
		return $noms_erreur;
20 jpm 730
	}
731
 
171 jpm 732
	/**
199 delphine 733
	 * Test #27
171 jpm 734
	 */
735
	private function testerGenreSyntaxe() {
20 jpm 736
		$noms_erreur = array();
64 jpm 737
		foreach ($this->noms as &$nom) {
171 jpm 738
			if ($nom['genre'] != '') {
739
				$mots = explode(' ', $nom['genre']);
740
				foreach ($mots as $mot) {
741
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) {
742
						$nom_traite = $this->repererEspace($nom['genre']);
183 jpm 743
						$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
194 delphine 744
						break;
171 jpm 745
					}
20 jpm 746
				}
747
			}
748
		}
177 jpm 749
		return $noms_erreur;
20 jpm 750
	}
751
 
171 jpm 752
	/**
199 delphine 753
	 * Test #28
171 jpm 754
	 */
755
	private function testerGenreRang() {
20 jpm 756
		$noms_erreur = array();
64 jpm 757
		foreach ($this->noms as &$nom) {
171 jpm 758
			if ($nom['genre'] != '') {
759
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 760
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 761
				}
762
			}
763
		}
177 jpm 764
		return $noms_erreur;
20 jpm 765
	}
766
 
171 jpm 767
	/**
199 delphine 768
	 * Test #29
171 jpm 769
	 */
770
	private function testerEpitheteInfraGeneriqueSyntaxe() {
20 jpm 771
		$noms_erreur = array();
64 jpm 772
		foreach ($this->noms as &$nom) {
171 jpm 773
			if ($nom['epithete_infra_generique'] != '') {
774
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) {
775
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
183 jpm 776
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 777
				}
778
			}
779
		}
177 jpm 780
		return $noms_erreur;
20 jpm 781
	}
782
 
171 jpm 783
	/**
199 delphine 784
	 * Test #30
171 jpm 785
	 */
786
	private function testerEpitheteInfraGeneriqueRang() {
20 jpm 787
		$noms_erreur = array();
64 jpm 788
		foreach ($this->noms as &$nom) {
171 jpm 789
			if ($nom['epithete_infra_generique'] != '') {
790
				if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) {
183 jpm 791
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 792
				}
793
			}
794
		}
177 jpm 795
		return $noms_erreur;
20 jpm 796
	}
797
 
171 jpm 798
	/**
199 delphine 799
	 * Test #31
171 jpm 800
	 */
801
	private function testerEpitheteInfraGeneriqueEspaces() {
20 jpm 802
		$noms_erreur = array();
64 jpm 803
		foreach ($this->noms as &$nom) {
171 jpm 804
			if ($nom['epithete_infra_generique'] != '') {
805
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) {
806
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
183 jpm 807
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 808
				}
809
			}
810
		}
177 jpm 811
		return $noms_erreur;
20 jpm 812
	}
813
 
171 jpm 814
	/**
199 delphine 815
	 * Test #32
171 jpm 816
	 */
817
	private function testerEpitheteSpEspaces() {
20 jpm 818
		$noms_erreur = array();
64 jpm 819
		foreach ($this->noms as &$nom) {
171 jpm 820
			if ($nom['epithete_sp'] != '') {
821
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) {
822
					$epithete_traite = $this->repererEspace($nom['epithete_sp']);
183 jpm 823
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 824
				}
825
			}
826
		}
177 jpm 827
		return $noms_erreur;
20 jpm 828
	}
829
 
171 jpm 830
	/**
199 delphine 831
	 * Test #33
171 jpm 832
	 */
833
	private function testerEpitheteSpSyntaxe() {
20 jpm 834
		$noms_erreur = array();
64 jpm 835
		foreach ($this->noms as &$nom) {
171 jpm 836
			if ($nom['epithete_sp'] != '') {
837
				$mots = explode(' ', $nom['epithete_sp']);
838
				foreach ($mots as $mot) {
839
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot))) {
840
						$epithete_traite = $this->repererEspace($nom['epithete_sp']);
183 jpm 841
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
194 delphine 842
						break;
171 jpm 843
					}
844
				}
20 jpm 845
			}
846
		}
177 jpm 847
		return $noms_erreur;
20 jpm 848
	}
849
 
171 jpm 850
	/**
199 delphine 851
	 * Test #34
171 jpm 852
	 */
853
	private function testerEpitheteSpRang() {
20 jpm 854
		$noms_erreur = array();
64 jpm 855
		foreach ($this->noms as &$nom) {
171 jpm 856
			if ($nom['epithete_sp'] != '') {
857
				if ($nom['rang'] < $this->manuel['rang_sp']) {
183 jpm 858
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 859
				}
860
			}
861
		}
177 jpm 862
		return $noms_erreur;
20 jpm 863
	}
864
 
171 jpm 865
	/**
199 delphine 866
	 * Test #35
171 jpm 867
	 */
868
	private function testerTypeEpitheteEspaces() {
20 jpm 869
		$noms_erreur = array();
64 jpm 870
		foreach ($this->noms as &$nom) {
171 jpm 871
			if ($nom['type_epithete'] != '') {
872
				if (preg_match('/\s+/', $nom['type_epithete'])) {
873
					$valeur_traitee = $this->repererEspace($nom['epithete_sp']);
183 jpm 874
					$noms_erreur[] = array($nom['num_nom'], $valeur_traitee, $nom['exclure_taxref']);
20 jpm 875
				}
876
			}
877
		}
177 jpm 878
		return $noms_erreur;
20 jpm 879
	}
880
 
171 jpm 881
	/**
199 delphine 882
	 * Test #36
171 jpm 883
	 */
884
	private function testerTypeEpitheteSyntaxe() {
20 jpm 885
		$noms_erreur = array();
64 jpm 886
		foreach ($this->noms as &$nom) {
171 jpm 887
			if ($nom['type_epithete'] != '') {
888
				if (!$this->verifierTypeEpithete($nom['type_epithete'])) {
183 jpm 889
					$noms_erreur[] = array($nom['num_nom'],  $nom['type_epithete'], $nom['exclure_taxref']);
20 jpm 890
				}
891
			}
892
		}
177 jpm 893
		return $noms_erreur;
20 jpm 894
	}
895
 
171 jpm 896
	/**
199 delphine 897
	 * Test #37
171 jpm 898
	 */
899
	private function testerTypeEpitheteHybridite() {
20 jpm 900
		$noms_erreur = array();
64 jpm 901
		foreach ($this->noms as &$nom) {
171 jpm 902
			if ($nom['type_epithete'] != '') {
903
				if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) {
183 jpm 904
					$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete'], $nom['exclure_taxref']);
20 jpm 905
				}
906
			}
907
		}
177 jpm 908
		return $noms_erreur;
20 jpm 909
	}
910
 
171 jpm 911
	/**
199 delphine 912
	 * Test #38
171 jpm 913
	 */
64 jpm 914
	private function testerEpitheteInfraSpEspaces() {
20 jpm 915
		$noms_erreur = array();
64 jpm 916
		foreach ($this->noms as &$nom) {
20 jpm 917
			if ($nom['epithete_infra_sp'] != '') {
918
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) {
919
					$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
183 jpm 920
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 921
				}
922
			}
923
		}
177 jpm 924
		return $noms_erreur;
20 jpm 925
	}
926
 
171 jpm 927
	/**
199 delphine 928
	 * Test #39
171 jpm 929
	 */
64 jpm 930
	private function testerEpitheteInfraSpSyntaxe() {
20 jpm 931
		$noms_erreur = array();
64 jpm 932
		foreach ($this->noms as &$nom) {
20 jpm 933
			if ($nom['epithete_infra_sp'] != '') {
934
				$mots = explode(' ', $nom['epithete_infra_sp']);
935
				foreach ($mots as $mot) {
936
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpitheteSp($mot))) {
194 delphine 937
						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
938
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
939
						break;
20 jpm 940
					}
941
				}
942
			}
943
		}
177 jpm 944
		return $noms_erreur;
20 jpm 945
	}
946
 
171 jpm 947
	/**
199 delphine 948
	 * Test #40
171 jpm 949
	 */
64 jpm 950
	private function testerEpitheteInfraSpRang() {
20 jpm 951
		$noms_erreur = array();
64 jpm 952
		foreach ($this->noms as &$nom) {
20 jpm 953
			if ($nom['epithete_infra_sp'] != '') {
954
				if ($nom['rang'] < $this->manuel['rang_sp']) {
183 jpm 955
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 956
				}
957
			}
958
		}
177 jpm 959
		return $noms_erreur;
20 jpm 960
	}
961
 
173 jpm 962
	/**
199 delphine 963
	 * Test #41
173 jpm 964
	 */
965
	private function testerGroupeCultivarSyntaxe() {
20 jpm 966
		$noms_erreur = array();
64 jpm 967
		foreach ($this->noms as &$nom) {
173 jpm 968
			if ($nom['cultivar_groupe'] != '') {
969
				if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
970
					$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
183 jpm 971
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 972
				}
973
			}
974
		}
177 jpm 975
		return $noms_erreur;
20 jpm 976
	}
977
 
173 jpm 978
	/**
199 delphine 979
	 * Test #42
173 jpm 980
	 */
981
	private function testerGroupeCultivarRang() {
20 jpm 982
		$noms_erreur = array();
64 jpm 983
		foreach ($this->noms as &$nom) {
173 jpm 984
			if ($nom['cultivar_groupe'] != '') {
985
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 986
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 987
				}
988
			}
989
		}
177 jpm 990
		return $noms_erreur;
20 jpm 991
	}
992
 
173 jpm 993
	/**
199 delphine 994
	 * Test #43
173 jpm 995
	 */
996
	private function testerCultivarSyntaxe() {
20 jpm 997
		$noms_erreur = array();
64 jpm 998
		foreach ($this->noms as &$nom) {
173 jpm 999
			if ($nom['cultivar'] != '') {
1000
				if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
1001
					$epithete_traite = $this->repererEspace($nom['cultivar']);
183 jpm 1002
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 1003
				}
1004
			}
1005
		}
177 jpm 1006
		return $noms_erreur;
20 jpm 1007
	}
1008
 
173 jpm 1009
	/**
199 delphine 1010
	 * Test #44
173 jpm 1011
	 */
1012
	private function testerCultivarRang() {
20 jpm 1013
		$noms_erreur = array();
64 jpm 1014
		foreach ($this->noms as &$nom) {
173 jpm 1015
			if ($nom['cultivar'] != '') {
1016
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 1017
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
171 jpm 1018
				}
20 jpm 1019
			}
1020
		}
177 jpm 1021
		return $noms_erreur;
20 jpm 1022
	}
1023
 
173 jpm 1024
	/**
199 delphine 1025
	 * Test #45
173 jpm 1026
	 */
1027
	private function testerNomCommercialSyntaxe() {
20 jpm 1028
		$noms_erreur = array();
64 jpm 1029
		foreach ($this->noms as &$nom) {
173 jpm 1030
			if ($nom['nom_commercial'] != '') {
1031
				if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
1032
					$epithete_traite = $this->repererEspace($nom['nom_commercial']);
183 jpm 1033
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
171 jpm 1034
				}
20 jpm 1035
			}
1036
		}
177 jpm 1037
		return $noms_erreur;
20 jpm 1038
	}
1039
 
173 jpm 1040
	/**
199 delphine 1041
	 * Test #46
173 jpm 1042
	 */
1043
	private function testerNomCommercialPresenceCultivar() {
20 jpm 1044
		$noms_erreur = array();
64 jpm 1045
		foreach ($this->noms as &$nom) {
173 jpm 1046
			if ((isset($nom['nom_commercial']) && $nom['nom_commercial'] != '') && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
183 jpm 1047
				$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
20 jpm 1048
			}
1049
		}
177 jpm 1050
		return $noms_erreur;
20 jpm 1051
	}
1052
 
173 jpm 1053
	/**
199 delphine 1054
	 * Test #47
173 jpm 1055
	 */
1056
	private function testerAuteurSyntaxe() {
20 jpm 1057
		$noms_erreur = array();
64 jpm 1058
		foreach ($this->noms as &$nom) {
173 jpm 1059
			if ($nom['auteur'] != '') {
1060
				if (!$this->verifierAuteur($nom['auteur'])) {
1061
					$intitule_traite = $this->repererEspace($nom['auteur']);
183 jpm 1062
					$noms_erreur[] = array($nom['num_nom'], $intitule_traite, $nom['exclure_taxref']);
171 jpm 1063
				}
20 jpm 1064
			}
1065
		}
177 jpm 1066
		return $noms_erreur;
20 jpm 1067
	}
1068
 
173 jpm 1069
	/**
199 delphine 1070
	 * Test #48
173 jpm 1071
	 */
1072
	private function testerAnneeSyntaxe() {
20 jpm 1073
		$noms_erreur = array();
64 jpm 1074
		foreach ($this->noms as &$nom) {
173 jpm 1075
			if ($nom['annee'] != '') {
1076
				if (!$this->verifierAnnee($nom['annee'])) {
183 jpm 1077
					$noms_erreur[] = array($nom['num_nom'], $nom['annee'], $nom['exclure_taxref']);
171 jpm 1078
				}
20 jpm 1079
			}
1080
		}
177 jpm 1081
		return $noms_erreur;
20 jpm 1082
	}
1083
 
173 jpm 1084
	/**
199 delphine 1085
	 * Test #49
173 jpm 1086
	 */
1087
	private function testerBiblioOrigineSyntaxe() {
20 jpm 1088
		$noms_erreur = array();
64 jpm 1089
		foreach ($this->noms as &$nom) {
173 jpm 1090
			if ($nom['biblio_origine'] != '') {
1091
				if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
1092
					$biblio_traite = $this->repererEspace($nom['biblio_origine']);
183 jpm 1093
					$noms_erreur[] = array($nom['num_nom'], $biblio_traite, $nom['exclure_taxref']);
20 jpm 1094
				}
1095
			}
1096
		}
177 jpm 1097
		return $noms_erreur;
20 jpm 1098
	}
1099
 
173 jpm 1100
	/**
199 delphine 1101
	 * Test #50
173 jpm 1102
	 */
1103
	private function testerHomonymieSyntaxe() {
20 jpm 1104
		$noms_erreur = array();
173 jpm 1105
		foreach ($this->noms as &$nom) {
1106
			if ($nom['homonyme'] != '') {
1107
				if (!$this->verifierBooleen($nom['homonyme'])) {
183 jpm 1108
					$noms_erreur[] = array($nom['num_nom'], $nom['homonyme'], $nom['exclure_taxref']);
161 jpm 1109
				}
20 jpm 1110
			}
1111
		}
177 jpm 1112
		return $noms_erreur;
20 jpm 1113
	}
1114
 
173 jpm 1115
	/**
199 delphine 1116
	 * Test #51
173 jpm 1117
	 */
1118
	private function testerHomonymieExistence() {
1119
		$noms_homonymie = $this->classerNomsParNomComplet();
1120
 
20 jpm 1121
		$noms_erreur = array();
64 jpm 1122
		foreach ($this->noms as &$nom) {
173 jpm 1123
			if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
1124
				if ($noms_homonymie[$nom['nom_sci']] <= 1) {
183 jpm 1125
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
171 jpm 1126
				}
20 jpm 1127
			}
1128
		}
173 jpm 1129
		$noms_homonymie = null;
177 jpm 1130
		return $noms_erreur;
20 jpm 1131
	}
1132
 
173 jpm 1133
	/**
199 delphine 1134
	 * Test #52
173 jpm 1135
	 */
1136
	private function testerBasionymeSyntaxe() {
20 jpm 1137
		$noms_erreur = array();
64 jpm 1138
		foreach ($this->noms as &$nom) {
173 jpm 1139
			if ($nom['basionyme'] != '') {
1140
				if (!$this->verifierNombre($nom['basionyme'])) {
183 jpm 1141
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme'], $nom['exclure_taxref']);
20 jpm 1142
				}
1143
			}
1144
		}
177 jpm 1145
		return $noms_erreur;
20 jpm 1146
	}
173 jpm 1147
 
1148
	/**
199 delphine 1149
	 * Test #53
173 jpm 1150
	 */
1151
	private function testerBasionymeExistence() {
20 jpm 1152
		$noms_erreur = array();
64 jpm 1153
		foreach ($this->noms as &$nom) {
173 jpm 1154
			if ($nom['basionyme'] != '') {
1155
				if (!isset($this->noms[$nom['basionyme']])) {
183 jpm 1156
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme'], $nom['exclure_taxref']);
173 jpm 1157
				}
20 jpm 1158
			}
1159
		}
177 jpm 1160
		return $noms_erreur;
20 jpm 1161
	}
1162
 
173 jpm 1163
	/**
199 delphine 1164
	 * Test #54
173 jpm 1165
	 */
1166
	private function testerSynonymeProparteSyntaxe() {
20 jpm 1167
		$noms_erreur = array();
64 jpm 1168
		foreach ($this->noms as &$nom) {
171 jpm 1169
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1170
				if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
183 jpm 1171
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte'], $nom['exclure_taxref']);
20 jpm 1172
				}
1173
			}
1174
		}
177 jpm 1175
		return $noms_erreur;
20 jpm 1176
	}
1177
 
173 jpm 1178
	/**
199 delphine 1179
	 * Test #55
173 jpm 1180
	 */
1181
	private function testerSynonymeProparteExistence() {
20 jpm 1182
		$noms_erreur = array();
64 jpm 1183
		foreach ($this->noms as &$nom) {
171 jpm 1184
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1185
				$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
1186
				$num_nom_en_erreur = array();
1187
				foreach ($num_nom_a_verifier as $num_nom) {
1188
					if (!isset($this->noms[$num_nom])) {
1189
						$num_nom_en_erreur[] = $num_nom;
1190
					}
20 jpm 1191
				}
173 jpm 1192
				if (count($nbre_en_erreur) > 0) {
183 jpm 1193
					$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur), $nom['exclure_taxref']);
173 jpm 1194
				}
20 jpm 1195
			}
1196
		}
177 jpm 1197
		return $noms_erreur;
20 jpm 1198
	}
1199
 
173 jpm 1200
	/**
199 delphine 1201
	 * Test #56
173 jpm 1202
	 */
1203
	private function testerSynonymeDouteuxSyntaxe() {
20 jpm 1204
		$noms_erreur = array();
64 jpm 1205
		foreach ($this->noms as &$nom) {
173 jpm 1206
			if ($nom['synonyme_douteux'] != '') {
1207
				if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
183 jpm 1208
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
20 jpm 1209
				}
1210
			}
1211
		}
177 jpm 1212
		return $noms_erreur;
20 jpm 1213
	}
1214
 
173 jpm 1215
	/**
199 delphine 1216
	 * Test #57
173 jpm 1217
	 */
1218
	private function testerSynonymeDouteuxNumNomRetenu() {
20 jpm 1219
		$noms_erreur = array();
64 jpm 1220
		foreach ($this->noms as &$nom) {
186 delphine 1221
			if ($nom['synonyme_douteux'] == 1 && !$this->verifierNombre($nom['num_nom_retenu'])) {
1222
				$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
20 jpm 1223
			}
1224
		}
177 jpm 1225
		return $noms_erreur;
20 jpm 1226
	}
1227
 
171 jpm 1228
	/**
199 delphine 1229
	 * Test #58
171 jpm 1230
	 */
173 jpm 1231
	private function testerSynonymeMalAppliqueSyntaxe() {
20 jpm 1232
		$noms_erreur = array();
64 jpm 1233
		foreach ($this->noms as &$nom) {
173 jpm 1234
			if ($nom['synonyme_mal_applique'] != '') {
1235
				if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
183 jpm 1236
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']);
20 jpm 1237
				}
1238
			}
1239
		}
177 jpm 1240
		return $noms_erreur;
20 jpm 1241
	}
1242
 
171 jpm 1243
	/**
199 delphine 1244
	 * Test #59
171 jpm 1245
	 */
173 jpm 1246
	private function testerSynonymeOrthographiqueSyntaxe() {
20 jpm 1247
		$noms_erreur = array();
173 jpm 1248
		foreach ($this->noms as $nom) {
1249
			if ($nom['synonyme_orthographique'] != '') {
1250
				if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
183 jpm 1251
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
20 jpm 1252
				}
1253
			}
1254
		}
177 jpm 1255
		return $noms_erreur;
20 jpm 1256
	}
1257
 
171 jpm 1258
	/**
199 delphine 1259
	 * Test #60
171 jpm 1260
	 */
173 jpm 1261
	private function testerSynonymeOrthographiqueExistence() {
20 jpm 1262
		$noms_erreur = array();
64 jpm 1263
		foreach ($this->noms as &$nom) {
173 jpm 1264
			if ($nom['synonyme_orthographique'] != '') {
1265
				if (!isset($this->noms[$nom['synonyme_orthographique']])) {
183 jpm 1266
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
20 jpm 1267
				}
1268
			}
1269
		}
177 jpm 1270
		return $noms_erreur;
20 jpm 1271
	}
1272
 
171 jpm 1273
	/**
199 delphine 1274
	 * Test #61
171 jpm 1275
	 */
173 jpm 1276
	private function testerHybrideParent01Syntaxe() {
20 jpm 1277
		$noms_erreur = array();
64 jpm 1278
		foreach ($this->noms as &$nom) {
173 jpm 1279
			if ($nom['hybride_parent_01'] != '') {
1280
				if (!$this->verifierNombre($nom['hybride_parent_01'])) {
183 jpm 1281
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
20 jpm 1282
				}
1283
			}
1284
		}
177 jpm 1285
		return $noms_erreur;
20 jpm 1286
	}
1287
 
171 jpm 1288
	/**
199 delphine 1289
	 * Test #62
171 jpm 1290
	 */
173 jpm 1291
	private function testerHybrideParent01Existence() {
20 jpm 1292
		$noms_erreur = array();
64 jpm 1293
		foreach ($this->noms as &$nom) {
173 jpm 1294
			if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
1295
				if (!isset($this->noms[$nom['hybride_parent_01']])) {
183 jpm 1296
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
20 jpm 1297
				}
1298
			}
1299
		}
177 jpm 1300
		return $noms_erreur;
20 jpm 1301
	}
171 jpm 1302
 
1303
	/**
199 delphine 1304
	 * Test #63
171 jpm 1305
	 */
173 jpm 1306
	private function testerHybrideParent02Syntaxe() {
20 jpm 1307
		$noms_erreur = array();
64 jpm 1308
		foreach ($this->noms as &$nom) {
173 jpm 1309
			if ($nom['hybride_parent_02'] != '') {
1310
				if (!$this->verifierNombre($nom['hybride_parent_02'])) {
183 jpm 1311
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
173 jpm 1312
				}
20 jpm 1313
			}
1314
		}
177 jpm 1315
		return $noms_erreur;
20 jpm 1316
	}
1317
 
171 jpm 1318
	/**
199 delphine 1319
	 * Test #64
171 jpm 1320
	 */
173 jpm 1321
	private function testerHybrideParent02Existence() {
20 jpm 1322
		$noms_erreur = array();
64 jpm 1323
		foreach ($this->noms as &$nom) {
173 jpm 1324
			if ($nom['hybride_parent_02'] != '') {
1325
				if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
183 jpm 1326
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
20 jpm 1327
				}
1328
			}
1329
		}
177 jpm 1330
		return $noms_erreur;
20 jpm 1331
	}
1332
 
171 jpm 1333
	/**
199 delphine 1334
	 * Test #65
171 jpm 1335
	 */
173 jpm 1336
	private function testerPresenceSyntaxe() {
20 jpm 1337
		$noms_erreur = array();
64 jpm 1338
		foreach ($this->noms as &$nom) {
173 jpm 1339
			if ($nom['presence'] != '') {
1340
				if (!$this->verifierPresence($nom['presence'])) {
183 jpm 1341
					$noms_erreur[] = array($nom['num_nom'], $nom['presence'], $nom['exclure_taxref']);
20 jpm 1342
				}
1343
			}
1344
		}
177 jpm 1345
		return $noms_erreur;
20 jpm 1346
	}
1347
 
171 jpm 1348
	/**
199 delphine 1349
	 * Test #66
171 jpm 1350
	 */
173 jpm 1351
	private function testerStatutOrigineSyntaxe() {
20 jpm 1352
		$noms_erreur = array();
64 jpm 1353
		foreach ($this->noms as &$nom) {
173 jpm 1354
			if ($nom['statut_origine'] != '') {
1355
				if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
183 jpm 1356
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine'], $nom['exclure_taxref']);
20 jpm 1357
				}
1358
			}
1359
		}
177 jpm 1360
		return $noms_erreur;
20 jpm 1361
	}
1362
 
171 jpm 1363
	/**
199 delphine 1364
	 * Test #67
171 jpm 1365
	 */
173 jpm 1366
	private function testerStatutIntroductionSyntaxe() {
20 jpm 1367
		$noms_erreur = array();
64 jpm 1368
		foreach ($this->noms as &$nom) {
173 jpm 1369
			if ($nom['statut_introduction'] != '') {
1370
				if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
183 jpm 1371
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction'], $nom['exclure_taxref']);
20 jpm 1372
				}
1373
			}
1374
		}
177 jpm 1375
		return $noms_erreur;
20 jpm 1376
	}
1377
 
171 jpm 1378
	/**
199 delphine 1379
	 * Test #68
171 jpm 1380
	 */
173 jpm 1381
	private function testerStatutCultureSyntaxe() {
20 jpm 1382
		$noms_erreur = array();
64 jpm 1383
		foreach ($this->noms as &$nom) {
173 jpm 1384
			if ($nom['statut_culture'] != '') {
1385
				if (!$this->verifierStatutCulture($nom['statut_culture'])) {
183 jpm 1386
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture'], $nom['exclure_taxref']);
20 jpm 1387
				}
1388
			}
1389
		}
177 jpm 1390
		return $noms_erreur;
20 jpm 1391
	}
1392
 
171 jpm 1393
	/**
199 delphine 1394
	 * Test #69
171 jpm 1395
	 */
146 delphine 1396
	private function testerExclureTaxRefSyntaxe() {
1397
		$noms_erreur = array();
1398
		foreach ($this->noms as &$nom) {
1399
			if ($nom['exclure_taxref'] != '' && $nom['exclure_taxref'] != null) {
183 jpm 1400
				if (!preg_match('/^(?:0|1|9)$/', $nom['exclure_taxref'])) {
146 delphine 1401
					$noms_erreur[] = array($nom['num_nom'], $nom['exclure_taxref']);
1402
				}
1403
			}
1404
		}
177 jpm 1405
		return $noms_erreur;
146 delphine 1406
	}
171 jpm 1407
 
1408
 
1409
 
20 jpm 1410
	//+--------------------------------------------------------------------------------------------------------------+//
1411
	// MÉTHODES COMMUNES aux TESTS
1412
 
64 jpm 1413
	private function verifierPresence(&$valeur) {
20 jpm 1414
		$codes = $this->manuel['codes_presence'];
1415
		$ok = $this->verifierStatuts($valeur, $codes);
1416
		return $ok;
1417
	}
1418
 
64 jpm 1419
	private function verifierStatutOrigine(&$valeur) {
20 jpm 1420
		$codes = $this->manuel['codes_statuts_origine'];
1421
		$ok = $this->verifierStatuts($valeur, $codes);
1422
		return $ok;
1423
	}
1424
 
64 jpm 1425
	private function verifierStatutIntroduction(&$valeur) {
20 jpm 1426
		$codes = $this->manuel['codes_statuts_introduction'];
1427
		$ok = $this->verifierStatuts($valeur, $codes);
1428
		return $ok;
1429
	}
1430
 
64 jpm 1431
	private function verifierStatutCulture(&$valeur) {
20 jpm 1432
		$codes = $this->manuel['codes_statuts_culture'];
1433
		$ok = $this->verifierStatuts($valeur, $codes);
1434
		return $ok;
1435
	}
1436
 
64 jpm 1437
	private function verifierStatuts(&$valeur, &$codes) {
20 jpm 1438
		$ok = true;
1439
		if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
1440
			$ok = false;
1441
		}
1442
		return $ok;
1443
	}
1444
 
64 jpm 1445
	private function verifierBooleen(&$valeur) {
20 jpm 1446
		$ok = true;
1447
		if (!preg_match('/^1$/', $valeur)) {
1448
			$ok = false;
1449
		}
1450
		return $ok;
1451
	}
1452
 
64 jpm 1453
	private function verifierNombre(&$valeur) {
20 jpm 1454
		$ok = true;
1455
		if (!preg_match('/^[0-9]+$/', $valeur)) {
1456
			$ok = false;
1457
		}
1458
		return $ok;
1459
	}
1460
 
64 jpm 1461
	private function verifierNombreSuite(&$valeur) {
20 jpm 1462
		$ok = true;
1463
		if (!preg_match('/^(?:[0-9]+,)*[0-9]+$/', $valeur)) {
1464
			$ok = false;
1465
		}
1466
		return $ok;
1467
	}
1468
 
64 jpm 1469
	private function verifierTypeEpithete(&$type) {
20 jpm 1470
		$ok = false;
1471
		$rejetes = $this->manuel['type_epithete_rejetes'];
1472
		if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
1473
			$ok = false;
1474
		} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
1475
			$ok = true;
1476
		}
1477
		return $ok;
1478
	}
1479
 
64 jpm 1480
	private function verifierBiblioOrigine(&$intitule) {
20 jpm 1481
		$ok = true;
1482
		if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1483
			$ok = false;// Contient des espaces en trop
1484
		} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
1485
			$ok = false;
1486
		} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
1487
			$ok = false;// Contient une mauvaise suite de caractères
1488
		}
1489
		return $ok;
1490
	}
1491
 
64 jpm 1492
	private function verifierAnnee(&$annee) {
20 jpm 1493
		$ok = true;
1494
		if (!preg_match('/^[0-9]{4}$/', $annee)) {
1495
			$ok = false;
188 delphine 1496
		} else if ($annee < ANNEE_MINIMUM) {
20 jpm 1497
			$ok = false;
188 delphine 1498
		} else if ($annee > ANNEE_EN_COURS) {
186 delphine 1499
			$ok = false;
20 jpm 1500
		}
1501
		return $ok;
1502
	}
1503
 
64 jpm 1504
	private function verifierAuteur(&$intitule) {
20 jpm 1505
		$ok = true;
1506
		$acceptes = $this->manuel['auteur_acceptes'];
1507
		if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
1508
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1509
				$ok = false;// Contient des espaces en trop
1510
			} else {
1511
				$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
1512
				$mots = explode(' ', $intitule);
1513
				foreach ($mots as $position => $mot) {
1514
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1515
						$ok = false;// Mot rejeté
184 jpm 1516
					} else if (preg_match("/^(?:(?:\p{L}|[.'\(\),-])+|[&])$/u", $mot)) {
20 jpm 1517
						continue;// Mot de l'intitulé auteur
1518
					} else {
1519
						$ok = false;
1520
					}
1521
				}
1522
			}
1523
		}
1524
		return $ok;
1525
	}
1526
 
64 jpm 1527
	private function verifierNomCommercial(&$epithete) {
20 jpm 1528
		$ok = false;
1529
		if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
1530
			$ok = true;
1531
		}
1532
		return $ok;
1533
	}
1534
 
64 jpm 1535
	private function verifierEpitheteCultivar(&$epithete) {
20 jpm 1536
		$ok = true;
1537
		$acceptes = $this->manuel['cultivar_acceptes'];
1538
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1539
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1540
				$ok = false;// Contient des espaces en trop
1541
			} else {
1542
				$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
1543
				$mots_mineurs = $this->manuel['mots_mineurs'];
1544
				$mots = explode(' ', $epithete);
1545
				foreach ($mots as $position => $mot) {
1546
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1547
						$ok = false;// Mot rejeté
1548
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1549
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1550
					} else {
1551
						$mots_tiret = explode('-', $mot);
1552
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1553
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1554
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
1555
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1556
								continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
1557
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1558
								continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1559
							} else {
1560
								$ok = false;
1561
							}
1562
						}
1563
					}
1564
				}
1565
			}
1566
		}
1567
		return $ok;
1568
	}
1569
 
64 jpm 1570
	private function verifierEpitheteGroupeCultivar(&$epithete) {
20 jpm 1571
		$ok = true;
1572
		$acceptes = $this->manuel['cultivar_gp_acceptes'];
1573
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1574
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1575
				$ok = false;// Contient des espaces en trop
1576
			} else {
1577
				$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
1578
				$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
1579
				$mots_mineurs = $this->manuel['mots_mineurs'];
1580
				$mots = explode(' ', $epithete);
1581
				foreach ($mots as $position => $mot) {
1582
					if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
1583
						continue;// Mot accepté
1584
					} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1585
						$ok = false;// Mot rejeté
1586
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1587
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1588
					} else {
1589
						$mots_tiret = explode('-', $mot);
1590
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1591
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1592
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
1593
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1594
								continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
1595
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1596
								continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1597
							} else {
1598
								$ok = false;
1599
							}
1600
						}
1601
					}
1602
				}
1603
			}
1604
		}
1605
		return $ok;
1606
	}
1607
 
64 jpm 1608
	private function verifierEpitheteSp(&$epithete) {
20 jpm 1609
		$ok = false;
183 jpm 1610
		if (preg_match('/^[a-zäëḧïöẗüẅẍÿ][-a-zäëḧïöẗüẅẍÿ]+$/', $epithete)) {
20 jpm 1611
			$ok = true;
1612
		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
1613
			$ok = true;
1614
		}
1615
		return $ok;
1616
	}
1617
 
64 jpm 1618
	private function verifierEpitheteGenre(&$epithete) {
20 jpm 1619
		$ok = false;
183 jpm 1620
		if (preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ](?:[-a-zäëḧïöẗüẅẍÿ]+|[a-zäëḧïöẗüẅẍÿ]+-[A-ZÄËḦÏÖÜẄẌŸ][a-zäëḧïöẗüẅẍÿ]+)$/', $epithete)) {
20 jpm 1621
			$ok = true;
1622
		}
1623
		return $ok;
1624
	}
1625
 
64 jpm 1626
	private function formaterStyleNomGenre(&$genre) {
20 jpm 1627
		$genre_fmt = '';
1628
		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
192 delphine 1629
			$genre_fmt = utf8_encode(strtolower(utf8_decode($match[1]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[2]))));
194 delphine 1630
		} elseif (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $genre, $match)) {
1631
			$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.
1632
				utf8_encode(strtolower(utf8_decode($match[2]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[3]))));
20 jpm 1633
		} else {
192 delphine 1634
			$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($genre))));
20 jpm 1635
		}
1636
		return $genre_fmt;
1637
	}
1638
 
149 jpm 1639
	private function repererEspace($nom_sci) {
1640
		$nom_sci = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_sci);
1641
		return $nom_sci;
20 jpm 1642
	}
1643
 
64 jpm 1644
	private function construireSuffixeNomPltCultivee(&$nom) {
20 jpm 1645
		$suffixe = array();
1646
		$suffixe[] = $this->construireNomCultivarGroupe($nom);
1647
		$suffixe[] = $this->construireNomCommercial($nom);
1648
		$suffixe[] = $this->construireNomCultivar($nom);
1649
		$suffixe = array_filter($suffixe);
1650
		return implode(' ', $suffixe);
1651
	}
1652
 
64 jpm 1653
	private function construireNomCultivarGroupe(&$nom) {
20 jpm 1654
		$nom_groupe_cultivar = '';
1655
		if ($nom['cultivar_groupe'] != '') {
1656
			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
1657
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
1658
			} else {
1659
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
1660
			}
1661
		}
1662
		return $nom_groupe_cultivar;
1663
	}
1664
 
64 jpm 1665
	private function construireNomCommercial(&$nom) {
20 jpm 1666
		$nom_commercial = '';
1667
		if ($nom['nom_commercial'] != '') {
1668
			$nom_commercial =  strtoupper($nom['nom_commercial']);
1669
		}
1670
		return $nom_commercial;
1671
	}
1672
 
64 jpm 1673
	private function construireNomCultivar(&$nom) {
20 jpm 1674
		$nom_cultivar = '';
1675
		if ($nom['cultivar'] != '') {
1676
			$nom_cultivar =  "'".$nom['cultivar']."'";
1677
		}
1678
		return $nom_cultivar;
1679
	}
1680
 
64 jpm 1681
	private function classerNomsParNomComplet() {
20 jpm 1682
		$noms_classes = array();
64 jpm 1683
		foreach ($this->noms as &$nom) {
149 jpm 1684
			if (!isset($noms_classes[$nom['nom_sci']])) {
1685
				$noms_classes[$nom['nom_sci']] = 1;
20 jpm 1686
			} else {
149 jpm 1687
				$noms_classes[$nom['nom_sci']]++;
20 jpm 1688
			}
1689
		}
1690
		return $noms_classes;
1691
	}
1692
}
1693
?>