Subversion Repositories Applications.referentiel

Rev

Rev 314 | Rev 364 | 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
	/**
318 delphine 1384
	* Test #60
1385
	*/
1386
	private function testerSynonymeDouteuxSynonyme() {
1387
		$noms_erreur = array();
1388
		foreach ($this->noms as &$nom) {
1389
			if ($nom['synonyme_douteux'] == 1 && $nom['num_nom'] == $nom['num_nom_retenu']) {
1390
				$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
1391
				$this->ajouterNumNomErreursTest($nom['num_nom']);
1392
			}
1393
		}
1394
		return $noms_erreur;
1395
	}
1396
 
1397
	/**
1398
	 * Test #61
171 jpm 1399
	 */
173 jpm 1400
	private function testerSynonymeMalAppliqueSyntaxe() {
20 jpm 1401
		$noms_erreur = array();
64 jpm 1402
		foreach ($this->noms as &$nom) {
173 jpm 1403
			if ($nom['synonyme_mal_applique'] != '') {
1404
				if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
183 jpm 1405
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']);
309 delphine 1406
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1407
				}
1408
			}
1409
		}
177 jpm 1410
		return $noms_erreur;
20 jpm 1411
	}
1412
 
171 jpm 1413
	/**
318 delphine 1414
	* Test #62
1415
	*/
1416
	private function testerSynonymeMalAppliqueChampsAnnexe() {
1417
		$noms_erreur = array();
1418
		foreach ($this->noms as &$nom) {
1419
			if ($nom['synonyme_mal_applique'] == 1) {
1420
				$erreur = true;
1421
				$erreur = ($nom['annee'] == "") ? false : $erreur;
1422
				$erreur = ($nom['biblio_origine'] == "") ? false : $erreur;
1423
				$erreur = (strpos($nom['auteur'], "sensu") === 0) ? $erreur : false;
1424
				if ($erreur == false) {
1425
					$noms_erreur[] = array($nom['num_nom'], $nom['auteur'], $nom['annee'], $nom['biblio_origine'], $nom['exclure_taxref']);
1426
					$this->ajouterNumNomErreursTest($nom['num_nom']);
1427
				}
1428
			}
1429
		}
1430
		return $noms_erreur;
1431
	}
1432
 
1433
	/**
1434
	* Test #63
1435
	*/
1436
	private function testerSynonymeMalAppliqueSynonyme() {
1437
		$noms_erreur = array();
1438
		foreach ($this->noms as &$nom) {
1439
			if ($nom['synonyme_mal_applique'] == 1 && $nom['num_nom'] == $nom['num_nom_retenu']) {
1440
				$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']);
1441
				$this->ajouterNumNomErreursTest($nom['num_nom']);
1442
			}
1443
		}
1444
		return $noms_erreur;
1445
	}
1446
 
1447
	/**
1448
	 * Test #64
171 jpm 1449
	 */
173 jpm 1450
	private function testerSynonymeOrthographiqueSyntaxe() {
20 jpm 1451
		$noms_erreur = array();
173 jpm 1452
		foreach ($this->noms as $nom) {
1453
			if ($nom['synonyme_orthographique'] != '') {
1454
				if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
183 jpm 1455
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $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
	}
1462
 
171 jpm 1463
	/**
318 delphine 1464
	 * Test #65
171 jpm 1465
	 */
173 jpm 1466
	private function testerSynonymeOrthographiqueExistence() {
20 jpm 1467
		$noms_erreur = array();
64 jpm 1468
		foreach ($this->noms as &$nom) {
173 jpm 1469
			if ($nom['synonyme_orthographique'] != '') {
1470
				if (!isset($this->noms[$nom['synonyme_orthographique']])) {
183 jpm 1471
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
309 delphine 1472
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1473
				}
1474
			}
1475
		}
177 jpm 1476
		return $noms_erreur;
20 jpm 1477
	}
1478
 
171 jpm 1479
	/**
318 delphine 1480
	 * Test #66
171 jpm 1481
	 */
173 jpm 1482
	private function testerHybrideParent01Syntaxe() {
20 jpm 1483
		$noms_erreur = array();
64 jpm 1484
		foreach ($this->noms as &$nom) {
173 jpm 1485
			if ($nom['hybride_parent_01'] != '') {
1486
				if (!$this->verifierNombre($nom['hybride_parent_01'])) {
183 jpm 1487
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $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
	/**
318 delphine 1496
	 * Test #67
171 jpm 1497
	 */
173 jpm 1498
	private function testerHybrideParent01Existence() {
20 jpm 1499
		$noms_erreur = array();
64 jpm 1500
		foreach ($this->noms as &$nom) {
173 jpm 1501
			if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
1502
				if (!isset($this->noms[$nom['hybride_parent_01']])) {
183 jpm 1503
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
309 delphine 1504
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1505
				}
1506
			}
1507
		}
177 jpm 1508
		return $noms_erreur;
20 jpm 1509
	}
171 jpm 1510
 
1511
	/**
318 delphine 1512
	 * Test #68
171 jpm 1513
	 */
173 jpm 1514
	private function testerHybrideParent02Syntaxe() {
20 jpm 1515
		$noms_erreur = array();
64 jpm 1516
		foreach ($this->noms as &$nom) {
173 jpm 1517
			if ($nom['hybride_parent_02'] != '') {
1518
				if (!$this->verifierNombre($nom['hybride_parent_02'])) {
183 jpm 1519
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
309 delphine 1520
					$this->ajouterNumNomErreursTest($nom['num_nom']);
173 jpm 1521
				}
20 jpm 1522
			}
1523
		}
177 jpm 1524
		return $noms_erreur;
20 jpm 1525
	}
1526
 
171 jpm 1527
	/**
318 delphine 1528
	 * Test #69
171 jpm 1529
	 */
173 jpm 1530
	private function testerHybrideParent02Existence() {
20 jpm 1531
		$noms_erreur = array();
64 jpm 1532
		foreach ($this->noms as &$nom) {
173 jpm 1533
			if ($nom['hybride_parent_02'] != '') {
1534
				if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
183 jpm 1535
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $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
	/**
318 delphine 1544
	* Test #70
309 delphine 1545
	*/
1546
	private function testerNumTypeSyntaxe() {
1547
		$noms_erreur = array();
1548
		foreach ($this->noms as &$nom) {
1549
			if ($nom['num_type'] != '') {
1550
				if (!$this->verifierNombre($nom['num_type'])) {
1551
					$noms_erreur[] = array($nom['num_nom'], $nom['num_type'], $nom['exclure_taxref']);
1552
					$this->ajouterNumNomErreursTest($nom['num_nom']);
1553
				}
1554
			}
1555
		}
1556
		return $noms_erreur;
1557
	}
1558
 
1559
	/**
318 delphine 1560
	 * Test #71
171 jpm 1561
	 */
309 delphine 1562
	private function testerNumTypeExistence() {
1563
		$noms_erreur = array();
1564
		foreach ($this->noms as &$nom) {
1565
			if ($nom['num_type'] != '') {
1566
				if (!isset($this->noms[$nom['num_type']])) {
1567
					$noms_erreur[] = array($nom['num_nom'], $nom['num_type'], $nom['exclure_taxref']);
1568
					$this->ajouterNumNomErreursTest($nom['num_nom']);
1569
				}
1570
			}
1571
		}
1572
		return $noms_erreur;
1573
	}
1574
 
1575
	/**
318 delphine 1576
	 * Test #72
309 delphine 1577
	 */
173 jpm 1578
	private function testerPresenceSyntaxe() {
20 jpm 1579
		$noms_erreur = array();
64 jpm 1580
		foreach ($this->noms as &$nom) {
173 jpm 1581
			if ($nom['presence'] != '') {
1582
				if (!$this->verifierPresence($nom['presence'])) {
183 jpm 1583
					$noms_erreur[] = array($nom['num_nom'], $nom['presence'], $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
	/**
318 delphine 1592
	* Test #73
294 delphine 1593
	*/
1594
	private function testerPresenceExistence() {
1595
		$noms_erreur = array();
1596
		foreach ($this->noms as &$nom) {
1597
			if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0) {
1598
				if ($nom['presence'] == "") {
1599
					$noms_erreur[] = array($nom['num_nom'],$nom['num_nom_retenu'], $nom['presence'], $nom['exclure_taxref']);
309 delphine 1600
					$this->ajouterNumNomErreursTest($nom['num_nom']);
294 delphine 1601
				}
1602
			}
1603
		}
1604
		return $noms_erreur;
1605
	}
1606
 
1607
	/**
318 delphine 1608
	 * Test #74
171 jpm 1609
	 */
173 jpm 1610
	private function testerStatutOrigineSyntaxe() {
20 jpm 1611
		$noms_erreur = array();
64 jpm 1612
		foreach ($this->noms as &$nom) {
173 jpm 1613
			if ($nom['statut_origine'] != '') {
1614
				if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
183 jpm 1615
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine'], $nom['exclure_taxref']);
309 delphine 1616
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1617
				}
1618
			}
1619
		}
177 jpm 1620
		return $noms_erreur;
20 jpm 1621
	}
1622
 
171 jpm 1623
	/**
318 delphine 1624
	 * Test #75
171 jpm 1625
	 */
173 jpm 1626
	private function testerStatutIntroductionSyntaxe() {
20 jpm 1627
		$noms_erreur = array();
64 jpm 1628
		foreach ($this->noms as &$nom) {
173 jpm 1629
			if ($nom['statut_introduction'] != '') {
1630
				if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
183 jpm 1631
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction'], $nom['exclure_taxref']);
309 delphine 1632
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1633
				}
1634
			}
1635
		}
177 jpm 1636
		return $noms_erreur;
20 jpm 1637
	}
1638
 
171 jpm 1639
	/**
318 delphine 1640
	 * Test #76
171 jpm 1641
	 */
173 jpm 1642
	private function testerStatutCultureSyntaxe() {
20 jpm 1643
		$noms_erreur = array();
64 jpm 1644
		foreach ($this->noms as &$nom) {
173 jpm 1645
			if ($nom['statut_culture'] != '') {
1646
				if (!$this->verifierStatutCulture($nom['statut_culture'])) {
183 jpm 1647
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture'], $nom['exclure_taxref']);
309 delphine 1648
					$this->ajouterNumNomErreursTest($nom['num_nom']);
20 jpm 1649
				}
1650
			}
1651
		}
177 jpm 1652
		return $noms_erreur;
20 jpm 1653
	}
1654
 
171 jpm 1655
	/**
318 delphine 1656
	 * Test #77
171 jpm 1657
	 */
146 delphine 1658
	private function testerExclureTaxRefSyntaxe() {
1659
		$noms_erreur = array();
1660
		foreach ($this->noms as &$nom) {
1661
			if ($nom['exclure_taxref'] != '' && $nom['exclure_taxref'] != null) {
183 jpm 1662
				if (!preg_match('/^(?:0|1|9)$/', $nom['exclure_taxref'])) {
146 delphine 1663
					$noms_erreur[] = array($nom['num_nom'], $nom['exclure_taxref']);
309 delphine 1664
					$this->ajouterNumNomErreursTest($nom['num_nom']);
146 delphine 1665
				}
1666
			}
1667
		}
177 jpm 1668
		return $noms_erreur;
146 delphine 1669
	}
171 jpm 1670
 
262 aurelien 1671
	/**
318 delphine 1672
	* Test #78
262 aurelien 1673
	*/
263 aurelien 1674
	private function testerNomFrancaisUnique() {
262 aurelien 1675
		$noms_erreur = array();
1676
		foreach ($this->noms as &$nom) {
1677
			if ($nom['nom_francais'] != '' && $nom['nom_francais'] != null) {
1678
				if (strpbrk($nom['nom_francais'],',;')) {
263 aurelien 1679
					$noms_erreur[] = array($nom['num_nom'], $this->repererCaracteresInvalidesNomFrancais($nom['nom_francais']));
309 delphine 1680
					$this->ajouterNumNomErreursTest($nom['num_nom']);
262 aurelien 1681
				}
1682
			}
1683
		}
1684
		return $noms_erreur;
1685
	}
264 aurelien 1686
 
1687
	/**
318 delphine 1688
	* Test #79
264 aurelien 1689
	*/
1690
	private function testerExclureTaxRefPresence() {
1691
		$noms_erreur = array();
1692
		foreach ($this->noms as &$nom) {
266 aurelien 1693
			// On vérifie tous les noms retenu nom exclus de taxref de rang inférieur ou égal à l'espèce
1694
			if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0 && $nom['rang'] >= 240) {
264 aurelien 1695
				if($nom['presence'] == '' || !$this->verifierPresence($nom['presence'])) {
1696
					if(($nom['statut_origine'] == '' || !$this->verifierStatutOrigine($nom['statut_origine'])) &&
1697
					   ($nom['statut_introduction'] == '' || !$this->verifierStatutIntroduction($nom['statut_introduction'])) &&
1698
					   ($nom['statut_culture'] == '' || !$this->verifierStatutCulture($nom['statut_culture'])))
1699
					{
1700
						$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'],
1701
												$this->mettreEnValeurAvertissement($nom['presence']),
1702
												$this->mettreEnValeurAvertissement($nom['statut_origine']),
1703
												$this->mettreEnValeurAvertissement($nom['statut_introduction']),
1704
												$this->mettreEnValeurAvertissement($nom['statut_culture'])
1705
										);
309 delphine 1706
						$this->ajouterNumNomErreursTest($nom['num_nom']);
264 aurelien 1707
					} else {
1708
						//TODO: le comportement est identique mais il faudrait pouvoir afficher un avertissement
1709
						// si le champ présence n'est pas rempli mais que l'une des colonne de statut l'est
1710
						$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'],
1711
												$nom['presence'],
1712
												$this->mettreEnValeurAvertissement($nom['statut_origine']),
1713
												$this->mettreEnValeurAvertissement($nom['statut_introduction']),
1714
												$this->mettreEnValeurAvertissement($nom['statut_culture'])
1715
										);
309 delphine 1716
						$this->ajouterNumNomErreursTest($nom['num_nom']);
264 aurelien 1717
					}
1718
				}
1719
			}
1720
		}
1721
		return $noms_erreur;
1722
	}
294 delphine 1723
 
171 jpm 1724
 
20 jpm 1725
	//+--------------------------------------------------------------------------------------------------------------+//
1726
	// MÉTHODES COMMUNES aux TESTS
1727
 
64 jpm 1728
	private function verifierPresence(&$valeur) {
20 jpm 1729
		$codes = $this->manuel['codes_presence'];
1730
		$ok = $this->verifierStatuts($valeur, $codes);
1731
		return $ok;
1732
	}
1733
 
64 jpm 1734
	private function verifierStatutOrigine(&$valeur) {
20 jpm 1735
		$codes = $this->manuel['codes_statuts_origine'];
1736
		$ok = $this->verifierStatuts($valeur, $codes);
1737
		return $ok;
1738
	}
1739
 
64 jpm 1740
	private function verifierStatutIntroduction(&$valeur) {
20 jpm 1741
		$codes = $this->manuel['codes_statuts_introduction'];
1742
		$ok = $this->verifierStatuts($valeur, $codes);
1743
		return $ok;
1744
	}
1745
 
64 jpm 1746
	private function verifierStatutCulture(&$valeur) {
20 jpm 1747
		$codes = $this->manuel['codes_statuts_culture'];
1748
		$ok = $this->verifierStatuts($valeur, $codes);
1749
		return $ok;
1750
	}
1751
 
64 jpm 1752
	private function verifierStatuts(&$valeur, &$codes) {
20 jpm 1753
		$ok = true;
1754
		if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
1755
			$ok = false;
1756
		}
1757
		return $ok;
1758
	}
1759
 
64 jpm 1760
	private function verifierBooleen(&$valeur) {
20 jpm 1761
		$ok = true;
1762
		if (!preg_match('/^1$/', $valeur)) {
1763
			$ok = false;
1764
		}
1765
		return $ok;
1766
	}
1767
 
64 jpm 1768
	private function verifierNombre(&$valeur) {
20 jpm 1769
		$ok = true;
1770
		if (!preg_match('/^[0-9]+$/', $valeur)) {
1771
			$ok = false;
1772
		}
1773
		return $ok;
1774
	}
1775
 
64 jpm 1776
	private function verifierNombreSuite(&$valeur) {
20 jpm 1777
		$ok = true;
259 delphine 1778
		if (!preg_match('/^(?:[0-9]+, ?)*[0-9]+$/', $valeur)) {
20 jpm 1779
			$ok = false;
1780
		}
1781
		return $ok;
1782
	}
1783
 
64 jpm 1784
	private function verifierTypeEpithete(&$type) {
20 jpm 1785
		$ok = false;
1786
		$rejetes = $this->manuel['type_epithete_rejetes'];
1787
		if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
1788
			$ok = false;
1789
		} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
1790
			$ok = true;
1791
		}
1792
		return $ok;
1793
	}
1794
 
64 jpm 1795
	private function verifierBiblioOrigine(&$intitule) {
20 jpm 1796
		$ok = true;
1797
		if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1798
			$ok = false;// Contient des espaces en trop
1799
		} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
1800
			$ok = false;
1801
		} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
1802
			$ok = false;// Contient une mauvaise suite de caractères
1803
		}
1804
		return $ok;
1805
	}
1806
 
64 jpm 1807
	private function verifierAnnee(&$annee) {
20 jpm 1808
		$ok = true;
1809
		if (!preg_match('/^[0-9]{4}$/', $annee)) {
1810
			$ok = false;
188 delphine 1811
		} else if ($annee < ANNEE_MINIMUM) {
20 jpm 1812
			$ok = false;
188 delphine 1813
		} else if ($annee > ANNEE_EN_COURS) {
186 delphine 1814
			$ok = false;
20 jpm 1815
		}
1816
		return $ok;
1817
	}
1818
 
64 jpm 1819
	private function verifierAuteur(&$intitule) {
20 jpm 1820
		$ok = true;
1821
		$acceptes = $this->manuel['auteur_acceptes'];
1822
		if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
1823
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1824
				$ok = false;// Contient des espaces en trop
1825
			} else {
1826
				$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
1827
				$mots = explode(' ', $intitule);
1828
				foreach ($mots as $position => $mot) {
1829
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1830
						$ok = false;// Mot rejeté
184 jpm 1831
					} else if (preg_match("/^(?:(?:\p{L}|[.'\(\),-])+|[&])$/u", $mot)) {
20 jpm 1832
						continue;// Mot de l'intitulé auteur
1833
					} else {
1834
						$ok = false;
1835
					}
1836
				}
1837
			}
1838
		}
1839
		return $ok;
1840
	}
1841
 
64 jpm 1842
	private function verifierNomCommercial(&$epithete) {
20 jpm 1843
		$ok = false;
1844
		if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
1845
			$ok = true;
1846
		}
1847
		return $ok;
1848
	}
1849
 
64 jpm 1850
	private function verifierEpitheteCultivar(&$epithete) {
20 jpm 1851
		$ok = true;
1852
		$acceptes = $this->manuel['cultivar_acceptes'];
1853
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1854
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1855
				$ok = false;// Contient des espaces en trop
1856
			} else {
1857
				$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
1858
				$mots_mineurs = $this->manuel['mots_mineurs'];
1859
				$mots = explode(' ', $epithete);
1860
				foreach ($mots as $position => $mot) {
1861
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1862
						$ok = false;// Mot rejeté
1863
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1864
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1865
					} else {
1866
						$mots_tiret = explode('-', $mot);
1867
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1868
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1869
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
1870
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1871
								continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
1872
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1873
								continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1874
							} else {
1875
								$ok = false;
1876
							}
1877
						}
1878
					}
1879
				}
1880
			}
1881
		}
1882
		return $ok;
1883
	}
1884
 
64 jpm 1885
	private function verifierEpitheteGroupeCultivar(&$epithete) {
20 jpm 1886
		$ok = true;
1887
		$acceptes = $this->manuel['cultivar_gp_acceptes'];
1888
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1889
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1890
				$ok = false;// Contient des espaces en trop
1891
			} else {
1892
				$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
1893
				$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
1894
				$mots_mineurs = $this->manuel['mots_mineurs'];
1895
				$mots = explode(' ', $epithete);
1896
				foreach ($mots as $position => $mot) {
1897
					if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
1898
						continue;// Mot accepté
1899
					} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1900
						$ok = false;// Mot rejeté
1901
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1902
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1903
					} else {
1904
						$mots_tiret = explode('-', $mot);
1905
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1906
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1907
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
1908
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1909
								continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
1910
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1911
								continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1912
							} else {
1913
								$ok = false;
1914
							}
1915
						}
1916
					}
1917
				}
1918
			}
1919
		}
1920
		return $ok;
1921
	}
1922
 
64 jpm 1923
	private function verifierEpitheteSp(&$epithete) {
20 jpm 1924
		$ok = false;
183 jpm 1925
		if (preg_match('/^[a-zäëḧïöẗüẅẍÿ][-a-zäëḧïöẗüẅẍÿ]+$/', $epithete)) {
20 jpm 1926
			$ok = true;
1927
		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
1928
			$ok = true;
1929
		}
1930
		return $ok;
1931
	}
1932
 
64 jpm 1933
	private function verifierEpitheteGenre(&$epithete) {
20 jpm 1934
		$ok = false;
183 jpm 1935
		if (preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ](?:[-a-zäëḧïöẗüẅẍÿ]+|[a-zäëḧïöẗüẅẍÿ]+-[A-ZÄËḦÏÖÜẄẌŸ][a-zäëḧïöẗüẅẍÿ]+)$/', $epithete)) {
20 jpm 1936
			$ok = true;
1937
		}
1938
		return $ok;
1939
	}
1940
 
254 aurelien 1941
	private function verifierEstAbbreviationInfraSp($mot) {
1942
		$ok = false;
1943
		if(preg_match($this->manuel['abbr_rangs_infra_specifique'], $mot)) {
1944
			$ok = true;
1945
		}
1946
		return $ok;
1947
	}
1948
 
64 jpm 1949
	private function formaterStyleNomGenre(&$genre) {
20 jpm 1950
		$genre_fmt = '';
1951
		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
192 delphine 1952
			$genre_fmt = utf8_encode(strtolower(utf8_decode($match[1]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[2]))));
194 delphine 1953
		} elseif (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $genre, $match)) {
1954
			$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.
1955
				utf8_encode(strtolower(utf8_decode($match[2]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[3]))));
20 jpm 1956
		} else {
192 delphine 1957
			$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($genre))));
20 jpm 1958
		}
1959
		return $genre_fmt;
1960
	}
1961
 
250 delphine 1962
	private function formaterStyleEpitheteSpHybride(&$genre, &$epithete) {
1963
		$nom_fmt = '';
1964
		$erreur = '';
1965
		if (trim($genre) == '') {
1966
			if ($epithete != '') {
1967
				$nom_fmt = $this->formaterFormuleHybridite($epithete);
1968
			} else {
1969
				$erreur = "Formule d'hybridité sans épithéte spécifique";
1970
			}
1971
		} else {
1972
			$nom_fmt = $this->formaterNomHybride($genre, $epithete);
1973
		}
1974
		return array($nom_fmt, $erreur);
1975
	}
1976
 
1977
	private function formaterStyleEpitheteInfraSpHybride(&$nom_sci, &$infra, &$genre = null) {
1978
		$nom_fmt = '';
1979
		$erreur = '';
1980
		if (trim($genre) == '') {
1981
			if (trim($nom_sci) == '') {
1982
				if (trim($infra) != '') {
1983
					$nom_fmt = $this->formaterFormuleHybridite($infra);
1984
				} else {
1985
					$erreur = "Formule d'hybridité sans épithéte infraspécifique";
1986
				}
1987
			} else {
1988
				$erreur = "Formule d'hybridité avec épithéte spécifique";
1989
			}
1990
		} else {
1991
			$nom_fmt = $this->formaterNomHybride($nom_sci, $infra);
1992
		}
1993
		return array($nom_fmt, $erreur);
1994
	}
1995
 
1996
	private function formaterNomHybride(&$nom_sci, &$epithete) {
1997
		if (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $epithete, $match) != '') {
1998
			$nom_fmt = $nom_sci.utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.
1999
				utf8_encode(strtolower(utf8_decode($match[2]))).' '.
2000
				utf8_encode(ucfirst(strtolower(utf8_decode($match[3]))));
2001
		} elseif (preg_match('/^([x+])\s+(.+)$/i', $epithete, $match) != '') {
2002
			$nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($match[1]))).' '.
2003
				utf8_encode(strtolower(utf8_decode($match[2])));
2004
		} else {
2005
			$nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($epithete)));
2006
		}
2007
		return $nom_fmt;
2008
	}
2009
 
2010
	private function formaterFormuleHybridite(&$epithete) {
2011
		$liste_parents = explode(' x ', $epithete);
2012
		if (count($liste_parents) == 2) {
2013
			$nom_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[0])))).' x '.
2014
			utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[1]))));
2015
		} else {
2016
			for ($i=0; $i<count($liste_parents); $i++) {
2017
				if (strstr(trim($liste_parents[$i]), ' ') == false) {
2018
					$nom[] = utf8_encode(ucfirst(strtolower(utf8_decode(trim($liste_parents[$i]))))).' x '.
2019
					utf8_encode(strtolower(utf8_decode(trim($liste_parents[$i+1]))));
2020
					$i++;
2021
				} else {
2022
					$nom[] = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[$i]))));
2023
				}
2024
			}
2025
			$nom_fmt = implode(' x ', $nom);
2026
		}
2027
		return $nom_fmt;
2028
	}
2029
 
149 jpm 2030
	private function repererEspace($nom_sci) {
2031
		$nom_sci = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_sci);
2032
		return $nom_sci;
20 jpm 2033
	}
2034
 
263 aurelien 2035
	private function repererCaracteresInvalidesNomFrancais($nom_verna) {
262 aurelien 2036
		$nom_verna = str_replace(',', '<span class="espace">,</span>', $nom_verna);
2037
		$nom_verna = str_replace(';', '<span class="espace">;</span>', $nom_verna);
2038
		return $nom_verna;
2039
	}
2040
 
264 aurelien 2041
	private function mettreEnValeurAvertissement($chaine) {
2042
		$chaine = '<span class="espace">'.$chaine.'</span>';
2043
		return $chaine;
2044
	}
2045
 
64 jpm 2046
	private function construireSuffixeNomPltCultivee(&$nom) {
20 jpm 2047
		$suffixe = array();
2048
		$suffixe[] = $this->construireNomCultivarGroupe($nom);
2049
		$suffixe[] = $this->construireNomCommercial($nom);
2050
		$suffixe[] = $this->construireNomCultivar($nom);
2051
		$suffixe = array_filter($suffixe);
2052
		return implode(' ', $suffixe);
2053
	}
2054
 
64 jpm 2055
	private function construireNomCultivarGroupe(&$nom) {
20 jpm 2056
		$nom_groupe_cultivar = '';
2057
		if ($nom['cultivar_groupe'] != '') {
2058
			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
2059
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
2060
			} else {
2061
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
2062
			}
2063
		}
2064
		return $nom_groupe_cultivar;
2065
	}
2066
 
64 jpm 2067
	private function construireNomCommercial(&$nom) {
20 jpm 2068
		$nom_commercial = '';
2069
		if ($nom['nom_commercial'] != '') {
2070
			$nom_commercial =  strtoupper($nom['nom_commercial']);
2071
		}
2072
		return $nom_commercial;
2073
	}
2074
 
64 jpm 2075
	private function construireNomCultivar(&$nom) {
20 jpm 2076
		$nom_cultivar = '';
2077
		if ($nom['cultivar'] != '') {
2078
			$nom_cultivar =  "'".$nom['cultivar']."'";
2079
		}
2080
		return $nom_cultivar;
2081
	}
2082
 
64 jpm 2083
	private function classerNomsParNomComplet() {
20 jpm 2084
		$noms_classes = array();
64 jpm 2085
		foreach ($this->noms as &$nom) {
149 jpm 2086
			if (!isset($noms_classes[$nom['nom_sci']])) {
2087
				$noms_classes[$nom['nom_sci']] = 1;
20 jpm 2088
			} else {
149 jpm 2089
				$noms_classes[$nom['nom_sci']]++;
20 jpm 2090
			}
2091
		}
2092
		return $noms_classes;
2093
	}
2094
}
2095
?>