Subversion Repositories Applications.referentiel

Rev

Rev 262 | Rev 264 | 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';
225 jpm 22
	const MANUEL_VERSION = '4.3';
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.') {
250 delphine 601
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '.
602
						$this->formaterStyleNomGenre($nom['epithete_infra_generique']).' '.
603
						$nom['type_epithete'];
171 jpm 604
				} else {
250 delphine 605
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '.
606
						$nom['type_epithete'].' '.
607
						$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();
250 delphine 624
		$erreur = '';
64 jpm 625
		foreach ($this->noms as &$nom) {
171 jpm 626
			if ($nom['rang'] == $this->manuel['rang_sp']) {
627
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
250 delphine 628
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' ';
629
				if (strstr($nom['nom_sci'] , ' x ') != false) {
630
					list($nom_sci_ideal, $erreur) = $this->formaterStyleEpitheteSpHybride($nom_sci_ideal, $nom['epithete_sp']);
631
				} else {
632
					$nom_sci_ideal .= utf8_encode(strtolower(utf8_decode($nom['epithete_sp'])));
633
				}
171 jpm 634
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
194 delphine 635
				$nom_sci_ideal = trim($nom_sci_ideal);
171 jpm 636
				if ($nom['nom_sci'] != $nom_sci_ideal) {
637
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
250 delphine 638
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $erreur, $nom['exclure_taxref']);
20 jpm 639
				}
640
			}
641
		}
176 jpm 642
		return $noms_erreur;
20 jpm 643
	}
644
 
171 jpm 645
	/**
199 delphine 646
	 * Test #22
171 jpm 647
	 */
648
	private function testerNomCompletInfraSpecifique() {
158 delphine 649
		$noms_erreur = array();
254 aurelien 650
		$erreur = null;
158 delphine 651
		foreach ($this->noms as &$nom) {
171 jpm 652
			if ($nom['rang'] > $this->manuel['rang_sp']) {
250 delphine 653
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '.
654
					utf8_encode(strtolower(utf8_decode($nom['epithete_sp']))).' '.
655
					utf8_encode(strtolower(utf8_decode($nom['type_epithete']))).' ';
171 jpm 656
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
250 delphine 657
				if (strstr($nom['nom_sci'] , ' x ') != false) {
658
					list($nom_sci_ideal, $erreur) = $this->formaterStyleEpitheteInfraSpHybride($nom_sci_ideal, $nom['epithete_infra_sp'], $nom['genre']);
659
				} else {
660
					$nom_sci_ideal .= utf8_encode(strtolower(utf8_decode($nom['epithete_infra_sp'])));
661
				}
662
				$nom_sci_ideal = trim($nom_sci_ideal);
171 jpm 663
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
664
				if ($nom['nom_sci'] != $nom_sci_ideal) {
665
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
250 delphine 666
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $erreur, $nom['exclure_taxref']);
171 jpm 667
				}
158 delphine 668
			}
669
		}
176 jpm 670
		return $noms_erreur;
158 delphine 671
	}
672
 
171 jpm 673
	/**
199 delphine 674
	 * Test #23
171 jpm 675
	 */
676
	private function testerNomSupraGeneriqueEspaces() {
20 jpm 677
		$noms_erreur = array();
64 jpm 678
		foreach ($this->noms as &$nom) {
171 jpm 679
			if ($nom['nom_supra_generique'] != '') {
680
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
681
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
183 jpm 682
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']);
20 jpm 683
				}
684
			}
685
		}
176 jpm 686
		return $noms_erreur;
20 jpm 687
	}
688
 
171 jpm 689
	/**
199 delphine 690
	 * Test #24
171 jpm 691
	 */
692
	private function testerNomSupraGeneriqueSyntaxe() {
20 jpm 693
		$noms_erreur = array();
64 jpm 694
		foreach ($this->noms as &$nom) {
171 jpm 695
			if ($nom['nom_supra_generique'] != '') {
696
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) {
697
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
183 jpm 698
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']);
20 jpm 699
				}
700
			}
701
		}
177 jpm 702
		return $noms_erreur;
20 jpm 703
	}
704
 
171 jpm 705
	/**
199 delphine 706
	 * Test #25
171 jpm 707
	 */
708
	private function testerNomSupraGeneriqueRang() {
20 jpm 709
		$noms_erreur = array();
64 jpm 710
		foreach ($this->noms as &$nom) {
171 jpm 711
			if ($nom['nom_supra_generique'] != '') {
712
				if ($nom['rang'] >= $this->manuel['rang_genre']) {
183 jpm 713
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 714
				}
715
			}
716
		}
177 jpm 717
		return $noms_erreur;
20 jpm 718
	}
719
 
171 jpm 720
	/**
199 delphine 721
	 * Test #26
171 jpm 722
	 */
723
	private function testerGenreEspaces() {
20 jpm 724
		$noms_erreur = array();
64 jpm 725
		foreach ($this->noms as &$nom) {
171 jpm 726
			if ($nom['genre'] != '') {
727
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) {
728
					$nom_traite = $this->repererEspace($nom['genre']);
183 jpm 729
					$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
20 jpm 730
				}
731
			}
732
		}
177 jpm 733
		return $noms_erreur;
20 jpm 734
	}
735
 
171 jpm 736
	/**
199 delphine 737
	 * Test #27
171 jpm 738
	 */
739
	private function testerGenreSyntaxe() {
20 jpm 740
		$noms_erreur = array();
64 jpm 741
		foreach ($this->noms as &$nom) {
171 jpm 742
			if ($nom['genre'] != '') {
743
				$mots = explode(' ', $nom['genre']);
744
				foreach ($mots as $mot) {
745
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) {
746
						$nom_traite = $this->repererEspace($nom['genre']);
183 jpm 747
						$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
194 delphine 748
						break;
171 jpm 749
					}
20 jpm 750
				}
751
			}
752
		}
177 jpm 753
		return $noms_erreur;
20 jpm 754
	}
755
 
171 jpm 756
	/**
199 delphine 757
	 * Test #28
171 jpm 758
	 */
759
	private function testerGenreRang() {
20 jpm 760
		$noms_erreur = array();
64 jpm 761
		foreach ($this->noms as &$nom) {
171 jpm 762
			if ($nom['genre'] != '') {
763
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 764
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 765
				}
766
			}
767
		}
177 jpm 768
		return $noms_erreur;
20 jpm 769
	}
770
 
171 jpm 771
	/**
199 delphine 772
	 * Test #29
171 jpm 773
	 */
774
	private function testerEpitheteInfraGeneriqueSyntaxe() {
20 jpm 775
		$noms_erreur = array();
64 jpm 776
		foreach ($this->noms as &$nom) {
171 jpm 777
			if ($nom['epithete_infra_generique'] != '') {
778
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) {
779
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
183 jpm 780
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 781
				}
782
			}
783
		}
177 jpm 784
		return $noms_erreur;
20 jpm 785
	}
786
 
171 jpm 787
	/**
199 delphine 788
	 * Test #30
171 jpm 789
	 */
790
	private function testerEpitheteInfraGeneriqueRang() {
20 jpm 791
		$noms_erreur = array();
64 jpm 792
		foreach ($this->noms as &$nom) {
171 jpm 793
			if ($nom['epithete_infra_generique'] != '') {
794
				if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) {
183 jpm 795
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 796
				}
797
			}
798
		}
177 jpm 799
		return $noms_erreur;
20 jpm 800
	}
801
 
171 jpm 802
	/**
199 delphine 803
	 * Test #31
171 jpm 804
	 */
805
	private function testerEpitheteInfraGeneriqueEspaces() {
20 jpm 806
		$noms_erreur = array();
64 jpm 807
		foreach ($this->noms as &$nom) {
171 jpm 808
			if ($nom['epithete_infra_generique'] != '') {
809
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) {
810
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
183 jpm 811
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 812
				}
813
			}
814
		}
177 jpm 815
		return $noms_erreur;
20 jpm 816
	}
817
 
171 jpm 818
	/**
199 delphine 819
	 * Test #32
171 jpm 820
	 */
821
	private function testerEpitheteSpEspaces() {
20 jpm 822
		$noms_erreur = array();
64 jpm 823
		foreach ($this->noms as &$nom) {
171 jpm 824
			if ($nom['epithete_sp'] != '') {
825
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) {
826
					$epithete_traite = $this->repererEspace($nom['epithete_sp']);
183 jpm 827
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 828
				}
829
			}
830
		}
177 jpm 831
		return $noms_erreur;
20 jpm 832
	}
833
 
171 jpm 834
	/**
199 delphine 835
	 * Test #33
171 jpm 836
	 */
837
	private function testerEpitheteSpSyntaxe() {
20 jpm 838
		$noms_erreur = array();
64 jpm 839
		foreach ($this->noms as &$nom) {
171 jpm 840
			if ($nom['epithete_sp'] != '') {
254 aurelien 841
				$formule_hybridite = (strpos($nom['epithete_sp'], ' x ') !== false);
171 jpm 842
				$mots = explode(' ', $nom['epithete_sp']);
843
				foreach ($mots as $mot) {
252 aurelien 844
					// TODO: créer un test qui vérifie la formule d'hybridité en la reconstruisant à partir des parents
845
					// afin que seuls des formules valides parviennent à la fonction
254 aurelien 846
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot) ||
847
						($formule_hybridite && $this->verifierEpitheteGenre($mot) && !$this->verifierEstAbbreviationInfraSp($mot)))) {
171 jpm 848
						$epithete_traite = $this->repererEspace($nom['epithete_sp']);
183 jpm 849
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
194 delphine 850
						break;
171 jpm 851
					}
852
				}
20 jpm 853
			}
854
		}
177 jpm 855
		return $noms_erreur;
20 jpm 856
	}
857
 
171 jpm 858
	/**
199 delphine 859
	 * Test #34
171 jpm 860
	 */
861
	private function testerEpitheteSpRang() {
20 jpm 862
		$noms_erreur = array();
64 jpm 863
		foreach ($this->noms as &$nom) {
171 jpm 864
			if ($nom['epithete_sp'] != '') {
865
				if ($nom['rang'] < $this->manuel['rang_sp']) {
183 jpm 866
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 867
				}
868
			}
869
		}
177 jpm 870
		return $noms_erreur;
20 jpm 871
	}
872
 
171 jpm 873
	/**
199 delphine 874
	 * Test #35
171 jpm 875
	 */
876
	private function testerTypeEpitheteEspaces() {
20 jpm 877
		$noms_erreur = array();
64 jpm 878
		foreach ($this->noms as &$nom) {
171 jpm 879
			if ($nom['type_epithete'] != '') {
880
				if (preg_match('/\s+/', $nom['type_epithete'])) {
881
					$valeur_traitee = $this->repererEspace($nom['epithete_sp']);
183 jpm 882
					$noms_erreur[] = array($nom['num_nom'], $valeur_traitee, $nom['exclure_taxref']);
20 jpm 883
				}
884
			}
885
		}
177 jpm 886
		return $noms_erreur;
20 jpm 887
	}
888
 
171 jpm 889
	/**
199 delphine 890
	 * Test #36
171 jpm 891
	 */
892
	private function testerTypeEpitheteSyntaxe() {
20 jpm 893
		$noms_erreur = array();
64 jpm 894
		foreach ($this->noms as &$nom) {
171 jpm 895
			if ($nom['type_epithete'] != '') {
896
				if (!$this->verifierTypeEpithete($nom['type_epithete'])) {
183 jpm 897
					$noms_erreur[] = array($nom['num_nom'],  $nom['type_epithete'], $nom['exclure_taxref']);
20 jpm 898
				}
899
			}
900
		}
177 jpm 901
		return $noms_erreur;
20 jpm 902
	}
903
 
171 jpm 904
	/**
199 delphine 905
	 * Test #37
171 jpm 906
	 */
907
	private function testerTypeEpitheteHybridite() {
20 jpm 908
		$noms_erreur = array();
64 jpm 909
		foreach ($this->noms as &$nom) {
171 jpm 910
			if ($nom['type_epithete'] != '') {
911
				if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) {
183 jpm 912
					$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete'], $nom['exclure_taxref']);
20 jpm 913
				}
914
			}
915
		}
177 jpm 916
		return $noms_erreur;
20 jpm 917
	}
918
 
171 jpm 919
	/**
199 delphine 920
	 * Test #38
171 jpm 921
	 */
64 jpm 922
	private function testerEpitheteInfraSpEspaces() {
20 jpm 923
		$noms_erreur = array();
64 jpm 924
		foreach ($this->noms as &$nom) {
20 jpm 925
			if ($nom['epithete_infra_sp'] != '') {
926
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) {
927
					$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
183 jpm 928
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 929
				}
930
			}
931
		}
177 jpm 932
		return $noms_erreur;
20 jpm 933
	}
934
 
171 jpm 935
	/**
199 delphine 936
	 * Test #39
171 jpm 937
	 */
64 jpm 938
	private function testerEpitheteInfraSpSyntaxe() {
20 jpm 939
		$noms_erreur = array();
64 jpm 940
		foreach ($this->noms as &$nom) {
20 jpm 941
			if ($nom['epithete_infra_sp'] != '') {
942
				$mots = explode(' ', $nom['epithete_infra_sp']);
255 aurelien 943
				$hybride_contient_abbreviation_infra_sp = false;
944
				$formule_hybridite = (strpos($nom['epithete_infra_sp'], ' x ') !== false);
20 jpm 945
				foreach ($mots as $mot) {
255 aurelien 946
					if($formule_hybridite && $this->verifierEstAbbreviationInfraSp($mot)) {
947
						$hybride_contient_abbreviation_infra_sp = true;
948
					}
949
					$formule_hybridite_valide = $this->verifierEpitheteGenre($mot) || $this->verifierEpitheteSp($mot) || $hybride_contient_abbreviation_infra_sp;
950
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot) || $this->verifierEpitheteSp($mot) ||
951
						$formule_hybridite_valide)) {
194 delphine 952
						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
953
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
954
						break;
20 jpm 955
					}
956
				}
255 aurelien 957
 
958
				if($formule_hybridite && !$hybride_contient_abbreviation_infra_sp) {
959
					$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
960
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
961
				}
20 jpm 962
			}
963
		}
177 jpm 964
		return $noms_erreur;
20 jpm 965
	}
966
 
171 jpm 967
	/**
199 delphine 968
	 * Test #40
171 jpm 969
	 */
64 jpm 970
	private function testerEpitheteInfraSpRang() {
20 jpm 971
		$noms_erreur = array();
64 jpm 972
		foreach ($this->noms as &$nom) {
20 jpm 973
			if ($nom['epithete_infra_sp'] != '') {
974
				if ($nom['rang'] < $this->manuel['rang_sp']) {
183 jpm 975
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 976
				}
977
			}
978
		}
177 jpm 979
		return $noms_erreur;
20 jpm 980
	}
981
 
173 jpm 982
	/**
199 delphine 983
	 * Test #41
173 jpm 984
	 */
985
	private function testerGroupeCultivarSyntaxe() {
20 jpm 986
		$noms_erreur = array();
64 jpm 987
		foreach ($this->noms as &$nom) {
173 jpm 988
			if ($nom['cultivar_groupe'] != '') {
989
				if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
990
					$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
183 jpm 991
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 992
				}
993
			}
994
		}
177 jpm 995
		return $noms_erreur;
20 jpm 996
	}
997
 
173 jpm 998
	/**
199 delphine 999
	 * Test #42
173 jpm 1000
	 */
1001
	private function testerGroupeCultivarRang() {
20 jpm 1002
		$noms_erreur = array();
64 jpm 1003
		foreach ($this->noms as &$nom) {
173 jpm 1004
			if ($nom['cultivar_groupe'] != '') {
1005
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 1006
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 1007
				}
1008
			}
1009
		}
177 jpm 1010
		return $noms_erreur;
20 jpm 1011
	}
1012
 
173 jpm 1013
	/**
199 delphine 1014
	 * Test #43
173 jpm 1015
	 */
1016
	private function testerCultivarSyntaxe() {
20 jpm 1017
		$noms_erreur = array();
64 jpm 1018
		foreach ($this->noms as &$nom) {
173 jpm 1019
			if ($nom['cultivar'] != '') {
1020
				if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
1021
					$epithete_traite = $this->repererEspace($nom['cultivar']);
183 jpm 1022
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 1023
				}
1024
			}
1025
		}
177 jpm 1026
		return $noms_erreur;
20 jpm 1027
	}
1028
 
173 jpm 1029
	/**
199 delphine 1030
	 * Test #44
173 jpm 1031
	 */
1032
	private function testerCultivarRang() {
20 jpm 1033
		$noms_erreur = array();
64 jpm 1034
		foreach ($this->noms as &$nom) {
173 jpm 1035
			if ($nom['cultivar'] != '') {
1036
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 1037
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
171 jpm 1038
				}
20 jpm 1039
			}
1040
		}
177 jpm 1041
		return $noms_erreur;
20 jpm 1042
	}
1043
 
173 jpm 1044
	/**
199 delphine 1045
	 * Test #45
173 jpm 1046
	 */
1047
	private function testerNomCommercialSyntaxe() {
20 jpm 1048
		$noms_erreur = array();
64 jpm 1049
		foreach ($this->noms as &$nom) {
173 jpm 1050
			if ($nom['nom_commercial'] != '') {
1051
				if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
1052
					$epithete_traite = $this->repererEspace($nom['nom_commercial']);
183 jpm 1053
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
171 jpm 1054
				}
20 jpm 1055
			}
1056
		}
177 jpm 1057
		return $noms_erreur;
20 jpm 1058
	}
1059
 
173 jpm 1060
	/**
199 delphine 1061
	 * Test #46
173 jpm 1062
	 */
1063
	private function testerNomCommercialPresenceCultivar() {
20 jpm 1064
		$noms_erreur = array();
64 jpm 1065
		foreach ($this->noms as &$nom) {
173 jpm 1066
			if ((isset($nom['nom_commercial']) && $nom['nom_commercial'] != '') && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
183 jpm 1067
				$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
20 jpm 1068
			}
1069
		}
177 jpm 1070
		return $noms_erreur;
20 jpm 1071
	}
1072
 
173 jpm 1073
	/**
199 delphine 1074
	 * Test #47
173 jpm 1075
	 */
1076
	private function testerAuteurSyntaxe() {
20 jpm 1077
		$noms_erreur = array();
64 jpm 1078
		foreach ($this->noms as &$nom) {
173 jpm 1079
			if ($nom['auteur'] != '') {
1080
				if (!$this->verifierAuteur($nom['auteur'])) {
1081
					$intitule_traite = $this->repererEspace($nom['auteur']);
183 jpm 1082
					$noms_erreur[] = array($nom['num_nom'], $intitule_traite, $nom['exclure_taxref']);
171 jpm 1083
				}
20 jpm 1084
			}
1085
		}
177 jpm 1086
		return $noms_erreur;
20 jpm 1087
	}
1088
 
173 jpm 1089
	/**
199 delphine 1090
	 * Test #48
173 jpm 1091
	 */
1092
	private function testerAnneeSyntaxe() {
20 jpm 1093
		$noms_erreur = array();
64 jpm 1094
		foreach ($this->noms as &$nom) {
173 jpm 1095
			if ($nom['annee'] != '') {
1096
				if (!$this->verifierAnnee($nom['annee'])) {
183 jpm 1097
					$noms_erreur[] = array($nom['num_nom'], $nom['annee'], $nom['exclure_taxref']);
171 jpm 1098
				}
20 jpm 1099
			}
1100
		}
177 jpm 1101
		return $noms_erreur;
20 jpm 1102
	}
1103
 
173 jpm 1104
	/**
199 delphine 1105
	 * Test #49
173 jpm 1106
	 */
1107
	private function testerBiblioOrigineSyntaxe() {
20 jpm 1108
		$noms_erreur = array();
64 jpm 1109
		foreach ($this->noms as &$nom) {
173 jpm 1110
			if ($nom['biblio_origine'] != '') {
1111
				if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
1112
					$biblio_traite = $this->repererEspace($nom['biblio_origine']);
183 jpm 1113
					$noms_erreur[] = array($nom['num_nom'], $biblio_traite, $nom['exclure_taxref']);
20 jpm 1114
				}
1115
			}
1116
		}
177 jpm 1117
		return $noms_erreur;
20 jpm 1118
	}
1119
 
173 jpm 1120
	/**
199 delphine 1121
	 * Test #50
173 jpm 1122
	 */
1123
	private function testerHomonymieSyntaxe() {
20 jpm 1124
		$noms_erreur = array();
173 jpm 1125
		foreach ($this->noms as &$nom) {
1126
			if ($nom['homonyme'] != '') {
1127
				if (!$this->verifierBooleen($nom['homonyme'])) {
183 jpm 1128
					$noms_erreur[] = array($nom['num_nom'], $nom['homonyme'], $nom['exclure_taxref']);
161 jpm 1129
				}
20 jpm 1130
			}
1131
		}
177 jpm 1132
		return $noms_erreur;
20 jpm 1133
	}
1134
 
173 jpm 1135
	/**
199 delphine 1136
	 * Test #51
173 jpm 1137
	 */
1138
	private function testerHomonymieExistence() {
1139
		$noms_homonymie = $this->classerNomsParNomComplet();
1140
 
20 jpm 1141
		$noms_erreur = array();
64 jpm 1142
		foreach ($this->noms as &$nom) {
173 jpm 1143
			if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
1144
				if ($noms_homonymie[$nom['nom_sci']] <= 1) {
183 jpm 1145
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
171 jpm 1146
				}
20 jpm 1147
			}
1148
		}
173 jpm 1149
		$noms_homonymie = null;
177 jpm 1150
		return $noms_erreur;
20 jpm 1151
	}
1152
 
173 jpm 1153
	/**
199 delphine 1154
	 * Test #52
173 jpm 1155
	 */
1156
	private function testerBasionymeSyntaxe() {
20 jpm 1157
		$noms_erreur = array();
64 jpm 1158
		foreach ($this->noms as &$nom) {
173 jpm 1159
			if ($nom['basionyme'] != '') {
1160
				if (!$this->verifierNombre($nom['basionyme'])) {
183 jpm 1161
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme'], $nom['exclure_taxref']);
20 jpm 1162
				}
1163
			}
1164
		}
177 jpm 1165
		return $noms_erreur;
20 jpm 1166
	}
173 jpm 1167
 
1168
	/**
199 delphine 1169
	 * Test #53
173 jpm 1170
	 */
1171
	private function testerBasionymeExistence() {
20 jpm 1172
		$noms_erreur = array();
64 jpm 1173
		foreach ($this->noms as &$nom) {
173 jpm 1174
			if ($nom['basionyme'] != '') {
1175
				if (!isset($this->noms[$nom['basionyme']])) {
183 jpm 1176
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme'], $nom['exclure_taxref']);
173 jpm 1177
				}
20 jpm 1178
			}
1179
		}
177 jpm 1180
		return $noms_erreur;
20 jpm 1181
	}
1182
 
173 jpm 1183
	/**
199 delphine 1184
	 * Test #54
173 jpm 1185
	 */
1186
	private function testerSynonymeProparteSyntaxe() {
20 jpm 1187
		$noms_erreur = array();
64 jpm 1188
		foreach ($this->noms as &$nom) {
171 jpm 1189
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1190
				if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
183 jpm 1191
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte'], $nom['exclure_taxref']);
20 jpm 1192
				}
1193
			}
1194
		}
177 jpm 1195
		return $noms_erreur;
20 jpm 1196
	}
1197
 
173 jpm 1198
	/**
199 delphine 1199
	 * Test #55
173 jpm 1200
	 */
1201
	private function testerSynonymeProparteExistence() {
20 jpm 1202
		$noms_erreur = array();
64 jpm 1203
		foreach ($this->noms as &$nom) {
171 jpm 1204
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1205
				$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
1206
				$num_nom_en_erreur = array();
1207
				foreach ($num_nom_a_verifier as $num_nom) {
1208
					if (!isset($this->noms[$num_nom])) {
1209
						$num_nom_en_erreur[] = $num_nom;
1210
					}
20 jpm 1211
				}
173 jpm 1212
				if (count($nbre_en_erreur) > 0) {
183 jpm 1213
					$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur), $nom['exclure_taxref']);
173 jpm 1214
				}
20 jpm 1215
			}
1216
		}
177 jpm 1217
		return $noms_erreur;
20 jpm 1218
	}
1219
 
173 jpm 1220
	/**
199 delphine 1221
	 * Test #56
173 jpm 1222
	 */
1223
	private function testerSynonymeDouteuxSyntaxe() {
20 jpm 1224
		$noms_erreur = array();
64 jpm 1225
		foreach ($this->noms as &$nom) {
173 jpm 1226
			if ($nom['synonyme_douteux'] != '') {
1227
				if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
183 jpm 1228
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
20 jpm 1229
				}
1230
			}
1231
		}
177 jpm 1232
		return $noms_erreur;
20 jpm 1233
	}
1234
 
173 jpm 1235
	/**
199 delphine 1236
	 * Test #57
173 jpm 1237
	 */
1238
	private function testerSynonymeDouteuxNumNomRetenu() {
20 jpm 1239
		$noms_erreur = array();
64 jpm 1240
		foreach ($this->noms as &$nom) {
186 delphine 1241
			if ($nom['synonyme_douteux'] == 1 && !$this->verifierNombre($nom['num_nom_retenu'])) {
1242
				$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
20 jpm 1243
			}
1244
		}
177 jpm 1245
		return $noms_erreur;
20 jpm 1246
	}
1247
 
171 jpm 1248
	/**
199 delphine 1249
	 * Test #58
171 jpm 1250
	 */
173 jpm 1251
	private function testerSynonymeMalAppliqueSyntaxe() {
20 jpm 1252
		$noms_erreur = array();
64 jpm 1253
		foreach ($this->noms as &$nom) {
173 jpm 1254
			if ($nom['synonyme_mal_applique'] != '') {
1255
				if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
183 jpm 1256
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']);
20 jpm 1257
				}
1258
			}
1259
		}
177 jpm 1260
		return $noms_erreur;
20 jpm 1261
	}
1262
 
171 jpm 1263
	/**
199 delphine 1264
	 * Test #59
171 jpm 1265
	 */
173 jpm 1266
	private function testerSynonymeOrthographiqueSyntaxe() {
20 jpm 1267
		$noms_erreur = array();
173 jpm 1268
		foreach ($this->noms as $nom) {
1269
			if ($nom['synonyme_orthographique'] != '') {
1270
				if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
183 jpm 1271
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
20 jpm 1272
				}
1273
			}
1274
		}
177 jpm 1275
		return $noms_erreur;
20 jpm 1276
	}
1277
 
171 jpm 1278
	/**
199 delphine 1279
	 * Test #60
171 jpm 1280
	 */
173 jpm 1281
	private function testerSynonymeOrthographiqueExistence() {
20 jpm 1282
		$noms_erreur = array();
64 jpm 1283
		foreach ($this->noms as &$nom) {
173 jpm 1284
			if ($nom['synonyme_orthographique'] != '') {
1285
				if (!isset($this->noms[$nom['synonyme_orthographique']])) {
183 jpm 1286
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
20 jpm 1287
				}
1288
			}
1289
		}
177 jpm 1290
		return $noms_erreur;
20 jpm 1291
	}
1292
 
171 jpm 1293
	/**
199 delphine 1294
	 * Test #61
171 jpm 1295
	 */
173 jpm 1296
	private function testerHybrideParent01Syntaxe() {
20 jpm 1297
		$noms_erreur = array();
64 jpm 1298
		foreach ($this->noms as &$nom) {
173 jpm 1299
			if ($nom['hybride_parent_01'] != '') {
1300
				if (!$this->verifierNombre($nom['hybride_parent_01'])) {
183 jpm 1301
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
20 jpm 1302
				}
1303
			}
1304
		}
177 jpm 1305
		return $noms_erreur;
20 jpm 1306
	}
1307
 
171 jpm 1308
	/**
199 delphine 1309
	 * Test #62
171 jpm 1310
	 */
173 jpm 1311
	private function testerHybrideParent01Existence() {
20 jpm 1312
		$noms_erreur = array();
64 jpm 1313
		foreach ($this->noms as &$nom) {
173 jpm 1314
			if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
1315
				if (!isset($this->noms[$nom['hybride_parent_01']])) {
183 jpm 1316
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
20 jpm 1317
				}
1318
			}
1319
		}
177 jpm 1320
		return $noms_erreur;
20 jpm 1321
	}
171 jpm 1322
 
1323
	/**
199 delphine 1324
	 * Test #63
171 jpm 1325
	 */
173 jpm 1326
	private function testerHybrideParent02Syntaxe() {
20 jpm 1327
		$noms_erreur = array();
64 jpm 1328
		foreach ($this->noms as &$nom) {
173 jpm 1329
			if ($nom['hybride_parent_02'] != '') {
1330
				if (!$this->verifierNombre($nom['hybride_parent_02'])) {
183 jpm 1331
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
173 jpm 1332
				}
20 jpm 1333
			}
1334
		}
177 jpm 1335
		return $noms_erreur;
20 jpm 1336
	}
1337
 
171 jpm 1338
	/**
199 delphine 1339
	 * Test #64
171 jpm 1340
	 */
173 jpm 1341
	private function testerHybrideParent02Existence() {
20 jpm 1342
		$noms_erreur = array();
64 jpm 1343
		foreach ($this->noms as &$nom) {
173 jpm 1344
			if ($nom['hybride_parent_02'] != '') {
1345
				if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
183 jpm 1346
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
20 jpm 1347
				}
1348
			}
1349
		}
177 jpm 1350
		return $noms_erreur;
20 jpm 1351
	}
1352
 
171 jpm 1353
	/**
199 delphine 1354
	 * Test #65
171 jpm 1355
	 */
173 jpm 1356
	private function testerPresenceSyntaxe() {
20 jpm 1357
		$noms_erreur = array();
64 jpm 1358
		foreach ($this->noms as &$nom) {
173 jpm 1359
			if ($nom['presence'] != '') {
1360
				if (!$this->verifierPresence($nom['presence'])) {
183 jpm 1361
					$noms_erreur[] = array($nom['num_nom'], $nom['presence'], $nom['exclure_taxref']);
20 jpm 1362
				}
1363
			}
1364
		}
177 jpm 1365
		return $noms_erreur;
20 jpm 1366
	}
1367
 
171 jpm 1368
	/**
199 delphine 1369
	 * Test #66
171 jpm 1370
	 */
173 jpm 1371
	private function testerStatutOrigineSyntaxe() {
20 jpm 1372
		$noms_erreur = array();
64 jpm 1373
		foreach ($this->noms as &$nom) {
173 jpm 1374
			if ($nom['statut_origine'] != '') {
1375
				if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
183 jpm 1376
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine'], $nom['exclure_taxref']);
20 jpm 1377
				}
1378
			}
1379
		}
177 jpm 1380
		return $noms_erreur;
20 jpm 1381
	}
1382
 
171 jpm 1383
	/**
199 delphine 1384
	 * Test #67
171 jpm 1385
	 */
173 jpm 1386
	private function testerStatutIntroductionSyntaxe() {
20 jpm 1387
		$noms_erreur = array();
64 jpm 1388
		foreach ($this->noms as &$nom) {
173 jpm 1389
			if ($nom['statut_introduction'] != '') {
1390
				if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
183 jpm 1391
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction'], $nom['exclure_taxref']);
20 jpm 1392
				}
1393
			}
1394
		}
177 jpm 1395
		return $noms_erreur;
20 jpm 1396
	}
1397
 
171 jpm 1398
	/**
199 delphine 1399
	 * Test #68
171 jpm 1400
	 */
173 jpm 1401
	private function testerStatutCultureSyntaxe() {
20 jpm 1402
		$noms_erreur = array();
64 jpm 1403
		foreach ($this->noms as &$nom) {
173 jpm 1404
			if ($nom['statut_culture'] != '') {
1405
				if (!$this->verifierStatutCulture($nom['statut_culture'])) {
183 jpm 1406
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture'], $nom['exclure_taxref']);
20 jpm 1407
				}
1408
			}
1409
		}
177 jpm 1410
		return $noms_erreur;
20 jpm 1411
	}
1412
 
171 jpm 1413
	/**
199 delphine 1414
	 * Test #69
171 jpm 1415
	 */
146 delphine 1416
	private function testerExclureTaxRefSyntaxe() {
1417
		$noms_erreur = array();
1418
		foreach ($this->noms as &$nom) {
1419
			if ($nom['exclure_taxref'] != '' && $nom['exclure_taxref'] != null) {
183 jpm 1420
				if (!preg_match('/^(?:0|1|9)$/', $nom['exclure_taxref'])) {
146 delphine 1421
					$noms_erreur[] = array($nom['num_nom'], $nom['exclure_taxref']);
1422
				}
1423
			}
1424
		}
177 jpm 1425
		return $noms_erreur;
146 delphine 1426
	}
171 jpm 1427
 
262 aurelien 1428
	/**
1429
	* Test #70
1430
	*/
263 aurelien 1431
	private function testerNomFrancaisUnique() {
262 aurelien 1432
		$noms_erreur = array();
1433
		foreach ($this->noms as &$nom) {
1434
			if ($nom['nom_francais'] != '' && $nom['nom_francais'] != null) {
1435
				if (strpbrk($nom['nom_francais'],',;')) {
263 aurelien 1436
					$noms_erreur[] = array($nom['num_nom'], $this->repererCaracteresInvalidesNomFrancais($nom['nom_francais']));
262 aurelien 1437
				}
1438
			}
1439
		}
1440
		return $noms_erreur;
1441
	}
171 jpm 1442
 
20 jpm 1443
	//+--------------------------------------------------------------------------------------------------------------+//
1444
	// MÉTHODES COMMUNES aux TESTS
1445
 
64 jpm 1446
	private function verifierPresence(&$valeur) {
20 jpm 1447
		$codes = $this->manuel['codes_presence'];
1448
		$ok = $this->verifierStatuts($valeur, $codes);
1449
		return $ok;
1450
	}
1451
 
64 jpm 1452
	private function verifierStatutOrigine(&$valeur) {
20 jpm 1453
		$codes = $this->manuel['codes_statuts_origine'];
1454
		$ok = $this->verifierStatuts($valeur, $codes);
1455
		return $ok;
1456
	}
1457
 
64 jpm 1458
	private function verifierStatutIntroduction(&$valeur) {
20 jpm 1459
		$codes = $this->manuel['codes_statuts_introduction'];
1460
		$ok = $this->verifierStatuts($valeur, $codes);
1461
		return $ok;
1462
	}
1463
 
64 jpm 1464
	private function verifierStatutCulture(&$valeur) {
20 jpm 1465
		$codes = $this->manuel['codes_statuts_culture'];
1466
		$ok = $this->verifierStatuts($valeur, $codes);
1467
		return $ok;
1468
	}
1469
 
64 jpm 1470
	private function verifierStatuts(&$valeur, &$codes) {
20 jpm 1471
		$ok = true;
1472
		if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
1473
			$ok = false;
1474
		}
1475
		return $ok;
1476
	}
1477
 
64 jpm 1478
	private function verifierBooleen(&$valeur) {
20 jpm 1479
		$ok = true;
1480
		if (!preg_match('/^1$/', $valeur)) {
1481
			$ok = false;
1482
		}
1483
		return $ok;
1484
	}
1485
 
64 jpm 1486
	private function verifierNombre(&$valeur) {
20 jpm 1487
		$ok = true;
1488
		if (!preg_match('/^[0-9]+$/', $valeur)) {
1489
			$ok = false;
1490
		}
1491
		return $ok;
1492
	}
1493
 
64 jpm 1494
	private function verifierNombreSuite(&$valeur) {
20 jpm 1495
		$ok = true;
259 delphine 1496
		if (!preg_match('/^(?:[0-9]+, ?)*[0-9]+$/', $valeur)) {
20 jpm 1497
			$ok = false;
1498
		}
1499
		return $ok;
1500
	}
1501
 
64 jpm 1502
	private function verifierTypeEpithete(&$type) {
20 jpm 1503
		$ok = false;
1504
		$rejetes = $this->manuel['type_epithete_rejetes'];
1505
		if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
1506
			$ok = false;
1507
		} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
1508
			$ok = true;
1509
		}
1510
		return $ok;
1511
	}
1512
 
64 jpm 1513
	private function verifierBiblioOrigine(&$intitule) {
20 jpm 1514
		$ok = true;
1515
		if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1516
			$ok = false;// Contient des espaces en trop
1517
		} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
1518
			$ok = false;
1519
		} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
1520
			$ok = false;// Contient une mauvaise suite de caractères
1521
		}
1522
		return $ok;
1523
	}
1524
 
64 jpm 1525
	private function verifierAnnee(&$annee) {
20 jpm 1526
		$ok = true;
1527
		if (!preg_match('/^[0-9]{4}$/', $annee)) {
1528
			$ok = false;
188 delphine 1529
		} else if ($annee < ANNEE_MINIMUM) {
20 jpm 1530
			$ok = false;
188 delphine 1531
		} else if ($annee > ANNEE_EN_COURS) {
186 delphine 1532
			$ok = false;
20 jpm 1533
		}
1534
		return $ok;
1535
	}
1536
 
64 jpm 1537
	private function verifierAuteur(&$intitule) {
20 jpm 1538
		$ok = true;
1539
		$acceptes = $this->manuel['auteur_acceptes'];
1540
		if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
1541
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1542
				$ok = false;// Contient des espaces en trop
1543
			} else {
1544
				$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
1545
				$mots = explode(' ', $intitule);
1546
				foreach ($mots as $position => $mot) {
1547
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1548
						$ok = false;// Mot rejeté
184 jpm 1549
					} else if (preg_match("/^(?:(?:\p{L}|[.'\(\),-])+|[&])$/u", $mot)) {
20 jpm 1550
						continue;// Mot de l'intitulé auteur
1551
					} else {
1552
						$ok = false;
1553
					}
1554
				}
1555
			}
1556
		}
1557
		return $ok;
1558
	}
1559
 
64 jpm 1560
	private function verifierNomCommercial(&$epithete) {
20 jpm 1561
		$ok = false;
1562
		if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
1563
			$ok = true;
1564
		}
1565
		return $ok;
1566
	}
1567
 
64 jpm 1568
	private function verifierEpitheteCultivar(&$epithete) {
20 jpm 1569
		$ok = true;
1570
		$acceptes = $this->manuel['cultivar_acceptes'];
1571
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1572
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1573
				$ok = false;// Contient des espaces en trop
1574
			} else {
1575
				$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
1576
				$mots_mineurs = $this->manuel['mots_mineurs'];
1577
				$mots = explode(' ', $epithete);
1578
				foreach ($mots as $position => $mot) {
1579
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1580
						$ok = false;// Mot rejeté
1581
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1582
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1583
					} else {
1584
						$mots_tiret = explode('-', $mot);
1585
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1586
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1587
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
1588
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1589
								continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
1590
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1591
								continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1592
							} else {
1593
								$ok = false;
1594
							}
1595
						}
1596
					}
1597
				}
1598
			}
1599
		}
1600
		return $ok;
1601
	}
1602
 
64 jpm 1603
	private function verifierEpitheteGroupeCultivar(&$epithete) {
20 jpm 1604
		$ok = true;
1605
		$acceptes = $this->manuel['cultivar_gp_acceptes'];
1606
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1607
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1608
				$ok = false;// Contient des espaces en trop
1609
			} else {
1610
				$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
1611
				$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
1612
				$mots_mineurs = $this->manuel['mots_mineurs'];
1613
				$mots = explode(' ', $epithete);
1614
				foreach ($mots as $position => $mot) {
1615
					if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
1616
						continue;// Mot accepté
1617
					} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1618
						$ok = false;// Mot rejeté
1619
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1620
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1621
					} else {
1622
						$mots_tiret = explode('-', $mot);
1623
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1624
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1625
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
1626
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1627
								continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
1628
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1629
								continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1630
							} else {
1631
								$ok = false;
1632
							}
1633
						}
1634
					}
1635
				}
1636
			}
1637
		}
1638
		return $ok;
1639
	}
1640
 
64 jpm 1641
	private function verifierEpitheteSp(&$epithete) {
20 jpm 1642
		$ok = false;
183 jpm 1643
		if (preg_match('/^[a-zäëḧïöẗüẅẍÿ][-a-zäëḧïöẗüẅẍÿ]+$/', $epithete)) {
20 jpm 1644
			$ok = true;
1645
		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
1646
			$ok = true;
1647
		}
1648
		return $ok;
1649
	}
1650
 
64 jpm 1651
	private function verifierEpitheteGenre(&$epithete) {
20 jpm 1652
		$ok = false;
183 jpm 1653
		if (preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ](?:[-a-zäëḧïöẗüẅẍÿ]+|[a-zäëḧïöẗüẅẍÿ]+-[A-ZÄËḦÏÖÜẄẌŸ][a-zäëḧïöẗüẅẍÿ]+)$/', $epithete)) {
20 jpm 1654
			$ok = true;
1655
		}
1656
		return $ok;
1657
	}
1658
 
254 aurelien 1659
	private function verifierEstAbbreviationInfraSp($mot) {
1660
		$ok = false;
1661
		if(preg_match($this->manuel['abbr_rangs_infra_specifique'], $mot)) {
1662
			$ok = true;
1663
		}
1664
		return $ok;
1665
	}
1666
 
64 jpm 1667
	private function formaterStyleNomGenre(&$genre) {
20 jpm 1668
		$genre_fmt = '';
1669
		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
192 delphine 1670
			$genre_fmt = utf8_encode(strtolower(utf8_decode($match[1]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[2]))));
194 delphine 1671
		} elseif (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $genre, $match)) {
1672
			$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.
1673
				utf8_encode(strtolower(utf8_decode($match[2]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[3]))));
20 jpm 1674
		} else {
192 delphine 1675
			$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($genre))));
20 jpm 1676
		}
1677
		return $genre_fmt;
1678
	}
1679
 
250 delphine 1680
	private function formaterStyleEpitheteSpHybride(&$genre, &$epithete) {
1681
		$nom_fmt = '';
1682
		$erreur = '';
1683
		if (trim($genre) == '') {
1684
			if ($epithete != '') {
1685
				$nom_fmt = $this->formaterFormuleHybridite($epithete);
1686
			} else {
1687
				$erreur = "Formule d'hybridité sans épithéte spécifique";
1688
			}
1689
		} else {
1690
			$nom_fmt = $this->formaterNomHybride($genre, $epithete);
1691
		}
1692
		return array($nom_fmt, $erreur);
1693
	}
1694
 
1695
	private function formaterStyleEpitheteInfraSpHybride(&$nom_sci, &$infra, &$genre = null) {
1696
		$nom_fmt = '';
1697
		$erreur = '';
1698
		if (trim($genre) == '') {
1699
			if (trim($nom_sci) == '') {
1700
				if (trim($infra) != '') {
1701
					$nom_fmt = $this->formaterFormuleHybridite($infra);
1702
				} else {
1703
					$erreur = "Formule d'hybridité sans épithéte infraspécifique";
1704
				}
1705
			} else {
1706
				$erreur = "Formule d'hybridité avec épithéte spécifique";
1707
			}
1708
		} else {
1709
			$nom_fmt = $this->formaterNomHybride($nom_sci, $infra);
1710
		}
1711
		return array($nom_fmt, $erreur);
1712
	}
1713
 
1714
	private function formaterNomHybride(&$nom_sci, &$epithete) {
1715
		if (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $epithete, $match) != '') {
1716
			$nom_fmt = $nom_sci.utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.
1717
				utf8_encode(strtolower(utf8_decode($match[2]))).' '.
1718
				utf8_encode(ucfirst(strtolower(utf8_decode($match[3]))));
1719
		} elseif (preg_match('/^([x+])\s+(.+)$/i', $epithete, $match) != '') {
1720
			$nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($match[1]))).' '.
1721
				utf8_encode(strtolower(utf8_decode($match[2])));
1722
		} else {
1723
			$nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($epithete)));
1724
		}
1725
		return $nom_fmt;
1726
	}
1727
 
1728
	private function formaterFormuleHybridite(&$epithete) {
1729
		$liste_parents = explode(' x ', $epithete);
1730
		if (count($liste_parents) == 2) {
1731
			$nom_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[0])))).' x '.
1732
			utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[1]))));
1733
		} else {
1734
			for ($i=0; $i<count($liste_parents); $i++) {
1735
				if (strstr(trim($liste_parents[$i]), ' ') == false) {
1736
					$nom[] = utf8_encode(ucfirst(strtolower(utf8_decode(trim($liste_parents[$i]))))).' x '.
1737
					utf8_encode(strtolower(utf8_decode(trim($liste_parents[$i+1]))));
1738
					$i++;
1739
				} else {
1740
					$nom[] = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[$i]))));
1741
				}
1742
			}
1743
			$nom_fmt = implode(' x ', $nom);
1744
		}
1745
		return $nom_fmt;
1746
	}
1747
 
149 jpm 1748
	private function repererEspace($nom_sci) {
1749
		$nom_sci = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_sci);
1750
		return $nom_sci;
20 jpm 1751
	}
1752
 
263 aurelien 1753
	private function repererCaracteresInvalidesNomFrancais($nom_verna) {
262 aurelien 1754
		$nom_verna = str_replace(',', '<span class="espace">,</span>', $nom_verna);
1755
		$nom_verna = str_replace(';', '<span class="espace">;</span>', $nom_verna);
1756
		return $nom_verna;
1757
	}
1758
 
64 jpm 1759
	private function construireSuffixeNomPltCultivee(&$nom) {
20 jpm 1760
		$suffixe = array();
1761
		$suffixe[] = $this->construireNomCultivarGroupe($nom);
1762
		$suffixe[] = $this->construireNomCommercial($nom);
1763
		$suffixe[] = $this->construireNomCultivar($nom);
1764
		$suffixe = array_filter($suffixe);
1765
		return implode(' ', $suffixe);
1766
	}
1767
 
64 jpm 1768
	private function construireNomCultivarGroupe(&$nom) {
20 jpm 1769
		$nom_groupe_cultivar = '';
1770
		if ($nom['cultivar_groupe'] != '') {
1771
			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
1772
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
1773
			} else {
1774
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
1775
			}
1776
		}
1777
		return $nom_groupe_cultivar;
1778
	}
1779
 
64 jpm 1780
	private function construireNomCommercial(&$nom) {
20 jpm 1781
		$nom_commercial = '';
1782
		if ($nom['nom_commercial'] != '') {
1783
			$nom_commercial =  strtoupper($nom['nom_commercial']);
1784
		}
1785
		return $nom_commercial;
1786
	}
1787
 
64 jpm 1788
	private function construireNomCultivar(&$nom) {
20 jpm 1789
		$nom_cultivar = '';
1790
		if ($nom['cultivar'] != '') {
1791
			$nom_cultivar =  "'".$nom['cultivar']."'";
1792
		}
1793
		return $nom_cultivar;
1794
	}
1795
 
64 jpm 1796
	private function classerNomsParNomComplet() {
20 jpm 1797
		$noms_classes = array();
64 jpm 1798
		foreach ($this->noms as &$nom) {
149 jpm 1799
			if (!isset($noms_classes[$nom['nom_sci']])) {
1800
				$noms_classes[$nom['nom_sci']] = 1;
20 jpm 1801
			} else {
149 jpm 1802
				$noms_classes[$nom['nom_sci']]++;
20 jpm 1803
			}
1804
		}
1805
		return $noms_classes;
1806
	}
1807
}
1808
?>