Subversion Repositories Applications.referentiel

Rev

Rev 18 | Rev 23 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 18 Rev 20
Line 39... Line 39...
39 
	// Méthodes
 39 
	// Méthodes
40 
	/**
 40 
	/**
41 
	 * Fonction d'affichage par défaut, elle appelle la liste des administrateurs
 41 
	 * Fonction d'affichage par défaut, elle appelle la liste des administrateurs
42 
	 */
 42 
	 */
43 
	public function executerActionParDefaut() {
 43 
	public function executerActionParDefaut() {
44 
		return $this->lancerTest();
 44 
		return '';
45 
	}
 45 
	}
Line 46... Line -...
46
- 
 
47 
	public function lancerTest() {
 - 
 
48 
		$donnees = array();
 - 
 
49 
		$donnees['tests'] = array();
 - 
 
50 
		/*
- 
 
51 
		// Récupération des données à tester
 - 
 
52 
		$colonnes = $this->tableStructureDao->getColonnes($this->projet);
 - 
 
53 
		$analyses = $this->tableStructureDao->getAnalyse($this->projet);
 - 
 
54 
		$noms = $this->referentielDao->getTout($this->projet);
 - 
 
55 
		$noms = $this->classerNomsParNumNom($noms);
 - 
 
56 
		$noms_homonymie = $this->classerNomsParNomComplet($noms);
 - 
 
57
- 
 
58 
		// Lancement des tests unitaires
 - 
 
59 
		$donnees['tests'][] = $this->testerNombreDeChamps($colonnes);
 - 
 
60 
		$donnees['tests'][] = $this->testerNomDesChamps($colonnes);
 - 
 
61 
		$donnees['tests'][] = $this->testerTypeDesChamps($colonnes);
 - 
 
62 
		$donnees['tests'][] = $this->testerTailleDesChamps($colonnes, $analyses);
 - 
 
63 
		$donnees['tests'][] = $this->testerNumNomClePrimaire($colonnes);
 - 
 
64
- 
 
65 
		$donnees['tests'][] = $this->testerNumNomSuperieurAZero($noms);
 - 
 
66
- 
 
67 
		$donnees['tests'][] = $this->testerNumNomRetenuSuperieurAZero($noms);
 - 
 
68 
		$donnees['tests'][] = $this->testerNumTaxSupEgalZeroUnique($noms);
 - 
 
69 
		$donnees['tests'][] = $this->testerTaxSupPourTaxon($noms);
 - 
 
70 
		$donnees['tests'][] = $this->testerExitenceTaxonSuperieur($noms);
 - 
 
71 
		$donnees['tests'][] = $this->testerClassificationRang($noms);
- 
 
72 
		$donnees['tests'][] = $this->testerClassification($noms);
 - 
 
73
- 
 
74 
		$donnees['tests'][] = $this->testerRang($noms);
 - 
 
75
- 
 
76 
		$donnees['tests'][] = $this->testerNomCompletSupraGenerique($noms);
 - 
 
77 
		$donnees['tests'][] = $this->testerNomCompletGenre($noms);
 - 
 
78 
		$donnees['tests'][] = $this->testerNomCompletInfraGenre($noms);
 - 
 
79 
		$donnees['tests'][] = $this->testerNomCompletEspece($noms);
 - 
 
80 
		$donnees['tests'][] = $this->testerNomCompletInfraSpecifique($noms);
 - 
 
81 
 
 - 
 
82 
		$donnees['tests'][] = $this->testerNomSupraGeneriqueEspaces($noms);
 - 
 
83 
		$donnees['tests'][] = $this->testerNomSupraGeneriqueSyntaxe($noms);
 - 
 
84 
		$donnees['tests'][] = $this->testerNomSupraGeneriqueRang($noms);
 - 
 
85
- 
 
86 
		$donnees['tests'][] = $this->testerGenreEspaces($noms);
 - 
 
87 
		$donnees['tests'][] = $this->testerGenreSyntaxe($noms);
 - 
 
88 
		$donnees['tests'][] = $this->testerGenreRang($noms);
 - 
 
89
- 
 
90 
		$donnees['tests'][] = $this->testerEpitheteInfraGeneriqueEspaces($noms);
 - 
 
91 
		$donnees['tests'][] = $this->testerEpitheteInfraGeneriqueSyntaxe($noms);
 - 
 
92 
		$donnees['tests'][] = $this->testerEpitheteInfraGeneriqueRang($noms);
 - 
 
93
- 
 
94 
		$donnees['tests'][] = $this->testerEpitheteSpEspaces($noms);
 - 
 
95 
		$donnees['tests'][] = $this->testerEpitheteSpSyntaxe($noms);
 - 
 
96 
		$donnees['tests'][] = $this->testerEpitheteSpRang($noms);
 - 
 
97
- 
 
98 
		$donnees['tests'][] = $this->testerTypeEpitheteEspaces($noms);
 - 
 
99 
		$donnees['tests'][] = $this->testerTypeEpitheteSyntaxe($noms);
 - 
 
100 
		$donnees['tests'][] = $this->testerTypeEpitheteHybridite($noms);
 - 
 
101
- 
 
102 
		$donnees['tests'][] = $this->testerEpitheteInfraSpEspaces($noms);
 - 
 
103 
		$donnees['tests'][] = $this->testerEpitheteInfraSpSyntaxe($noms);
 - 
 
104 
		$donnees['tests'][] = $this->testerEpitheteInfraSpRang($noms);
 - 
 
105
- 
 
106 
		$donnees['tests'][] = $this->testerGroupeCultivarSyntaxe($noms);
 - 
 
107 
		$donnees['tests'][] = $this->testerGroupeCultivarRang($noms);
- 
 
108
- 
 
109 
		$donnees['tests'][] = $this->testerCultivarSyntaxe($noms);
 - 
 
110 
		$donnees['tests'][] = $this->testerCultivarRang($noms);
 - 
 
111
- 
 
112 
		$donnees['tests'][] = $this->testerNomCommercialSyntaxe($noms);
 - 
 
113 
		$donnees['tests'][] = $this->testerNomCommercialPresenceCultivar($noms);
 - 
 
114
- 
 
115 
		$donnees['tests'][] = $this->testerAuteurSyntaxe($noms);
 - 
 
116
- 
 
117 
		$donnees['tests'][] = $this->testerAnneeSyntaxe($noms);
 - 
 
118
- 
 
119 
		$donnees['tests'][] = $this->testerBiblioOrigineSyntaxe($noms);
 - 
 
120
- 
 
121 
		$donnees['tests'][] = $this->testerHomonymieSyntaxe($noms);
 - 
 
122 
		$donnees['tests'][] = $this->testerHomonymieExistence($noms, $noms_homonymie);
 - 
 
123
- 
 
124 
		$donnees['tests'][] = $this->testerBasionymeSyntaxe($noms);
 - 
 
125 
		$donnees['tests'][] = $this->testerBasionymeExistence($noms);
 - 
 
126
- 
 
127 
		$donnees['tests'][] = $this->testerSynonymeProparteSyntaxe($noms);
 - 
 
128 
		$donnees['tests'][] = $this->testerSynonymeProparteExistence($noms);
 - 
 
129
- 
 
130 
		$donnees['tests'][] = $this->testerSynonymeDouteuxSyntaxe($noms);
 - 
 
131
- 
 
132 
		$donnees['tests'][] = $this->testerSynonymeMalAppliqueSyntaxe($noms);
 - 
 
133
- 
 
134 
		$donnees['tests'][] = $this->testerSynonymeOrthographiqueSyntaxe($noms);
 - 
 
135 
		$donnees['tests'][] = $this->testerSynonymeOrthographiqueExistence($noms);
 - 
 
136
- 
 
137 
		$donnees['tests'][] = $this->testerHybrideParent01Syntaxe($noms);
 - 
 
138 
		$donnees['tests'][] = $this->testerHybrideParent01Existence($noms);
 - 
 
139 
		$donnees['tests'][] = $this->testerHybrideParent02Syntaxe($noms);
 - 
 
140 
		$donnees['tests'][] = $this->testerHybrideParent02Existence($noms);
 - 
 
141
- 
 
142 
		$donnees['tests'][] = $this->testerPresenceSyntaxe($noms);
 - 
 
143 
		$donnees['tests'][] = $this->testerStatutOrigineSyntaxe($noms);
 - 
 
144 
		$donnees['tests'][] = $this->testerStatutIntroductionSyntaxe($noms);
 - 
 
145 
		$donnees['tests'][] = $this->testerStatutCultureSyntaxe($noms);
 - 
 
146 
		*/
 - 
 
147
- 
 
148 
		//Debug::printr($this->manuel);
 - 
 
149 
		$this->setSortie(self::RENDU_CORPS, $this->getVue('test', $donnees));
- 
 
150 
	}
 - 
 
151
- 
 
152 
	//+--------------------------------------------------------------------------------------------------------------+//
 - 
 
153 
	// TESTS
 - 
 
154
- 
 
155 
	private function testerStatutCultureSyntaxe($noms) {
 - 
 
156 
		$info = array('titre' => 'statut_culture -> syntaxe',
 - 
 
157 
			'description' => "Le champ statut_culture peut contenir :\n".
 - 
 
158 
			" - le symbole tiret «-» une autre information non référencée...\n".
 - 
 
159 
			" - une première lettre en majuscule indiquant le code standard attribué à ce taxon.\n".
 - 
 
160 
			" - Cette première lettre peut être suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant ".
 - 
 
161 
			"un code de présence spécifique au référentiel.",
 - 
 
162 
			'resultat' => false);
 - 
 
163
- 
 
164 
		// Réalisation du test
 - 
 
165 
		$noms_erreur = array();
 - 
 
166 
		foreach ($noms as $nom) {
 - 
 
167 
			if ($nom['statut_culture'] != '') {
 - 
 
168 
				if (!$this->verifierStatutCulture($nom['statut_culture'])) {
 - 
 
169 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture']);
 - 
 
170 
				}
 - 
 
171 
			}
 - 
 
172 
		}
 - 
 
173
- 
 
174 
		// Analyse des résultats
 - 
 
175 
		if (count($noms_erreur) > 0) {
 - 
 
176 
			$info['message']['entete'] = array('num_nom', 'statut_culture erroné');
 - 
 
177 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
178 
		} else {
 - 
 
179 
			$info['resultat'] = true;
 - 
 
180 
		}
 - 
 
181
- 
 
182 
		return $info;
 - 
 
183 
	}
 - 
 
184
- 
 
185 
	private function testerStatutIntroductionSyntaxe($noms) {
 - 
 
186 
		$info = array('titre' => 'statut_introduction -> syntaxe',
 - 
 
187 
			'description' => "Le champ statut_introduction peut contenir :\n".
 - 
 
188 
			" - le symbole tiret «-» une autre information non référencée...\n".
 - 
 
189 
			" - une première lettre en majuscule indiquant le code standard attribué à ce taxon.\n".
 - 
 
190 
			" - Cette première lettre peut être suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant ".
 - 
 
191 
			"un code de présence spécifique au référentiel.",
 - 
 
192 
			'resultat' => false);
 - 
 
193
- 
 
194 
		// Réalisation du test
 - 
 
195 
		$noms_erreur = array();
 - 
 
196 
		foreach ($noms as $nom) {
 - 
 
197 
			if ($nom['statut_introduction'] != '') {
 - 
 
198 
				if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
 - 
 
199 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction']);
 - 
 
200 
				}
 - 
 
201 
			}
 - 
 
202 
		}
 - 
 
203
- 
 
204 
		// Analyse des résultats
 - 
 
205 
		if (count($noms_erreur) > 0) {
 - 
 
206 
			$info['message']['entete'] = array('num_nom', 'statut_introduction erroné');
 - 
 
207 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
208 
		} else {
 - 
 
209 
			$info['resultat'] = true;
 - 
 
210 
		}
 - 
 
211
- 
 
212 
		return $info;
 - 
 
213 
	}
 - 
 
214
- 
 
215 
	private function testerStatutOrigineSyntaxe($noms) {
 - 
 
216 
		$info = array('titre' => 'statut_origine -> syntaxe',
 - 
 
217 
			'description' => "Le champ statut_origine peut contenir :\n".
 - 
 
218 
			" - le symbole tiret «-» une autre information non référencée...\n".
 - 
 
219 
			" - une première lettre en majuscule indiquant le code standard attribué à ce taxon.\n".
 - 
 
220 
			" - Cette première lettre peut être suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant ".
 - 
 
221 
			"un code de présence spécifique au référentiel.",
 - 
 
222 
			'resultat' => false);
 - 
 
223
- 
 
224 
		// Réalisation du test
 - 
 
225 
		$noms_erreur = array();
 - 
 
226 
		foreach ($noms as $nom) {
 - 
 
227 
			if ($nom['statut_origine'] != '') {
 - 
 
228 
				if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
 - 
 
229 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine']);
 - 
 
230 
				}
 - 
 
231 
			}
 - 
 
232 
		}
 - 
 
233
- 
 
234 
		// Analyse des résultats
 - 
 
235 
		if (count($noms_erreur) > 0) {
 - 
 
236 
			$info['message']['entete'] = array('num_nom', 'statut_origine erroné');
 - 
 
237 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
238 
		} else {
 - 
 
239 
			$info['resultat'] = true;
 - 
 
240 
		}
 - 
 
241
- 
 
242 
		return $info;
 - 
 
243 
	}
 - 
 
244
- 
 
245 
	private function testerPresenceSyntaxe($noms) {
 - 
 
246 
		$info = array('titre' => 'presence -> syntaxe',
 - 
 
247 
			'description' => "Le champ presence contient soit :\n".
 - 
 
248 
			" - le symbole tiret «-» une autre information non référencée...\n".
 - 
 
249 
			" - une première lettre en majuscule indiquant le code standard attribué à ce taxon.\n".
 - 
 
250 
			" - Cette première lettre peut être suivie d'un tiret puis d'une deuxième lettre en majuscule indiquant ".
 - 
 
251 
			"un code de présence spécifique au référentiel.",
 - 
 
252 
			'resultat' => false);
 - 
 
253
- 
 
254 
		// Réalisation du test
 - 
 
255 
		$noms_erreur = array();
 - 
 
256 
		foreach ($noms as $nom) {
 - 
 
257 
			if ($nom['presence'] != '') {
 - 
 
258 
				if (!$this->verifierPresence($nom['presence'])) {
 - 
 
259 
					$noms_erreur[] = array($nom['num_nom'], $nom['presence']);
 - 
 
260 
				}
 - 
 
261 
			}
 - 
 
262 
		}
 - 
 
263
- 
 
264 
		// Analyse des résultats
 - 
 
265 
		if (count($noms_erreur) > 0) {
 - 
 
266 
			$info['message']['entete'] = array('num_nom', 'presence erroné');
 - 
 
267 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
268 
		} else {
 - 
 
269 
			$info['resultat'] = true;
 - 
 
270 
		}
 - 
 
271
- 
 
272 
		return $info;
 - 
 
273 
	}
 - 
 
274
- 
 
275 
	private function testerHybrideParent02Existence($noms) {
 - 
 
276 
		$info = array('titre' => 'hybride_parent_02 -> existence',
 - 
 
277 
			'description' => "Si le champ hybride_parent_02 contient un nombre alors il doit correspondre à une valeur du champ ".
 - 
 
278 
			"num_nom.",
 - 
 
279 
			'resultat' => false);
 - 
 
280
- 
 
281 
		// Réalisation du test
 - 
 
282 
		$noms_erreur = array();
 - 
 
283 
		foreach ($noms as $nom) {
 - 
 
284 
			if ($nom['hybride_parent_02'] != '') {
 - 
 
285 
				if (!isset($noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
 - 
 
286 
					$noms_erreur[] = array($nom['num_nom'], $nom['hybride_parent_02']);
 - 
 
287 
				}
 - 
 
288 
			}
 - 
 
289 
		}
 - 
 
290
- 
 
291 
		// Analyse des résultats
 - 
 
292 
		if (count($noms_erreur) > 0) {
 - 
 
293 
			$info['message']['entete'] = array('num_nom', 'hybride_parent_02 introuvable');
 - 
 
294 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
295 
		} else {
 - 
 
296 
			$info['resultat'] = true;
 - 
 
297 
		}
 - 
 
298
- 
 
299 
		return $info;
 - 
 
300 
	}
 - 
 
301
- 
 
302 
	private function testerHybrideParent02Syntaxe($noms) {
 - 
 
303 
		$info = array('titre' => 'hybride_parent_02 -> syntaxe',
 - 
 
304 
			'description' => "Le champ hybride_parent_02 contient soit :\n".
 - 
 
305 
			" - une valeur vide.\n".
 - 
 
306 
			" - un nombre",
 - 
 
307 
			'resultat' => false);
 - 
 
308
- 
 
309 
		// Réalisation du test
 - 
 
310 
		$noms_erreur = array();
 - 
 
311 
		foreach ($noms as $nom) {
 - 
 
312 
			if ($nom['hybride_parent_02'] != '') {
 - 
 
313 
				if (!$this->verifierNombre($nom['hybride_parent_02'])) {
 - 
 
314 
					$noms_erreur[] = array($nom['num_nom'], $nom['hybride_parent_02']);
 - 
 
315 
				}
 - 
 
316 
			}
 - 
 
317 
		}
 - 
 
318
- 
 
319 
		// Analyse des résultats
 - 
 
320 
		if (count($noms_erreur) > 0) {
 - 
 
321 
			$info['message']['entete'] = array('num_nom', 'hybride_parent_02 erroné');
 - 
 
322 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
323 
		} else {
 - 
 
324 
			$info['resultat'] = true;
 - 
 
325 
		}
 - 
 
326
- 
 
327 
		return $info;
 - 
 
328 
	}
 - 
 
329
- 
 
330
- 
 
331 
	private function testerHybrideParent01Existence($noms) {
 - 
 
332 
		$info = array('titre' => 'hybride_parent_01 -> existence',
 - 
 
333 
			'description' => "Si le champ hybride_parent_01 contient un nombre alors il doit correspondre à une valeur du champ ".
 - 
 
334 
			"num_nom.",
 - 
 
335 
			'resultat' => false);
 - 
 
336
- 
 
337 
		// Réalisation du test
 - 
 
338 
		$noms_erreur = array();
 - 
 
339 
		foreach ($noms as $nom) {
 - 
 
340 
			if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
 - 
 
341 
				if (!isset($noms[$nom['hybride_parent_01']])) {
 - 
 
342 
					$noms_erreur[] = array($nom['num_nom'], $nom['hybride_parent_01']);
 - 
 
343 
				}
 - 
 
344 
			}
 - 
 
345 
		}
 - 
 
346
- 
 
347 
		// Analyse des résultats
 - 
 
348 
		if (count($noms_erreur) > 0) {
 - 
 
349 
			$info['message']['entete'] = array('num_nom', 'hybride_parent_01 introuvable');
 - 
 
350 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
351 
		} else {
 - 
 
352 
			$info['resultat'] = true;
 - 
 
353 
		}
 - 
 
354
- 
 
355 
		return $info;
 - 
 
356 
	}
 - 
 
357
- 
 
358 
	private function testerHybrideParent01Syntaxe($noms) {
 - 
 
359 
		$info = array('titre' => 'hybride_parent_01 -> syntaxe',
 - 
 
360 
			'description' => "Le champ hybride_parent_01 contient soit :\n".
 - 
 
361 
			" - une valeur vide.\n".
 - 
 
362 
			" - un nombre",
 - 
 
363 
			'resultat' => false);
 - 
 
364
- 
 
365 
		// Réalisation du test
 - 
 
366 
		$noms_erreur = array();
 - 
 
367 
		foreach ($noms as $nom) {
 - 
 
368 
			if ($nom['hybride_parent_01'] != '') {
 - 
 
369 
				if (!$this->verifierNombre($nom['hybride_parent_01'])) {
 - 
 
370 
					$noms_erreur[] = array($nom['num_nom'], $nom['hybride_parent_01']);
 - 
 
371 
				}
 - 
 
372 
			}
 - 
 
373 
		}
 - 
 
374
- 
 
375 
		// Analyse des résultats
 - 
 
376 
		if (count($noms_erreur) > 0) {
 - 
 
377 
			$info['message']['entete'] = array('num_nom', 'hybride_parent_01 erroné');
 - 
 
378 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
379 
		} else {
 - 
 
380 
			$info['resultat'] = true;
 - 
 
381 
		}
 - 
 
382
- 
 
383 
		return $info;
 - 
 
384 
	}
 - 
 
385
- 
 
386 
	private function testerSynonymeOrthographiqueExistence($noms) {
 - 
 
387 
		$info = array('titre' => 'synonyme_orthographique -> existence',
 - 
 
388 
			'description' => "Si le champ synonyme_orthographique contient un nombre alors il doit correspondre à une valeur du champ ".
 - 
 
389 
			"num_nom.",
 - 
 
390 
			'resultat' => false);
 - 
 
391
- 
 
392 
		// Réalisation du test
 - 
 
393 
		$noms_erreur = array();
 - 
 
394 
		foreach ($noms as $nom) {
 - 
 
395 
			if ($nom['synonyme_orthographique'] != '') {
 - 
 
396 
				if (!isset($noms[$nom['synonyme_orthographique']])) {
 - 
 
397 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique']);
 - 
 
398 
				}
 - 
 
399 
			}
 - 
 
400 
		}
 - 
 
401
- 
 
402 
		// Analyse des résultats
 - 
 
403 
		if (count($noms_erreur) > 0) {
 - 
 
404 
			$info['message']['entete'] = array('num_nom', 'synonyme_orthographique introuvable');
 - 
 
405 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
406 
		} else {
 - 
 
407 
			$info['resultat'] = true;
 - 
 
408 
		}
 - 
 
409
- 
 
410 
		return $info;
 - 
 
411 
	}
 - 
 
412
- 
 
413 
	private function testerSynonymeOrthographiqueSyntaxe($noms) {
 - 
 
414 
		$info = array('titre' => 'synonyme_orthographique -> syntaxe',
 - 
 
415 
			'description' => "Le champ synonyme_orthographique contient soit :\n".
 - 
 
416 
			" - une valeur vide.\n".
 - 
 
417 
			" - un nombre",
 - 
 
418 
			'resultat' => false);
 - 
 
419
- 
 
420 
		// Réalisation du test
 - 
 
421 
		$noms_erreur = array();
 - 
 
422 
		foreach ($noms as $nom) {
 - 
 
423 
			if ($nom['synonyme_orthographique'] != '') {
 - 
 
424 
				if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
 - 
 
425 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique']);
 - 
 
426 
				}
 - 
 
427 
			}
 - 
 
428 
		}
 - 
 
429
- 
 
430 
		// Analyse des résultats
 - 
 
431 
		if (count($noms_erreur) > 0) {
 - 
 
432 
			$info['message']['entete'] = array('num_nom', 'synonyme_orthographique erroné');
 - 
 
433 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
434 
		} else {
 - 
 
435 
			$info['resultat'] = true;
 - 
 
436 
		}
 - 
 
437
- 
 
438 
		return $info;
 - 
 
439 
	}
 - 
 
440
- 
 
441 
	private function testerSynonymeMalAppliqueSyntaxe($noms) {
 - 
 
442 
		$info = array('titre' => 'synonyme_mal_applique -> syntaxe',
 - 
 
443 
			'description' => "Le champ synonyme_mal_applique contient soit :\n".
 - 
 
444 
			" - une valeur vide.\n".
 - 
 
445 
			" - le chiffre 1",
 - 
 
446 
			'resultat' => false);
 - 
 
447
- 
 
448 
		// Réalisation du test
 - 
 
449 
		$noms_erreur = array();
 - 
 
450 
		foreach ($noms as $nom) {
 - 
 
451 
			if ($nom['synonyme_mal_applique'] != '') {
 - 
 
452 
				if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
 - 
 
453 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique']);
 - 
 
454 
				}
 - 
 
455 
			}
 - 
 
456 
		}
 - 
 
457
- 
 
458 
		// Analyse des résultats
 - 
 
459 
		if (count($noms_erreur) > 0) {
 - 
 
460 
			$info['message']['entete'] = array('num_nom', 'synonyme_mal_applique erroné');
 - 
 
461 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
462 
		} else {
 - 
 
463 
			$info['resultat'] = true;
 - 
 
464 
		}
 - 
 
465
- 
 
466 
		return $info;
 - 
 
467 
	}
 - 
 
468
- 
 
469 
	private function testerSynonymeDouteuxSyntaxe($noms) {
 - 
 
470 
		$info = array('titre' => 'synonyme_douteux -> syntaxe',
 - 
 
471 
			'description' => "Le champ synonyme_douteux contient soit :\n".
 - 
 
472 
			" - une valeur vide.\n".
 - 
 
473 
			" - le chiffre 1",
 - 
 
474 
			'resultat' => false);
 - 
 
475
- 
 
476 
		// Réalisation du test
 - 
 
477 
		$noms_erreur = array();
 - 
 
478 
		foreach ($noms as $nom) {
 - 
 
479 
			if ($nom['synonyme_douteux'] != '') {
 - 
 
480 
				if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
 - 
 
481 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux']);
 - 
 
482 
				}
 - 
 
483 
			}
 - 
 
484 
		}
 - 
 
485
- 
 
486 
		// Analyse des résultats
 - 
 
487 
		if (count($noms_erreur) > 0) {
 - 
 
488 
			$info['message']['entete'] = array('num_nom', 'synonyme_douteux erroné');
 - 
 
489 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
490 
		} else {
 - 
 
491 
			$info['resultat'] = true;
 - 
 
492 
		}
 - 
 
493
- 
 
494 
		return $info;
 - 
 
495 
	}
 - 
 
496
- 
 
497 
	private function testerSynonymeProparteExistence($noms) {
 - 
 
498 
		$info = array('titre' => 'synonyme_proparte -> existence',
 - 
 
499 
			'description' => "Si le champ synonyme_proparte contient un ou plusieurs nombres alors chacun d'entre eux ".
 - 
 
500 
			"doit correspondre à une valeur du champ num_nom.",
 - 
 
501 
			'resultat' => false);
 - 
 
502
- 
 
503 
		// Réalisation du test
 - 
 
504 
		$noms_erreur = array();
 - 
 
505 
		foreach ($noms as $nom) {
 - 
 
506 
			if ($nom['synonyme_proparte'] != '') {
 - 
 
507 
				$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
 - 
 
508 
				$num_nom_en_erreur = array();
 - 
 
509 
				foreach ($num_nom_a_verifier as $num_nom) {
 - 
 
510 
					if (!isset($noms[$num_nom])) {
 - 
 
511 
						$num_nom_en_erreur[] = $num_nom;
 - 
 
512 
					}
 - 
 
513 
				}
 - 
 
514 
				if (count($nbre_en_erreur) > 0) {
 - 
 
515 
					$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur));
 - 
 
516 
				}
 - 
 
517 
			}
 - 
 
518 
		}
 - 
 
519
- 
 
520 
		// Analyse des résultats
 - 
 
521 
		if (count($noms_erreur) > 0) {
 - 
 
522 
			$info['message']['entete'] = array('num_nom', 'synonyme_proparte introuvable');
 - 
 
523 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
524 
		} else {
 - 
 
525 
			$info['resultat'] = true;
 - 
 
526 
		}
 - 
 
527
- 
 
528 
		return $info;
 - 
 
529 
	}
 - 
 
530
- 
 
531 
	private function testerSynonymeProparteSyntaxe($noms) {
 - 
 
532 
		$info = array('titre' => 'synonyme_proparte -> syntaxe',
 - 
 
533 
			'description' => "Le champ synonyme_proparte contient soit :\n".
 - 
 
534 
			" - une valeur vide.\n".
 - 
 
535 
			" - un nombre.\n".
 - 
 
536 
			" - une suite de nombre séparés par des virgules.",
 - 
 
537 
			'resultat' => false);
 - 
 
538
- 
 
539 
		// Réalisation du test
 - 
 
540 
		$noms_erreur = array();
 - 
 
541 
		foreach ($noms as $nom) {
 - 
 
542 
			if ($nom['synonyme_proparte'] != '') {
 - 
 
543 
				if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
 - 
 
544 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte']);
 - 
 
545 
				}
 - 
 
546 
			}
 - 
 
547 
		}
 - 
 
548
- 
 
549 
		// Analyse des résultats
 - 
 
550 
		if (count($noms_erreur) > 0) {
 - 
 
551 
			$info['message']['entete'] = array('num_nom', 'synonyme_proparte erroné');
 - 
 
552 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
553 
		} else {
 - 
 
554 
			$info['resultat'] = true;
 - 
 
555 
		}
 - 
 
556
- 
 
557 
		return $info;
 - 
 
558 
	}
 - 
 
559
- 
 
560 
	private function testerBasionymeExistence($noms) {
 - 
 
561 
		$info = array('titre' => 'basionyme -> existence',
 - 
 
562 
			'description' => "Si le champ basionyme contient un nombre alors il doit correspondre à une valeur du champ ".
 - 
 
563 
			"num_nom.",
 - 
 
564 
			'resultat' => false);
 - 
 
565
- 
 
566 
		// Réalisation du test
 - 
 
567 
		$noms_erreur = array();
 - 
 
568 
		foreach ($noms as $nom) {
 - 
 
569 
			if ($nom['basionyme'] != '') {
 - 
 
570 
				if (!isset($noms[$nom['basionyme']])) {
 - 
 
571 
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme']);
 - 
 
572 
				}
 - 
 
573 
			}
 - 
 
574 
		}
 - 
 
575
- 
 
576 
		// Analyse des résultats
 - 
 
577 
		if (count($noms_erreur) > 0) {
 - 
 
578 
			$info['message']['entete'] = array('num_nom', 'basionyme introuvable');
 - 
 
579 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
580 
		} else {
 - 
 
581 
			$info['resultat'] = true;
 - 
 
582 
		}
 - 
 
583
- 
 
584 
		return $info;
 - 
 
585 
	}
 - 
 
586
- 
 
587 
	private function testerBasionymeSyntaxe($noms) {
 - 
 
588 
		$info = array('titre' => 'basionyme -> syntaxe',
 - 
 
589 
			'description' => "Le champ basionyme contient :\n".
 - 
 
590 
			" - un nombre ou une valeur vide.\n",
 - 
 
591 
			'resultat' => false);
 - 
 
592
- 
 
593 
		// Réalisation du test
 - 
 
594 
		$noms_erreur = array();
 - 
 
595 
		foreach ($noms as $nom) {
 - 
 
596 
			if ($nom['basionyme'] != '') {
 - 
 
597 
				if (!$this->verifierNombre($nom['basionyme'])) {
 - 
 
598 
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme']);
 - 
 
599 
				}
 - 
 
600 
			}
 - 
 
601 
		}
 - 
 
602
- 
 
603 
		// Analyse des résultats
 - 
 
604 
		if (count($noms_erreur) > 0) {
 - 
 
605 
			$info['message']['entete'] = array('num_nom', 'basionyme erroné');
 - 
 
606 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
607 
		} else {
 - 
 
608 
			$info['resultat'] = true;
 - 
 
609 
		}
 - 
 
610
- 
 
611 
		return $info;
 - 
 
612 
	}
 - 
 
613
- 
 
614 
	private function testerHomonymieExistence($noms, $noms_homonymie) {
 - 
 
615 
		$info = array('titre' => 'homonyme -> existence',
 - 
 
616 
			'description' => "Si le champ homonyme contient «1» alors plusieurs noms doivent posséder la même valeur ".
 - 
 
617 
			"dans le champ nom_complet.",
 - 
 
618 
			'resultat' => false);
 - 
 
619
- 
 
620 
		// Réalisation du test
 - 
 
621 
		$noms_erreur = array();
 - 
 
622 
		foreach ($noms as $nom) {
 - 
 
623 
			if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
 - 
 
624 
				if ($noms_homonymie[$nom['nom_complet']] <= 1) {
 - 
 
625 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet']);
 - 
 
626 
				}
 - 
 
627 
			}
 - 
 
628 
		}
 - 
 
629
- 
 
630 
		// Analyse des résultats
 - 
 
631 
		if (count($noms_erreur) > 0) {
 - 
 
632 
			$info['message']['entete'] = array('num_nom', 'homonyme introuvable');
 - 
 
633 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
634 
		} else {
 - 
 
635 
			$info['resultat'] = true;
 - 
 
636 
		}
 - 
 
637
- 
 
638 
		return $info;
 - 
 
639 
	}
 - 
 
640
- 
 
641 
	private function testerHomonymieSyntaxe($noms) {
 - 
 
642 
		$info = array('titre' => 'homonyme -> syntaxe',
 - 
 
643 
			'description' => "Le champ homonyme contient :\n".
 - 
 
644 
			" - le chiffre 1 ou une valeur vide.\n",
 - 
 
645 
			'resultat' => false);
 - 
 
646
- 
 
647 
		// Réalisation du test
 - 
 
648 
		$noms_erreur = array();
 - 
 
649 
		foreach ($noms as $nom) {
 - 
 
650 
			if ($nom['homonyme'] != '') {
 - 
 
651 
				if (!$this->verifierBooleen($nom['homonyme'])) {
 - 
 
652 
					$noms_erreur[] = array($nom['num_nom'], $nom['homonyme']);
 - 
 
653 
				}
 - 
 
654 
			}
 - 
 
655 
		}
 - 
 
656
- 
 
657 
		// Analyse des résultats
 - 
 
658 
		if (count($noms_erreur) > 0) {
 - 
 
659 
			$info['message']['entete'] = array('num_nom', 'homonyme erroné');
 - 
 
660 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
661 
		} else {
 - 
 
662 
			$info['resultat'] = true;
 - 
 
663 
		}
 - 
 
664
- 
 
665 
		return $info;
 - 
 
666 
	}
 - 
 
667
- 
 
668 
	private function testerBiblioOrigineSyntaxe($noms) {
 - 
 
669 
		$info = array('titre' => 'biblio_origine -> syntaxe',
 - 
 
670 
			'description' => "Le champ biblio_origine se compose de plusieurs parties séparées par des caractères ".
 - 
 
671 
			"précis qui sont dans l'ordre de gauche à droite :\n".
 - 
 
672 
			" - Éventuellement le mot « in » suivi d'un intitulé auteur (utilisé pour indiquer l'intitulé auteur de ".
 - 
 
673 
			"l'ouvrage global dans lequel la publication est parue).\n".
 - 
 
674 
			" - point-virgule « ; » (si l'info précédent a été renseignée)\n".
 - 
 
675 
			" - Abréviation ou nom de l'ouvrage ou de la revue selon le standard en vigueur dans le code du nom. ".
 - 
 
676 
			"Cette information ne doit pas contenir de caractère virgule « , ».\n".
 - 
 
677 
			" - virgule « , »\n".
 - 
 
678 
			" - Les informations permettant d'identifier plus précisément le document contenant le nom... ".
 - 
 
679 
			"Par exemple, l'éditeur, le tome, le numéro d'édition, le volume... séparées par des virgules ou d'autres ".
 - 
 
680 
			"caractères sauf deux points « : ».\n".
 - 
 
681 
			" - deux points « : »\n".
 - 
 
682 
			" - la page contenant la publication du nom ou un ensemble de page (première et dernière page de ".
 - 
 
683 
			"l'ensemble séparées par un tiret « - »). Quelques fois des numéros ou d'autres informations indiquant ".
 - 
 
684 
			"dans le document la position du nom. Le tiret « - » doit toujours servir à séparer un ensemble.",
 - 
 
685 
			'resultat' => false);
 - 
 
686
- 
 
687 
		// Réalisation du test
 - 
 
688 
		$noms_erreur = array();
 - 
 
689 
		foreach ($noms as $nom) {
 - 
 
690 
			if ($nom['biblio_origine'] != '') {
 - 
 
691 
				if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
 - 
 
692 
					$biblio_traite = $this->repererEspace($nom['biblio_origine']);
 - 
 
693 
					$noms_erreur[] = array($nom['num_nom'], $biblio_traite);
 - 
 
694 
				}
 - 
 
695 
			}
 - 
 
696 
		}
 - 
 
697
- 
 
698 
		// Analyse des résultats
 - 
 
699 
		if (count($noms_erreur) > 0) {
 - 
 
700 
			$info['message']['entete'] = array('num_nom', 'biblio_origine erroné');
 - 
 
701 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
702 
		} else {
 - 
 
703 
			$info['resultat'] = true;
 - 
 
704 
		}
 - 
 
705
- 
 
706 
		return $info;
 - 
 
707 
	}
 - 
 
708
- 
 
709 
	private function testerAnneeSyntaxe($noms) {
 - 
 
710 
		$info = array('titre' => 'annee -> syntaxe',
 - 
 
711 
			'description' => "Le champ annee doit :\n".
 - 
 
712 
			" - contenir un nombre de 4 chiffre\n".
 - 
 
713 
			" - être supérieur ou égal à 1753 ",
 - 
 
714 
			'resultat' => false);
 - 
 
715
- 
 
716 
		// Réalisation du test
 - 
 
717 
		$noms_erreur = array();
 - 
 
718 
		foreach ($noms as $nom) {
 - 
 
719 
			if ($nom['annee'] != '') {
 - 
 
720 
				if (!$this->verifierAnnee($nom['annee'])) {
 - 
 
721 
					$noms_erreur[] = array($nom['num_nom'], $nom['annee']);
 - 
 
722 
				}
 - 
 
723 
			}
 - 
 
724 
		}
 - 
 
725
- 
 
726 
		// Analyse des résultats
 - 
 
727 
		if (count($noms_erreur) > 0) {
 - 
 
728 
			$info['message']['entete'] = array('num_nom', 'annee erroné');
 - 
 
729 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
730 
		} else {
 - 
 
731 
			$info['resultat'] = true;
 - 
 
732 
		}
 - 
 
733
- 
 
734 
		return $info;
 - 
 
735 
	}
 - 
 
736
- 
 
737 
	private function testerAuteurSyntaxe($noms) {
 - 
 
738 
		$info = array('titre' => 'auteur -> syntaxe',
 - 
 
739 
			'description' => "Le champ auteur doit :\n".
 - 
 
740 
			" - contenir l'intitulé complet des noms de l'auteur ou des auteurs ayant publiés à l'origine la combinaison latine courante.\n".
 - 
 
741 
    		" - ou débuter par le mot « sensu » et contient l'intitulé complet des noms de l'auteur ou des auteurs ayant publiés un nom dont la description ne correspond pas à celle de l'auteur ou des auteurs d'origine.\n".
 - 
 
742 
			" - se composer de caractères alphabétiques (A-Z, a-z), incluant les signes diacritiques, le symbole point (.), les paires de parenthèses ( () ), les apostrophes, l'esperluette (&) et l'espace ( ).\n".
 - 
 
743 
			" - contenir, si nécessaire, des abréviations de noms d'auteurs respectant les standards.\n".
 - 
 
744 
			" - contenir une translittération des noms d'alphabet cyrillique, arabe, chinois... en alphabet latin.\n".
 - 
 
745 
			" - inclure entre parenthèses l'intitulé des noms de l'auteur ou des auteurs ayant publié le basionyme.\n".
 - 
 
746 
			" - toujours utiliser l'esperluette (&) à la place du mot « et » pour séparer les noms d'auteurs.\n".
 - 
 
747 
			" - conformément à la recommandation 46C.2 du CINB, si une un citation comprend plus de deux auteurs, ".
 - 
 
748 
			"elle devrait être limitée au nom du premier, suivi de « & al.».\n",
 - 
 
749 
			'resultat' => false);
 - 
 
750
- 
 
751 
		// Réalisation du test
 - 
 
752 
		$noms_erreur = array();
 - 
 
753 
		foreach ($noms as $nom) {
 - 
 
754 
			if ($nom['auteur'] != '') {
 - 
 
755 
				if (!$this->verifierAuteur($nom['auteur'])) {
 - 
 
756 
					$intitule_traite = $this->repererEspace($nom['auteur']);
 - 
 
757 
					$noms_erreur[] = array($nom['num_nom'], $intitule_traite);
 - 
 
758 
				}
 - 
 
759 
			}
 - 
 
760 
		}
 - 
 
761
- 
 
762 
		// Analyse des résultats
 - 
 
763 
		if (count($noms_erreur) > 0) {
 - 
 
764 
			$info['message']['entete'] = array('num_nom', 'auteur erroné');
 - 
 
765 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
766 
		} else {
 - 
 
767 
			$info['resultat'] = true;
 - 
 
768 
		}
 - 
 
769
- 
 
770 
		return $info;
 - 
 
771 
	}
 - 
 
772
- 
 
773 
	private function testerNomCommercialSyntaxe($noms) {
 - 
 
774 
		$info = array('titre' => 'nom_commercial -> syntaxe',
 - 
 
775 
			'description' => "Le champ nom_commercial doit contenir un nom commercial conforme aux règles du ".
 - 
 
776 
				"Code Internationnal de Nomenclature des Plantes Cultivées (CINPC) ".
 - 
 
777 
				"qui se compose de caractères majuscules (A-Z) incluant des signes diacritiques et des espaces.\n",
 - 
 
778 
			'resultat' => false);
 - 
 
779
- 
 
780 
		// Réalisation du test
 - 
 
781 
		$noms_erreur = array();
 - 
 
782 
		foreach ($noms as $nom) {
 - 
 
783 
			if ($nom['nom_commercial'] != '') {
 - 
 
784 
				if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
 - 
 
785 
					$epithete_traite = $this->repererEspace($nom['nom_commercial']);
 - 
 
786 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
 - 
 
787 
				}
 - 
 
788 
			}
 - 
 
789 
		}
 - 
 
790
- 
 
791 
		// Analyse des résultats
 - 
 
792 
		if (count($noms_erreur) > 0) {
 - 
 
793 
			$info['message']['entete'] = array('num_nom', 'cultivar erroné');
 - 
 
794 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
795 
		} else {
 - 
 
796 
			$info['resultat'] = true;
 - 
 
797 
		}
 - 
 
798
- 
 
799 
		return $info;
 - 
 
800 
	}
 - 
 
801
- 
 
802 
	private function testerNomCommercialPresenceCultivar($noms) {
 - 
 
803 
		$info = array('titre' => 'nom_commercial -> groupe_cultivar OU cultivar non vide',
 - 
 
804 
			'description' => "Si le champ nom_commercial contier un nom commercial alors le champ cultivar OU ".
 - 
 
805 
				"cultivar_groupe ne doit pas être vide.",
 - 
 
806 
			'resultat' => false);
 - 
 
807
- 
 
808 
		// Réalisation du test
 - 
 
809 
		$noms_erreur = array();
 - 
 
810 
		foreach ($noms as $nom) {
 - 
 
811 
			if ($nom['nom_commercial'] != '' && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
 - 
 
812 
				$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet']);
 - 
 
813 
			}
 - 
 
814 
		}
 - 
 
815
- 
 
816 
		// Analyse des résultats
 - 
 
817 
		if (count($noms_erreur) > 0) {
 - 
 
818 
			$info['message']['entete'] = array('num_nom', 'nom_commercial sans cultivar ou cultivar_groupe');
 - 
 
819 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
820 
		} else {
 - 
 
821 
			$info['resultat'] = true;
 - 
 
822 
		}
 - 
 
823
- 
 
824 
		return $info;
 - 
 
825 
	}
 - 
 
826
- 
 
827 
	private function testerCultivarSyntaxe($noms) {
 - 
 
828 
		$info = array('titre' => 'cultivar -> syntaxe',
 - 
 
829 
			'description' => "Le champ cultivar_groupe doit contenir :\n".
 - 
 
830 
				" - un nom de cultivar conforme aux règles du Code Internationnal de Nomenclature des Plantes ".
 - 
 
831 
				"Cultivées (CINPC) qui se compose de caractères alphanumériques (A-Z,a-z et 0-9) incluant ".
 - 
 
832 
				"signes diacritiques et marques de ponctuations.\n".
 - 
 
833 
				" - un nom en alphabet latin ce qui implique une translittération des noms d'alphabet cyrillique, ".
 - 
 
834 
				"arabe, chinois...\n".
 - 
 
835 
				" - une lettre majuscule obligatoire pour le premier caractère du premier mot et pour les autres mots ".
 - 
 
836 
				"importants mais pas pour les mots mineurs.\n".
 - 
 
837 
				"Ne doit pas contenir :\n".
 - 
 
838 
				" - cv., convar. ou de guillemets simples (').\n",
 - 
 
839 
			'resultat' => false);
 - 
 
840
- 
 
841 
		// Réalisation du test
 - 
 
842 
		$noms_erreur = array();
 - 
 
843 
		foreach ($noms as $nom) {
 - 
 
844 
			if ($nom['cultivar'] != '') {
 - 
 
845 
				if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
 - 
 
846 
					$epithete_traite = $this->repererEspace($nom['cultivar']);
 - 
 
847 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
 - 
 
848 
				}
 - 
 
849 
			}
 - 
 
850 
		}
 - 
 
851
- 
 
852 
		// Analyse des résultats
 - 
 
853 
		if (count($noms_erreur) > 0) {
 - 
 
854 
			$info['message']['entete'] = array('num_nom', 'cultivar erroné');
 - 
 
855 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
856 
		} else {
 - 
 
857 
			$info['resultat'] = true;
 - 
 
858 
		}
 - 
 
859
- 
 
860 
		return $info;
 - 
 
861 
	}
 - 
 
862
- 
 
863 
	private function testerCultivarRang($noms) {
 - 
 
864 
		$info = array('titre' => "cultivar -> rang >= {$this->manuel['rang_genre']}",
 - 
 
865 
			'description' => "Si le champ cultivar n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.",
 - 
 
866 
			'resultat' => false);
 - 
 
867
- 
 
868 
		// Réalisation du test
 - 
 
869 
		$noms_erreur = array();
 - 
 
870 
		foreach ($noms as $nom) {
 - 
 
871 
			if ($nom['cultivar'] != '') {
 - 
 
872 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
 - 
 
873 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
 - 
 
874 
				}
 - 
 
875 
			}
 - 
 
876 
		}
 - 
 
877
- 
 
878 
		// Analyse des résultats
 - 
 
879 
		if (count($noms_erreur) > 0) {
 - 
 
880 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
 - 
 
881 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
882 
		} else {
 - 
 
883 
			$info['resultat'] = true;
 - 
 
884 
		}
 - 
 
885
- 
 
886 
		return $info;
 - 
 
887 
	}
 - 
 
888
- 
 
889 
	private function testerGroupeCultivarSyntaxe($noms) {
 - 
 
890 
		$info = array('titre' => 'cultivar_groupe -> syntaxe',
 - 
 
891 
			'description' => "Le champ cultivar_groupe doit contenir un nom de groupe de cultivar conforme aux règles ".
 - 
 
892 
				"du code des plantes cultivées qui se compose de caractères alphanumériques (A-Z,a-z et 0-9) incluant ".
 - 
 
893 
				"signes diacritiques et marques de ponctuations.\n".
 - 
 
894 
				"Il ne doit pas contenir le mot Groupe, l'abbréviation «gp» ou des parenthèses.\n".
 - 
 
895 
				"Il peut contir à la fin l'abréviation «gx» pour distinguer les groupes des grex.",
 - 
 
896 
			'resultat' => false);
 - 
 
897
- 
 
898 
		// Réalisation du test
 - 
 
899 
		$noms_erreur = array();
 - 
 
900 
		foreach ($noms as $nom) {
 - 
 
901 
			if ($nom['cultivar_groupe'] != '') {
 - 
 
902 
				if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
 - 
 
903 
					$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
 - 
 
904 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
 - 
 
905 
				}
 - 
 
906 
			}
 - 
 
907 
		}
 - 
 
908
- 
 
909 
		// Analyse des résultats
 - 
 
910 
		if (count($noms_erreur) > 0) {
 - 
 
911 
			$info['message']['entete'] = array('num_nom', 'cultivar_groupe erroné');
 - 
 
912 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
913 
		} else {
 - 
 
914 
			$info['resultat'] = true;
 - 
 
915 
		}
 - 
 
916
- 
 
917 
		return $info;
 - 
 
918 
	}
 - 
 
919
- 
 
920 
	private function testerGroupeCultivarRang($noms) {
 - 
 
921 
		$info = array('titre' => "cultivar_groupe -> rang >= {$this->manuel['rang_genre']}",
 - 
 
922 
			'description' => "Si le champ cultivar_groupe n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.",
 - 
 
923 
			'resultat' => false);
 - 
 
924
- 
 
925 
		// Réalisation du test
 - 
 
926 
		$noms_erreur = array();
 - 
 
927 
		foreach ($noms as $nom) {
 - 
 
928 
			if ($nom['cultivar_groupe'] != '') {
 - 
 
929 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
 - 
 
930 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
 - 
 
931 
				}
 - 
 
932 
			}
 - 
 
933 
		}
 - 
 
934
- 
 
935 
		// Analyse des résultats
 - 
 
936 
		if (count($noms_erreur) > 0) {
 - 
 
937 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
 - 
 
938 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
939 
		} else {
 - 
 
940 
			$info['resultat'] = true;
 - 
 
941 
		}
 - 
 
942
- 
 
943 
		return $info;
 - 
 
944 
	}
 - 
 
945
- 
 
946 
	private function testerEpitheteInfraSpEspaces($noms) {
 - 
 
947 
		$info = array('titre' => 'epithete_infra_sp -> espaces en trop',
 - 
 
948 
			'description' => "Le champ epithete_infra_sp ne doit pas contenir d'espace avant ou aprés le nom.\n".
 - 
 
949 
				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
 - 
 
950 
			'resultat' => false);
 - 
 
951
- 
 
952 
		// Réalisation du test
 - 
 
953 
		$noms_erreur = array();
 - 
 
954 
		foreach ($noms as $nom) {
 - 
 
955 
			if ($nom['epithete_infra_sp'] != '') {
 - 
 
956 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) {
 - 
 
957 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
 - 
 
958 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
 - 
 
959 
				}
 - 
 
960 
			}
 - 
 
961 
		}
 - 
 
962
- 
 
963 
		// Analyse des résultats
 - 
 
964 
		if (count($noms_erreur) > 0) {
 - 
 
965 
			$info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné');
 - 
 
966 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
967 
		} else {
 - 
 
968 
			$info['resultat'] = true;
 - 
 
969 
		}
 - 
 
970
- 
 
971 
		return $info;
 - 
 
972 
	}
 - 
 
973
- 
 
974 
	private function testerEpitheteInfraSpSyntaxe($noms) {
 - 
 
975 
		$info = array('titre' => 'epithete_infra_sp -> syntaxe',
 - 
 
976 
			'description' => "Le champ epithete_infra_sp peut contenir :\n".
 - 
 
977 
			 	" - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
 - 
 
978 
				"	Il commence par une lettre minuscule (avec ou sans tréma).\n".
- 
 
979 
				"	Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n".
 - 
 
980 
				" - une formule d'hybridité composée d'une série de noms d'espèce ou d'infra espèce (au moins 2) séparés entre eux \n".
 - 
 
981 
				"	par la lettre x entourée de caractères espaces.",
 - 
 
982 
			'resultat' => false);
 - 
 
983
- 
 
984 
		// Réalisation du test
 - 
 
985 
		$noms_erreur = array();
 - 
 
986 
		foreach ($noms as $nom) {
 - 
 
987 
			if ($nom['epithete_infra_sp'] != '') {
 - 
 
988 
				$mots = explode(' ', $nom['epithete_infra_sp']);
 - 
 
989 
				foreach ($mots as $mot) {
 - 
 
990 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpitheteSp($mot))) {
 - 
 
991 
						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
 - 
 
992 
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
 - 
 
993 
					}
 - 
 
994 
				}
 - 
 
995 
			}
 - 
 
996 
		}
 - 
 
997
- 
 
998 
		// Analyse des résultats
 - 
 
999 
		if (count($noms_erreur) > 0) {
 - 
 
1000 
			$info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné');
 - 
 
1001 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1002 
		} else {
 - 
 
1003 
			$info['resultat'] = true;
 - 
 
1004 
		}
 - 
 
1005
- 
 
1006 
		return $info;
 - 
 
1007 
	}
 - 
 
1008
- 
 
1009 
	private function testerEpitheteInfraSpRang($noms) {
 - 
 
1010 
		$info = array('titre' => "epithete_infra_sp -> rang > {$this->manuel['rang_sp']}",
 - 
 
1011 
			'description' => "Si le champ epithete_infra_sp n'est pas vide alors le rang du nom doit être supérieur à {$this->manuel['rang_sp']}.",
 - 
 
1012 
			'resultat' => false);
 - 
 
1013
- 
 
1014 
		// Réalisation du test
 - 
 
1015 
		$noms_erreur = array();
 - 
 
1016 
		foreach ($noms as $nom) {
 - 
 
1017 
			if ($nom['epithete_infra_sp'] != '') {
 - 
 
1018 
				if ($nom['rang'] < $this->manuel['rang_sp']) {
 - 
 
1019 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
 - 
 
1020 
				}
 - 
 
1021 
			}
 - 
 
1022 
		}
 - 
 
1023
- 
 
1024 
		// Analyse des résultats
 - 
 
1025 
		if (count($noms_erreur) > 0) {
 - 
 
1026 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
 - 
 
1027 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1028 
		} else {
 - 
 
1029 
			$info['resultat'] = true;
 - 
 
1030 
		}
 - 
 
1031
- 
 
1032 
		return $info;
 - 
 
1033 
	}
 - 
 
1034
- 
 
1035 
	private function testerTypeEpitheteEspaces($noms) {
 - 
 
1036 
		$info = array('titre' => 'type_epithete -> espaces en trop',
 - 
 
1037 
			'description' => "Le champ type_epithete ne doit pas contenir d'espace.",
 - 
 
1038 
			'resultat' => false);
 - 
 
1039
- 
 
1040 
		// Réalisation du test
 - 
 
1041 
		$noms_erreur = array();
 - 
 
1042 
		foreach ($noms as $nom) {
 - 
 
1043 
			if ($nom['type_epithete'] != '') {
 - 
 
1044 
				if (preg_match('/\s+/', $nom['type_epithete'])) {
 - 
 
1045 
					$valeur_traitee = $this->repererEspace($nom['epithete_sp']);
 - 
 
1046 
					$noms_erreur[] = array($nom['num_nom'], $valeur_traitee);
 - 
 
1047 
				}
 - 
 
1048 
			}
 - 
 
1049 
		}
 - 
 
1050
- 
 
1051 
		// Analyse des résultats
 - 
 
1052 
		if (count($noms_erreur) > 0) {
 - 
 
1053 
			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
 - 
 
1054 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1055 
		} else {
 - 
 
1056 
			$info['resultat'] = true;
 - 
 
1057 
		}
 - 
 
1058
- 
 
1059 
		return $info;
 - 
 
1060 
	}
 - 
 
1061
- 
 
1062 
	private function testerTypeEpitheteSyntaxe($noms) {
 - 
 
1063 
		$info = array('titre' => 'type_epithete -> syntaxe',
 - 
 
1064 
			'description' => "Le champ type_epithete doit contenir un mot unique composé de lettres minuscules sans ".
 - 
 
1065 
				" accents et de tirets (-). Il commence par une lettre minuscule sans accent.",
 - 
 
1066 
			'resultat' => false);
 - 
 
1067
- 
 
1068 
		// Réalisation du test
 - 
 
1069 
		$noms_erreur = array();
 - 
 
1070 
		foreach ($noms as $nom) {
 - 
 
1071 
			if ($nom['type_epithete'] != '') {
 - 
 
1072 
				if (!$this->verifierTypeEpithete($nom['type_epithete'])) {
 - 
 
1073 
					$noms_erreur[] = array($nom['num_nom'],  $nom['type_epithete']);
 - 
 
1074 
				}
 - 
 
1075 
			}
 - 
 
1076 
		}
 - 
 
1077
- 
 
1078 
		// Analyse des résultats
 - 
 
1079 
		if (count($noms_erreur) > 0) {
 - 
 
1080 
			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
 - 
 
1081 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1082 
		} else {
 - 
 
1083 
			$info['resultat'] = true;
 - 
 
1084 
		}
 - 
 
1085
- 
 
1086 
		return $info;
 - 
 
1087 
	}
 - 
 
1088
- 
 
1089 
	private function testerTypeEpitheteHybridite($noms) {
 - 
 
1090 
		$info = array('titre' => 'type_epithete -> hybridité',
 - 
 
1091 
			'description' => "Le champ type_epithete ne doit pas contenir de préfixe indiquant l'hybridité comme : \n".
 - 
 
1092 
				" - «n-» \n".
 - 
 
1093 
				" - «notho-» \n",
 - 
 
1094 
			'resultat' => false);
 - 
 
1095
- 
 
1096 
		// Réalisation du test
 - 
 
1097 
		$noms_erreur = array();
 - 
 
1098 
		foreach ($noms as $nom) {
 - 
 
1099 
			if ($nom['type_epithete'] != '') {
 - 
 
1100 
				if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) {
 - 
 
1101 
					$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete']);
 - 
 
1102 
				}
 - 
 
1103 
			}
 - 
 
1104 
		}
 - 
 
1105
- 
 
1106 
		// Analyse des résultats
 - 
 
1107 
		if (count($noms_erreur) > 0) {
 - 
 
1108 
			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
 - 
 
1109 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1110 
		} else {
 - 
 
1111 
			$info['resultat'] = true;
 - 
 
1112 
		}
 - 
 
1113
- 
 
1114 
		return $info;
 - 
 
1115 
	}
 - 
 
1116
- 
 
1117 
	private function testerNombreDeChamps($colonnes) {
 - 
 
1118 
		$info = array('titre' => 'Structure -> nombre de champs : %s',
 - 
 
1119 
			'description' => 'Le nombre de champs présent dans la table doit être supérieur ou égal à 35.',
 - 
 
1120 
			'resultat' => false);
 - 
 
1121
- 
 
1122 
		$nbre_colonnes = count($colonnes);
 - 
 
1123 
		$info['titre'] = sprintf($info['titre'], $nbre_colonnes);
 - 
 
1124 
		if ($nbre_colonnes >= 35) {
 - 
 
1125 
			$info['resultat'] = true;
 - 
 
1126 
		}
 - 
 
1127 
		return $info;
 - 
 
1128 
	}
 - 
 
1129
- 
 
1130 
	private function testerNomDesChamps($colonnes) {
 - 
 
1131 
		$info = array('titre' => 'Structure -> noms des champs',
 - 
 
1132 
			'description' => 'Les champs de la table contenant le référentiel doivent être conforme à ceux définit par le manuel technique.',
 - 
 
1133 
			'resultat' => false);
 - 
 
1134
- 
 
1135 
		$champs_attendus = explode(',', $this->manuel['champs']);
 - 
 
1136 
		$champs_presents = array();
 - 
 
1137 
		foreach ($colonnes as $colonne) {
 - 
 
1138 
			$champs_presents[$colonne['Field']] = $colonne;
 - 
 
1139 
		}
 - 
 
1140
- 
 
1141 
		$ok = true;
 - 
 
1142 
		$champs_manquant = array();
- 
 
1143 
		foreach ($champs_attendus as $champ_attendu) {
 - 
 
1144 
			if (!isset($champs_presents[$champ_attendu])) {
 - 
 
1145 
				$champs_manquant[] = $champ_attendu;
- 
 
1146 
				$ok = false;
 - 
 
1147 
			}
 - 
 
1148 
		}
 - 
 
1149 
		$info['resultat'] = $ok;
 - 
 
1150 
		if (!$ok) {
 - 
 
1151 
			$info['message'] = 'Champs manquant : '.implode(', ', $champs_manquant).'.';
 - 
 
1152 
		}
 - 
 
1153
- 
 
1154 
		return $info;
 - 
 
1155 
	}
 - 
 
1156
- 
 
1157 
	private function testerTypeDesChamps($colonnes) {
 - 
 
1158 
		$info = array('titre' => 'Structure -> types des champs',
 - 
 
1159 
			'description' => 'Les types des champs de la table contenant le référentiel doivent être conforme à ceux définit par le manuel technique.',
 - 
 
1160 
			'resultat' => false);
 - 
 
1161
- 
 
1162 
		$champs_attendus = explode(',', $this->manuel['champs_type']);
 - 
 
1163 
		$champs_presents = array();
 - 
 
1164 
		foreach ($colonnes as $colonne) {
 - 
 
1165 
			$champs_presents[$colonne['Field']] = $colonne['Type'];
 - 
 
1166 
		}
 - 
 
1167
- 
 
1168 
		// Recercherche des erreurs
 - 
 
1169 
		$champs_erreur = array();
- 
 
1170 
		foreach ($champs_attendus as $champ_attendu) {
 - 
 
1171 
			list($champ_attendu_nom, $champ_attendu_type) = explode('=', trim($champ_attendu));
 - 
 
1172 
 
 - 
 
1173 
			if (isset($champs_presents[$champ_attendu_nom])) {
 - 
 
1174 
				$champs_present_type = $champs_presents[$champ_attendu_nom];
 - 
 
1175
- 
 
1176 
				if (($champ_attendu_type == 'VARCHAR' && strstr($champs_present_type, 'varchar') === false)
 - 
 
1177 
					|| ($champ_attendu_type == 'TEXT' && strstr($champs_present_type, 'text') === false)
 - 
 
1178 
					|| ($champ_attendu_type == 'INT' && strstr($champs_present_type, 'int') === false)
- 
 
1179 
					|| ($champ_attendu_type == 'BOOL' && preg_match('/(?:bool|boolean|tinyint\(1\))/i', $champs_present_type) === false)) {
 - 
 
1180 
					$champs_erreur[] = $champ_attendu." vaut ".$champs_present_type;
 - 
 
1181 
				}
 - 
 
1182 
			}
 - 
 
1183 
		}
 - 
 
1184
- 
 
1185 
		// Analyse des résultats
 - 
 
1186 
		if (count($champs_erreur) > 0) {
 - 
 
1187 
			$info['message'] = "Champs n'ayant pas un bon type : ".implode(', ', $champs_erreur).'.';
 - 
 
1188 
		} else {
 - 
 
1189 
			$info['resultat'] = true;
 - 
 
1190 
		}
 - 
 
1191
- 
 
1192 
		return $info;
 - 
 
1193 
	}
 - 
 
1194
- 
 
1195 
	private function testerTailleDesChamps($colonnes, $analyses) {
 - 
 
1196 
		$info = array('titre' => 'Structure -> champs tronqués',
 - 
 
1197 
			'description' => "Vérifie que les données de type texte insérées dans la table n'ont pas été tronquées lors de leur insertion.",
 - 
 
1198 
			'resultat' => false);
 - 
 
1199
- 
 
1200 
		$tailles_champs_maxi = array();
 - 
 
1201 
		foreach ($colonnes as $colonne) {
 - 
 
1202 
			if (preg_match('/^varchar\(([0-9]+)\)$/', $colonne['Type'], $match)) {
 - 
 
1203 
				$tailles_champs_maxi[$colonne['Field']] = $match[1];
 - 
 
1204 
			}
 - 
 
1205 
		}
 - 
 
1206
- 
 
1207 
		$tailles_trouvees = array();
 - 
 
1208 
		foreach ($analyses as $analyse) {
 - 
 
1209 
			if (preg_match('/\.([^.]+)$/', $analyse['Field_name'], $match)) {
 - 
 
1210 
				$tailles_trouvees[$match[1]] = $analyse['Max_length'];
 - 
 
1211 
			}
 - 
 
1212 
		}
 - 
 
1213
- 
 
1214 
		$champs_erreur = array();
 - 
 
1215 
		$champs_attendus = explode(',', $this->manuel['champs']);
 - 
 
1216 
		foreach ($champs_attendus as $champ_attendu) {
 - 
 
1217 
			if (isset($tailles_champs_maxi[$champ_attendu]) && isset($tailles_trouvees[$champ_attendu])) {
 - 
 
1218 
				if ($tailles_champs_maxi[$champ_attendu] == $tailles_trouvees[$champ_attendu]) {
 - 
 
1219 
					$champs_erreur[] = $champ_attendu;
 - 
 
1220 
				}
 - 
 
1221 
			}
 - 
 
1222 
		}
 - 
 
1223
- 
 
1224 
		// Analyse des résultats
 - 
 
1225 
		if (count($champs_erreur) > 0) {
 - 
 
1226 
			$info['message'] = "Champs possédant des enregistrements avec une taille maximum : ".implode(', ', $champs_erreur).'.';
 - 
 
1227 
		} else {
 - 
 
1228 
			$info['resultat'] = true;
 - 
 
1229 
		}
 - 
 
1230
- 
 
1231 
		return $info;
 - 
 
1232 
	}
 - 
 
1233
- 
 
1234 
	private function testerNumNomClePrimaire($colonnes) {
 - 
 
1235 
		$info = array('titre' => 'Structure -> num_nom est clé primaire',
 - 
 
1236 
			'description' => "Vérifie que le champ num_nom est bien la clé primaire de la table.",
 - 
 
1237 
			'resultat' => false);
 - 
 
1238
- 
 
1239 
		foreach ($colonnes as $colonne) {
 - 
 
1240 
			if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') {
 - 
 
1241 
				$info['resultat'] = true;
 - 
 
1242 
			}
 - 
 
1243 
		}
 - 
 
1244
- 
 
1245 
		return $info;
 - 
 
1246 
	}
 - 
 
1247
- 
 
1248 
	private function testerNumNomSuperieurAZero($noms) {
 - 
 
1249 
		$info = array('titre' => 'num_nom -> supérieur à 0',
 - 
 
1250 
			'description' => "Le champ num_nom doit contenir des nombres entiers supérieurs à 0.",
 - 
 
1251 
			'resultat' => false);
 - 
 
1252
- 
 
1253 
		// Réalisation du test
 - 
 
1254 
		$noms_erreur = array();
 - 
 
1255 
		foreach ($noms as $nom) {
 - 
 
1256 
			if ($nom['num_nom'] <= 0) {
 - 
 
1257 
				$noms_erreur[] = $nom['num_nom'];
 - 
 
1258 
			}
 - 
 
1259 
		}
 - 
 
1260
- 
 
1261 
		// Analyse des résultats
 - 
 
1262 
		if (count($noms_erreur) > 0) {
 - 
 
1263 
			$info['message'] = count($noms_erreur)." enregistrements contiennent dans le champ num_nom une valeur inférieure ou égale à 0.";
 - 
 
1264 
		} else {
 - 
 
1265 
			$info['resultat'] = true;
 - 
 
1266 
		}
 - 
 
1267
- 
 
1268 
		return $info;
 - 
 
1269 
	}
 - 
 
1270
- 
 
1271 
	private function testerNumNomRetenuSuperieurAZero($noms) {
 - 
 
1272 
		$info = array('titre' => 'num_nom_retenu -> supérieur à 0',
 - 
 
1273 
			'description' => "Le champ num_nom_retenu doit contenir des nombres entiers supérieurs à 0.",
 - 
 
1274 
			'resultat' => false);
 - 
 
1275
- 
 
1276 
		// Réalisation du test
 - 
 
1277 
		$noms_erreur = array();
 - 
 
1278 
		foreach ($noms as $nom) {
 - 
 
1279 
			if ($nom['num_nom_retenu'] <= 0) {
 - 
 
1280 
				$noms_erreur[] = $nom['num_nom'];
 - 
 
1281 
			}
 - 
 
1282 
		}
 - 
 
1283
- 
 
1284 
		// Analyse des résultats
 - 
 
1285 
		if (count($noms_erreur) > 0) {
 - 
 
1286 
			$info['message'] = count($noms_erreur)." enregistrements dont le champ num_nom_retenu est inférieur ou égal à 0 : ".implode(', ', $noms_erreur).'.';
 - 
 
1287 
		} else {
 - 
 
1288 
			$info['resultat'] = true;
 - 
 
1289 
		}
 - 
 
1290
- 
 
1291 
		return $info;
 - 
 
1292 
	}
 - 
 
1293
- 
 
1294 
	private function testerNumTaxSupEgalZeroUnique($noms) {
 - 
 
1295 
		$info = array('titre' => 'num_tax_sup -> égal à 0 unique',
 - 
 
1296 
			'description' => "Un seul enregistrement doit posséder la valeur 0 dans le champ num_tax_sup. Il correspond au premier taxon de la classification.",
 - 
 
1297 
			'resultat' => false);
 - 
 
1298
- 
 
1299 
		// Réalisation du test
 - 
 
1300 
		$noms_erreur = array();
 - 
 
1301 
		foreach ($noms as $nom) {
 - 
 
1302 
			if (preg_match('/^0$/', $nom['num_tax_sup'])) {
 - 
 
1303 
				$noms_erreur[] = $nom['num_nom'];
 - 
 
1304 
			}
 - 
 
1305 
		}
 - 
 
1306
- 
 
1307 
		// Analyse des résultats
 - 
 
1308 
		if (count($noms_erreur) > 1) {
 - 
 
1309 
			$info['message'] = count($noms_erreur)." enregistrements ont une valeur de 0 dans le champ num_tax_sup : ".implode(', ', $noms_erreur).'.';
 - 
 
1310 
		} else {
 - 
 
1311 
			$info['resultat'] = true;
 - 
 
1312 
		}
 - 
 
1313
- 
 
1314 
		return $info;
 - 
 
1315 
	}
 - 
 
1316
- 
 
1317 
	private function testerTaxSupPourTaxon($noms) {
 - 
 
1318 
		$info = array('titre' => 'Classification -> uniquement pour les taxons',
 - 
 
1319 
			'description' => "Seul les enregistrements représentant un taxon doivent posséder une valeur dans le champ num_tax_sup.",
 - 
 
1320 
			'resultat' => false);
 - 
 
1321
- 
 
1322 
		// Réalisation du test
 - 
 
1323 
		$noms_erreur = array();
 - 
 
1324 
		foreach ($noms as $nom) {
 - 
 
1325 
			if ($nom['num_nom_retenu'] == $nom['num_nom'] && preg_match('/^[0-9]+$/', $nom['num_tax_sup'])) {
 - 
 
1326 
				$noms_erreur[] = $nom['num_nom'];
- 
 
1327 
			}
 - 
 
1328 
		}
 - 
 
1329
- 
 
1330 
		// Analyse des résultats
 - 
 
1331 
		if (count($noms_erreur) > 0) {
 - 
 
1332 
			$info['message'] = count($noms_erreur)." enregistrements qui n'est pas un taxon et qui possède une valeur dans num_tax_sup : ".implode(', ', $noms_erreur).'.';
 - 
 
1333 
		} else {
 - 
 
1334 
			$info['resultat'] = true;
 - 
 
1335 
		}
 - 
 
1336
- 
 
1337 
		return $info;
 - 
 
1338 
	}
 - 
 
1339
- 
 
1340 
	private function testerExitenceTaxonSuperieur($noms) {
 - 
 
1341 
		$info = array('titre' => 'Classification -> existence du taxon supérieur',
 - 
 
1342 
			'description' => "Pour chaque enregistrement représentant un taxon doit posséder un taxon supérieur sauf la racine de la classification.",
 - 
 
1343 
			'resultat' => false);
 - 
 
1344
- 
 
1345 
		// Réalisation du test
 - 
 
1346 
		$noms_erreur = array();
 - 
 
1347 
		foreach ($noms as $nom) {
 - 
 
1348 
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
 - 
 
1349 
				if ($nom['num_tax_sup'] != 0 && !isset($noms[$nom['num_tax_sup']])) {
 - 
 
1350 
					$noms_erreur[] = $nom['num_nom'];
 - 
 
1351 
				}
- 
 
1352 
			}
 - 
 
1353 
		}
 - 
 
1354
- 
 
1355 
		// Analyse des résultats
 - 
 
1356 
		if (count($noms_erreur) > 0) {
 - 
 
1357 
			$info['message'] = count($noms_erreur)." enregistrements dont le taxon supérieur n'existe pas : ".implode(', ', $noms_erreur).'.';
 - 
 
1358 
		} else {
 - 
 
1359 
			$info['resultat'] = true;
 - 
 
1360 
		}
 - 
 
1361
- 
 
1362 
		return $info;
 - 
 
1363 
	}
 - 
 
1364
- 
 
1365 
	private function testerClassificationRang($noms) {
 - 
 
1366 
		$info = array('titre' => 'Classification -> taxon supérieur avec rang inférieur',
 - 
 
1367 
			'description' => "Pour chaque enregistrement représentant un taxon, chaque taxon supérieur doit avoir un rang inférieur au taxon courant.",
 - 
 
1368 
			'resultat' => false);
 - 
 
1369
- 
 
1370 
		// Réalisation du test
 - 
 
1371 
		$noms_erreur = array();
 - 
 
1372 
		foreach ($noms as $nom) {
 - 
 
1373 
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
 - 
 
1374 
				if (isset($noms[$nom['num_tax_sup']])) {
 - 
 
1375 
					$nom_sup = $noms[$nom['num_tax_sup']];
 - 
 
1376 
					if ($nom_sup['rang'] > $nom['rang']) {
 - 
 
1377 
						$noms_erreur[] = $nom['num_nom'];
 - 
 
1378 
					}
 - 
 
1379 
				}
 - 
 
1380 
			}
 - 
 
1381 
		}
 - 
 
1382
- 
 
1383 
		// Analyse des résultats
 - 
 
1384 
		if (count($noms_erreur) > 0) {
 - 
 
1385 
			$info['message'] = count($noms_erreur)." enregistrements avec un problème : ".implode(', ', $noms_erreur).'.';
 - 
 
1386 
		} else {
 - 
 
1387 
			$info['resultat'] = true;
 - 
 
1388 
		}
 - 
 
1389
- 
 
1390 
		return $info;
 - 
 
1391 
	}
 - 
 
1392
- 
 
1393 
	private function testerClassification($noms) {
 - 
 
1394 
		$info = array('titre' => 'Classification -> racine liée à chaque noeud',
 - 
 
1395 
			'description' => "Pour chaque enregistrement, la classification doit pouvoir être remonté jusqu'à un même nom unique possédant une valeur num_tax_sup de 0.",
 - 
 
1396 
			'resultat' => false);
 - 
 
1397
- 
 
1398 
		// Réalisation du test
 - 
 
1399 
		$noms_erreur = array();
 - 
 
1400 
		foreach ($noms as $nom) {
 - 
 
1401 
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
 - 
 
1402 
				$classif_ok = $this->remonterClassif($noms, $nom);
 - 
 
1403 
				if ($classif_ok === false) {
 - 
 
1404 
					$noms_erreur[] = $nom['num_nom'];
 - 
 
1405 
				}
 - 
 
1406 
			}
 - 
 
1407 
		}
 - 
 
1408
- 
 
1409 
		// Analyse des résultats
 - 
 
1410 
		if (count($noms_erreur) > 0) {
 - 
 
1411 
			$info['message'] = count($noms_erreur)." taxons dont la classification n'est pas bonne : ".implode(', ', $noms_erreur).'.';
 - 
 
1412 
		} else {
 - 
 
1413 
			$info['resultat'] = true;
 - 
 
1414 
		}
 - 
 
1415
- 
 
1416 
		return $info;
 - 
 
1417 
	}
 - 
 
1418
- 
 
1419 
	private function remonterClassif(&$noms, $nom) {
 - 
 
1420 
		if (!isset($noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') {
 - 
 
1421 
			return true;
 - 
 
1422 
		} else if (!isset($noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') {
 - 
 
1423 
			return false;
 - 
 
1424 
		} else {
 - 
 
1425 
			return $this->remonterClassif($noms, $noms[$nom['num_tax_sup']]);
 - 
 
1426 
		}
 - 
 
1427 
	}
 - 
 
1428
- 
 
1429 
	private function testerRang($noms) {
 - 
 
1430 
		$info = array('titre' => 'rang',
 - 
 
1431 
			'description' => "Le rang doit correspondre à un valeur numérique définit dans le manuel.",
 - 
 
1432 
			'resultat' => false);
 - 
 
1433
- 
 
1434 
		$rangs = array_flip(explode(',', $this->manuel['rangs']));
 - 
 
1435
- 
 
1436 
		// Réalisation du test
 - 
 
1437 
		$noms_erreur = array();
 - 
 
1438 
		foreach ($noms as $nom) {
 - 
 
1439 
			if (!isset($rangs[$nom['rang']])) {
 - 
 
1440 
				$noms_erreur[] = $nom['num_nom'];
 - 
 
1441 
			}
 - 
 
1442 
		}
 - 
 
1443
- 
 
1444 
		// Analyse des résultats
 - 
 
1445 
		if (count($noms_erreur) > 0) {
 - 
 
1446 
			$info['message'] = count($noms_erreur)." noms dont le rang n'est pas bon : ".implode(', ', $noms_erreur).'.';
 - 
 
1447 
		} else {
 - 
 
1448 
			$info['resultat'] = true;
 - 
 
1449 
		}
 - 
 
1450
- 
 
1451 
		return $info;
 - 
 
1452 
	}
 - 
 
1453
- 
 
1454 
	private function testerNomCompletSupraGenerique($noms) {
 - 
 
1455 
		$info = array('titre' => 'nom_complet -> noms supra-génériques',
 - 
 
1456 
			'description' => "Si le rang est < à {$this->manuel['rang_genre']} le nom_complet doit correspondre à la valeur du champ nom_supra_generique. ".
 - 
 
1457 
				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 - 
 
1458 
			'resultat' => false);
 - 
 
1459
- 
 
1460 
		// Réalisation du test
 - 
 
1461 
		$noms_erreur = array();
 - 
 
1462 
		foreach ($noms as $nom) {
 - 
 
1463 
			if ($nom['rang'] < $this->manuel['rang_genre']) {
 - 
 
1464 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
 - 
 
1465 
				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']);
 - 
 
1466 
				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
 - 
 
1467 
				if ($nom['nom_complet'] != $nom_complet_ideal) {
 - 
 
1468 
					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
 - 
 
1469 
					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
 - 
 
1470 
				}
 - 
 
1471 
			}
 - 
 
1472 
		}
 - 
 
1473
- 
 
1474 
		// Analyse des résultats
 - 
 
1475 
		if (count($noms_erreur) > 0) {
 - 
 
1476 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
 - 
 
1477 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1478 
		} else {
 - 
 
1479 
			$info['resultat'] = true;
 - 
 
1480 
		}
 - 
 
1481
- 
 
1482 
		return $info;
 - 
 
1483 
	}
 - 
 
1484
- 
 
1485 
	private function testerNomCompletGenre($noms) {
 - 
 
1486 
		$info = array('titre' => 'nom_complet -> noms de genres',
 - 
 
1487 
			'description' => "Si le rang est = à {$this->manuel['rang_genre']} le nom_complet doit correspondre à la valeur du champ genre. ".
 - 
 
1488 
				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 - 
 
1489 
			'resultat' => false);
 - 
 
1490
- 
 
1491 
		// Réalisation du test
 - 
 
1492 
		$noms_erreur = array();
 - 
 
1493 
		foreach ($noms as $nom) {
 - 
 
1494 
			if ($nom['rang'] == $this->manuel['rang_genre']) {
 - 
 
1495 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
 - 
 
1496 
				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
 - 
 
1497 
				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
 - 
 
1498 
				if ($nom['nom_complet'] != $nom_complet_ideal) {
 - 
 
1499 
					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
 - 
 
1500 
					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
 - 
 
1501 
				}
 - 
 
1502 
			}
 - 
 
1503 
		}
 - 
 
1504
- 
 
1505 
		// Analyse des résultats
 - 
 
1506 
		if (count($noms_erreur) > 0) {
 - 
 
1507 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
 - 
 
1508 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1509 
		} else {
 - 
 
1510 
			$info['resultat'] = true;
 - 
 
1511 
		}
 - 
 
1512
- 
 
1513 
		return $info;
 - 
 
1514 
	}
 - 
 
1515
- 
 
1516 
	private function testerNomCompletInfraGenre($noms) {
 - 
 
1517 
		$info = array('titre' => 'nom_complet -> noms infra-génériques',
 - 
 
1518 
			'description' => "Si le rang est > à {$this->manuel['rang_genre']} et < à {$this->manuel['rang_sp']} le nom_complet doit correspondre à une des formules suivantes : \n".
 - 
 
1519 
			" genre + ' ' + type_epithete + ' ' + epithete_infra_generique \n".
 - 
 
1520 
			" genre + ' ' + epithete_infra_generique + ' ' + type_epithete=agg. \n".
 - 
 
1521 
			"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 - 
 
1522 
			'resultat' => false);
 - 
 
1523
- 
 
1524 
		// Réalisation du test
 - 
 
1525 
		$noms_erreur = array();
 - 
 
1526 
		foreach ($noms as $nom) {
 - 
 
1527 
			if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) {
 - 
 
1528 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
 - 
 
1529 
				$nom_complet_ideal = '';
 - 
 
1530 
				if ($nom['type_epithete'] == 'agg.') {
 - 
 
1531 
					$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
 - 
 
1532 
					$nom_complet_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
 - 
 
1533 
					$nom_complet_ideal .= ' '.$nom['type_epithete'];
 - 
 
1534 
				} else {
 - 
 
1535 
					$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
 - 
 
1536 
					$nom_complet_ideal .= ' '.$nom['type_epithete'];
 - 
 
1537 
					$nom_complet_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
 - 
 
1538 
				}
 - 
 
1539 
				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
 - 
 
1540 
				if ($nom['nom_complet'] != $nom_complet_ideal) {
 - 
 
1541 
					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
 - 
 
1542 
					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
 - 
 
1543 
				}
 - 
 
1544 
			}
 - 
 
1545 
		}
 - 
 
1546
- 
 
1547 
		// Analyse des résultats
 - 
 
1548 
		if (count($noms_erreur) > 0) {
 - 
 
1549 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
 - 
 
1550 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1551 
		} else {
 - 
 
1552 
			$info['resultat'] = true;
 - 
 
1553 
		}
 - 
 
1554
- 
 
1555 
		return $info;
 - 
 
1556 
	}
 - 
 
1557
- 
 
1558 
	private function testerNomCompletEspece($noms) {
 - 
 
1559 
		$info = array('titre' => "nom_complet -> noms d'espèce",
 - 
 
1560 
			'description' => "Si le rang est = à {$this->manuel['rang_sp']} le nom_complet doit correspondre à la formule : \n".
 - 
 
1561 
				" genre + ' ' + epithete_sp \n".
 - 
 
1562 
				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 - 
 
1563 
			'resultat' => false);
 - 
 
1564
- 
 
1565 
		// Réalisation du test
 - 
 
1566 
		$noms_erreur = array();
 - 
 
1567 
		foreach ($noms as $nom) {
 - 
 
1568 
			if ($nom['rang'] == $this->manuel['rang_sp']) {
 - 
 
1569 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
 - 
 
1570 
				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
 - 
 
1571 
				$nom_complet_ideal .= ' '.strtolower($nom['epithete_sp']);
 - 
 
1572 
				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
 - 
 
1573 
				if ($nom['nom_complet'] != $nom_complet_ideal) {
 - 
 
1574 
					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
 - 
 
1575 
					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
 - 
 
1576 
				}
 - 
 
1577 
			}
 - 
 
1578 
		}
 - 
 
1579
- 
 
1580 
		// Analyse des résultats
 - 
 
1581 
		if (count($noms_erreur) > 0) {
 - 
 
1582 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
 - 
 
1583 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1584 
		} else {
 - 
 
1585 
			$info['resultat'] = true;
 - 
 
1586 
		}
 - 
 
1587
- 
 
1588 
		return $info;
 - 
 
1589 
	}
 - 
 
1590
- 
 
1591 
	private function testerNomCompletInfraSpecifique($noms) {
 - 
 
1592 
		$info = array('titre' => 'nom_complet -> noms infra-spécifiques',
 - 
 
1593 
			'description' => "Si le rang est > à {$this->manuel['rang_sp']} le nom_complet doit correspondre à la formule : \n".
 - 
 
1594 
				" genre + ' ' + epithete_sp + ' ' + type_epithete + ' ' + epithete_infra_generique\n".
- 
 
1595 
				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 - 
 
1596 
			'resultat' => false);
 - 
 
1597
- 
 
1598 
		// Réalisation du test
 - 
 
1599 
		$noms_erreur = array();
 - 
 
1600 
		foreach ($noms as $nom) {
 - 
 
1601 
			if ($nom['rang'] > $this->manuel['rang_sp']) {
 - 
 
1602 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
 - 
 
1603 
				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
 - 
 
1604 
				$nom_complet_ideal .= ' '.strtolower($nom['epithete_sp']);
 - 
 
1605 
				$nom_complet_ideal .= ' '.strtolower($nom['type_epithete']);
 - 
 
1606 
				$nom_complet_ideal .= ' '.strtolower($nom['epithete_infra_sp']);
 - 
 
1607 
				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
 - 
 
1608 
				if ($nom['nom_complet'] != $nom_complet_ideal) {
 - 
 
1609 
					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
 - 
 
1610 
					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
 - 
 
1611 
				}
 - 
 
1612 
			}
 - 
 
1613 
		}
 - 
 
1614
- 
 
1615 
		// Analyse des résultats
 - 
 
1616 
		if (count($noms_erreur) > 0) {
 - 
 
1617 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
 - 
 
1618 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1619 
		} else {
 - 
 
1620 
			$info['resultat'] = true;
 - 
 
1621 
		}
 - 
 
1622
- 
 
1623 
		return $info;
 - 
 
1624 
	}
 - 
 
1625
- 
 
1626 
	private function testerNomSupraGeneriqueEspaces($noms) {
 - 
 
1627 
		$info = array('titre' => 'nom_supra_generique -> espaces en trop',
 - 
 
1628 
			'description' => "Le champ nom_supra_generique ne doit pas contenir d'espace avant ou aprés le nom.",
 - 
 
1629 
			'resultat' => false);
 - 
 
1630
- 
 
1631 
		// Réalisation du test
 - 
 
1632 
		$noms_erreur = array();
 - 
 
1633 
		foreach ($noms as $nom) {
 - 
 
1634 
			if ($nom['nom_supra_generique'] != '') {
 - 
 
1635 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
 - 
 
1636 
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
 - 
 
1637 
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
 - 
 
1638 
				}
 - 
 
1639 
			}
 - 
 
1640 
		}
 - 
 
1641
- 
 
1642 
		// Analyse des résultats
 - 
 
1643 
		if (count($noms_erreur) > 0) {
 - 
 
1644 
			$info['message']['entete'] = array('num_nom', 'nom_supra_generique erroné');
 - 
 
1645 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1646 
		} else {
 - 
 
1647 
			$info['resultat'] = true;
 - 
 
1648 
		}
 - 
 
1649
- 
 
1650 
		return $info;
 - 
 
1651 
	}
 - 
 
1652
- 
 
1653 
	private function testerNomSupraGeneriqueSyntaxe($noms) {
 - 
 
1654 
		$info = array('titre' => 'nom_supra_generique -> syntaxe',
 - 
 
1655 
			'description' => "Le champ nom_supra_generique contient un mot composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
 - 
 
1656 
				"La première lettre (avec ou sans tréma) du mot doit être en majuscule.",
 - 
 
1657 
			'resultat' => false);
 - 
 
1658
- 
 
1659 
		// Réalisation du test
 - 
 
1660 
		$noms_erreur = array();
 - 
 
1661 
		foreach ($noms as $nom) {
 - 
 
1662 
			if ($nom['nom_supra_generique'] != '') {
 - 
 
1663 
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) {
 - 
 
1664 
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
 - 
 
1665 
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
 - 
 
1666 
				}
 - 
 
1667 
			}
 - 
 
1668 
		}
 - 
 
1669
- 
 
1670 
		// Analyse des résultats
 - 
 
1671 
		if (count($noms_erreur) > 0) {
 - 
 
1672 
			$info['message']['entete'] = array('num_nom', 'nom_supra_generique erroné');
 - 
 
1673 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1674 
		} else {
 - 
 
1675 
			$info['resultat'] = true;
 - 
 
1676 
		}
 - 
 
1677
- 
 
1678 
		return $info;
 - 
 
1679 
	}
 - 
 
1680
- 
 
1681 
	private function testerNomSupraGeneriqueRang($noms) {
 - 
 
1682 
		$info = array('titre' => "nom_supra_generique -> rang < {$this->manuel['rang_genre']}",
 - 
 
1683 
			'description' => "Si le champ nom_supra_generique n'est pas vide alors le rang du nom doit être inférieur à {$this->manuel['rang_genre']}.",
 - 
 
1684 
			'resultat' => false);
 - 
 
1685
- 
 
1686 
		// Réalisation du test
 - 
 
1687 
		$noms_erreur = array();
 - 
 
1688 
		foreach ($noms as $nom) {
 - 
 
1689 
			if ($nom['nom_supra_generique'] != '') {
 - 
 
1690 
				if ($nom['rang'] >= $this->manuel['rang_genre']) {
 - 
 
1691 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
 - 
 
1692 
				}
 - 
 
1693 
			}
 - 
 
1694 
		}
 - 
 
1695
- 
 
1696 
		// Analyse des résultats
 - 
 
1697 
		if (count($noms_erreur) > 0) {
 - 
 
1698 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
 - 
 
1699 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1700 
		} else {
 - 
 
1701 
			$info['resultat'] = true;
 - 
 
1702 
		}
 - 
 
1703
- 
 
1704 
		return $info;
 - 
 
1705 
	}
 - 
 
1706
- 
 
1707 
	private function testerGenreEspaces($noms) {
 - 
 
1708 
		$info = array('titre' => 'genre -> espaces en trop',
 - 
 
1709 
			'description' => "Le champ genre ne doit pas contenir d'espace avant ou aprés le nom.\n".
 - 
 
1710 
				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
 - 
 
1711 
			'resultat' => false);
 - 
 
1712
- 
 
1713 
		// Réalisation du test
 - 
 
1714 
		$noms_erreur = array();
 - 
 
1715 
		foreach ($noms as $nom) {
 - 
 
1716 
			if ($nom['genre'] != '') {
 - 
 
1717 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) {
 - 
 
1718 
					$nom_traite = $this->repererEspace($nom['genre']);
 - 
 
1719 
					$noms_erreur[] = array($nom['num_nom'], $nom_traite);
 - 
 
1720 
				}
 - 
 
1721 
			}
 - 
 
1722 
		}
 - 
 
1723
- 
 
1724 
		// Analyse des résultats
 - 
 
1725 
		if (count($noms_erreur) > 0) {
 - 
 
1726 
			$info['message']['entete'] = array('num_nom', 'genre erroné');
 - 
 
1727 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1728 
		} else {
 - 
 
1729 
			$info['resultat'] = true;
 - 
 
1730 
		}
 - 
 
1731
- 
 
1732 
		return $info;
 - 
 
1733 
	}
 - 
 
1734
- 
 
1735 
	private function testerGenreSyntaxe($noms) {
 - 
 
1736 
		$info = array('titre' => 'genre -> syntaxe',
 - 
 
1737 
			'description' => "Le champ genre peut contenir :\n".
 - 
 
1738 
			 	" - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
 - 
 
1739 
				"	Il commence par une lettre majuscule (avec ou sans tréma).".
- 
 
1740 
				"	Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n".
 - 
 
1741 
				" - une formule d'hybridité composée d'une série de noms de genre (au moins 2) séparés entre eux \n".
 - 
 
1742 
				"	par la lettre x entourée de caractères espaces.",
 - 
 
1743 
			'resultat' => false);
 - 
 
1744
- 
 
1745 
		// Réalisation du test
 - 
 
1746 
		$noms_erreur = array();
 - 
 
1747 
		foreach ($noms as $nom) {
 - 
 
1748 
			if ($nom['genre'] != '') {
 - 
 
1749 
				$mots = explode(' ', $nom['genre']);
 - 
 
1750 
				foreach ($mots as $mot) {
 - 
 
1751 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) {
 - 
 
1752 
						$nom_traite = $this->repererEspace($nom['genre']);
 - 
 
1753 
						$noms_erreur[] = array($nom['num_nom'], $nom_traite);
 - 
 
1754 
					}
 - 
 
1755 
				}
 - 
 
1756 
			}
 - 
 
1757 
		}
 - 
 
1758
- 
 
1759 
		// Analyse des résultats
 - 
 
1760 
		if (count($noms_erreur) > 0) {
 - 
 
1761 
			$info['message']['entete'] = array('num_nom', 'genre erroné');
 - 
 
1762 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1763 
		} else {
 - 
 
1764 
			$info['resultat'] = true;
 - 
 
1765 
		}
 - 
 
1766
- 
 
1767 
		return $info;
 - 
 
1768 
	}
 - 
 
1769
- 
 
1770 
	private function testerGenreRang($noms) {
 - 
 
1771 
		$info = array('titre' => "genre -> rang >= {$this->manuel['rang_genre']}",
 - 
 
1772 
			'description' => "Si le champ genre n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.",
 - 
 
1773 
			'resultat' => false);
 - 
 
1774
- 
 
1775 
		// Réalisation du test
 - 
 
1776 
		$noms_erreur = array();
 - 
 
1777 
		foreach ($noms as $nom) {
 - 
 
1778 
			if ($nom['genre'] != '') {
 - 
 
1779 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
 - 
 
1780 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
 - 
 
1781 
				}
 - 
 
1782 
			}
 - 
 
1783 
		}
 - 
 
1784
- 
 
1785 
		// Analyse des résultats
 - 
 
1786 
		if (count($noms_erreur) > 0) {
 - 
 
1787 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
 - 
 
1788 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1789 
		} else {
 - 
 
1790 
			$info['resultat'] = true;
 - 
 
1791 
		}
 - 
 
1792
- 
 
1793 
		return $info;
 - 
 
1794 
	}
 - 
 
1795
- 
 
1796 
	private function testerEpitheteInfraGeneriqueSyntaxe($noms) {
 - 
 
1797 
		$info = array('titre' => 'epithete_infra_generique -> syntaxe',
 - 
 
1798 
			'description' => "Le champ epithete_infra_generique est composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
 - 
 
1799 
				"La première lettre (avec ou sans tréma) doit être en majuscule.",
 - 
 
1800 
			'resultat' => false);
 - 
 
1801
- 
 
1802 
		// Réalisation du test
 - 
 
1803 
		$noms_erreur = array();
 - 
 
1804 
		foreach ($noms as $nom) {
 - 
 
1805 
			if ($nom['epithete_infra_generique'] != '') {
 - 
 
1806 
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) {
 - 
 
1807 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
 - 
 
1808 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
 - 
 
1809 
				}
 - 
 
1810 
			}
 - 
 
1811 
		}
 - 
 
1812
- 
 
1813 
		// Analyse des résultats
 - 
 
1814 
		if (count($noms_erreur) > 0) {
 - 
 
1815 
			$info['message']['entete'] = array('num_nom', 'epithete_infra_generique erroné');
 - 
 
1816 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1817 
		} else {
 - 
 
1818 
			$info['resultat'] = true;
 - 
 
1819 
		}
 - 
 
1820
- 
 
1821 
		return $info;
 - 
 
1822 
	}
 - 
 
1823
- 
 
1824 
	private function testerEpitheteInfraGeneriqueRang($noms) {
 - 
 
1825 
		$info = array('titre' => "epithete_infra_generique -> {$this->manuel['rang_genre']} < rang < {$this->manuel['rang_sp']}",
 - 
 
1826 
			'description' => "Si le champ epithete_infra_generique n'est pas vide alors le rang du nom doit être compris \n".
 - 
 
1827 
				"entre {$this->manuel['rang_genre']} et {$this->manuel['rang_sp']}.",
 - 
 
1828 
			'resultat' => false);
 - 
 
1829
- 
 
1830 
		// Réalisation du test
 - 
 
1831 
		$noms_erreur = array();
 - 
 
1832 
		foreach ($noms as $nom) {
 - 
 
1833 
			if ($nom['epithete_infra_generique'] != '') {
 - 
 
1834 
				if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) {
 - 
 
1835 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
 - 
 
1836 
				}
 - 
 
1837 
			}
 - 
 
1838 
		}
 - 
 
1839
- 
 
1840 
		// Analyse des résultats
 - 
 
1841 
		if (count($noms_erreur) > 0) {
 - 
 
1842 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
 - 
 
1843 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1844 
		} else {
 - 
 
1845 
			$info['resultat'] = true;
 - 
 
1846 
		}
 - 
 
1847
- 
 
1848 
		return $info;
 - 
 
1849 
	}
 - 
 
1850
- 
 
1851 
	private function testerEpitheteInfraGeneriqueEspaces($noms) {
 - 
 
1852 
		$info = array('titre' => 'epithete_infra_generique -> espaces en trop',
 - 
 
1853 
			'description' => "Le champ epithete_infra_generique ne doit pas contenir d'espace avant ou aprés sa valeur.",
 - 
 
1854 
			'resultat' => false);
 - 
 
1855
- 
 
1856 
		// Réalisation du test
 - 
 
1857 
		$noms_erreur = array();
 - 
 
1858 
		foreach ($noms as $nom) {
 - 
 
1859 
			if ($nom['epithete_infra_generique'] != '') {
 - 
 
1860 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) {
 - 
 
1861 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
 - 
 
1862 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
 - 
 
1863 
				}
 - 
 
1864 
			}
 - 
 
1865 
		}
 - 
 
1866
- 
 
1867 
		// Analyse des résultats
 - 
 
1868 
		if (count($noms_erreur) > 0) {
 - 
 
1869 
			$info['message']['entete'] = array('num_nom', 'epithete_infra_generique erroné');
 - 
 
1870 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1871 
		} else {
 - 
 
1872 
			$info['resultat'] = true;
 - 
 
1873 
		}
 - 
 
1874
- 
 
1875 
		return $info;
 - 
 
1876 
	}
 - 
 
1877
- 
 
1878 
	private function testerEpitheteSpEspaces($noms) {
 - 
 
1879 
		$info = array('titre' => 'epithete_sp -> espaces en trop',
 - 
 
1880 
			'description' => "Le champ epithete_sp ne doit pas contenir d'espace avant ou aprés le nom.\n".
 - 
 
1881 
				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
 - 
 
1882 
			'resultat' => false);
 - 
 
1883
- 
 
1884 
		// Réalisation du test
 - 
 
1885 
		$noms_erreur = array();
 - 
 
1886 
		foreach ($noms as $nom) {
 - 
 
1887 
			if ($nom['epithete_sp'] != '') {
 - 
 
1888 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) {
 - 
 
1889 
					$epithete_traite = $this->repererEspace($nom['epithete_sp']);
 - 
 
1890 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
 - 
 
1891 
				}
 - 
 
1892 
			}
 - 
 
1893 
		}
 - 
 
1894
- 
 
1895 
		// Analyse des résultats
 - 
 
1896 
		if (count($noms_erreur) > 0) {
 - 
 
1897 
			$info['message']['entete'] = array('num_nom', 'epithete_sp erroné');
 - 
 
1898 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1899 
		} else {
 - 
 
1900 
			$info['resultat'] = true;
 - 
 
1901 
		}
 - 
 
1902
- 
 
1903 
		return $info;
 - 
 
1904 
	}
 - 
 
1905
- 
 
1906 
	private function testerEpitheteSpSyntaxe($noms) {
 - 
 
1907 
		$info = array('titre' => 'epithete_sp -> syntaxe',
 - 
 
1908 
			'description' => "Le champ epithete_sp peut contenir :\n".
 - 
 
1909 
			 	" - un mot unique composé de lettres minuscules [a-z] incluant les caractères [ëï-]. \n".
 - 
 
1910 
				"	Il commence par une lettre minuscule [a-zëï].\n".
- 
 
1911 
				"	Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n".
 - 
 
1912 
				" - un mot contenant sp. suivi d'un ou plusieurs caractères numériques (1-9) ou d'un seul caractère majuscule (A-Z) \n".
 - 
 
1913 
				" - une formule d'hybridité composée d'une série de noms d'espèce (au moins 2) séparés entre eux \n".
 - 
 
1914 
				"	par la lettre x entourée de caractères espaces.",
 - 
 
1915 
			'resultat' => false);
 - 
 
1916
- 
 
1917 
		// Réalisation du test
 - 
 
1918 
		$noms_erreur = array();
 - 
 
1919 
		foreach ($noms as $nom) {
 - 
 
1920 
			if ($nom['epithete_sp'] != '') {
 - 
 
1921 
				$mots = explode(' ', $nom['epithete_sp']);
 - 
 
1922 
				foreach ($mots as $mot) {
 - 
 
1923 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot))) {
 - 
 
1924 
						$epithete_traite = $this->repererEspace($nom['epithete_sp']);
 - 
 
1925 
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
 - 
 
1926 
					}
 - 
 
1927 
				}
 - 
 
1928 
			}
 - 
 
1929 
		}
 - 
 
1930
- 
 
1931 
		// Analyse des résultats
 - 
 
1932 
		if (count($noms_erreur) > 0) {
 - 
 
1933 
			$info['message']['entete'] = array('num_nom', 'epithete_sp erroné');
 - 
 
1934 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1935 
		} else {
 - 
 
1936 
			$info['resultat'] = true;
 - 
 
1937 
		}
 - 
 
1938
- 
 
1939 
		return $info;
 - 
 
1940 
	}
 - 
 
1941
- 
 
1942 
	private function testerEpitheteSpRang($noms) {
 - 
 
1943 
		$info = array('titre' => "epithete_sp -> rang >= {$this->manuel['rang_sp']}",
 - 
 
1944 
			'description' => "Si le champ epithete_sp n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_sp']}.",
 - 
 
1945 
			'resultat' => false);
 - 
 
1946
- 
 
1947 
		// Réalisation du test
 - 
 
1948 
		$noms_erreur = array();
 - 
 
1949 
		foreach ($noms as $nom) {
 - 
 
1950 
			if ($nom['epithete_sp'] != '') {
 - 
 
1951 
				if ($nom['rang'] < $this->manuel['rang_sp']) {
 - 
 
1952 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
 - 
 
1953 
				}
 - 
 
1954 
			}
 - 
 
1955 
		}
 - 
 
1956
- 
 
1957 
		// Analyse des résultats
 - 
 
1958 
		if (count($noms_erreur) > 0) {
 - 
 
1959 
			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
 - 
 
1960 
			$info['message']['lignes'] = $noms_erreur;
 - 
 
1961 
		} else {
 - 
 
1962 
			$info['resultat'] = true;
 - 
 
1963 
		}
 - 
 
1964
- 
 
1965 
		return $info;
 - 
 
1966 
	}
 - 
 
1967
- 
 
1968 
	//+--------------------------------------------------------------------------------------------------------------+//
 - 
 
1969 
	// MÉTHODES COMMUNES aux TESTS
 - 
 
1970
- 
 
1971 
	private function verifierPresence($valeur) {
 - 
 
1972 
		$codes = $this->manuel['codes_presence'];
 - 
 
1973 
		$ok = $this->verifierStatuts($valeur, $codes);
 - 
 
1974 
		return $ok;
 - 
 
1975 
	}
 - 
 
1976
- 
 
1977 
	private function verifierStatutOrigine($valeur) {
 - 
 
1978 
		$codes = $this->manuel['codes_statuts_origine'];
 - 
 
1979 
		$ok = $this->verifierStatuts($valeur, $codes);
 - 
 
1980 
		return $ok;
 - 
 
1981 
	}
 - 
 
1982
- 
 
1983 
	private function verifierStatutIntroduction($valeur) {
 - 
 
1984 
		$codes = $this->manuel['codes_statuts_introduction'];
 - 
 
1985 
		$ok = $this->verifierStatuts($valeur, $codes);
 - 
 
1986 
		return $ok;
 - 
 
1987 
	}
 - 
 
1988
- 
 
1989 
	private function verifierStatutCulture($valeur) {
 - 
 
1990 
		$codes = $this->manuel['codes_statuts_culture'];
 - 
 
1991 
		$ok = $this->verifierStatuts($valeur, $codes);
 - 
 
1992 
		return $ok;
 - 
 
1993 
	}
 - 
 
1994
- 
 
1995 
	private function verifierStatuts($valeur, $codes) {
 - 
 
1996 
		$ok = true;
 - 
 
1997 
		if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
 - 
 
1998 
			$ok = false;
 - 
 
1999 
		}
 - 
 
2000 
		return $ok;
 - 
 
2001 
	}
 - 
 
2002
- 
 
2003 
	private function verifierBooleen($valeur) {
 - 
 
2004 
		$ok = true;
 - 
 
2005 
		if (!preg_match('/^1$/', $valeur)) {
 - 
 
2006 
			$ok = false;
 - 
 
2007 
		}
 - 
 
2008 
		return $ok;
 - 
 
2009 
	}
 - 
 
2010
- 
 
2011 
	private function verifierNombre($valeur) {
 - 
 
2012 
		$ok = true;
 - 
 
2013 
		if (!preg_match('/^[0-9]+$/', $valeur)) {
 - 
 
2014 
			$ok = false;
 - 
 
2015 
		}
 - 
 
2016 
		return $ok;
 - 
 
2017 
	}
 - 
 
2018
- 
 
2019 
	private function verifierNombreSuite($valeur) {
 - 
 
2020 
		$ok = true;
 - 
 
2021 
		if (!preg_match('/^(?:[0-9]+,)*[0-9]+$/', $valeur)) {
 - 
 
2022 
			$ok = false;
 - 
 
2023 
		}
 - 
 
2024 
		return $ok;
 - 
 
2025 
	}
 - 
 
2026
- 
 
2027 
	private function verifierTypeEpithete($type) {
 - 
 
2028 
		$ok = false;
 - 
 
2029 
		$rejetes = $this->manuel['type_epithete_rejetes'];
 - 
 
2030 
		if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
 - 
 
2031 
			$ok = false;
 - 
 
2032 
		} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
 - 
 
2033 
			$ok = true;
 - 
 
2034 
		}
 - 
 
2035 
		return $ok;
 - 
 
2036 
	}
 - 
 
2037
- 
 
2038 
	private function verifierBiblioOrigine($intitule) {
 - 
 
2039 
		$ok = true;
 - 
 
2040 
		if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
 - 
 
2041 
			$ok = false;// Contient des espaces en trop
 - 
 
2042 
		} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
 - 
 
2043 
			$ok = false;
 - 
 
2044 
		} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
 - 
 
2045 
			$ok = false;// Contient une mauvaise suite de caractères
 - 
 
2046 
		}
 - 
 
2047 
		return $ok;
 - 
 
2048 
	}
 - 
 
2049
- 
 
2050 
	private function verifierAnnee($annee) {
 - 
 
2051 
		$ok = true;
 - 
 
2052 
		if (!preg_match('/^[0-9]{4}$/', $annee)) {
 - 
 
2053 
			$ok = false;
 - 
 
2054 
		} else if ($annee < 1753) {
 - 
 
2055 
			$ok = false;
 - 
 
2056 
		}
 - 
 
2057 
		return $ok;
 - 
 
2058 
	}
 - 
 
2059
- 
 
2060 
	private function verifierAuteur($intitule) {
 - 
 
2061 
		$ok = true;
 - 
 
2062 
		$acceptes = $this->manuel['auteur_acceptes'];
 - 
 
2063 
		if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
 - 
 
2064 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
 - 
 
2065 
				$ok = false;// Contient des espaces en trop
 - 
 
2066 
			} else {
 - 
 
2067 
				$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
 - 
 
2068 
				$mots = explode(' ', $intitule);
 - 
 
2069 
				foreach ($mots as $position => $mot) {
 - 
 
2070 
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
 - 
 
2071 
						$ok = false;// Mot rejeté
 - 
 
2072 
					} else if (preg_match("/^(?:(?:\p{L}|[.'\(\)-])+|[&])$/u", $mot)) {
 - 
 
2073 
						continue;// Mot de l'intitulé auteur
 - 
 
2074 
					} else {
 - 
 
2075 
						$ok = false;
 - 
 
2076 
					}
 - 
 
2077 
				}
 - 
 
2078 
			}
 - 
 
2079 
		}
 - 
 
2080 
		return $ok;
 - 
 
2081 
	}
 - 
 
2082
- 
 
2083 
	private function verifierNomCommercial($epithete) {
 - 
 
2084 
		$ok = false;
 - 
 
2085 
		if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
 - 
 
2086 
			$ok = true;
 - 
 
2087 
		}
 - 
 
2088 
		return $ok;
 - 
 
2089 
	}
 - 
 
2090
- 
 
2091 
	private function verifierEpitheteCultivar($epithete) {
 - 
 
2092 
		$ok = true;
 - 
 
2093 
		$acceptes = $this->manuel['cultivar_acceptes'];
 - 
 
2094 
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
 - 
 
2095 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
 - 
 
2096 
				$ok = false;// Contient des espaces en trop
 - 
 
2097 
			} else {
 - 
 
2098 
				$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
 - 
 
2099 
				$mots_mineurs = $this->manuel['mots_mineurs'];
 - 
 
2100 
				$mots = explode(' ', $epithete);
 - 
 
2101 
				foreach ($mots as $position => $mot) {
 - 
 
2102 
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
 - 
 
2103 
						$ok = false;// Mot rejeté
 - 
 
2104 
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
 - 
 
2105 
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
 - 
 
2106 
					} else {
 - 
 
2107 
						$mots_tiret = explode('-', $mot);
 - 
 
2108 
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
 - 
 
2109 
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
 - 
 
2110 
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
 - 
 
2111 
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
 - 
 
2112 
								continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
 - 
 
2113 
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
 - 
 
2114 
								continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
 - 
 
2115 
							} else {
 - 
 
2116 
								$ok = false;
 - 
 
2117 
							}
 - 
 
2118 
						}
 - 
 
2119 
					}
 - 
 
2120 
				}
 - 
 
2121 
			}
 - 
 
2122 
		}
 - 
 
2123 
		return $ok;
 - 
 
2124 
	}
 - 
 
2125
- 
 
2126 
	private function verifierEpitheteGroupeCultivar($epithete) {
 - 
 
2127 
		$ok = true;
 - 
 
2128 
		$acceptes = $this->manuel['cultivar_gp_acceptes'];
 - 
 
2129 
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
 - 
 
2130 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
 - 
 
2131 
				$ok = false;// Contient des espaces en trop
 - 
 
2132 
			} else {
 - 
 
2133 
				$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
 - 
 
2134 
				$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
 - 
 
2135 
				$mots_mineurs = $this->manuel['mots_mineurs'];
 - 
 
2136 
				$mots = explode(' ', $epithete);
 - 
 
2137 
				foreach ($mots as $position => $mot) {
 - 
 
2138 
					if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
 - 
 
2139 
						continue;// Mot accepté
 - 
 
2140 
					} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
 - 
 
2141 
						$ok = false;// Mot rejeté
 - 
 
2142 
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
 - 
 
2143 
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
 - 
 
2144 
					} else {
 - 
 
2145 
						$mots_tiret = explode('-', $mot);
 - 
 
2146 
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
 - 
 
2147 
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
 - 
 
2148 
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
 - 
 
2149 
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
 - 
 
2150 
								continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
 - 
 
2151 
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
 - 
 
2152 
								continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
 - 
 
2153 
							} else {
 - 
 
2154 
								$ok = false;
 - 
 
2155 
							}
 - 
 
2156 
						}
 - 
 
2157 
					}
 - 
 
2158 
				}
 - 
 
2159 
			}
 - 
 
2160 
		}
 - 
 
2161 
		return $ok;
 - 
 
2162 
	}
 - 
 
2163
- 
 
2164 
	private function verifierEpitheteSp($epithete) {
 - 
 
2165 
		$ok = false;
 - 
 
2166 
		if (preg_match('/^[a-zëï][-a-zëï]+$/', $epithete)) {
 - 
 
2167 
			$ok = true;
 - 
 
2168 
		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
 - 
 
2169 
			$ok = true;
 - 
 
2170 
		}
 - 
 
2171 
		return $ok;
 - 
 
2172 
	}
 - 
 
2173
- 
 
2174 
	private function verifierEpitheteGenre($epithete) {
 - 
 
2175 
		$ok = false;
 - 
 
2176 
		if (preg_match('/^[A-ZËÏ](?:[-a-zëï]+|[a-zëï]+-[A-ZËÏ][a-zëï]+)$/', $epithete)) {
 - 
 
2177 
			$ok = true;
 - 
 
2178 
		}
 - 
 
2179 
		return $ok;
 - 
 
2180 
	}
 - 
 
2181
- 
 
2182 
	private function formaterStyleNomGenre($genre) {
 - 
 
2183 
		$genre_fmt = '';
 - 
 
2184 
		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
 - 
 
2185 
			$genre_fmt = strtolower($match[1]).' '.ucfirst(strtolower($match[2]));
 - 
 
2186 
		} else {
 - 
 
2187 
			$genre_fmt = ucfirst(strtolower($genre));
 - 
 
2188 
		}
 - 
 
2189 
		return $genre_fmt;
 - 
 
2190 
	}
 - 
 
2191
- 
 
2192 
	private function repererEspace($nom_complet) {
 - 
 
2193 
		$nom_complet = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_complet);
 - 
 
2194 
		return $nom_complet;
 - 
 
2195 
	}
 - 
 
2196
- 
 
2197 
	private function construireSuffixeNomPltCultivee($nom) {
 - 
 
2198 
		$suffixe = array();
 - 
 
2199 
		$suffixe[] = $this->construireNomCultivarGroupe($nom);
 - 
 
2200 
		$suffixe[] = $this->construireNomCommercial($nom);
 - 
 
2201 
		$suffixe[] = $this->construireNomCultivar($nom);
 - 
 
2202 
		$suffixe = array_filter($suffixe);
 - 
 
2203 
		return implode(' ', $suffixe);
 - 
 
2204 
	}
 - 
 
2205
- 
 
2206 
	private function construireNomCultivarGroupe($nom) {
 - 
 
2207 
		$nom_groupe_cultivar = '';
 - 
 
2208 
		if ($nom['cultivar_groupe'] != '') {
 - 
 
2209 
			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
 - 
 
2210 
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
 - 
 
2211 
			} else {
 - 
 
2212 
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
 - 
 
2213 
			}
 - 
 
2214 
		}
 - 
 
2215 
		return $nom_groupe_cultivar;
 - 
 
2216 
	}
 - 
 
2217
- 
 
2218 
	private function construireNomCommercial($nom) {
 - 
 
2219 
		$nom_commercial = '';
 - 
 
2220 
		if ($nom['nom_commercial'] != '') {
 - 
 
2221 
			$nom_commercial =  strtoupper($nom['nom_commercial']);
 - 
 
2222 
		}
 - 
 
2223 
		return $nom_commercial;
 - 
 
2224 
	}
 - 
 
2225
- 
 
2226 
	private function construireNomCultivar($nom) {
 - 
 
2227 
		$nom_cultivar = '';
 - 
 
2228 
		if ($nom['cultivar'] != '') {
 - 
 
2229 
			$nom_cultivar =  "'".$nom['cultivar']."'";
 - 
 
2230 
		}
 - 
 
2231 
		return $nom_cultivar;
 - 
 
2232 
	}
 - 
 
2233
- 
 
2234 
	private function classerNomsParNumNom($noms) {
 - 
 
2235 
		$noms_classes = array();
 - 
 
2236 
		foreach ($noms as $nom) {
 - 
 
2237 
			$noms_classes[$nom['num_nom']] = $nom;
 - 
 
2238 
		}
 - 
 
2239 
		return $noms_classes;
 - 
 
2240 
	}
 - 
 
2241
- 
 
2242 
	private function classerNomsParNomComplet($noms) {
 - 
 
2243 
		$noms_classes = array();
 - 
 
2244 
		foreach ($noms as $nom) {
 - 
 
2245 
			if (!isset($noms_classes[$nom['nom_complet']])) {
 - 
 
2246 
				$noms_classes[$nom['nom_complet']] = 1;
 - 
 
2247 
			} else {
 - 
 
2248 
				$noms_classes[$nom['nom_complet']]++;
 - 
 
2249 
			}
 - 
 
2250 
		}
 - 
 
2251 
		return $noms_classes;
 - 
 
2252 
	}
 46
2253 
}
 47 
}
2254 
?>
 48 
?>