Subversion Repositories Applications.referentiel

Rev

Rev 364 | 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) {
364 delphine 1056
			if ($nom["rang"] != 450) {
1057
				if ($nom['epithete_infra_sp'] != '') {
1058
					$mots = explode(' ', $nom['epithete_infra_sp']);
1059
					$hybride_contient_abbreviation_infra_sp = false;
1060
					$formule_hybridite = (strpos($nom['epithete_infra_sp'], ' x ') !== false);
1061
					foreach ($mots as $mot) {
1062
						if($formule_hybridite && $this->verifierEstAbbreviationInfraSp($mot)) {
1063
							$hybride_contient_abbreviation_infra_sp = true;
1064
						}
1065
						$formule_hybridite_valide = $this->verifierEpitheteGenre($mot) || $this->verifierEpitheteSp($mot) || $hybride_contient_abbreviation_infra_sp;
1066
						if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot) || $this->verifierEpitheteSp($mot) ||
1067
							$formule_hybridite_valide)) {
1068
							$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
1069
							$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
1070
							$this->ajouterNumNomErreursTest($nom['num_nom']);
1071
							break;
1072
						}
255 aurelien 1073
					}
364 delphine 1074
 
1075
					if($formule_hybridite && !$hybride_contient_abbreviation_infra_sp) {
194 delphine 1076
						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
1077
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
309 delphine 1078
						$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1079
					}
1080
				}
1081
			}
1082
		}
177 jpm 1083
		return $noms_erreur;
20 jpm 1084
	}
1085
 
171 jpm 1086
	/**
309 delphine 1087
	 * Test #42
171 jpm 1088
	 */
64 jpm 1089
	private function testerEpitheteInfraSpRang() {
20 jpm 1090
		$noms_erreur = array();
64 jpm 1091
		foreach ($this->noms as &$nom) {
20 jpm 1092
			if ($nom['epithete_infra_sp'] != '') {
1093
				if ($nom['rang'] < $this->manuel['rang_sp']) {
183 jpm 1094
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
309 delphine 1095
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1096
				}
1097
			}
1098
		}
177 jpm 1099
		return $noms_erreur;
20 jpm 1100
	}
1101
 
173 jpm 1102
	/**
309 delphine 1103
	 * Test #43
173 jpm 1104
	 */
1105
	private function testerGroupeCultivarSyntaxe() {
20 jpm 1106
		$noms_erreur = array();
64 jpm 1107
		foreach ($this->noms as &$nom) {
173 jpm 1108
			if ($nom['cultivar_groupe'] != '') {
1109
				if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
1110
					$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
183 jpm 1111
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
309 delphine 1112
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1113
				}
1114
			}
1115
		}
177 jpm 1116
		return $noms_erreur;
20 jpm 1117
	}
1118
 
173 jpm 1119
	/**
309 delphine 1120
	 * Test #44
173 jpm 1121
	 */
1122
	private function testerGroupeCultivarRang() {
20 jpm 1123
		$noms_erreur = array();
64 jpm 1124
		foreach ($this->noms as &$nom) {
173 jpm 1125
			if ($nom['cultivar_groupe'] != '') {
1126
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 1127
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
309 delphine 1128
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1129
				}
1130
			}
1131
		}
177 jpm 1132
		return $noms_erreur;
20 jpm 1133
	}
1134
 
173 jpm 1135
	/**
309 delphine 1136
	 * Test #45
173 jpm 1137
	 */
1138
	private function testerCultivarSyntaxe() {
20 jpm 1139
		$noms_erreur = array();
64 jpm 1140
		foreach ($this->noms as &$nom) {
173 jpm 1141
			if ($nom['cultivar'] != '') {
1142
				if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
1143
					$epithete_traite = $this->repererEspace($nom['cultivar']);
183 jpm 1144
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
309 delphine 1145
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1146
				}
1147
			}
1148
		}
177 jpm 1149
		return $noms_erreur;
20 jpm 1150
	}
1151
 
173 jpm 1152
	/**
309 delphine 1153
	 * Test #46
173 jpm 1154
	 */
1155
	private function testerCultivarRang() {
20 jpm 1156
		$noms_erreur = array();
64 jpm 1157
		foreach ($this->noms as &$nom) {
173 jpm 1158
			if ($nom['cultivar'] != '') {
1159
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 1160
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
309 delphine 1161
					$this->ajouterNumNomErreursTest($nom['num_nom']);
171 jpm 1162
				}
20 jpm 1163
			}
1164
		}
177 jpm 1165
		return $noms_erreur;
20 jpm 1166
	}
1167
 
173 jpm 1168
	/**
309 delphine 1169
	 * Test #47
173 jpm 1170
	 */
1171
	private function testerNomCommercialSyntaxe() {
20 jpm 1172
		$noms_erreur = array();
64 jpm 1173
		foreach ($this->noms as &$nom) {
173 jpm 1174
			if ($nom['nom_commercial'] != '') {
1175
				if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
1176
					$epithete_traite = $this->repererEspace($nom['nom_commercial']);
183 jpm 1177
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
309 delphine 1178
					$this->ajouterNumNomErreursTest($nom['num_nom']);
171 jpm 1179
				}
20 jpm 1180
			}
1181
		}
177 jpm 1182
		return $noms_erreur;
20 jpm 1183
	}
1184
 
173 jpm 1185
	/**
309 delphine 1186
	 * Test #48
173 jpm 1187
	 */
1188
	private function testerNomCommercialPresenceCultivar() {
20 jpm 1189
		$noms_erreur = array();
64 jpm 1190
		foreach ($this->noms as &$nom) {
173 jpm 1191
			if ((isset($nom['nom_commercial']) && $nom['nom_commercial'] != '') && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
183 jpm 1192
				$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
309 delphine 1193
				$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1194
			}
1195
		}
177 jpm 1196
		return $noms_erreur;
20 jpm 1197
	}
1198
 
173 jpm 1199
	/**
309 delphine 1200
	 * Test #49
173 jpm 1201
	 */
1202
	private function testerAuteurSyntaxe() {
20 jpm 1203
		$noms_erreur = array();
64 jpm 1204
		foreach ($this->noms as &$nom) {
173 jpm 1205
			if ($nom['auteur'] != '') {
1206
				if (!$this->verifierAuteur($nom['auteur'])) {
1207
					$intitule_traite = $this->repererEspace($nom['auteur']);
183 jpm 1208
					$noms_erreur[] = array($nom['num_nom'], $intitule_traite, $nom['exclure_taxref']);
309 delphine 1209
					$this->ajouterNumNomErreursTest($nom['num_nom']);
171 jpm 1210
				}
20 jpm 1211
			}
1212
		}
177 jpm 1213
		return $noms_erreur;
20 jpm 1214
	}
1215
 
173 jpm 1216
	/**
309 delphine 1217
	 * Test #50
173 jpm 1218
	 */
1219
	private function testerAnneeSyntaxe() {
20 jpm 1220
		$noms_erreur = array();
64 jpm 1221
		foreach ($this->noms as &$nom) {
173 jpm 1222
			if ($nom['annee'] != '') {
1223
				if (!$this->verifierAnnee($nom['annee'])) {
183 jpm 1224
					$noms_erreur[] = array($nom['num_nom'], $nom['annee'], $nom['exclure_taxref']);
309 delphine 1225
					$this->ajouterNumNomErreursTest($nom['num_nom']);
171 jpm 1226
				}
20 jpm 1227
			}
1228
		}
177 jpm 1229
		return $noms_erreur;
20 jpm 1230
	}
1231
 
173 jpm 1232
	/**
309 delphine 1233
	 * Test #51
173 jpm 1234
	 */
1235
	private function testerBiblioOrigineSyntaxe() {
20 jpm 1236
		$noms_erreur = array();
64 jpm 1237
		foreach ($this->noms as &$nom) {
173 jpm 1238
			if ($nom['biblio_origine'] != '') {
1239
				if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
1240
					$biblio_traite = $this->repererEspace($nom['biblio_origine']);
183 jpm 1241
					$noms_erreur[] = array($nom['num_nom'], $biblio_traite, $nom['exclure_taxref']);
309 delphine 1242
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1243
				}
1244
			}
1245
		}
177 jpm 1246
		return $noms_erreur;
20 jpm 1247
	}
1248
 
173 jpm 1249
	/**
309 delphine 1250
	 * Test #52
173 jpm 1251
	 */
1252
	private function testerHomonymieSyntaxe() {
20 jpm 1253
		$noms_erreur = array();
173 jpm 1254
		foreach ($this->noms as &$nom) {
1255
			if ($nom['homonyme'] != '') {
1256
				if (!$this->verifierBooleen($nom['homonyme'])) {
183 jpm 1257
					$noms_erreur[] = array($nom['num_nom'], $nom['homonyme'], $nom['exclure_taxref']);
309 delphine 1258
					$this->ajouterNumNomErreursTest($nom['num_nom']);
161 jpm 1259
				}
20 jpm 1260
			}
1261
		}
177 jpm 1262
		return $noms_erreur;
20 jpm 1263
	}
1264
 
173 jpm 1265
	/**
309 delphine 1266
	 * Test #53
173 jpm 1267
	 */
1268
	private function testerHomonymieExistence() {
1269
		$noms_homonymie = $this->classerNomsParNomComplet();
1270
 
20 jpm 1271
		$noms_erreur = array();
64 jpm 1272
		foreach ($this->noms as &$nom) {
173 jpm 1273
			if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
1274
				if ($noms_homonymie[$nom['nom_sci']] <= 1) {
183 jpm 1275
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
309 delphine 1276
					$this->ajouterNumNomErreursTest($nom['num_nom']);
171 jpm 1277
				}
20 jpm 1278
			}
1279
		}
173 jpm 1280
		$noms_homonymie = null;
177 jpm 1281
		return $noms_erreur;
20 jpm 1282
	}
1283
 
173 jpm 1284
	/**
309 delphine 1285
	 * Test #54
173 jpm 1286
	 */
1287
	private function testerBasionymeSyntaxe() {
20 jpm 1288
		$noms_erreur = array();
64 jpm 1289
		foreach ($this->noms as &$nom) {
309 delphine 1290
			if ($nom['num_basionyme'] != '') {
1291
				if (!$this->verifierNombre($nom['num_basionyme'])) {
1292
					$noms_erreur[] = array($nom['num_nom'], $nom['num_basionyme'], $nom['exclure_taxref']);
1293
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1294
				}
1295
			}
1296
		}
177 jpm 1297
		return $noms_erreur;
20 jpm 1298
	}
173 jpm 1299
 
1300
	/**
309 delphine 1301
	 * Test #55
173 jpm 1302
	 */
1303
	private function testerBasionymeExistence() {
20 jpm 1304
		$noms_erreur = array();
64 jpm 1305
		foreach ($this->noms as &$nom) {
309 delphine 1306
			if ($nom['num_basionyme'] != '') {
1307
				if (!isset($this->noms[$nom['num_basionyme']])) {
1308
					$noms_erreur[] = array($nom['num_nom'], $nom['num_basionyme'], $nom['exclure_taxref']);
1309
					$this->ajouterNumNomErreursTest($nom['num_nom']);
173 jpm 1310
				}
20 jpm 1311
			}
1312
		}
177 jpm 1313
		return $noms_erreur;
20 jpm 1314
	}
1315
 
173 jpm 1316
	/**
309 delphine 1317
	 * Test #56
173 jpm 1318
	 */
1319
	private function testerSynonymeProparteSyntaxe() {
20 jpm 1320
		$noms_erreur = array();
64 jpm 1321
		foreach ($this->noms as &$nom) {
171 jpm 1322
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1323
				if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
183 jpm 1324
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte'], $nom['exclure_taxref']);
309 delphine 1325
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1326
				}
1327
			}
1328
		}
177 jpm 1329
		return $noms_erreur;
20 jpm 1330
	}
1331
 
173 jpm 1332
	/**
309 delphine 1333
	 * Test #57
173 jpm 1334
	 */
1335
	private function testerSynonymeProparteExistence() {
20 jpm 1336
		$noms_erreur = array();
64 jpm 1337
		foreach ($this->noms as &$nom) {
171 jpm 1338
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1339
				$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
1340
				$num_nom_en_erreur = array();
1341
				foreach ($num_nom_a_verifier as $num_nom) {
1342
					if (!isset($this->noms[$num_nom])) {
1343
						$num_nom_en_erreur[] = $num_nom;
1344
					}
20 jpm 1345
				}
309 delphine 1346
				if (count($num_nom_en_erreur) > 0) {
183 jpm 1347
					$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur), $nom['exclure_taxref']);
309 delphine 1348
					$this->ajouterNumNomErreursTest($nom['num_nom']);
173 jpm 1349
				}
20 jpm 1350
			}
1351
		}
177 jpm 1352
		return $noms_erreur;
20 jpm 1353
	}
1354
 
173 jpm 1355
	/**
309 delphine 1356
	 * Test #58
173 jpm 1357
	 */
1358
	private function testerSynonymeDouteuxSyntaxe() {
20 jpm 1359
		$noms_erreur = array();
64 jpm 1360
		foreach ($this->noms as &$nom) {
173 jpm 1361
			if ($nom['synonyme_douteux'] != '') {
1362
				if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
183 jpm 1363
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
309 delphine 1364
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1365
				}
1366
			}
1367
		}
177 jpm 1368
		return $noms_erreur;
20 jpm 1369
	}
1370
 
173 jpm 1371
	/**
309 delphine 1372
	 * Test #59
173 jpm 1373
	 */
1374
	private function testerSynonymeDouteuxNumNomRetenu() {
20 jpm 1375
		$noms_erreur = array();
64 jpm 1376
		foreach ($this->noms as &$nom) {
186 delphine 1377
			if ($nom['synonyme_douteux'] == 1 && !$this->verifierNombre($nom['num_nom_retenu'])) {
1378
				$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
309 delphine 1379
				$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1380
			}
1381
		}
177 jpm 1382
		return $noms_erreur;
20 jpm 1383
	}
1384
 
171 jpm 1385
	/**
318 delphine 1386
	* Test #60
1387
	*/
1388
	private function testerSynonymeDouteuxSynonyme() {
1389
		$noms_erreur = array();
1390
		foreach ($this->noms as &$nom) {
1391
			if ($nom['synonyme_douteux'] == 1 && $nom['num_nom'] == $nom['num_nom_retenu']) {
1392
				$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
1393
				$this->ajouterNumNomErreursTest($nom['num_nom']);
1394
			}
1395
		}
1396
		return $noms_erreur;
1397
	}
1398
 
1399
	/**
1400
	 * Test #61
171 jpm 1401
	 */
173 jpm 1402
	private function testerSynonymeMalAppliqueSyntaxe() {
20 jpm 1403
		$noms_erreur = array();
64 jpm 1404
		foreach ($this->noms as &$nom) {
173 jpm 1405
			if ($nom['synonyme_mal_applique'] != '') {
1406
				if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
183 jpm 1407
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique'], $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
	/**
318 delphine 1416
	* Test #62
1417
	*/
1418
	private function testerSynonymeMalAppliqueChampsAnnexe() {
1419
		$noms_erreur = array();
1420
		foreach ($this->noms as &$nom) {
1421
			if ($nom['synonyme_mal_applique'] == 1) {
1422
				$erreur = true;
1423
				$erreur = ($nom['annee'] == "") ? false : $erreur;
1424
				$erreur = ($nom['biblio_origine'] == "") ? false : $erreur;
1425
				$erreur = (strpos($nom['auteur'], "sensu") === 0) ? $erreur : false;
1426
				if ($erreur == false) {
1427
					$noms_erreur[] = array($nom['num_nom'], $nom['auteur'], $nom['annee'], $nom['biblio_origine'], $nom['exclure_taxref']);
1428
					$this->ajouterNumNomErreursTest($nom['num_nom']);
1429
				}
1430
			}
1431
		}
1432
		return $noms_erreur;
1433
	}
1434
 
1435
	/**
1436
	* Test #63
1437
	*/
1438
	private function testerSynonymeMalAppliqueSynonyme() {
1439
		$noms_erreur = array();
1440
		foreach ($this->noms as &$nom) {
1441
			if ($nom['synonyme_mal_applique'] == 1 && $nom['num_nom'] == $nom['num_nom_retenu']) {
1442
				$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']);
1443
				$this->ajouterNumNomErreursTest($nom['num_nom']);
1444
			}
1445
		}
1446
		return $noms_erreur;
1447
	}
1448
 
1449
	/**
1450
	 * Test #64
171 jpm 1451
	 */
173 jpm 1452
	private function testerSynonymeOrthographiqueSyntaxe() {
20 jpm 1453
		$noms_erreur = array();
173 jpm 1454
		foreach ($this->noms as $nom) {
1455
			if ($nom['synonyme_orthographique'] != '') {
1456
				if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
183 jpm 1457
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
309 delphine 1458
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1459
				}
1460
			}
1461
		}
177 jpm 1462
		return $noms_erreur;
20 jpm 1463
	}
1464
 
171 jpm 1465
	/**
318 delphine 1466
	 * Test #65
171 jpm 1467
	 */
173 jpm 1468
	private function testerSynonymeOrthographiqueExistence() {
20 jpm 1469
		$noms_erreur = array();
64 jpm 1470
		foreach ($this->noms as &$nom) {
173 jpm 1471
			if ($nom['synonyme_orthographique'] != '') {
1472
				if (!isset($this->noms[$nom['synonyme_orthographique']])) {
183 jpm 1473
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
309 delphine 1474
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1475
				}
1476
			}
1477
		}
177 jpm 1478
		return $noms_erreur;
20 jpm 1479
	}
1480
 
171 jpm 1481
	/**
318 delphine 1482
	 * Test #66
171 jpm 1483
	 */
173 jpm 1484
	private function testerHybrideParent01Syntaxe() {
20 jpm 1485
		$noms_erreur = array();
64 jpm 1486
		foreach ($this->noms as &$nom) {
173 jpm 1487
			if ($nom['hybride_parent_01'] != '') {
1488
				if (!$this->verifierNombre($nom['hybride_parent_01'])) {
183 jpm 1489
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
309 delphine 1490
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1491
				}
1492
			}
1493
		}
177 jpm 1494
		return $noms_erreur;
20 jpm 1495
	}
1496
 
171 jpm 1497
	/**
318 delphine 1498
	 * Test #67
171 jpm 1499
	 */
173 jpm 1500
	private function testerHybrideParent01Existence() {
20 jpm 1501
		$noms_erreur = array();
64 jpm 1502
		foreach ($this->noms as &$nom) {
173 jpm 1503
			if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
1504
				if (!isset($this->noms[$nom['hybride_parent_01']])) {
183 jpm 1505
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
309 delphine 1506
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1507
				}
1508
			}
1509
		}
177 jpm 1510
		return $noms_erreur;
20 jpm 1511
	}
171 jpm 1512
 
1513
	/**
318 delphine 1514
	 * Test #68
171 jpm 1515
	 */
173 jpm 1516
	private function testerHybrideParent02Syntaxe() {
20 jpm 1517
		$noms_erreur = array();
64 jpm 1518
		foreach ($this->noms as &$nom) {
173 jpm 1519
			if ($nom['hybride_parent_02'] != '') {
1520
				if (!$this->verifierNombre($nom['hybride_parent_02'])) {
183 jpm 1521
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
309 delphine 1522
					$this->ajouterNumNomErreursTest($nom['num_nom']);
173 jpm 1523
				}
20 jpm 1524
			}
1525
		}
177 jpm 1526
		return $noms_erreur;
20 jpm 1527
	}
1528
 
171 jpm 1529
	/**
318 delphine 1530
	 * Test #69
171 jpm 1531
	 */
173 jpm 1532
	private function testerHybrideParent02Existence() {
20 jpm 1533
		$noms_erreur = array();
64 jpm 1534
		foreach ($this->noms as &$nom) {
173 jpm 1535
			if ($nom['hybride_parent_02'] != '') {
1536
				if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
183 jpm 1537
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
309 delphine 1538
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1539
				}
1540
			}
1541
		}
177 jpm 1542
		return $noms_erreur;
20 jpm 1543
	}
1544
 
171 jpm 1545
	/**
318 delphine 1546
	* Test #70
309 delphine 1547
	*/
1548
	private function testerNumTypeSyntaxe() {
1549
		$noms_erreur = array();
1550
		foreach ($this->noms as &$nom) {
1551
			if ($nom['num_type'] != '') {
1552
				if (!$this->verifierNombre($nom['num_type'])) {
1553
					$noms_erreur[] = array($nom['num_nom'], $nom['num_type'], $nom['exclure_taxref']);
1554
					$this->ajouterNumNomErreursTest($nom['num_nom']);
1555
				}
1556
			}
1557
		}
1558
		return $noms_erreur;
1559
	}
1560
 
1561
	/**
318 delphine 1562
	 * Test #71
171 jpm 1563
	 */
309 delphine 1564
	private function testerNumTypeExistence() {
1565
		$noms_erreur = array();
1566
		foreach ($this->noms as &$nom) {
1567
			if ($nom['num_type'] != '') {
1568
				if (!isset($this->noms[$nom['num_type']])) {
1569
					$noms_erreur[] = array($nom['num_nom'], $nom['num_type'], $nom['exclure_taxref']);
1570
					$this->ajouterNumNomErreursTest($nom['num_nom']);
1571
				}
1572
			}
1573
		}
1574
		return $noms_erreur;
1575
	}
1576
 
1577
	/**
318 delphine 1578
	 * Test #72
309 delphine 1579
	 */
173 jpm 1580
	private function testerPresenceSyntaxe() {
20 jpm 1581
		$noms_erreur = array();
64 jpm 1582
		foreach ($this->noms as &$nom) {
173 jpm 1583
			if ($nom['presence'] != '') {
1584
				if (!$this->verifierPresence($nom['presence'])) {
183 jpm 1585
					$noms_erreur[] = array($nom['num_nom'], $nom['presence'], $nom['exclure_taxref']);
309 delphine 1586
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1587
				}
1588
			}
1589
		}
177 jpm 1590
		return $noms_erreur;
20 jpm 1591
	}
1592
 
171 jpm 1593
	/**
318 delphine 1594
	* Test #73
294 delphine 1595
	*/
1596
	private function testerPresenceExistence() {
1597
		$noms_erreur = array();
1598
		foreach ($this->noms as &$nom) {
1599
			if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0) {
1600
				if ($nom['presence'] == "") {
1601
					$noms_erreur[] = array($nom['num_nom'],$nom['num_nom_retenu'], $nom['presence'], $nom['exclure_taxref']);
309 delphine 1602
					$this->ajouterNumNomErreursTest($nom['num_nom']);
294 delphine 1603
				}
1604
			}
1605
		}
1606
		return $noms_erreur;
1607
	}
1608
 
1609
	/**
318 delphine 1610
	 * Test #74
171 jpm 1611
	 */
173 jpm 1612
	private function testerStatutOrigineSyntaxe() {
20 jpm 1613
		$noms_erreur = array();
64 jpm 1614
		foreach ($this->noms as &$nom) {
173 jpm 1615
			if ($nom['statut_origine'] != '') {
1616
				if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
183 jpm 1617
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine'], $nom['exclure_taxref']);
309 delphine 1618
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1619
				}
1620
			}
1621
		}
177 jpm 1622
		return $noms_erreur;
20 jpm 1623
	}
1624
 
171 jpm 1625
	/**
318 delphine 1626
	 * Test #75
171 jpm 1627
	 */
173 jpm 1628
	private function testerStatutIntroductionSyntaxe() {
20 jpm 1629
		$noms_erreur = array();
64 jpm 1630
		foreach ($this->noms as &$nom) {
173 jpm 1631
			if ($nom['statut_introduction'] != '') {
1632
				if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
183 jpm 1633
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction'], $nom['exclure_taxref']);
309 delphine 1634
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1635
				}
1636
			}
1637
		}
177 jpm 1638
		return $noms_erreur;
20 jpm 1639
	}
1640
 
171 jpm 1641
	/**
318 delphine 1642
	 * Test #76
171 jpm 1643
	 */
173 jpm 1644
	private function testerStatutCultureSyntaxe() {
20 jpm 1645
		$noms_erreur = array();
64 jpm 1646
		foreach ($this->noms as &$nom) {
173 jpm 1647
			if ($nom['statut_culture'] != '') {
1648
				if (!$this->verifierStatutCulture($nom['statut_culture'])) {
183 jpm 1649
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture'], $nom['exclure_taxref']);
309 delphine 1650
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1651
				}
1652
			}
1653
		}
177 jpm 1654
		return $noms_erreur;
20 jpm 1655
	}
1656
 
171 jpm 1657
	/**
318 delphine 1658
	 * Test #77
171 jpm 1659
	 */
146 delphine 1660
	private function testerExclureTaxRefSyntaxe() {
1661
		$noms_erreur = array();
1662
		foreach ($this->noms as &$nom) {
1663
			if ($nom['exclure_taxref'] != '' && $nom['exclure_taxref'] != null) {
183 jpm 1664
				if (!preg_match('/^(?:0|1|9)$/', $nom['exclure_taxref'])) {
146 delphine 1665
					$noms_erreur[] = array($nom['num_nom'], $nom['exclure_taxref']);
309 delphine 1666
					$this->ajouterNumNomErreursTest($nom['num_nom']);
146 delphine 1667
				}
1668
			}
1669
		}
177 jpm 1670
		return $noms_erreur;
146 delphine 1671
	}
171 jpm 1672
 
262 aurelien 1673
	/**
318 delphine 1674
	* Test #78
262 aurelien 1675
	*/
263 aurelien 1676
	private function testerNomFrancaisUnique() {
262 aurelien 1677
		$noms_erreur = array();
1678
		foreach ($this->noms as &$nom) {
1679
			if ($nom['nom_francais'] != '' && $nom['nom_francais'] != null) {
1680
				if (strpbrk($nom['nom_francais'],',;')) {
263 aurelien 1681
					$noms_erreur[] = array($nom['num_nom'], $this->repererCaracteresInvalidesNomFrancais($nom['nom_francais']));
309 delphine 1682
					$this->ajouterNumNomErreursTest($nom['num_nom']);
262 aurelien 1683
				}
1684
			}
1685
		}
1686
		return $noms_erreur;
1687
	}
264 aurelien 1688
 
364 delphine 1689
 
1690
	/**
367 delphine 1691
	 * Test #79
364 delphine 1692
	 */
1693
	private function testerExistenceNomSuperieur() {
1694
		$noms_erreur = array();
1695
		foreach ($this->noms as &$nom) {
1696
				if ($nom['num_nom_sup'] != 0 && !isset($this->noms[$nom['num_nom_sup']])) {
1697
					$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_sup'], $nom['exclure_taxref']);
1698
					$this->ajouterNumNomErreursTest($nom['num_nom']);
1699
				}
1700
		}
1701
		return $noms_erreur;
1702
	}
1703
 
1704
	/**
367 delphine 1705
	* Test #80
364 delphine 1706
	*/
264 aurelien 1707
	private function testerExclureTaxRefPresence() {
1708
		$noms_erreur = array();
1709
		foreach ($this->noms as &$nom) {
266 aurelien 1710
			// On vérifie tous les noms retenu nom exclus de taxref de rang inférieur ou égal à l'espèce
1711
			if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0 && $nom['rang'] >= 240) {
264 aurelien 1712
				if($nom['presence'] == '' || !$this->verifierPresence($nom['presence'])) {
1713
					if(($nom['statut_origine'] == '' || !$this->verifierStatutOrigine($nom['statut_origine'])) &&
1714
					   ($nom['statut_introduction'] == '' || !$this->verifierStatutIntroduction($nom['statut_introduction'])) &&
1715
					   ($nom['statut_culture'] == '' || !$this->verifierStatutCulture($nom['statut_culture'])))
1716
					{
1717
						$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'],
1718
												$this->mettreEnValeurAvertissement($nom['presence']),
1719
												$this->mettreEnValeurAvertissement($nom['statut_origine']),
1720
												$this->mettreEnValeurAvertissement($nom['statut_introduction']),
1721
												$this->mettreEnValeurAvertissement($nom['statut_culture'])
1722
										);
309 delphine 1723
						$this->ajouterNumNomErreursTest($nom['num_nom']);
264 aurelien 1724
					} else {
1725
						//TODO: le comportement est identique mais il faudrait pouvoir afficher un avertissement
1726
						// si le champ présence n'est pas rempli mais que l'une des colonne de statut l'est
1727
						$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'],
1728
												$nom['presence'],
1729
												$this->mettreEnValeurAvertissement($nom['statut_origine']),
1730
												$this->mettreEnValeurAvertissement($nom['statut_introduction']),
1731
												$this->mettreEnValeurAvertissement($nom['statut_culture'])
1732
										);
309 delphine 1733
						$this->ajouterNumNomErreursTest($nom['num_nom']);
264 aurelien 1734
					}
1735
				}
1736
			}
1737
		}
1738
		return $noms_erreur;
1739
	}
294 delphine 1740
 
171 jpm 1741
 
20 jpm 1742
	//+--------------------------------------------------------------------------------------------------------------+//
1743
	// MÉTHODES COMMUNES aux TESTS
1744
 
64 jpm 1745
	private function verifierPresence(&$valeur) {
20 jpm 1746
		$codes = $this->manuel['codes_presence'];
1747
		$ok = $this->verifierStatuts($valeur, $codes);
1748
		return $ok;
1749
	}
1750
 
64 jpm 1751
	private function verifierStatutOrigine(&$valeur) {
20 jpm 1752
		$codes = $this->manuel['codes_statuts_origine'];
1753
		$ok = $this->verifierStatuts($valeur, $codes);
1754
		return $ok;
1755
	}
1756
 
64 jpm 1757
	private function verifierStatutIntroduction(&$valeur) {
20 jpm 1758
		$codes = $this->manuel['codes_statuts_introduction'];
1759
		$ok = $this->verifierStatuts($valeur, $codes);
1760
		return $ok;
1761
	}
1762
 
64 jpm 1763
	private function verifierStatutCulture(&$valeur) {
20 jpm 1764
		$codes = $this->manuel['codes_statuts_culture'];
1765
		$ok = $this->verifierStatuts($valeur, $codes);
1766
		return $ok;
1767
	}
1768
 
64 jpm 1769
	private function verifierStatuts(&$valeur, &$codes) {
20 jpm 1770
		$ok = true;
1771
		if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
1772
			$ok = false;
1773
		}
1774
		return $ok;
1775
	}
1776
 
64 jpm 1777
	private function verifierBooleen(&$valeur) {
20 jpm 1778
		$ok = true;
1779
		if (!preg_match('/^1$/', $valeur)) {
1780
			$ok = false;
1781
		}
1782
		return $ok;
1783
	}
1784
 
64 jpm 1785
	private function verifierNombre(&$valeur) {
20 jpm 1786
		$ok = true;
1787
		if (!preg_match('/^[0-9]+$/', $valeur)) {
1788
			$ok = false;
1789
		}
1790
		return $ok;
1791
	}
1792
 
64 jpm 1793
	private function verifierNombreSuite(&$valeur) {
20 jpm 1794
		$ok = true;
259 delphine 1795
		if (!preg_match('/^(?:[0-9]+, ?)*[0-9]+$/', $valeur)) {
20 jpm 1796
			$ok = false;
1797
		}
1798
		return $ok;
1799
	}
1800
 
64 jpm 1801
	private function verifierTypeEpithete(&$type) {
20 jpm 1802
		$ok = false;
1803
		$rejetes = $this->manuel['type_epithete_rejetes'];
1804
		if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
1805
			$ok = false;
1806
		} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
1807
			$ok = true;
1808
		}
1809
		return $ok;
1810
	}
1811
 
64 jpm 1812
	private function verifierBiblioOrigine(&$intitule) {
20 jpm 1813
		$ok = true;
1814
		if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1815
			$ok = false;// Contient des espaces en trop
1816
		} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
1817
			$ok = false;
1818
		} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
1819
			$ok = false;// Contient une mauvaise suite de caractères
1820
		}
1821
		return $ok;
1822
	}
1823
 
64 jpm 1824
	private function verifierAnnee(&$annee) {
20 jpm 1825
		$ok = true;
1826
		if (!preg_match('/^[0-9]{4}$/', $annee)) {
1827
			$ok = false;
188 delphine 1828
		} else if ($annee < ANNEE_MINIMUM) {
20 jpm 1829
			$ok = false;
188 delphine 1830
		} else if ($annee > ANNEE_EN_COURS) {
186 delphine 1831
			$ok = false;
20 jpm 1832
		}
1833
		return $ok;
1834
	}
1835
 
64 jpm 1836
	private function verifierAuteur(&$intitule) {
20 jpm 1837
		$ok = true;
1838
		$acceptes = $this->manuel['auteur_acceptes'];
1839
		if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
1840
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1841
				$ok = false;// Contient des espaces en trop
1842
			} else {
1843
				$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
1844
				$mots = explode(' ', $intitule);
1845
				foreach ($mots as $position => $mot) {
1846
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1847
						$ok = false;// Mot rejeté
184 jpm 1848
					} else if (preg_match("/^(?:(?:\p{L}|[.'\(\),-])+|[&])$/u", $mot)) {
20 jpm 1849
						continue;// Mot de l'intitulé auteur
1850
					} else {
1851
						$ok = false;
1852
					}
1853
				}
1854
			}
1855
		}
1856
		return $ok;
1857
	}
1858
 
64 jpm 1859
	private function verifierNomCommercial(&$epithete) {
20 jpm 1860
		$ok = false;
1861
		if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
1862
			$ok = true;
1863
		}
1864
		return $ok;
1865
	}
1866
 
64 jpm 1867
	private function verifierEpitheteCultivar(&$epithete) {
20 jpm 1868
		$ok = true;
1869
		$acceptes = $this->manuel['cultivar_acceptes'];
1870
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1871
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1872
				$ok = false;// Contient des espaces en trop
1873
			} else {
1874
				$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
1875
				$mots_mineurs = $this->manuel['mots_mineurs'];
1876
				$mots = explode(' ', $epithete);
1877
				foreach ($mots as $position => $mot) {
1878
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1879
						$ok = false;// Mot rejeté
1880
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1881
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1882
					} else {
1883
						$mots_tiret = explode('-', $mot);
1884
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1885
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1886
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
1887
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1888
								continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
1889
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1890
								continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1891
							} else {
1892
								$ok = false;
1893
							}
1894
						}
1895
					}
1896
				}
1897
			}
1898
		}
1899
		return $ok;
1900
	}
1901
 
64 jpm 1902
	private function verifierEpitheteGroupeCultivar(&$epithete) {
20 jpm 1903
		$ok = true;
1904
		$acceptes = $this->manuel['cultivar_gp_acceptes'];
1905
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1906
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1907
				$ok = false;// Contient des espaces en trop
1908
			} else {
1909
				$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
1910
				$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
1911
				$mots_mineurs = $this->manuel['mots_mineurs'];
1912
				$mots = explode(' ', $epithete);
1913
				foreach ($mots as $position => $mot) {
1914
					if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
1915
						continue;// Mot accepté
1916
					} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1917
						$ok = false;// Mot rejeté
1918
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1919
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1920
					} else {
1921
						$mots_tiret = explode('-', $mot);
1922
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1923
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1924
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
1925
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1926
								continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
1927
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1928
								continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1929
							} else {
1930
								$ok = false;
1931
							}
1932
						}
1933
					}
1934
				}
1935
			}
1936
		}
1937
		return $ok;
1938
	}
1939
 
64 jpm 1940
	private function verifierEpitheteSp(&$epithete) {
20 jpm 1941
		$ok = false;
183 jpm 1942
		if (preg_match('/^[a-zäëḧïöẗüẅẍÿ][-a-zäëḧïöẗüẅẍÿ]+$/', $epithete)) {
20 jpm 1943
			$ok = true;
1944
		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
1945
			$ok = true;
1946
		}
1947
		return $ok;
1948
	}
1949
 
64 jpm 1950
	private function verifierEpitheteGenre(&$epithete) {
20 jpm 1951
		$ok = false;
183 jpm 1952
		if (preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ](?:[-a-zäëḧïöẗüẅẍÿ]+|[a-zäëḧïöẗüẅẍÿ]+-[A-ZÄËḦÏÖÜẄẌŸ][a-zäëḧïöẗüẅẍÿ]+)$/', $epithete)) {
20 jpm 1953
			$ok = true;
1954
		}
1955
		return $ok;
1956
	}
1957
 
254 aurelien 1958
	private function verifierEstAbbreviationInfraSp($mot) {
1959
		$ok = false;
1960
		if(preg_match($this->manuel['abbr_rangs_infra_specifique'], $mot)) {
1961
			$ok = true;
1962
		}
1963
		return $ok;
1964
	}
1965
 
64 jpm 1966
	private function formaterStyleNomGenre(&$genre) {
20 jpm 1967
		$genre_fmt = '';
1968
		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
192 delphine 1969
			$genre_fmt = utf8_encode(strtolower(utf8_decode($match[1]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[2]))));
194 delphine 1970
		} elseif (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $genre, $match)) {
1971
			$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.
1972
				utf8_encode(strtolower(utf8_decode($match[2]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[3]))));
20 jpm 1973
		} else {
192 delphine 1974
			$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($genre))));
20 jpm 1975
		}
1976
		return $genre_fmt;
1977
	}
1978
 
250 delphine 1979
	private function formaterStyleEpitheteSpHybride(&$genre, &$epithete) {
1980
		$nom_fmt = '';
1981
		$erreur = '';
1982
		if (trim($genre) == '') {
1983
			if ($epithete != '') {
1984
				$nom_fmt = $this->formaterFormuleHybridite($epithete);
1985
			} else {
1986
				$erreur = "Formule d'hybridité sans épithéte spécifique";
1987
			}
1988
		} else {
1989
			$nom_fmt = $this->formaterNomHybride($genre, $epithete);
1990
		}
1991
		return array($nom_fmt, $erreur);
1992
	}
1993
 
1994
	private function formaterStyleEpitheteInfraSpHybride(&$nom_sci, &$infra, &$genre = null) {
1995
		$nom_fmt = '';
1996
		$erreur = '';
1997
		if (trim($genre) == '') {
1998
			if (trim($nom_sci) == '') {
1999
				if (trim($infra) != '') {
2000
					$nom_fmt = $this->formaterFormuleHybridite($infra);
2001
				} else {
2002
					$erreur = "Formule d'hybridité sans épithéte infraspécifique";
2003
				}
2004
			} else {
2005
				$erreur = "Formule d'hybridité avec épithéte spécifique";
2006
			}
2007
		} else {
2008
			$nom_fmt = $this->formaterNomHybride($nom_sci, $infra);
2009
		}
2010
		return array($nom_fmt, $erreur);
2011
	}
2012
 
2013
	private function formaterNomHybride(&$nom_sci, &$epithete) {
2014
		if (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $epithete, $match) != '') {
2015
			$nom_fmt = $nom_sci.utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.
2016
				utf8_encode(strtolower(utf8_decode($match[2]))).' '.
2017
				utf8_encode(ucfirst(strtolower(utf8_decode($match[3]))));
2018
		} elseif (preg_match('/^([x+])\s+(.+)$/i', $epithete, $match) != '') {
2019
			$nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($match[1]))).' '.
2020
				utf8_encode(strtolower(utf8_decode($match[2])));
2021
		} else {
2022
			$nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($epithete)));
2023
		}
2024
		return $nom_fmt;
2025
	}
2026
 
2027
	private function formaterFormuleHybridite(&$epithete) {
2028
		$liste_parents = explode(' x ', $epithete);
2029
		if (count($liste_parents) == 2) {
2030
			$nom_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[0])))).' x '.
2031
			utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[1]))));
2032
		} else {
2033
			for ($i=0; $i<count($liste_parents); $i++) {
2034
				if (strstr(trim($liste_parents[$i]), ' ') == false) {
2035
					$nom[] = utf8_encode(ucfirst(strtolower(utf8_decode(trim($liste_parents[$i]))))).' x '.
2036
					utf8_encode(strtolower(utf8_decode(trim($liste_parents[$i+1]))));
2037
					$i++;
2038
				} else {
2039
					$nom[] = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[$i]))));
2040
				}
2041
			}
2042
			$nom_fmt = implode(' x ', $nom);
2043
		}
2044
		return $nom_fmt;
2045
	}
2046
 
149 jpm 2047
	private function repererEspace($nom_sci) {
2048
		$nom_sci = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_sci);
2049
		return $nom_sci;
20 jpm 2050
	}
2051
 
263 aurelien 2052
	private function repererCaracteresInvalidesNomFrancais($nom_verna) {
262 aurelien 2053
		$nom_verna = str_replace(',', '<span class="espace">,</span>', $nom_verna);
2054
		$nom_verna = str_replace(';', '<span class="espace">;</span>', $nom_verna);
2055
		return $nom_verna;
2056
	}
2057
 
264 aurelien 2058
	private function mettreEnValeurAvertissement($chaine) {
2059
		$chaine = '<span class="espace">'.$chaine.'</span>';
2060
		return $chaine;
2061
	}
2062
 
64 jpm 2063
	private function construireSuffixeNomPltCultivee(&$nom) {
20 jpm 2064
		$suffixe = array();
2065
		$suffixe[] = $this->construireNomCultivarGroupe($nom);
2066
		$suffixe[] = $this->construireNomCommercial($nom);
2067
		$suffixe[] = $this->construireNomCultivar($nom);
2068
		$suffixe = array_filter($suffixe);
2069
		return implode(' ', $suffixe);
2070
	}
2071
 
64 jpm 2072
	private function construireNomCultivarGroupe(&$nom) {
20 jpm 2073
		$nom_groupe_cultivar = '';
2074
		if ($nom['cultivar_groupe'] != '') {
2075
			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
2076
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
2077
			} else {
2078
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
2079
			}
2080
		}
2081
		return $nom_groupe_cultivar;
2082
	}
2083
 
64 jpm 2084
	private function construireNomCommercial(&$nom) {
20 jpm 2085
		$nom_commercial = '';
2086
		if ($nom['nom_commercial'] != '') {
2087
			$nom_commercial =  strtoupper($nom['nom_commercial']);
2088
		}
2089
		return $nom_commercial;
2090
	}
2091
 
64 jpm 2092
	private function construireNomCultivar(&$nom) {
20 jpm 2093
		$nom_cultivar = '';
2094
		if ($nom['cultivar'] != '') {
2095
			$nom_cultivar =  "'".$nom['cultivar']."'";
2096
		}
2097
		return $nom_cultivar;
2098
	}
2099
 
64 jpm 2100
	private function classerNomsParNomComplet() {
20 jpm 2101
		$noms_classes = array();
64 jpm 2102
		foreach ($this->noms as &$nom) {
149 jpm 2103
			if (!isset($noms_classes[$nom['nom_sci']])) {
2104
				$noms_classes[$nom['nom_sci']] = 1;
20 jpm 2105
			} else {
149 jpm 2106
				$noms_classes[$nom['nom_sci']]++;
20 jpm 2107
			}
2108
		}
2109
		return $noms_classes;
2110
	}
2111
}
2112
?>