Subversion Repositories Applications.referentiel

Rev

Rev 344 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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