Subversion Repositories Applications.referentiel

Rev

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