| Line 47... |
Line 47... |
| 47 |
|
47 |
|
| 48 |
// Récupération des données à tester
|
48 |
// Récupération des données à tester
|
| 49 |
$colonnes = $this->tableStructureDao->getColonnes($this->projet);
|
49 |
$colonnes = $this->tableStructureDao->getColonnes($this->projet);
|
| 50 |
$analyses = $this->tableStructureDao->getAnalyse($this->projet);
|
50 |
$analyses = $this->tableStructureDao->getAnalyse($this->projet);
|
| 51 |
$noms = $this->referentielDao->getTout($this->projet);
|
51 |
$noms = $this->referentielDao->getTout($this->projet);
|
| - |
|
52 |
$noms = $this->classerNomsParNumNom($noms);
|
| Line 52... |
Line 53... |
| 52 |
$noms = $this->classerNoms($noms);
|
53 |
$noms_homonymie = $this->classerNomsParNomComplet($noms);
|
| 53 |
|
54 |
|
| 54 |
// Lancement des tests unitaires
|
55 |
// Lancement des tests unitaires
|
| 55 |
/*
|
56 |
/*
|
| Line 97... |
Line 98... |
| 97 |
$donnees['tests'][] = $this->testerTypeEpitheteHybridite($noms);
|
98 |
$donnees['tests'][] = $this->testerTypeEpitheteHybridite($noms);
|
| Line 98... |
Line 99... |
| 98 |
|
99 |
|
| 99 |
$donnees['tests'][] = $this->testerEpitheteInfraSpEspaces($noms);
|
100 |
$donnees['tests'][] = $this->testerEpitheteInfraSpEspaces($noms);
|
| 100 |
$donnees['tests'][] = $this->testerEpitheteInfraSpSyntaxe($noms);
|
101 |
$donnees['tests'][] = $this->testerEpitheteInfraSpSyntaxe($noms);
|
| 101 |
$donnees['tests'][] = $this->testerEpitheteInfraSpRang($noms);
|
102 |
$donnees['tests'][] = $this->testerEpitheteInfraSpRang($noms);
|
| 102 |
*/
|
103 |
|
| - |
|
104 |
$donnees['tests'][] = $this->testerGroupeCultivarSyntaxe($noms);
|
| - |
|
105 |
$donnees['tests'][] = $this->testerGroupeCultivarRang($noms);
|
| - |
|
106 |
|
| - |
|
107 |
$donnees['tests'][] = $this->testerCultivarSyntaxe($noms);
|
| - |
|
108 |
$donnees['tests'][] = $this->testerCultivarRang($noms);
|
| - |
|
109 |
|
| - |
|
110 |
$donnees['tests'][] = $this->testerNomCommercialSyntaxe($noms);
|
| - |
|
111 |
$donnees['tests'][] = $this->testerNomCommercialPresenceCultivar($noms);
|
| - |
|
112 |
|
| - |
|
113 |
$donnees['tests'][] = $this->testerAuteurSyntaxe($noms);
|
| - |
|
114 |
|
| - |
|
115 |
$donnees['tests'][] = $this->testerAnneeSyntaxe($noms);
|
| - |
|
116 |
|
| - |
|
117 |
$donnees['tests'][] = $this->testerBiblioOrigineSyntaxe($noms);
|
| - |
|
118 |
|
| - |
|
119 |
$donnees['tests'][] = $this->testerHomonymieSyntaxe($noms);
|
| - |
|
120 |
$donnees['tests'][] = $this->testerHomonymieExistence($noms, $noms_homonymie);
|
| - |
|
121 |
|
| - |
|
122 |
$donnees['tests'][] = $this->testerBasionymeSyntaxe($noms);
|
| - |
|
123 |
$donnees['tests'][] = $this->testerBasionymeExistence($noms);
|
| - |
|
124 |
|
| - |
|
125 |
$donnees['tests'][] = $this->testerSynonymeProparteSyntaxe($noms);
|
| - |
|
126 |
$donnees['tests'][] = $this->testerSynonymeProparteExistence($noms);
|
| - |
|
127 |
*/
|
| - |
|
128 |
|
| - |
|
129 |
$donnees['tests'][] = $this->testerSynonymeDouteuxSyntaxe($noms);
|
| Line 103... |
Line 130... |
| 103 |
$donnees['tests'][] = $this->testerGroupeCultivarSyntaxe($noms);
|
130 |
$donnees['tests'][] = $this->testerSynonymeMalAppliqueSyntaxe($noms);
|
| 104 |
|
131 |
|
| 105 |
//Debug::printr($this->manuel);
|
132 |
//Debug::printr($this->manuel);
|
| Line 106... |
Line 133... |
| 106 |
$this->setSortie(self::RENDU_CORPS, $this->getVue('test', $donnees));
|
133 |
$this->setSortie(self::RENDU_CORPS, $this->getVue('test', $donnees));
|
| 107 |
}
|
134 |
}
|
| - |
|
135 |
|
| - |
|
136 |
//+--------------------------------------------------------------------------------------------------------------+//
|
| - |
|
137 |
// TESTS
|
| - |
|
138 |
|
| - |
|
139 |
private function testerSynonymeMalAppliqueSyntaxe($noms) {
|
| - |
|
140 |
$info = array('titre' => 'synonyme_mal_applique -> syntaxe',
|
| - |
|
141 |
'description' => "Le champ synonyme_mal_applique contient soit :\n".
|
| - |
|
142 |
" - une valeur vide.\n".
|
| - |
|
143 |
" - le chiffre 1",
|
| - |
|
144 |
'resultat' => false);
|
| - |
|
145 |
|
| - |
|
146 |
// Réalisation du test
|
| - |
|
147 |
$noms_erreur = array();
|
| - |
|
148 |
foreach ($noms as $nom) {
|
| - |
|
149 |
if ($nom['synonyme_mal_applique'] != '') {
|
| - |
|
150 |
if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
|
| - |
|
151 |
$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique']);
|
| - |
|
152 |
}
|
| - |
|
153 |
}
|
| - |
|
154 |
}
|
| - |
|
155 |
|
| - |
|
156 |
// Analyse des résultats
|
| - |
|
157 |
if (count($noms_erreur) > 0) {
|
| - |
|
158 |
$info['message']['entete'] = array('num_nom', 'synonyme_mal_applique erroné');
|
| - |
|
159 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
160 |
} else {
|
| - |
|
161 |
$info['resultat'] = true;
|
| - |
|
162 |
}
|
| - |
|
163 |
|
| - |
|
164 |
return $info;
|
| - |
|
165 |
}
|
| - |
|
166 |
|
| - |
|
167 |
private function testerSynonymeDouteuxSyntaxe($noms) {
|
| - |
|
168 |
$info = array('titre' => 'synonyme_douteux -> syntaxe',
|
| - |
|
169 |
'description' => "Le champ synonyme_douteux contient soit :\n".
|
| - |
|
170 |
" - une valeur vide.\n".
|
| - |
|
171 |
" - le chiffre 1",
|
| - |
|
172 |
'resultat' => false);
|
| - |
|
173 |
|
| - |
|
174 |
// Réalisation du test
|
| - |
|
175 |
$noms_erreur = array();
|
| - |
|
176 |
foreach ($noms as $nom) {
|
| - |
|
177 |
if ($nom['synonyme_douteux'] != '') {
|
| - |
|
178 |
if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
|
| - |
|
179 |
$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux']);
|
| - |
|
180 |
}
|
| - |
|
181 |
}
|
| - |
|
182 |
}
|
| - |
|
183 |
|
| - |
|
184 |
// Analyse des résultats
|
| - |
|
185 |
if (count($noms_erreur) > 0) {
|
| - |
|
186 |
$info['message']['entete'] = array('num_nom', 'synonyme_douteux erroné');
|
| - |
|
187 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
188 |
} else {
|
| - |
|
189 |
$info['resultat'] = true;
|
| - |
|
190 |
}
|
| - |
|
191 |
|
| - |
|
192 |
return $info;
|
| - |
|
193 |
}
|
| - |
|
194 |
|
| - |
|
195 |
private function testerSynonymeProparteExistence($noms) {
|
| - |
|
196 |
$info = array('titre' => 'synonyme_proparte -> existence',
|
| - |
|
197 |
'description' => "Si le champ synonyme_proparte contient un ou plusieurs nombres alors chacun d'entre eux ".
|
| - |
|
198 |
"doit correspondre à une valeur du champ num_nom.",
|
| - |
|
199 |
'resultat' => false);
|
| - |
|
200 |
|
| - |
|
201 |
// Réalisation du test
|
| - |
|
202 |
$noms_erreur = array();
|
| - |
|
203 |
foreach ($noms as $nom) {
|
| - |
|
204 |
if ($nom['synonyme_proparte'] != '') {
|
| - |
|
205 |
$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
|
| - |
|
206 |
$num_nom_en_erreur = array();
|
| - |
|
207 |
foreach ($num_nom_a_verifier as $num_nom) {
|
| - |
|
208 |
if (!isset($noms[$num_nom])) {
|
| - |
|
209 |
$num_nom_en_erreur[] = $num_nom;
|
| - |
|
210 |
}
|
| - |
|
211 |
}
|
| - |
|
212 |
if (count($nbre_en_erreur) > 0) {
|
| - |
|
213 |
$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur));
|
| - |
|
214 |
}
|
| - |
|
215 |
}
|
| - |
|
216 |
}
|
| - |
|
217 |
|
| - |
|
218 |
// Analyse des résultats
|
| - |
|
219 |
if (count($noms_erreur) > 0) {
|
| - |
|
220 |
$info['message']['entete'] = array('num_nom', 'synonyme_proparte introuvable');
|
| - |
|
221 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
222 |
} else {
|
| - |
|
223 |
$info['resultat'] = true;
|
| - |
|
224 |
}
|
| - |
|
225 |
|
| - |
|
226 |
return $info;
|
| - |
|
227 |
}
|
| - |
|
228 |
|
| - |
|
229 |
private function testerSynonymeProparteSyntaxe($noms) {
|
| - |
|
230 |
$info = array('titre' => 'synonyme_proparte -> syntaxe',
|
| - |
|
231 |
'description' => "Le champ synonyme_proparte contient soit :\n".
|
| - |
|
232 |
" - une valeur vide.\n".
|
| - |
|
233 |
" - un nombre.\n".
|
| - |
|
234 |
" - une suite de nombre séparés par des virgules.",
|
| - |
|
235 |
'resultat' => false);
|
| - |
|
236 |
|
| - |
|
237 |
// Réalisation du test
|
| - |
|
238 |
$noms_erreur = array();
|
| - |
|
239 |
foreach ($noms as $nom) {
|
| - |
|
240 |
if ($nom['synonyme_proparte'] != '') {
|
| - |
|
241 |
if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
|
| - |
|
242 |
$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte']);
|
| - |
|
243 |
}
|
| - |
|
244 |
}
|
| - |
|
245 |
}
|
| - |
|
246 |
|
| - |
|
247 |
// Analyse des résultats
|
| - |
|
248 |
if (count($noms_erreur) > 0) {
|
| - |
|
249 |
$info['message']['entete'] = array('num_nom', 'synonyme_proparte erroné');
|
| - |
|
250 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
251 |
} else {
|
| - |
|
252 |
$info['resultat'] = true;
|
| - |
|
253 |
}
|
| - |
|
254 |
|
| - |
|
255 |
return $info;
|
| - |
|
256 |
}
|
| - |
|
257 |
|
| - |
|
258 |
private function testerBasionymeExistence($noms) {
|
| - |
|
259 |
$info = array('titre' => 'basionyme -> existence',
|
| - |
|
260 |
'description' => "Si le champ basionyme contient un nombre alors il doit correspondre à une valeur du champ ".
|
| - |
|
261 |
"num_nom.",
|
| - |
|
262 |
'resultat' => false);
|
| - |
|
263 |
|
| - |
|
264 |
// Réalisation du test
|
| - |
|
265 |
$noms_erreur = array();
|
| - |
|
266 |
foreach ($noms as $nom) {
|
| - |
|
267 |
if ($nom['basionyme'] != '') {
|
| - |
|
268 |
if (!isset($noms[$nom['basionyme']])) {
|
| - |
|
269 |
$noms_erreur[] = array($nom['num_nom'], $nom['basionyme']);
|
| - |
|
270 |
}
|
| - |
|
271 |
}
|
| - |
|
272 |
}
|
| - |
|
273 |
|
| - |
|
274 |
// Analyse des résultats
|
| - |
|
275 |
if (count($noms_erreur) > 0) {
|
| - |
|
276 |
$info['message']['entete'] = array('num_nom', 'basionyme introuvable');
|
| - |
|
277 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
278 |
} else {
|
| - |
|
279 |
$info['resultat'] = true;
|
| - |
|
280 |
}
|
| - |
|
281 |
|
| - |
|
282 |
return $info;
|
| - |
|
283 |
}
|
| - |
|
284 |
|
| - |
|
285 |
private function testerBasionymeSyntaxe($noms) {
|
| - |
|
286 |
$info = array('titre' => 'basionyme -> syntaxe',
|
| 108 |
|
287 |
'description' => "Le champ basionyme contient :\n".
|
| - |
|
288 |
" - un nombre ou une valeur vide.\n",
|
| - |
|
289 |
'resultat' => false);
|
| - |
|
290 |
|
| - |
|
291 |
// Réalisation du test
|
| - |
|
292 |
$noms_erreur = array();
|
| - |
|
293 |
foreach ($noms as $nom) {
|
| - |
|
294 |
if ($nom['basionyme'] != '') {
|
| - |
|
295 |
if (!$this->verifierNombre($nom['basionyme'])) {
|
| - |
|
296 |
$noms_erreur[] = array($nom['num_nom'], $nom['basionyme']);
|
| - |
|
297 |
}
|
| - |
|
298 |
}
|
| - |
|
299 |
}
|
| - |
|
300 |
|
| - |
|
301 |
// Analyse des résultats
|
| - |
|
302 |
if (count($noms_erreur) > 0) {
|
| - |
|
303 |
$info['message']['entete'] = array('num_nom', 'basionyme erroné');
|
| - |
|
304 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
305 |
} else {
|
| - |
|
306 |
$info['resultat'] = true;
|
| - |
|
307 |
}
|
| - |
|
308 |
|
| - |
|
309 |
return $info;
|
| - |
|
310 |
}
|
| - |
|
311 |
|
| - |
|
312 |
private function testerHomonymieExistence($noms, $noms_homonymie) {
|
| - |
|
313 |
$info = array('titre' => 'homonyme -> existence',
|
| - |
|
314 |
'description' => "Si le champ homonyme contient «1» alors plusieurs noms doivent posséder la même valeur ".
|
| - |
|
315 |
"dans le champ nom_complet.",
|
| - |
|
316 |
'resultat' => false);
|
| - |
|
317 |
|
| - |
|
318 |
// Réalisation du test
|
| - |
|
319 |
$noms_erreur = array();
|
| - |
|
320 |
foreach ($noms as $nom) {
|
| - |
|
321 |
if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
|
| - |
|
322 |
if ($noms_homonymie[$nom['nom_complet']] <= 1) {
|
| - |
|
323 |
$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet']);
|
| - |
|
324 |
}
|
| - |
|
325 |
}
|
| - |
|
326 |
}
|
| - |
|
327 |
|
| - |
|
328 |
// Analyse des résultats
|
| - |
|
329 |
if (count($noms_erreur) > 0) {
|
| - |
|
330 |
$info['message']['entete'] = array('num_nom', 'homonyme introuvable');
|
| - |
|
331 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
332 |
} else {
|
| - |
|
333 |
$info['resultat'] = true;
|
| - |
|
334 |
}
|
| - |
|
335 |
|
| - |
|
336 |
return $info;
|
| - |
|
337 |
}
|
| - |
|
338 |
|
| - |
|
339 |
private function testerHomonymieSyntaxe($noms) {
|
| - |
|
340 |
$info = array('titre' => 'homonyme -> syntaxe',
|
| - |
|
341 |
'description' => "Le champ homonyme contient :\n".
|
| - |
|
342 |
" - le chiffre 1 ou une valeur vide.\n",
|
| - |
|
343 |
'resultat' => false);
|
| - |
|
344 |
|
| - |
|
345 |
// Réalisation du test
|
| - |
|
346 |
$noms_erreur = array();
|
| - |
|
347 |
foreach ($noms as $nom) {
|
| - |
|
348 |
if ($nom['homonyme'] != '') {
|
| - |
|
349 |
if (!$this->verifierBooleen($nom['homonyme'])) {
|
| - |
|
350 |
$noms_erreur[] = array($nom['num_nom'], $nom['homonyme']);
|
| - |
|
351 |
}
|
| - |
|
352 |
}
|
| - |
|
353 |
}
|
| - |
|
354 |
|
| - |
|
355 |
// Analyse des résultats
|
| - |
|
356 |
if (count($noms_erreur) > 0) {
|
| - |
|
357 |
$info['message']['entete'] = array('num_nom', 'homonyme erroné');
|
| - |
|
358 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
359 |
} else {
|
| - |
|
360 |
$info['resultat'] = true;
|
| - |
|
361 |
}
|
| - |
|
362 |
|
| - |
|
363 |
return $info;
|
| - |
|
364 |
}
|
| - |
|
365 |
|
| - |
|
366 |
private function testerBiblioOrigineSyntaxe($noms) {
|
| - |
|
367 |
$info = array('titre' => 'biblio_origine -> syntaxe',
|
| - |
|
368 |
'description' => "Le champ biblio_origine se compose de plusieurs parties séparées par des caractères ".
|
| - |
|
369 |
"précis qui sont dans l'ordre de gauche à droite :\n".
|
| - |
|
370 |
" - Éventuellement le mot « in » suivi d'un intitulé auteur (utilisé pour indiquer l'intitulé auteur de ".
|
| - |
|
371 |
"l'ouvrage global dans lequel la publication est parue).\n".
|
| - |
|
372 |
" - point-virgule « ; » (si l'info précédent a été renseignée)\n".
|
| - |
|
373 |
" - Abréviation ou nom de l'ouvrage ou de la revue selon le standard en vigueur dans le code du nom. ".
|
| - |
|
374 |
"Cette information ne doit pas contenir de caractère virgule « , ».\n".
|
| - |
|
375 |
" - virgule « , »\n".
|
| - |
|
376 |
" - Les informations permettant d'identifier plus précisément le document contenant le nom... ".
|
| - |
|
377 |
"Par exemple, l'éditeur, le tome, le numéro d'édition, le volume... séparées par des virgules ou d'autres ".
|
| - |
|
378 |
"caractères sauf deux points « : ».\n".
|
| - |
|
379 |
" - deux points « : »\n".
|
| - |
|
380 |
" - la page contenant la publication du nom ou un ensemble de page (première et dernière page de ".
|
| - |
|
381 |
"l'ensemble séparées par un tiret « - »). Quelques fois des numéros ou d'autres informations indiquant ".
|
| - |
|
382 |
"dans le document la position du nom. Le tiret « - » doit toujours servir à séparer un ensemble.",
|
| - |
|
383 |
'resultat' => false);
|
| - |
|
384 |
|
| - |
|
385 |
// Réalisation du test
|
| - |
|
386 |
$noms_erreur = array();
|
| - |
|
387 |
foreach ($noms as $nom) {
|
| - |
|
388 |
if ($nom['biblio_origine'] != '') {
|
| - |
|
389 |
if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
|
| - |
|
390 |
$biblio_traite = $this->repererEspace($nom['biblio_origine']);
|
| - |
|
391 |
$noms_erreur[] = array($nom['num_nom'], $biblio_traite);
|
| - |
|
392 |
}
|
| - |
|
393 |
}
|
| - |
|
394 |
}
|
| - |
|
395 |
|
| - |
|
396 |
// Analyse des résultats
|
| - |
|
397 |
if (count($noms_erreur) > 0) {
|
| - |
|
398 |
$info['message']['entete'] = array('num_nom', 'biblio_origine erroné');
|
| - |
|
399 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
400 |
} else {
|
| - |
|
401 |
$info['resultat'] = true;
|
| - |
|
402 |
}
|
| - |
|
403 |
|
| - |
|
404 |
return $info;
|
| - |
|
405 |
}
|
| - |
|
406 |
|
| - |
|
407 |
private function testerAnneeSyntaxe($noms) {
|
| - |
|
408 |
$info = array('titre' => 'annee -> syntaxe',
|
| - |
|
409 |
'description' => "Le champ annee doit :\n".
|
| - |
|
410 |
" - contenir un nombre de 4 chiffre\n".
|
| - |
|
411 |
" - être supérieur ou égal à 1753 ",
|
| - |
|
412 |
'resultat' => false);
|
| - |
|
413 |
|
| - |
|
414 |
// Réalisation du test
|
| - |
|
415 |
$noms_erreur = array();
|
| - |
|
416 |
foreach ($noms as $nom) {
|
| - |
|
417 |
if ($nom['annee'] != '') {
|
| - |
|
418 |
if (!$this->verifierAnnee($nom['annee'])) {
|
| - |
|
419 |
$noms_erreur[] = array($nom['num_nom'], $nom['annee']);
|
| - |
|
420 |
}
|
| - |
|
421 |
}
|
| - |
|
422 |
}
|
| - |
|
423 |
|
| - |
|
424 |
// Analyse des résultats
|
| - |
|
425 |
if (count($noms_erreur) > 0) {
|
| - |
|
426 |
$info['message']['entete'] = array('num_nom', 'annee erroné');
|
| - |
|
427 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
428 |
} else {
|
| - |
|
429 |
$info['resultat'] = true;
|
| - |
|
430 |
}
|
| - |
|
431 |
|
| - |
|
432 |
return $info;
|
| - |
|
433 |
}
|
| - |
|
434 |
|
| - |
|
435 |
private function testerAuteurSyntaxe($noms) {
|
| - |
|
436 |
$info = array('titre' => 'auteur -> syntaxe',
|
| - |
|
437 |
'description' => "Le champ auteur doit :\n".
|
| - |
|
438 |
" - contenir l'intitulé complet des noms de l'auteur ou des auteurs ayant publiés à l'origine la combinaison latine courante.\n".
|
| - |
|
439 |
" - 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".
|
| - |
|
440 |
" - 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".
|
| - |
|
441 |
" - contenir, si nécessaire, des abréviations de noms d'auteurs respectant les standards.\n".
|
| - |
|
442 |
" - contenir une translittération des noms d'alphabet cyrillique, arabe, chinois... en alphabet latin.\n".
|
| - |
|
443 |
" - inclure entre parenthèses l'intitulé des noms de l'auteur ou des auteurs ayant publié le basionyme.\n".
|
| - |
|
444 |
" - toujours utiliser l'esperluette (&) à la place du mot « et » pour séparer les noms d'auteurs.\n".
|
| - |
|
445 |
" - conformément à la recommandation 46C.2 du CINB, si une un citation comprend plus de deux auteurs, ".
|
| - |
|
446 |
"elle devrait être limitée au nom du premier, suivi de « & al.».\n",
|
| - |
|
447 |
'resultat' => false);
|
| - |
|
448 |
|
| - |
|
449 |
// Réalisation du test
|
| - |
|
450 |
$noms_erreur = array();
|
| - |
|
451 |
foreach ($noms as $nom) {
|
| - |
|
452 |
if ($nom['auteur'] != '') {
|
| - |
|
453 |
if (!$this->verifierAuteur($nom['auteur'])) {
|
| - |
|
454 |
$intitule_traite = $this->repererEspace($nom['auteur']);
|
| - |
|
455 |
$noms_erreur[] = array($nom['num_nom'], $intitule_traite);
|
| - |
|
456 |
}
|
| - |
|
457 |
}
|
| - |
|
458 |
}
|
| - |
|
459 |
|
| - |
|
460 |
// Analyse des résultats
|
| - |
|
461 |
if (count($noms_erreur) > 0) {
|
| - |
|
462 |
$info['message']['entete'] = array('num_nom', 'auteur erroné');
|
| - |
|
463 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
464 |
} else {
|
| - |
|
465 |
$info['resultat'] = true;
|
| - |
|
466 |
}
|
| - |
|
467 |
|
| - |
|
468 |
return $info;
|
| - |
|
469 |
}
|
| - |
|
470 |
|
| - |
|
471 |
private function testerNomCommercialSyntaxe($noms) {
|
| - |
|
472 |
$info = array('titre' => 'nom_commercial -> syntaxe',
|
| - |
|
473 |
'description' => "Le champ nom_commercial doit contenir un nom commercial conforme aux règles du ".
|
| - |
|
474 |
"Code Internationnal de Nomenclature des Plantes Cultivées (CINPC) ".
|
| - |
|
475 |
"qui se compose de caractères majuscules (A-Z) incluant des signes diacritiques et des espaces.\n",
|
| - |
|
476 |
'resultat' => false);
|
| - |
|
477 |
|
| - |
|
478 |
// Réalisation du test
|
| - |
|
479 |
$noms_erreur = array();
|
| - |
|
480 |
foreach ($noms as $nom) {
|
| - |
|
481 |
if ($nom['nom_commercial'] != '') {
|
| - |
|
482 |
if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
|
| - |
|
483 |
$epithete_traite = $this->repererEspace($nom['nom_commercial']);
|
| - |
|
484 |
$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
|
| - |
|
485 |
}
|
| - |
|
486 |
}
|
| - |
|
487 |
}
|
| - |
|
488 |
|
| - |
|
489 |
// Analyse des résultats
|
| - |
|
490 |
if (count($noms_erreur) > 0) {
|
| - |
|
491 |
$info['message']['entete'] = array('num_nom', 'cultivar erroné');
|
| - |
|
492 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
493 |
} else {
|
| - |
|
494 |
$info['resultat'] = true;
|
| - |
|
495 |
}
|
| - |
|
496 |
|
| - |
|
497 |
return $info;
|
| - |
|
498 |
}
|
| - |
|
499 |
|
| - |
|
500 |
private function testerNomCommercialPresenceCultivar($noms) {
|
| - |
|
501 |
$info = array('titre' => 'nom_commercial -> groupe_cultivar OU cultivar non vide',
|
| - |
|
502 |
'description' => "Si le champ nom_commercial contier un nom commercial alors le champ cultivar OU ".
|
| - |
|
503 |
"cultivar_groupe ne doit pas être vide.",
|
| - |
|
504 |
'resultat' => false);
|
| - |
|
505 |
|
| - |
|
506 |
// Réalisation du test
|
| - |
|
507 |
$noms_erreur = array();
|
| - |
|
508 |
foreach ($noms as $nom) {
|
| - |
|
509 |
if ($nom['nom_commercial'] != '' && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
|
| - |
|
510 |
$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet']);
|
| - |
|
511 |
}
|
| - |
|
512 |
}
|
| - |
|
513 |
|
| - |
|
514 |
// Analyse des résultats
|
| - |
|
515 |
if (count($noms_erreur) > 0) {
|
| - |
|
516 |
$info['message']['entete'] = array('num_nom', 'nom_commercial sans cultivar ou cultivar_groupe');
|
| - |
|
517 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
518 |
} else {
|
| - |
|
519 |
$info['resultat'] = true;
|
| - |
|
520 |
}
|
| - |
|
521 |
|
| - |
|
522 |
return $info;
|
| - |
|
523 |
}
|
| - |
|
524 |
|
| - |
|
525 |
private function testerCultivarSyntaxe($noms) {
|
| - |
|
526 |
$info = array('titre' => 'cultivar -> syntaxe',
|
| - |
|
527 |
'description' => "Le champ cultivar_groupe doit contenir :\n".
|
| - |
|
528 |
" - un nom de cultivar conforme aux règles du Code Internationnal de Nomenclature des Plantes ".
|
| - |
|
529 |
"Cultivées (CINPC) qui se compose de caractères alphanumériques (A-Z,a-z et 0-9) incluant ".
|
| - |
|
530 |
"signes diacritiques et marques de ponctuations.\n".
|
| - |
|
531 |
" - un nom en alphabet latin ce qui implique une translittération des noms d'alphabet cyrillique, ".
|
| - |
|
532 |
"arabe, chinois...\n".
|
| - |
|
533 |
" - une lettre majuscule obligatoire pour le premier caractère du premier mot et pour les autres mots ".
|
| - |
|
534 |
"importants mais pas pour les mots mineurs.\n".
|
| - |
|
535 |
"Ne doit pas contenir :\n".
|
| - |
|
536 |
" - cv., convar. ou de guillemets simples (').\n",
|
| - |
|
537 |
'resultat' => false);
|
| - |
|
538 |
|
| - |
|
539 |
// Réalisation du test
|
| - |
|
540 |
$noms_erreur = array();
|
| - |
|
541 |
foreach ($noms as $nom) {
|
| - |
|
542 |
if ($nom['cultivar'] != '') {
|
| - |
|
543 |
if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
|
| - |
|
544 |
$epithete_traite = $this->repererEspace($nom['cultivar']);
|
| - |
|
545 |
$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
|
| - |
|
546 |
}
|
| - |
|
547 |
}
|
| - |
|
548 |
}
|
| - |
|
549 |
|
| - |
|
550 |
// Analyse des résultats
|
| - |
|
551 |
if (count($noms_erreur) > 0) {
|
| - |
|
552 |
$info['message']['entete'] = array('num_nom', 'cultivar erroné');
|
| - |
|
553 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
554 |
} else {
|
| - |
|
555 |
$info['resultat'] = true;
|
| - |
|
556 |
}
|
| - |
|
557 |
|
| - |
|
558 |
return $info;
|
| - |
|
559 |
}
|
| - |
|
560 |
|
| - |
|
561 |
private function testerCultivarRang($noms) {
|
| - |
|
562 |
$info = array('titre' => "cultivar -> rang >= {$this->manuel['rang_genre']}",
|
| - |
|
563 |
'description' => "Si le champ cultivar n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.",
|
| - |
|
564 |
'resultat' => false);
|
| - |
|
565 |
|
| - |
|
566 |
// Réalisation du test
|
| - |
|
567 |
$noms_erreur = array();
|
| - |
|
568 |
foreach ($noms as $nom) {
|
| - |
|
569 |
if ($nom['cultivar'] != '') {
|
| - |
|
570 |
if ($nom['rang'] < $this->manuel['rang_genre']) {
|
| - |
|
571 |
$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
|
| - |
|
572 |
}
|
| - |
|
573 |
}
|
| - |
|
574 |
}
|
| - |
|
575 |
|
| - |
|
576 |
// Analyse des résultats
|
| - |
|
577 |
if (count($noms_erreur) > 0) {
|
| - |
|
578 |
$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
|
| - |
|
579 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
580 |
} else {
|
| - |
|
581 |
$info['resultat'] = true;
|
| - |
|
582 |
}
|
| - |
|
583 |
|
| 109 |
//+--------------------------------------------------------------------------------------------------------------+//
|
584 |
return $info;
|
| 110 |
// TESTS
|
585 |
}
|
| 111 |
|
586 |
|
| 112 |
private function testerGroupeCultivarSyntaxe($noms) {
|
587 |
private function testerGroupeCultivarSyntaxe($noms) {
|
| 113 |
$info = array('titre' => 'groupe_cultivar -> syntaxe',
|
588 |
$info = array('titre' => 'cultivar_groupe -> syntaxe',
|
| 114 |
'description' => "Le champ groupe_cultivar doit contenir un nom de groupe de cultivar conforme aux règles ".
|
589 |
'description' => "Le champ cultivar_groupe doit contenir un nom de groupe de cultivar conforme aux règles ".
|
| 115 |
"du code des plantes cultivées qui se compose de caractères alphanumériques (A-Z,a-z et 0-9) incluant ".
|
590 |
"du code des plantes cultivées qui se compose de caractères alphanumériques (A-Z,a-z et 0-9) incluant ".
|
| 116 |
"signes diacritiques et marques de ponctuations.\n".
|
591 |
"signes diacritiques et marques de ponctuations.\n".
|
| Line 117... |
Line 592... |
| 117 |
"Il ne doit pas contenir le mot Groupe, l'abbréviation «gp» ou des parenthèses.\n".
|
592 |
"Il ne doit pas contenir le mot Groupe, l'abbréviation «gp» ou des parenthèses.\n".
|
| 118 |
"Il peut contir à la fin l'abréviation «gx» pour distinguer les groupes des grex.",
|
593 |
"Il peut contir à la fin l'abréviation «gx» pour distinguer les groupes des grex.",
|
| 119 |
'resultat' => false);
|
594 |
'resultat' => false);
|
| 120 |
|
595 |
|
| 121 |
// Réalisation du test
|
- |
|
| 122 |
$noms_erreur = array();
|
- |
|
| 123 |
foreach ($noms as $nom) {
|
596 |
// Réalisation du test
|
| 124 |
if ($nom['groupe_cultivar'] != '') {
|
597 |
$noms_erreur = array();
|
| 125 |
$mots = explode(' ', $nom['groupe_cultivar']);
|
598 |
foreach ($noms as $nom) {
|
| 126 |
foreach ($mots as $mot) {
|
- |
|
| 127 |
if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpithteSp($mot))) {
|
599 |
if ($nom['cultivar_groupe'] != '') {
|
| 128 |
$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
|
600 |
if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
|
| 129 |
$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
|
601 |
$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
|
| Line 130... |
Line 602... |
| 130 |
}
|
602 |
$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
|
| 131 |
}
|
603 |
}
|
| 132 |
}
|
604 |
}
|
| - |
|
605 |
}
|
| - |
|
606 |
|
| - |
|
607 |
// Analyse des résultats
|
| - |
|
608 |
if (count($noms_erreur) > 0) {
|
| - |
|
609 |
$info['message']['entete'] = array('num_nom', 'cultivar_groupe erroné');
|
| - |
|
610 |
$info['message']['lignes'] = $noms_erreur;
|
| - |
|
611 |
} else {
|
| - |
|
612 |
$info['resultat'] = true;
|
| - |
|
613 |
}
|
| - |
|
614 |
|
| - |
|
615 |
return $info;
|
| - |
|
616 |
}
|
| - |
|
617 |
|
| - |
|
618 |
private function testerGroupeCultivarRang($noms) {
|
| - |
|
619 |
$info = array('titre' => "cultivar_groupe -> rang >= {$this->manuel['rang_genre']}",
|
| - |
|
620 |
'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']}.",
|
| - |
|
621 |
'resultat' => false);
|
| - |
|
622 |
|
| - |
|
623 |
// Réalisation du test
|
| - |
|
624 |
$noms_erreur = array();
|
| - |
|
625 |
foreach ($noms as $nom) {
|
| - |
|
626 |
if ($nom['cultivar_groupe'] != '') {
|
| - |
|
627 |
if ($nom['rang'] < $this->manuel['rang_genre']) {
|
| - |
|
628 |
$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
|
| - |
|
629 |
}
|
| - |
|
630 |
}
|
| 133 |
}
|
631 |
}
|
| 134 |
|
632 |
|
| 135 |
// Analyse des résultats
|
633 |
// Analyse des résultats
|
| 136 |
if (count($noms_erreur) > 0) {
|
634 |
if (count($noms_erreur) > 0) {
|
| Line 185... |
Line 683... |
| 185 |
$noms_erreur = array();
|
683 |
$noms_erreur = array();
|
| 186 |
foreach ($noms as $nom) {
|
684 |
foreach ($noms as $nom) {
|
| 187 |
if ($nom['epithete_infra_sp'] != '') {
|
685 |
if ($nom['epithete_infra_sp'] != '') {
|
| 188 |
$mots = explode(' ', $nom['epithete_infra_sp']);
|
686 |
$mots = explode(' ', $nom['epithete_infra_sp']);
|
| 189 |
foreach ($mots as $mot) {
|
687 |
foreach ($mots as $mot) {
|
| 190 |
if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpithteSp($mot))) {
|
688 |
if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpitheteSp($mot))) {
|
| 191 |
$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
|
689 |
$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
|
| 192 |
$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
|
690 |
$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
|
| 193 |
}
|
691 |
}
|
| 194 |
}
|
692 |
}
|
| 195 |
}
|
693 |
}
|
| Line 267... |
Line 765... |
| 267 |
|
765 |
|
| 268 |
// Réalisation du test
|
766 |
// Réalisation du test
|
| 269 |
$noms_erreur = array();
|
767 |
$noms_erreur = array();
|
| 270 |
foreach ($noms as $nom) {
|
768 |
foreach ($noms as $nom) {
|
| 271 |
if ($nom['type_epithete'] != '') {
|
769 |
if ($nom['type_epithete'] != '') {
|
| 272 |
if (!preg_match('/^[a-z][-a-z]*[.]?$/', $nom['type_epithete'])) {
|
770 |
if (!$this->verifierTypeEpithete($nom['type_epithete'])) {
|
| 273 |
$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete']);
|
771 |
$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete']);
|
| 274 |
}
|
772 |
}
|
| 275 |
}
|
773 |
}
|
| Line 946... |
Line 1444... |
| 946 |
$noms_erreur = array();
|
1444 |
$noms_erreur = array();
|
| 947 |
foreach ($noms as $nom) {
|
1445 |
foreach ($noms as $nom) {
|
| 948 |
if ($nom['genre'] != '') {
|
1446 |
if ($nom['genre'] != '') {
|
| 949 |
$mots = explode(' ', $nom['genre']);
|
1447 |
$mots = explode(' ', $nom['genre']);
|
| 950 |
foreach ($mots as $mot) {
|
1448 |
foreach ($mots as $mot) {
|
| 951 |
if (!(preg_match('/^[+x]$/', $mot) || preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $mot))) {
|
1449 |
if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) {
|
| 952 |
$nom_traite = $this->repererEspace($nom['genre']);
|
1450 |
$nom_traite = $this->repererEspace($nom['genre']);
|
| 953 |
$noms_erreur[] = array($nom['num_nom'], $nom_traite);
|
1451 |
$noms_erreur[] = array($nom['num_nom'], $nom_traite);
|
| 954 |
}
|
1452 |
}
|
| 955 |
}
|
1453 |
}
|
| 956 |
}
|
1454 |
}
|
| Line 1104... |
Line 1602... |
| 1104 |
}
|
1602 |
}
|
| Line 1105... |
Line 1603... |
| 1105 |
|
1603 |
|
| 1106 |
private function testerEpitheteSpSyntaxe($noms) {
|
1604 |
private function testerEpitheteSpSyntaxe($noms) {
|
| 1107 |
$info = array('titre' => 'epithete_sp -> syntaxe',
|
1605 |
$info = array('titre' => 'epithete_sp -> syntaxe',
|
| 1108 |
'description' => "Le champ epithete_sp peut contenir :\n".
|
1606 |
'description' => "Le champ epithete_sp peut contenir :\n".
|
| 1109 |
" - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
|
1607 |
" - un mot unique composé de lettres minuscules [a-z] incluant les caractères [ëï-]. \n".
|
| 1110 |
" Il commence par une lettre minuscule (avec ou sans tréma).\n".
|
1608 |
" Il commence par une lettre minuscule [a-zëï].\n".
|
| 1111 |
" Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n".
|
1609 |
" Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n".
|
| 1112 |
" - 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".
|
1610 |
" - 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".
|
| 1113 |
" - une formule d'hybridité composée d'une série de noms d'espèce (au moins 2) séparés entre eux \n".
|
1611 |
" - une formule d'hybridité composée d'une série de noms d'espèce (au moins 2) séparés entre eux \n".
|
| 1114 |
" par la lettre x entourée de caractères espaces.",
|
1612 |
" par la lettre x entourée de caractères espaces.",
|
| Line 1118... |
Line 1616... |
| 1118 |
$noms_erreur = array();
|
1616 |
$noms_erreur = array();
|
| 1119 |
foreach ($noms as $nom) {
|
1617 |
foreach ($noms as $nom) {
|
| 1120 |
if ($nom['epithete_sp'] != '') {
|
1618 |
if ($nom['epithete_sp'] != '') {
|
| 1121 |
$mots = explode(' ', $nom['epithete_sp']);
|
1619 |
$mots = explode(' ', $nom['epithete_sp']);
|
| 1122 |
foreach ($mots as $mot) {
|
1620 |
foreach ($mots as $mot) {
|
| 1123 |
if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpithteSp($mot))) {
|
1621 |
if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot))) {
|
| 1124 |
$epithete_traite = $this->repererEspace($nom['epithete_sp']);
|
1622 |
$epithete_traite = $this->repererEspace($nom['epithete_sp']);
|
| 1125 |
$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
|
1623 |
$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
|
| 1126 |
}
|
1624 |
}
|
| 1127 |
}
|
1625 |
}
|
| 1128 |
}
|
1626 |
}
|
| Line 1166... |
Line 1664... |
| 1166 |
}
|
1664 |
}
|
| Line 1167... |
Line 1665... |
| 1167 |
|
1665 |
|
| 1168 |
//+--------------------------------------------------------------------------------------------------------------+//
|
1666 |
//+--------------------------------------------------------------------------------------------------------------+//
|
| Line -... |
Line 1667... |
| - |
|
1667 |
// MÉTHODES COMMUNES aux TESTS
|
| - |
|
1668 |
|
| - |
|
1669 |
private function verifierBooleen($valeur) {
|
| - |
|
1670 |
$ok = true;
|
| - |
|
1671 |
if (!preg_match('/^1$/', $valeur)) {
|
| - |
|
1672 |
$ok = false;
|
| - |
|
1673 |
}
|
| - |
|
1674 |
return $ok;
|
| - |
|
1675 |
}
|
| - |
|
1676 |
|
| - |
|
1677 |
private function verifierNombre($valeur) {
|
| - |
|
1678 |
$ok = true;
|
| - |
|
1679 |
if (!preg_match('/^[0-9]+$/', $valeur)) {
|
| - |
|
1680 |
$ok = false;
|
| - |
|
1681 |
}
|
| - |
|
1682 |
return $ok;
|
| - |
|
1683 |
}
|
| - |
|
1684 |
|
| - |
|
1685 |
private function verifierNombreSuite($valeur) {
|
| - |
|
1686 |
$ok = true;
|
| - |
|
1687 |
if (!preg_match('/^(?:[0-9]+,)*[0-9]+$/', $valeur)) {
|
| - |
|
1688 |
$ok = false;
|
| - |
|
1689 |
}
|
| - |
|
1690 |
return $ok;
|
| 1169 |
// MÉTHODES COMMUNES aux TESTS
|
1691 |
}
|
| - |
|
1692 |
|
| - |
|
1693 |
private function verifierTypeEpithete($type) {
|
| - |
|
1694 |
$ok = false;
|
| - |
|
1695 |
$rejetes = $this->manuel['type_epithete_rejetes'];
|
| - |
|
1696 |
if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
|
| - |
|
1697 |
$ok = false;
|
| - |
|
1698 |
} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
|
| - |
|
1699 |
$ok = true;
|
| - |
|
1700 |
}
|
| - |
|
1701 |
return $ok;
|
| - |
|
1702 |
}
|
| 1170 |
|
1703 |
|
| 1171 |
private function verifierTypeEpithete($type) {
|
1704 |
private function verifierBiblioOrigine($intitule) {
|
| - |
|
1705 |
$ok = true;
|
| - |
|
1706 |
if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
|
| 1172 |
$ok = true;
|
1707 |
$ok = false;// Contient des espaces en trop
|
| - |
|
1708 |
} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
|
| - |
|
1709 |
$ok = false;
|
| 1173 |
if (!preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
|
1710 |
} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
|
| 1174 |
$ok = false;
|
1711 |
$ok = false;// Contient une mauvaise suite de caractères
|
| 1175 |
}
|
1712 |
}
|
| Line -... |
Line 1713... |
| - |
|
1713 |
return $ok;
|
| - |
|
1714 |
}
|
| - |
|
1715 |
|
| - |
|
1716 |
private function verifierAnnee($annee) {
|
| - |
|
1717 |
$ok = true;
|
| - |
|
1718 |
if (!preg_match('/^[0-9]{4}$/', $annee)) {
|
| - |
|
1719 |
$ok = false;
|
| - |
|
1720 |
} else if ($annee < 1753) {
|
| - |
|
1721 |
$ok = false;
|
| - |
|
1722 |
}
|
| - |
|
1723 |
return $ok;
|
| - |
|
1724 |
}
|
| - |
|
1725 |
|
| - |
|
1726 |
private function verifierAuteur($intitule) {
|
| - |
|
1727 |
$ok = true;
|
| - |
|
1728 |
$acceptes = $this->manuel['auteur_acceptes'];
|
| - |
|
1729 |
if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
|
| - |
|
1730 |
if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
|
| - |
|
1731 |
$ok = false;// Contient des espaces en trop
|
| - |
|
1732 |
} else {
|
| - |
|
1733 |
$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
|
| - |
|
1734 |
$mots = explode(' ', $intitule);
|
| - |
|
1735 |
foreach ($mots as $position => $mot) {
|
| - |
|
1736 |
if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
|
| - |
|
1737 |
$ok = false;// Mot rejeté
|
| - |
|
1738 |
} else if (preg_match("/^(?:(?:\p{L}|[.'\(\)-])+|[&])$/u", $mot)) {
|
| - |
|
1739 |
continue;// Mot de l'intitulé auteur
|
| - |
|
1740 |
} else {
|
| - |
|
1741 |
$ok = false;
|
| - |
|
1742 |
}
|
| - |
|
1743 |
}
|
| - |
|
1744 |
}
|
| - |
|
1745 |
}
|
| 1176 |
return $ok;
|
1746 |
return $ok;
|
| 1177 |
}
|
1747 |
}
|
| - |
|
1748 |
|
| - |
|
1749 |
private function verifierNomCommercial($epithete) {
|
| - |
|
1750 |
$ok = false;
|
| - |
|
1751 |
if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
|
| - |
|
1752 |
$ok = true;
|
| - |
|
1753 |
}
|
| - |
|
1754 |
return $ok;
|
| - |
|
1755 |
}
|
| - |
|
1756 |
|
| - |
|
1757 |
private function verifierEpitheteCultivar($epithete) {
|
| - |
|
1758 |
$ok = true;
|
| - |
|
1759 |
$acceptes = $this->manuel['cultivar_acceptes'];
|
| - |
|
1760 |
if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
|
| - |
|
1761 |
if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
|
| - |
|
1762 |
$ok = false;// Contient des espaces en trop
|
| - |
|
1763 |
} else {
|
| - |
|
1764 |
$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
|
| - |
|
1765 |
$mots_mineurs = $this->manuel['mots_mineurs'];
|
| - |
|
1766 |
$mots = explode(' ', $epithete);
|
| - |
|
1767 |
foreach ($mots as $position => $mot) {
|
| - |
|
1768 |
if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
|
| - |
|
1769 |
$ok = false;// Mot rejeté
|
| - |
|
1770 |
} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
|
| - |
|
1771 |
continue;// Mot mineur en minuscule qui n'est pas en 1ère position
|
| - |
|
1772 |
} else {
|
| - |
|
1773 |
$mots_tiret = explode('-', $mot);
|
| - |
|
1774 |
foreach ($mots_tiret as $position_tiret => $mot_tiret) {
|
| - |
|
1775 |
if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
|
| - |
|
1776 |
continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
|
| - |
|
1777 |
} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
|
| - |
|
1778 |
continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
|
| - |
|
1779 |
} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
|
| - |
|
1780 |
continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
|
| - |
|
1781 |
} else {
|
| - |
|
1782 |
$ok = false;
|
| - |
|
1783 |
}
|
| - |
|
1784 |
}
|
| - |
|
1785 |
}
|
| - |
|
1786 |
}
|
| - |
|
1787 |
}
|
| - |
|
1788 |
}
|
| - |
|
1789 |
return $ok;
|
| - |
|
1790 |
}
|
| - |
|
1791 |
|
| - |
|
1792 |
private function verifierEpitheteGroupeCultivar($epithete) {
|
| - |
|
1793 |
$ok = true;
|
| - |
|
1794 |
$acceptes = $this->manuel['cultivar_gp_acceptes'];
|
| - |
|
1795 |
if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
|
| - |
|
1796 |
if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
|
| - |
|
1797 |
$ok = false;// Contient des espaces en trop
|
| - |
|
1798 |
} else {
|
| - |
|
1799 |
$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
|
| - |
|
1800 |
$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
|
| - |
|
1801 |
$mots_mineurs = $this->manuel['mots_mineurs'];
|
| - |
|
1802 |
$mots = explode(' ', $epithete);
|
| - |
|
1803 |
foreach ($mots as $position => $mot) {
|
| - |
|
1804 |
if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
|
| - |
|
1805 |
continue;// Mot accepté
|
| - |
|
1806 |
} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
|
| - |
|
1807 |
$ok = false;// Mot rejeté
|
| - |
|
1808 |
} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
|
| - |
|
1809 |
continue;// Mot mineur en minuscule qui n'est pas en 1ère position
|
| - |
|
1810 |
} else {
|
| - |
|
1811 |
$mots_tiret = explode('-', $mot);
|
| - |
|
1812 |
foreach ($mots_tiret as $position_tiret => $mot_tiret) {
|
| - |
|
1813 |
if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
|
| - |
|
1814 |
continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
|
| - |
|
1815 |
} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
|
| - |
|
1816 |
continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
|
| - |
|
1817 |
} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
|
| - |
|
1818 |
continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
|
| - |
|
1819 |
} else {
|
| - |
|
1820 |
$ok = false;
|
| - |
|
1821 |
}
|
| - |
|
1822 |
}
|
| - |
|
1823 |
}
|
| - |
|
1824 |
}
|
| - |
|
1825 |
}
|
| - |
|
1826 |
}
|
| - |
|
1827 |
return $ok;
|
| - |
|
1828 |
}
|
| 1178 |
|
1829 |
|
| 1179 |
private function verifierEpithteSp($epithete) {
|
1830 |
private function verifierEpitheteSp($epithete) {
|
| 1180 |
$ok = false;
|
1831 |
$ok = false;
|
| 1181 |
if (preg_match('/^[a-zäëḧïöẗüẅẍÿ][-a-zäëḧïöẗüẅẍÿ]+$/', $epithete)) {
|
1832 |
if (preg_match('/^[a-zëï][-a-zëï]+$/', $epithete)) {
|
| 1182 |
$ok = true;
|
1833 |
$ok = true;
|
| 1183 |
} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
|
1834 |
} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
|
| 1184 |
$ok = true;
|
1835 |
$ok = true;
|
| Line -... |
Line 1836... |
| - |
|
1836 |
}
|
| - |
|
1837 |
return $ok;
|
| - |
|
1838 |
}
|
| - |
|
1839 |
|
| - |
|
1840 |
private function verifierEpitheteGenre($epithete) {
|
| - |
|
1841 |
$ok = false;
|
| - |
|
1842 |
if (preg_match('/^[A-ZËÏ](?:[-a-zëï]+|[a-zëï]+-[A-ZËÏ][a-zëï]+)$/', $epithete)) {
|
| - |
|
1843 |
$ok = true;
|
| 1185 |
}
|
1844 |
}
|
| 1186 |
return $ok;
|
1845 |
return $ok;
|
| 1187 |
}
|
1846 |
}
|
| 1188 |
|
1847 |
|
| 1189 |
private function formaterStyleNomGenre($genre) {
|
1848 |
private function formaterStyleNomGenre($genre) {
|
| Line 1236... |
Line 1895... |
| 1236 |
$nom_cultivar = "'".$nom['cultivar']."'";
|
1895 |
$nom_cultivar = "'".$nom['cultivar']."'";
|
| 1237 |
}
|
1896 |
}
|
| 1238 |
return $nom_cultivar;
|
1897 |
return $nom_cultivar;
|
| 1239 |
}
|
1898 |
}
|
| Line 1240... |
Line 1899... |
| 1240 |
|
1899 |
|
| 1241 |
private function classerNoms($noms) {
|
1900 |
private function classerNomsParNumNom($noms) {
|
| 1242 |
$noms_classes = array();
|
1901 |
$noms_classes = array();
|
| 1243 |
foreach ($noms as $nom) {
|
1902 |
foreach ($noms as $nom) {
|
| 1244 |
$noms_classes[$nom['num_nom']] = $nom;
|
1903 |
$noms_classes[$nom['num_nom']] = $nom;
|
| 1245 |
}
|
1904 |
}
|
| 1246 |
return $noms_classes;
|
1905 |
return $noms_classes;
|
| - |
|
1906 |
}
|
| - |
|
1907 |
|
| - |
|
1908 |
private function classerNomsParNomComplet($noms) {
|
| - |
|
1909 |
$noms_classes = array();
|
| - |
|
1910 |
foreach ($noms as $nom) {
|
| - |
|
1911 |
if (!isset($noms_classes[$nom['nom_complet']])) {
|
| - |
|
1912 |
$noms_classes[$nom['nom_complet']] = 1;
|
| - |
|
1913 |
} else {
|
| - |
|
1914 |
$noms_classes[$nom['nom_complet']]++;
|
| - |
|
1915 |
}
|
| - |
|
1916 |
}
|
| - |
|
1917 |
return $noms_classes;
|
| 1247 |
}
|
1918 |
}
|
| 1248 |
}
|
1919 |
}
|
| 1249 |
?>
|
1920 |
?>
|